init

enriched-qwen3-coder-next/Common/DTS.CommonCore/Events/GroupTemplates/CustomChannels.md

@@ -0,0 +1,59 @@
+---
+source_files:
+  - Common/DTS.CommonCore/Events/GroupTemplates/CustomChannels/CustomChannelExportFileSetEvent.cs
+  - Common/DTS.CommonCore/Events/GroupTemplates/CustomChannels/CustomChannelImportEvent.cs
+generated_at: "2026-04-16T02:49:05.802703+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "46fed4b1ba64a18a"
+---
+
+# CustomChannels
+
+## Documentation: Custom Channel Events Module
+
+### 1. Purpose  
+This module defines Prism-based events used to coordinate custom channel import and export operations within the application’s Group Templates feature. Specifically, it provides a mechanism to signal when a custom channel export file set is ready (triggering UI busy state) and to report the completion status of a custom channel import operation. These events facilitate decoupled communication between components involved in custom channel lifecycle management.
+
+### 2. Public Interface  
+
+- **`CustomChannelExportFileSetEvent`**  
+  - *Type*: `class`  
+  - *Inherits*: `CompositePresentationEvent<string>`  
+  - *Behavior*: A Prism event used to notify subscribers that a custom channel export file set has been generated. The payload is a `string`, which (based on naming and typical usage) is expected to represent the file path or identifier of the exported file set. Subscribers should interpret this string as the location or reference to the exported data.  
+
+- **`CustomChannelImportEvent`**  
+  - *Type*: `class`  
+  - *Inherits*: `CompositePresentationEvent<CustomChannelImportEventArgs>`  
+  - *Behavior*: A Prism event used to signal the completion status of a custom channel import operation.  
+
+- **`CustomChannelImportEventArgs`**  
+  - *Type*: `class`  
+  - *Properties*:  
+    - `ImportStatus`: `Status` — read-only; indicates the outcome of the import operation.  
+  - *Constructors*:  
+    - `CustomChannelImportEventArgs(Status status)` — initializes the event args with the given import status.  
+  - *Nested Type*:  
+    - `Status` — `enum` with a single member:  
+      - `Done` — indicates the import operation has completed.  
+
+### 3. Invariants  
+- `CustomChannelExportFileSetEvent` payloads are non-null `string` values representing an exported file set reference (e.g., a file path). Null payloads are not explicitly guarded against in the event definition, but their presence would likely cause downstream failures.  
+- `CustomChannelImportEventArgs` instances must be constructed with a valid `Status` value; currently, only `Status.Done` is defined, implying that *only successful import completions are reported*. No error or cancellation states are modeled in the current implementation.  
+- Events are published via Prism’s `EventAggregator`, so subscribers must be registered and unregistered appropriately to avoid memory leaks or missed notifications.  
+
+### 4. Dependencies  
+- **Depends on**:  
+  - `Microsoft.Practices.Prism.Events` (Prism library for event aggregation)  
+  - `DTS.CommonCore` (namespace context for shared core types)  
+- **Used by**:  
+  - Components responsible for custom channel export (publishing `CustomChannelExportFileSetEvent`)  
+  - Components responsible for custom channel import (publishing `CustomChannelImportEvent`)  
+  - UI or service layers that react to these events (e.g., to toggle busy states or update import history)  
+
+### 5. Gotchas  
+- The `CustomChannelExportFileSetEvent` inherits `CompositePresentationEvent<string>`, but the documentation comment does not clarify the *meaning* of the `string` payload (e.g., is it a file path, a GUID, or serialized metadata?). This ambiguity may lead to inconsistent interpretation by subscribers.  
+- `CustomChannelImportEventArgs.Status` currently only supports `Done`. If import failures or partial successes occur, they are *not* reported via this event, potentially masking errors or leaving subscribers unaware of non-success outcomes.  
+- The `CustomChannelImportEvent` and `CustomChannelExportFileSetEvent` share the same namespace (`DTS.Common.Events.GroupTemplates.CustomChannels`), suggesting they are part of a related workflow, but no explicit ordering or dependency between them is enforced (e.g., export must precede import).  
+- No validation is performed on the `string` payload of `CustomChannelExportFileSetEvent`; subscribers must assume responsibility for path existence, format, or permissions.  
+- None identified from source alone.

enriched-qwen3-coder-next/Common/DTS.CommonCore/Events/GroupTemplates/GroupTemplateList.md

