@codemation/core 0.2.3 → 0.4.0

package/src/testing/ItemHarnessNode.ts

@@ -1,24 +1,18 @@
-import type { Item, ItemNode, Items, NodeExecutionContext } from "../types";
+import type { Item, RunnableNode, RunnableNodeExecuteArgs } from "../types";
 
 import type { ItemHarnessNodeConfig } from "./ItemHarnessNodeConfig";
 
 /**
  * Item-mode harness node for engine tests (see {@link ItemHarnessNodeConfig}).
  */
-export class ItemHarnessNode implements ItemNode<ItemHarnessNodeConfig<any, any, any>, unknown, unknown> {
+export class ItemHarnessNode implements RunnableNode<ItemHarnessNodeConfig<any, any>> {
   readonly kind = "node" as const;
   readonly outputPorts = ["main"] as const;
 
-  async executeOne(args: {
-    input: unknown;
-    item: Item;
-    itemIndex: number;
-    items: Items;
-    ctx: NodeExecutionContext<ItemHarnessNodeConfig<any, any, any>>;
-  }): Promise<unknown> {
+  async execute(args: RunnableNodeExecuteArgs<ItemHarnessNodeConfig<any, any>>): Promise<unknown> {
     return await args.ctx.config.runOne({
       input: args.input as never,
-      item: args.item,
+      item: args.item as Item,
       itemIndex: args.itemIndex,
       items: args.items,
       ctx: args.ctx,

package/src/testing/ItemHarnessNodeConfig.ts

@@ -1,19 +1,15 @@
 import type { ZodType } from "zod";
 
 import type { TypeToken } from "../di";
-import type { Item, ItemInputMapper, Items, NodeExecutionContext, RunnableNodeConfig } from "../types";
+import type { Item, Items, NodeExecutionContext, RunnableNodeConfig } from "../types";
 
 import { ItemHarnessNode } from "./ItemHarnessNode";
 
 /**
- * Item-mode harness node config for engine tests: engine applies {@link RunnableNodeConfig.inputSchema} +
- * optional {@link RunnableNodeConfig.mapInput}, then {@link ItemHarnessNode.executeOne} per item.
+ * Item-mode harness node config for engine tests: engine applies {@link RunnableNodeConfig.inputSchema},
+ * then {@link ItemHarnessNode.execute} per item.
  */
-export class ItemHarnessNodeConfig<TIn = unknown, TOut = unknown, TWire = TIn> implements RunnableNodeConfig<
-  TIn,
-  TOut,
-  TWire
-> {
+export class ItemHarnessNodeConfig<TIn = unknown, TOut = unknown> implements RunnableNodeConfig<TIn, TOut> {
   readonly kind = "node" as const;
   readonly type: TypeToken<unknown> = ItemHarnessNode;
 
@@ -22,21 +18,16 @@ export class ItemHarnessNodeConfig<TIn = unknown, TOut = unknown, TWire = TIn> i
     public readonly inputSchema: ZodType<TIn>,
     public readonly runOne: (args: {
       input: TIn;
-      item: Item<TWire>;
+      item: Item<TIn>;
       itemIndex: number;
-      items: Items<TWire>;
-      ctx: NodeExecutionContext<ItemHarnessNodeConfig<TIn, TOut, TWire>>;
+      items: Items<TIn>;
+      ctx: NodeExecutionContext<ItemHarnessNodeConfig<TIn, TOut>>;
     }) => TOut | Promise<TOut>,
     public readonly opts: Readonly<{
       id?: string;
-      mapInput?: ItemInputMapper<TWire, TIn>;
     }> = {},
   ) {}
 
-  get mapInput(): ItemInputMapper<TWire, TIn> | undefined {
-    return this.opts.mapInput;
-  }
-
   get id(): string | undefined {
     return this.opts.id;
   }

package/src/testing/RegistrarEngineTestKitFactory.ts

@@ -32,6 +32,7 @@ import type { RegistrarEngineTestKitHandle, RegistrarEngineTestKitOptions } from
 import { ItemHarnessNode } from "./ItemHarnessNode";
 import { SubWorkflowRunnerNode } from "./SubWorkflowRunnerTestNode";
 import { WorkflowTestHarnessManualTriggerNode } from "./WorkflowTestHarnessManualTrigger";
+import { SwitchHarnessNode } from "./SwitchHarnessNode";
 
 export class RegistrarEngineTestKitFactory {
   static create(options: RegistrarEngineTestKitOptions = {}): RegistrarEngineTestKitHandle {
@@ -110,6 +111,7 @@ export class RegistrarEngineTestKitFactory {
       new SubWorkflowRunnerNode(workflowRunner as WorkflowRunnerService),
     );
     dependencyContainer.registerInstance(ItemHarnessNode, new ItemHarnessNode());
+    dependencyContainer.registerInstance(SwitchHarnessNode, new SwitchHarnessNode());
     dependencyContainer.registerInstance(
       WorkflowTestHarnessManualTriggerNode,
       new WorkflowTestHarnessManualTriggerNode(),

package/src/testing/SubWorkflowRunnerTestNode.ts

@@ -1,16 +1,8 @@
 /* eslint-disable codemation/single-class-per-file -- Runnable config and implementation share a TypeToken pairing. */
 import type { WorkflowRunnerService } from "../contracts/runtimeTypes";
 import type { TypeToken } from "../di";
-import type {
-  Item,
-  Items,
-  NodeExecutionContext,
-  NodeId,
-  NodeOutputs,
-  Node,
-  RunnableNodeConfig,
-  WorkflowId,
-} from "../types";
+import type { Item, NodeId, RunnableNode, RunnableNodeConfig, RunnableNodeExecuteArgs, WorkflowId } from "../types";
+import { emitPorts } from "../contracts/emitPorts";
 
 /**
  * Test harness subworkflow runner (mirrors integration patterns; lives under {@link "@codemation/core/testing"}).
@@ -22,6 +14,9 @@ export class SubWorkflowRunnerConfig<TInputJson = unknown, TOutputJson = unknown
   readonly kind = "node" as const;
   readonly type: TypeToken<unknown> = SubWorkflowRunnerNode;
 
+  readonly workflowId: WorkflowId;
+  readonly startAt: NodeId | undefined;
+
   constructor(
     public readonly name: string,
     public readonly args: Readonly<{
@@ -30,7 +25,10 @@ export class SubWorkflowRunnerConfig<TInputJson = unknown, TOutputJson = unknown
       id?: string;
       execution?: Readonly<{ hint?: "local" | "worker"; queue?: string }>;
     }>,
-  ) {}
+  ) {
+    this.workflowId = args.workflowId;
+    this.startAt = args.startAt;
+  }
 
   get id(): string | undefined {
     return this.args.id;
@@ -39,45 +37,32 @@ export class SubWorkflowRunnerConfig<TInputJson = unknown, TOutputJson = unknown
   get execution(): Readonly<{ hint?: "local" | "worker"; queue?: string }> | undefined {
     return this.args.execution;
   }
-
-  get workflowId(): WorkflowId {
-    return this.args.workflowId;
-  }
-
-  get startAt(): NodeId | undefined {
-    return this.args.startAt;
-  }
 }
 
-export class SubWorkflowRunnerNode implements Node<SubWorkflowRunnerConfig<any, any>> {
+export class SubWorkflowRunnerNode implements RunnableNode<SubWorkflowRunnerConfig<any, any>> {
   readonly kind = "node" as const;
   readonly outputPorts = ["main"] as const;
 
   constructor(private readonly workflows: WorkflowRunnerService) {}
 
-  async execute(items: Items, ctx: NodeExecutionContext<SubWorkflowRunnerConfig<any, any>>): Promise<NodeOutputs> {
-    const out: Item[] = [];
-    for (let i = 0; i < items.length; i++) {
-      const current = items[i]!;
-      const result = await this.workflows.runById({
-        workflowId: ctx.config.workflowId,
-        startAt: ctx.config.startAt,
-        items: [current],
-        parent: {
-          runId: ctx.runId,
-          workflowId: ctx.workflowId,
-          nodeId: ctx.nodeId,
-          subworkflowDepth: ctx.subworkflowDepth,
-          engineMaxNodeActivations: ctx.engineMaxNodeActivations,
-          engineMaxSubworkflowDepth: ctx.engineMaxSubworkflowDepth,
-        },
-      });
-      if (result.status !== "completed") {
-        throw new Error(`Subworkflow ${ctx.config.workflowId} did not complete (status=${result.status})`);
-      }
-      out.push(...result.outputs);
+  async execute(args: RunnableNodeExecuteArgs<SubWorkflowRunnerConfig<any, any>>): Promise<unknown> {
+    const current = args.item as Item;
+    const result = await this.workflows.runById({
+      workflowId: args.ctx.config.workflowId,
+      startAt: args.ctx.config.startAt,
+      items: [current],
+      parent: {
+        runId: args.ctx.runId,
+        workflowId: args.ctx.workflowId,
+        nodeId: args.ctx.nodeId,
+        subworkflowDepth: args.ctx.subworkflowDepth,
+        engineMaxNodeActivations: args.ctx.engineMaxNodeActivations,
+        engineMaxSubworkflowDepth: args.ctx.engineMaxSubworkflowDepth,
+      },
+    });
+    if (result.status !== "completed") {
+      throw new Error(`Subworkflow ${args.ctx.config.workflowId} did not complete (status=${result.status})`);
     }
-
-    return { main: out };
+    return emitPorts({ main: result.outputs });
   }
 }

package/src/testing/SwitchHarnessNode.ts

@@ -0,0 +1,54 @@
+import type { TypeToken } from "../di";
+import type {
+  Item,
+  Items,
+  NodeExecutionContext,
+  RunnableNode,
+  RunnableNodeConfig,
+  RunnableNodeExecuteArgs,
+} from "../types";
+import { emitPorts } from "../contracts/emitPorts";
+
+export class SwitchHarnessNode implements RunnableNode<SwitchHarnessNodeConfig<any>> {
+  readonly kind = "node" as const;
+  readonly outputPorts = [] as const;
+
+  async execute(args: RunnableNodeExecuteArgs<SwitchHarnessNodeConfig<any>>): Promise<unknown> {
+    const key = await Promise.resolve(
+      args.ctx.config.cfg.resolveCaseKey(args.item as Item, args.itemIndex, args.items, args.ctx),
+    );
+    const { cases, defaultCase } = args.ctx.config.cfg;
+    const port = cases.includes(key) ? key : defaultCase;
+    return emitPorts({
+      [port]: [args.item],
+    });
+  }
+}
+
+export class SwitchHarnessNodeConfig<TInputJson = unknown> implements RunnableNodeConfig<TInputJson, TInputJson> {
+  readonly kind = "node" as const;
+  readonly type: TypeToken<unknown> = SwitchHarnessNode;
+  readonly lineageCarry = "carryThrough" as const;
+  readonly declaredOutputPorts: ReadonlyArray<string>;
+
+  constructor(
+    public readonly name: string,
+    public readonly cfg: Readonly<{
+      cases: readonly string[];
+      defaultCase: string;
+      resolveCaseKey: (
+        item: Item<TInputJson>,
+        index: number,
+        items: Items<TInputJson>,
+        ctx: NodeExecutionContext<SwitchHarnessNodeConfig<TInputJson>>,
+      ) => string | Promise<string>;
+    }>,
+    public readonly opts: Readonly<{ id?: string }> = {},
+  ) {
+    this.declaredOutputPorts = [...new Set([...cfg.cases, cfg.defaultCase])].sort();
+  }
+
+  get id(): string | undefined {
+    return this.opts.id;
+  }
+}

package/src/types/index.ts

@@ -1,3 +1,6 @@
+export * from "../contracts/emitPorts";
+export * from "../contracts/itemMeta";
+export * from "../contracts/itemValue";
 export * from "../contracts/retryPolicySpec.types";
 export * from "../contracts/NoRetryPolicy";
 export * from "../contracts/RetryPolicy";

package/src/workflow/dsl/ChainCursorResolver.ts

@@ -1,4 +1,5 @@
 import type {
+  InputPortKey,
   NodeRef,
   OutputPortKey,
   RunnableNodeConfig,
@@ -16,6 +17,8 @@ import type {
   StepSequenceOutput,
 } from "./workflowBuilderTypes";
 
+type ChainCursorEndpoint = Readonly<{ node: NodeRef; output: OutputPortKey; inputPortHint?: InputPortKey }>;
+
 type ChainCursorWhenOverloads<TCurrentJson> = BooleanWhenOverloads<TCurrentJson, WhenBuilder<TCurrentJson>> & {
   <
     TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined,
@@ -34,16 +37,30 @@ type ChainCursorWhenOverloads<TCurrentJson> = BooleanWhenOverloads<TCurrentJson,
 export class ChainCursor<TCurrentJson> {
   constructor(
     private readonly wf: WorkflowBuilder,
-    private readonly cursor: NodeRef,
-    private readonly cursorOutput: OutputPortKey,
+    private readonly endpoints: ReadonlyArray<ChainCursorEndpoint>,
   ) {}
 
-  then<TInputJson, TOutputJson, TConfig extends RunnableNodeConfig<TInputJson, TOutputJson, TCurrentJson>>(
+  then<TOutputJson, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson>>(
+    config: TConfig,
+  ): ChainCursor<RunnableNodeOutputJson<TConfig>> {
+    const next = (this.wf as any).add(config) as NodeRef;
+    const inputPortHint = this.resolveSharedInputPortHint();
+    for (const e of this.endpoints) {
+      (this.wf as any).connect(e.node, next, e.output);
+    }
+    return new ChainCursor<RunnableNodeOutputJson<TConfig>>(this.wf, [
+      { node: next, output: "main", ...(inputPortHint ? { inputPortHint } : {}) },
+    ]);
+  }
+
+  thenIntoInputHints<TOutputJson, TConfig extends RunnableNodeConfig<any, TOutputJson>>(
     config: TConfig,
   ): ChainCursor<RunnableNodeOutputJson<TConfig>> {
     const next = (this.wf as any).add(config) as NodeRef;
-    (this.wf as any).connect(this.cursor, next, this.cursorOutput);
-    return new ChainCursor<RunnableNodeOutputJson<TConfig>>(this.wf, next, "main");
+    for (const e of this.endpoints) {
+      (this.wf as any).connect(e.node, next, e.output, e.inputPortHint ?? "in");
+    }
+    return new ChainCursor<RunnableNodeOutputJson<TConfig>>(this.wf, [{ node: next, output: "main" }]);
   }
 
   readonly when: ChainCursorWhenOverloads<TCurrentJson> = ((
@@ -53,51 +70,79 @@ export class ChainCursor<TCurrentJson> {
     steps?: ReadonlyArray<AnyRunnableNodeConfig> | AnyRunnableNodeConfig,
     ...more: AnyRunnableNodeConfig[]
   ): WhenBuilder<TCurrentJson> | ChainCursor<TCurrentJson> => {
+    if (this.endpoints.length !== 1) {
+      throw new Error("ChainCursor.when(...) is only supported from a single cursor endpoint");
+    }
+    const cursor = this.endpoints[0]!.node;
+
     if (typeof arg1 === "boolean") {
       const list = Array.isArray(steps) ? steps : steps ? [steps, ...more] : more;
       const port: OutputPortKey = arg1 ? "true" : "false";
-      const b = new WhenBuilder<TCurrentJson>(this.wf, this.cursor, port);
+      const b = new WhenBuilder<TCurrentJson>(this.wf, cursor, port);
       b.addBranch(list);
       return b;
     }
 
     const branches = arg1;
-    const makeMerge = (this.wf as any).options?.makeMergeNode as ((name: string) => AnyRunnableNodeConfig) | undefined;
-    if (!makeMerge) {
-      throw new Error(
-        'WorkflowBuilder is missing options.makeMergeNode (required for when({true,false}). Use createWorkflowBuilder from "@codemation/core-nodes".',
-      );
-    }
-
     const wfAny = this.wf as any;
 
     const buildBranch = (
       port: OutputPortKey,
       branchSteps: ReadonlyArray<AnyRunnableNodeConfig> | undefined,
-    ): Readonly<{ end: NodeRef; endOutput: OutputPortKey }> => {
+    ): Readonly<{ end: NodeRef; endOutput: OutputPortKey; inputPortHint: InputPortKey }> => {
       const list = branchSteps ?? [];
       let prev: NodeRef | null = null;
       for (const cfg of list) {
         const ref = wfAny.add(cfg) as NodeRef;
-        if (!prev) wfAny.connect(this.cursor, ref, port, "in");
+        if (!prev) wfAny.connect(cursor, ref, port, "in");
         else wfAny.connect(prev, ref, "main", "in");
         prev = ref;
       }
-      if (!prev) return { end: this.cursor, endOutput: port };
-      return { end: prev, endOutput: "main" };
+      if (!prev) return { end: cursor, endOutput: port, inputPortHint: port };
+      return { end: prev, endOutput: "main", inputPortHint: port };
     };
 
     const t = buildBranch("true", branches.true);
     const f = buildBranch("false", branches.false);
-
-    const merge = wfAny.add(makeMerge("Merge (auto)")) as NodeRef;
-    wfAny.connect(t.end, merge, t.endOutput, "true");
-    wfAny.connect(f.end, merge, f.endOutput, "false");
-
-    return new ChainCursor<TCurrentJson>(this.wf, merge, "main");
+    return new ChainCursor<TCurrentJson>(this.wf, [
+      { node: t.end, output: t.endOutput, inputPortHint: t.inputPortHint },
+      { node: f.end, output: f.endOutput, inputPortHint: f.inputPortHint },
+    ]);
   }) as ChainCursorWhenOverloads<TCurrentJson>;
 
+  route<TNextJson>(
+    branches: Readonly<
+      Record<OutputPortKey, (branch: ChainCursor<TCurrentJson>) => ChainCursor<TNextJson> | undefined>
+    >,
+  ): ChainCursor<TNextJson> {
+    if (this.endpoints.length !== 1) {
+      throw new Error("ChainCursor.route(...) is only supported from a single cursor endpoint");
+    }
+    const cursor = this.endpoints[0]!;
+    const nextEndpoints: ChainCursorEndpoint[] = [];
+    for (const [port, branchFactory] of Object.entries(branches)) {
+      if (!branchFactory) {
+        continue;
+      }
+      const branch = new ChainCursor<TCurrentJson>(this.wf, [{ node: cursor.node, output: port, inputPortHint: port }]);
+      const builtBranch = branchFactory(branch);
+      if (!builtBranch) {
+        continue;
+      }
+      nextEndpoints.push(...builtBranch.endpoints);
+    }
+    return new ChainCursor<TNextJson>(this.wf, nextEndpoints);
+  }
+
   build(): WorkflowDefinition {
     return this.wf.build();
   }
+
+  private resolveSharedInputPortHint(): InputPortKey | undefined {
+    const first = this.endpoints[0]?.inputPortHint;
+    if (!first) {
+      return undefined;
+    }
+    return this.endpoints.every((endpoint) => endpoint.inputPortHint === first) ? first : undefined;
+  }
 }

package/src/workflow/dsl/WorkflowBuilder.ts

@@ -20,9 +20,7 @@ export class WorkflowBuilder {
 
   constructor(
     private readonly meta: { id: WorkflowId; name: string },
-    private readonly options?: Readonly<{
-      makeMergeNode?: (name: string) => AnyRunnableNodeConfig;
-    }>,
+    private readonly options?: Readonly<Record<string, never>>,
   ) {}
 
   private add(config: NodeConfigBase): NodeRef {
@@ -38,12 +36,12 @@ export class WorkflowBuilder {
 
   trigger<TConfig extends AnyTriggerNodeConfig>(config: TConfig): ChainCursor<TriggerNodeOutputJson<TConfig>> {
     const ref = this.add(config);
-    return new ChainCursor<TriggerNodeOutputJson<TConfig>>(this, ref, "main");
+    return new ChainCursor<TriggerNodeOutputJson<TConfig>>(this, [{ node: ref, output: "main" }]);
   }
 
   start<TConfig extends AnyRunnableNodeConfig>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>> {
     const ref = this.add(config);
-    return new ChainCursor<RunnableNodeOutputJson<TConfig>>(this, ref, "main");
+    return new ChainCursor<RunnableNodeOutputJson<TConfig>>(this, [{ node: ref, output: "main" }]);
   }
 
   build(): WorkflowDefinition {

package/src/workflow/dsl/workflowBuilderTypes.ts

@@ -1,6 +1,6 @@
 import type { RunnableNodeConfig, RunnableNodeOutputJson, TriggerNodeConfig } from "../../types";
 
-export type AnyRunnableNodeConfig = RunnableNodeConfig<any, any, any>;
+export type AnyRunnableNodeConfig = RunnableNodeConfig<any, any>;
 
 export type AnyTriggerNodeConfig = TriggerNodeConfig<any>;
 
@@ -10,7 +10,7 @@ export type ValidStepSequence<
 > = TSteps extends readonly []
   ? readonly []
   : TSteps extends readonly [infer TFirst, ...infer TRest]
-    ? TFirst extends RunnableNodeConfig<infer _TIn, infer TNextJson, TCurrentJson>
+    ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson>
       ? TRest extends ReadonlyArray<AnyRunnableNodeConfig>
         ? readonly [TFirst, ...ValidStepSequence<TNextJson, TRest>]
         : never
@@ -22,7 +22,7 @@ export type StepSequenceOutput<TCurrentJson, TSteps extends ReadonlyArray<AnyRun
     ? TSteps extends readonly []
       ? TCurrentJson
       : TSteps extends readonly [infer TFirst, ...infer TRest]
-        ? TFirst extends RunnableNodeConfig<infer _TIn, infer TNextJson, TCurrentJson>
+        ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson>
           ? TRest extends ReadonlyArray<AnyRunnableNodeConfig>
             ? StepSequenceOutput<TNextJson, TRest>
             : never
@@ -46,7 +46,7 @@ export type BranchStepsArg<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnabl
 
 export type BranchMoreArgs<
   TCurrentJson,
-  TFirstStep extends RunnableNodeConfig<any, any, TCurrentJson>,
+  TFirstStep extends RunnableNodeConfig<TCurrentJson, any>,
   TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>,
 > = TRestSteps & ValidStepSequence<RunnableNodeOutputJson<TFirstStep>, TRestSteps>;
 
@@ -55,10 +55,7 @@ export type BooleanWhenOverloads<TCurrentJson, TReturn> = {
     branch: boolean,
     steps: BranchStepsArg<TCurrentJson, TSteps>,
   ): TReturn;
-  <
-    TFirstStep extends RunnableNodeConfig<any, any, TCurrentJson>,
-    TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>,
-  >(
+  <TFirstStep extends RunnableNodeConfig<TCurrentJson, any>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(
     branch: boolean,
     step: TFirstStep,
     ...more: BranchMoreArgs<TCurrentJson, TFirstStep, TRestSteps>

package/src/workflowSnapshots/MissingRuntimeNode.ts

@@ -1,12 +1,12 @@
-import type { Items, Node, NodeOutputs } from "../types";
+import type { RunnableNode, RunnableNodeExecuteArgs } from "../types";
 
 import { MissingRuntimeNodeConfig } from "./MissingRuntimeNodeConfig";
 
-export class MissingRuntimeNode implements Node<MissingRuntimeNodeConfig> {
+export class MissingRuntimeNode implements RunnableNode<MissingRuntimeNodeConfig> {
   readonly kind = "node" as const;
   readonly outputPorts = ["main"] as const;
 
-  async execute(items: Items): Promise<NodeOutputs> {
-    return { main: items };
+  execute(args: RunnableNodeExecuteArgs<MissingRuntimeNodeConfig>): unknown {
+    return args.item;
   }
 }

package/src/workflowSnapshots/MissingRuntimeNodeConfig.ts

@@ -1,8 +1,8 @@
-import type { NodeConfigBase } from "../types";
+import type { RunnableNodeConfig } from "../types";
 
 import { MissingRuntimeNodeToken } from "./MissingRuntimeNodeToken";
 
-export class MissingRuntimeNodeConfig implements NodeConfigBase {
+export class MissingRuntimeNodeConfig implements RunnableNodeConfig<unknown, unknown> {
   readonly kind = "node" as const;
   readonly type = MissingRuntimeNodeToken;
 

package/src/workflowSnapshots/WorkflowSnapshotCodec.ts

@@ -96,14 +96,14 @@ export class WorkflowSnapshotCodec {
     }
   }
 
-  private mergeValue(liveValue: unknown, snapshotValue: unknown): Record<string, unknown> {
+  private mergeValue(liveValue: unknown, snapshotValue: unknown): Record<PropertyKey, unknown> {
     const liveRecord = this.asRecord(liveValue);
     const snapshotRecord = this.asRecord(snapshotValue);
     const hydrated = Object.create(
       liveValue && typeof liveValue === "object"
         ? (Object.getPrototypeOf(liveValue) ?? Object.prototype)
         : Object.prototype,
-    ) as Record<string, unknown>;
+    ) as Record<PropertyKey, unknown>;
 
     for (const [key, value] of Object.entries(snapshotRecord)) {
       hydrated[key] = this.mergeNestedValue(liveRecord[key], value);
@@ -126,17 +126,21 @@ export class WorkflowSnapshotCodec {
   }
 
   private restoreNonSerializableProperties(
-    liveRecord: Record<string, unknown>,
-    hydrated: Record<string, unknown>,
+    liveRecord: Record<PropertyKey, unknown>,
+    hydrated: Record<PropertyKey, unknown>,
   ): void {
     for (const [key, value] of Object.entries(liveRecord)) {
       if (typeof value === "function" || typeof value === "symbol") {
         hydrated[key] = value;
       }
     }
+    // Preserve symbol-keyed brands (e.g. itemValue / emitPorts) and other runtime-only keys.
+    for (const sym of Object.getOwnPropertySymbols(liveRecord)) {
+      hydrated[sym] = liveRecord[sym];
+    }
   }
 
-  private restoreTypeProperty(record: Record<string, unknown>): void {
+  private restoreTypeProperty(record: Record<PropertyKey, unknown>): void {
     const tokenId = typeof record.tokenId === "string" ? record.tokenId : undefined;
     if (!tokenId) {
       return;
@@ -168,10 +172,15 @@ export class WorkflowSnapshotCodec {
     return undefined;
   }
 
-  private asRecord(value: unknown): Record<string, unknown> {
+  private asRecord(value: unknown): Record<PropertyKey, unknown> {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       return {};
     }
-    return { ...(value as Record<string, unknown>) };
+    const record = value as Record<PropertyKey, unknown>;
+    const out: Record<PropertyKey, unknown> = { ...(record as Record<string, unknown>) };
+    for (const sym of Object.getOwnPropertySymbols(value)) {
+      out[sym] = record[sym];
+    }
+    return out;
   }
 }

package/dist/bootstrap-BD6CobHl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bootstrap-BD6CobHl.js","names":["out: RunPruneCandidate[]"],"sources":["../src/policies/executionLimits/EngineExecutionLimitsPolicyFactory.ts","../src/runStorage/RunSummaryMapper.ts","../src/runStorage/InMemoryWorkflowExecutionRepository.ts","../src/scheduler/InlineDrivingSchedulerFactory.ts","../src/bootstrap/runtime/EngineRuntimeRegistrar.ts"],"sourcesContent":["import {\n  EngineExecutionLimitsPolicy,\n  ENGINE_EXECUTION_LIMITS_DEFAULTS,\n  type EngineExecutionLimitsPolicyConfig,\n} from \"./EngineExecutionLimitsPolicy\";\n\n/**\n * Builds {@link EngineExecutionLimitsPolicy} by merging {@link ENGINE_EXECUTION_LIMITS_DEFAULTS} with optional `overrides` (e.g. host `runtime.engineExecutionLimits`).\n */\nexport class EngineExecutionLimitsPolicyFactory {\n  create(overrides?: Partial<EngineExecutionLimitsPolicyConfig>): EngineExecutionLimitsPolicy {\n    return new EngineExecutionLimitsPolicy({ ...ENGINE_EXECUTION_LIMITS_DEFAULTS, ...overrides });\n  }\n}\n","import { RunFinishedAtFactory } from \"../contracts/runFinishedAtFactory\";\nimport type { PersistedRunState, RunSummary } from \"../types\";\n\n/** Maps persisted run state to API run summaries for listings. */\nexport class RunSummaryMapper {\n  static fromPersistedState(state: PersistedRunState): RunSummary {\n    return {\n      runId: state.runId,\n      workflowId: state.workflowId,\n      startedAt: state.startedAt,\n      status: state.status,\n      finishedAt: RunFinishedAtFactory.resolveIso(state),\n      parent: state.parent,\n      executionOptions: state.executionOptions,\n    };\n  }\n}\n","import type {\n  EngineRunCounters,\n  NodeId,\n  NodeOutputs,\n  ParentExecutionRef,\n  PersistedRunSchedulingState,\n  PersistedRunState,\n  RunId,\n  RunSummary,\n  WorkflowExecutionListingRepository,\n  WorkflowExecutionPruneRepository,\n  WorkflowExecutionRepository,\n  RunPruneCandidate,\n  WorkflowId,\n} from \"../types\";\nimport { RunFinishedAtFactory } from \"../contracts/runFinishedAtFactory\";\nimport { RunSummaryMapper } from \"./RunSummaryMapper\";\n\nexport class InMemoryWorkflowExecutionRepository\n  implements WorkflowExecutionRepository, WorkflowExecutionListingRepository, WorkflowExecutionPruneRepository\n{\n  private readonly runs = new Map<RunId, PersistedRunState>();\n\n  async createRun(args: {\n    runId: RunId;\n    workflowId: WorkflowId;\n    startedAt: string;\n    parent?: ParentExecutionRef;\n    executionOptions?: PersistedRunState[\"executionOptions\"];\n    control?: PersistedRunState[\"control\"];\n    workflowSnapshot?: PersistedRunState[\"workflowSnapshot\"];\n    mutableState?: PersistedRunState[\"mutableState\"];\n    policySnapshot?: PersistedRunState[\"policySnapshot\"];\n    engineCounters?: EngineRunCounters;\n  }): Promise<void> {\n    this.runs.set(args.runId, {\n      runId: args.runId,\n      workflowId: args.workflowId,\n      startedAt: args.startedAt,\n      revision: 0,\n      parent: args.parent,\n      executionOptions: args.executionOptions,\n      control: args.control,\n      workflowSnapshot: args.workflowSnapshot,\n      mutableState: args.mutableState,\n      policySnapshot: args.policySnapshot,\n      engineCounters: args.engineCounters,\n      status: \"running\",\n      queue: [],\n      outputsByNode: {} as Record<NodeId, NodeOutputs>,\n      nodeSnapshotsByNodeId: {},\n      connectionInvocations: [],\n    });\n  }\n\n  async load(runId: RunId): Promise<PersistedRunState | undefined> {\n    return this.runs.get(runId);\n  }\n\n  async loadSchedulingState(runId: RunId): Promise<PersistedRunSchedulingState | undefined> {\n    const state = this.runs.get(runId);\n    if (!state) {\n      return undefined;\n    }\n    return {\n      pending: state.pending ? { ...state.pending } : undefined,\n      queue: state.queue.map((entry) => ({ ...entry })),\n    };\n  }\n\n  async save(state: PersistedRunState): Promise<void> {\n    this.runs.set(state.runId, { ...state, revision: (state.revision ?? 0) + 1 });\n  }\n\n  async deleteRun(runId: RunId): Promise<void> {\n    this.runs.delete(runId);\n  }\n\n  async listRuns(args?: Readonly<{ workflowId?: WorkflowId; limit?: number }>): Promise<ReadonlyArray<RunSummary>> {\n    const limit = args?.limit ?? 50;\n    const summaries = [...this.runs.values()]\n      .filter((s) => (args?.workflowId ? s.workflowId === args.workflowId : true))\n      .sort((a, b) => b.startedAt.localeCompare(a.startedAt))\n      .slice(0, limit)\n      .map((s) => RunSummaryMapper.fromPersistedState(s));\n    return summaries;\n  }\n\n  async listRunsOlderThan(\n    args: Readonly<{ beforeIso: string; limit?: number }>,\n  ): Promise<ReadonlyArray<RunPruneCandidate>> {\n    const limit = args.limit ?? 100;\n    const out: RunPruneCandidate[] = [];\n    for (const s of this.runs.values()) {\n      if (s.status !== \"completed\" && s.status !== \"failed\") continue;\n      const finishedAt = RunFinishedAtFactory.resolveIso(s);\n      if (!finishedAt || finishedAt >= args.beforeIso) continue;\n      out.push({\n        runId: s.runId,\n        workflowId: s.workflowId,\n        startedAt: s.startedAt,\n        finishedAt,\n      });\n    }\n    out.sort((a, b) => a.finishedAt.localeCompare(b.finishedAt));\n    return out.slice(0, limit);\n  }\n}\n","import { NodeExecutor } from \"../execution/NodeExecutor\";\n\nimport { InlineDrivingScheduler } from \"./InlineDrivingScheduler\";\n\nexport class InlineDrivingSchedulerFactory {\n  create(nodeExecutor: NodeExecutor): InlineDrivingScheduler {\n    return new InlineDrivingScheduler(nodeExecutor);\n  }\n}\n","import { instanceCachingFactory, type DependencyContainer } from \"../../di\";\nimport { CoreTokens } from \"../../di\";\nimport { EngineExecutionLimitsPolicyFactory } from \"../../policies/executionLimits/EngineExecutionLimitsPolicyFactory\";\nimport {\n  DefaultAsyncSleeper,\n  InProcessRetryRunnerFactory,\n  NodeExecutor,\n  NodeExecutorFactory,\n  NodeInstanceFactoryFactory,\n} from \"../../execution\";\nimport {\n  EngineFactory,\n  EngineWorkflowRunnerServiceFactory,\n  RunIntentServiceFactory,\n  RunIntentService,\n  WorkflowRepositoryWebhookTriggerMatcherFactory,\n} from \"../../runtime\";\nimport { InlineDrivingScheduler } from \"../../scheduler/InlineDrivingScheduler\";\nimport { InlineDrivingSchedulerFactory } from \"../../scheduler/InlineDrivingSchedulerFactory\";\nimport { Engine } from \"../../orchestration/Engine\";\nimport type { EngineRuntimeRegistrationOptions } from \"./EngineRuntimeRegistration.types\";\nimport type { WebhookTriggerMatcherProvider } from \"./EngineRuntimeRegistration.types\";\n\n/**\n * Container-first entry: call on a host/test container **after** workflow, run, node, and credential\n * ports are registered. The registrar owns the default inline scheduler, engine binding,\n * and intent-surface wiring so hosts only override the seams they actually replace.\n */\nexport class EngineRuntimeRegistrar {\n  register(container: DependencyContainer, options?: EngineRuntimeRegistrationOptions): void {\n    this.registerSupportFactories(container);\n    this.registerExecutionLimitsPolicy(container, options);\n    this.ensureWorkflowNodeInstanceFactory(container);\n    this.ensureNodeExecutor(container);\n    this.registerDefaultActivationScheduler(container);\n    this.registerEngine(container, options);\n    this.registerIntentServices(container);\n  }\n\n  private registerSupportFactories(container: DependencyContainer): void {\n    container.register(EngineExecutionLimitsPolicyFactory, { useClass: EngineExecutionLimitsPolicyFactory });\n    container.register(NodeInstanceFactoryFactory, { useClass: NodeInstanceFactoryFactory });\n    container.register(DefaultAsyncSleeper, { useClass: DefaultAsyncSleeper });\n    container.register(InProcessRetryRunnerFactory, { useClass: InProcessRetryRunnerFactory });\n    container.register(NodeExecutorFactory, { useClass: NodeExecutorFactory });\n    container.register(InlineDrivingSchedulerFactory, { useClass: InlineDrivingSchedulerFactory });\n    container.register(RunIntentServiceFactory, { useClass: RunIntentServiceFactory });\n    container.register(EngineWorkflowRunnerServiceFactory, {\n      useClass: EngineWorkflowRunnerServiceFactory,\n    });\n    container.register(WorkflowRepositoryWebhookTriggerMatcherFactory, {\n      useClass: WorkflowRepositoryWebhookTriggerMatcherFactory,\n    });\n  }\n\n  private registerExecutionLimitsPolicy(\n    container: DependencyContainer,\n    options: EngineRuntimeRegistrationOptions | undefined,\n  ): void {\n    if (container.isRegistered(CoreTokens.EngineExecutionLimitsPolicy, true)) {\n      return;\n    }\n    container.register(CoreTokens.EngineExecutionLimitsPolicy, {\n      useFactory: instanceCachingFactory((dependencyContainer) => {\n        const fromResolver = options?.resolveEngineExecutionLimits?.();\n        const merged = fromResolver ?? options?.engineExecutionLimits;\n        return dependencyContainer.resolve(EngineExecutionLimitsPolicyFactory).create(merged);\n      }),\n    });\n  }\n\n  private ensureWorkflowNodeInstanceFactory(container: DependencyContainer): void {\n    if (container.isRegistered(CoreTokens.WorkflowNodeInstanceFactory, true)) {\n      return;\n    }\n    container.register(CoreTokens.WorkflowNodeInstanceFactory, {\n      useFactory: instanceCachingFactory((dependencyContainer) => {\n        return dependencyContainer\n          .resolve(NodeInstanceFactoryFactory)\n          .create(dependencyContainer.resolve(CoreTokens.NodeResolver));\n      }),\n    });\n  }\n\n  private ensureNodeExecutor(container: DependencyContainer): void {\n    if (container.isRegistered(NodeExecutor, true)) {\n      return;\n    }\n    container.register(NodeExecutor, {\n      useFactory: instanceCachingFactory((dependencyContainer) => {\n        const retryRunner = dependencyContainer\n          .resolve(InProcessRetryRunnerFactory)\n          .create(dependencyContainer.resolve(DefaultAsyncSleeper));\n        return dependencyContainer\n          .resolve(NodeExecutorFactory)\n          .create(dependencyContainer.resolve(CoreTokens.WorkflowNodeInstanceFactory), retryRunner);\n      }),\n    });\n  }\n\n  private registerDefaultActivationScheduler(container: DependencyContainer): void {\n    if (container.isRegistered(CoreTokens.NodeActivationScheduler, true)) {\n      return;\n    }\n    container.register(InlineDrivingScheduler, {\n      useFactory: instanceCachingFactory((dependencyContainer) => {\n        return dependencyContainer\n          .resolve(InlineDrivingSchedulerFactory)\n          .create(dependencyContainer.resolve(NodeExecutor));\n      }),\n    });\n    container.register(CoreTokens.NodeActivationScheduler, {\n      useFactory: instanceCachingFactory((dependencyContainer) => {\n        return dependencyContainer.resolve(InlineDrivingScheduler);\n      }),\n    });\n  }\n\n  private registerEngine(container: DependencyContainer, options: EngineRuntimeRegistrationOptions | undefined): void {\n    container.register(EngineFactory, { useClass: EngineFactory });\n    const matcherProvider = this.resolveMatcherProvider(options);\n    container.register(Engine, {\n      useFactory: instanceCachingFactory((dependencyContainer) => {\n        const liveWorkflowRepository = dependencyContainer.resolve(CoreTokens.LiveWorkflowRepository);\n        const nodeResolver = dependencyContainer.resolve(CoreTokens.NodeResolver);\n        const tokenRegistryLike = dependencyContainer.resolve(CoreTokens.PersistedWorkflowTokenRegistry);\n        const workflowActivationPolicy = dependencyContainer.resolve(CoreTokens.WorkflowActivationPolicy);\n        const webhookTriggerMatcher = matcherProvider.createMatcher(dependencyContainer);\n        const workflowNodeInstanceFactory = dependencyContainer.resolve(CoreTokens.WorkflowNodeInstanceFactory);\n        const triggerRuntimeDiagnostics = options?.triggerRuntimeDiagnosticsProvider?.create(dependencyContainer);\n        return dependencyContainer.resolve(EngineFactory).create({\n          credentialSessions: dependencyContainer.resolve(CoreTokens.CredentialSessionService),\n          liveWorkflowRepository,\n          workflowRepository: dependencyContainer.resolve(CoreTokens.WorkflowRepository),\n          workflowActivationPolicy,\n          nodeResolver,\n          triggerSetupStateRepository: dependencyContainer.resolve(CoreTokens.TriggerSetupStateRepository),\n          webhookTriggerMatcher,\n          runIdFactory: dependencyContainer.resolve(CoreTokens.RunIdFactory),\n          activationIdFactory: dependencyContainer.resolve(CoreTokens.ActivationIdFactory),\n          workflowExecutionRepository: dependencyContainer.resolve(CoreTokens.WorkflowExecutionRepository),\n          activationScheduler: dependencyContainer.resolve(CoreTokens.NodeActivationScheduler),\n          runDataFactory: dependencyContainer.resolve(CoreTokens.RunDataFactory),\n          executionContextFactory: dependencyContainer.resolve(CoreTokens.ExecutionContextFactory),\n          nodeExecutor: dependencyContainer.resolve(NodeExecutor),\n          eventBus: dependencyContainer.resolve(CoreTokens.RunEventBus),\n          tokenRegistry: tokenRegistryLike,\n          workflowNodeInstanceFactory,\n          executionLimitsPolicy: dependencyContainer.resolve(CoreTokens.EngineExecutionLimitsPolicy),\n          triggerRuntimeDiagnostics,\n        });\n      }),\n    });\n  }\n\n  private registerIntentServices(container: DependencyContainer): void {\n    container.register(RunIntentService, {\n      useFactory: instanceCachingFactory((dependencyContainer) => {\n        return dependencyContainer\n          .resolve(RunIntentServiceFactory)\n          .create(dependencyContainer.resolve(Engine), dependencyContainer.resolve(CoreTokens.WorkflowRepository));\n      }),\n    });\n    container.register(CoreTokens.WorkflowRunnerService, {\n      useFactory: instanceCachingFactory((dependencyContainer) => {\n        return dependencyContainer\n          .resolve(EngineWorkflowRunnerServiceFactory)\n          .create(dependencyContainer.resolve(Engine), dependencyContainer.resolve(CoreTokens.WorkflowRepository));\n      }),\n    });\n  }\n\n  private resolveMatcherProvider(options: EngineRuntimeRegistrationOptions | undefined): WebhookTriggerMatcherProvider {\n    if (options?.webhookTriggerMatcherProvider) {\n      return options.webhookTriggerMatcherProvider;\n    }\n    return {\n      createMatcher: (container) =>\n        container\n          .resolve(WorkflowRepositoryWebhookTriggerMatcherFactory)\n          .create(\n            container.resolve(CoreTokens.WorkflowRepository),\n            container.resolve(CoreTokens.WorkflowActivationPolicy),\n            options?.webhookTriggerRoutingDiagnostics,\n          ),\n    };\n  }\n}\n"],"mappings":"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"}