@particle-academy/fancy-flow 0.44.0 → 0.46.0

package/dist/layout/index.d.cts

@@ -1,4 +1,4 @@
-import { F as FlowGraph, b as FlowNode } from '../types-sOmpCitB.cjs';
+import { F as FlowGraph, a as FlowNode } from '../types-Jx1TwehV.cjs';
 import '@xyflow/react';
 
 type AutoLayoutDirection = "LR" | "TB" | "RL" | "BT";

package/dist/layout/index.d.ts

@@ -1,4 +1,4 @@
-import { F as FlowGraph, b as FlowNode } from '../types-sOmpCitB.js';
+import { F as FlowGraph, a as FlowNode } from '../types-Jx1TwehV.js';
 import '@xyflow/react';
 
 type AutoLayoutDirection = "LR" | "TB" | "RL" | "BT";

package/dist/llm/prism.d.cts

@@ -1,5 +1,5 @@
-import { L as LlmClient } from '../capabilities-BtJQTbnw.cjs';
-import '../types-sOmpCitB.cjs';
+import { L as LlmClient } from '../capabilities-Dmd26aAs.cjs';
+import '../types-Jx1TwehV.cjs';
 import '@xyflow/react';
 
 /**

package/dist/llm/prism.d.ts

@@ -1,5 +1,5 @@
-import { L as LlmClient } from '../capabilities-CkhKj_U_.js';
-import '../types-sOmpCitB.js';
+import { L as LlmClient } from '../capabilities-DMUhnyZD.js';
+import '../types-Jx1TwehV.js';
 import '@xyflow/react';
 
 /**

package/dist/llm/vercel-ai.d.cts

@@ -1,6 +1,6 @@
 import { LanguageModel } from 'ai';
-import { a as LlmRouteRequest, L as LlmClient } from '../capabilities-BtJQTbnw.cjs';
-import '../types-sOmpCitB.cjs';
+import { a as LlmRouteRequest, L as LlmClient } from '../capabilities-Dmd26aAs.cjs';
+import '../types-Jx1TwehV.cjs';
 import '@xyflow/react';
 
 /**

package/dist/llm/vercel-ai.d.ts

@@ -1,6 +1,6 @@
 import { LanguageModel } from 'ai';
-import { a as LlmRouteRequest, L as LlmClient } from '../capabilities-CkhKj_U_.js';
-import '../types-sOmpCitB.js';
+import { a as LlmRouteRequest, L as LlmClient } from '../capabilities-DMUhnyZD.js';
+import '../types-Jx1TwehV.js';
 import '@xyflow/react';
 
 /**

package/dist/pause-9iT4tCEV.d.cts

@@ -0,0 +1,96 @@
+/**
+ * The human-pause contract.
+ *
+ * A workflow that waits for a person is not an error, but it travels the same
+ * channel as one: the executor aborts, the engine records a reason string, and
+ * the durable runner decides whether that string meant "failed" or "waiting".
+ *
+ * That seam existed before this module, as two `str_starts_with` checks in the
+ * Laravel run job against constants owned by two BUILTIN executors. It worked,
+ * and it was invisible: a third-party human-input node had no way to announce
+ * that it pauses, and nothing stopped a refactor from removing the mechanism
+ * out from under published packages. Reported by the MOIC Suite consumer, who
+ * needed exactly that and had to reach for a private constant to get it.
+ *
+ * So the encoding is now public, typed, and versioned by prefix rather than
+ * implied. The wire format stays a plain string on purpose — it survives the
+ * existing abort → `RunResult.error` path unchanged, crosses a queue boundary,
+ * and decodes identically in PHP, none of which a thrown class would do.
+ *
+ * @see decodePause — the one function a durable runner needs.
+ */
+/**
+ * What the run is waiting for.
+ *
+ * `approval` and `input` are the shapes both runtimes ship. The type stays open
+ * because the whole point is that a marketplace node can define its own —
+ * a signature step, a payment confirmation, a review queue — and a runner that
+ * does not recognise one should report it rather than guess.
+ */
+type PauseAwaiting = "approval" | "input" | (string & {});
+/** A run halted, waiting for a person. */
+type PauseSignal = {
+    /** The node that paused — where a submission gets injected on resume. */
+    nodeId: string;
+    awaiting: PauseAwaiting;
+    /**
+     * Kind-supplied context for whoever renders the wait — a form schema, the
+     * question being asked, a diff to approve. Must be JSON-serializable: it
+     * crosses a queue boundary and, for durable runs, a database column.
+     */
+    detail?: unknown;
+};
+/** Marks a reason string as a pause rather than a failure. */
+declare const PAUSE_PREFIX = "fancy-flow:pause:";
+/**
+ * Reason prefixes shipped before this contract, kept decodable forever.
+ *
+ * These are what `DurableApprovalExecutor` and `DurableUserInputExecutor`
+ * emitted, and they are written into the `error` column of every run that
+ * paused under an older version. Dropping them would strand those runs
+ * mid-flight — a resume path that only works for new runs is not a resume path.
+ */
+declare const LEGACY_PAUSE_PREFIXES: ReadonlyArray<readonly [string, PauseAwaiting]>;
+/**
+ * Encode a pause as the reason string an executor aborts with.
+ *
+ * The payload is JSON rather than delimited fields because a node id may
+ * contain a colon, and a positional encoding that breaks on user data is the
+ * kind of bug that only shows up in someone else's graph.
+ */
+declare function encodePause(signal: PauseSignal): string;
+/**
+ * Decode a run's error reason into a pause, or null if it was a real failure.
+ *
+ * This is the whole contract from a runner's side: call it on `result.error`,
+ * and if it returns non-null, persist the run as waiting on `signal.nodeId`
+ * instead of failing it. Accepts the legacy prefixes, so a runner written
+ * against this handles runs that paused under an older version.
+ */
+declare function decodePause(reason: string | null | undefined): PauseSignal | null;
+/** True when a run's error reason is actually a pause. */
+declare function isPause(reason: string | null | undefined): boolean;
+/**
+ * Abort the current node as a pause.
+ *
+ * Called from inside an executor with its own context. Node authors should
+ * reach for this rather than hand-encoding a reason, so the format stays ours
+ * to change:
+ *
+ * ```ts
+ * const values = ctx.inputs.values;
+ * if (values === undefined) pauseForHuman(ctx, "input", { fields });
+ * return values;
+ * ```
+ *
+ * Note the `undefined` check — an empty submission (`{}`) is a real answer and
+ * must resume. Truthiness here pauses forever on an empty form.
+ */
+declare function pauseForHuman(ctx: {
+    node: {
+        id: string;
+    };
+    abort: (reason?: string) => never;
+}, awaiting: PauseAwaiting, detail?: unknown): never;
+
+export { LEGACY_PAUSE_PREFIXES as L, type PauseAwaiting as P, PAUSE_PREFIX as a, type PauseSignal as b, decodePause as d, encodePause as e, isPause as i, pauseForHuman as p };