@@ -0,0 +1,45 @@
+---
+source_files:
+  - Common/DTS.CommonCore/Events/GroupTemplates/GroupTemplateList/GroupTemplateListGroupDoubleClickEvent.cs
+  - Common/DTS.CommonCore/Events/GroupTemplates/GroupTemplateList/GroupTemplateListGroupTemplateSelectedEvent.cs
+generated_at: "2026-04-16T02:49:23.076829+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "20dafea03a43d30f"
+---
+
+# GroupTemplateList
+
+## 1. Purpose  
+This module defines two Prism-based events used for inter-module communication in the DTS application related to group template management in the UI. Specifically, `GroupTemplateListGroupDoubleClickEvent` signals when a user double-clicks on a group template (carrying the template’s identifier as a `string`), while `GroupTemplateListGroupTemplateSelectedEvent` signals when one or more group templates are selected (carrying an array of template identifiers as `string[]`). These events decouple UI components (e.g., a list view and a detail panel or command handler) by enabling event-driven responses to user interactions.
+
+## 2. Public Interface  
+- **`GroupTemplateListGroupDoubleClickEvent`**  
+  - *Signature*: `public class GroupTemplateListGroupDoubleClickEvent : CompositePresentationEvent<string>`  
+  - *Behavior*: A Prism `CompositePresentationEvent` that publishes a single `string` payload—the identifier of the group template that was double-clicked. Intended for use when a double-click action should trigger an immediate operation (e.g., opening the template for editing or preview).  
+
+- **`GroupTemplateListGroupTemplateSelectedEvent`**  
+  - *Signature*: `public class GroupTemplateListGroupTemplateSelectedEvent : CompositePresentationEvent<string[]>`  
+  - *Behavior*: A Prism `CompositePresentationEvent` that publishes a `string[]` payload—identifiers of the group templates currently selected in the UI (e.g., via checkbox or multi-select). Intended for scenarios where selection state changes (e.g., enabling/disabling toolbar buttons or updating a summary view).  
+
+## 3. Invariants  
+- The payload for `GroupTemplateListGroupDoubleClickEvent` is always a non-null `string` representing exactly one template ID (since double-click implies a single item).  
+- The payload for `GroupTemplateListGroupTemplateSelectedEvent` is always a non-null `string[]`, though the array may be empty (indicating no selection).  
+- Event payloads contain *only* template identifiers (no metadata or full objects); consumers must resolve IDs to template instances via other means (e.g., a service or cache).  
+- No ordering guarantee is specified for the `string[]` in `GroupTemplateListGroupTemplateSelectedEvent`; consumers must not assume the order reflects UI selection order unless documented elsewhere.  
+
+## 4. Dependencies  
+- **Dependencies *of* this module**:  
+  - `Microsoft.Practices.Prism.Events` (Prism library, specifically `CompositePresentationEvent<T>`).  
+  - Implicitly depends on `DTS.Common.Events.GroupTemplates.GroupTemplateList` namespace structure (other event types may exist in this hierarchy, but none are referenced here).  
+- **Dependencies *on* this module**:  
+  - UI components (e.g., a `GroupTemplateList` view) that publish these events.  
+  - Command handlers or view models (e.g., `GroupTemplateListViewModel`) that subscribe to these events to react to user actions.  
+  - No direct dependencies on other *events* in the source—though logically, these events likely coordinate with other group-template-related events (e.g., load/save events), but those are not evident from the provided files.  
+
+## 5. Gotchas  
+- **Naming inconsistency**: The class `GroupTemplateListGroupDoubleClickEvent` is documented as `The GroupTemplateListGroupTemplateSelectedEvent event` in its XML comment—this appears to be a copy-paste error in the comment (the class name itself is correct).  
+- **Ambiguous semantics**: The distinction between *selection* and *double-click* is not clarified in the source. Double-click may or may not trigger a selection event first; consumers should not assume ordering or mutual exclusivity without external documentation.  
+- **No validation on IDs**: Neither event validates or enforces ID format (e.g., GUID vs. numeric). Consumers must handle invalid or missing IDs gracefully.  
+- **Array mutability risk**: Since `string[]` is passed directly, subscribers could inadvertently modify the array. Prism does not clone payloads; consider defensive copying if mutation is a concern (not enforced here).  
+- **No cancellation support**: These are `CompositePresentationEvent<T>` (not `PubSubEvent<T>`), meaning all subscribers are invoked synchronously and cannot cancel the event. This may cause side effects if one subscriber fails.

enriched-qwen3-coder-next/Common/DTS.CommonCore/Events/GroupTemplates/TemplateChannelList.md

