eventmodeler 0.2.4 → 0.2.6

package/dist/index.js

@@ -35,6 +35,7 @@ import { createStateChangeSlice } from './slices/create-state-change-slice/index
 import { createAutomationSlice } from './slices/create-automation-slice/index.js';
 import { createStateViewSlice } from './slices/create-state-view-slice/index.js';
 import { createFlow } from './slices/create-flow/index.js';
+import { codegenSlice } from './slices/codegen-slice/index.js';
 const args = process.argv.slice(2);
 function getNamedArg(argList, ...names) {
     for (let i = 0; i < argList.length; i++) {
@@ -94,12 +95,14 @@ COMMANDS:
   create state-change-slice --xml <data>
                                  Create a state-change slice (Screen → Command → Event)
   create automation-slice --xml <data>
-                                 Create an automation slice (Processor → Command → Event)
+                                 Create an automation slice (ReadModel → Processor → Command → Event)
   create state-view-slice --xml <data>
                                  Create a state-view slice (Read Model)
   create flow --from <source> --to <target>
                                  Create a flow between elements (Event→ReadModel, ReadModel→Screen/Processor)
 
+  codegen slice <name>           Generate code-ready JSON for a slice (includes dependencies, mappings, scenarios)
+
   summary                        Show model summary statistics
 
   export json                    Export entire model as JSON
@@ -476,6 +479,24 @@ async function main() {
                     process.exit(1);
             }
             break;
+        case 'codegen':
+            switch (subcommand) {
+                case 'slice': {
+                    const sliceName = filteredArgs[2];
+                    if (!sliceName) {
+                        console.error('Error: slice name is required');
+                        console.error('Usage: eventmodeler codegen slice <name>');
+                        process.exit(1);
+                    }
+                    codegenSlice(model, sliceName);
+                    break;
+                }
+                default:
+                    console.error(`Unknown codegen target: ${subcommand}`);
+                    console.error('Valid targets: slice');
+                    process.exit(1);
+            }
+            break;
         default:
             console.error(`Unknown command: ${command}`);
             printHelp();

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

@@ -24,6 +24,12 @@ export declare const STATE_CHANGE_SLICE: {
 export declare const AUTOMATION_SLICE: {
     width: number;
     height: number;
+    readModel: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
     processor: {
         width: number;
         height: number;

package/dist/lib/slice-utils.js

@@ -7,11 +7,12 @@ export const STATE_CHANGE_SLICE = {
     event: { width: 160, height: 100, offsetX: 360, offsetY: 860 },
 };
 export const AUTOMATION_SLICE = {
-    width: 560,
+    width: 880,
     height: 1000,
-    processor: { width: 120, height: 120, offsetX: 40, offsetY: 120 },
-    command: { width: 160, height: 100, offsetX: 180, offsetY: 460 },
-    event: { width: 160, height: 100, offsetX: 360, offsetY: 860 },
+    readModel: { width: 160, height: 100, offsetX: 40, offsetY: 460 },
+    processor: { width: 120, height: 120, offsetX: 280, offsetY: 120 },
+    command: { width: 160, height: 100, offsetX: 440, offsetY: 460 },
+    event: { width: 160, height: 100, offsetX: 680, offsetY: 860 },
 };
 export const STATE_VIEW_SLICE = {
     width: 380,

package/dist/projection.js

@@ -824,138 +824,6 @@ function applyEvent(model, event) {
         case 'ScreenDesignUpdated':
             // Screen designs are visual-only, not relevant for CLI
             break;
-        // Compound slice placement events - place entire slices atomically
-        case 'StateChangeSlicePlaced': {
-            // Create slice
-            model.slices.set(event.sliceId, {
-                id: event.sliceId,
-                name: event.sliceName,
-                status: 'created',
-                position: event.slicePosition,
-                size: event.sliceSize,
-                nodeIds: [event.screenId, event.commandId, event.eventId],
-            });
-            // Create screen
-            model.screens.set(event.screenId, {
-                id: event.screenId,
-                name: event.screenName,
-                fields: event.screenFields,
-                position: event.screenPosition,
-                width: event.screenSize.width,
-                height: event.screenSize.height,
-            });
-            // Create command
-            model.commands.set(event.commandId, {
-                id: event.commandId,
-                name: event.commandName,
-                fields: event.commandFields,
-                position: event.commandPosition,
-                width: event.commandSize.width,
-                height: event.commandSize.height,
-            });
-            // Create event
-            model.events.set(event.eventId, {
-                id: event.eventId,
-                name: event.eventName,
-                fields: event.eventFields,
-                position: event.eventPosition,
-                width: event.eventSize.width,
-                height: event.eventSize.height,
-            });
-            // Create screen->command flow
-            model.flows.set(event.screenToCommandFlowId, {
-                id: event.screenToCommandFlowId,
-                flowType: 'ScreenToCommand',
-                sourceId: event.screenId,
-                targetId: event.commandId,
-                fieldMappings: event.screenToCommandMappings,
-            });
-            // Create command->event flow
-            model.flows.set(event.commandToEventFlowId, {
-                id: event.commandToEventFlowId,
-                flowType: 'CommandToEvent',
-                sourceId: event.commandId,
-                targetId: event.eventId,
-                fieldMappings: event.commandToEventMappings,
-            });
-            break;
-        }
-        case 'AutomationSlicePlaced': {
-            // Create slice
-            model.slices.set(event.sliceId, {
-                id: event.sliceId,
-                name: event.sliceName,
-                status: 'created',
-                position: event.slicePosition,
-                size: event.sliceSize,
-                nodeIds: [event.processorId, event.commandId, event.eventId],
-            });
-            // Create processor
-            model.processors.set(event.processorId, {
-                id: event.processorId,
-                name: event.processorName,
-                fields: [],
-                position: event.processorPosition,
-                width: event.processorSize.width,
-                height: event.processorSize.height,
-            });
-            // Create command
-            model.commands.set(event.commandId, {
-                id: event.commandId,
-                name: event.commandName,
-                fields: event.commandFields,
-                position: event.commandPosition,
-                width: event.commandSize.width,
-                height: event.commandSize.height,
-            });
-            // Create event
-            model.events.set(event.eventId, {
-                id: event.eventId,
-                name: event.eventName,
-                fields: event.eventFields,
-                position: event.eventPosition,
-                width: event.eventSize.width,
-                height: event.eventSize.height,
-            });
-            // Create processor->command flow
-            model.flows.set(event.processorToCommandFlowId, {
-                id: event.processorToCommandFlowId,
-                flowType: 'ProcessorToCommand',
-                sourceId: event.processorId,
-                targetId: event.commandId,
-                fieldMappings: [],
-            });
-            // Create command->event flow
-            model.flows.set(event.commandToEventFlowId, {
-                id: event.commandToEventFlowId,
-                flowType: 'CommandToEvent',
-                sourceId: event.commandId,
-                targetId: event.eventId,
-                fieldMappings: event.commandToEventMappings,
-            });
-            break;
-        }
-        case 'StateViewSlicePlaced': {
-            // Create slice
-            model.slices.set(event.sliceId, {
-                id: event.sliceId,
-                name: event.sliceName,
-                status: 'created',
-                position: event.slicePosition,
-                size: event.sliceSize,
-                nodeIds: [event.readModelId],
-            });
-            // Create read model
-            model.readModels.set(event.readModelId, {
-                id: event.readModelId,
-                name: event.readModelName,
-                fields: event.readModelFields,
-                position: event.readModelPosition,
-                width: event.readModelSize.width,
-                height: event.readModelSize.height,
-            });
-            break;
-        }
     }
 }
 // Merge propagated fields with existing fields:

package/dist/slices/add-scenario/index.js

@@ -207,15 +207,20 @@ export function addScenario(model, filePath, sliceName, input) {
         };
     }
     // Calculate position below slice
+    // Scenarios are tall (GWT rows with 100px stickies + labels + padding = ~400px+)
+    // so we need adequate spacing between them
+    const SCENARIO_GAP = 20; // Match slice gap
+    const SCENARIO_ESTIMATED_HEIGHT = 450; // Approximate rendered height for positioning
     const existingScenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
     const sliceBottom = slice.position.y + slice.size.height;
     let positionY;
     if (existingScenarios.length === 0) {
-        positionY = sliceBottom + 20;
+        positionY = sliceBottom + SCENARIO_GAP;
     }
     else {
-        const lowestY = Math.max(...existingScenarios.map(s => s.position.y + s.height));
-        positionY = lowestY + 10;
+        // Use estimated height since stored height (80px) doesn't reflect actual rendered size
+        const lowestY = Math.max(...existingScenarios.map(s => s.position.y + SCENARIO_ESTIMATED_HEIGHT));
+        positionY = lowestY + SCENARIO_GAP;
     }
     const position = {
         x: slice.position.x + 10,

package/dist/slices/codegen-slice/index.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../../types.js';
+export declare function codegenSlice(model: EventModel, sliceName: string): void;

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

@@ -0,0 +1,384 @@
+import { outputJson } from '../../lib/format.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
+// Get components inside a slice by checking if center point is within bounds
+function getSliceComponents(model, slice) {
+    const bounds = {
+        left: slice.position.x,
+        right: slice.position.x + slice.size.width,
+        top: slice.position.y,
+        bottom: slice.position.y + slice.size.height,
+    };
+    function isInSlice(pos, width, height) {
+        const centerX = pos.x + width / 2;
+        const centerY = pos.y + height / 2;
+        return centerX >= bounds.left && centerX <= bounds.right && centerY >= bounds.top && centerY <= bounds.bottom;
+    }
+    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)),
+        processors: [...model.processors.values()].filter(p => isInSlice(p.position, p.width, p.height)),
+    };
+}
+// Find which slice contains a node
+function findSliceForNode(model, nodeId) {
+    const event = model.events.get(nodeId);
+    const readModel = model.readModels.get(nodeId);
+    const screen = model.screens.get(nodeId);
+    const command = model.commands.get(nodeId);
+    const processor = model.processors.get(nodeId);
+    const node = event ?? readModel ?? screen ?? command ?? processor;
+    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
+function findAggregateForEvent(model, event) {
+    const centerX = event.position.x + event.width / 2;
+    const centerY = event.position.y + event.height / 2;
+    for (const aggregate of model.aggregates.values()) {
+        if (centerX >= aggregate.position.x &&
+            centerX <= aggregate.position.x + aggregate.size.width &&
+            centerY >= aggregate.position.y &&
+            centerY <= aggregate.position.y + aggregate.size.height) {
+            return aggregate.name;
+        }
+    }
+    return undefined;
+}
+// Find which actor a screen belongs to
+function findActorForScreen(model, screen) {
+    const centerX = screen.position.x + screen.width / 2;
+    const centerY = screen.position.y + screen.height / 2;
+    for (const actor of model.actors.values()) {
+        if (centerX >= actor.position.x &&
+            centerX <= actor.position.x + actor.size.width &&
+            centerY >= actor.position.y &&
+            centerY <= actor.position.y + actor.size.height) {
+            return actor.name;
+        }
+    }
+    return undefined;
+}
+// Convert Field to JSON-friendly format
+function fieldToJson(field) {
+    const result = {
+        name: field.name,
+        type: field.fieldType,
+    };
+    if (field.isList)
+        result.list = true;
+    if (field.isGenerated)
+        result.generated = true;
+    if (field.isOptional)
+        result.optional = true;
+    if (field.isUserInput)
+        result.userInput = true;
+    if (field.subfields && field.subfields.length > 0) {
+        result.subfields = field.subfields.map(fieldToJson);
+    }
+    return result;
+}
+// Determine slice type based on components, returns null for invalid configurations
+function determineSliceType(hasProcessors, hasCommands, hasEvents, hasReadModels, hasScreens) {
+    // AUTOMATION: Must have a Processor (and typically ReadModel, Command, Event)
+    if (hasProcessors)
+        return 'AUTOMATION';
+    // STATE_CHANGE: Must have both Command and Event (typically with Screen)
+    if (hasCommands && hasEvents)
+        return 'STATE_CHANGE';
+    // STATE_VIEW: Must have at least one ReadModel
+    if (hasReadModels && !hasCommands && !hasEvents)
+        return 'STATE_VIEW';
+    // Invalid configurations:
+    // - Empty slice
+    // - Only Command (no Event)
+    // - Only Event (no Command)
+    // - Only Screen (no Command)
+    return null;
+}
+// Get element type for an ID
+function getElementType(model, id) {
+    if (model.commands.has(id))
+        return 'COMMAND';
+    if (model.events.has(id))
+        return 'EVENT';
+    if (model.readModels.has(id))
+        return 'READMODEL';
+    if (model.screens.has(id))
+        return 'SCREEN';
+    if (model.processors.has(id))
+        return 'PROCESSOR';
+    return null;
+}
+// Get element name for an ID
+function getElementName(model, id) {
+    return (model.commands.get(id)?.name ??
+        model.events.get(id)?.name ??
+        model.readModels.get(id)?.name ??
+        model.screens.get(id)?.name ??
+        model.processors.get(id)?.name ??
+        'Unknown');
+}
+// Get element fields for an ID
+function getElementFields(model, id) {
+    return (model.commands.get(id)?.fields ??
+        model.events.get(id)?.fields ??
+        model.readModels.get(id)?.fields ??
+        model.screens.get(id)?.fields ??
+        model.processors.get(id)?.fields ??
+        []);
+}
+// Find a field by ID within an element's fields
+function findFieldById(fields, fieldId) {
+    for (const field of fields) {
+        if (field.id === fieldId)
+            return field;
+        if (field.subfields) {
+            const found = findFieldById(field.subfields, fieldId);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+// Get element reference (type, id, name)
+function getElementRef(model, id) {
+    return {
+        type: getElementType(model, id) ?? 'EVENT',
+        id,
+        name: getElementName(model, id),
+    };
+}
+// Get element with full schema
+function getElementWithSchema(model, id) {
+    const type = getElementType(model, id) ?? 'EVENT';
+    const name = getElementName(model, id);
+    const fields = getElementFields(model, id).map(fieldToJson);
+    const result = { type, id, name, fields };
+    // Add aggregate info for events
+    const event = model.events.get(id);
+    if (event) {
+        const aggregate = findAggregateForEvent(model, event);
+        if (aggregate)
+            result.aggregate = aggregate;
+        const originSlice = findSliceForNode(model, id);
+        if (originSlice)
+            result.originSlice = originSlice.name;
+    }
+    // Add actor info for screens
+    const screen = model.screens.get(id);
+    if (screen) {
+        const actor = findActorForScreen(model, screen);
+        if (actor)
+            result.actor = actor;
+    }
+    return result;
+}
+// Enrich field mappings with field names
+function enrichFieldMappings(model, flow) {
+    const sourceFields = getElementFields(model, flow.sourceId);
+    const targetFields = getElementFields(model, flow.targetId);
+    return flow.fieldMappings.map(mapping => {
+        const sourceField = findFieldById(sourceFields, mapping.sourceFieldId);
+        const targetField = findFieldById(targetFields, mapping.targetFieldId);
+        return {
+            sourceFieldId: mapping.sourceFieldId,
+            sourceFieldName: sourceField?.name ?? 'unknown',
+            targetFieldId: mapping.targetFieldId,
+            targetFieldName: targetField?.name ?? 'unknown',
+        };
+    });
+}
+// Get inbound dependencies (flows where target is in slice but source is not)
+function getInboundDependencies(model, componentIds) {
+    return [...model.flows.values()]
+        .filter(f => componentIds.has(f.targetId) && !componentIds.has(f.sourceId))
+        .map(flow => ({
+        flowId: flow.id,
+        flowType: flow.flowType,
+        source: getElementWithSchema(model, flow.sourceId),
+        target: getElementRef(model, flow.targetId),
+        fieldMappings: enrichFieldMappings(model, flow),
+    }));
+}
+// Get internal flows (both source and target are in slice)
+function getInternalFlows(model, componentIds) {
+    return [...model.flows.values()]
+        .filter(f => componentIds.has(f.sourceId) && componentIds.has(f.targetId))
+        .map(flow => ({
+        flowId: flow.id,
+        flowType: flow.flowType,
+        source: getElementRef(model, flow.sourceId),
+        target: getElementRef(model, flow.targetId),
+        fieldMappings: enrichFieldMappings(model, flow),
+    }));
+}
+// Format scenario then clause
+function formatScenarioThen(model, then) {
+    if (then.type === 'error') {
+        return {
+            type: 'error',
+            errorType: then.errorType,
+            errorMessage: then.errorMessage,
+        };
+    }
+    if (then.type === 'events' && then.expectedEvents) {
+        return {
+            type: 'events',
+            expectedEvents: then.expectedEvents.map(expected => {
+                const event = model.events.get(expected.eventStickyId);
+                return {
+                    eventId: expected.eventStickyId,
+                    eventName: event?.name ?? 'UnknownEvent',
+                    eventSchema: { fields: event?.fields.map(fieldToJson) ?? [] },
+                    fieldValues: expected.fieldValues ?? {},
+                };
+            }),
+        };
+    }
+    if (then.type === 'readModelAssertion' && then.readModelAssertion) {
+        const rm = model.readModels.get(then.readModelAssertion.readModelStickyId);
+        return {
+            type: 'readModelAssertion',
+            readModelName: rm?.name ?? 'UnknownReadModel',
+            expectedFieldValues: then.readModelAssertion.expectedFieldValues,
+        };
+    }
+    // Default fallback
+    return { type: 'events', expectedEvents: [] };
+}
+// Format scenarios with resolved schemas
+function formatScenarios(model, scenarios) {
+    return scenarios.map(scenario => ({
+        id: scenario.id,
+        name: scenario.name,
+        description: scenario.description,
+        given: scenario.givenEvents.map(ref => {
+            const event = model.events.get(ref.eventStickyId);
+            const originSlice = findSliceForNode(model, ref.eventStickyId);
+            return {
+                eventId: ref.eventStickyId,
+                eventName: event?.name ?? 'UnknownEvent',
+                originSlice: originSlice?.name ?? null,
+                eventSchema: { fields: event?.fields.map(fieldToJson) ?? [] },
+                fieldValues: ref.fieldValues ?? {},
+            };
+        }),
+        when: scenario.whenCommand
+            ? {
+                commandId: scenario.whenCommand.commandStickyId,
+                commandName: model.commands.get(scenario.whenCommand.commandStickyId)?.name ?? 'UnknownCommand',
+                fieldValues: scenario.whenCommand.fieldValues ?? {},
+            }
+            : null,
+        then: formatScenarioThen(model, scenario.then),
+    }));
+}
+export function codegenSlice(model, sliceName) {
+    // 1. Find the slice
+    const slice = findElementOrExit(model.slices, sliceName, 'slice');
+    // 2. Get components inside slice
+    const components = getSliceComponents(model, slice);
+    // 3. Build component ID set
+    const componentIds = new Set();
+    components.commands.forEach(c => componentIds.add(c.id));
+    components.events.forEach(e => componentIds.add(e.id));
+    components.readModels.forEach(rm => componentIds.add(rm.id));
+    components.screens.forEach(s => componentIds.add(s.id));
+    components.processors.forEach(p => componentIds.add(p.id));
+    // 4. Determine slice type
+    const sliceType = determineSliceType(components.processors.length > 0, components.commands.length > 0, components.events.length > 0, components.readModels.length > 0, components.screens.length > 0);
+    // Validate slice type - exit with error for invalid configurations
+    if (sliceType === null) {
+        const hasAny = componentIds.size > 0;
+        if (!hasAny) {
+            console.error(`Error: Slice "${slice.name}" is empty - no elements found inside slice bounds`);
+        }
+        else {
+            const parts = [];
+            if (components.commands.length > 0)
+                parts.push(`${components.commands.length} command(s)`);
+            if (components.events.length > 0)
+                parts.push(`${components.events.length} event(s)`);
+            if (components.screens.length > 0)
+                parts.push(`${components.screens.length} screen(s)`);
+            if (components.readModels.length > 0)
+                parts.push(`${components.readModels.length} read model(s)`);
+            console.error(`Error: Slice "${slice.name}" has invalid configuration for codegen: ${parts.join(', ')}`);
+            console.error('Valid configurations:');
+            console.error('  AUTOMATION:   Processor + ReadModel + Command + Event');
+            console.error('  STATE_CHANGE: Screen + Command + Event');
+            console.error('  STATE_VIEW:   ReadModel only');
+        }
+        process.exit(1);
+    }
+    // 5. Get inbound dependencies with full schemas
+    const inboundDependencies = getInboundDependencies(model, componentIds);
+    // 6. Get internal flows with field mappings
+    const internalFlows = getInternalFlows(model, componentIds);
+    // 7. Get scenarios for this slice
+    const scenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
+    // 8. Build output
+    const output = {
+        sliceType,
+        slice: {
+            id: slice.id,
+            name: slice.name,
+        },
+        elements: {
+            readModels: components.readModels.map(rm => ({
+                id: rm.id,
+                name: rm.name,
+                fields: rm.fields.map(fieldToJson),
+            })),
+            processors: components.processors.map(p => ({
+                id: p.id,
+                name: p.name,
+            })),
+            commands: components.commands.map(cmd => ({
+                id: cmd.id,
+                name: cmd.name,
+                fields: cmd.fields.map(fieldToJson),
+            })),
+            events: components.events.map(evt => {
+                const result = {
+                    id: evt.id,
+                    name: evt.name,
+                    fields: evt.fields.map(fieldToJson),
+                };
+                const aggregate = findAggregateForEvent(model, evt);
+                if (aggregate)
+                    result.aggregate = aggregate;
+                return result;
+            }),
+            screens: components.screens.map(scr => {
+                const result = {
+                    id: scr.id,
+                    name: scr.name,
+                    fields: scr.fields.map(fieldToJson),
+                };
+                const actor = findActorForScreen(model, scr);
+                if (actor)
+                    result.actor = actor;
+                return result;
+            }),
+        },
+        inboundDependencies,
+        internalFlows,
+        scenarios: formatScenarios(model, scenarios),
+    };
+    // 9. Output JSON
+    outputJson(output);
+}

package/dist/slices/create-automation-slice/index.js

@@ -16,6 +16,16 @@ function parseXmlInput(xml) {
     }
     const after = getAttr(sliceMatch[1], 'after');
     const before = getAttr(sliceMatch[1], 'before');
+    // Parse read-model
+    const readModelMatch = xml.match(/<read-model([^>]*)>([\s\S]*?)<\/read-model>/);
+    if (!readModelMatch) {
+        throw new Error('Invalid XML: missing <read-model> element');
+    }
+    const readModelName = getAttr(readModelMatch[1], 'name');
+    if (!readModelName) {
+        throw new Error('Invalid XML: read-model must have a name attribute');
+    }
+    const readModelFields = parseFieldsFromXml(readModelMatch[2]);
     // Parse processor (no fields)
     const processorMatch = xml.match(/<processor([^>]*?)(?:\/>|>([\s\S]*?)<\/processor>)/);
     if (!processorMatch) {
@@ -49,6 +59,7 @@ function parseXmlInput(xml) {
         sliceName,
         after,
         before,
+        readModel: { name: readModelName, fields: readModelFields },
         processor: { name: processorName },
         command: { name: commandName, fields: commandFields },
         event: { name: eventName, fields: eventFields },
@@ -99,17 +110,25 @@ export function createAutomationSlice(model, filePath, xmlInput) {
     }
     // Generate IDs
     const sliceId = crypto.randomUUID();
+    const readModelId = crypto.randomUUID();
     const processorId = crypto.randomUUID();
     const commandId = crypto.randomUUID();
     const eventId = crypto.randomUUID();
+    const readModelToProcessorFlowId = crypto.randomUUID();
     const processorToCommandFlowId = crypto.randomUUID();
     const commandToEventFlowId = crypto.randomUUID();
     // Convert field inputs to fields with IDs
+    const readModelFields = input.readModel.fields.map(fieldInputToField);
     const commandFields = input.command.fields.map(fieldInputToField);
     const eventFields = input.event.fields.map(fieldInputToField);
-    // Infer field mappings (processor has no fields, so only command->event)
+    // Infer field mappings
+    const readModelToCommandMappings = inferFieldMappings(readModelFields, commandFields);
     const commandToEventMappings = inferFieldMappings(commandFields, eventFields);
     // Calculate absolute positions for components within the slice
+    const readModelPosition = {
+        x: slicePosition.x + AUTOMATION_SLICE.readModel.offsetX,
+        y: slicePosition.y + AUTOMATION_SLICE.readModel.offsetY,
+    };
     const processorPosition = {
         x: slicePosition.x + AUTOMATION_SLICE.processor.offsetX,
         y: slicePosition.y + AUTOMATION_SLICE.processor.offsetY,
@@ -132,7 +151,26 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         size: { width: AUTOMATION_SLICE.width, height: AUTOMATION_SLICE.height },
         timestamp: Date.now(),
     });
-    // 2. Create the processor
+    // 2. Create the read model
+    appendEvent(filePath, {
+        type: 'ReadModelStickyPlaced',
+        readModelStickyId: readModelId,
+        name: input.readModel.name,
+        position: readModelPosition,
+        width: AUTOMATION_SLICE.readModel.width,
+        height: AUTOMATION_SLICE.readModel.height,
+        timestamp: Date.now(),
+    });
+    // 3. Add read model fields
+    for (const field of readModelFields) {
+        appendEvent(filePath, {
+            type: 'ReadModelFieldAdded',
+            readModelStickyId: readModelId,
+            field,
+            timestamp: Date.now(),
+        });
+    }
+    // 4. Create the processor
     appendEvent(filePath, {
         type: 'ProcessorPlaced',
         processorId,
@@ -142,7 +180,7 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         height: AUTOMATION_SLICE.processor.height,
         timestamp: Date.now(),
     });
-    // 3. Create the command
+    // 5. Create the command
     appendEvent(filePath, {
         type: 'CommandStickyPlaced',
         commandStickyId: commandId,
@@ -152,7 +190,7 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         height: AUTOMATION_SLICE.command.height,
         timestamp: Date.now(),
     });
-    // 4. Add command fields
+    // 6. Add command fields
     for (const field of commandFields) {
         appendEvent(filePath, {
             type: 'CommandFieldAdded',
@@ -161,7 +199,7 @@ export function createAutomationSlice(model, filePath, xmlInput) {
             timestamp: Date.now(),
         });
     }
-    // 5. Create the event
+    // 7. Create the event
     appendEvent(filePath, {
         type: 'EventStickyPlaced',
         eventStickyId: eventId,
@@ -171,7 +209,7 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         height: AUTOMATION_SLICE.event.height,
         timestamp: Date.now(),
     });
-    // 6. Add event fields
+    // 8. Add event fields
     for (const field of eventFields) {
         appendEvent(filePath, {
             type: 'EventFieldAdded',
@@ -180,7 +218,26 @@ export function createAutomationSlice(model, filePath, xmlInput) {
             timestamp: Date.now(),
         });
     }
-    // 7. Create processor -> command flow
+    // 9. Create read model -> processor flow
+    appendEvent(filePath, {
+        type: 'ReadModelToProcessorFlowSpecified',
+        flowId: readModelToProcessorFlowId,
+        readModelStickyId: readModelId,
+        processorId,
+        sourceHandle: 'top-source',
+        targetHandle: 'bottom-target',
+        timestamp: Date.now(),
+    });
+    // 10. Add read model -> command field mappings
+    if (readModelToCommandMappings.length > 0) {
+        appendEvent(filePath, {
+            type: 'FieldMappingSpecified',
+            flowId: readModelToProcessorFlowId,
+            mappings: readModelToCommandMappings,
+            timestamp: Date.now(),
+        });
+    }
+    // 11. Create processor -> command flow
     appendEvent(filePath, {
         type: 'ProcessorToCommandFlowSpecified',
         flowId: processorToCommandFlowId,
@@ -190,7 +247,7 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         targetHandle: 'top-target',
         timestamp: Date.now(),
     });
-    // 8. Create command -> event flow
+    // 12. Create command -> event flow
     appendEvent(filePath, {
         type: 'CommandToEventFlowSpecified',
         flowId: commandToEventFlowId,
@@ -200,7 +257,7 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         targetHandle: 'top-target',
         timestamp: Date.now(),
     });
-    // 9. Add command -> event field mappings
+    // 13. Add command -> event field mappings
     if (commandToEventMappings.length > 0) {
         appendEvent(filePath, {
             type: 'FieldMappingSpecified',
@@ -210,8 +267,10 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         });
     }
     console.log(`Created automation slice "${input.sliceName}"`);
+    console.log(`  ReadModel: ${input.readModel.name} (${readModelFields.length} fields)`);
     console.log(`  Processor: ${input.processor.name}`);
     console.log(`  Command: ${input.command.name} (${commandFields.length} fields)`);
     console.log(`  Event: ${input.event.name} (${eventFields.length} fields)`);
+    console.log(`  ReadModel -> Command mappings: ${readModelToCommandMappings.length}`);
     console.log(`  Command -> Event mappings: ${commandToEventMappings.length}`);
 }

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

@@ -23,7 +23,7 @@ function findElementByName(model, name) {
         }
         for (const rm of model.readModels.values()) {
             if (rm.id.toLowerCase().startsWith(idSearch)) {
-                return { element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel' }, ambiguous: [] };
+                return { element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel', canonicalId: rm.canonicalId }, ambiguous: [] };
             }
         }
         for (const scr of model.screens.values()) {
@@ -49,7 +49,7 @@ function findElementByName(model, name) {
             return { element: { id: evt.id, name: evt.name, fields: evt.fields, type: 'event' }, ambiguous: [] };
         const rm = model.readModels.get(name);
         if (rm)
-            return { element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel' }, ambiguous: [] };
+            return { element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel', canonicalId: rm.canonicalId }, ambiguous: [] };
         const scr = model.screens.get(name);
         if (scr)
             return { element: { id: scr.id, name: scr.name, fields: scr.fields, type: 'screen' }, ambiguous: [] };
@@ -73,7 +73,7 @@ function findElementByName(model, name) {
     }
     for (const rm of model.readModels.values()) {
         if (rm.name.toLowerCase() === nameLower) {
-            matches.push({ element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel' }, type: 'readModel' });
+            matches.push({ element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel', canonicalId: rm.canonicalId }, type: 'readModel' });
         }
     }
     for (const scr of model.screens.values()) {
@@ -123,6 +123,95 @@ function flattenFields(fields, prefix = '') {
     }
     return result;
 }
+/**
+ * Calculates completeness for a read model using the union approach.
+ * A field is satisfied if ANY incoming event provides it.
+ * For linked copies, considers flows into ALL nodes in the canonical group.
+ */
+function calculateReadModelUnionCompleteness(model, readModelId, readModelFields, canonicalId) {
+    // Find all node IDs in the canonical group (original + all copies)
+    let targetNodeIds;
+    if (canonicalId) {
+        targetNodeIds = [...model.readModels.values()]
+            .filter(rm => rm.canonicalId === canonicalId)
+            .map(rm => rm.id);
+    }
+    else {
+        targetNodeIds = [readModelId];
+    }
+    // Find all incoming EventToReadModel flows to ANY node in the group
+    const incomingFlows = [...model.flows.values()].filter(f => targetNodeIds.includes(f.targetId) && f.flowType === 'EventToReadModel');
+    // Collect all source fields from all incoming events (union)
+    const allSourceFields = [];
+    const allManualMappings = [];
+    const sourceEventNames = [];
+    for (const flow of incomingFlows) {
+        const sourceFields = getSourceFields(model, flow.sourceId);
+        allSourceFields.push(...flattenFields(sourceFields));
+        if (flow.fieldMappings) {
+            allManualMappings.push(...flow.fieldMappings);
+        }
+        // Get event name for reporting
+        const event = model.events.get(flow.sourceId);
+        if (event && !sourceEventNames.includes(event.name)) {
+            sourceEventNames.push(event.name);
+        }
+    }
+    // Check each target field against the union of all sources
+    const flatTarget = flattenFields(readModelFields);
+    const untraceableFields = [];
+    const optionalMissingFields = [];
+    const fieldStatuses = [];
+    for (const { id, path, field } of flatTarget) {
+        // 1. Generated fields don't need a source
+        if (field.isGenerated) {
+            fieldStatuses.push({ fieldId: id, fieldName: path, status: 'generated' });
+            continue;
+        }
+        // 2. Check if there's a manual mapping from any flow
+        const manualMapping = allManualMappings.find(m => m.targetFieldId === id);
+        if (manualMapping) {
+            const sourceField = allSourceFields.find(sf => sf.id === manualMapping.sourceFieldId);
+            fieldStatuses.push({
+                fieldId: id,
+                fieldName: path,
+                status: 'satisfied',
+                sourceFieldId: manualMapping.sourceFieldId,
+                sourceFieldName: sourceField?.path,
+            });
+            continue;
+        }
+        // 3. Check auto-mapping by path match from any source
+        const autoMatch = allSourceFields.find(sf => sf.path === path);
+        if (autoMatch) {
+            fieldStatuses.push({
+                fieldId: id,
+                fieldName: path,
+                status: 'satisfied',
+                sourceFieldId: autoMatch.id,
+                sourceFieldName: autoMatch.path,
+            });
+            continue;
+        }
+        // 4. Optional fields missing is a warning, not an error
+        if (field.isOptional) {
+            optionalMissingFields.push(path);
+            fieldStatuses.push({ fieldId: id, fieldName: path, status: 'optional-missing' });
+            continue;
+        }
+        // Field is untraceable (required but no source)
+        untraceableFields.push(path);
+        fieldStatuses.push({ fieldId: id, fieldName: path, status: 'unsatisfied' });
+    }
+    return {
+        isComplete: untraceableFields.length === 0,
+        hasWarnings: optionalMissingFields.length > 0,
+        untraceableFields,
+        optionalMissingFields,
+        sourceEvents: sourceEventNames,
+        fieldStatuses,
+    };
+}
 function calculateFlowCompleteness(model, flow, targetFields, sourceFields) {
     const flatSource = flattenFields(sourceFields);
     const flatTarget = flattenFields(targetFields);
@@ -254,10 +343,112 @@ export function showCompleteness(model, elementName, format) {
         }
         process.exit(1);
     }
-    // Find all incoming flows for this element type
+    const elementTypeLabel = element.type === 'readModel' ? 'read-model' : element.type;
+    // For read models, use union completeness (all incoming events combined)
+    if (element.type === 'readModel') {
+        const unionResult = calculateReadModelUnionCompleteness(model, element.id, element.fields, element.canonicalId);
+        // Check if there are any incoming flows at all
+        let targetNodeIds;
+        if (element.canonicalId) {
+            targetNodeIds = [...model.readModels.values()]
+                .filter(rm => rm.canonicalId === element.canonicalId)
+                .map(rm => rm.id);
+        }
+        else {
+            targetNodeIds = [element.id];
+        }
+        const hasIncomingFlows = [...model.flows.values()].some(f => targetNodeIds.includes(f.targetId) && f.flowType === 'EventToReadModel');
+        if (!hasIncomingFlows) {
+            if (format === 'json') {
+                outputJson({
+                    elementType: elementTypeLabel,
+                    name: element.name,
+                    message: `No flows into this ${elementTypeLabel}`
+                });
+            }
+            else {
+                console.log(`<completeness ${elementTypeLabel}="${escapeXml(element.name)}">`);
+                console.log(`  <no-flows>No flows into this ${elementTypeLabel}</no-flows>`);
+                console.log('</completeness>');
+            }
+            return;
+        }
+        const overallStatus = unionResult.isComplete ? 'complete' : 'incomplete';
+        const flatTargetFields = flattenFields(element.fields);
+        if (format === 'json') {
+            outputJson({
+                elementType: elementTypeLabel,
+                name: element.name,
+                status: overallStatus,
+                ...(unionResult.hasWarnings ? { hasWarnings: true } : {}),
+                sourceEvents: unionResult.sourceEvents,
+                ...(unionResult.untraceableFields.length > 0 ? { untraceableFields: unionResult.untraceableFields } : {}),
+                ...(unionResult.optionalMissingFields.length > 0 ? { optionalMissingFields: unionResult.optionalMissingFields } : {}),
+                fieldStatuses: unionResult.fieldStatuses.map(f => ({
+                    name: f.fieldName,
+                    status: f.status,
+                    ...(f.sourceFieldName ? { source: f.sourceFieldName } : {})
+                })),
+                elementFields: flatTargetFields.map(({ id, path, field }) => ({
+                    id,
+                    name: path,
+                    type: field.fieldType,
+                    ...(field.isList ? { isList: true } : {}),
+                    ...(field.isOptional ? { isOptional: true } : {}),
+                    ...(field.isGenerated ? { isGenerated: true } : {})
+                }))
+            });
+            return;
+        }
+        // XML output for read models
+        console.log(`<completeness ${elementTypeLabel}="${escapeXml(element.name)}" status="${overallStatus}"${unionResult.hasWarnings ? ' hasWarnings="true"' : ''}>`);
+        console.log('  <source-events>');
+        for (const eventName of unionResult.sourceEvents) {
+            console.log(`    <event name="${escapeXml(eventName)}"/>`);
+        }
+        console.log('  </source-events>');
+        if (unionResult.untraceableFields.length > 0) {
+            console.log('  <untraceable-fields>');
+            for (const fieldName of unionResult.untraceableFields) {
+                console.log(`    <field name="${escapeXml(fieldName)}"/>`);
+            }
+            console.log('  </untraceable-fields>');
+        }
+        if (unionResult.optionalMissingFields.length > 0) {
+            console.log('  <optional-missing-fields>');
+            for (const fieldName of unionResult.optionalMissingFields) {
+                console.log(`    <field name="${escapeXml(fieldName)}"/>`);
+            }
+            console.log('  </optional-missing-fields>');
+        }
+        console.log('  <field-statuses>');
+        for (const field of unionResult.fieldStatuses) {
+            if (field.sourceFieldName) {
+                console.log(`    <field name="${escapeXml(field.fieldName)}" status="${field.status}" source="${escapeXml(field.sourceFieldName)}"/>`);
+            }
+            else {
+                console.log(`    <field name="${escapeXml(field.fieldName)}" status="${field.status}"/>`);
+            }
+        }
+        console.log('  </field-statuses>');
+        console.log(`  <${elementTypeLabel}-fields>`);
+        for (const { id, path, field } of flatTargetFields) {
+            const attrs = [`id="${id}"`, `name="${escapeXml(path)}"`, `type="${field.fieldType}"`];
+            if (field.isList)
+                attrs.push('isList="true"');
+            if (field.isOptional)
+                attrs.push('isOptional="true"');
+            if (field.isGenerated)
+                attrs.push('isGenerated="true"');
+            console.log(`    <field ${attrs.join(' ')}/>`);
+        }
+        console.log(`  </${elementTypeLabel}-fields>`);
+        console.log('</completeness>');
+        return;
+    }
+    // For non-read-model elements, use per-flow completeness
     const validFlowTypes = INCOMING_FLOW_TYPES[element.type];
     const incomingFlows = [...model.flows.values()].filter(f => f.targetId === element.id && validFlowTypes.includes(f.flowType));
-    const elementTypeLabel = element.type === 'readModel' ? 'read-model' : element.type;
     if (incomingFlows.length === 0) {
         if (format === 'json') {
             outputJson({
@@ -367,14 +558,22 @@ export function showModelCompleteness(model, format) {
     const incompleteFlows = [];
     let completeCount = 0;
     let totalCount = 0;
+    // For read models, we use union completeness - track which canonical groups we've processed
+    const processedReadModelGroups = new Set();
+    const incompleteReadModels = [];
+    let readModelCompleteCount = 0;
+    let readModelTotalCount = 0;
     for (const flow of allFlows) {
+        // Skip EventToReadModel flows - we handle read models separately with union logic
+        if (flow.flowType === 'EventToReadModel') {
+            continue;
+        }
         // Get target element info
         let targetName = 'Unknown';
         let targetType = 'unknown';
         let targetFields = [];
         const targetCmd = model.commands.get(flow.targetId);
         const targetEvt = model.events.get(flow.targetId);
-        const targetRm = model.readModels.get(flow.targetId);
         const targetScr = model.screens.get(flow.targetId);
         const targetProc = model.processors.get(flow.targetId);
         if (targetCmd) {
@@ -387,11 +586,6 @@ export function showModelCompleteness(model, format) {
             targetType = 'event';
             targetFields = targetEvt.fields;
         }
-        else if (targetRm) {
-            targetName = targetRm.name;
-            targetType = 'read-model';
-            targetFields = targetRm.fields;
-        }
         else if (targetScr) {
             targetName = targetScr.name;
             targetType = 'screen';
@@ -423,13 +617,51 @@ export function showModelCompleteness(model, format) {
             });
         }
     }
+    // Process read models with union completeness
+    // Group read models by canonicalId (or use id if no canonicalId)
+    for (const rm of model.readModels.values()) {
+        const groupKey = rm.canonicalId ?? rm.id;
+        // Skip if we've already processed this canonical group
+        if (processedReadModelGroups.has(groupKey)) {
+            continue;
+        }
+        processedReadModelGroups.add(groupKey);
+        // Check if this read model has any incoming EventToReadModel flows
+        let targetNodeIds;
+        if (rm.canonicalId) {
+            targetNodeIds = [...model.readModels.values()]
+                .filter(r => r.canonicalId === rm.canonicalId)
+                .map(r => r.id);
+        }
+        else {
+            targetNodeIds = [rm.id];
+        }
+        const hasIncomingFlows = allFlows.some(f => targetNodeIds.includes(f.targetId) && f.flowType === 'EventToReadModel');
+        if (!hasIncomingFlows) {
+            // No incoming flows - skip this read model
+            continue;
+        }
+        readModelTotalCount++;
+        const unionResult = calculateReadModelUnionCompleteness(model, rm.id, rm.fields, rm.canonicalId);
+        if (unionResult.isComplete) {
+            readModelCompleteCount++;
+        }
+        else {
+            incompleteReadModels.push({
+                name: rm.name,
+                untraceableFields: unionResult.untraceableFields,
+                sourceEvents: unionResult.sourceEvents,
+            });
+        }
+    }
     const incompleteCount = totalCount - completeCount;
+    const readModelIncompleteCount = readModelTotalCount - readModelCompleteCount;
     if (format === 'json') {
         outputJson({
             summary: {
-                complete: completeCount,
-                incomplete: incompleteCount,
-                total: totalCount
+                complete: completeCount + readModelCompleteCount,
+                incomplete: incompleteCount + readModelIncompleteCount,
+                total: totalCount + readModelTotalCount
             },
             incompleteFlows: incompleteFlows.map(item => ({
                 from: item.sourceName,
@@ -437,12 +669,19 @@ export function showModelCompleteness(model, format) {
                 targetType: item.targetType,
                 flowType: item.flow.flowType,
                 unsatisfiedFields: item.unsatisfiedFields
-            }))
+            })),
+            ...(incompleteReadModels.length > 0 ? {
+                incompleteReadModels: incompleteReadModels.map(item => ({
+                    name: item.name,
+                    untraceableFields: item.untraceableFields,
+                    sourceEvents: item.sourceEvents
+                }))
+            } : {})
         });
         return;
     }
     console.log('<model-completeness>');
-    console.log(`  <summary complete="${completeCount}" incomplete="${incompleteCount}" total="${totalCount}"/>`);
+    console.log(`  <summary complete="${completeCount + readModelCompleteCount}" incomplete="${incompleteCount + readModelIncompleteCount}" total="${totalCount + readModelTotalCount}"/>`);
     if (incompleteFlows.length > 0) {
         console.log('  <incomplete-flows>');
         for (const item of incompleteFlows) {
@@ -458,5 +697,23 @@ export function showModelCompleteness(model, format) {
         }
         console.log('  </incomplete-flows>');
     }
+    if (incompleteReadModels.length > 0) {
+        console.log('  <incomplete-read-models>');
+        for (const item of incompleteReadModels) {
+            console.log(`    <read-model name="${escapeXml(item.name)}">`);
+            console.log('      <untraceable-fields>');
+            for (const fieldName of item.untraceableFields) {
+                console.log(`        <field name="${escapeXml(fieldName)}"/>`);
+            }
+            console.log('      </untraceable-fields>');
+            console.log('      <source-events>');
+            for (const eventName of item.sourceEvents) {
+                console.log(`        <event name="${escapeXml(eventName)}"/>`);
+            }
+            console.log('      </source-events>');
+            console.log('    </read-model>');
+        }
+        console.log('  </incomplete-read-models>');
+    }
     console.log('</model-completeness>');
 }

package/package.json

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