package/dist/pause-9iT4tCEV.d.ts

@@ -0,0 +1,96 @@
+/**
+ * The human-pause contract.
+ *
+ * A workflow that waits for a person is not an error, but it travels the same
+ * channel as one: the executor aborts, the engine records a reason string, and
+ * the durable runner decides whether that string meant "failed" or "waiting".
+ *
+ * That seam existed before this module, as two `str_starts_with` checks in the
+ * Laravel run job against constants owned by two BUILTIN executors. It worked,
+ * and it was invisible: a third-party human-input node had no way to announce
+ * that it pauses, and nothing stopped a refactor from removing the mechanism
+ * out from under published packages. Reported by the MOIC Suite consumer, who
+ * needed exactly that and had to reach for a private constant to get it.
+ *
+ * So the encoding is now public, typed, and versioned by prefix rather than
+ * implied. The wire format stays a plain string on purpose — it survives the
+ * existing abort → `RunResult.error` path unchanged, crosses a queue boundary,
+ * and decodes identically in PHP, none of which a thrown class would do.
+ *
+ * @see decodePause — the one function a durable runner needs.
+ */
+/**
+ * What the run is waiting for.
+ *
+ * `approval` and `input` are the shapes both runtimes ship. The type stays open
+ * because the whole point is that a marketplace node can define its own —
+ * a signature step, a payment confirmation, a review queue — and a runner that
+ * does not recognise one should report it rather than guess.
+ */
+type PauseAwaiting = "approval" | "input" | (string & {});
+/** A run halted, waiting for a person. */
+type PauseSignal = {
+    /** The node that paused — where a submission gets injected on resume. */
+    nodeId: string;
+    awaiting: PauseAwaiting;
+    /**
+     * Kind-supplied context for whoever renders the wait — a form schema, the
+     * question being asked, a diff to approve. Must be JSON-serializable: it
+     * crosses a queue boundary and, for durable runs, a database column.
+     */
+    detail?: unknown;
+};
+/** Marks a reason string as a pause rather than a failure. */
+declare const PAUSE_PREFIX = "fancy-flow:pause:";
+/**
+ * Reason prefixes shipped before this contract, kept decodable forever.
+ *
+ * These are what `DurableApprovalExecutor` and `DurableUserInputExecutor`
+ * emitted, and they are written into the `error` column of every run that
+ * paused under an older version. Dropping them would strand those runs
+ * mid-flight — a resume path that only works for new runs is not a resume path.
+ */
+declare const LEGACY_PAUSE_PREFIXES: ReadonlyArray<readonly [string, PauseAwaiting]>;
+/**
+ * Encode a pause as the reason string an executor aborts with.
+ *
+ * The payload is JSON rather than delimited fields because a node id may
+ * contain a colon, and a positional encoding that breaks on user data is the
+ * kind of bug that only shows up in someone else's graph.
+ */
+declare function encodePause(signal: PauseSignal): string;
+/**
+ * Decode a run's error reason into a pause, or null if it was a real failure.
+ *
+ * This is the whole contract from a runner's side: call it on `result.error`,
+ * and if it returns non-null, persist the run as waiting on `signal.nodeId`
+ * instead of failing it. Accepts the legacy prefixes, so a runner written
+ * against this handles runs that paused under an older version.
+ */
+declare function decodePause(reason: string | null | undefined): PauseSignal | null;
+/** True when a run's error reason is actually a pause. */
+declare function isPause(reason: string | null | undefined): boolean;
+/**
+ * Abort the current node as a pause.
+ *
+ * Called from inside an executor with its own context. Node authors should
+ * reach for this rather than hand-encoding a reason, so the format stays ours
+ * to change:
+ *
+ * ```ts
+ * const values = ctx.inputs.values;
+ * if (values === undefined) pauseForHuman(ctx, "input", { fields });
+ * return values;
+ * ```
+ *
+ * Note the `undefined` check — an empty submission (`{}`) is a real answer and
+ * must resume. Truthiness here pauses forever on an empty form.
+ */
+declare function pauseForHuman(ctx: {
+    node: {
+        id: string;
+    };
+    abort: (reason?: string) => never;
+}, awaiting: PauseAwaiting, detail?: unknown): never;
+
+export { LEGACY_PAUSE_PREFIXES as L, type PauseAwaiting as P, PAUSE_PREFIX as a, type PauseSignal as b, decodePause as d, encodePause as e, isPause as i, pauseForHuman as p };

