eventmodeler 0.3.2 → 0.3.3

package/dist/lib/flow-utils.d.ts

@@ -26,6 +26,7 @@ export interface SliceFlowInfo extends FlowInfo {
         name: string;
     };
 }
+export declare function resolveToCanonical(model: EventModel, id: string): string;
 export declare function getElementInfo(model: EventModel, id: string): ElementInfo | null;
 export declare function getSliceComponentIds(model: EventModel, slice: Slice): Set<string>;
 export declare function findSliceForComponent(model: EventModel, componentId: string): Slice | null;

package/dist/lib/flow-utils.js

@@ -1,3 +1,16 @@
+// Resolve a linked copy to its canonical original, or return the ID unchanged if not a copy
+export function resolveToCanonical(model, id) {
+    const screen = model.screens.get(id);
+    if (screen?.originalNodeId)
+        return screen.originalNodeId;
+    const event = model.events.get(id);
+    if (event?.originalNodeId)
+        return event.originalNodeId;
+    const readModel = model.readModels.get(id);
+    if (readModel?.originalNodeId)
+        return readModel.originalNodeId;
+    return id;
+}
 // Get element info (name and type) by ID
 export function getElementInfo(model, id) {
     const screen = model.screens.get(id);
@@ -61,16 +74,13 @@ function isElementInSlice(slice, position, width, height) {
         centerY >= slice.position.y &&
         centerY <= slice.position.y + slice.size.height);
 }
