langflower 0.0.8 → 0.0.10

package/vendor/node-sdk/dist/node-factory/define-llm-node/llm-inventory-wire.d.ts

@@ -2,3 +2,4 @@
 export declare const SUBAGENT_REGISTRATION_WIRE_TYPE = "subagent-registration";
 export declare const SUBAGENT_SPAWN_WIRE_TYPE = "subagent-spawn";
 export declare const SUBAGENT_RESULT_WIRE_TYPE = "subagent-result";
+//# sourceMappingURL=llm-inventory-wire.d.ts.map

package/vendor/node-sdk/dist/node-factory/define-llm-node/llm-inventory-wire.js

@@ -2,3 +2,4 @@
 export const SUBAGENT_REGISTRATION_WIRE_TYPE = 'subagent-registration';
 export const SUBAGENT_SPAWN_WIRE_TYPE = 'subagent-spawn';
 export const SUBAGENT_RESULT_WIRE_TYPE = 'subagent-result';
+//# sourceMappingURL=llm-inventory-wire.js.map

package/vendor/node-sdk/dist/node-factory/define-llm-node/recovery-notice.d.ts

@@ -5,10 +5,18 @@
  */
 export declare const RECOVERY_PORT_ID: "recovery";
 export type LlmRecoveryNoticeCode = 'retry' | 'suspended';
+export type LlmRecoveryRetryReason = 'idle' | 'dead-loop' | 'rate-limit' | 'provider-unavailable' | 'network';
 export type LlmRecoveryNotice = {
     readonly code: LlmRecoveryNoticeCode;
     readonly text: string;
+    readonly attempt?: number;
+    readonly reason?: LlmRecoveryRetryReason;
+    readonly lastAttemptAt?: number;
+    readonly nextAttemptAt?: number;
+    readonly backoffMs?: number;
 };
 export declare const isLlmRecoveryNotice: (value: unknown) => value is LlmRecoveryNotice;
 export declare const isLlmRecoverySuspended: (value: unknown) => boolean;
 export declare const recoveryNoticeText: (value: unknown) => string;
+/** Port payload: `code` + `text` plus any additive timing fields. */
+export declare const toLlmRecoveryPortValue: (notice: LlmRecoveryNotice) => LlmRecoveryNotice;

package/vendor/node-sdk/dist/node-factory/define-llm-node/recovery-notice.js

@@ -22,3 +22,17 @@ export const recoveryNoticeText = (value) => {
     }
     return '';
 };
+/** Port payload: `code` + `text` plus any additive timing fields. */
+export const toLlmRecoveryPortValue = (notice) => ({
+    code: notice.code,
+    text: notice.text,
+    ...(notice.attempt !== undefined ? { attempt: notice.attempt } : {}),
+    ...(notice.reason !== undefined ? { reason: notice.reason } : {}),
+    ...(notice.lastAttemptAt !== undefined
+        ? { lastAttemptAt: notice.lastAttemptAt }
+        : {}),
+    ...(notice.nextAttemptAt !== undefined
+        ? { nextAttemptAt: notice.nextAttemptAt }
+        : {}),
+    ...(notice.backoffMs !== undefined ? { backoffMs: notice.backoffMs } : {}),
+});

package/vendor/node-sdk/dist/node-factory/define-mcp/mcp-handle.d.ts