@@ -0,0 +1,66 @@
+---
+source_files:
+  - Common/DTS.CommonCore/Events/GroupTemplates/TemplateChannelList/TemplateChannelListOrderChangedEvent.cs
+  - Common/DTS.CommonCore/Events/GroupTemplates/TemplateChannelList/TemplateChannelListSelectionChangedEvent.cs
+  - Common/DTS.CommonCore/Events/GroupTemplates/TemplateChannelList/TemplateChannelListRequiredChangedEvent.cs
+generated_at: "2026-04-16T02:49:20.561270+00:00"
+model: "Qwen/Qwen3-Coder-Next-FP8"
+schema_version: 1
+sha256: "2352802106c3fc56"
+---
+
+# TemplateChannelList
+
+## Documentation: TemplateChannelList Events Module
+
+### 1. Purpose  
+This module defines Prism-based event types used to communicate changes in the state of a *template channel list*—a UI or logical construct representing ordered, selectable channels associated with a group template. Specifically, it publishes events when the *order* of channels changes, when the *selection* among channels changes, or when the *required status* of the channel list changes (e.g., whether at least one channel must be selected). These events decouple UI components or services that manage or react to channel list state, enabling modular and testable event-driven behavior within the application.
+
+### 2. Public Interface  
+
+- **`TemplateChannelListOrderChangedEvent`**  
+  - **Type**: `class` inheriting from `CompositePresentationEvent<IGroupTemplateChannel>`  
+  - **Behavior**: Published when the *order* of channels in the template channel list has been modified (e.g., via drag-and-drop reordering). The payload is the `IGroupTemplateChannel` instance that was moved (or the channel whose position changed most significantly—implementation detail not specified in source).  
+
+- **`TemplateChannelListSelectionChangedEvent`**  
+  - **Type**: `class` inheriting from `CompositePresentationEvent<IGroupTemplateChannel>`  
+  - **Behavior**: Published when the *selection state* of a channel in the list changes (e.g., a channel is selected or deselected). The payload is the `IGroupTemplateChannel` instance whose selection status changed.  
+
+- **`TemplateChannelListRequiredChangedEvent`**  
+  - **Type**: `class` inheriting from `CompositePresentationEvent<TemplateChannelListRequiredChangeEventArgs>`  
+  - **Behavior**: Published when the *required status* of the channel list changes (e.g., the list transitions from optional to mandatory, or vice versa). The payload is a `TemplateChannelListRequiredChangeEventArgs` object containing:  
+    - `Consumer`: The object (e.g., UI control, service) triggering or affected by the change.  
+    - `Channels`: An array of `IGroupTemplateChannel` instances currently in the list.  
+
+- **`TemplateChannelListRequiredChangeEventArgs`**  
+  - **Type**: `class`  
+  - **Properties**:  
+    - `public object Consumer { get; }` — The entity responsible for the change.  
+    - `public IGroupTemplateChannel[] Channels { get; }` — The current set of channels in the list at the time of the event.  
+  - **Constructor**: `TemplateChannelListRequiredChangeEventArgs(object o, IGroupTemplateChannel[] channels)` — Initializes the args with the consumer and channel array.  
+
+### 3. Invariants  
+- All events derive from `CompositePresentationEvent<T>`, meaning they are published/subscribed via Prism’s event aggregation mechanism and are *thread-safe* for cross-thread publishing (subject to Prism’s default behavior).  
+- The payload for `TemplateChannelListOrderChangedEvent` and `TemplateChannelListSelectionChangedEvent` is a *single* `IGroupTemplateChannel` instance, implying events are likely published per-channel changes (not batched).  
+- For `TemplateChannelListRequiredChangedEvent`, the `Channels` array is non-null (as it is assigned directly from constructor parameter), but its *contents* may be empty if no channels exist.  
+- The `Consumer` property in `TemplateChannelListRequiredChangeEventArgs` is typed as `object`, indicating no specific contract is enforced—consumers must cast or inspect as needed.  
+
+### 4. Dependencies  
+
+- **Depends on**:  
+  - `DTS.Common.Interface.GroupTemplate` (specifically `IGroupTemplateChannel` interface)  
+  - `Microsoft.Practices.Prism.Events` (`CompositePresentationEvent<T>`)  
+
+- **Depended on by**:  
+  - Any module or component that manages or reacts to template channel list state (e.g., UI views, view models, or services handling group templates).  
+  - *Inferred*: Components that implement or consume `IGroupTemplateChannel` (e.g., channel list controls, template editors) will likely subscribe to these events.  
+
+### 5. Gotchas  
+
+- **Misleading XML documentation**: All three event classes share the same summary comment: *“The GroupTemplateListGroupTemplateSelectedEvent event.”* and remarks: *“called when a template is selected.”* This is **inaccurate** for `TemplateChannelListOrderChangedEvent` and `TemplateChannelListRequiredChangedEvent`, and partially misleading for `TemplateChannelListSelectionChangedEvent` (which concerns *channel* selection, not *template* selection). This may cause confusion during maintenance.  
+- **Ambiguous semantics**: The source does not clarify whether `TemplateChannelListOrderChangedEvent` publishes the *moved* channel, the *source* channel, or the *entire list*—only that it carries a single `IGroupTemplateChannel`. Similarly, it is unclear whether `TemplateChannelListSelectionChangedEvent` fires on *any* selection change or only on *user-initiated* selection changes.  
+- **No batch support**: Events are single-channel focused; reordering or bulk selection changes may require multiple event publications, potentially impacting performance or consistency if not handled atomically by subscribers.  
+- **`Consumer` type safety**: `TemplateChannelListRequiredChangeEventArgs.Consumer` is `object`, requiring runtime type checks or casting—no compile-time safety.  
+- **No event filtering or cancellation**: As Prism `CompositePresentationEvent<T>` instances, these events do not support payload filtering or cancellation by default (unlike `PubSubEvent<T>` with `ThreadOption.PublisherThread` or custom `SubscriptionToken` handling).  
+
+None identified beyond the above.