package/dist/registry/index.d.cts

@@ -1,12 +1,13 @@
-import { d as NodeKindDefinition, j as PortSpec } from '../types-B78Rm69S.cjs';
-export { a as ConfigField, q as CredentialConfigField, D as DocumentConfigField, E as ExpressionConfigField, J as JsonConfigField, K as KeyValueConfigField, L as LEGACY_PAUSE_PREFIXES, c as NodeCategory, r as NumberConfigField, h as PAUSE_PREFIX, P as PauseAwaiting, i as PauseSignal, R as RenderBodyContext, t as RepeaterConfigField, u as RepeaterRowField, w as SelectConfigField, x as SwitchConfigField, T as TextConfigField, y as TextareaConfigField, m as decodePause, n as encodePause, o as isPause, p as pauseForHuman } from '../types-B78Rm69S.cjs';
-import { P as PortDescriptor, b as FlowNode, N as NodeExecutor } from '../types-sOmpCitB.cjs';
+import { N as NodeKindDefinition, P as PortSpec } from '../types--S2Kzx7w.cjs';
+export { C as ConfigField, j as CredentialConfigField, D as DocumentConfigField, E as ExpressionConfigField, J as JsonConfigField, K as KeyValueConfigField, a as NodeCategory, k as NumberConfigField, R as RenderBodyContext, l as RepeaterConfigField, m as RepeaterRowField, n as SelectConfigField, o as SwitchConfigField, T as TextConfigField, p as TextareaConfigField } from '../types--S2Kzx7w.cjs';
+import { P as PortDescriptor, a as FlowNode, N as NodeExecutor } from '../types-Jx1TwehV.cjs';
 import { Connection, Edge, NodeProps, NodeTypes } from '@xyflow/react';
