eventmodeler 0.2.1 → 0.2.4

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

@@ -0,0 +1,217 @@
+import { appendEvent } from '../../lib/file-loader.js';
+import { AUTOMATION_SLICE, SLICE_GAP, calculateSlicePosition, validateSliceNameUnique, inferFieldMappings, parseFieldsFromXml, getSlicesToShift, fieldInputToField, } from '../../lib/slice-utils.js';
+function getAttr(attrs, name) {
+    const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
+    return match ? match[1] : undefined;
+}
+function parseXmlInput(xml) {
+    // Parse <automation-slice name="..." after="..." before="...">
+    const sliceMatch = xml.match(/<automation-slice([^>]*)>/);
+    if (!sliceMatch) {
+        throw new Error('Invalid XML: missing <automation-slice> tag');
+    }
+    const sliceName = getAttr(sliceMatch[1], 'name');
+    if (!sliceName) {
+        throw new Error('Invalid XML: automation-slice must have a name attribute');
+    }
+    const after = getAttr(sliceMatch[1], 'after');
+    const before = getAttr(sliceMatch[1], 'before');
+    // Parse processor (no fields)
+    const processorMatch = xml.match(/<processor([^>]*?)(?:\/>|>([\s\S]*?)<\/processor>)/);
+    if (!processorMatch) {
+        throw new Error('Invalid XML: missing <processor> element');
+    }
+    const processorName = getAttr(processorMatch[1], 'name');
+    if (!processorName) {
+        throw new Error('Invalid XML: processor must have a name attribute');
+    }
+    // Parse command
+    const commandMatch = xml.match(/<command([^>]*)>([\s\S]*?)<\/command>/);
+    if (!commandMatch) {
+        throw new Error('Invalid XML: missing <command> element');
+    }
+    const commandName = getAttr(commandMatch[1], 'name');
+    if (!commandName) {
+        throw new Error('Invalid XML: command must have a name attribute');
+    }
+    const commandFields = parseFieldsFromXml(commandMatch[2]);
+    // Parse event
+    const eventMatch = xml.match(/<event([^>]*)>([\s\S]*?)<\/event>/);
+    if (!eventMatch) {
+        throw new Error('Invalid XML: missing <event> element');
+    }
+    const eventName = getAttr(eventMatch[1], 'name');
+    if (!eventName) {
+        throw new Error('Invalid XML: event must have a name attribute');
+    }
+    const eventFields = parseFieldsFromXml(eventMatch[2]);
+    return {
+        sliceName,
+        after,
+        before,
+        processor: { name: processorName },
+        command: { name: commandName, fields: commandFields },
+        event: { name: eventName, fields: eventFields },
+    };
+}
+export function createAutomationSlice(model, filePath, xmlInput) {
+    // Parse input
+    let input;
+    try {
+        input = parseXmlInput(xmlInput);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Validate slice name is unique
+    try {
+        validateSliceNameUnique(model, input.sliceName);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Calculate position
+    let slicePosition;
+    try {
+        slicePosition = calculateSlicePosition(model, AUTOMATION_SLICE.width, {
+            after: input.after,
+            before: input.before,
+        });
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Handle "before" positioning - shift existing slices
+    if (input.before) {
+        const shiftAmount = AUTOMATION_SLICE.width + SLICE_GAP;
+        const toShift = getSlicesToShift(model, slicePosition.x, shiftAmount);
+        for (const { sliceId, newX, currentY } of toShift) {
+            appendEvent(filePath, {
+                type: 'SliceMoved',
+                sliceId,
+                position: { x: newX, y: currentY },
+                timestamp: Date.now(),
+            });
+        }
+    }
+    // Generate IDs
+    const sliceId = crypto.randomUUID();
+    const processorId = crypto.randomUUID();
+    const commandId = crypto.randomUUID();
+    const eventId = crypto.randomUUID();
+    const processorToCommandFlowId = crypto.randomUUID();
+    const commandToEventFlowId = crypto.randomUUID();
+    // Convert field inputs to fields with IDs
+    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)
+    const commandToEventMappings = inferFieldMappings(commandFields, eventFields);
+    // Calculate absolute positions for components within the slice
+    const processorPosition = {
+        x: slicePosition.x + AUTOMATION_SLICE.processor.offsetX,
+        y: slicePosition.y + AUTOMATION_SLICE.processor.offsetY,
+    };
+    const commandPosition = {
+        x: slicePosition.x + AUTOMATION_SLICE.command.offsetX,
+        y: slicePosition.y + AUTOMATION_SLICE.command.offsetY,
+    };
+    const eventPosition = {
+        x: slicePosition.x + AUTOMATION_SLICE.event.offsetX,
+        y: slicePosition.y + AUTOMATION_SLICE.event.offsetY,
+    };
+    // Emit atomic events in sequence
+    // 1. Create the slice
+    appendEvent(filePath, {
+        type: 'SlicePlaced',
+        sliceId,
+        name: input.sliceName,
+        position: slicePosition,
+        size: { width: AUTOMATION_SLICE.width, height: AUTOMATION_SLICE.height },
+        timestamp: Date.now(),
+    });
+    // 2. Create the processor
+    appendEvent(filePath, {
+        type: 'ProcessorPlaced',
+        processorId,
+        name: input.processor.name,
+        position: processorPosition,
+        width: AUTOMATION_SLICE.processor.width,
+        height: AUTOMATION_SLICE.processor.height,
+        timestamp: Date.now(),
+    });
+    // 3. Create the command
+    appendEvent(filePath, {
+        type: 'CommandStickyPlaced',
+        commandStickyId: commandId,
+        name: input.command.name,
+        position: commandPosition,
+        width: AUTOMATION_SLICE.command.width,
+        height: AUTOMATION_SLICE.command.height,
+        timestamp: Date.now(),
+    });
+    // 4. Add command fields
+    for (const field of commandFields) {
+        appendEvent(filePath, {
+            type: 'CommandFieldAdded',
+            commandStickyId: commandId,
+            field,
+            timestamp: Date.now(),
+        });
+    }
+    // 5. Create the event
+    appendEvent(filePath, {
+        type: 'EventStickyPlaced',
+        eventStickyId: eventId,
+        name: input.event.name,
+        position: eventPosition,
+        width: AUTOMATION_SLICE.event.width,
+        height: AUTOMATION_SLICE.event.height,
+        timestamp: Date.now(),
+    });
+    // 6. Add event fields
+    for (const field of eventFields) {
+        appendEvent(filePath, {
+            type: 'EventFieldAdded',
+            eventStickyId: eventId,
+            field,
+            timestamp: Date.now(),
+        });
+    }
+    // 7. Create processor -> command flow
+    appendEvent(filePath, {
+        type: 'ProcessorToCommandFlowSpecified',
+        flowId: processorToCommandFlowId,
+        processorId,
+        commandStickyId: commandId,
+        sourceHandle: 'bottom-source',
+        targetHandle: 'top-target',
+        timestamp: Date.now(),
+    });
+    // 8. Create command -> event flow
+    appendEvent(filePath, {
+        type: 'CommandToEventFlowSpecified',
+        flowId: commandToEventFlowId,
+        commandStickyId: commandId,
+        eventStickyId: eventId,
+        sourceHandle: 'bottom-source',
+        targetHandle: 'top-target',
+        timestamp: Date.now(),
+    });
+    // 9. Add command -> event field mappings
+    if (commandToEventMappings.length > 0) {
+        appendEvent(filePath, {
+            type: 'FieldMappingSpecified',
+            flowId: commandToEventFlowId,
+            mappings: commandToEventMappings,
+            timestamp: Date.now(),
+        });
+    }
+    console.log(`Created automation slice "${input.sliceName}"`);
+    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(`  Command -> Event mappings: ${commandToEventMappings.length}`);
+}

package/dist/slices/create-flow/index.d.ts

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

package/dist/slices/create-flow/index.js

@@ -0,0 +1,177 @@
+import { appendEvent } from '../../lib/file-loader.js';
+import { findElement } from '../../lib/element-lookup.js';
+function findSource(model, name) {
+    // Try events first
+    const eventResult = findElement(model.events, name);
+    if (eventResult.success) {
+        return { type: 'event', element: eventResult.element };
+    }
+    // Try read models
+    const readModelResult = findElement(model.readModels, name);
+    if (readModelResult.success) {
+        return { type: 'readModel', element: readModelResult.element };
+    }
+    return null;
+}
+function findTarget(model, name) {
+    // Try read models first
+    const readModelResult = findElement(model.readModels, name);
+    if (readModelResult.success) {
+        return { type: 'readModel', element: readModelResult.element };
+    }
+    // Try screens
+    const screenResult = findElement(model.screens, name);
+    if (screenResult.success) {
+        return { type: 'screen', element: screenResult.element };
+    }
+    // Try processors
+    const processorResult = findElement(model.processors, name);
+    if (processorResult.success) {
+        return { type: 'processor', element: processorResult.element };
+    }
+    return null;
+}
+function listAvailableSources(model) {
+    const sources = [];
+    for (const event of model.events.values()) {
+        sources.push(`  - Event: "${event.name}"`);
+    }
+    for (const rm of model.readModels.values()) {
+        sources.push(`  - ReadModel: "${rm.name}"`);
+    }
+    return sources;
+}
+function listAvailableTargets(model) {
+    const targets = [];
+    for (const rm of model.readModels.values()) {
+        targets.push(`  - ReadModel: "${rm.name}"`);
+    }
+    for (const screen of model.screens.values()) {
+        targets.push(`  - Screen: "${screen.name}"`);
+    }
+    for (const proc of model.processors.values()) {
+        targets.push(`  - Processor: "${proc.name}"`);
+    }
+    return targets;
+}
+function flowExists(model, sourceId, targetId) {
+    for (const flow of model.flows.values()) {
+        if (flow.sourceId === sourceId && flow.targetId === targetId) {
+            return true;
+        }
+    }
+    return false;
+}
+export function createFlow(model, filePath, fromName, toName) {
+    // Find source element
+    const source = findSource(model, fromName);
+    if (!source) {
+        console.error(`Error: Source not found: "${fromName}"`);
+        console.error('Valid sources are events or read models.');
+        const available = listAvailableSources(model);
+        if (available.length > 0) {
+            console.error('Available sources:');
+            available.forEach(s => console.error(s));
+        }
+        process.exit(1);
+    }
+    // Find target element
+    const target = findTarget(model, toName);
+    if (!target) {
+        console.error(`Error: Target not found: "${toName}"`);
+        console.error('Valid targets are read models, screens, or processors.');
+        const available = listAvailableTargets(model);
+        if (available.length > 0) {
+            console.error('Available targets:');
+            available.forEach(t => console.error(t));
+        }
+        process.exit(1);
+    }
+    // Validate the flow combination
+    const flowId = crypto.randomUUID();
+    let event;
+    if (source.type === 'event' && target.type === 'readModel') {
+        // Event → ReadModel (event top → read model bottom)
+        if (flowExists(model, source.element.id, target.element.id)) {
+            console.error(`Error: Flow already exists from "${source.element.name}" to "${target.element.name}"`);
+            process.exit(1);
+        }
+        event = {
+            type: 'EventToReadModelFlowSpecified',
+            flowId,
+            eventStickyId: source.element.id,
+            readModelStickyId: target.element.id,
+            sourceHandle: 'top-source',
+            targetHandle: 'bottom-target',
+            timestamp: Date.now(),
+        };
+        appendEvent(filePath, event);
+        console.log(`Created flow: Event "${source.element.name}" → ReadModel "${target.element.name}"`);
+    }
+    else if (source.type === 'readModel' && target.type === 'screen') {
+        // ReadModel → Screen (read model top → screen bottom)
+        if (flowExists(model, source.element.id, target.element.id)) {
+            console.error(`Error: Flow already exists from "${source.element.name}" to "${target.element.name}"`);
+            process.exit(1);
+        }
+        event = {
+            type: 'ReadModelToScreenFlowSpecified',
+            flowId,
+            readModelStickyId: source.element.id,
+            screenId: target.element.id,
+            sourceHandle: 'top-source',
+            targetHandle: 'bottom-target',
+            timestamp: Date.now(),
+        };
+        appendEvent(filePath, event);
+        console.log(`Created flow: ReadModel "${source.element.name}" → Screen "${target.element.name}"`);
+    }
+    else if (source.type === 'readModel' && target.type === 'processor') {
+        // ReadModel → Processor (read model top → processor bottom)
+        if (flowExists(model, source.element.id, target.element.id)) {
+            console.error(`Error: Flow already exists from "${source.element.name}" to "${target.element.name}"`);
+            process.exit(1);
+        }
+        event = {
+            type: 'ReadModelToProcessorFlowSpecified',
+            flowId,
+            readModelStickyId: source.element.id,
+            processorId: target.element.id,
+            sourceHandle: 'top-source',
+            targetHandle: 'bottom-target',
+            timestamp: Date.now(),
+        };
+        appendEvent(filePath, event);
+        console.log(`Created flow: ReadModel "${source.element.name}" → Processor "${target.element.name}"`);
+    }
+    else if (source.type === 'event' && target.type === 'screen') {
+        console.error('Error: Cannot create flow directly from Event to Screen.');
+        console.error('Events flow to ReadModels, which then flow to Screens.');
+        console.error('Create a ReadModel first, then:');
+        console.error(`  1. eventmodeler create flow --from "${source.element.name}" --to "<ReadModelName>"`);
+        console.error(`  2. eventmodeler create flow --from "<ReadModelName>" --to "${target.element.name}"`);
+        process.exit(1);
+    }
+    else if (source.type === 'event' && target.type === 'processor') {
+        console.error('Error: Cannot create flow directly from Event to Processor.');
+        console.error('Events flow to ReadModels, which then flow to Processors.');
+        console.error('Create a ReadModel first, then:');
+        console.error(`  1. eventmodeler create flow --from "${source.element.name}" --to "<ReadModelName>"`);
+        console.error(`  2. eventmodeler create flow --from "<ReadModelName>" --to "${target.element.name}"`);
+        process.exit(1);
+    }
+    else if (source.type === 'readModel' && target.type === 'readModel') {
+        console.error('Error: Cannot create flow from ReadModel to ReadModel.');
+        console.error('ReadModels receive data from Events and provide data to Screens or Processors.');
+        process.exit(1);
+    }
+    else {
+        console.error(`Error: Invalid flow combination: ${source.type} → ${target.type}`);
+        console.error('Valid combinations:');
+        console.error('  - Event → ReadModel');
+        console.error('  - ReadModel → Screen');
+        console.error('  - ReadModel → Processor');
+        process.exit(1);
+    }
+    console.log(`Use 'eventmodeler map fields --flow "${fromName}→${toName}"' to set field mappings.`);
+}

package/dist/slices/create-state-change-slice/index.d.ts

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

package/dist/slices/create-state-change-slice/index.js

@@ -0,0 +1,239 @@
+import { appendEvent } from '../../lib/file-loader.js';
+import { STATE_CHANGE_SLICE, SLICE_GAP, calculateSlicePosition, validateSliceNameUnique, inferFieldMappings, parseFieldsFromXml, getSlicesToShift, fieldInputToField, } from '../../lib/slice-utils.js';
+function getAttr(attrs, name) {
+    const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
+    return match ? match[1] : undefined;
+}
+function parseXmlInput(xml) {
+    // Parse <state-change-slice name="..." after="..." before="...">
+    const sliceMatch = xml.match(/<state-change-slice([^>]*)>/);
+    if (!sliceMatch) {
+        throw new Error('Invalid XML: missing <state-change-slice> tag');
+    }
+    const sliceName = getAttr(sliceMatch[1], 'name');
+    if (!sliceName) {
+        throw new Error('Invalid XML: state-change-slice must have a name attribute');
+    }
+    const after = getAttr(sliceMatch[1], 'after');
+    const before = getAttr(sliceMatch[1], 'before');
+    // Parse screen
+    const screenMatch = xml.match(/<screen([^>]*)>([\s\S]*?)<\/screen>/);
+    if (!screenMatch) {
+        throw new Error('Invalid XML: missing <screen> element');
+    }
+    const screenName = getAttr(screenMatch[1], 'name');
+    if (!screenName) {
+        throw new Error('Invalid XML: screen must have a name attribute');
+    }
+    const screenFields = parseFieldsFromXml(screenMatch[2]);
+    // Parse command
+    const commandMatch = xml.match(/<command([^>]*)>([\s\S]*?)<\/command>/);
+    if (!commandMatch) {
+        throw new Error('Invalid XML: missing <command> element');
+    }
+    const commandName = getAttr(commandMatch[1], 'name');
+    if (!commandName) {
+        throw new Error('Invalid XML: command must have a name attribute');
+    }
+    const commandFields = parseFieldsFromXml(commandMatch[2]);
+    // Parse event
+    const eventMatch = xml.match(/<event([^>]*)>([\s\S]*?)<\/event>/);
+    if (!eventMatch) {
+        throw new Error('Invalid XML: missing <event> element');
+    }
+    const eventName = getAttr(eventMatch[1], 'name');
+    if (!eventName) {
+        throw new Error('Invalid XML: event must have a name attribute');
+    }
+    const eventFields = parseFieldsFromXml(eventMatch[2]);
+    return {
+        sliceName,
+        after,
+        before,
+        screen: { name: screenName, fields: screenFields },
+        command: { name: commandName, fields: commandFields },
+        event: { name: eventName, fields: eventFields },
+    };
+}
+export function createStateChangeSlice(model, filePath, xmlInput) {
+    // Parse input
+    let input;
+    try {
+        input = parseXmlInput(xmlInput);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Validate slice name is unique
+    try {
+        validateSliceNameUnique(model, input.sliceName);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Calculate position
+    let slicePosition;
+    try {
+        slicePosition = calculateSlicePosition(model, STATE_CHANGE_SLICE.width, {
+            after: input.after,
+            before: input.before,
+        });
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Handle "before" positioning - shift existing slices
+    if (input.before) {
+        const shiftAmount = STATE_CHANGE_SLICE.width + SLICE_GAP;
+        const toShift = getSlicesToShift(model, slicePosition.x, shiftAmount);
+        for (const { sliceId, newX, currentY } of toShift) {
+            appendEvent(filePath, {
+                type: 'SliceMoved',
+                sliceId,
+                position: { x: newX, y: currentY },
+                timestamp: Date.now(),
+            });
+        }
+    }
+    // Generate IDs
+    const sliceId = crypto.randomUUID();
+    const screenId = crypto.randomUUID();
+    const commandId = crypto.randomUUID();
+    const eventId = crypto.randomUUID();
+    const screenToCommandFlowId = crypto.randomUUID();
+    const commandToEventFlowId = crypto.randomUUID();
+    // Convert field inputs to fields with IDs
+    const screenFields = input.screen.fields.map(fieldInputToField);
+    const commandFields = input.command.fields.map(fieldInputToField);
+    const eventFields = input.event.fields.map(fieldInputToField);
+    // Infer field mappings
+    const screenToCommandMappings = inferFieldMappings(screenFields, commandFields);
+    const commandToEventMappings = inferFieldMappings(commandFields, eventFields);
+    // Calculate absolute positions for components within the slice
+    const screenPosition = {
+        x: slicePosition.x + STATE_CHANGE_SLICE.screen.offsetX,
+        y: slicePosition.y + STATE_CHANGE_SLICE.screen.offsetY,
+    };
+    const commandPosition = {
+        x: slicePosition.x + STATE_CHANGE_SLICE.command.offsetX,
+        y: slicePosition.y + STATE_CHANGE_SLICE.command.offsetY,
+    };
+    const eventPosition = {
+        x: slicePosition.x + STATE_CHANGE_SLICE.event.offsetX,
+        y: slicePosition.y + STATE_CHANGE_SLICE.event.offsetY,
+    };
+    // Emit atomic events in sequence
+    // 1. Create the slice
+    appendEvent(filePath, {
+        type: 'SlicePlaced',
+        sliceId,
+        name: input.sliceName,
+        position: slicePosition,
+        size: { width: STATE_CHANGE_SLICE.width, height: STATE_CHANGE_SLICE.height },
+        timestamp: Date.now(),
+    });
+    // 2. Create the screen
+    appendEvent(filePath, {
+        type: 'ScreenPlaced',
+        screenId,
+        name: input.screen.name,
+        position: screenPosition,
+        width: STATE_CHANGE_SLICE.screen.width,
+        height: STATE_CHANGE_SLICE.screen.height,
+        timestamp: Date.now(),
+    });
+    // 3. Add screen fields
+    for (const field of screenFields) {
+        appendEvent(filePath, {
+            type: 'ScreenFieldAdded',
+            screenId,
+            field,
+            timestamp: Date.now(),
+        });
+    }
+    // 4. Create the command
+    appendEvent(filePath, {
+        type: 'CommandStickyPlaced',
+        commandStickyId: commandId,
+        name: input.command.name,
+        position: commandPosition,
+        width: STATE_CHANGE_SLICE.command.width,
+        height: STATE_CHANGE_SLICE.command.height,
+        timestamp: Date.now(),
+    });
+    // 5. Add command fields
+    for (const field of commandFields) {
+        appendEvent(filePath, {
+            type: 'CommandFieldAdded',
+            commandStickyId: commandId,
+            field,
+            timestamp: Date.now(),
+        });
+    }
+    // 6. Create the event
+    appendEvent(filePath, {
+        type: 'EventStickyPlaced',
+        eventStickyId: eventId,
+        name: input.event.name,
+        position: eventPosition,
+        width: STATE_CHANGE_SLICE.event.width,
+        height: STATE_CHANGE_SLICE.event.height,
+        timestamp: Date.now(),
+    });
+    // 7. Add event fields
+    for (const field of eventFields) {
+        appendEvent(filePath, {
+            type: 'EventFieldAdded',
+            eventStickyId: eventId,
+            field,
+            timestamp: Date.now(),
+        });
+    }
+    // 8. Create screen -> command flow
+    appendEvent(filePath, {
+        type: 'ScreenToCommandFlowSpecified',
+        flowId: screenToCommandFlowId,
+        screenId,
+        commandStickyId: commandId,
+        sourceHandle: 'bottom-source',
+        targetHandle: 'top-target',
+        timestamp: Date.now(),
+    });
+    // 9. Add screen -> command field mappings
+    if (screenToCommandMappings.length > 0) {
+        appendEvent(filePath, {
+            type: 'FieldMappingSpecified',
+            flowId: screenToCommandFlowId,
+            mappings: screenToCommandMappings,
+            timestamp: Date.now(),
+        });
+    }
+    // 10. Create command -> event flow
+    appendEvent(filePath, {
+        type: 'CommandToEventFlowSpecified',
+        flowId: commandToEventFlowId,
+        commandStickyId: commandId,
+        eventStickyId: eventId,
+        sourceHandle: 'bottom-source',
+        targetHandle: 'top-target',
+        timestamp: Date.now(),
+    });
+    // 11. Add command -> event field mappings
+    if (commandToEventMappings.length > 0) {
+        appendEvent(filePath, {
+            type: 'FieldMappingSpecified',
+            flowId: commandToEventFlowId,
+            mappings: commandToEventMappings,
+            timestamp: Date.now(),
+        });
+    }
+    console.log(`Created state-change slice "${input.sliceName}"`);
+    console.log(`  Screen: ${input.screen.name} (${screenFields.length} fields)`);
+    console.log(`  Command: ${input.command.name} (${commandFields.length} fields)`);
+    console.log(`  Event: ${input.event.name} (${eventFields.length} fields)`);
+    console.log(`  Screen -> Command mappings: ${screenToCommandMappings.length}`);
+    console.log(`  Command -> Event mappings: ${commandToEventMappings.length}`);
+}

package/dist/slices/create-state-view-slice/index.d.ts

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