@auto-engineer/pipeline 1.105.0 → 1.107.0

package/ketchup-plan.md

@@ -2,6 +2,15 @@
 
 ## TODO
 
+### Fix Settled Node Labels and Event Routing (Bursts 107-112)
+
+- [x] Burst 107: processSettledHandler uses descriptor.label for graph node [depends: none]
+- [x] Burst 108: bridge filters commands by sourceEventTypes [depends: none]
+- [x] Burst 109: builder sets sourceEventTypes from emit chain event type [depends: none]
+- [x] Burst 110: Add label and sourceEventTypes to descriptor and builder (merged into 107+109)
+- [x] Burst 111: Add source event filtering to bridge (merged into 108)
+- [x] Burst 112: Thread source event type through pipeline server [depends: 110, 111]
+
 ### Graph Rendering Fix (Burst 106)
 
 - [ ] Burst 106: Show source commands whose events are listened to by the pipeline [depends: none]

package/package.json

@@ -14,8 +14,8 @@
     "get-port": "^7.1.0",
     "jose": "^5.9.6",
     "nanoid": "^5.0.0",
-    "@auto-engineer/file-store": "1.105.0",
-    "@auto-engineer/message-bus": "1.105.0"
+    "@auto-engineer/file-store": "1.107.0",
+    "@auto-engineer/message-bus": "1.107.0"
   },
   "devDependencies": {
     "@types/cors": "^2.8.17",
@@ -24,7 +24,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.105.0",
+  "version": "1.107.0",
   "scripts": {
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts",
     "test": "vitest run --reporter=dot",

package/src/builder/define.specs.ts

@@ -153,6 +153,64 @@ describe('settled()', () => {
     expect(settledNode?.label).toBe('Settled');
   });
 
+  it('sets sourceEventTypes from preceding emit chain event type', () => {
+    const pipeline = define('test')
+      .on('SliceImplemented')
+      .emit('CheckTests', {})
+      .settled(['CheckTests', 'CheckTypes'])
+      .dispatch({ dispatches: ['ImplementSlice'] }, () => {})
+      .build();
+
+    const descriptor = pipeline.descriptor.handlers[1] as SettledHandlerDescriptor;
+    expect(descriptor.sourceEventTypes).toEqual(['SliceImplemented']);
+  });
+
+  it('has no sourceEventTypes for top-level settled', () => {
+    const pipeline = define('test')
+      .settled(['CheckTests'])
+      .dispatch({ dispatches: [] }, () => {})
+      .build();
+
+    const descriptor = pipeline.descriptor.handlers[0] as SettledHandlerDescriptor;
+    expect(descriptor.sourceEventTypes).toBeUndefined();
+  });
+
+  it('uses custom label passed to settled()', () => {
+    const pipeline = define('test')
+      .settled(['CheckTests', 'CheckTypes'], 'Slice Checks')
+      .dispatch({ dispatches: ['ImplementSlice'] }, () => {})
+      .build();
+
+    const descriptor = pipeline.descriptor.handlers[0] as SettledHandlerDescriptor;
+    expect(descriptor.label).toBe('Slice Checks');
+
+    const graph = pipeline.toGraph();
+    const settledNode = graph.nodes.find((n) => n.id.startsWith('settled:'));
+    expect(settledNode).toEqual({
+      id: 'settled:settled-0',
+      type: 'settled',
+      label: 'Slice Checks',
+    });
+  });
+
+  it('uses label from descriptor for settled graph nodes', () => {
+    const pipeline = define('test')
+      .settled(['CheckTests', 'CheckTypes'])
+      .dispatch({ dispatches: ['ImplementSlice'] }, () => {})
+      .build();
+
+    const handlers = pipeline.descriptor.handlers as SettledHandlerDescriptor[];
+    expect(handlers[0].label).toBe('ImplementSlice Settled');
+
+    const graph = pipeline.toGraph();
+    const settledNode = graph.nodes.find((n) => n.id.startsWith('settled:'));
+    expect(settledNode).toEqual({
+      id: 'settled:settled-0',
+      type: 'settled',
+      label: 'ImplementSlice Settled',
+    });
+  });
+
   it('should accept options-first dispatch with dispatches array', () => {
     const pipeline = define('test')
       .settled(['CheckA'])

package/src/builder/define.ts

@@ -34,7 +34,7 @@ export interface PipelineBuilder {
   key<E>(name: string, extractor: (event: E) => string): PipelineBuilder;
   declare(commandType: string): DeclareBuilder;
   on(eventType: string): TriggerBuilder;
-  settled(commandTypes: readonly string[]): SettledBuilder;
+  settled(commandTypes: readonly string[], label?: string): SettledBuilder;
   build(): Pipeline;
 }
 
@@ -55,7 +55,7 @@ export interface SettledBuilder {
 export interface SettledChain {
   declare(commandType: string): DeclareBuilder;
   on(eventType: string): TriggerBuilder;
-  settled(commandTypes: readonly string[]): SettledBuilder;
+  settled(commandTypes: readonly string[], label?: string): SettledBuilder;
   build(): Pipeline;
 }
 
@@ -133,7 +133,7 @@ export interface EmitChain {
   emit(commandType: string, data: unknown): EmitChain;
   declare(commandType: string): DeclareBuilder;
   on(eventType: string): TriggerBuilder;
-  settled(commandTypes: readonly string[]): SettledBuilder;
+  settled(commandTypes: readonly string[], label?: string): SettledBuilder;
   build(): Pipeline;
 }
 
@@ -156,11 +156,16 @@ class PipelineBuilderImpl implements PipelineBuilder {
   private descriptionValue?: string;
   private readonly keys: Map<string, KeyExtractor> = new Map();
   private readonly handlers: HandlerDescriptor[] = [];
+  private settledCounter = 0;
 
   constructor(name: string) {
     this.name = name;
   }
 
+  nextSettledId(): string {
+    return `settled-${this.settledCounter++}`;
+  }
+
   version(v: string): PipelineBuilder {
     this.versionValue = v;
     return this;
@@ -184,8 +189,8 @@ class PipelineBuilderImpl implements PipelineBuilder {
     return new TriggerBuilderImpl(this, eventType);
   }
 
-  settled(commandTypes: readonly string[]): SettledBuilder {
-    return new SettledBuilderImpl(this, commandTypes);
+  settled(commandTypes: readonly string[], label?: string): SettledBuilder {
+    return new SettledBuilderImpl(this, commandTypes, undefined, label);
   }
 
   addHandler(handler: HandlerDescriptor): void {
@@ -288,8 +293,9 @@ function processAcceptsHandler(ctx: GraphBuilderContext, handler: AcceptsDescrip
 }
 
 function processSettledHandler(ctx: GraphBuilderContext, handler: SettledHandlerDescriptor): void {
-  const settledNodeId = `settled:${handler.commandTypes.join(',')}`;
-  addNode(ctx, settledNodeId, 'settled', 'Settled');
+  const settledKey = handler.settledId ?? handler.commandTypes.join(',');
+  const settledNodeId = `settled:${settledKey}`;
+  addNode(ctx, settledNodeId, 'settled', handler.label ?? 'Settled');
 
   for (const commandType of handler.commandTypes) {
     addNode(ctx, `cmd:${commandType}`, 'command', commandType);
@@ -402,9 +408,9 @@ class EmitChainImpl implements EmitChain {
     return new TriggerBuilderImpl(this.parent, eventType);
   }
 
-  settled(commandTypes: readonly string[]): SettledBuilder {
+  settled(commandTypes: readonly string[], label?: string): SettledBuilder {
     this.finalizeHandler();
-    return new SettledBuilderImpl(this.parent, commandTypes);
+    return new SettledBuilderImpl(this.parent, commandTypes, this.eventType, label);
   }
 
   build(): Pipeline {
@@ -707,6 +713,8 @@ class SettledBuilderImpl implements SettledBuilder {
   constructor(
     private readonly parent: PipelineBuilderImpl,
     private readonly commandTypes: readonly string[],
+    private readonly sourceEventType?: string,
+    private readonly customLabel?: string,
   ) {}
 
   dispatch<const D extends readonly string[]>(
@@ -716,7 +724,14 @@ class SettledBuilderImpl implements SettledBuilder {
       send: (commandType: D[number], data: unknown) => void,
     ) => undefined | { persist: boolean },
   ): SettledChain {
-    return new SettledChainImpl(this.parent, this.commandTypes, handler as SettledHandler, options.dispatches);
+    return new SettledChainImpl(
+      this.parent,
+      this.commandTypes,
+      handler as SettledHandler,
+      options.dispatches,
+      this.sourceEventType,
+      this.customLabel,
+    );
   }
 }
 
@@ -726,6 +741,8 @@ class SettledChainImpl implements SettledChain {
     private readonly commandTypes: readonly string[],
     private readonly handler: SettledHandler,
     private readonly dispatches?: readonly string[],
+    private readonly sourceEventType?: string,
+    private readonly customLabel?: string,
   ) {}
 
   declare(commandType: string): DeclareBuilder {
@@ -738,9 +755,9 @@ class SettledChainImpl implements SettledChain {
     return new TriggerBuilderImpl(this.parent, eventType);
   }
 
-  settled(commandTypes: readonly string[]): SettledBuilder {
+  settled(commandTypes: readonly string[], label?: string): SettledBuilder {
     this.finalizeHandler();
-    return new SettledBuilderImpl(this.parent, commandTypes);
+    return new SettledBuilderImpl(this.parent, commandTypes, undefined, label);
   }
 
   build(): Pipeline {
@@ -749,11 +766,16 @@ class SettledChainImpl implements SettledChain {
   }
 
   private finalizeHandler(): void {
+    const autoLabel = this.dispatches && this.dispatches.length > 0 ? `${this.dispatches[0]} Settled` : undefined;
+    const settledLabel = this.customLabel ?? autoLabel;
     const descriptor: SettledHandlerDescriptor = {
       type: 'settled',
       commandTypes: this.commandTypes,
       handler: this.handler,
       dispatches: this.dispatches,
+      settledId: this.parent.nextSettledId(),
+      label: settledLabel,
+      sourceEventTypes: this.sourceEventType ? [this.sourceEventType] : undefined,
     };
     this.parent.addHandler(descriptor);
   }

package/src/core/descriptors.ts

@@ -85,6 +85,9 @@ export interface SettledHandlerDescriptor {
   commandTypes: readonly string[];
   handler: SettledHandler;
   dispatches?: readonly string[];
+  settledId?: string;
+  label?: string;
+  sourceEventTypes?: readonly string[];
 }
 
 export interface AcceptsDescriptor {

package/src/server/pipeline-server.specs.ts

@@ -460,7 +460,7 @@ describe('PipelineServer', () => {
       server.registerPipeline(pipeline);
       await server.start();
       const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
-      const settledNode = data.nodes.find((n) => n.id === 'settled:CheckTests');
+      const settledNode = data.nodes.find((n) => n.id === 'settled:settled-0');
       expect(settledNode?.status).toBe('idle');
       expect(settledNode?.pendingCount).toBe(0);
       expect(settledNode?.endedCount).toBe(0);
@@ -493,7 +493,7 @@ describe('PipelineServer', () => {
       await new Promise((r) => setTimeout(r, 100));
 
       const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
-      const settledNode = data.nodes.find((n) => n.id === 'settled:CheckTests');
+      const settledNode = data.nodes.find((n) => n.id === 'settled:settled-0');
       expect(settledNode?.status).toBeDefined();
       expect(settledNode?.pendingCount).toBeDefined();
       expect(settledNode?.endedCount).toBeDefined();
@@ -526,9 +526,9 @@ describe('PipelineServer', () => {
       await new Promise((r) => setTimeout(r, 100));
 
       const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
-      const settledNode = data.nodes.find((n) => n.id === 'settled:CheckTests');
+      const settledNode = data.nodes.find((n) => n.id === 'settled:settled-0');
       expect(settledNode).toEqual({
-        id: 'settled:CheckTests',
+        id: 'settled:settled-0',
         type: 'settled',
         label: 'Settled',
         status: 'success',
@@ -1407,8 +1407,8 @@ describe('PipelineServer', () => {
       await server.start();
       const res = await fetch(`http://localhost:${server.port}/pipeline/mermaid`);
       const mermaid = await res.text();
-      expect(mermaid).toContain('CheckA --> settled_CheckA_CheckB');
-      expect(mermaid).toContain('CheckB --> settled_CheckA_CheckB');
+      expect(mermaid).toContain('CheckA --> settled_settled-0');
+      expect(mermaid).toContain('CheckB --> settled_settled-0');
       await server.stop();
     });
 
@@ -1435,7 +1435,7 @@ describe('PipelineServer', () => {
       await server.start();
       const res = await fetch(`http://localhost:${server.port}/pipeline/mermaid`);
       const mermaid = await res.text();
-      expect(mermaid).toContain('settled_CheckA -.->|retry| RetryCommand');
+      expect(mermaid).toContain('settled_settled-0 -.->|retry| RetryCommand');
       await server.stop();
     });
 

package/src/server/pipeline-server.ts

@@ -75,6 +75,7 @@ export class PipelineServer {
   private sqliteEventStore?: EventStore;
   private currentSessionId = '';
   private readonly quiescenceTracker: QuiescenceTracker;
+  private readonly requestIdToSourceEvent = new Map<string, string>();
 
   constructor(config: PipelineServerConfig) {
     this.storeFileName = config.storeFileName;
@@ -993,6 +994,12 @@ export class PipelineServer {
     return false;
   }
 
+  private settledCommandTypes(graph: GraphIR, settledNodeId: string): string[] {
+    return graph.edges
+      .filter((e) => e.to === settledNodeId && e.from.startsWith('cmd:'))
+      .map((e) => e.from.replace('cmd:', ''));
+  }
+
   private extractPipelineEvents(graph: GraphIR, commandToEvents: Record<string, string[]>): Set<string> {
     const pipelineEvents = new Set<string>();
 
@@ -1001,8 +1008,7 @@ export class PipelineServer {
         pipelineEvents.add(node.id.replace('evt:', ''));
       }
       if (node.id.startsWith('settled:')) {
-        const commandTypes = node.id.replace('settled:', '').split(',');
-        for (const commandType of commandTypes) {
+        for (const commandType of this.settledCommandTypes(graph, node.id)) {
           const events = commandToEvents[commandType];
           if (events !== undefined) {
             for (const eventName of events) {
@@ -1034,8 +1040,8 @@ export class PipelineServer {
         commandNodes.add(commandName);
         lines.push(`  ${commandName}[${node.label}]`);
       } else if (node.id.startsWith('settled:')) {
-        const commandTypes = node.id.replace('settled:', '').split(',');
-        const safeId = `settled_${commandTypes.join('_')}`;
+        const commandTypes = this.settledCommandTypes(graph, node.id);
+        const safeId = `settled_${node.id.replace('settled:', '')}`;
         settledNodes.add(safeId);
         lines.push(`  ${safeId}{{${commandTypes.join(', ')}}}`);
       }
@@ -1067,8 +1073,7 @@ export class PipelineServer {
     if (nodeId.startsWith('cmd:')) {
       return nodeId.replace('cmd:', '');
     }
-    const commandTypes = nodeId.replace('settled:', '').split(',');
-    return `settled_${commandTypes.join('_')}`;
+    return `settled_${nodeId.replace('settled:', '')}`;
   }
 
   private addMermaidStyles(
@@ -1135,7 +1140,9 @@ export class PipelineServer {
     await this.getOrCreateItemStatus(this.currentSessionId, command.type, itemKey, command.requestId);
 
     await this.updateNodeStatus(this.currentSessionId, command.type, 'running');
-    this.settledBridge.onCommandStarted(command, this.currentSessionId);
+    const sourceEventType = this.requestIdToSourceEvent.get(command.requestId);
+    this.requestIdToSourceEvent.delete(command.requestId);
+    this.settledBridge.onCommandStarted(command, this.currentSessionId, sourceEventType);
 
     const ctx = this.createContext(command.correlationId, signal);
     let events: Event[];
@@ -1193,7 +1200,7 @@ export class PipelineServer {
       const sourceCommand = this.eventCommandMapper.getSourceCommand(eventWithIds.type);
       if (sourceCommand !== undefined) {
         const result = eventWithIds.type.includes('Failed') ? 'failure' : 'success';
-        this.settledBridge.onEventReceived(eventWithIds, sourceCommand, result, this.currentSessionId);
+        this.settledBridge.onEventReceived(eventWithIds, sourceCommand, result, this.currentSessionId, sourceEventType);
       }
 
       this.routeEventToPhasedExecutor(eventWithIds);
@@ -1237,12 +1244,12 @@ export class PipelineServer {
   }
 
   private async routeEventToPipelines(event: EventWithCorrelation): Promise<void> {
-    const ctx = this.createContext(event.correlationId);
+    const ctx = this.createContext(event.correlationId, undefined, event.type);
     const runtimes = Array.from(this.runtimes.values());
     await Promise.all(runtimes.map((runtime) => runtime.handleEvent(event, ctx)));
   }
 
-  private createContext(correlationId: string, signal?: AbortSignal): PipelineContext {
+  private createContext(correlationId: string, signal?: AbortSignal, sourceEventType?: string): PipelineContext {
     return {
       correlationId,
       signal,
@@ -1266,6 +1273,9 @@ export class PipelineServer {
           correlationId: effectiveCorrelationId,
           requestId,
         };
+        if (sourceEventType) {
+          this.requestIdToSourceEvent.set(requestId, sourceEventType);
+        }
         await this.emitCommandDispatched(effectiveCorrelationId, requestId, type, data as Record<string, unknown>);
         void this.processCommand(command);
       },

package/src/server/v2-runtime-bridge.specs.ts

@@ -344,4 +344,120 @@ describe('V2RuntimeBridge', () => {
       expect(stats).toEqual({ status: 'idle', pendingCount: 0, endedCount: 0 });
     });
   });
+
+  describe('sourceEventTypes filtering', () => {
+    it('only routes commands to settled blocks matching source event type', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      const handler1Calls: Record<string, Event[]>[] = [];
+      const handler2Calls: Record<string, Event[]>[] = [];
+
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A', 'B'],
+        settledId: 'settled-0',
+        sourceEventTypes: ['Foo'],
+        handler: (events) => {
+          handler1Calls.push(events);
+          return undefined;
+        },
+      });
+
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A', 'B'],
+        settledId: 'settled-1',
+        sourceEventTypes: ['Bar'],
+        handler: (events) => {
+          handler2Calls.push(events);
+          return undefined;
+        },
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'), undefined, 'Foo');
+      bridge.onCommandStarted(makeCommand('B', 'corr-1'), undefined, 'Foo');
+      bridge.onEventReceived(makeEvent('ADone', 'corr-1', { a: 1 }), 'A', 'success', undefined, 'Foo');
+      bridge.onEventReceived(makeEvent('BDone', 'corr-1', { b: 2 }), 'B', 'success', undefined, 'Foo');
+
+      expect(handler1Calls).toHaveLength(1);
+      expect(handler2Calls).toHaveLength(0);
+    });
+
+    it('routes to all blocks when sourceEventType is not provided', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      const handler1Calls: Record<string, Event[]>[] = [];
+      const handler2Calls: Record<string, Event[]>[] = [];
+
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A'],
+        settledId: 'settled-0',
+        sourceEventTypes: ['Foo'],
+        handler: (events) => {
+          handler1Calls.push(events);
+          return undefined;
+        },
+      });
+
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A'],
+        settledId: 'settled-1',
+        sourceEventTypes: ['Bar'],
+        handler: (events) => {
+          handler2Calls.push(events);
+          return undefined;
+        },
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onEventReceived(makeEvent('ADone', 'corr-1'), 'A');
+
+      expect(handler1Calls).toHaveLength(1);
+      expect(handler2Calls).toHaveLength(1);
+    });
+  });
+
+  describe('multiple settled blocks with same command types', () => {
+    it('fires both handlers independently when two blocks watch the same commands', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      const handler1Calls: Record<string, Event[]>[] = [];
+      const handler2Calls: Record<string, Event[]>[] = [];
+
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A', 'B'],
+        settledId: 'settled-0',
+        handler: (events) => {
+          handler1Calls.push(events);
+          return undefined;
+        },
+      });
+
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A', 'B'],
+        settledId: 'settled-1',
+        handler: (events) => {
+          handler2Calls.push(events);
+          return undefined;
+        },
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onCommandStarted(makeCommand('B', 'corr-1'));
+      bridge.onEventReceived(makeEvent('ADone', 'corr-1', { a: 1 }), 'A');
+      bridge.onEventReceived(makeEvent('BDone', 'corr-1', { b: 2 }), 'B');
+
+      expect(handler1Calls).toHaveLength(1);
+      expect(handler2Calls).toHaveLength(1);
+      expect(handler1Calls[0]).toEqual({
+        A: [{ type: 'ADone', data: { a: 1 }, correlationId: 'corr-1' }],
+        B: [{ type: 'BDone', data: { b: 2 }, correlationId: 'corr-1' }],
+      });
+      expect(handler2Calls[0]).toEqual({
+        A: [{ type: 'ADone', data: { a: 1 }, correlationId: 'corr-1' }],
+        B: [{ type: 'BDone', data: { b: 2 }, correlationId: 'corr-1' }],
+      });
+    });
+  });
 });

package/src/server/v2-runtime-bridge.ts

@@ -20,6 +20,7 @@ interface RegisteredSettled {
   descriptor: SettledHandlerDescriptor;
   commandTypes: readonly string[];
   maxRetries: number;
+  sourceEventTypes?: readonly string[];
 }
 
 type SettledEvent = SettledInput | SettledOutput;
@@ -142,13 +143,16 @@ export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
   return {
     registerSettled(descriptor: SettledHandlerDescriptor, config?: { maxRetries?: number }): void {
       const commandTypes = descriptor.commandTypes;
-      const templateId = `template-${commandTypes.join(',')}`;
+      const templateId = descriptor.settledId
+        ? `template-${descriptor.settledId}`
+        : `template-${commandTypes.join(',')}`;
 
       const registration: RegisteredSettled = {
         templateId,
         descriptor,
         commandTypes,
         maxRetries: config?.maxRetries ?? 3,
+        sourceEventTypes: descriptor.sourceEventTypes,
       };
 
       registrations.set(templateId, registration);
@@ -160,7 +164,7 @@ export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
       }
     },
 
-    onCommandStarted(command: Command, sessionCorrelationId?: string): void {
+    onCommandStarted(command: Command, sessionCorrelationId?: string, sourceEventType?: string): void {
       const { type: commandType, correlationId, requestId } = command;
 
       if (!isValidId(correlationId) || !isValidId(requestId)) {
@@ -177,6 +181,14 @@ export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
       for (const templateId of templateIds) {
         const registration = registrations.get(templateId);
         if (registration) {
+          if (
+            sourceEventType &&
+            registration.sourceEventTypes &&
+            registration.sourceEventTypes.length > 0 &&
+            !registration.sourceEventTypes.includes(sourceEventType)
+          ) {
+            continue;
+          }
           const history = getHistory(templateId, keyCorrelationId);
           const input: SettledInput = {
             type: 'StartSettled',
@@ -192,6 +204,7 @@ export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
       sourceCommandType: string,
       result: 'success' | 'failure' = 'success',
       sessionCorrelationId?: string,
+      sourceEventType?: string,
     ): void {
       const correlationId = event.correlationId;
 
@@ -208,6 +221,14 @@ export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
 
       for (const templateId of templateIds) {
         const registration = registrations.get(templateId)!;
+        if (
+          sourceEventType &&
+          registration.sourceEventTypes &&
+          registration.sourceEventTypes.length > 0 &&
+          !registration.sourceEventTypes.includes(sourceEventType)
+        ) {
+          continue;
+        }
         const existing = ensureBuffer(templateId, keyCorrelationId, sourceCommandType);
         existing.push(event);