-import { b as LlmRoute } from '../capabilities-BtJQTbnw.cjs';
-export { C as CapabilityId, L as LlmClient, c as LlmRouteChoice, a as LlmRouteRequest, W as WorkflowResolution, d as WorkflowResolutionFailure, e as WorkflowResolver, f as capabilityStatus, g as getLlmClient, h as getWorkflowResolver, i as isResolutionFailure, r as registerLlmClient, j as registerWorkflowResolver } from '../capabilities-BtJQTbnw.cjs';
+import { b as LlmRoute } from '../capabilities-Dmd26aAs.cjs';
+export { C as CapabilityId, L as LlmClient, c as LlmRouteChoice, a as LlmRouteRequest, d as WorkflowResolution, e as WorkflowResolutionFailure, W as WorkflowResolver, f as capabilityStatus, g as getLlmClient, h as getWorkflowResolver, i as isResolutionFailure, r as registerLlmClient, j as registerWorkflowResolver } from '../capabilities-Dmd26aAs.cjs';
+export { L as LEGACY_PAUSE_PREFIXES, a as PAUSE_PREFIX, P as PauseAwaiting, b as PauseSignal, d as decodePause, e as encodePause, i as isPause, p as pauseForHuman } from '../pause-9iT4tCEV.cjs';
 import * as react from 'react';
 import { ComponentType, ReactNode } from 'react';
