@codemation/core 0.3.0 → 0.5.0

package/src/execution/NodeExecutor.ts

@@ -1,80 +1,249 @@
+import { z } from "zod";
+import { isPortsEmission, isUnbrandedPortsEmissionShape } from "../contracts/emitPorts";
+
 import type {
   Item,
+  LineageCarryPolicy,
   MultiInputNode,
-  Node,
   NodeActivationRequest,
+  NodeConfigBase,
+  NodeExecutionContext,
   NodeOutputs,
+  RunnableNode,
+  RunnableNodeConfig,
+  RunnableNodeExecuteArgs,
+  TriggerNode,
   WorkflowNodeInstanceFactory,
 } from "../types";
 
+import { FanInMergeByOriginMerger } from "./FanInMergeByOriginMerger";
+import { ItemValueResolver } from "./ItemValueResolver";
 import { InProcessRetryRunner } from "./InProcessRetryRunner";
+import { NodeOutputNormalizer } from "./NodeOutputNormalizer";
 
 export class NodeExecutor {
+  private readonly fanInMerger = new FanInMergeByOriginMerger();
+  private readonly outputNormalizer = new NodeOutputNormalizer();
+  private readonly itemValueResolver: ItemValueResolver;
+
   constructor(
     private readonly nodeInstanceFactory: WorkflowNodeInstanceFactory,
     private readonly retryRunner: InProcessRetryRunner,
-  ) {}
+    itemValueResolver?: ItemValueResolver,
+  ) {
+    this.itemValueResolver = itemValueResolver ?? new ItemValueResolver();
+  }
 
   async execute(request: NodeActivationRequest): Promise<NodeOutputs> {
     const policy = request.ctx.config.retryPolicy;
     return await this.retryRunner.run(policy, async () => {
       const nodeInstance = this.nodeInstanceFactory.createByType(request.ctx.config.type);
       if (request.kind === "multi") {
-        return await this.executeMultiInputNode(request, nodeInstance);
+        return await this.executeMultiInputActivation(request, nodeInstance);
       }
       return await this.executeSingleInputNode(request, nodeInstance);
     });
   }
 
