langflower 0.0.7 → 0.0.9

package/vendor/common-nodes/dist/flow/repeat/node.js

@@ -36,10 +36,11 @@ export const repeatNode = defineReactiveNode({
                 return of({ kind: 'done' });
             }
             return trigger.value$.pipe(startWith(undefined), take(n + 1), observeOn(asapScheduler), map((_, index) => index < n
-                ? { kind: 'value', value: v }
+                ? { kind: 'value', value: v, index }
                 : { kind: 'done' }));
         }));
         const valueOut$ = session$.pipeValue(filter((e) => e.kind === 'value'), map((e) => e.value));
+        const indexOut$ = session$.pipeValue(filter((e) => e.kind === 'value'), map((e) => e.index));
         const doneOut$ = session$.pipeValue(filter((e) => e.kind === 'done'), map(() => true));
         return {
             inputs: [value, count, trigger],
@@ -47,8 +48,12 @@ export const repeatNode = defineReactiveNode({
                 configureOutput('value', valueOut$, {
                     inferTypeFrom: value,
                 }),
+                configureOutput('index', indexOut$, {
+                    wireType: 'number',
+                }),
                 configureOutput('done', doneOut$, {
                     wireType: 'boolean',
+                    feed: { role: 'none' },
                 }),
             ],
         };

package/vendor/common-nodes/dist/langflower-tools/emit-registration-tools.d.ts

@@ -0,0 +1,18 @@
+import { type ToolHandle, type ToolHandler } from '@langflower/node-sdk';
+import { type Observable } from 'rxjs';
+type RegistrationTool = {
+    readonly toolId: string;
+    readonly name?: string;
+    readonly description: string;
+    readonly inputSchema: object;
+    readonly handler: ToolHandler;
+};
+/**
+ * Emit a `tools` pack, peeking **this** node's EC at invoke so bus RPC
+ * stays on the pack instance (not agent `toolCtx`). Local to this folder —
+ * not the author SDK factory.
+ */
+export declare const emitRegistrationTools: (ctx: {
+    readonly value$: Observable<unknown>;
+}, tools: readonly RegistrationTool[]) => import("@rx-evo/stateful-observable").StatefulObservable<ToolHandle[], unknown, undefined>;
+export {};

package/vendor/common-nodes/dist/langflower-tools/emit-registration-tools.js

@@ -0,0 +1,29 @@
+import { statefulObservable } from '@rx-evo/stateful-observable';
+import { of } from 'rxjs';
+const peekNodeContext = (source) => {
+    let peeked;
+    const sub = source.value$.subscribe((value) => {
+        peeked = value;
+    });
+    sub.unsubscribe();
+    return typeof peeked === 'object' && peeked !== null
+        ? peeked
+        : undefined;
+};
+/**
+ * Emit a `tools` pack, peeking **this** node's EC at invoke so bus RPC
+ * stays on the pack instance (not agent `toolCtx`). Local to this folder —
+ * not the author SDK factory.
+ */
+export const emitRegistrationTools = (ctx, tools) => statefulObservable({
+    loader: () => of(tools.map((tool) => ({
+        toolId: tool.toolId,
+        name: tool.name ?? tool.toolId,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        invoke: (args, agentCtx) => {
+            const nodeCtx = peekNodeContext(ctx);
+            return tool.handler(args, nodeCtx ?? agentCtx);
+        },
+    }))),
+});

package/vendor/common-nodes/dist/langflower-tools/node.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Emits Langflower bus tools for agent inventory. Recompile is unsafe:
+ * wire this node’s `tools` into the agent (starter Helper / Writer).
+ */
+export declare const langflowerToolsNode: {
+    readonly emitOncePerActivation: boolean;
+    readonly stopsRun: boolean;
+    readonly chatEntry: boolean;
+    readonly uiSchema: readonly [];
+    readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
+    readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [], Record<string, never>>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
+    readonly outputsConfigs: (import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
+    readonly getInstance: () => import("@langflower/node-sdk").ReactiveNodeInstance<readonly [], Record<string, never>>;
+    readonly paletteSecondary?: true;
+    readonly description?: string;
+    readonly type: string;
+    readonly displayName: string;
+    readonly category: string | undefined;
+    readonly icon: string | undefined;
+};

package/vendor/common-nodes/dist/langflower-tools/node.js

@@ -0,0 +1,77 @@
+import { defineReactiveNode, TOOL_HANDLE_WIRE_TYPE, } from '@langflower/node-sdk';
+import { getRunHostServices } from '../ai/features/run-host-services.js';
+import { emitRegistrationTools } from './emit-registration-tools.js';
+const MISSING_RPC_TEXT = '{ ok: false }\ncompile_custom_nodes unavailable (no bus RPC)';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** Format `customPalette.snapshot` (RPC wait skips `compiling`). */
+const formatPaletteSnapshot = (value) => {
+    if (!isRecord(value)) {
+        return `{ ok: false }\nUnexpected compile result`;
+    }
+    const status = typeof value.status === 'string' ? value.status : 'error';
+    const lines = [`status: ${status}`];
+    const nodes = Array.isArray(value.nodes) ? value.nodes : [];
+    const nodeTypes = nodes.flatMap((node) => isRecord(node) && typeof node.type === 'string' ? [node.type] : []);
+    if (nodeTypes.length > 0) {
+        lines.push(`nodeTypes: ${nodeTypes.join(', ')}`);
+    }
+    const errors = Array.isArray(value.errors) ? value.errors : [];
+    if (errors.length > 0) {
+        lines.push('errors:');
+        for (const error of errors) {
+            if (!isRecord(error)) {
+                continue;
+            }
+            const pack = typeof error.packageName === 'string'
+                ? error.packageName
+                : 'unknown';
+            const message = typeof error.message === 'string' ? error.message : '';
+            lines.push(`- ${pack}: ${message}`);
+        }
+    }
+    return lines.join('\n');
+};
+const LANGFLOWER_BUS_TOOL_CONFIGS = [
+    {
+        toolId: 'compile_custom_nodes',
+        description: 'Recompile `.langflower/nodes/` packs, hot-swap live custom instances, and refresh the Custom palette (same intent as Custom → Update). No arguments. Pack failures also write COMPILATION_ERRORS.md.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+        },
+        handler: (async (_args, ctx) => {
+            const request = getRunHostServices(ctx)?.requestLangflowerBus;
+            if (request === undefined) {
+                return MISSING_RPC_TEXT;
+            }
+            try {
+                const snapshot = await request('customPalette.update.requested', {});
+                return formatPaletteSnapshot(snapshot);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return `{ ok: false }\n${message}`;
+            }
+        }),
+    },
+];
+/**
+ * Emits Langflower bus tools for agent inventory. Recompile is unsafe:
+ * wire this node’s `tools` into the agent (starter Helper / Writer).
+ */
+export const langflowerToolsNode = defineReactiveNode({
+    type: 'common-langflower-tools',
+    displayName: 'Langflower Tools',
+    category: 'Tools',
+    description: 'Emits compile_custom_nodes (Custom → Update over the bus). Wire tools to opt in; later bus actions may be added to this pack.',
+    uiSchema: [],
+    bind(ctx, { configureOutput }) {
+        return {
+            inputs: [],
+            outputs: [
+                configureOutput('tools', emitRegistrationTools(ctx, LANGFLOWER_BUS_TOOL_CONFIGS), { wireType: TOOL_HANDLE_WIRE_TYPE }),
+            ],
+        };
+    },
+});

package/vendor/common-nodes/dist/text/append-file/node.js

@@ -1,7 +1,7 @@
 import { defineReactiveNode } from '@langflower/node-sdk';
 import { createProjectFilesContext } from '@langflower/tools/create-project-files-context';
 import { from, map, mergeMap, throwError } from 'rxjs';
-import { getRunHostServices } from '../../ai/run-host-services.js';
+import { getRunHostServices } from '../../ai/features/run-host-services.js';
 /**
  * Append to a project-relative text file via `createProjectFilesContext` (no permission ask).
  * Non-empty files get `delimiter` between existing text and `content`.

package/vendor/common-nodes/dist/text/read-file/node.js

@@ -1,7 +1,7 @@
 import { defineReactiveNode } from '@langflower/node-sdk';
 import { createProjectFilesContext } from '@langflower/tools/create-project-files-context';
 import { from, mergeMap, throwError } from 'rxjs';
-import { getRunHostServices } from '../../ai/run-host-services.js';
+import { getRunHostServices } from '../../ai/features/run-host-services.js';
 /**
  * Read a project-relative text file via `createProjectFilesContext` (no permission ask).
  * Wire `update` (dynamic) to re-read when the path is unchanged.

package/vendor/common-nodes/dist/text/write-file/node.js

@@ -1,7 +1,7 @@
 import { defineReactiveNode } from '@langflower/node-sdk';
 import { createProjectFilesContext } from '@langflower/tools/create-project-files-context';
 import { from, map, mergeMap, throwError } from 'rxjs';
-import { getRunHostServices } from '../../ai/run-host-services.js';
+import { getRunHostServices } from '../../ai/features/run-host-services.js';
 /**
  * Overwrite a project-relative text file via `createProjectFilesContext` (no permission ask).
  */

package/vendor/common-nodes/dist/tools/inventory-tool-round.d.ts

@@ -1,8 +1,8 @@
 import type { ToolHandle } from '@langflower/node-sdk';
 import { type Harness } from '@langflower/tools/create-project-harness';
 import type { ToolHandlerContext } from '@langflower/tools/domain-tool-configs';
-import type { ChatCompletionToolCall, ChatCompletionToolDefinition } from '../ai/chat-completion-stream.js';
-import type { SubAgentRegistration, SubAgentSpawnPayload } from '../ai/sub-agent-protocol.js';
+import type { ChatCompletionToolCall, ChatCompletionToolDefinition } from '../ai/features/chat-completion-stream.js';
+import type { SubAgentRegistration, SubAgentSpawnPayload } from '../ai/features/sub-agent-protocol.js';
 export declare const SPAWN_SUBAGENT_TOOL = "spawn_subagent";
 export declare const previewToolLogText: (text: string) => string;
 export declare const toChatToolDefinitions: (tools: readonly ToolHandle[]) => readonly ChatCompletionToolDefinition[];

package/vendor/common-nodes/package.json

@@ -14,24 +14,24 @@
 			"import": "./dist/test-nodes/test-index.js"
 		},
 		"./ai/llm-role-preset": {
-			"types": "./dist/ai/llm-role-preset.d.ts",
-			"import": "./dist/ai/llm-role-preset.js"
+			"types": "./dist/ai/features/llm-role-preset.d.ts",
+			"import": "./dist/ai/features/llm-role-preset.js"
 		},
 		"./ai/sub-agent-protocol": {
-			"types": "./dist/ai/sub-agent-protocol.d.ts",
-			"import": "./dist/ai/sub-agent-protocol.js"
+			"types": "./dist/ai/features/sub-agent-protocol.d.ts",
+			"import": "./dist/ai/features/sub-agent-protocol.js"
 		},
 		"./ai/run-host-services": {
-			"types": "./dist/ai/run-host-services.d.ts",
-			"import": "./dist/ai/run-host-services.js"
+			"types": "./dist/ai/features/run-host-services.d.ts",
+			"import": "./dist/ai/features/run-host-services.js"
 		},
 		"./ai/openai/create-chat-completion-stream": {
-			"types": "./dist/ai/openai/create-chat-completion-stream.d.ts",
-			"import": "./dist/ai/openai/create-chat-completion-stream.js"
+			"types": "./dist/ai/features/openai/create-chat-completion-stream.d.ts",
+			"import": "./dist/ai/features/openai/create-chat-completion-stream.js"
 		},
 		"./ai/openai/list-provider-models": {
-			"types": "./dist/ai/openai/list-provider-models.d.ts",
-			"import": "./dist/ai/openai/list-provider-models.js"
+			"types": "./dist/ai/features/openai/list-provider-models.d.ts",
+			"import": "./dist/ai/features/openai/list-provider-models.js"
 		}
 	},
 	"dependencies": {

package/vendor/compiler/dist/compile-project-nodes.d.ts

@@ -7,7 +7,8 @@ export declare const hasCustomNodePacks: (projectDir: string) => Promise<boolean
  * Scan `.langflower/nodes/`. Each pack runs independently; within a pack each
  * `export default` entry is typechecked then esbuilt only if clean.
  * Returns all successful definitions plus all failures (partial success OK).
- * Empty / missing `nodes/` is a no-op (no cache dir).
+ * Always deletes `.langflower/.cache/nodes/` first. Empty / missing `nodes/`
+ * does not recreate the cache dir.
  */
 export declare const compileProjectNodes: (projectDir: string) => Promise<CompileProjectNodesResult>;
 export type { CompileDiagnostic, CompilePackError, CompileProjectNodesResult, } from './compile-types.js';

package/vendor/compiler/dist/compile-project-nodes.js

@@ -1,17 +1,39 @@
 import fs from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { bundleEntry } from './bundle-pack.js';
-import { computePackCacheKey } from './cache-key.js';
 import { discoverPacks } from './discover-packs.js';
 import { diagnosticsForEntry, typecheckPack } from './typecheck-pack.js';
 import { formatCompilePackError } from './format-compilation-errors.js';
 import { parseDefaultExport } from './validate-default-export.js';
 import { deleteCompilationErrorsFile, writeCompilationErrorsFile, } from './write-compilation-errors.js';
 const cacheRoot = (projectDir) => path.join(projectDir, '.langflower', '.cache', 'nodes');
+const wipeCacheRoot = async (projectDir) => {
+    try {
+        await fs.rm(cacheRoot(projectDir), { recursive: true, force: true });
+        return { ok: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            error: formatCompilePackError('.cache/nodes', [
+                {
+                    message: `Failed to delete custom-node cache: ${message}`,
+                },
+            ], projectDir),
+        };
+    }
+};
 const loadBundledDefault = async (outfile, entryPath, packageName, projectDir) => {
-    const href = `${pathToFileURL(outfile).href}?t=${Date.now()}`;
+    const loadFile = path.join(os.tmpdir(), `lf-node-load-${process.hrtime.bigint()}.mjs`);
     try {
+        // Stable outfile stays at `<pack>/<entry>.mjs` for git diff. Import a
+        // unique temp copy so Node / Vitest ESM cache cannot reuse the previous
+        // module for that path (query strings are not enough under Vitest).
+        await fs.copyFile(outfile, loadFile);
+        const href = `${pathToFileURL(loadFile).href}?t=${Date.now()}`;
         const mod = await import(href);
         const defaultExport = typeof mod === 'object' && mod !== null && 'default' in mod
             ? mod.default
@@ -40,9 +62,11 @@ const loadBundledDefault = async (outfile, entryPath, packageName, projectDir) =
 };
 const relativeEntry = (packDir, entryPath) => path.relative(packDir, entryPath).split(path.sep).join('/');
 const compileEntry = async (projectDir, pack, entryPath) => {
-    const cacheKey = await computePackCacheKey(pack.packDir, [entryPath]);
-    const relative = relativeEntry(pack.packDir, entryPath).replace(/[\\/]/g, '__');
-    const outfile = path.join(cacheRoot(projectDir), pack.packageName.replace(/[^\w.-]+/g, '_'), cacheKey, `${relative}.mjs`);
+    const relative = relativeEntry(pack.packDir, entryPath)
+        .replace(/[\\/]/g, '__')
+        .replace(/\.tsx$/u, '')
+        .replace(/\.ts$/u, '');
+    const outfile = path.join(cacheRoot(projectDir), pack.packageName.replace(/[^\w.-]+/g, '_'), `${relative}.mjs`);
     const bundled = await bundleEntry({
         entryPath,
         packDir: pack.packDir,
@@ -95,10 +119,15 @@ export const hasCustomNodePacks = async (projectDir) => {
  * Scan `.langflower/nodes/`. Each pack runs independently; within a pack each
  * `export default` entry is typechecked then esbuilt only if clean.
  * Returns all successful definitions plus all failures (partial success OK).
- * Empty / missing `nodes/` is a no-op (no cache dir).
+ * Always deletes `.langflower/.cache/nodes/` first. Empty / missing `nodes/`
+ * does not recreate the cache dir.
  */
 export const compileProjectNodes = async (projectDir) => {
     const packs = await discoverPacks(projectDir);
+    const wiped = await wipeCacheRoot(projectDir);
+    if (!wiped.ok) {
+        return { nodes: [], errors: [wiped.error] };
+    }
     if (packs.length === 0) {
         return { nodes: [], errors: [] };
     }

package/vendor/compiler/dist/resolve-host-types.d.ts

@@ -8,11 +8,6 @@ export declare const isHostPeerSpecifier: (id: string) => boolean;
  * compiler's install tree. Works with `npm i -g` and an empty project.
  */
 export declare const resolveHostPackageEntry: (specifier: string) => string | undefined;
-/**
- * Stable stamp of resolved host peer roots for cache invalidation when the
- * Langflower install tree moves or upgrades.
- */
-export declare const hostRuntimeEntryStamp: () => string;
 /**
  * Resolve declaration entry for a host package installed next to the
  * compiler (global Langflower tree), using package.json `types` /

package/vendor/compiler/dist/resolve-host-types.js

@@ -64,14 +64,6 @@ export const isHostPeerSpecifier = (id) => {
  * compiler's install tree. Works with `npm i -g` and an empty project.
  */
 export const resolveHostPackageEntry = (specifier) => resolvePackageEntry(specifier);
-/**
- * Stable stamp of resolved host peer roots for cache invalidation when the
- * Langflower install tree moves or upgrades.
- */
-export const hostRuntimeEntryStamp = () => HOST_PEER_PACKAGES.map((name) => {
-    const entry = resolveHostPackageEntry(name);
-    return `${name}=${entry === undefined ? '' : toPosix(entry)}`;
-}).join('\n');
 /**
  * Prefer `exports` types conditions (import → require → default), then
  * top-level `types` / `typings`.

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

@@ -43,4 +43,4 @@ export declare const defineLlmNode: <UI extends readonly UISchemaConstItem[]>(co
 export { LLM_INVENTORY_INPUT_PORT_IDS, LLM_INVENTORY_OUTPUT_PORT_IDS, type LlmInventoryInputs, type LlmInventoryOutputStreams, } from './default-llm-ports.js';
 export { SUBAGENT_REGISTRATION_WIRE_TYPE, SUBAGENT_RESULT_WIRE_TYPE, SUBAGENT_SPAWN_WIRE_TYPE, } from './llm-inventory-wire.js';
 export { STEER_CONTROL_PORT_ID, isSteerControlContinue, isSteerControlPause, isSteerControlPayload, type SteerControlPayload, type SteerControlPause, type SteerControlResume, type SteerControlSteer, } from './steer-control.js';
-export { RECOVERY_PORT_ID, isLlmRecoveryNotice, isLlmRecoverySuspended, recoveryNoticeText, type LlmRecoveryNotice, type LlmRecoveryNoticeCode, } from './recovery-notice.js';
+export { RECOVERY_PORT_ID, isLlmRecoveryNotice, isLlmRecoverySuspended, recoveryNoticeText, toLlmRecoveryPortValue, type LlmRecoveryNotice, type LlmRecoveryNoticeCode, type LlmRecoveryRetryReason, } from './recovery-notice.js';

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

@@ -48,4 +48,4 @@ export const defineLlmNode = (config) => {
 export { LLM_INVENTORY_INPUT_PORT_IDS, LLM_INVENTORY_OUTPUT_PORT_IDS, } from './default-llm-ports.js';
 export { SUBAGENT_REGISTRATION_WIRE_TYPE, SUBAGENT_RESULT_WIRE_TYPE, SUBAGENT_SPAWN_WIRE_TYPE, } from './llm-inventory-wire.js';
 export { STEER_CONTROL_PORT_ID, isSteerControlContinue, isSteerControlPause, isSteerControlPayload, } from './steer-control.js';
-export { RECOVERY_PORT_ID, isLlmRecoveryNotice, isLlmRecoverySuspended, recoveryNoticeText, } from './recovery-notice.js';
+export { RECOVERY_PORT_ID, isLlmRecoveryNotice, isLlmRecoverySuspended, recoveryNoticeText, toLlmRecoveryPortValue, } from './recovery-notice.js';

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/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.js

@@ -239,18 +239,18 @@ 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, state, value, edgeIds, feed) {
+        const portIdStr = typeof portId === 'string' ? portId : String(portId);
+        this.emitRunnerEvent([
+            portDir,
             nodeId,
-            portId,
-            portIdx,
-            edgeIds,
+            portIdStr,
             state,
             value,
-            ...(feed !== undefined ? { feed } : {}),
-        });
+            portIdx,
+            edgeIds,
+            feed ?? null,
+        ]);
     }
     canPreparePushedInput(node, portId) {
         const connection = node.inputs[portId];
@@ -281,7 +281,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, 'value', cfg.payload, []);
             existing.source.next(cfg.payload);
             return run.runId;
         }
@@ -300,7 +300,7 @@ 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, 'value', cfg.payload, []);
         source.next(cfg.payload);
         return run.runId;
     }
@@ -326,7 +326,7 @@ export class RuntimeRunner {
                 if (resolved === null) {
                     return;
                 }
-                this.emitPortEvent(run.runId, 'output-emitted', nodeId, portId, 0, resolved.state, resolved.value, edgeIds, output.meta.feed);
+                this.emitPortEvent(run.runId, 'out', nodeId, portId, 0, resolved.state, resolved.value, edgeIds, output.meta.feed);
                 if (resolved.state === 'value' &&
                     node !== false &&
                     node.stopsRun === true) {
@@ -357,7 +357,7 @@ export class RuntimeRunner {
                 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, resolved.state, resolved.value, edgeIds);
             },
         }))
             .with({ meta: source.meta });
@@ -369,7 +369,7 @@ 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();
     }
@@ -429,7 +429,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', value, []);
                         }
                     },
                 })));
@@ -467,7 +467,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', value, []);
                     },
                 })));
                 wiredSlotKeys.add(key);
@@ -705,7 +705,7 @@ export class RuntimeRunner {
                     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, resolved.state, resolved.value, group.edges.map((entry) => entry.edge.edgeId));
                 },
             })));
             wiredSlots.push({

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

@@ -6,7 +6,8 @@ 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, RuntimePortSignalState, RuntimeResumeOptions, RuntimeRunnerApi, RuntimeRunnerEvent, RuntimeRunnerStatus, RuntimeSeedPortValue, RuntimeWireType, SwapNodeResult, } from './types.js';
+export { isPortTelemetry, isRuntimeDone } from './types.js';
 export type { RuntimeOptions };
 export declare class RuntimeFacade {
     readonly editor: RuntimeEditor;

package/vendor/runtime/dist/runtime.js

@@ -4,6 +4,7 @@ export { bypassOutputPortId, parseBypassOutputPortId } from './bypass-ports.js';
 export { RuntimeEditor } from './runtime-editor.js';
 export { graphHasCycle } from './runtime-helpers.js';
 export { RuntimeRunner } from './runtime-runner.js';
+export { isPortTelemetry, isRuntimeDone } from './types.js';
 export class RuntimeFacade {
     editor;
     runner;

package/vendor/runtime/dist/testing/workflows/workflow-events.d.ts

@@ -1,20 +1,22 @@
+import { type EdgeId, type PortTelemetry, type RunId, type RuntimeEdge, type RuntimeRunnerEvent } from '../../types.js';
 import { RuntimeEditor } from '../../runtime-editor.js';
 import { RuntimeRunner } from '../../runtime-runner.js';
 import { type RuntimeOptions } from '../../runtime.js';
-import type { RunId, RuntimeEdge, RuntimeRunnerEvent } from '../../types.js';
 export type RuntimeHarness = {
     readonly editor: RuntimeEditor;
     readonly runner: RuntimeRunner;
 };
 export declare function createRuntimeHarness(options?: RuntimeOptions): RuntimeHarness;
 export declare function wireEdge(editor: RuntimeEditor, edge: Omit<RuntimeEdge, 'edgeId'>): void;
-export type OutputEmittedEvent = Extract<RuntimeRunnerEvent, {
-    kind: 'output-emitted';
-}>;
-export declare function outputValues(events: readonly RuntimeRunnerEvent[], nodeId: string, portId: string, runId?: string): unknown[];
-export declare function waitForOutput(runtime: RuntimeRunner | RuntimeHarness, nodeId: string, portId: string, runId?: string): Promise<OutputEmittedEvent>;
+export type OutputEmittedEvent = PortTelemetry & {
+    readonly 0: 'out';
+};
+export declare function outputValues(events: readonly RuntimeRunnerEvent[], nodeId: string, portId: string, _runId?: string): unknown[];
+export declare function waitForOutput(runtime: RuntimeRunner | RuntimeHarness, nodeId: string, portId: string, _runId?: string): Promise<OutputEmittedEvent>;
 export declare function runAndCollectEvents(runtime: RuntimeRunner | RuntimeHarness, startRun: () => string, settleMs?: number): Promise<{
     readonly runId: string;
     readonly events: readonly RuntimeRunnerEvent[];
 }>;
 export declare function noDoneWithin(runtime: RuntimeRunner | RuntimeHarness, ms: number, runId?: RunId): Promise<boolean>;
+export declare const edgeIdsFromPortEvent: (event: PortTelemetry) => readonly EdgeId[];
+export declare const portDirLabel: (event: PortTelemetry) => "input-received" | "output-emitted";