-// Get all component IDs in a slice (including canonical group members for linked copies)
+// Get all component IDs in a slice (excludes linked copies - they are UI-only)
 export function getSliceComponentIds(model, slice) {
     const ids = new Set();
-    const canonicalIds = new Set();
-    // First pass: collect IDs and canonical IDs of elements in the slice
+    // Only include canonical elements (not linked copies) that are spatially in the slice
     for (const screen of model.screens.values()) {
-        if (isElementInSlice(slice, screen.position, screen.width, screen.height)) {
+        if (!screen.originalNodeId && isElementInSlice(slice, screen.position, screen.width, screen.height)) {
             ids.add(screen.id);
-            if (screen.canonicalId)
-                canonicalIds.add(screen.canonicalId);
         }
     }
     for (const command of model.commands.values()) {
@@ -79,17 +89,13 @@ export function getSliceComponentIds(model, slice) {
         }
     }
     for (const event of model.events.values()) {
-        if (isElementInSlice(slice, event.position, event.width, event.height)) {
+        if (!event.originalNodeId && isElementInSlice(slice, event.position, event.width, event.height)) {
             ids.add(event.id);
-            if (event.canonicalId)
-                canonicalIds.add(event.canonicalId);
         }
     }
     for (const readModel of model.readModels.values()) {
-        if (isElementInSlice(slice, readModel.position, readModel.width, readModel.height)) {
+        if (!readModel.originalNodeId && isElementInSlice(slice, readModel.position, readModel.width, readModel.height)) {
             ids.add(readModel.id);
-            if (readModel.canonicalId)
-                canonicalIds.add(readModel.canonicalId);
         }
     }
     for (const processor of model.processors.values()) {
@@ -97,25 +103,6 @@ export function getSliceComponentIds(model, slice) {
             ids.add(processor.id);
         }
     }
-    // Second pass: add all elements that share a canonical ID with elements in the slice
-    // This ensures flows targeting any element in a canonical group are detected
-    if (canonicalIds.size > 0) {
-        for (const screen of model.screens.values()) {
-            if (screen.canonicalId && canonicalIds.has(screen.canonicalId)) {
-                ids.add(screen.id);
-            }
-        }
-        for (const event of model.events.values()) {
-            if (event.canonicalId && canonicalIds.has(event.canonicalId)) {
-                ids.add(event.id);
-            }
-        }
-        for (const readModel of model.readModels.values()) {
-            if (readModel.canonicalId && canonicalIds.has(readModel.canonicalId)) {
-                ids.add(readModel.id);
-            }
-        }
-    }
     return ids;
 }
 // Find which slice contains a component
@@ -163,10 +150,13 @@ export function findSliceForComponent(model, componentId) {
     }
     return null;
 }
-// Build FlowInfo from a Flow
+// Build FlowInfo from a Flow (resolves linked copies to their canonical originals)
 function buildFlowInfo(model, flow) {
-    const source = getElementInfo(model, flow.sourceId);
-    const target = getElementInfo(model, flow.targetId);
+    // Resolve linked copies to canonical originals
+    const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+    const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+    const source = getElementInfo(model, canonicalSourceId);
+    const target = getElementInfo(model, canonicalTargetId);
     if (!source || !target)
         return null;
     return {
@@ -177,13 +167,16 @@ function buildFlowInfo(model, flow) {
         fieldMappings: enrichFieldMappings(model, flow),
     };
 }
-// Build SliceFlowInfo from a Flow (includes slice info for source/target)
+// Build SliceFlowInfo from a Flow (includes slice info for source/target, resolves linked copies)
 function buildSliceFlowInfo(model, flow) {
     const base = buildFlowInfo(model, flow);
     if (!base)
         return null;
-    const sourceSlice = findSliceForComponent(model, flow.sourceId);
-    const targetSlice = findSliceForComponent(model, flow.targetId);
+    // Resolve linked copies to canonical originals for slice lookup
+    const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+    const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+    const sourceSlice = findSliceForComponent(model, canonicalSourceId);
+    const targetSlice = findSliceForComponent(model, canonicalTargetId);
     return {
         ...base,
         sourceSlice: sourceSlice ? { id: sourceSlice.id, name: sourceSlice.name } : undefined,
@@ -195,7 +188,10 @@ export function getInboundFlows(model, slice) {
     const componentIds = getSliceComponentIds(model, slice);
     const flows = [];
     for (const flow of model.flows.values()) {
-        if (componentIds.has(flow.targetId) && !componentIds.has(flow.sourceId)) {
+        // Resolve linked copies to canonical originals for containment check
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+        if (componentIds.has(canonicalTargetId) && !componentIds.has(canonicalSourceId)) {
             const flowInfo = buildSliceFlowInfo(model, flow);
             if (flowInfo)
                 flows.push(flowInfo);
@@ -208,7 +204,10 @@ export function getOutboundFlows(model, slice) {
     const componentIds = getSliceComponentIds(model, slice);
     const flows = [];
     for (const flow of model.flows.values()) {
-        if (componentIds.has(flow.sourceId) && !componentIds.has(flow.targetId)) {
+        // Resolve linked copies to canonical originals for containment check
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+        if (componentIds.has(canonicalSourceId) && !componentIds.has(canonicalTargetId)) {
             const flowInfo = buildSliceFlowInfo(model, flow);
             if (flowInfo)
                 flows.push(flowInfo);
@@ -221,7 +220,10 @@ export function getInternalFlows(model, slice) {
     const componentIds = getSliceComponentIds(model, slice);
     const flows = [];
     for (const flow of model.flows.values()) {
-        if (componentIds.has(flow.sourceId) && componentIds.has(flow.targetId)) {
+        // Resolve linked copies to canonical originals for containment check
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+        if (componentIds.has(canonicalSourceId) && componentIds.has(canonicalTargetId)) {
             const flowInfo = buildFlowInfo(model, flow);
             if (flowInfo)
                 flows.push(flowInfo);
@@ -229,17 +231,22 @@ export function getInternalFlows(model, slice) {
     }
     return flows;
 }
-// Get all flows for a specific element (both directions)
+// Get all flows for a specific element (both directions, resolves linked copies)
 export function getFlowsForElement(model, elementId) {
     const incoming = [];
     const outgoing = [];
+    // Resolve element ID to canonical if it's a linked copy
+    const canonicalElementId = resolveToCanonical(model, elementId);
     for (const flow of model.flows.values()) {
-        if (flow.targetId === elementId) {
+        // Resolve flow endpoints to canonical originals
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        if (canonicalTargetId === canonicalElementId) {
             const flowInfo = buildFlowInfo(model, flow);
             if (flowInfo)
                 incoming.push(flowInfo);
         }
-        if (flow.sourceId === elementId) {
+        if (canonicalSourceId === canonicalElementId) {
             const flowInfo = buildFlowInfo(model, flow);
             if (flowInfo)
                 outgoing.push(flowInfo);
@@ -257,13 +264,16 @@ export function findSliceToSliceFlows(model, slices) {
     // Group flows by slice pair
     const flowsBySlicePair = new Map();
     for (const flow of model.flows.values()) {
+        // Resolve linked copies to canonical originals
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
         let sourceSliceId = null;
         let targetSliceId = null;
         // Find which slice contains source and target
         for (const [sliceId, componentIds] of sliceComponentMap.entries()) {
-            if (componentIds.has(flow.sourceId))
+            if (componentIds.has(canonicalSourceId))
                 sourceSliceId = sliceId;
-            if (componentIds.has(flow.targetId))
+            if (componentIds.has(canonicalTargetId))
                 targetSliceId = sliceId;
         }
         // Only include flows between different slices in our set
@@ -304,7 +314,10 @@ export function findChapterInboundFlows(model, slices) {
     }
     const flows = [];
     for (const flow of model.flows.values()) {
-        if (chapterComponentIds.has(flow.targetId) && !chapterComponentIds.has(flow.sourceId)) {
+        // Resolve linked copies to canonical originals
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+        if (chapterComponentIds.has(canonicalTargetId) && !chapterComponentIds.has(canonicalSourceId)) {
             const flowInfo = buildSliceFlowInfo(model, flow);
             if (flowInfo)
                 flows.push(flowInfo);
@@ -322,7 +335,10 @@ export function findChapterOutboundFlows(model, slices) {
     }
     const flows = [];
     for (const flow of model.flows.values()) {
-        if (chapterComponentIds.has(flow.sourceId) && !chapterComponentIds.has(flow.targetId)) {
+        // Resolve linked copies to canonical originals
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+        if (chapterComponentIds.has(canonicalSourceId) && !chapterComponentIds.has(canonicalTargetId)) {
             const flowInfo = buildSliceFlowInfo(model, flow);
             if (flowInfo)
                 flows.push(flowInfo);

package/dist/slices/show-slice/index.js

@@ -1,7 +1,7 @@
 import { escapeXml, escapeXmlText, outputJson } from '../../lib/format.js';
 import { findElementOrExit } from '../../lib/element-lookup.js';
 import { findChapterForSlice, getChapterHierarchy } from '../../lib/chapter-utils.js';
-import { getInboundFlows, getOutboundFlows, getFlowsForElement, getSliceComponentIds, } from '../../lib/flow-utils.js';
+import { getInboundFlows, getOutboundFlows, getFlowsForElement, getSliceComponentIds, resolveToCanonical, } from '../../lib/flow-utils.js';
 function formatFieldValues(values) {
     if (!values || Object.keys(values).length === 0)
         return '';
@@ -46,36 +46,16 @@ function getSliceComponents(model, slice) {
         const centerY = pos.y + height / 2;
         return centerX >= bounds.left && centerX <= bounds.right && centerY >= bounds.top && centerY <= bounds.bottom;
     }
-    // Include all elements in the slice (including linked copies)
-    // Linked copies will be marked as such in the output
+    // Only include canonical elements - linked copies are UI-only conveniences
+    // and should not appear as slice contents in CLI output
     return {
         commands: [...model.commands.values()].filter(c => isInSlice(c.position, c.width, c.height)),
-        events: [...model.events.values()].filter(e => isInSlice(e.position, e.width, e.height)),
-        readModels: [...model.readModels.values()].filter(rm => isInSlice(rm.position, rm.width, rm.height)),
-        screens: [...model.screens.values()].filter(s => isInSlice(s.position, s.width, s.height)),
+        events: [...model.events.values()].filter(e => !e.originalNodeId && isInSlice(e.position, e.width, e.height)),
+        readModels: [...model.readModels.values()].filter(rm => !rm.originalNodeId && isInSlice(rm.position, rm.width, rm.height)),
+        screens: [...model.screens.values()].filter(s => !s.originalNodeId && isInSlice(s.position, s.width, s.height)),
         processors: [...model.processors.values()].filter(p => isInSlice(p.position, p.width, p.height)),
     };
 }
-// Find which slice contains the original of a linked copy
-function findSliceForNode(model, nodeId) {
-    const event = model.events.get(nodeId);
-    const readModel = model.readModels.get(nodeId);
-    const screen = model.screens.get(nodeId);
-    const node = event ?? readModel ?? screen;
-    if (!node)
-        return null;
-    for (const slice of model.slices.values()) {
-        const centerX = node.position.x + node.width / 2;
-        const centerY = node.position.y + node.height / 2;
-        if (centerX >= slice.position.x &&
-            centerX <= slice.position.x + slice.size.width &&
-            centerY >= slice.position.y &&
-            centerY <= slice.position.y + slice.size.height) {
-            return slice;
-        }
-    }
-    return null;
-}
 // Find which aggregate an event belongs to (center point inside aggregate bounds)
 function findAggregateForEvent(model, event) {
     const centerX = event.position.x + event.width / 2;
@@ -191,8 +171,17 @@ function formatSliceXml(model, slice) {
     const chapter = findChapterForSlice(model, slice);
     // Use shared function that handles canonical groups for linked copies
     const componentIds = getSliceComponentIds(model, slice);
-    const flows = [...model.flows.values()].filter(f => componentIds.has(f.sourceId) || componentIds.has(f.targetId));
-    const internalFlows = flows.filter(f => componentIds.has(f.sourceId) && componentIds.has(f.targetId));
+    // Resolve linked copies to canonical originals when checking flow containment
+    const flows = [...model.flows.values()].filter(f => {
+        const canonicalSourceId = resolveToCanonical(model, f.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, f.targetId);
+        return componentIds.has(canonicalSourceId) || componentIds.has(canonicalTargetId);
+    });
+    const internalFlows = flows.filter(f => {
+        const canonicalSourceId = resolveToCanonical(model, f.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, f.targetId);
+        return componentIds.has(canonicalSourceId) && componentIds.has(canonicalTargetId);
+    });
     // Get inbound and outbound flows for the slice
     const inboundFlows = getInboundFlows(model, slice);
     const outboundFlows = getOutboundFlows(model, slice);
@@ -210,19 +199,10 @@ function formatSliceXml(model, slice) {
     }
     xml += '  <components>\n';
     for (const screen of components.screens) {
-        // Check if this is a linked copy
-        const copyAttr = screen.originalNodeId ? ' linked-copy="true"' : '';
-        let originAttr = '';
-        if (screen.originalNodeId) {
-            const originSlice = findSliceForNode(model, screen.originalNodeId);
-            if (originSlice) {
-                originAttr = ` origin-slice="${escapeXml(originSlice.name)}"`;
-            }
-        }
         // Check which actor this screen belongs to
         const actor = findActorForScreen(model, screen);
         const actorAttr = actor ? ` actor="${escapeXml(actor.name)}"` : '';
-        xml += `    <screen id="${screen.id}" name="${escapeXml(screen.name)}"${copyAttr}${originAttr}${actorAttr}>\n`;
+        xml += `    <screen id="${screen.id}" name="${escapeXml(screen.name)}"${actorAttr}>\n`;
         // Add flow annotations
         const screenFlows = getFlowsForElement(model, screen.id);
         xml += formatFlowAnnotationsXml(screen.id, screenFlows.incoming, screenFlows.outgoing, componentIds, '      ');
@@ -258,19 +238,10 @@ function formatSliceXml(model, slice) {
         xml += '    </command>\n';
     }
     for (const event of components.events) {
-        // Check if this is a linked copy
-        const copyAttr = event.originalNodeId ? ' linked-copy="true"' : '';
-        let originAttr = '';
-        if (event.originalNodeId) {
-            const originSlice = findSliceForNode(model, event.originalNodeId);
-            if (originSlice) {
-                originAttr = ` origin-slice="${escapeXml(originSlice.name)}"`;
-            }
-        }
         // Check which aggregate this event belongs to
         const aggregate = findAggregateForEvent(model, event);
         const aggregateAttr = aggregate ? ` aggregate="${escapeXml(aggregate.name)}"` : '';
-        xml += `    <event id="${event.id}" name="${escapeXml(event.name)}"${copyAttr}${originAttr}${aggregateAttr}>\n`;
+        xml += `    <event id="${event.id}" name="${escapeXml(event.name)}"${aggregateAttr}>\n`;
         // Add flow annotations
         const eventFlows = getFlowsForElement(model, event.id);
         xml += formatFlowAnnotationsXml(event.id, eventFlows.incoming, eventFlows.outgoing, componentIds, '      ');
@@ -295,16 +266,7 @@ function formatSliceXml(model, slice) {
         xml += '    </event>\n';
     }
     for (const readModel of components.readModels) {
-        // Check if this is a linked copy
-        const copyAttr = readModel.originalNodeId ? ' linked-copy="true"' : '';
-        let originAttr = '';
-        if (readModel.originalNodeId) {
-            const originSlice = findSliceForNode(model, readModel.originalNodeId);
-            if (originSlice) {
-                originAttr = ` origin-slice="${escapeXml(originSlice.name)}"`;
-            }
-        }
-        xml += `    <read-model id="${readModel.id}" name="${escapeXml(readModel.name)}"${copyAttr}${originAttr}>\n`;
+        xml += `    <read-model id="${readModel.id}" name="${escapeXml(readModel.name)}">\n`;
         // Add flow annotations
         const rmFlows = getFlowsForElement(model, readModel.id);
         xml += formatFlowAnnotationsXml(readModel.id, rmFlows.incoming, rmFlows.outgoing, componentIds, '      ');
@@ -428,8 +390,17 @@ function formatSliceJson(model, slice) {
     const chapter = findChapterForSlice(model, slice);
     // Use shared function that handles canonical groups for linked copies
     const componentIds = getSliceComponentIds(model, slice);
-    const flows = [...model.flows.values()].filter(f => componentIds.has(f.sourceId) || componentIds.has(f.targetId));
-    const internalFlows = flows.filter(f => componentIds.has(f.sourceId) && componentIds.has(f.targetId));
+    // Resolve linked copies to canonical originals when checking flow containment
+    const flows = [...model.flows.values()].filter(f => {
+        const canonicalSourceId = resolveToCanonical(model, f.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, f.targetId);
+        return componentIds.has(canonicalSourceId) || componentIds.has(canonicalTargetId);
+    });
+    const internalFlows = flows.filter(f => {
+        const canonicalSourceId = resolveToCanonical(model, f.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, f.targetId);
+        return componentIds.has(canonicalSourceId) && componentIds.has(canonicalTargetId);
+    });
     // Get inbound and outbound flows for the slice
     const inboundFlows = getInboundFlows(model, slice);
     const outboundFlows = getOutboundFlows(model, slice);
@@ -453,12 +424,6 @@ function formatSliceJson(model, slice) {
                     name: screen.name,
                     fields: screen.fields.map(fieldToJson)
                 };
-                if (screen.originalNodeId) {
-                    screenObj.linkedCopy = true;
-                    const originSlice = findSliceForNode(model, screen.originalNodeId);
-                    if (originSlice)
-                        screenObj.originSlice = originSlice.name;
-                }
                 const actor = findActorForScreen(model, screen);
                 if (actor)
                     screenObj.actor = actor.name;
@@ -509,12 +474,6 @@ function formatSliceJson(model, slice) {
                     name: event.name,
                     fields: event.fields.map(fieldToJson)
                 };
-                if (event.originalNodeId) {
-                    eventObj.linkedCopy = true;
-                    const originSlice = findSliceForNode(model, event.originalNodeId);
-                    if (originSlice)
-                        eventObj.originSlice = originSlice.name;
-                }
                 const aggregate = findAggregateForEvent(model, event);
                 if (aggregate)
                     eventObj.aggregate = aggregate.name;
@@ -542,12 +501,6 @@ function formatSliceJson(model, slice) {
                     name: rm.name,
                     fields: rm.fields.map(fieldToJson)
                 };
-                if (rm.originalNodeId) {
-                    rmObj.linkedCopy = true;
-                    const originSlice = findSliceForNode(model, rm.originalNodeId);
-                    if (originSlice)
-                        rmObj.originSlice = originSlice.name;
-                }
                 // Add flow annotations
                 const rmFlows = getFlowsForElement(model, rm.id);
                 if (rmFlows.incoming.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eventmodeler",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "CLI tool for interacting with Event Model files - query, update, and export event models from the terminal",
   "type": "module",
   "bin": {