-  private async executeMultiInputNode(
+  private async executeMultiInputActivation(
     request: Extract<NodeActivationRequest, { kind: "multi" }>,
     node: unknown,
   ): Promise<NodeOutputs> {
     const multiInputNode = node as MultiInputNode;
-    if (typeof (multiInputNode as { executeMulti?: unknown }).executeMulti !== "function") {
-      throw new Error(`Node ${request.nodeId} does not support executeMulti but received multi-input activation`);
+    if (typeof (multiInputNode as { executeMulti?: unknown }).executeMulti === "function") {
+      const raw = await multiInputNode.executeMulti(request.inputsByPort, request.ctx as never);
+      this.assertNoPortEnvelopeBypass(request.nodeId, raw, "executeMulti()");
+      return raw;
     }
-    return await multiInputNode.executeMulti(request.inputsByPort, request.ctx as any);
+    if (this.isRunnableNode(node)) {
+      const merged = this.fanInMerger.merge(request.inputsByPort);
+      const single: Extract<NodeActivationRequest, { kind: "single" }> = {
+        ...request,
+        kind: "single",
+        input: merged,
+      };
+      return await this.executeRunnableActivation(single, node);
+    }
+    throw new Error(
+      `Node ${request.nodeId} does not support executeMulti or RunnableNode.execute but received multi-input activation`,
+    );
   }
 
   private async executeSingleInputNode(
     request: Extract<NodeActivationRequest, { kind: "single" }>,
     node: unknown,
   ): Promise<NodeOutputs> {
-    if (this.hasExecuteOne(node)) {
-      return await this.executeItemNode(request, node);
+    if (this.isTriggerNode(node)) {
+      const raw = await (node as TriggerNode).execute(request.input, request.ctx as never);
+      this.assertNoPortEnvelopeBypass(request.nodeId, raw, "trigger execute()");
+      return raw;
     }
-    const singleInputNode = node as Node;
-    if (typeof (singleInputNode as { execute?: unknown }).execute !== "function") {
-      throw new Error(`Node ${request.nodeId} does not support execute but received single-input activation`);
+    if (this.isRunnableNode(node)) {
+      return await this.executeRunnableActivation(request, node);
     }
-    return await singleInputNode.execute(request.input, request.ctx as any);
+    if (this.hasExecuteMulti(node)) {
+      return await this.executeMultiInputActivation(this.asMultiFromSingleActivation(request), node);
+    }
+    throw new Error(`Node ${request.nodeId} does not support trigger or RunnableNode execution`);
+  }
+
+  private isTriggerNode(node: unknown): node is TriggerNode {
+    return typeof node === "object" && node !== null && (node as { kind?: string }).kind === "trigger";
   }
 
-  private hasExecuteOne(node: unknown): node is { executeOne: (args: unknown) => unknown | Promise<unknown> } {
+  private isRunnableNode(node: unknown): node is RunnableNode {
     return (
-      typeof node === "object" && node !== null && typeof (node as { executeOne?: unknown }).executeOne === "function"
+      typeof node === "object" &&
+      node !== null &&
+      (node as { kind?: string }).kind === "node" &&
+      typeof (node as { execute?: unknown }).execute === "function"
     );
   }
 
-  private async executeItemNode(
+  private hasExecuteMulti(node: unknown): boolean {
+    return typeof (node as { executeMulti?: unknown })?.executeMulti === "function";
+  }
+
+  private asMultiFromSingleActivation(
     request: Extract<NodeActivationRequest, { kind: "single" }>,
-    node: { executeOne: (args: unknown) => unknown | Promise<unknown> },
+  ): Extract<NodeActivationRequest, { kind: "multi" }> {
+    return {
+      kind: "multi",
+      runId: request.runId,
+      activationId: request.activationId,
+      workflowId: request.workflowId,
+      nodeId: request.nodeId,
+      parent: request.parent,
+      executionOptions: request.executionOptions,
+      batchId: request.batchId,
+      ctx: request.ctx,
+      inputsByPort: { in: request.input ?? [] },
+    };
+  }
+
+  private async executeRunnableActivation(
+    request: Extract<NodeActivationRequest, { kind: "single" }>,
+    node: RunnableNode,
   ): Promise<NodeOutputs> {
-    const out: Item[] = [];
-    for (let i = 0; i < request.input.length; i++) {
-      const item = request.input[i] as Item;
-      const outputJson = await Promise.resolve(
-        node.executeOne({
-          input: item.json,
-          item,
-          itemIndex: i,
-          items: request.input,
-          ctx: request.ctx,
-        }),
+    const runnableConfig = request.ctx.config as RunnableNodeConfig;
+    const carry = this.resolveLineageCarry(node, runnableConfig);
+    const inputSchema = this.resolveInputSchema(node, runnableConfig);
+    const inputBatch = request.input ?? [];
+    if (inputBatch.length === 0 && runnableConfig.emptyBatchExecution === "runOnce") {
+      const syntheticItem: Item = { json: {} };
+      const parsed = inputSchema.parse(syntheticItem.json);
+      const runnableCtx = request.ctx as NodeExecutionContext<RunnableNodeConfig>;
+      const resolvedCtx = await this.itemValueResolver.resolveConfigForItem(runnableCtx, syntheticItem, 0, inputBatch);
+      const ctx = this.pickExecutionContext(runnableCtx, resolvedCtx);
+      const args: RunnableNodeExecuteArgs = {
+        input: parsed,
+        item: syntheticItem,
+        itemIndex: 0,
+        items: inputBatch,
+        ctx,
+      };
+      const raw = await Promise.resolve(node.execute(args));
+      return this.outputNormalizer.normalizeExecuteResult({
+        baseItem: syntheticItem,
+        raw,
+        carry,
+      }) as NodeOutputs;
+    }
+    const byPort: Partial<Record<string, Item[]>> = {};
+    for (let i = 0; i < inputBatch.length; i++) {
+      const item = inputBatch[i] as Item;
+      this.assertItemJsonNotTopLevelArray(request.nodeId, item);
+      const parsed = inputSchema.parse(item.json);
+      const runnableCtx = request.ctx as NodeExecutionContext<RunnableNodeConfig>;
+      const resolvedCtx = await this.itemValueResolver.resolveConfigForItem(runnableCtx, item, i, inputBatch);
+      const ctx = this.pickExecutionContext(runnableCtx, resolvedCtx);
+      const args: RunnableNodeExecuteArgs = {
+        input: parsed,
+        item,
+        itemIndex: i,
+        items: inputBatch,
+        ctx,
+      };
+      const raw = await Promise.resolve(node.execute(args));
+      const normalized = this.outputNormalizer.normalizeExecuteResult({
+        baseItem: item,
+        raw,
+        carry,
+      });
+      for (const [port, batch] of Object.entries(normalized)) {
+        if (!batch || batch.length === 0) {
+          continue;
+        }
+        const list = byPort[port] ?? [];
+        list.push(...batch);
+        byPort[port] = list;
+      }
+    }
+    return byPort as NodeOutputs;
+  }
+
+  /** Use resolver ctx only when {@link NodeExecutionContext.config} is non-nullish. */
+  private pickExecutionContext<TConfig extends RunnableNodeConfig<any, any>>(
+    runnableCtx: NodeExecutionContext<TConfig>,
+    resolvedCtx: NodeExecutionContext<TConfig> | null | undefined,
+  ): NodeExecutionContext<TConfig> {
+    if (resolvedCtx != null && resolvedCtx.config != null) {
+      return resolvedCtx;
+    }
+    return runnableCtx;
+  }
+
+  private resolveInputSchema(
+    nodeInstance: RunnableNode,
+    config: RunnableNodeConfig,
+  ): {
+    parse: (data: unknown) => unknown;
+  } {
+    const fromInstance = nodeInstance.inputSchema;
+    if (fromInstance && typeof fromInstance.parse === "function") {
+      return fromInstance as { parse: (data: unknown) => unknown };
+    }
+    const fromConfig = config.inputSchema;
+    if (fromConfig && typeof fromConfig.parse === "function") {
+      return fromConfig as { parse: (data: unknown) => unknown };
+    }
+    return z.unknown();
+  }
+
+  private assertItemJsonNotTopLevelArray(nodeId: string, item: Item): void {
+    if (Array.isArray(item.json)) {
+      throw new Error(`Node ${nodeId}: item.json must not be a top-level JSON array`);
+    }
+  }
+
+  private assertNoPortEnvelopeBypass(nodeId: string, value: unknown, methodName: string): void {
+    if (isPortsEmission(value)) {
+      throw new Error(`Node ${nodeId}: ${methodName} must return NodeOutputs, not emitPorts(...).`);
+    }
+    if (isUnbrandedPortsEmissionShape(value)) {
+      throw new Error(
+        `Node ${nodeId}: ${methodName} returned an unbranded \`{ ports: ... }\` object. Return NodeOutputs instead.`,
       );
-      out.push({ ...item, json: outputJson });
     }
-    return { main: out };
+  }
+
+  private resolveLineageCarry(node: unknown, config: RunnableNodeConfig): LineageCarryPolicy {
+    if (config.lineageCarry) {
+      return config.lineageCarry;
+    }
+
+    const base = config as NodeConfigBase;
+    const declared = base.declaredOutputPorts;
+    const ports =
+      declared && declared.length > 0
+        ? [...new Set([...(declared as readonly string[]), ...(base.nodeErrorHandler ? ["error"] : [])])]
+        : base.nodeErrorHandler
+          ? (["main", "error"] as const)
+          : (["main"] as const);
+
+    if (ports.length > 1) {
+      return "carryThrough";
+    }
+    return "emitOnly";
   }
 }

package/src/execution/NodeOutputNormalizer.ts

@@ -0,0 +1,90 @@
+import { isPortsEmission, isUnbrandedPortsEmissionShape } from "../contracts/emitPorts";
+import type { PortsEmission } from "../contracts/emitPorts";
+import type { Item, JsonNonArray, LineageCarryPolicy, NodeOutputs, OutputPortKey, Items } from "../types";
+
+export class NodeOutputNormalizer {
+  normalizeExecuteResult(
+    args: Readonly<{
+      baseItem: Item;
+      raw: unknown;
+      carry: LineageCarryPolicy;
+    }>,
+  ): NodeOutputs {
+    const { baseItem, raw, carry } = args;
+    if (isPortsEmission(raw)) {
+      return this.emitPortsToOutputs(baseItem, raw, carry);
+    }
+    if (isUnbrandedPortsEmissionShape(raw)) {
+      throw new Error(
+        "execute() returned an unbranded `{ ports: ... }` object. Use emitPorts(...) for multi-port runnable outputs.",
+      );
+    }
+    if (Array.isArray(raw)) {
+      return this.arrayFanOutToMain(baseItem, raw, carry);
+    }
+    if (this.isItemLike(raw)) {
+      return { main: [this.applyLineage(baseItem, raw, carry)] };
+    }
+    return {
+      main: [this.applyLineage(baseItem, { json: raw as JsonNonArray }, carry)],
+    };
+  }
+
+  private arrayFanOutToMain(baseItem: Item, raw: readonly unknown[], carry: LineageCarryPolicy): NodeOutputs {
+    for (const el of raw) {
+      if (Array.isArray(el)) {
+        throw new Error(
+          "execute() fan-out arrays must contain only non-array JSON elements (nested arrays belong inside objects).",
+        );
+      }
+    }
+    const main: Item[] = raw.map((json) => this.applyLineage(baseItem, { json: json as JsonNonArray }, carry));
+    return { main };
+  }
+
+  private emitPortsToOutputs(baseItem: Item, emission: PortsEmission, carry: LineageCarryPolicy): NodeOutputs {
+    const out: NodeOutputs = {};
+    for (const [port, payload] of Object.entries(emission.ports)) {
+      if (payload === undefined) {
+        continue;
+      }
+      out[port as OutputPortKey] = this.normalizePortPayload(baseItem, payload, carry);
+    }
+    return out;
+  }
+
+  private normalizePortPayload(
+    baseItem: Item,
+    payload: Items | ReadonlyArray<JsonNonArray>,
+    carry: LineageCarryPolicy,
+  ): Items {
+    if (payload.length === 0) {
+      return [];
+    }
+    const el0 = payload[0] as unknown;
+    if (this.isItemLike(el0)) {
+      return (payload as Items).map((it) => this.applyLineage(baseItem, it, carry));
+    }
+    return (payload as readonly JsonNonArray[]).map((json) => this.applyLineage(baseItem, { json }, carry));
+  }
+
+  private isItemLike(value: unknown): value is Item {
+    return typeof value === "object" && value !== null && "json" in value;
+  }
+
+  private applyLineage(baseItem: Item, next: Item, carry: LineageCarryPolicy): Item {
+    if (carry === "carryThrough") {
+      return {
+        ...baseItem,
+        ...next,
+        json: next.json,
+      };
+    }
+    return {
+      json: next.json,
+      ...(next.binary ? { binary: next.binary } : {}),
+      ...(next.meta ? { meta: next.meta } : {}),
+      ...(next.paired ? { paired: next.paired } : {}),
+    };
+  }
+}

package/src/execution/index.ts

@@ -5,6 +5,8 @@ export { CredentialResolverFactory } from "./CredentialResolverFactory";
 export { DefaultAsyncSleeper } from "./DefaultAsyncSleeper";
 export { DefaultExecutionContextFactory } from "./DefaultExecutionContextFactory";
 export { InProcessRetryRunner } from "./InProcessRetryRunner";
+export { ItemValueResolver } from "./ItemValueResolver";
+export { NodeOutputNormalizer } from "./NodeOutputNormalizer";
 export { InProcessRetryRunnerFactory } from "./InProcessRetryRunnerFactory";
 export { NodeActivationRequestComposer } from "./NodeActivationRequestComposer";
 export { NodeExecutionSnapshotFactory } from "./NodeExecutionSnapshotFactory";

package/src/index.ts

@@ -18,6 +18,8 @@ export {
   DefaultAsyncSleeper,
   DefaultExecutionContextFactory,
   InProcessRetryRunner,
+  ItemValueResolver,
+  NodeOutputNormalizer,
 } from "./execution";
 export { EngineExecutionLimitsPolicy, type EngineExecutionLimitsPolicyConfig } from "./policies";
 export { InMemoryBinaryStorage, InMemoryRunDataFactory } from "./runStorage";

package/src/orchestration/NodeExecutionRequestHandlerService.ts

@@ -66,7 +66,6 @@ export class NodeExecutionRequestHandlerService implements NodeExecutionRequestH
     const resolvedParent = request.parent ?? state.parent;
     const data = this.runDataFactory.create(state.outputsByNode);
     const limits = this.resolveEngineLimitsFromState(state);
-    const persistedInput = pendingExecution.inputsByPort.in ?? request.input;
     const base = this.runExecutionContextFactory.create({
       runId: state.runId,
       workflowId: state.workflowId,
@@ -78,21 +77,43 @@ export class NodeExecutionRequestHandlerService implements NodeExecutionRequestH
       data,
       nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, resolvedParent),
     });
-    const activationRequest = this.nodeActivationRequestComposer.createSingleFromDefinitionWithActivation({
-      activationId: request.activationId,
-      runId: request.runId,
-      workflowId: request.workflowId,
-      parent: resolvedParent,
-      executionOptions: request.executionOptions ?? state.executionOptions,
-      base,
-      data,
-      definition: {
-        id: definition.id,
-        config: definition.config,
-      },
-      batchId: pendingExecution.batchId ?? "batch_1",
-      input: persistedInput,
-    });
+
+    const inputsByPort = pendingExecution.inputsByPort;
+    const portKeys = Object.keys(inputsByPort);
+    const kind = portKeys.length === 1 && portKeys[0] === "in" ? ("single" as const) : ("multi" as const);
+    const batchId = pendingExecution.batchId ?? "batch_1";
+    const activationRequest =
+      kind === "multi"
+        ? this.nodeActivationRequestComposer.createMultiFromDefinitionWithActivation({
+            activationId: request.activationId,
+            runId: request.runId,
+            workflowId: request.workflowId,
+            parent: resolvedParent,
+            executionOptions: request.executionOptions ?? state.executionOptions,
+            base,
+            data,
+            definition: {
+              id: definition.id,
+              config: definition.config,
+            },
+            batchId,
+            inputsByPort,
+          })
+        : this.nodeActivationRequestComposer.createSingleFromDefinitionWithActivation({
+            activationId: request.activationId,
+            runId: request.runId,
+            workflowId: request.workflowId,
+            parent: resolvedParent,
+            executionOptions: request.executionOptions ?? state.executionOptions,
+            base,
+            data,
+            definition: {
+              id: definition.id,
+              config: definition.config,
+            },
+            batchId,
+            input: inputsByPort.in ?? request.input ?? [],
+          });
 
     await this.continuation.markNodeRunning({
       runId: activationRequest.runId,
@@ -131,7 +152,7 @@ export class NodeExecutionRequestHandlerService implements NodeExecutionRequestH
   }
 
   private async resumeAfterExecutionResult(
-    request: ReturnType<NodeActivationRequestComposer["createSingleFromDefinitionWithActivation"]>,
+    request: Readonly<{ runId: string; activationId: string; nodeId: string }>,
     outputs: unknown,
   ): Promise<void> {
     try {
@@ -147,7 +168,7 @@ export class NodeExecutionRequestHandlerService implements NodeExecutionRequestH
   }
 
   private async resumeAfterExecutionError(
-    request: ReturnType<NodeActivationRequestComposer["createSingleFromDefinitionWithActivation"]>,
+    request: Readonly<{ runId: string; activationId: string; nodeId: string }>,
     error: Error,
   ): Promise<void> {
     try {

package/src/orchestration/RunContinuationService.ts

@@ -335,7 +335,7 @@ export class RunContinuationService {
         nextNodeId: next.nodeId,
         request,
         completedSnapshot,
-        nextNodeSnapshotsByNodeId,
+        nextNodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
         outputsByNode: data.dump(),
         engineCounters,
         error,
@@ -653,6 +653,12 @@ export class RunContinuationService {
     planner.applyOutputs(queue, { fromNodeId: args.args.nodeId, outputs: triggerOutputs as any, batchId });
     const next = planner.nextActivation(queue);
 
+    const finishedAt = completedSnapshot.finishedAt ?? completedSnapshot.updatedAt;
+    const mergedSnapshots = {
+      ...(args.state.nodeSnapshotsByNodeId ?? {}),
+      [args.args.nodeId]: completedSnapshot,
+    };
+
     if (!next) {
       const lastNodeId = WorkflowExecutableNodeClassifierFactory.create(
         args.workflow,
@@ -664,11 +670,8 @@ export class RunContinuationService {
         status: "completed",
         queue: [],
         outputsByNode: data.dump(),
-        nodeSnapshotsByNodeId: {
-          ...(args.state.nodeSnapshotsByNodeId ?? {}),
-          [args.args.nodeId]: completedSnapshot,
-        },
-        finishedAtIso: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt,
+        nodeSnapshotsByNodeId: mergedSnapshots,
+        finishedAtIso: finishedAt,
       });
       await this.workflowExecutionRepository.save(completedState);
       await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -705,11 +708,8 @@ export class RunContinuationService {
         status: "failed",
         queue: queue.map((q) => ({ ...q })),
         outputsByNode: data.dump(),
-        nodeSnapshotsByNodeId: {
-          ...(args.state.nodeSnapshotsByNodeId ?? {}),
-          [args.args.nodeId]: completedSnapshot,
-        },
-        finishedAtIso: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt,
+        nodeSnapshotsByNodeId: mergedSnapshots,
+        finishedAtIso: finishedAt,
       });
       await this.workflowExecutionRepository.save(failedState);
       await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -765,11 +765,6 @@ export class RunContinuationService {
       nodeDefinition: nextDefinition,
     });
 
-    const mergedSnapshots = {
-      ...(args.state.nodeSnapshotsByNodeId ?? {}),
-      [args.args.nodeId]: completedSnapshot,
-    };
-
     try {
       const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
         runId: args.state.runId,
@@ -800,7 +795,6 @@ export class RunContinuationService {
       return result;
     } catch (cause) {
       const error = cause instanceof Error ? cause : new Error(String(cause));
-      const finishedAt = completedSnapshot.finishedAt ?? completedSnapshot.updatedAt;
       const result = await this.terminateRunAfterActivationEnqueueRejected({
         wf: args.workflow,
         state: args.state,

package/src/planning/CurrentStateFrontierPlanner.ts

@@ -200,7 +200,7 @@ export class CurrentStateFrontierPlanner {
         continue;
       }
       const incomingEdges = this.topology.incomingByNode.get(nodeId) ?? [];
-      const isFrontier = incomingEdges.every((edge) => this.isEdgeSatisfied(currentState, nodeId, edge.input));
+      const isFrontier = incomingEdges.every((edge) => this.isEdgeSatisfied(currentState, nodeId, edge.collectKey));
       if (isFrontier) {
         frontierNodeIds.push(nodeId);
       }
@@ -235,7 +235,7 @@ export class CurrentStateFrontierPlanner {
     requiredNodeIds.add(nodeId);
     for (const edge of this.topology.incomingByNode.get(nodeId) ?? []) {
       if (
-        !this.isEdgeSatisfied(currentState, nodeId, edge.input) ||
+        !this.isEdgeSatisfied(currentState, nodeId, edge.collectKey) ||
         this.isNodeSatisfiedByOutputsOnly(currentState, edge.from.nodeId)
       ) {
         this.collectRequiredNode(requiredNodeIds, currentState, edge.from.nodeId);
@@ -249,7 +249,7 @@ export class CurrentStateFrontierPlanner {
       return [];
     }
     const expectedInputs = this.topology.expectedInputsByNode.get(nodeId) ?? [];
-    const usesCollect = expectedInputs.length !== 1 || expectedInputs[0] !== "in";
+    const usesCollect = this.usesCollect(nodeId);
     if (usesCollect) {
       const received: Record<InputPortKey, Items> = {};
       for (const input of expectedInputs) {
@@ -268,7 +268,7 @@ export class CurrentStateFrontierPlanner {
       ];
     }
     const input = expectedInputs[0] ?? "in";
-    const incomingEdge = incomingEdges.find((edge) => edge.input === input);
+    const incomingEdge = incomingEdges.find((edge) => edge.collectKey === input);
     return [
       {
         nodeId,
@@ -298,26 +298,31 @@ export class CurrentStateFrontierPlanner {
     return this.hasOutputs(currentState, nodeId) && !this.hasCompletedSnapshot(currentState, nodeId);
   }
 
-  private isEdgeSatisfied(currentState: RunCurrentState, nodeId: NodeId, input: InputPortKey): boolean {
-    const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input);
+  private isEdgeSatisfied(currentState: RunCurrentState, nodeId: NodeId, collectKey: InputPortKey): boolean {
+    const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find(
+      (edge) => edge.collectKey === collectKey,
+    );
     if (!incomingEdge) {
       return false;
     }
-    if (!this.hasOutputPort(currentState, incomingEdge.from.nodeId, incomingEdge.from.output)) {
+    const fromNodeId = incomingEdge.from.nodeId;
+    if (!this.isNodeSatisfied(currentState, fromNodeId)) {
       return false;
     }
     if (this.usesCollect(nodeId)) {
       return true;
     }
-    const items = this.resolveOutputItems(currentState, incomingEdge.from.nodeId, incomingEdge.from.output);
+    const items = this.resolveOutputItems(currentState, fromNodeId, incomingEdge.from.output);
     if (items.length > 0) {
       return true;
     }
-    return this.shouldContinueAfterEmptyOutputFromSource(incomingEdge.from.nodeId);
+    return this.shouldContinueAfterEmptyOutputFromSource(fromNodeId);
   }
 
-  private resolveInput(currentState: RunCurrentState, nodeId: NodeId, input: InputPortKey): Items {
-    const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input);
+  private resolveInput(currentState: RunCurrentState, nodeId: NodeId, collectKey: InputPortKey): Items {
+    const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find(
+      (edge) => edge.collectKey === collectKey,
+    );
     if (!incomingEdge) {
       return [];
     }
@@ -333,21 +338,16 @@ export class CurrentStateFrontierPlanner {
     return snapshot?.status === "completed" || snapshot?.status === "skipped";
   }
 
-  private hasOutputPort(currentState: RunCurrentState, nodeId: NodeId, output: OutputPortKey): boolean {
-    const outputs = currentState.outputsByNode[nodeId];
-    if (!outputs) {
-      return false;
-    }
-    return Object.prototype.hasOwnProperty.call(outputs, output);
-  }
-
   private resolveOutputItems(currentState: RunCurrentState, nodeId: NodeId, output: OutputPortKey): Items {
     return currentState.outputsByNode[nodeId]?.[output] ?? [];
   }
 
   private usesCollect(nodeId: NodeId): boolean {
     const expectedInputs = this.topology.expectedInputsByNode.get(nodeId) ?? [];
-    return expectedInputs.length !== 1 || expectedInputs[0] !== "in";
+    if (expectedInputs.length !== 1 || expectedInputs[0] !== "in") {
+      return true;
+    }
+    return (this.topology.incomingByNode.get(nodeId) ?? []).length > 1;
   }
 
   private shouldContinueAfterEmptyOutputFromSource(nodeId: NodeId): boolean {