-export { N as NodeKindPresentation, c as categoryAccent, b as clearNodeKindOverrides, d as defaultConfigFor, g as getNodeKind, k as kindIds, l as listNodeKinds, o as onNodeKindsChanged, e as overrideNodeKind, r as registerNodeKind, a as resolveKindId, v as validateConfig } from '../registry-C9KMVpn7.cjs';
+export { N as NodeKindPresentation, c as categoryAccent, b as clearNodeKindOverrides, d as defaultConfigFor, g as getNodeKind, k as kindIds, l as listNodeKinds, o as onNodeKindsChanged, e as overrideNodeKind, r as registerNodeKind, a as resolveKindId, v as validateConfig } from '../registry-D_kyUZEf.cjs';
 
 /**
  * Connection validation — the single rule that decides whether an edge between

package/dist/registry/index.d.ts

@@ -1,12 +1,13 @@
-import { d as NodeKindDefinition, j as PortSpec } from '../types-JViq8reb.js';
-export { a as ConfigField, q as CredentialConfigField, D as DocumentConfigField, E as ExpressionConfigField, J as JsonConfigField, K as KeyValueConfigField, L as LEGACY_PAUSE_PREFIXES, c as NodeCategory, r as NumberConfigField, h as PAUSE_PREFIX, P as PauseAwaiting, i as PauseSignal, R as RenderBodyContext, t as RepeaterConfigField, u as RepeaterRowField, w as SelectConfigField, x as SwitchConfigField, T as TextConfigField, y as TextareaConfigField, m as decodePause, n as encodePause, o as isPause, p as pauseForHuman } from '../types-JViq8reb.js';
-import { P as PortDescriptor, b as FlowNode, N as NodeExecutor } from '../types-sOmpCitB.js';
+import { N as NodeKindDefinition, P as PortSpec } from '../types-ChkCRonF.js';
+export { C as ConfigField, j as CredentialConfigField, D as DocumentConfigField, E as ExpressionConfigField, J as JsonConfigField, K as KeyValueConfigField, a as NodeCategory, k as NumberConfigField, R as RenderBodyContext, l as RepeaterConfigField, m as RepeaterRowField, n as SelectConfigField, o as SwitchConfigField, T as TextConfigField, p as TextareaConfigField } from '../types-ChkCRonF.js';
+import { P as PortDescriptor, a as FlowNode, N as NodeExecutor } from '../types-Jx1TwehV.js';
 import { Connection, Edge, NodeProps, NodeTypes } from '@xyflow/react';
-import { b as LlmRoute } from '../capabilities-CkhKj_U_.js';
-export { C as CapabilityId, L as LlmClient, c as LlmRouteChoice, a as LlmRouteRequest, W as WorkflowResolution, d as WorkflowResolutionFailure, e as WorkflowResolver, f as capabilityStatus, g as getLlmClient, h as getWorkflowResolver, i as isResolutionFailure, r as registerLlmClient, j as registerWorkflowResolver } from '../capabilities-CkhKj_U_.js';
+import { b as LlmRoute } from '../capabilities-DMUhnyZD.js';
+export { C as CapabilityId, L as LlmClient, c as LlmRouteChoice, a as LlmRouteRequest, d as WorkflowResolution, e as WorkflowResolutionFailure, W as WorkflowResolver, f as capabilityStatus, g as getLlmClient, h as getWorkflowResolver, i as isResolutionFailure, r as registerLlmClient, j as registerWorkflowResolver } from '../capabilities-DMUhnyZD.js';
+export { L as LEGACY_PAUSE_PREFIXES, a as PAUSE_PREFIX, P as PauseAwaiting, b as PauseSignal, d as decodePause, e as encodePause, i as isPause, p as pauseForHuman } from '../pause-9iT4tCEV.js';
 import * as react from 'react';
 import { ComponentType, ReactNode } from 'react';
-export { N as NodeKindPresentation, c as categoryAccent, b as clearNodeKindOverrides, d as defaultConfigFor, g as getNodeKind, k as kindIds, l as listNodeKinds, o as onNodeKindsChanged, e as overrideNodeKind, r as registerNodeKind, a as resolveKindId, v as validateConfig } from '../registry-FGCBprcn.js';
+export { N as NodeKindPresentation, c as categoryAccent, b as clearNodeKindOverrides, d as defaultConfigFor, g as getNodeKind, k as kindIds, l as listNodeKinds, o as onNodeKindsChanged, e as overrideNodeKind, r as registerNodeKind, a as resolveKindId, v as validateConfig } from '../registry-LHB3MlR9.js';
 
 /**
  * Connection validation — the single rule that decides whether an edge between

package/dist/{registry-C9KMVpn7.d.cts → registry-D_kyUZEf.d.cts}

@@ -1,4 +1,4 @@
-import { d as NodeKindDefinition } from './types-B78Rm69S.cjs';
+import { N as NodeKindDefinition } from './types--S2Kzx7w.cjs';
 
 /**
  * The presentation fields a consumer may override on someone else's node kind.

package/dist/{registry-FGCBprcn.d.ts → registry-LHB3MlR9.d.ts}

@@ -1,4 +1,4 @@
-import { d as NodeKindDefinition } from './types-JViq8reb.js';
+import { N as NodeKindDefinition } from './types-ChkCRonF.js';
 
 /**
  * The presentation fields a consumer may override on someone else's node kind.

package/dist/registry.cjs

@@ -323,10 +323,121 @@ function pauseForHuman(ctx, awaiting, detail) {
   return ctx.abort(encodePause({ nodeId: ctx.node.id, awaiting, detail }));
 }
 
+// src/runtime/run-identity.ts
+function escapeSegment(value) {
+  return value.replace(/%/g, "%25").replace(/\//g, "%2F").replace(/#/g, "%23");
+}
+function renderSegment(value, occurrence) {
+  const escaped = escapeSegment(value);
+  return occurrence === void 0 || occurrence === null ? escaped : `${escaped}#${occurrence}`;
+}
+function instant(value) {
+  const ms = Date.parse(value);
+  if (Number.isNaN(ms)) {
+    throw new Error(
+      `RunIdentity: firstAttemptAt is not a parseable timestamp: ${JSON.stringify(value)}`
+    );
+  }
+  return ms;
+}
+var RunIdentity = class _RunIdentity {
+  constructor(runKey, path = [], attempt = 1, firstAttemptAt = (/* @__PURE__ */ new Date()).toISOString()) {
+    if (!runKey || runKey.trim() === "") {
+      throw new Error("RunIdentity: runKey must be a non-empty string.");
+    }
+    this.runKey = runKey;
+    this.path = Object.freeze([...path]);
+    this.attempt = Math.max(1, Math.trunc(attempt));
+    this.firstAttemptAt = firstAttemptAt;
+    Object.freeze(this);
+  }
+  /**
+   * The identity of one execution of one node — stable across retries of that
+   * execution, distinct from every other execution of the same node.
+   *
+   * Pass `occurrence` when an executor runs the same node more than once at the
+   * same level (a loop body, one item of a fan-out it drives itself).
+   */
+  stepKey(nodeId, occurrence) {
+    return `${this.runKey}:${[...this.path, renderSegment(nodeId, occurrence)].join("/")}`;
+  }
+  /**
+   * A child identity for work nested inside this step.
+   *
+   * `subflow` pushes the invoking node's id, so a node inside the child graph
+   * cannot collide with a same-named node in the parent. Attempt and
+   * `firstAttemptAt` are carried down unchanged: the nested work happens inside
+   * this step's attempt, and shares its clock.
+   */
+  descend(segment, occurrence) {
+    return new _RunIdentity(
+      this.runKey,
+      [...this.path, renderSegment(segment, occurrence)],
+      this.attempt,
+      this.firstAttemptAt
+    );
+  }
+  /** A copy on a different attempt, first-attempt clock preserved. */
+  withAttempt(attempt, firstAttemptAt) {
+    return new _RunIdentity(
+      this.runKey,
+      this.path,
+      attempt,
+      firstAttemptAt ?? this.firstAttemptAt
+    );
+  }
+  /**
+   * May this attempt reuse the step key and still be deduplicated?
+   *
+   * Providers forget idempotency keys — Stripe after 24 hours. Past that
+   * window, resending the key creates a second charge and sending a fresh one
+   * creates a second charge, so **the caller must refuse rather than pick
+   * between them**: a loud stuck run beats a silent double write.
+   *
+   * `true` on attempt 1 whatever the elapsed time — nothing was sent on an
+   * earlier attempt, so there is nothing for the provider to have forgotten.
+   * That is what lets a run park on a human gate for a week and then write.
+   *
+   * `windowSeconds: null` means the provider does not expire keys. `0` means
+   * it does not dedupe at all, so no retry may reuse a key — it is a real
+   * window, not an absent one, and the two must not be conflated: reading `0`
+   * as `null` turns "this provider does not dedupe" into "this provider
+   * dedupes forever", which is the more dangerous of the two by a distance.
+   */
+  isReplaySafe(windowSeconds, now2 = /* @__PURE__ */ new Date()) {
+    if (this.attempt <= 1) return true;
+    if (windowSeconds === null || windowSeconds === void 0) return true;
+    if (windowSeconds <= 0) return false;
+    const nowMs = typeof now2 === "string" ? instant(now2) : now2.getTime();
+    const elapsedSeconds = Math.max(0, (nowMs - instant(this.firstAttemptAt)) / 1e3);
+    return elapsedSeconds <= windowSeconds;
+  }
+  toJSON() {
+    return {
+      runKey: this.runKey,
+      path: [...this.path],
+      attempt: this.attempt,
+      firstAttemptAt: this.firstAttemptAt
+    };
+  }
+  /** Rebuild from a queue payload. */
+  static from(value) {
+    if (value instanceof _RunIdentity) return value;
+    if (typeof value === "string") return new _RunIdentity(value);
+    return new _RunIdentity(
+      value.runKey,
+      value.path ?? [],
+      value.attempt ?? 1,
+      value.firstAttemptAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    );
+  }
+};
+
 // src/runtime/run-flow.ts
 async function runFlow(graph, executors, onEvent = () => {
 }, options = {}) {
-  const { signal, initialInputs = {}, timeoutMs, depth = 0 } = options;
+  const { signal, initialInputs = {}, timeoutMs, depth = 0, resumeOutputs = {} } = options;
+  const run = options.run === void 0 ? void 0 : RunIdentity.from(options.run);
   const outputs = {};
   const portValues = /* @__PURE__ */ new Map();
   const completed = /* @__PURE__ */ new Set();
@@ -344,6 +455,18 @@ async function runFlow(graph, executors, onEvent = () => {
     for (const node of order) {
       if (signal?.aborted) throw new Error("aborted");
       if (errors.length) break;
+      if (Object.prototype.hasOwnProperty.call(resumeOutputs, node.id)) {
+        const stored = resumeOutputs[node.id];
+        outputs[node.id] = stored;
+        const activated = activatedPorts(node, stored);
+        for (const portId of activated.ports) {
+          portValues.set(`${node.id}:${portId}`, activated.value);
+          onEvent({ type: "node-output", nodeId: node.id, portId, value: activated.value });
+        }
+        completed.add(node.id);
+        onEvent({ type: "node-status", nodeId: node.id, status: "done", text: "resumed" });
+        continue;
+      }
       const incoming = incomingByNode.get(node.id) ?? [];
       if (incoming.length > 0) {
         const anyActive = incoming.some((e) => portValues.has(`${e.source}:${e.sourceHandle ?? "out"}`));
@@ -383,7 +506,8 @@ async function runFlow(graph, executors, onEvent = () => {
               throw new Error(reason ?? "aborted");
             },
             emit: onEvent,
-            depth
+            depth,
+            run
           })
         );
         outputs[node.id] = result;
@@ -536,7 +660,13 @@ var subflowExecutor = async (ctx) => {
         // require no configuration at all.
         __parent: ctx.inputs
       },
-      depth: depth + 1
+      depth: depth + 1,
+      // Push THIS node onto the identity path, so a node inside the child graph
+      // cannot share an idempotency key with a same-named node in the parent —
+      // or with the same child graph invoked from a different parent node.
+      // Attempt and the first-attempt clock ride down unchanged: the child's
+      // work happens inside this node's attempt.
+      run: ctx.run?.descend(ctx.node.id)
     }
   );
   if (!result.ok) {