@@ -1,8 +1,8 @@
 import type { ToolHandle } from '../define-tool-registrations/tool-handle.js';
 /**
- * Live MCP session handle on LLM `mcp` init ports.
- * Owned by MCP stdio/http nodes and server project MCP seed — agents only
- * flatten `tools`. Not JSON-serializable.
+ * Live MCP session handle owned by MCP stdio/http nodes and server project
+ * MCP seed. Agents consume `tools` only — not a canvas wire type.
+ * Not JSON-serializable.
  */
 export type McpHandle = {
     /** Wire: graph nodeId. System: jsonc `mcp.servers` key. */
@@ -12,4 +12,3 @@ export type McpHandle = {
     /** Tools listed+bound at connect (`tools/list`; system MCP may filter). */
     readonly tools: readonly ToolHandle[];
 };
-export declare const MCP_HANDLE_WIRE_TYPE = "mcp-handle";

package/vendor/node-sdk/dist/node-factory/define-mcp/mcp-handle.js

@@ -1 +1 @@
-export const MCP_HANDLE_WIRE_TYPE = 'mcp-handle';
+export {};

package/vendor/node-sdk/dist/node-factory/define-reactive-node/types.d.ts

@@ -1,5 +1,4 @@
 import type { combineStatefulObservables, StatefulConnection, StatefulObservable } from '@rx-evo/stateful-observable';
-import type { McpHandle } from '../define-mcp/mcp-handle.js';
 import type { ToolHandle } from '../define-tool-registrations/tool-handle.js';
 import type { CtxError } from './ctx-error.js';
 import { configureOutput, InputConfig, makeInput, OutputConfig } from './io-helpers.js';
@@ -8,7 +7,7 @@ import type { AssertConstUISchema, ParamsFromUISchema, TypedUISchema, UISchemaCo
 /**
  * Identity + panel only. Host I/O (files/kb/crawl/…) is owned by specialized
  * common-nodes internally — not part of the author ExecutionContext API.
- * LLM inventory arrives via {@link LlmExecutionCaps} (`toolHandles` / `mcpHandles`).
+ * LLM inventory arrives via {@link LlmExecutionCaps} (`toolHandles`).
  */
 export type ExecutionContext<UI extends readonly UISchemaConstItem[] = readonly UISchemaConstItem[], Caps extends object = Record<string, never>> = {
     readonly projectDir: string;
@@ -18,10 +17,9 @@ export type ExecutionContext<UI extends readonly UISchemaConstItem[] = readonly
     readonly uiSchema: TypedUISchema<UI>;
     readonly amendInput?: (patch: Readonly<Record<string, unknown>>) => void;
 } & Caps;
-/** Caps for {@link defineLlmNode} — outside world via ToolHandle / MCP only. */
+/** Caps for {@link defineLlmNode} — outside world via ToolHandle only. */
 export type LlmExecutionCaps = {
     readonly toolHandles?: readonly ToolHandle[];
-    readonly mcpHandles?: readonly McpHandle[];
 };
 type ReactiveNodeBindResult = {
     readonly inputs: InputConfig[];

package/vendor/node-sdk/dist/node-factory/define-reactive-node/ui-schema-inference.d.ts

@@ -14,7 +14,7 @@ export type UISchemaConstItem = {
     readonly optionsSource?: 'langflower.providers' | 'langflower.models' | 'langflower.tools' | 'langflower.skills' | 'langflower.mcpServers' | 'node.wiredTools';
     readonly dependsOn?: string;
 };
-export type DataTypeToTsType<D extends string> = D extends 'string' | 'url' | 'file-path' | 'select' | 'phase' | 'llm-message' ? string : D extends 'number' ? number : D extends 'boolean' ? boolean : D extends 'json' | 'tool-handle' | 'tool-registration' | 'mcp-handle' | 'mcp-transport' | 'tool-id-list' | 'tool-permission-table' | 'any' ? unknown : D extends 'stream' ? never : unknown;
+export type DataTypeToTsType<D extends string> = D extends 'string' | 'url' | 'file-path' | 'select' | 'phase' | 'llm-message' ? string : D extends 'number' ? number : D extends 'boolean' ? boolean : D extends 'json' | 'tool-handle' | 'tool-registration' | 'tool-id-list' | 'tool-permission-table' | 'any' ? unknown : D extends 'stream' ? never : unknown;
 export type UISchemaItemValue<I extends UISchemaConstItem> = DataTypeToTsType<I['type']>;
 export type UISchemaFieldNames<UI extends readonly UISchemaConstItem[]> = UI[number]['field'];
 export type AssertConstUISchema<UI extends readonly UISchemaConstItem[]> = string extends UISchemaFieldNames<UI> ? never : UI;

package/vendor/node-sdk/package.json

@@ -23,7 +23,7 @@
 		}
 	},
 	"dependencies": {
-		"@rx-evo/stateful-observable": "^0.5.2",
+		"@rx-evo/stateful-observable": "^0.6.0",
 		"rxjs": "^7.8.1"
 	},
 	"files": [

package/vendor/runtime/dist/port-feed-override.d.ts

@@ -0,0 +1,13 @@
+import type { RuntimeFeedPortMeta } from './types.js';
+/**
+ * Tag one port emission with per-event feed meta. Runtime unwraps before
+ * telemetry and edges so the public value stays `T`.
+ */
+export declare const withPortFeed: <T>(value: T, feed: RuntimeFeedPortMeta) => T;
+export declare const readPortFeedOverride: (raw: unknown) => {
+    readonly value: unknown;
+    readonly feed: RuntimeFeedPortMeta;
+} | undefined;
+/** Inner value when tagged; otherwise `raw` unchanged. */
+export declare const unwrapPortFeedValue: (raw: unknown) => unknown;
+//# sourceMappingURL=port-feed-override.d.ts.map

package/vendor/runtime/dist/port-feed-override.js

@@ -0,0 +1,21 @@
+const PORT_FEED_TAG = Symbol.for('langflower.portFeed');
+const isPortFeedBox = (raw) => typeof raw === 'object' && raw !== null && PORT_FEED_TAG in raw;
+/**
+ * Tag one port emission with per-event feed meta. Runtime unwraps before
+ * telemetry and edges so the public value stays `T`.
+ */
+export const withPortFeed = (value, feed) => ({
+    [PORT_FEED_TAG]: { value, feed },
+});
+export const readPortFeedOverride = (raw) => {
+    if (!isPortFeedBox(raw)) {
+        return undefined;
+    }
+    return raw[PORT_FEED_TAG];
+};
+/** Inner value when tagged; otherwise `raw` unchanged. */
+export const unwrapPortFeedValue = (raw) => {
+    const override = readPortFeedOverride(raw);
+    return override === undefined ? raw : override.value;
+};
+//# sourceMappingURL=port-feed-override.js.map

package/vendor/runtime/dist/port-signal-from-response.d.ts

@@ -0,0 +1,15 @@
+import { type ResponseDto } from '@rx-evo/stateful-observable';
+import type { RuntimeFeedPortMeta } from './types.js';
+export type PortEmission = {
+    readonly response: ResponseDto<unknown>;
+    readonly feed: RuntimeFeedPortMeta | undefined;
+};
+/**
+ * JSON-safe {@link ResponseDto} for `PortTelemetry` slot 3, plus per-emit feed.
+ */
+export declare const toPortEmission: (response: unknown, defaultFeed: RuntimeFeedPortMeta | undefined) => PortEmission | null;
+/** Drop sentinels and errors so edges only carry success values. */
+export declare const isEdgeForwardable: (response: unknown) => boolean;
+/** True when `raw$` is the inactive sentinel (unconnected / disconnected). */
+export declare const isInactiveResponse: (response: unknown) => boolean;
+//# sourceMappingURL=port-signal-from-response.d.ts.map

package/vendor/runtime/dist/port-signal-from-response.js

@@ -0,0 +1,48 @@
+import { serializeResponse, } from '@rx-evo/stateful-observable';
+import { normalizePortErrorValue } from './normalize-port-error-value.js';
+import { readPortFeedOverride } from './port-feed-override.js';
+const asResponse = (response) => response;
+const toResponseDto = (response) => {
+    if (response === null || response === undefined) {
+        return null;
+    }
+    const dto = serializeResponse(asResponse(response));
+    if ('error' in dto) {
+        return { error: normalizePortErrorValue(dto.error) };
+    }
+    return dto;
+};
+/**
+ * JSON-safe {@link ResponseDto} for `PortTelemetry` slot 3, plus per-emit feed.
+ */
+export const toPortEmission = (response, defaultFeed) => {
+    const dto = toResponseDto(response);
+    if (dto === null) {
+        return null;
+    }
+    if (!('value' in dto)) {
+        return { response: dto, feed: defaultFeed };
+    }
+    const override = readPortFeedOverride(dto.value);
+    if (override === undefined) {
+        return { response: dto, feed: defaultFeed };
+    }
+    return {
+        response: { value: override.value },
+        feed: override.feed,
+    };
+};
+/** Drop sentinels and errors so edges only carry success values. */
+export const isEdgeForwardable = (response) => {
+    const dto = toResponseDto(response);
+    return dto !== null && 'value' in dto;
+};
+/** True when `raw$` is the inactive sentinel (unconnected / disconnected). */
+export const isInactiveResponse = (response) => {
+    if (response === null || response === undefined) {
+        return true;
+    }
+    const dto = toResponseDto(response);
+    return dto !== null && 'inactive' in dto;
+};
+//# sourceMappingURL=port-signal-from-response.js.map

package/vendor/runtime/dist/runtime-editor.d.ts

@@ -1,5 +1,5 @@
 import { GraphCluster } from './runtime-helpers.js';
-import { RuntimeEdge, RuntimeEditorApi, RuntimeNode, type EdgeId, type NodeId } from './types.js';
+import { RuntimeEdge, RuntimeEditorApi, RuntimeNode, type EdgeId, type NodeId, type SwapNodeResult } from './types.js';
 export declare class RuntimeEditor implements RuntimeEditorApi {
     /** Node ID -> node definition. */
     private readonly nodes;
@@ -20,6 +20,10 @@ export declare class RuntimeEditor implements RuntimeEditorApi {
      * Composer: find occupying → prepare → swap → cleanup/rollback → refresh.
      */
     replaceEdge(edgeInput: Omit<RuntimeEdge, 'edgeId'>): RuntimeEdge | false;
+    /**
+     * Replace the live instance at `nodeId` with `next`. Allowed while locked.
+     */
+    swapNode(nodeId: NodeId, next: Omit<RuntimeNode, 'nodeId'>): SwapNodeResult | false;
     removeNode(nodeId: NodeId): RuntimeNode | false;
     removeEdge(edgeId: EdgeId): RuntimeNode[];
     getNode(nodeId: NodeId): RuntimeNode | false;

package/vendor/runtime/dist/runtime-editor.js

@@ -108,6 +108,25 @@ export class RuntimeEditor {
         this.refreshClusters();
         return occupying;
     }
+    /**
+     * Replace the live instance at `nodeId` with `next`. Allowed while locked.
+     */
+    swapNode(nodeId, next) {
+        if (this.disposed) {
+            return false;
+        }
+        if (!this.nodes.has(nodeId)) {
+            return false;
+        }
+        const runtimeNode = materializeBypassNodeOnAdd({
+            ...next,
+            nodeId,
+        });
+        this.nodes.set(nodeId, runtimeNode);
+        const droppedEdges = this.cleanupInvalidEdges();
+        this.refreshClusters();
+        return { node: runtimeNode, droppedEdges };
+    }
     removeNode(nodeId) {
         if (this.disposed) {
             return false;

package/vendor/runtime/dist/runtime-runner.d.ts

@@ -9,6 +9,8 @@ export declare class RuntimeRunner implements RuntimeRunnerApi {
     private readonly logEvents;
     private readonly eventLogBuffer;
     private activeRun;
+    private pendingWireRunId;
+    private pendingWire;
     private disposed;
     readonly status$: Observable<RuntimeRunnerStatus>;
     /** Synchronous snapshot of {@link status$}. */
@@ -38,9 +40,9 @@ export declare class RuntimeRunner implements RuntimeRunnerApi {
     private pushIntoActiveRun;
     /**
      * Returns `output` wrapped with a `tap` that emits `output-emitted`
-     * telemetry, then `filter(isEdgeForwardable)` so `ResponseError` and
-     * loading sentinels stay visible to Observability on the source node but
-     * are not forwarded on edges (loading must not appear as `{}` downstream).
+     * telemetry, then forward only success values on edges so errors and
+     * loading sentinels stay visible on the source node (loading must not
+     * appear as `{}` downstream).
      * The wrapper is the value the downstream connects to, so the event fires
      * *as part of* the dataflow delivery — there is no separate refCounted
      * subscriber, which is what previously reordered events against downstream
@@ -56,6 +58,9 @@ export declare class RuntimeRunner implements RuntimeRunnerApi {
      */
     private tapInputPort;
     private finishRun;
+    private assertResumeOutputSnapshots;
+    private cancelPendingWire;
+    private flushPendingWire;
     private runScope;
     private teardownRun;
     private applySeeds;

package/vendor/runtime/dist/runtime-runner.js

@@ -1,60 +1,24 @@
-import { combineStatefulObservables, isError, isInactive, isLoading, isSuccess, statefulObservable, } from '@rx-evo/stateful-observable';
+import { combineStatefulObservables, serializeResponse, statefulObservable, } from '@rx-evo/stateful-observable';
 import { BehaviorSubject, filter, merge, of, Subject, Subscription, tap, zip, } from 'rxjs';
 import { checkpointPortIdForSlot, getBypassConnection, isBypassPort, } from './bypass-ports.js';
 import { normalizePortErrorValue } from './normalize-port-error-value.js';
 import { edgePortSlotKey, parseSlotKey, slotKey, } from './port-meta.js';
 import { clusterHasChatEntry, collectClusterSlotKeys, } from './runtime-helpers.js';
+const toResponseDto = (response) => {
+    if (response === null || response === undefined) {
+        return null;
+    }
+    return serializeResponse(response);
+};
 const isConnectionInactive = (connection) => {
     let inactive = true;
     const sub = connection.raw$.subscribe((raw) => {
-        // Same dual-package Symbol hazard as loading (BUG-2026-07-23 /
-        // ADR-028): CJS `isInactive` can miss an ESM inactive sentinel.
-        inactive = isInactive(raw) || isSymbolStateSentinel(raw);
+        const dto = toResponseDto(raw);
+        inactive = dto === null || 'inactive' in dto;
     });
     sub.unsubscribe();
     return inactive;
 };
-/**
- * `@rx-evo` status sentinels are `{ state: Symbol(...) }` (loading / inactive).
- * When the sentinel is created by a different module instance than the
- * `isLoading` / `isInactive` guards (CJS/ESM dual-package hazard), identity
- * checks fail and `isSuccess` may return true — telemetry then emits
- * `state:'value'` with that object (JSON → `{}`), or `applyPortDefaults`
- * skips seeding and LLM `combineInputs` stalls.
- */
-const isSymbolStateSentinel = (signal) => {
-    if (typeof signal !== 'object' ||
-        signal === null ||
-        Array.isArray(signal)) {
-        return false;
-    }
-    const keys = Object.keys(signal);
-    if (keys.length !== 1 || keys[0] !== 'state') {
-        return false;
-    }
-    const state = signal.state;
-    return typeof state === 'symbol';
-};
-const resolveSignalState = (response) => {
-    const signal = response;
-    if (isError(signal)) {
-        return {
-            state: 'error',
-            value: normalizePortErrorValue(signal.error),
-        };
-    }
-    if (isLoading(signal) || isSymbolStateSentinel(signal)) {
-        return { state: 'pending', value: undefined };
-    }
-    if (isSuccess(signal)) {
-        return { state: 'value', value: signal };
-    }
-    return null;
-};
-/** Drop errors and loading so edges only carry success values. */
-const isEdgeForwardable = (response) => !isError(response) &&
-    !isLoading(response) &&
-    !isSymbolStateSentinel(response);
 export class RuntimeRunner {
     editor;
     static EMPTY_EVENT_LOG = [];
@@ -63,6 +27,8 @@ export class RuntimeRunner {
     logEvents;
     eventLogBuffer = [];
     activeRun;
+    pendingWireRunId;
+    pendingWire;
     disposed = false;
     status$ = this.statusSubject.asObservable();
     /** Synchronous snapshot of {@link status$}. */
@@ -143,6 +109,7 @@ export class RuntimeRunner {
             this.finishRun(resolvedRunId);
             return resolvedRunId;
         }
+        this.assertResumeOutputSnapshots(completedNodeIds, outputSnapshots);
         return this.runScope(new Set(nodes.map((node) => node.nodeId)), new Set(edges.map((edge) => edge.edgeId)), options.initialPayload, resolvedRunId, {
             completedNodeIds,
             outputSnapshots,
@@ -169,6 +136,7 @@ export class RuntimeRunner {
             return false;
         }
         const runId = this.runScope(cluster.nodeIds, cluster.edgeIds);
+        this.flushPendingWire();
         const pushedRunId = this.pushIntoActiveRun(cfg);
         if (pushedRunId === false) {
             this.interrupt('cancel');
@@ -181,6 +149,7 @@ export class RuntimeRunner {
         if (this.statusSubject.value !== 'running') {
             return;
         }
+        this.cancelPendingWire();
         this.teardownRun();
         this.setStatus('stopped');
     }
@@ -206,6 +175,7 @@ export class RuntimeRunner {
             return;
         }
         if (this.statusSubject.value === 'running') {
+            this.cancelPendingWire();
             this.teardownRun();
         }
         this.disposed = true;
@@ -239,18 +209,26 @@ export class RuntimeRunner {
         }
         this.eventsSubject.next(event);
     }
-    emitPortEvent(runId, kind, nodeId, portId, portIdx, state, value, edgeIds, feed) {
-        this.emitRunnerEvent({
-            kind,
-            runId,
+    emitPortEvent(_runId, portDir, nodeId, portId, portIdx, raw, edgeIds, defaultFeed) {
+        const dto = toResponseDto(raw);
+        if (dto === null) {
+            return false;
+        }
+        const response = 'error' in dto
+            ? { error: normalizePortErrorValue(dto.error) }
+            : dto;
+        const feed = defaultFeed ?? null;
+        const portIdStr = typeof portId === 'string' ? portId : String(portId);
+        this.emitRunnerEvent([
+            portDir,
             nodeId,
-            portId,
+            portIdStr,
+            response,
             portIdx,
             edgeIds,
-            state,
-            value,
-            ...(feed !== undefined ? { feed } : {}),
-        });
+            feed,
+        ]);
+        return 'value' in response;
     }
     canPreparePushedInput(node, portId) {
         const connection = node.inputs[portId];
@@ -268,6 +246,7 @@ export class RuntimeRunner {
             edge.toPort[1] === 0);
     }
     pushIntoActiveRun(cfg) {
+        this.flushPendingWire();
         const run = this.activeRun;
         if (run === undefined || !run.scopeNodeIds.has(cfg.nodeId)) {
             return false;
@@ -281,7 +260,7 @@ export class RuntimeRunner {
         if (existing !== undefined) {
             // Telemetry before deliver so HITL input-received precedes cascade
             // (output-emitted / downstream input-received) in the event log.
-            this.emitPortEvent(run.runId, 'input-received', cfg.nodeId, cfg.portId, 0, 'value', cfg.payload, []);
+            this.emitPortEvent(run.runId, 'in', cfg.nodeId, cfg.portId, 0, cfg.payload, []);
             existing.source.next(cfg.payload);
             return run.runId;
         }
@@ -300,15 +279,15 @@ export class RuntimeRunner {
             connection,
         });
         run.pushedInputSources.set(key, { source });
-        this.emitPortEvent(run.runId, 'input-received', cfg.nodeId, cfg.portId, 0, 'value', cfg.payload, []);
+        this.emitPortEvent(run.runId, 'in', cfg.nodeId, cfg.portId, 0, cfg.payload, []);
         source.next(cfg.payload);
         return run.runId;
     }
     /**
      * Returns `output` wrapped with a `tap` that emits `output-emitted`
-     * telemetry, then `filter(isEdgeForwardable)` so `ResponseError` and
-     * loading sentinels stay visible to Observability on the source node but
-     * are not forwarded on edges (loading must not appear as `{}` downstream).
+     * telemetry, then forward only success values on edges so errors and
+     * loading sentinels stay visible on the source node (loading must not
+     * appear as `{}` downstream).
      * The wrapper is the value the downstream connects to, so the event fires
      * *as part of* the dataflow delivery — there is no separate refCounted
      * subscriber, which is what previously reordered events against downstream
@@ -322,12 +301,8 @@ export class RuntimeRunner {
         return output
             .pipe(tap({
             next: (response) => {
-                const resolved = resolveSignalState(response);
-                if (resolved === null) {
-                    return;
-                }
-                this.emitPortEvent(run.runId, 'output-emitted', nodeId, portId, 0, resolved.state, resolved.value, edgeIds, output.meta.feed);
-                if (resolved.state === 'value' &&
+                const emittedValue = this.emitPortEvent(run.runId, 'out', nodeId, portId, 0, response, edgeIds, output.meta.feed);
+                if (emittedValue &&
                     node !== false &&
                     node.stopsRun === true) {
                     const finishRunId = run.runId;
@@ -338,7 +313,10 @@ export class RuntimeRunner {
                     });
                 }
             },
-        }), filter(isEdgeForwardable))
+        }), filter((response) => {
+            const dto = toResponseDto(response);
+            return dto !== null && 'value' in dto;
+        }))
             .with({ meta: output.meta });
     }
     /**
@@ -353,11 +331,7 @@ export class RuntimeRunner {
         return source
             .pipe(tap({
             next: (response) => {
-                const resolved = resolveSignalState(response);
-                if (resolved === null) {
-                    return;
-                }
-                this.emitPortEvent(run.runId, 'input-received', nodeId, portId, slotIndex, resolved.state, resolved.value, edgeIds);
+                this.emitPortEvent(run.runId, 'in', nodeId, portId, slotIndex, response, edgeIds);
             },
         }))
             .with({ meta: source.meta });
@@ -369,29 +343,80 @@ export class RuntimeRunner {
         if (this.activeRun !== undefined && this.activeRun.runId !== runId) {
             return;
         }
-        this.emitRunnerEvent({ kind: 'done', runId });
+        this.emitRunnerEvent(['done', runId]);
         this.setStatus('idle');
         this.teardownRun();
     }
+    assertResumeOutputSnapshots(completedNodeIds, outputSnapshots) {
+        const nodesById = new Map(this.editor.getNodes().map((node) => [node.nodeId, node]));
+        for (const edge of this.editor.getEdges()) {
+            if (!completedNodeIds.has(edge.fromNodeId) ||
+                completedNodeIds.has(edge.toNodeId)) {
+                continue;
+            }
+            const fromNode = nodesById.get(edge.fromNodeId);
+            if (fromNode === undefined) {
+                continue;
+            }
+            const [fromPortId, fromSlotIndex] = edge.fromPort;
+            const snapshotPortId = checkpointPortIdForSlot(fromNode, fromPortId, fromSlotIndex);
+            const snapshotValue = outputSnapshots
+                .get(edge.fromNodeId)
+                ?.get(snapshotPortId);
+            if (snapshotValue === undefined) {
+                throw new Error(`Resume missing output snapshot for ${edge.fromNodeId}.${fromPortId}`);
+            }
+        }
+    }
+    cancelPendingWire() {
+        this.pendingWire = undefined;
+        this.pendingWireRunId = undefined;
+    }
+    flushPendingWire() {
+        const wire = this.pendingWire;
+        if (wire === undefined) {
+            return;
+        }
+        this.pendingWire = undefined;
+        this.pendingWireRunId = undefined;
+        wire();
+    }
     runScope(scopeNodeIds, scopeEdgeIds, initialPayload, runId, resumeOverlay) {
         this.assertNotDisposed();
         if (this.statusSubject.value === 'running') {
             return false;
         }
         const resolvedRunId = runId ?? crypto.randomUUID();
-        this.editor.setLocked(true);
-        try {
-            this.activeRun = this.wireScope(resolvedRunId, scopeEdgeIds, scopeNodeIds, initialPayload, resumeOverlay);
-        }
-        catch (error) {
-            this.editor.setLocked(false);
-            throw error;
-        }
         this.setStatus('running');
+        this.editor.setLocked(true);
+        this.pendingWireRunId = resolvedRunId;
+        this.pendingWire = () => {
+            try {
+                this.activeRun = this.wireScope(resolvedRunId, scopeEdgeIds, scopeNodeIds, initialPayload, resumeOverlay);
+            }
+            catch (error) {
+                this.editor.setLocked(false);
+                this.setStatus('idle');
+                throw error;
+            }
+        };
+        queueMicrotask(() => {
+            if (this.pendingWireRunId !== resolvedRunId) {
+                return;
+            }
+            try {
+                this.flushPendingWire();
+            }
+            catch {
+                // Status/lock already restored in pendingWire.
+            }
+        });
         return resolvedRunId;
     }
     teardownRun() {
+        this.cancelPendingWire();
         if (this.activeRun === undefined) {
+            this.editor.setLocked(false);
             return;
         }
         for (const wired of this.activeRun.wiredSlots) {
@@ -429,7 +454,7 @@ export class RuntimeRunner {
                 connection.connect(of(seed.value).pipe(tap({
                     next: (value) => {
                         if (typeof seed.portId !== 'symbol') {
-                            this.emitPortEvent(runId, 'input-received', nodeId, seed.portId, seed.slotIndex, 'value', value, []);
+                            this.emitPortEvent(runId, 'in', nodeId, seed.portId, seed.slotIndex, value, []);
                         }
                     },
                 })));
@@ -467,7 +492,7 @@ export class RuntimeRunner {
                 }
                 connection.connect(of(defaultValue).pipe(tap({
                     next: (value) => {
-                        this.emitPortEvent(runId, 'input-received', nodeId, portId, 0, 'value', value, []);
+                        this.emitPortEvent(runId, 'in', nodeId, portId, 0, value, []);
                     },
                 })));
                 wiredSlotKeys.add(key);
@@ -701,11 +726,7 @@ export class RuntimeRunner {
                         }).with({ meta });
             group.connection.connect(combined.pipe(tap({
                 next: (response) => {
-                    const resolved = resolveSignalState(response);
-                    if (resolved === null) {
-                        return;
-                    }
-                    this.emitPortEvent(run.runId, 'input-received', group.nodeId, group.portId, 0, resolved.state, resolved.value, group.edges.map((entry) => entry.edge.edgeId));
+                    this.emitPortEvent(run.runId, 'in', group.nodeId, group.portId, 0, response, group.edges.map((entry) => entry.edge.edgeId));
                 },
             })));
             wiredSlots.push({

package/vendor/runtime/dist/runtime.d.ts

@@ -6,8 +6,10 @@ export { RuntimeEditor } from './runtime-editor.js';
 export { graphHasCycle } from './runtime-helpers.js';
 export type { GraphCluster } from './runtime-helpers.js';
 export { RuntimeRunner } from './runtime-runner.js';
-export type { MetaFromStatefulObservable, NodeId, EdgeId, RunId, PortMeta, RuntimeEdge, RuntimeEditorApi, RuntimeFeedPortMeta, RuntimeFeedRole, RuntimeInputReceivedEvent, RuntimeNode, RuntimeOutputEmittedEvent, RuntimePortSignalState, RuntimeResumeOptions, RuntimeRunnerApi, RuntimeRunnerEvent, RuntimeRunnerStatus, RuntimeSeedPortValue, RuntimeWireType, } from './types.js';
+export type { MetaFromStatefulObservable, NodeId, EdgeId, RunId, PortMeta, RuntimeEdge, RuntimeEditorApi, RuntimeFeedPortMeta, RuntimeFeedRole, PortTelemetry, RuntimeDoneTelemetry, RuntimeNode, RuntimeResumeOptions, RuntimeRunnerApi, RuntimeRunnerEvent, RuntimeRunnerStatus, RuntimeSeedPortValue, RuntimeWireType, SwapNodeResult, } from './types.js';
+export { isPortErrorTelemetry, isPortPendingTelemetry, isPortTelemetry, isPortValueTelemetry, isRuntimeDone, } from './types.js';
 export type { RuntimeOptions };
+export type { ResponseDto } from '@rx-evo/stateful-observable';
 export declare class RuntimeFacade {
     readonly editor: RuntimeEditor;
     readonly runner: RuntimeRunner;