eventmodeler 0.5.0 → 0.6.0

package/dist/projection.js

@@ -1,828 +0,0 @@
-export function createEmptyModel() {
-    return {
-        modelId: '',
-        name: '',
-        commands: new Map(),
-        events: new Map(),
-        readModels: new Map(),
-        screens: new Map(),
-        processors: new Map(),
-        slices: new Map(),
-        chapters: new Map(),
-        scenarios: new Map(),
-        flows: new Map(),
-        aggregates: new Map(),
-        actors: new Map(),
-    };
-}
-export function projectEvents(rawEvents) {
-    const model = createEmptyModel();
-    for (const event of rawEvents) {
-        applyEvent(model, event);
-    }
-    return model;
-}
-function applyEvent(model, event) {
-    const d = event.data;
-    switch (event.type) {
-        // Model creation
-        case 'EventModelCreated':
-            model.modelId = d.modelId;
-            model.name = d.name;
-            break;
-        // Command sticky events
-        case 'CommandStickyPlaced':
-            model.commands.set(d.commandStickyId, {
-                id: d.commandStickyId,
-                name: d.name,
-                fields: [],
-                position: d.position,
-                width: d.width,
-                height: d.height,
-            });
-            break;
-        case 'CommandStickyMoved': {
-            const cmd = model.commands.get(d.commandStickyId);
-            if (cmd)
-                cmd.position = d.position;
-            break;
-        }
-        case 'CommandStickyRemoved':
-            model.commands.delete(d.commandStickyId);
-            break;
-        case 'CommandRenamed': {
-            const cmd = model.commands.get(d.commandStickyId);
-            if (cmd)
-                cmd.name = d.name;
-            break;
-        }
-        case 'CommandFieldAdded': {
-            const cmd = model.commands.get(d.commandStickyId);
-            if (cmd)
-                cmd.fields.push(d.field);
-            break;
-        }
-        case 'CommandFieldRemoved': {
-            const cmd = model.commands.get(d.commandStickyId);
-            if (cmd)
-                cmd.fields = cmd.fields.filter(f => f.id !== d.fieldId);
-            break;
-        }
-        case 'CommandFieldAdjusted': {
-            const cmd = model.commands.get(d.commandStickyId);
-            if (cmd) {
-                const idx = cmd.fields.findIndex(f => f.id === d.fieldId);
-                if (idx !== -1) {
-                    cmd.fields[idx] = { ...d.field, id: d.fieldId };
-                }
-            }
-            break;
-        }
-        // Event sticky events
-        case 'EventStickyPlaced':
-            model.events.set(d.eventStickyId, {
-                id: d.eventStickyId,
-                name: d.name,
-                fields: [],
-                position: d.position,
-                width: d.width,
-                height: d.height,
-            });
-            break;
-        case 'EventStickyMoved': {
-            const evt = model.events.get(d.eventStickyId);
-            if (evt)
-                evt.position = d.position;
-            break;
-        }
-        case 'EventStickyRemoved':
-            model.events.delete(d.eventStickyId);
-            break;
-        case 'EventRenamed': {
-            const evt = model.events.get(d.eventStickyId);
-            if (evt)
-                evt.name = d.name;
-            break;
-        }
-        case 'EventFieldAdded': {
-            const evt = model.events.get(d.eventStickyId);
-            if (evt) {
-                evt.fields.push(d.field);
-                // Sync field to all linked copies with the same canonicalId
-                if (evt.canonicalId) {
-                    for (const otherEvt of model.events.values()) {
-                        if (otherEvt.id !== evt.id && otherEvt.canonicalId === evt.canonicalId) {
-                            otherEvt.fields.push(d.field);
-                        }
-                    }
-                }
-            }
-            break;
-        }
-        case 'EventFieldRemoved': {
-            const evt = model.events.get(d.eventStickyId);
-            if (evt) {
-                evt.fields = evt.fields.filter(f => f.id !== d.fieldId);
-                // Sync removal to all linked copies with the same canonicalId
-                if (evt.canonicalId) {
-                    for (const otherEvt of model.events.values()) {
-                        if (otherEvt.id !== evt.id && otherEvt.canonicalId === evt.canonicalId) {
-                            otherEvt.fields = otherEvt.fields.filter(f => f.id !== d.fieldId);
-                        }
-                    }
-                }
-            }
-            break;
-        }
-        case 'EventFieldAdjusted': {
-            const evt = model.events.get(d.eventStickyId);
-            if (evt) {
-                const idx = evt.fields.findIndex(f => f.id === d.fieldId);
-                if (idx !== -1) {
-                    const adjustedField = { ...d.field, id: d.fieldId };
-                    evt.fields[idx] = adjustedField;
-                    // Sync adjustment to all linked copies with the same canonicalId
-                    if (evt.canonicalId) {
-                        for (const otherEvt of model.events.values()) {
-                            if (otherEvt.id !== evt.id && otherEvt.canonicalId === evt.canonicalId) {
-                                const otherIdx = otherEvt.fields.findIndex(f => f.id === d.fieldId);
-                                if (otherIdx !== -1) {
-                                    otherEvt.fields[otherIdx] = adjustedField;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            break;
-        }
-        case 'EventStickyLinkedCopyCreated': {
-            const source = model.events.get(d.sourceEventStickyId);
-            model.events.set(d.eventStickyId, {
-                id: d.eventStickyId,
-                name: source?.name ?? '',
-                fields: source?.fields ? [...source.fields] : [],
-                position: d.position,
-                width: d.width,
-                height: d.height,
-                canonicalId: d.canonicalId,
-                originalNodeId: d.sourceEventStickyId,
-            });
-            // Also set canonical on source if not already set
-            if (source && !source.canonicalId) {
-                source.canonicalId = d.canonicalId;
-            }
-            break;
-        }
-        case 'EventStickyCanonicalGroupRemoved': {
-            const canonicalId = d.canonicalId;
-            for (const [id, evt] of model.events) {
-                if (evt.canonicalId === canonicalId) {
-                    model.events.delete(id);
-                }
-            }
-            break;
-        }
-        // Read model sticky events
-        case 'ReadModelStickyPlaced':
-            model.readModels.set(d.readModelStickyId, {
-                id: d.readModelStickyId,
-                name: d.name,
-                fields: [],
-                position: d.position,
-                width: d.width,
-                height: d.height,
-            });
-            break;
-        case 'ReadModelStickyMoved': {
-            const rm = model.readModels.get(d.readModelStickyId);
-            if (rm)
-                rm.position = d.position;
-            break;
-        }
-        case 'ReadModelStickyRemoved':
-            model.readModels.delete(d.readModelStickyId);
-            break;
-        case 'ReadModelRenamed': {
-            const rm = model.readModels.get(d.readModelStickyId);
-            if (rm)
-                rm.name = d.name;
-            break;
-        }
-        case 'ReadModelFieldAdded': {
-            const rm = model.readModels.get(d.readModelStickyId);
-            if (rm) {
-                rm.fields.push(d.field);
-                // Sync field to all linked copies with the same canonicalId
-                if (rm.canonicalId) {
-                    for (const otherRm of model.readModels.values()) {
-                        if (otherRm.id !== rm.id && otherRm.canonicalId === rm.canonicalId) {
-                            otherRm.fields.push(d.field);
-                        }
-                    }
-                }
-            }
-            break;
-        }
-        case 'ReadModelFieldRemoved': {
-            const rm = model.readModels.get(d.readModelStickyId);
-            if (rm) {
-                rm.fields = rm.fields.filter(f => f.id !== d.fieldId);
-                // Sync removal to all linked copies with the same canonicalId
-                if (rm.canonicalId) {
-                    for (const otherRm of model.readModels.values()) {
-                        if (otherRm.id !== rm.id && otherRm.canonicalId === rm.canonicalId) {
-                            otherRm.fields = otherRm.fields.filter(f => f.id !== d.fieldId);
-                        }
-                    }
-                }
-            }
-            break;
-        }
-        case 'ReadModelFieldAdjusted': {
-            const rm = model.readModels.get(d.readModelStickyId);
-            if (rm) {
-                const idx = rm.fields.findIndex(f => f.id === d.fieldId);
-                if (idx !== -1) {
-                    const adjustedField = { ...d.field, id: d.fieldId };
-                    rm.fields[idx] = adjustedField;
-                    // Sync adjustment to all linked copies with the same canonicalId
-                    if (rm.canonicalId) {
-                        for (const otherRm of model.readModels.values()) {
-                            if (otherRm.id !== rm.id && otherRm.canonicalId === rm.canonicalId) {
-                                const otherIdx = otherRm.fields.findIndex(f => f.id === d.fieldId);
-                                if (otherIdx !== -1) {
-                                    otherRm.fields[otherIdx] = adjustedField;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            break;
-        }
-        case 'ReadModelStickyLinkedCopyCreated': {
-            const source = model.readModels.get(d.sourceReadModelStickyId);
-            model.readModels.set(d.readModelStickyId, {
-                id: d.readModelStickyId,
-                name: source?.name ?? '',
-                fields: source?.fields ? [...source.fields] : [],
-                position: d.position,
-                width: d.width,
-                height: d.height,
-                canonicalId: d.canonicalId,
-                originalNodeId: d.sourceReadModelStickyId,
-            });
-            if (source && !source.canonicalId) {
-                source.canonicalId = d.canonicalId;
-            }
-            break;
-        }
-        case 'ReadModelStickyCanonicalGroupRemoved': {
-            const canonicalId = d.canonicalId;
-            for (const [id, rm] of model.readModels) {
-                if (rm.canonicalId === canonicalId) {
-                    model.readModels.delete(id);
-                }
-            }
-            break;
-        }
-        // Screen events
-        case 'ScreenPlaced':
-            model.screens.set(d.screenId, {
-                id: d.screenId,
-                name: d.name,
-                fields: [],
-                position: d.position,
-                width: d.width,
-                height: d.height,
-            });
-            break;
-        case 'ScreenMoved': {
-            const scr = model.screens.get(d.screenId);
-            if (scr)
-                scr.position = d.position;
-            break;
-        }
-        case 'ScreenRemoved':
-            model.screens.delete(d.screenId);
-            break;
-        case 'ScreenRenamed': {
-            const scr = model.screens.get(d.screenId);
-            if (scr)
-                scr.name = d.name;
-            break;
-        }
-        case 'ScreenFieldAdded': {
-            const scr = model.screens.get(d.screenId);
-            if (scr) {
-                scr.fields.push(d.field);
-                // Sync field to all linked copies with the same canonicalId
-                if (scr.canonicalId) {
-                    for (const otherScr of model.screens.values()) {
-                        if (otherScr.id !== scr.id && otherScr.canonicalId === scr.canonicalId) {
-                            otherScr.fields.push(d.field);
-                        }
-                    }
-                }
-            }
-            break;
-        }
-        case 'ScreenFieldRemoved': {
-            const scr = model.screens.get(d.screenId);
-            if (scr) {
-                scr.fields = scr.fields.filter(f => f.id !== d.fieldId);
-                // Sync removal to all linked copies with the same canonicalId
-                if (scr.canonicalId) {
-                    for (const otherScr of model.screens.values()) {
-                        if (otherScr.id !== scr.id && otherScr.canonicalId === scr.canonicalId) {
-                            otherScr.fields = otherScr.fields.filter(f => f.id !== d.fieldId);
-                        }
-                    }
-                }
-            }
-            break;
-        }
-        case 'ScreenFieldAdjusted': {
-            const scr = model.screens.get(d.screenId);
-            if (scr) {
-                const idx = scr.fields.findIndex(f => f.id === d.fieldId);
-                if (idx !== -1) {
-                    const adjustedField = { ...d.field, id: d.fieldId };
-                    scr.fields[idx] = adjustedField;
-                    // Sync adjustment to all linked copies with the same canonicalId
-                    if (scr.canonicalId) {
-                        for (const otherScr of model.screens.values()) {
-                            if (otherScr.id !== scr.id && otherScr.canonicalId === scr.canonicalId) {
-                                const otherIdx = otherScr.fields.findIndex(f => f.id === d.fieldId);
-                                if (otherIdx !== -1) {
-                                    otherScr.fields[otherIdx] = adjustedField;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            break;
-        }
-        case 'ScreenLinkedCopyCreated': {
-            const source = model.screens.get(d.sourceScreenId);
-            model.screens.set(d.screenId, {
-                id: d.screenId,
-                name: source?.name ?? '',
-                fields: source?.fields ? [...source.fields] : [],
-                position: d.position,
-                width: d.width,
-                height: d.height,
-                canonicalId: d.canonicalId,
-                originalNodeId: d.sourceScreenId,
-            });
-            if (source && !source.canonicalId) {
-                source.canonicalId = d.canonicalId;
-            }
-            break;
-        }
-        case 'ScreenCanonicalGroupRemoved': {
-            const canonicalId = d.canonicalId;
-            for (const [id, scr] of model.screens) {
-                if (scr.canonicalId === canonicalId) {
-                    model.screens.delete(id);
-                }
-            }
-            break;
-        }
-        // Processor events
-        case 'ProcessorPlaced':
-            model.processors.set(d.processorId, {
-                id: d.processorId,
-                name: d.name,
-                fields: [],
-                position: d.position,
-                width: d.width,
-                height: d.height,
-            });
-            break;
-        case 'ProcessorMoved': {
-            const proc = model.processors.get(d.processorId);
-            if (proc)
-                proc.position = d.position;
-            break;
-        }
-        case 'ProcessorRemoved':
-            model.processors.delete(d.processorId);
-            break;
-        case 'ProcessorRenamed': {
-            const proc = model.processors.get(d.processorId);
-            if (proc)
-                proc.name = d.name;
-            break;
-        }
-        case 'ProcessorFieldAdded': {
-            const proc = model.processors.get(d.processorId);
-            if (proc)
-                proc.fields.push(d.field);
-            break;
-        }
-        case 'ProcessorFieldRemoved': {
-            const proc = model.processors.get(d.processorId);
-            if (proc)
-                proc.fields = proc.fields.filter(f => f.id !== d.fieldId);
-            break;
-        }
-        case 'ProcessorFieldAdjusted': {
-            const proc = model.processors.get(d.processorId);
-            if (proc) {
-                const idx = proc.fields.findIndex(f => f.id === d.fieldId);
-                if (idx !== -1) {
-                    proc.fields[idx] = { ...d.field, id: d.fieldId };
-                }
-            }
-            break;
-        }
-        // Slice events
-        case 'SlicePlaced':
-            model.slices.set(d.sliceId, {
-                id: d.sliceId,
-                name: d.name,
-                status: 'created',
-                position: d.position,
-                size: d.size,
-                nodeIds: [],
-            });
-            break;
-        case 'SliceMoved': {
-            const slice = model.slices.get(d.sliceId);
-            if (slice)
-                slice.position = d.position;
-            break;
-        }
-        case 'SliceResized': {
-            const slice = model.slices.get(d.sliceId);
-            if (slice) {
-                slice.position = d.position;
-                slice.size = d.size;
-            }
-            break;
-        }
-        case 'SliceRemoved':
-            model.slices.delete(d.sliceId);
-            break;
-        case 'SliceRenamed': {
-            const slice = model.slices.get(d.sliceId);
-            if (slice)
-                slice.name = d.name;
-            break;
-        }
-        case 'SliceMarkedAsCreated': {
-            const slice = model.slices.get(d.sliceId);
-            if (slice)
-                slice.status = 'created';
-            break;
-        }
-        case 'SliceMarkedAsInProgress': {
-            const slice = model.slices.get(d.sliceId);
-            if (slice)
-                slice.status = 'in-progress';
-            break;
-        }
-        case 'SliceMarkedAsBlocked': {
-            const slice = model.slices.get(d.sliceId);
-            if (slice)
-                slice.status = 'blocked';
-            break;
-        }
-        case 'SliceMarkedAsDone': {
-            const slice = model.slices.get(d.sliceId);
-            if (slice)
-                slice.status = 'done';
-            break;
-        }
-        case 'SlicesWidthEqualized': {
-            const width = d.width;
-            for (const sliceId of d.sliceIds) {
-                const slice = model.slices.get(sliceId);
-                if (slice)
-                    slice.size.width = width;
-            }
-            break;
-        }
-        case 'SlicesHeightEqualized': {
-            const height = d.height;
-            const y = d.y;
-            for (const sliceId of d.sliceIds) {
-                const slice = model.slices.get(sliceId);
-                if (slice) {
-                    slice.size.height = height;
-                    slice.position.y = y;
-                }
-            }
-            break;
-        }
-        // Aggregate events
-        case 'AggregatePlaced':
-            model.aggregates.set(d.aggregateId, {
-                id: d.aggregateId,
-                name: d.name,
-                position: d.position,
-                size: d.size,
-                eventIds: [],
-                aggregateIdFieldName: d.aggregateIdFieldName,
-                aggregateIdFieldType: d.aggregateIdFieldType,
-            });
-            break;
-        case 'AggregateMoved': {
-            const aggregate = model.aggregates.get(d.aggregateId);
-            if (aggregate)
-                aggregate.position = d.position;
-            break;
-        }
-        case 'AggregateResized': {
-            const aggregate = model.aggregates.get(d.aggregateId);
-            if (aggregate) {
-                aggregate.position = d.position;
-                aggregate.size = d.size;
-            }
-            break;
-        }
-        case 'AggregateRemoved':
-            model.aggregates.delete(d.aggregateId);
-            break;
-        case 'AggregateRenamed': {
-            const aggregate = model.aggregates.get(d.aggregateId);
-            if (aggregate)
-                aggregate.name = d.name;
-            break;
-        }
-        case 'AggregateIdFieldSet': {
-            const aggregate = model.aggregates.get(d.aggregateId);
-            if (aggregate) {
-                aggregate.aggregateIdFieldName = d.aggregateIdFieldName;
-                aggregate.aggregateIdFieldType = d.aggregateIdFieldType;
-            }
-            break;
-        }
-        // Actor events
-        case 'ActorPlaced':
-            model.actors.set(d.actorId, {
-                id: d.actorId,
-                name: d.name,
-                position: d.position,
-                size: d.size,
-                screenIds: [],
-            });
-            break;
-        case 'ActorMoved': {
-            const actor = model.actors.get(d.actorId);
-            if (actor)
-                actor.position = d.position;
-            break;
-        }
-        case 'ActorResized': {
-            const actor = model.actors.get(d.actorId);
-            if (actor) {
-                actor.position = d.position;
-                actor.size = d.size;
-            }
-            break;
-        }
-        case 'ActorRemoved':
-            model.actors.delete(d.actorId);
-            break;
-        case 'ActorRenamed': {
-            const actor = model.actors.get(d.actorId);
-            if (actor)
-                actor.name = d.name;
-            break;
-        }
-        // Chapter events
-        case 'ChapterPlaced':
-            model.chapters.set(d.chapterId, {
-                id: d.chapterId,
-                name: d.name,
-                position: d.position,
-                size: d.size,
-            });
-            break;
-        case 'ChapterMoved': {
-            const chapter = model.chapters.get(d.chapterId);
-            if (chapter)
-                chapter.position = d.position;
-            break;
-        }
-        case 'ChapterResized': {
-            const chapter = model.chapters.get(d.chapterId);
-            if (chapter) {
-                chapter.position = d.position;
-                chapter.size = d.size;
-            }
-            break;
-        }
-        case 'ChapterRemoved':
-            model.chapters.delete(d.chapterId);
-            break;
-        case 'ChapterRenamed': {
-            const chapter = model.chapters.get(d.chapterId);
-            if (chapter)
-                chapter.name = d.name;
-            break;
-        }
-        // Flow events
-        case 'CommandToEventFlowSpecified':
-            model.flows.set(d.flowId, {
-                id: d.flowId,
-                flowType: 'CommandToEvent',
-                sourceId: d.commandStickyId,
-                targetId: d.eventStickyId,
-                fieldMappings: [],
-            });
-            break;
-        case 'EventToReadModelFlowSpecified':
-            model.flows.set(d.flowId, {
-                id: d.flowId,
-                flowType: 'EventToReadModel',
-                sourceId: d.eventStickyId,
-                targetId: d.readModelStickyId,
-                fieldMappings: [],
-            });
-            break;
-        case 'ReadModelToScreenFlowSpecified':
-            model.flows.set(d.flowId, {
-                id: d.flowId,
-                flowType: 'ReadModelToScreen',
-                sourceId: d.readModelStickyId,
-                targetId: d.screenId,
-                fieldMappings: [],
-            });
-            break;
-        case 'ReadModelToProcessorFlowSpecified':
-            model.flows.set(d.flowId, {
-                id: d.flowId,
-                flowType: 'ReadModelToProcessor',
-                sourceId: d.readModelStickyId,
-                targetId: d.processorId,
-                fieldMappings: [],
-            });
-            break;
-        case 'ScreenToCommandFlowSpecified':
-            model.flows.set(d.flowId, {
-                id: d.flowId,
-                flowType: 'ScreenToCommand',
-                sourceId: d.screenId,
-                targetId: d.commandStickyId,
-                fieldMappings: [],
-            });
-            break;
-        case 'ProcessorToCommandFlowSpecified':
-            model.flows.set(d.flowId, {
-                id: d.flowId,
-                flowType: 'ProcessorToCommand',
-                sourceId: d.processorId,
-                targetId: d.commandStickyId,
-                fieldMappings: [],
-            });
-            break;
-        case 'FlowRemoved':
-            model.flows.delete(d.flowId);
-            break;
-        case 'FieldMappingSpecified': {
-            const flow = model.flows.get(d.flowId);
-            if (flow)
-                flow.fieldMappings = d.mappings;
-            break;
-        }
-        case 'FieldMappingCleared': {
-            const flow = model.flows.get(d.flowId);
-            if (flow)
-                flow.fieldMappings = [];
-            break;
-        }
-        // Field propagation events
-        case 'FieldsPropagatedFromCommandToEvent':
-        case 'FieldsPropagatedFromEventToCommand':
-        case 'FieldsPropagatedFromEventToReadModel':
-        case 'FieldsPropagatedFromReadModelToEvent':
-        case 'FieldsPropagatedFromReadModelToScreen':
-        case 'FieldsPropagatedFromScreenToReadModel':
-        case 'FieldsPropagatedFromReadModelToProcessor':
-        case 'FieldsPropagatedFromProcessorToReadModel':
-        case 'FieldsPropagatedFromScreenToCommand':
-        case 'FieldsPropagatedFromCommandToScreen':
-        case 'FieldsPropagatedFromProcessorToCommand':
-        case 'FieldsPropagatedFromCommandToProcessor':
-            handleFieldPropagation(model, event);
-            break;
-        // Scenario events
-        case 'ScenarioCreated':
-            model.scenarios.set(d.scenarioId, {
-                id: d.scenarioId,
-                sliceId: d.sliceId,
-                name: d.name,
-                description: '',
-                position: d.position,
-                width: d.width,
-                height: d.height,
-                givenEvents: [],
-                whenCommand: null,
-                whenEvents: [],
-                then: { type: 'events', expectedEvents: [] },
-            });
-            break;
-        case 'ScenarioMoved': {
-            const scenario = model.scenarios.get(d.scenarioId);
-            if (scenario)
-                scenario.position = d.position;
-            break;
-        }
-        case 'ScenarioRemoved':
-            model.scenarios.delete(d.scenarioId);
-            break;
-        case 'ScenarioRenamed': {
-            const scenario = model.scenarios.get(d.scenarioId);
-            if (scenario)
-                scenario.name = d.name;
-            break;
-        }
-        case 'ScenarioDescriptionUpdated': {
-            const scenario = model.scenarios.get(d.scenarioId);
-            if (scenario)
-                scenario.description = d.description;
-            break;
-        }
-        case 'ScenarioGivenEventsUpdated': {
-            const scenario = model.scenarios.get(d.scenarioId);
-            if (scenario)
-                scenario.givenEvents = d.givenEvents;
-            break;
-        }
-        case 'ScenarioWhenCommandUpdated': {
-            const scenario = model.scenarios.get(d.scenarioId);
-            if (scenario)
-                scenario.whenCommand = d.whenCommand;
-            break;
-        }
-        case 'ScenarioWhenEventsUpdated': {
-            const scenario = model.scenarios.get(d.scenarioId);
-            if (scenario)
-                scenario.whenEvents = d.whenEvents;
-            break;
-        }
-        case 'ScenarioThenUpdated': {
-            const scenario = model.scenarios.get(d.scenarioId);
-            if (scenario)
-                scenario.then = d.then;
-            break;
-        }
-        // Ignore visual-only events
-        case 'ScreenDesignUpdated':
-            // Screen designs are visual-only, not relevant for CLI
-            break;
-    }
-}
-// Merge source fields into target fields:
-// - If a field with the same name exists, update its subfields
-// - If it doesn't exist, add as new field
-function mergeFieldsInto(existingFields, sourceFields) {
-    for (const field of sourceFields) {
-        const existingIdx = existingFields.findIndex(f => f.name === field.name);
-        if (existingIdx !== -1) {
-            existingFields[existingIdx] = {
-                ...existingFields[existingIdx],
-                subfields: field.subfields,
-            };
-        }
-        else {
-            existingFields.push(field);
-        }
-    }
-}
-// Forward propagation: source → target on the flow
-const FORWARD_PROPAGATION_TYPES = new Set([
-    'FieldsPropagatedFromCommandToEvent',
-    'FieldsPropagatedFromEventToReadModel',
-    'FieldsPropagatedFromReadModelToScreen',
-    'FieldsPropagatedFromReadModelToProcessor',
-    'FieldsPropagatedFromScreenToCommand',
-    'FieldsPropagatedFromProcessorToCommand',
-]);
-function getFieldsForNode(model, nodeId) {
-    return model.commands.get(nodeId)?.fields
-        ?? model.events.get(nodeId)?.fields
-        ?? model.readModels.get(nodeId)?.fields
-        ?? model.screens.get(nodeId)?.fields
-        ?? model.processors.get(nodeId)?.fields
-        ?? null;
-}
-function handleFieldPropagation(model, event) {
-    const flowId = event.data.flowId;
-    const flow = model.flows.get(flowId);
-    if (!flow)
-        return;
-    const isForward = FORWARD_PROPAGATION_TYPES.has(event.type);
-    const sourceId = isForward ? flow.sourceId : flow.targetId;
-    const targetId = isForward ? flow.targetId : flow.sourceId;
-    const sourceFields = getFieldsForNode(model, sourceId) ?? [];
-    const targetFields = getFieldsForNode(model, targetId);
-    if (targetFields !== null) {
-        mergeFieldsInto(targetFields, sourceFields);
-    }
-}