@bian-womp/spark-graph 0.3.46 → 0.3.48

package/lib/src/runtime/GraphRuntime.js

@@ -0,0 +1,729 @@
+import { getInputDeclaredTypes } from "../core/type-utils";
+import { Graph } from "./components/Graph";
+import { EventEmitter } from "./components/EventEmitter";
+import { RunContextManager } from "./components/RunContextManager";
+import { HandleResolver } from "./components/HandleResolver";
+import { EdgePropagator } from "./components/EdgePropagator";
+import { NodeExecutor } from "./components/NodeExecutor";
+import { RuntimeValidatorManager } from "./components/RuntimeValidatorManager";
+import { valuesEqual } from "./utils";
+import { buildEdges, tryHandleResolving } from "./components/graph-utils";
+// Types are now imported from components/types.ts (re-exported above)
+export class GraphRuntime {
+    constructor() {
+        // State
+        this.environment = {};
+        this.runMode = null;
+        this.pauseRefCount = 0;
+        this.persistentPauseToken = null;
+        // Initialize components
+        this.eventEmitter = new EventEmitter();
+        this.graph = new Graph(this.eventEmitter);
+        this.runContextManager = new RunContextManager(this.graph, "info");
+        this.handleResolver = new HandleResolver(this.graph, this.eventEmitter, this.runContextManager, this);
+        this.edgePropagator = new EdgePropagator(this.graph, this.eventEmitter, this.runContextManager, this.handleResolver, this);
+        // Create NodeExecutor with EdgePropagator and HandleResolver
+        this.nodeExecutor = new NodeExecutor(this.graph, this.eventEmitter, this.runContextManager, this.handleResolver, this, this);
+        // Create RuntimeValidatorManager
+        this.runtimeValidatorManager = new RuntimeValidatorManager(this.graph);
+    }
+    static create(def, registry, opts) {
+        const gr = new GraphRuntime();
+        if (opts?.startPaused)
+            gr.pause();
+        gr.environment = opts?.environment ?? {};
+        // Set registry and environment on components
+        gr.graph.setRegistry(registry);
+        gr.handleResolver.setRegistry(registry);
+        gr.handleResolver.setEnvironment(gr.environment);
+        gr.nodeExecutor.setEnvironment(gr.environment);
+        gr.runtimeValidatorManager.setRegistry(registry);
+        // Precompute per-node resolved handles (use def-provided overrides; do not compute dynamically here)
+        const initial = gr.isPaused()
+            ? {
+                resolved: new Map(),
+                pending: new Set(),
+            }
+            : tryHandleResolving(def, registry, gr.environment);
+        if (gr.isPaused()) {
+            gr.handleResolvingSkippedRef = def;
+        }
+        for (const [nodeId, handles] of initial.resolved) {
+            gr.graph.setResolvedHandles(nodeId, handles);
+        }
+        // Instantiate nodes
+        for (const n of def.nodes) {
+            const desc = registry.nodes.get(n.typeId);
+            if (!desc)
+                throw new Error(`Unknown node type: ${n.typeId}`);
+            const cat = registry.categories.get(desc.categoryId);
+            if (!cat)
+                throw new Error(`Unknown category: ${desc.categoryId}`);
+            if (cat.validateImpl)
+                cat.validateImpl(desc.impl);
+            const runtime = cat.createRuntime({
+                nodeId: n.nodeId,
+                impl: desc.impl,
+            });
+            const rn = {
+                typeId: n.typeId,
+                nodeId: n.nodeId,
+                lifecycle: desc.lifecycle,
+                inputs: {},
+                outputs: {},
+                state: {},
+                runtime,
+                params: n.params,
+                policy: {
+                    ...cat.policy,
+                    ...desc.policy,
+                    ...n.params?.policy,
+                },
+                logLevel: desc.logLevel,
+                runSeq: 0,
+                activeControllers: new Set(),
+                controllerRunIds: new Map(),
+                queue: [],
+                stats: {
+                    runs: 0,
+                    active: 0,
+                    queued: 0,
+                    progress: 0,
+                },
+                activeRunContextIds: new Set(),
+                lastInputAt: {},
+                lastSuccessAt: undefined,
+            };
+            gr.graph.setNode(n.nodeId, rn);
+        }
+        // Instantiate edges
+        const resolvedByNode = new Map();
+        gr.graph.forEachResolvedHandles((handles, nodeId) => {
+            resolvedByNode.set(nodeId, handles);
+        });
+        const edges = buildEdges(def, registry, resolvedByNode);
+        gr.graph.setEdges(edges);
+        // Schedule async recompute only for nodes that indicated Promise-based resolveHandles
+        for (const nodeId of initial.pending) {
+            gr.handleResolver.scheduleRecomputeHandles(nodeId);
+        }
+        return gr;
+    }
+    on(event, handler) {
+        return this.eventEmitter.on(event, handler);
+    }
+    setInputs(nodeId, inputs) {
+        const node = this.graph.getNode(nodeId);
+        if (!node)
+            throw new Error(`Node not found: ${nodeId}`);
+        let anyChanged = false;
+        const registry = this.graph.getRegistry();
+        for (const [handle, value] of Object.entries(inputs)) {
+            let hasInbound = false;
+            this.graph.forEachEdge((e) => {
+                if (e.target.nodeId === nodeId && e.target.handle === handle) {
+                    hasInbound = true;
+                }
+            });
+            if (hasInbound)
+                continue;
+            // Validate input value against declared type
+            if (registry) {
+                const desc = registry.nodes.get(node.typeId);
+                const resolved = this.graph.getResolvedHandles(nodeId);
+                // Get declared types (may be union); prefer resolved handles over registry statics
+                const declaredTypes = resolved
+                    ? getInputDeclaredTypes(resolved.inputs, handle)
+                    : desc
+                        ? getInputDeclaredTypes(desc.inputs, handle)
+                        : undefined;
+                const typeIds = Array.isArray(declaredTypes)
+                    ? declaredTypes
+                    : declaredTypes
+                        ? [declaredTypes]
+                        : [];
+                if (typeIds.length > 0) {
+                    const isValidForAny = typeIds.some((tId) => {
+                        const typeDesc = registry.types.get(tId);
+                        // If no validate function, consider it valid
+                        if (!typeDesc?.validate)
+                            return true;
+                        return typeDesc.validate(value);
+                    });
+                    if (value !== undefined && !isValidForAny) {
+                        const typeLabel = typeIds.join("|");
+                        const errorMessage = `Invalid value for input ${nodeId}.${handle} (type ${typeLabel}): ${JSON.stringify(value)}`;
+                        this.eventEmitter.emit("error", {
+                            kind: "input-validation",
+                            nodeId,
+                            handle,
+                            typeId: typeLabel,
+                            value,
+                            message: errorMessage,
+                        });
+                        // Skip storing invalid value
+                        continue;
+                    }
+                }
+            }
+            const prev = node.inputs[handle];
+            const same = valuesEqual(prev, value);
+            if (!same) {
+                this.graph.updateNodeInput(nodeId, handle, value);
+                // Emit value event for input updates
+                this.eventEmitter.emit("value", { nodeId, handle, value, io: "input" });
+                anyChanged = true;
+            }
+        }
+        // In auto mode, input updates can trigger execution; in manual mode they never should.
+        // However, if autoRun policy is set, nodes run automatically even in manual mode.
+        if (anyChanged) {
+            this.handleResolver.scheduleRecomputeHandles(nodeId);
+            this.executeNodeAutoRun(nodeId);
+        }
+    }
+    getOutput(nodeId, output) {
+        const node = this.graph.getNode(nodeId);
+        return node?.outputs[output];
+    }
+    launch(invalidate = false, startPaused = false) {
+        this.graph.forEachNode((node) => {
+            const effectiveInputs = this.nodeExecutor.getEffectiveInputs(node.nodeId);
+            const ctrl = new AbortController();
+            const execCtx = this.nodeExecutor.createExecutionContext(node.nodeId, node, effectiveInputs, `${node.nodeId}:init`, ctrl.signal);
+            if (node.lifecycle?.prepare) {
+                execCtx.log("debug", "prepare-start");
+                node.lifecycle.prepare(node.params ?? {}, execCtx);
+                execCtx.log("debug", "prepare-done");
+            }
+            node.runtime.onActivated?.();
+        });
+        if (this.runMode === "auto" && invalidate) {
+            for (const nodeId of this.graph.getNodeIds()) {
+                if (this.graph.allInboundHaveValue(nodeId))
+                    this.execute(nodeId);
+            }
+        }
+        if (startPaused) {
+            this.pause();
+        }
+    }
+    triggerExternal(nodeId, event) {
+        const node = this.graph.getNode(nodeId);
+        if (!node)
+            return;
+        // If event is an invalidate event, re-run the node with same inputs
+        if (this.isInvalidateEvent(event)) {
+            // Check if node has all inbound inputs (required for execution)
+            if (this.graph.allInboundHaveValue(nodeId)) {
+                this.execute(nodeId);
+            }
+            return;
+        }
+        // Forward event to node's onExternalEvent handler for custom actions
+        node.runtime.onExternalEvent?.(event, node.state);
+    }
+    /**
+     * Check if an event is an invalidate event that should trigger re-execution
+     */
+    isInvalidateEvent(event) {
+        if (!event || typeof event !== "object")
+            return false;
+        // Check if event has action === "invalidate"
+        const e = event;
+        return e.action === "invalidate";
+    }
+    cancelNodeRuns(nodeIds) {
+        this.nodeExecutor.cancelNodeRuns(nodeIds);
+    }
+    getNodeIds() {
+        return this.graph.getNodeIds();
+    }
+    getNodeData(nodeId) {
+        const node = this.graph.getNode(nodeId);
+        if (!node)
+            return undefined;
+        return {
+            inputs: { ...node.inputs },
+            outputs: { ...node.outputs },
+            state: node.state,
+            params: node.params,
+            stats: { ...node.stats },
+        };
+    }
+    getEnvironment() {
+        return { ...this.environment };
+    }
+    setEnvironment(env) {
+        this.environment = { ...env };
+        this.handleResolver.setEnvironment(this.environment);
+        this.nodeExecutor.setEnvironment(this.environment);
+        for (const nodeId of this.graph.getNodeIds()) {
+            this.handleResolver.scheduleRecomputeHandles(nodeId);
+        }
+    }
+    /**
+     * Register a runtime validator that will be called before node execution.
+     * Validators are called in registration order - if any returns true, execution is blocked.
+     */
+    registerRuntimeValidator(validator) {
+        this.runtimeValidatorManager.registerValidator(validator);
+    }
+    /**
+     * Unregister a runtime validator.
+     */
+    unregisterRuntimeValidator(validator) {
+        this.runtimeValidatorManager.unregisterValidator(validator);
+    }
+    /**
+     * Check if any runtime validator blocks execution for this node.
+     * Returns RuntimeValidationError if execution should be blocked, null otherwise.
+     */
+    hasRuntimeValidationBlock(nodeId) {
+        return this.runtimeValidatorManager.hasBlock(nodeId);
+    }
+    getGraphDef() {
+        const nodes = [];
+        this.graph.forEachNode((n) => {
+            const resolved = this.graph.getResolvedHandles(n.nodeId);
+            nodes.push({
+                nodeId: n.nodeId,
+                typeId: n.typeId,
+                params: n.params ? { ...n.params } : undefined,
+                resolvedHandles: resolved ? { ...resolved } : undefined,
+            });
+        });
+        const edges = [];
+        this.graph.forEachEdge((e) => {
+            edges.push({
+                id: e.id,
+                source: { nodeId: e.source.nodeId, handle: e.source.handle },
+                target: { nodeId: e.target.nodeId, handle: e.target.handle },
+                typeId: e.typeId,
+            });
+        });
+        return { nodes, edges };
+    }
+    async whenIdle() {
+        const allRunContexts = this.runContextManager.getAllRunContexts();
+        if (allRunContexts.size > 0) {
+            await new Promise((resolve) => {
+                const check = () => {
+                    if (this.runContextManager.getAllRunContexts().size === 0) {
+                        resolve();
+                    }
+                    else {
+                        setTimeout(check, 10);
+                    }
+                };
+                setTimeout(check, 10);
+            });
+        }
+        const isIdle = () => {
+            let idle = true;
+            this.graph.forEachNode((n) => {
+                if (n.activeControllers.size > 0 || n.queue.length > 0) {
+                    idle = false;
+                }
+            });
+            return idle;
+        };
+        if (isIdle())
+            return;
+        await new Promise((resolve) => {
+            const check = () => {
+                if (isIdle())
+                    resolve();
+                else
+                    setTimeout(check, 10);
+            };
+            setTimeout(check, 10);
+        });
+    }
+    async runFromHereContext(startNodeId, options) {
+        const node = this.graph.getNode(startNodeId);
+        if (!node)
+            return;
+        return new Promise((resolve) => {
+            const id = this.runContextManager.createRunContext(startNodeId, {
+                resolve,
+                ...options,
+            });
+            this.graph.addNodeRunContextId(startNodeId, id);
+            this.execute(startNodeId, new Set([id]));
+        });
+    }
+    setRunMode(runMode) {
+        this.runMode = runMode;
+    }
+    getRunMode() {
+        return this.runMode;
+    }
+    requestPause() {
+        this.pauseRefCount++;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.pauseRefCount--;
+        };
+    }
+    isPaused() {
+        return this.pauseRefCount > 0;
+    }
+    pause() {
+        if (!this.persistentPauseToken) {
+            this.persistentPauseToken = this.requestPause();
+        }
+    }
+    resume() {
+        if (this.persistentPauseToken) {
+            this.persistentPauseToken();
+            this.persistentPauseToken = null;
+            // If handle resolving was skipped, trigger it now
+            if (this.handleResolvingSkippedRef) {
+                const registry = this.graph.getRegistry();
+                if (registry) {
+                    const result = tryHandleResolving(this.handleResolvingSkippedRef, registry, this.environment);
+                    for (const [nodeId, handles] of result.resolved) {
+                        this.graph.setResolvedHandles(nodeId, handles);
+                    }
+                    for (const nodeId of result.pending) {
+                        this.handleResolver.scheduleRecomputeHandles(nodeId);
+                    }
+                }
+                this.handleResolvingSkippedRef = undefined;
+            }
+        }
+    }
+    executeNodeAutoRun(nodeId) {
+        const node = this.graph.getNode(nodeId);
+        const shouldAutoRun = this.runMode === "auto" || node?.policy?.autoRun === true;
+        let runContextIdsToUse = undefined;
+        if (this.runMode === "manual") {
+            runContextIdsToUse = new Set([
+                this.runContextManager.createRunContext(nodeId, { propagate: false }),
+            ]);
+        }
+        if (shouldAutoRun && this.graph.allInboundHaveValue(nodeId)) {
+            this.execute(nodeId, runContextIdsToUse);
+        }
+    }
+    copyOutputs(fromNodeId, toNodeId, options) {
+        const fromNode = this.getNodeData(fromNodeId);
+        if (!fromNode?.outputs)
+            return;
+        this.hydrate({ outputs: { [toNodeId]: { ...fromNode.outputs } } }, { invalidate: !options?.dry });
+        this.handleResolver.scheduleRecomputeHandles(toNodeId);
+        this.executeNodeAutoRun(toNodeId);
+    }
+    hydrate(payload, opts) {
+        const releasePause = this.requestPause();
+        try {
+            const ins = payload?.inputs || {};
+            const nodesWithChangedInputs = new Set();
+            for (const [nodeId, map] of Object.entries(ins)) {
+                if (!this.graph.hasNode(nodeId))
+                    continue;
+                let nodeChanged = false;
+                for (const [h, v] of Object.entries(map || {})) {
+                    const node = this.graph.getNode(nodeId);
+                    const prev = node?.inputs[h];
+                    const clonedValue = structuredClone(v);
+                    const same = valuesEqual(prev, clonedValue);
+                    if (!same) {
+                        this.graph.updateNodeInput(nodeId, h, clonedValue, false);
+                        nodeChanged = true;
+                    }
+                }
+                if (nodeChanged) {
+                    nodesWithChangedInputs.add(nodeId);
+                }
+            }
+            const outs = payload?.outputs || {};
+            for (const [nodeId, map] of Object.entries(outs)) {
+                if (!this.graph.hasNode(nodeId))
+                    continue;
+                for (const [h, v] of Object.entries(map || {})) {
+                    const clonedValue = structuredClone(v);
+                    this.graph.updateNodeOutput(nodeId, h, clonedValue);
+                }
+            }
+            // Trigger handle resolution for nodes with changed inputs
+            for (const nodeId of nodesWithChangedInputs) {
+                this.handleResolver.scheduleRecomputeHandles(nodeId);
+            }
+            if (opts?.invalidate) {
+                for (const nodeId of this.graph.getNodeIds()) {
+                    this.invalidateDownstream(nodeId);
+                }
+            }
+        }
+        finally {
+            releasePause();
+        }
+    }
+    update(def, registry) {
+        {
+            // Delete nodes that are no longer in the definition
+            const afterIds = new Set(def.nodes.map((n) => n.nodeId));
+            const beforeIds = new Set(this.graph.getNodeIds());
+            for (const nodeId of Array.from(beforeIds)) {
+                if (!afterIds.has(nodeId)) {
+                    const node = this.graph.getNode(nodeId);
+                    if (!node)
+                        continue;
+                    this.nodeExecutor.cancelNodeActiveRuns(node, "node-deleted");
+                    this.runContextManager.cancelNodeInRunContexts(nodeId, true);
+                    node.runtime.onDeactivated?.();
+                    node.runtime.dispose?.();
+                    node.lifecycle?.dispose?.({
+                        state: node.state,
+                        setState: (next) => this.graph.updateNodeState(node.nodeId, next),
+                    });
+                    this.graph.deleteNode(nodeId);
+                    this.edgePropagator.clearArrayBuckets(nodeId);
+                }
+            }
+        }
+        {
+            // Add or update nodes that are in the definition
+            for (const n of def.nodes) {
+                const existing = this.graph.getNode(n.nodeId);
+                if (!existing) {
+                    const desc = registry.nodes.get(n.typeId);
+                    if (!desc)
+                        throw new Error(`Unknown node type: ${n.typeId}`);
+                    const cat = registry.categories.get(desc.categoryId);
+                    if (!cat)
+                        throw new Error(`Unknown category: ${desc.categoryId}`);
+                    if (cat.validateImpl)
+                        cat.validateImpl(desc.impl);
+                    const runtime = cat.createRuntime({
+                        nodeId: n.nodeId,
+                        impl: desc.impl,
+                    });
+                    const newNode = {
+                        typeId: n.typeId,
+                        nodeId: n.nodeId,
+                        lifecycle: desc.lifecycle,
+                        inputs: {},
+                        outputs: {},
+                        state: {},
+                        runtime,
+                        params: n.params,
+                        policy: {
+                            ...cat.policy,
+                            ...desc.policy,
+                            ...n.params?.policy,
+                        },
+                        runSeq: 0,
+                        activeControllers: new Set(),
+                        controllerRunIds: new Map(),
+                        queue: [],
+                        stats: {
+                            runs: 0,
+                            active: 0,
+                            queued: 0,
+                            progress: 0,
+                        },
+                        activeRunContextIds: new Set(),
+                        lastInputAt: {},
+                        lastSuccessAt: undefined,
+                    };
+                    this.graph.setNode(n.nodeId, newNode);
+                    const effectiveInputs = this.nodeExecutor.getEffectiveInputs(newNode.nodeId);
+                    const ctrl = new AbortController();
+                    const execCtx = this.nodeExecutor.createExecutionContext(newNode.nodeId, newNode, effectiveInputs, `${newNode.nodeId}:init`, ctrl.signal);
+                    if (newNode.lifecycle?.prepare) {
+                        execCtx.log("debug", "prepare-start");
+                        newNode.lifecycle.prepare(newNode.params ?? {}, execCtx);
+                        execCtx.log("debug", "prepare-done");
+                    }
+                    newNode.runtime.onActivated?.();
+                }
+                else {
+                    this.graph.updateNodeParams(n.nodeId, n.params);
+                    // Re-merge policy when params change (params.policy can override descriptor/category policy)
+                    const desc = registry.nodes.get(existing.typeId);
+                    const cat = registry.categories.get(desc?.categoryId ?? "");
+                    this.graph.updateNodePolicy(n.nodeId, {
+                        ...cat?.policy,
+                        ...desc?.policy,
+                        ...n.params?.policy,
+                    });
+                    // Initialize stats if missing
+                    if (!existing.stats) {
+                        this.graph.updateNodeStats(n.nodeId, {
+                            runs: 0,
+                            active: 0,
+                            queued: 0,
+                            progress: 0,
+                        });
+                    }
+                }
+            }
+        }
+        {
+            const beforeInbound = new Map();
+            const beforeOutTargets = new Map();
+            this.graph.forEachEdge((e) => {
+                // Build beforeInbound map
+                const set = beforeInbound.get(e.target.nodeId) ?? new Set();
+                set.add(e.target.handle);
+                beforeInbound.set(e.target.nodeId, set);
+                // Build beforeOutTargets map
+                const tmap = beforeOutTargets.get(e.source.nodeId) ??
+                    new Map();
+                const tset = tmap.get(e.source.handle) ?? new Set();
+                tset.add(`${e.target.nodeId}.${e.target.handle}`);
+                tmap.set(e.source.handle, tset);
+                beforeOutTargets.set(e.source.nodeId, tmap);
+            });
+            {
+                // Update handles and edges
+                const result = this.isPaused()
+                    ? {
+                        resolved: new Map(),
+                        pending: new Set(),
+                    }
+                    : tryHandleResolving(def, registry, this.environment);
+                if (this.isPaused()) {
+                    this.handleResolvingSkippedRef = def;
+                }
+                const changedHandles = {};
+                for (const [nodeId, newHandles] of result.resolved) {
+                    const oldHandles = this.graph.getResolvedHandles(nodeId);
+                    if (!oldHandles ||
+                        JSON.stringify(oldHandles) !== JSON.stringify(newHandles)) {
+                        changedHandles[nodeId] = newHandles;
+                    }
+                }
+                for (const [nodeId, handles] of result.resolved) {
+                    this.graph.setResolvedHandles(nodeId, handles);
+                }
+                const resolvedByNode = new Map();
+                this.graph.forEachResolvedHandles((handles, nodeId) => {
+                    resolvedByNode.set(nodeId, handles);
+                });
+                const afterEdges = buildEdges(def, registry, resolvedByNode);
+                this.graph.setEdges(afterEdges);
+                for (const nodeId of result.pending) {
+                    this.handleResolver.scheduleRecomputeHandles(nodeId);
+                }
+                if (Object.keys(changedHandles).length > 0) {
+                    this.eventEmitter.emit("invalidate", {
+                        reason: "graph-updated",
+                        resolvedHandles: changedHandles,
+                    });
+                }
+            }
+            {
+                // Update inputs and propagate changes
+                const afterInbound = new Map();
+                this.graph.forEachEdge((e) => {
+                    const set = afterInbound.get(e.target.nodeId) ?? new Set();
+                    set.add(e.target.handle);
+                    afterInbound.set(e.target.nodeId, set);
+                });
+                // Propagate changes on edges removed
+                for (const [nodeId, beforeSet] of beforeInbound) {
+                    const currSet = afterInbound.get(nodeId) ?? new Set();
+                    if (!this.graph.hasNode(nodeId))
+                        continue;
+                    let changed = false;
+                    for (const handle of Array.from(beforeSet)) {
+                        if (!currSet.has(handle)) {
+                            const node = this.graph.getNode(nodeId);
+                            if (node && handle in node.inputs) {
+                                this.graph.updateNodeInput(nodeId, handle, undefined);
+                                changed = true;
+                            }
+                        }
+                    }
+                    if (changed) {
+                        this.edgePropagator.clearArrayBuckets(nodeId);
+                        // Trigger handle resolution when inputs are removed
+                        this.handleResolver.scheduleRecomputeHandles(nodeId);
+                        this.executeNodeAutoRun(nodeId);
+                    }
+                }
+                // Propagate changes on edges added
+                const afterOutTargets = new Map();
+                this.graph.forEachEdge((e) => {
+                    const targetMap = afterOutTargets.get(e.source.nodeId) ??
+                        new Map();
+                    const targetSet = targetMap.get(e.source.handle) ?? new Set();
+                    targetSet.add(`${e.target.nodeId}.${e.target.handle}`);
+                    targetMap.set(e.source.handle, targetSet);
+                    afterOutTargets.set(e.source.nodeId, targetMap);
+                });
+                const setsEqual = (a, b) => {
+                    if (!a && !b)
+                        return true;
+                    if (!a || !b)
+                        return false;
+                    if (a.size !== b.size)
+                        return false;
+                    for (const v of a)
+                        if (!b.has(v))
+                            return false;
+                    return true;
+                };
+                const nodesToCheck = new Set([
+                    ...Array.from(beforeOutTargets.keys()),
+                    ...Array.from(afterOutTargets.keys()),
+                ]);
+                for (const nodeId of nodesToCheck) {
+                    const beforeMap = beforeOutTargets.get(nodeId) ?? new Map();
+                    const afterMap = afterOutTargets.get(nodeId) ?? new Map();
+                    const handles = new Set([
+                        ...Array.from(beforeMap.keys()),
+                        ...Array.from(afterMap.keys()),
+                    ]);
+                    for (const handle of handles) {
+                        const beforeTargetSet = beforeMap.get(handle) ?? new Set();
+                        const afterTargetSet = afterMap.get(handle) ?? new Set();
+                        if (!setsEqual(beforeTargetSet, afterTargetSet)) {
+                            const val = this.getOutput(nodeId, handle);
+                            if (val !== undefined) {
+                                let runContextIdsToUse = undefined;
+                                if (this.runMode === "manual") {
+                                    runContextIdsToUse = new Set([
+                                        this.runContextManager.createRunContext(nodeId, {
+                                            propagate: false,
+                                        }),
+                                    ]);
+                                }
+                                this.propagate(nodeId, handle, val, runContextIdsToUse);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    dispose() {
+        this.runContextManager.resolveAll();
+        this.graph.forEachNode((node) => {
+            node.runtime.onDeactivated?.();
+            node.runtime.dispose?.();
+            node.lifecycle?.dispose?.({
+                state: node.state,
+                setState: (next) => this.graph.updateNodeState(node.nodeId, next),
+            });
+        });
+        this.graph.clear();
+    }
+    execute(nodeId, runContextIds, canSkipHandleResolution) {
+        this.nodeExecutor.execute(nodeId, runContextIds, canSkipHandleResolution);
+    }
+    propagate(srcNodeId, srcHandle, value, runContextIds) {
+        this.edgePropagator.propagate(srcNodeId, srcHandle, value, runContextIds);
+    }
+    invalidateDownstream(nodeId) {
+        this.edgePropagator.invalidateDownstream(nodeId);
+    }
+}
+//# sourceMappingURL=GraphRuntime.js.map