@bian-womp/spark-workbench 0.3.88 → 0.3.90

package/lib/src/misc/context/WorkbenchContext.provider.js

@@ -0,0 +1,995 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useWorkbenchGraphTick, useWorkbenchGraphUiTick, useWorkbenchVersionTick } from "../hooks";
+import { WorkbenchContext } from "./WorkbenchContext";
+import { estimateNodeSize, computeEffectiveHandles } from "../layout";
+import { resolveOutputDisplay } from "../value";
+import { excludeViewportFromUIState, isValidViewport } from "../viewport-utils";
+// Helper to compute invalidated status from runtime metadata
+function computeInvalidatedFromMetadata(metadata) {
+    if (!metadata)
+        return true;
+    const { lastSuccessAt, lastInputAt, lastRunAt } = metadata;
+    if (!lastSuccessAt && !lastRunAt)
+        return true;
+    if (!lastInputAt || Object.keys(lastInputAt).length === 0)
+        return false;
+    const maxInputTime = Math.max(...Object.values(lastInputAt));
+    return maxInputTime > (lastSuccessAt ?? lastRunAt ?? 0);
+}
+export function WorkbenchProvider({ wb, runner, overrides, uiVersion, children, }) {
+    const [nodeStatus, setNodeStatus] = useState({});
+    const [edgeStatus, setEdgeStatus] = useState({});
+    const [runMode, setRunModeState] = useState("manual");
+    const [events, setEvents] = useState([]);
+    const clearEvents = useCallback(() => setEvents([]), []);
+    const [systemErrors, setSystemErrors] = useState([]);
+    const [registryErrors, setRegistryErrors] = useState([]);
+    const [inputValidationErrors, setInputValidationErrors] = useState([]);
+    const [registryVersion, setRegistryVersion] = useState(0);
+    const [registryReady, setRegistryReady] = useState(false);
+    const clearSystemErrors = useCallback(() => setSystemErrors([]), []);
+    const clearRegistryErrors = useCallback(() => setRegistryErrors([]), []);
+    const clearInputValidationErrors = useCallback(() => setInputValidationErrors([]), []);
+    const removeSystemError = useCallback((index) => {
+        setSystemErrors((prev) => prev.filter((_, idx) => idx !== index));
+    }, []);
+    const removeRegistryError = useCallback((index) => {
+        setRegistryErrors((prev) => prev.filter((_, idx) => idx !== index));
+    }, []);
+    const removeInputValidationError = useCallback((index) => {
+        setInputValidationErrors((prev) => prev.filter((_, idx) => idx !== index));
+    }, []);
+    // Fallback progress animation: drive progress to 100% over ~2 minutes
+    const FALLBACK_TOTAL_MS = 2 * 60 * 1000;
+    const [fallbackStarts, setFallbackStarts] = useState({});
+    // Track runs that emitted an error so we can keep progress on completion
+    const errorRunsRef = useRef({});
+    // Periodically advance fallback progress for running nodes without explicit progress
+    useEffect(() => {
+        const interval = setInterval(() => {
+            setNodeStatus((prev) => {
+                let changed = false;
+                const next = { ...prev };
+                const now = Date.now();
+                for (const id of Object.keys(prev)) {
+                    const st = prev[id];
+                    if (!st)
+                        continue;
+                    const runs = st.activeRuns ?? 0;
+                    const startAt = fallbackStarts[id];
+                    if (runs > 0 && startAt) {
+                        const cur = Math.max(0, Math.min(1, Number(st.progress) || 0));
+                        const elapsed = Math.max(0, now - startAt);
+                        // Approach 100% over the target window, but cap below 1 until done
+                        const target = Math.max(0, Math.min(0.99, elapsed / FALLBACK_TOTAL_MS));
+                        const merged = Math.max(cur, target);
+                        if (merged > cur + 0.005 && merged <= 1) {
+                            next[id] = { ...st, progress: merged };
+                            changed = true;
+                        }
+                    }
+                }
+                return changed ? next : prev;
+            });
+        }, 200);
+        return () => clearInterval(interval);
+    }, [fallbackStarts]);
+    // Validation
+    const [validation, setValidation] = useState(undefined);
+    // Selection (mirror workbench selectionChanged)
+    const [selectedNodeId, setSelectedNodeId] = useState();
+    const [selectedEdgeId, setSelectedEdgeId] = useState();
+    const setSelection = useCallback((sel) => wb.setSelection(sel), [wb]);
+    // Ticks
+    const graphTick = useWorkbenchGraphTick(wb);
+    const graphUiTick = useWorkbenchGraphUiTick(wb);
+    const versionTick = useWorkbenchVersionTick(runner);
+    const valuesTick = versionTick + graphTick + graphUiTick;
+    useEffect(() => {
+        const offRunnerStatus = runner.on("status", (status) => {
+            if (status.runMode) {
+                setRunModeState(status.runMode);
+            }
+        });
+        return () => {
+            offRunnerStatus();
+        };
+    }, [runner]);
+    const handlesMap = useMemo(() => {
+        const out = {};
+        for (const n of wb.def.nodes) {
+            out[n.nodeId] = computeEffectiveHandles(n, wb.registry);
+        }
+        return out;
+    }, [wb, wb.def, graphTick, wb.registry, registryVersion]);
+    // Def and IO values
+    const inputsMap = useMemo(() => runner.getInputs(wb.def), [runner, wb, wb.def, valuesTick]);
+    const inputDefaultsMap = useMemo(() => runner.getInputDefaults(wb.def), [runner, wb, wb.def, valuesTick]);
+    const outputsMap = useMemo(() => runner.getOutputs(wb.def), [runner, wb, wb.def, valuesTick]);
+    const outputTypesMap = useMemo(() => {
+        const out = {};
+        // Local: runtimeTypeId is not stored; derive from typed wrapper in outputsMap
+        for (const n of wb.def.nodes) {
+            const outputsDecl = handlesMap[n.nodeId]?.outputs ?? {};
+            const handles = Object.keys(outputsDecl);
+            const cur = {};
+            for (const h of handles) {
+                const v = outputsMap[n.nodeId]?.[h];
+                const declared = outputsDecl[h];
+                const { typeId } = resolveOutputDisplay(v, declared);
+                cur[h] = typeId;
+            }
+            if (Object.keys(cur).length > 0)
+                out[n.nodeId] = cur;
+        }
+        return out;
+    }, [wb, wb.def, outputsMap, handlesMap]);
+    // Initialize nodes and derive invalidated status from persisted metadata
+    useEffect(() => {
+        const workbenchRuntimeState = wb.getRuntimeState() ?? { nodes: {} };
+        setNodeStatus((prev) => {
+            const next = { ...prev };
+            const metadata = workbenchRuntimeState;
+            for (const n of wb.def.nodes) {
+                const cur = next[n.nodeId] ?? (next[n.nodeId] = {});
+                const nodeMeta = metadata.nodes[n.nodeId];
+                const updates = {};
+                if (cur.invalidated === undefined) {
+                    updates.invalidated = computeInvalidatedFromMetadata(nodeMeta);
+                }
+                if (cur.activeRunIds === undefined) {
+                    updates.activeRunIds = [];
+                }
+                if (cur.activeRuns === undefined) {
+                    updates.activeRuns = 0;
+                }
+                if (nodeMeta?.lastErrorSummary && cur.lastError === undefined) {
+                    updates.lastError = nodeMeta.lastErrorSummary;
+                }
+                if (Object.keys(updates).length > 0) {
+                    next[n.nodeId] = { ...cur, ...updates };
+                }
+            }
+            return next;
+        });
+    }, [wb.def, wb]);
+    // Auto layout (simple layered layout)
+    const runAutoLayout = useCallback(() => {
+        // Build DAG layers by indegree
+        const indegree = {};
+        const adj = {};
+        for (const n of wb.def.nodes) {
+            indegree[n.nodeId] = 0;
+            adj[n.nodeId] = [];
+        }
+        for (const e of wb.def.edges) {
+            indegree[e.target.nodeId] = (indegree[e.target.nodeId] ?? 0) + 1;
+            adj[e.source.nodeId].push(e.target.nodeId);
+        }
+        const q = Object.keys(indegree).filter((k) => indegree[k] === 0);
+        const layers = [];
+        while (q.length) {
+            const layer = [];
+            const next = [];
+            for (const id of q) {
+                layer.push(id);
+                for (const nb of adj[id]) {
+                    indegree[nb] -= 1;
+                    if (indegree[nb] === 0)
+                        next.push(nb);
+                }
+            }
+            layers.push(layer);
+            q.splice(0, q.length, ...next);
+        }
+        // Size-aware placement: columns by layer, stacking nodes vertically in each column
+        // Use the same sizing heuristic as mapping via estimateNodeSize
+        const H_GAP = 160;
+        const V_GAP = 24;
+        const pos = {};
+        let curX = 0;
+        for (const layer of layers) {
+            // Compute max width in this layer and individual heights
+            let maxWidth = 0;
+            const heights = {};
+            for (const id of layer) {
+                const node = wb.def.nodes.find((n) => n.nodeId === id);
+                if (!node)
+                    continue;
+                // Prefer showValues sizing similar to node rendering
+                // Consider per-type overrides when available via UI
+                const overrideSize = overrides?.getDefaultNodeSize?.(node.typeId) ?? undefined;
+                const size = estimateNodeSize({
+                    node,
+                    registry: wb.registry,
+                    showValues: true,
+                    overrides: overrideSize,
+                });
+                heights[id] = size.height;
+                if (size.width > maxWidth)
+                    maxWidth = size.width;
+            }
+            // Place nodes in this column
+            let curY = 0;
+            for (const id of layer) {
+                const h = heights[id] ?? 0;
+                pos[id] = { x: curX, y: curY };
+                curY += h + V_GAP;
+            }
+            curX += maxWidth + H_GAP;
+        }
+        wb.setPositions(pos, { commit: true, reason: "auto-layout" });
+    }, [wb, wb.def, wb.registry, registryVersion, overrides?.getDefaultNodeSize]);
+    const updateEdgeType = useCallback((edgeId, typeId) => wb.updateEdgeType(edgeId, typeId), [wb]);
+    const triggerExternal = useCallback((nodeId, event) => runner.triggerExternal(nodeId, event), [runner]);
+    const getNodeDisplayName = useCallback((nodeId) => {
+        const customName = wb.getNodeName(nodeId);
+        if (customName)
+            return customName;
+        const node = wb.def.nodes.find((n) => n.nodeId === nodeId);
+        if (!node)
+            return nodeId;
+        const desc = wb.registry.nodes.get(node.typeId);
+        return desc?.displayName || node.typeId;
+    }, [wb, wb.registry, registryVersion]);
+    const setNodeName = useCallback((nodeId, name) => {
+        wb.setNodeName(nodeId, name, { commit: true, reason: "rename-node" });
+    }, [wb]);
+    // Helper to save runtime metadata and UI state to extData
+    const saveUiRuntimeMetadata = useCallback(async (workbench, graphRunner) => {
+        try {
+            const currentRuntime = workbench.getRuntimeState() ?? { nodes: {} };
+            const runtimeMetaData = { nodes: { ...currentRuntime.nodes } };
+            const customMetaData = workbench.getCustomData();
+            // Clean up metadata for nodes that no longer exist
+            const nodeIds = new Set(workbench.def.nodes.map((n) => n.nodeId));
+            for (const nodeId of Object.keys(runtimeMetaData.nodes)) {
+                if (!nodeIds.has(nodeId)) {
+                    delete runtimeMetaData.nodes[nodeId];
+                }
+            }
+            // Save cleaned metadata to workbench state
+            workbench.setRuntimeState(runtimeMetaData);
+            const fullUiState = workbench.getUIState();
+            const uiWithoutViewport = excludeViewportFromUIState(fullUiState);
+            // Use updateExtData for efficient batched partial updates
+            const updates = [];
+            if (Object.keys(uiWithoutViewport || {}).length > 0) {
+                updates.push({ path: "ui", value: uiWithoutViewport });
+            }
+            updates.push({ path: "runtime", value: runtimeMetaData });
+            updates.push({ path: "custom", value: customMetaData });
+            await graphRunner.updateExtData(updates);
+        }
+        catch (err) {
+            console.warn("[WorkbenchContext] Failed to save runtime metadata:", err);
+        }
+    }, []);
+    // Subscribe to runner/workbench events
+    useEffect(() => {
+        const add = (source, type) => (payload) => setEvents((prev) => {
+            if (source === "workbench" && (type === "graphChanged" || type === "graphUiChanged")) {
+                const changeType = payload.change?.type;
+                if (changeType === "moveNode" || changeType === "moveNodes" || changeType === "resizeNodes")
+                    return prev;
+            }
+            const nextNo = prev.length > 0 ? (prev[0]?.no ?? 0) + 1 : 1;
+            const next = [
+                {
+                    no: nextNo,
+                    at: Date.now(),
+                    source,
+                    type,
+                    payload: structuredClone(payload),
+                },
+                ...prev,
+            ];
+            return next.length > 200 ? next.slice(0, 200) : next;
+        });
+        // Helper to apply resolved handles from event payload to workbench
+        const applyResolvedHandles = (resolvedHandles) => {
+            for (const n of wb.def.nodes) {
+                const updated = resolvedHandles[n.nodeId];
+                if (updated) {
+                    const before = JSON.stringify(n.resolvedHandles || {});
+                    const after = JSON.stringify(updated);
+                    if (before !== after) {
+                        wb.updateResolvedHandles(n.nodeId, updated, { dry: true });
+                    }
+                }
+            }
+        };
+        const offRunnerValue = runner.on("value", (e) => {
+            if (e?.dry)
+                return;
+            const now = Date.now();
+            if (e?.io === "input") {
+                const nodeId = e.nodeId;
+                const handle = e.handle;
+                // Track input timestamp in workbench runtime state
+                wb.updateNodeRuntimeMetadata(nodeId, (nodeMeta) => ({
+                    ...nodeMeta,
+                    lastInputAt: {
+                        ...(nodeMeta.lastInputAt ?? {}),
+                        [handle]: now,
+                    },
+                }));
+                // Clear validation errors for this input when a valid value is set
+                setInputValidationErrors((prev) => prev.filter((err) => !(err.nodeId === nodeId && err.handle === handle)));
+            }
+            else if (e?.io === "output") {
+                const nodeId = e.nodeId;
+                const handle = e.handle;
+                // Track output timestamp in workbench runtime state
+                wb.updateNodeRuntimeMetadata(nodeId, (nodeMeta) => ({
+                    ...nodeMeta,
+                    lastOutputAt: {
+                        ...(nodeMeta.lastOutputAt ?? {}),
+                        [handle]: now,
+                    },
+                }));
+            }
+            return add("runner", "value")(e);
+        });
+        const offRunnerError = runner.on("error", (e) => {
+            const edgeError = e;
+            const nodeError = e;
+            const registryError = e;
+            const systemError = e;
+            const inputValidationError = e;
+            if (edgeError.kind === "edge-convert") {
+                const edgeId = edgeError.edgeId;
+                setEdgeStatus((s) => ({
+                    ...s,
+                    [edgeId]: { ...s[edgeId], lastError: edgeError.err },
+                }));
+            }
+            else if (nodeError.kind === "node-run" && nodeError.nodeId) {
+                const nodeId = nodeError.nodeId;
+                const runId = nodeError.runId;
+                const now = Date.now();
+                // Track error timestamp and summary in workbench runtime state
+                const err = nodeError.err;
+                let errorSummary;
+                if (err && typeof err === "object") {
+                    const errAny = err;
+                    const message = errAny.userMessage || errAny.message || String(err);
+                    const code = errAny.statusCode || errAny.code;
+                    errorSummary = {
+                        message: typeof message === "string" ? message : String(message),
+                        code: typeof code === "number" ? code : undefined,
+                    };
+                }
+                wb.updateNodeRuntimeMetadata(nodeId, (nodeMeta) => ({
+                    ...nodeMeta,
+                    lastErrorAt: now,
+                    lastRunAt: now,
+                    ...(errorSummary ? { lastErrorSummary: errorSummary } : {}),
+                }));
+                setNodeStatus((s) => ({
+                    ...s,
+                    [nodeId]: {
+                        ...s[nodeId],
+                        lastError: errorSummary,
+                    },
+                }));
+                // Mark this runId as errored
+                if (runId) {
+                    errorRunsRef.current[nodeId] = {
+                        ...errorRunsRef.current[nodeId],
+                        [runId]: true,
+                    };
+                }
+            }
+            else if (registryError.kind === "registry") {
+                // Track registry errors for UI display
+                setRegistryErrors((prev) => {
+                    // Avoid duplicates by checking message
+                    if (prev.some((err) => err.message === registryError.message)) {
+                        return prev;
+                    }
+                    return [...prev, registryError];
+                });
+            }
+            else if (inputValidationError.kind === "input-validation") {
+                // Track input validation errors for UI display
+                setInputValidationErrors((prev) => {
+                    // Avoid duplicates by checking nodeId, handle, and typeId
+                    if (prev.some((err) => err.nodeId === inputValidationError.nodeId &&
+                        err.handle === inputValidationError.handle &&
+                        err.typeId === inputValidationError.typeId)) {
+                        return prev;
+                    }
+                    return [...prev, inputValidationError];
+                });
+            }
+            else if (systemError.kind === "system") {
+                // Track custom errors for UI display
+                setSystemErrors((prev) => {
+                    // Avoid duplicates by checking message and code
+                    if (prev.some((err) => err.message === systemError.message && err.code === systemError.code)) {
+                        return prev;
+                    }
+                    return [...prev, systemError];
+                });
+            }
+            return add("runner", "error")(e);
+        });
+        const offRunnerInvalidate = runner.on("invalidate", (e) => {
+            // If resolvedHandles are included in the event, use them directly (more efficient)
+            if (e?.resolvedHandles && Object.keys(e.resolvedHandles).length > 0) {
+                applyResolvedHandles(e.resolvedHandles);
+            }
+            return add("runner", "invalidate")(e);
+        });
+        const offRunnerStats = runner.on("stats", (s) => {
+            if (!s)
+                return;
+            if (s.kind === "node-start") {
+                const id = s.nodeId;
+                const runId = s.runId;
+                const now = Date.now();
+                // Track run timestamp in workbench runtime state
+                wb.updateNodeRuntimeMetadata(id, (nodeMeta) => ({
+                    ...nodeMeta,
+                    lastRunAt: now,
+                }));
+                // Validate runId is a non-empty string
+                const isValidRunId = runId && typeof runId === "string" && runId.length > 0;
+                if (!isValidRunId) {
+                    console.warn(`[WorkbenchContext] node-start event missing or invalid runId for node ${id}`, {
+                        runId,
+                        event: s,
+                    });
+                }
+                setNodeStatus((prev) => {
+                    const current = prev[id]?.activeRuns ?? 0;
+                    const currentRunIds = prev[id]?.activeRunIds ?? [];
+                    return {
+                        ...prev,
+                        [id]: {
+                            ...prev[id],
+                            activeRuns: current + 1,
+                            activeRunIds: isValidRunId ? [...currentRunIds, runId] : currentRunIds,
+                            progress: 0,
+                        },
+                    };
+                });
+                // Start fallback animation window
+                setFallbackStarts((prev) => ({ ...prev, [id]: now }));
+            }
+            else if (s.kind === "node-custom-data") {
+                const id = s.nodeId;
+                wb.setCustomNodeData(id, s.data, { commit: false, merge: true });
+            }
+            else if (s.kind === "node-progress") {
+                const id = s.nodeId;
+                setNodeStatus((prev) => ({
+                    ...prev,
+                    [id]: {
+                        ...prev[id],
+                        progress: Number(s.progress) || 0,
+                    },
+                }));
+            }
+            else if (s.kind === "node-done") {
+                const id = s.nodeId;
+                const runId = s.runId;
+                const now = Date.now();
+                // Validate runId is a non-empty string
+                const isValidRunId = runId && typeof runId === "string" && runId.length > 0;
+                const hadError = !!(isValidRunId && errorRunsRef.current[id]?.[runId]);
+                // Track success timestamp if no error in workbench runtime state
+                if (!hadError) {
+                    wb.updateNodeRuntimeMetadata(id, (nodeMeta) => {
+                        const updated = { ...nodeMeta, lastSuccessAt: now };
+                        // Clear error summary on success
+                        if (updated.lastErrorSummary) {
+                            delete updated.lastErrorSummary;
+                        }
+                        return updated;
+                    });
+                }
+                setNodeStatus((prev) => {
+                    const current = prev[id]?.activeRuns ?? 0;
+                    const currentRunIds = prev[id]?.activeRunIds ?? [];
+                    if (isValidRunId && !currentRunIds.includes(runId)) {
+                        console.warn(`[WorkbenchContext] node-done event for unknown runId: node=${id} runId=${runId}`, {
+                            event: s,
+                            currentRunIds,
+                        });
+                        return prev; // Ignore stale event
+                    }
+                    const nextActive = Math.max(0, current - 1); // Prevent negative values
+                    const nextRunIds = isValidRunId ? currentRunIds.filter((rid) => rid !== runId) : currentRunIds;
+                    const keepProgress = hadError || nextActive > 0;
+                    // Clear error flag for this runId
+                    if (isValidRunId && errorRunsRef.current[id]?.[runId]) {
+                        delete errorRunsRef.current[id]?.[runId];
+                    }
+                    return {
+                        ...prev,
+                        [id]: {
+                            ...prev[id],
+                            activeRuns: nextActive,
+                            activeRunIds: nextRunIds,
+                            progress: keepProgress ? prev[id]?.progress : 0,
+                            lastError: hadError ? prev[id]?.lastError : undefined,
+                        },
+                    };
+                });
+                // Clear fallback start timestamp if no more active runs
+                setFallbackStarts((prev) => {
+                    const nextPrev = { ...prev };
+                    // If we don't know nextActive here, conservatively clear to stop animation
+                    delete nextPrev[id];
+                    return nextPrev;
+                });
+            }
+            else if (s.kind === "edge-start") {
+                const id = s.edgeId;
+                setEdgeStatus((prev) => {
+                    const current = prev[id]?.activeRuns ?? 0;
+                    return {
+                        ...prev,
+                        [id]: { ...prev[id], activeRuns: current + 1 },
+                    };
+                });
+            }
+            else if (s.kind === "edge-done") {
+                const id = s.edgeId;
+                setEdgeStatus((prev) => {
+                    const current = prev[id]?.activeRuns ?? 0;
+                    return {
+                        ...prev,
+                        [id]: { ...prev[id], activeRuns: Math.max(0, current - 1) }, // Prevent negative values
+                    };
+                });
+            }
+            return add("runner", "stats")(s);
+        });
+        const offWbRegistryChanged = wb.on("registryChanged", (evt) => {
+            setRegistryVersion((v) => v + 1);
+        });
+        const offWbGraphChanged = wb.on("graphChanged", (event) => {
+            if (event.change?.type === "removeNode") {
+                const removedNodeId = event.change.nodeId;
+                setInputValidationErrors((prev) => prev.filter((err) => err.nodeId !== removedNodeId));
+            }
+            else if (event.change?.type === "batch") {
+                const removedIds = event.change.changes
+                    .filter((c) => c.type === "removeNode")
+                    .map((c) => c.nodeId);
+                if (removedIds.length > 0) {
+                    setInputValidationErrors((prev) => prev.filter((err) => !removedIds.includes(err.nodeId)));
+                }
+            }
+            return add("workbench", "graphChanged")(event);
+        });
+        const offWbGraphUiChangedForLog = wb.on("graphUiChanged", add("workbench", "graphUiChanged"));
+        const offWbValidationChanged = wb.on("validationChanged", add("workbench", "validationChanged"));
+        // Ensure newly added nodes start as invalidated until first evaluation
+        const GRAPH_REASON_BY_CHANGE = {
+            addNode: "add-node",
+            removeNode: "remove-node",
+            connect: "connect-edge",
+            disconnect: "disconnect-edge",
+            updateParams: "update-node-params",
+            updateEdgeType: "update-edge-type",
+            setInputs: "set-inputs",
+            updateResolvedHandles: "update-resolved-handles",
+        };
+        const getGraphReason = (event) => {
+            const changeType = event.change?.type;
+            return (changeType && GRAPH_REASON_BY_CHANGE[changeType]) || "graph-changed";
+        };
+        const commitGraphChange = async (shouldCommit, reason, errorPrefix) => {
+            if (!shouldCommit)
+                return;
+            await saveUiRuntimeMetadata(wb, runner);
+            const history = await runner.commit(reason).catch((err) => {
+                console.error(errorPrefix, err);
+                return undefined;
+            });
+            if (history)
+                wb.setHistory(history);
+        };
+        const applyAddNodeEffects = async (nodeId, inputs, copyOutputsFrom, dry) => {
+            if (inputs) {
+                await runner.setInputs(nodeId, inputs, { dry });
+            }
+            if (copyOutputsFrom) {
+                await runner.copyOutputs(copyOutputsFrom, nodeId, { dry });
+            }
+        };
+        const applyBatchGraphChange = async (event) => {
+            if (event.change?.type !== "batch")
+                return;
+            const { changes } = event.change;
+            const dry = !!event.dry;
+            if (!runner.isRunning())
+                return;
+            const hasNodeOps = changes.some((c) => c.type === "addNode" && (c.inputs || c.copyOutputsFrom));
+            await runner.update(event.def, { dry: dry || hasNodeOps });
+            for (const change of changes) {
+                if (change.type === "addNode") {
+                    await applyAddNodeEffects(change.nodeId, change.inputs, change.copyOutputsFrom, dry);
+                }
+                else if (change.type === "setInputs") {
+                    await runner.setInputs(change.nodeId, change.inputs, { dry });
+                }
+            }
+        };
+        const applySingleGraphChange = async (event) => {
+            if (event.change?.type === "batch")
+                return;
+            if (event.change?.type === "setInputs") {
+                const { nodeId, inputs } = event.change;
+                await runner.setInputs(nodeId, inputs, { dry: event.dry });
+            }
+            if (!runner.isRunning())
+                return;
+            if (event.change?.type === "addNode") {
+                const { nodeId, inputs, copyOutputsFrom } = event.change;
+                if (event.dry) {
+                    await runner.update(event.def, { dry: true });
+                    await applyAddNodeEffects(nodeId, inputs, copyOutputsFrom, true);
+                    return;
+                }
+                await runner.update(event.def, { dry: !!inputs });
+                await applyAddNodeEffects(nodeId, inputs, undefined, false);
+                return;
+            }
+            if (event.change?.type !== "setInputs" && event.change?.type !== "updateResolvedHandles") {
+                await runner.update(event.def, { dry: event.dry });
+            }
+        };
+        const offWbGraphChangedForUpdate = wb.on("graphChanged", async (event) => {
+            try {
+                if (event.change?.type === "batch") {
+                    await applyBatchGraphChange(event);
+                    await commitGraphChange(event.commit, event.reason ?? "batch", "[WorkbenchContext] Error committing batch:");
+                    return;
+                }
+                const reason = getGraphReason(event);
+                await applySingleGraphChange(event);
+                await commitGraphChange(event.commit, event.reason ?? reason, "[WorkbenchContext] Error committing:");
+            }
+            catch (err) {
+                console.error("[WorkbenchContext] Error processing graph change:", err);
+            }
+        });
+        const offWbSetValidation = wb.on("validationChanged", (r) => setValidation(r));
+        const offWbSelectionChanged = wb.on("selectionChanged", async (sel) => {
+            setSelectedNodeId(sel.nodes?.[0]);
+            setSelectedEdgeId(sel.edges?.[0]);
+            if (sel.commit) {
+                await saveUiRuntimeMetadata(wb, runner);
+                const history = await runner.commit(sel.reason ?? "selection").catch((err) => {
+                    console.error("[WorkbenchContext] Error committing selection change:", err);
+                    return undefined;
+                });
+                if (history) {
+                    wb.setHistory(history);
+                }
+            }
+        });
+        const offWbGraphUiChanged = wb.on("graphUiChanged", async (event) => {
+            // Handle viewport changes separately (send via SetViewport command, not commit)
+            if (event.change?.type === "viewport") {
+                const viewport = wb.getViewport();
+                if (viewport && runner.setViewport) {
+                    runner.setViewport(viewport).catch((err) => {
+                        console.warn("[WorkbenchContext] Failed to send viewport update:", err);
+                    });
+                }
+                return;
+            }
+            // Only commit if commit flag is true (e.g., drag end, not during dragging)
+            if (event.commit) {
+                // Build detailed reason from change type
+                let reason = "ui-changed";
+                if (event.change) {
+                    const changeType = event.change.type;
+                    if (changeType === "moveNode") {
+                        reason = "move-node";
+                    }
+                    else if (changeType === "moveNodes") {
+                        reason = "move-nodes";
+                    }
+                    else if (changeType === "resizeNodes") {
+                        reason = "resize-nodes";
+                    }
+                    else if (changeType === "selection") {
+                        reason = "selection";
+                    }
+                    else if (changeType === "customNodeData") {
+                        reason = "custom-node-data";
+                    }
+                    else if (changeType === "customEdgeData") {
+                        reason = "custom-edge-data";
+                    }
+                    else if (changeType === "customMetaData") {
+                        reason = "custom-meta";
+                    }
+                    else if (changeType === "customData") {
+                        reason = "custom";
+                    }
+                }
+                await saveUiRuntimeMetadata(wb, runner);
+                const history = await runner.commit(event.reason ?? reason).catch((err) => {
+                    console.error("[WorkbenchContext] Error committing UI changes:", err);
+                    return undefined;
+                });
+                if (history) {
+                    wb.setHistory(history);
+                }
+            }
+        });
+        const offWbError = wb.on("error", add("workbench", "error"));
+        // Registry updates: swap registry and refresh graph validation/UI
+        const offRunnerRegistry = runner.on("registry", async (registry) => {
+            wb.setRegistry(registry);
+            setRegistryReady(true);
+        });
+        const offFlowViewport = runner.on("viewport", (event) => {
+            const viewport = event.viewport;
+            if (isValidViewport(viewport)) {
+                wb.setViewport(viewport);
+            }
+        });
+        const offRunnerTransport = runner.on("transport", (t) => {
+            // Remote registry is only considered ready once we've received at least one "registry" event.
+            // Reset readiness whenever transport is not stable.
+            if (t.state === "local") {
+                setRegistryReady(true);
+            }
+            else if (t.state === "connecting" || t.state === "retrying") {
+                setRegistryReady(false);
+            }
+            else if (t.state === "disconnected") {
+                setRegistryReady(false);
+            }
+            if (t.state === "disconnected") {
+                console.info("[WorkbenchContext] Transport disconnected, resetting node status");
+                // Reinitialize node status with invalidated=true for all nodes
+                setNodeStatus(() => {
+                    const next = {};
+                    const metadata = wb.getRuntimeState() ?? { nodes: {} };
+                    for (const n of wb.def.nodes) {
+                        const nodeMeta = metadata.nodes[n.nodeId];
+                        next[n.nodeId] = {
+                            activeRuns: 0,
+                            activeRunIds: [],
+                            invalidated: computeInvalidatedFromMetadata(nodeMeta),
+                        };
+                    }
+                    return next;
+                });
+                setEdgeStatus({});
+                setFallbackStarts({});
+                errorRunsRef.current = {};
+            }
+        });
+        const offWbRuntimeMetadataChanged = wb.on("runtimeMetadataChanged", (event) => {
+            const workbenchRuntimeState = wb.getRuntimeState() ?? { nodes: {} };
+            setNodeStatus((prev) => {
+                const next = { ...prev };
+                const metadata = workbenchRuntimeState;
+                let changed = false;
+                // If nodeId is specified, only update that node; otherwise update all nodes
+                const nodesToUpdate = event.nodeId ? wb.def.nodes.filter((n) => n.nodeId === event.nodeId) : wb.def.nodes;
+                for (const n of nodesToUpdate) {
+                    const cur = next[n.nodeId];
+                    if (!cur)
+                        continue;
+                    const nodeMeta = metadata.nodes[n.nodeId];
+                    const newInvalidated = computeInvalidatedFromMetadata(nodeMeta);
+                    if (cur.invalidated !== newInvalidated) {
+                        next[n.nodeId] = { ...cur, invalidated: newInvalidated };
+                        changed = true;
+                    }
+                }
+                return changed ? next : prev;
+            });
+        });
+        wb.refreshValidation();
+        return () => {
+            offRunnerValue();
+            offRunnerError();
+            offRunnerInvalidate();
+            offRunnerStats();
+            offWbRegistryChanged();
+            offWbGraphChanged();
+            offWbGraphUiChangedForLog();
+            offWbGraphUiChanged();
+            offWbValidationChanged();
+            offWbError();
+            offWbGraphChangedForUpdate();
+            offWbSetValidation();
+            offWbSelectionChanged();
+            offRunnerRegistry();
+            offRunnerTransport();
+            offFlowViewport();
+            offWbRuntimeMetadataChanged();
+        };
+    }, [runner, wb]);
+    const isRunning = useCallback(() => runner.isRunning(), [runner]);
+    const setRunMode = useCallback((mode) => {
+        if (mode === runMode)
+            return;
+        runner.setRunMode(mode);
+        setRunModeState(mode);
+    }, [runMode, runner]);
+    const runNodeAction = useCallback(async (nodeId) => {
+        // Check if we're in auto mode or if node has autoRun policy
+        const nodeHasAutoRun = wb.shouldNodeAutoRun(nodeId);
+        const shouldUseTriggerExternal = runMode === "auto" || nodeHasAutoRun;
+        if (shouldUseTriggerExternal) {
+            // In auto mode or when node has autoRun, use triggerExternal with invalidate event
+            await runner.triggerExternal(nodeId, { action: "invalidate" });
+        }
+        else {
+            // In manual mode without autoRun, use computeNode
+            await runner.computeNode(nodeId);
+        }
+    }, [runner, wb, runMode]);
+    const runFromHereAction = useCallback(async (nodeId) => {
+        await runner.runFromHere(nodeId);
+    }, [runner]);
+    const abortNodeAction = useCallback((nodeId) => {
+        runner.cancelNodeRuns([nodeId]);
+    }, [runner]);
+    const validationByNode = useMemo(() => {
+        const inputs = {};
+        const outputs = {};
+        const issues = {};
+        if (!validation)
+            return { inputs, outputs, issues };
+        for (const is of validation.issues ?? []) {
+            const d = is.data;
+            const level = is.level;
+            const code = String(is.code ?? "");
+            const message = String(is.message ?? code);
+            if (!d)
+                continue;
+            if (d.nodeId) {
+                if (d.input) {
+                    const arr = inputs[d.nodeId] ?? (inputs[d.nodeId] = []);
+                    arr.push({ handle: String(d.input), level, message, code });
+                    const nodeArr = issues[d.nodeId] ?? (issues[d.nodeId] = []);
+                    nodeArr.push(is);
+                }
+                if (d.output) {
+                    const arr = outputs[d.nodeId] ?? (outputs[d.nodeId] = []);
+                    arr.push({ handle: String(d.output), level, message, code });
+                    const nodeArr = issues[d.nodeId] ?? (issues[d.nodeId] = []);
+                    nodeArr.push(is);
+                }
+                if (!d.input && !d.output) {
+                    const arr = issues[d.nodeId] ?? (issues[d.nodeId] = []);
+                    arr.push(is);
+                }
+            }
+        }
+        return { inputs, outputs, issues };
+    }, [validation]);
+    const validationGlobal = useMemo(() => {
+        const list = [];
+        if (!validation)
+            return list;
+        for (const is of validation.issues ?? []) {
+            const d = is.data;
+            if (!d || (!d.nodeId && !d.edgeId)) {
+                list.push(is);
+            }
+        }
+        return list;
+    }, [validation]);
+    const validationByEdge = useMemo(() => {
+        const errors = {};
+        const issues = {};
+        if (!validation)
+            return { errors, issues };
+        for (const is of validation.issues ?? []) {
+            const d = is.data;
+            const level = is.level;
+            if (d?.edgeId) {
+                if (level === "error")
+                    errors[d.edgeId] = true;
+                const arr = issues[d.edgeId] ?? (issues[d.edgeId] = []);
+                arr.push(is);
+            }
+        }
+        return { errors, issues };
+    }, [validation]);
+    const value = useMemo(() => ({
+        wb,
+        runner,
+        selectedNodeId,
+        selectedEdgeId,
+        setSelection,
+        nodeStatus,
+        edgeStatus,
+        valuesTick,
+        handlesMap,
+        inputsMap,
+        inputDefaultsMap,
+        outputsMap,
+        outputTypesMap,
+        validationByNode,
+        validationByEdge,
+        validationGlobal,
+        events,
+        clearEvents,
+        systemErrors,
+        registryErrors,
+        inputValidationErrors,
+        clearSystemErrors,
+        clearRegistryErrors,
+        clearInputValidationErrors,
+        removeSystemError,
+        removeRegistryError,
+        removeInputValidationError,
+        isRunning,
+        runMode,
+        setRunMode,
+        runNode: runNodeAction,
+        runFromHere: runFromHereAction,
+        abortNode: abortNodeAction,
+        runAutoLayout,
+        updateEdgeType,
+        triggerExternal,
+        uiVersion,
+        registryVersion,
+        registryReady,
+        overrides,
+        getNodeDisplayName,
+        setNodeName,
+    }), [
+        wb,
+        runner,
+        selectedNodeId,
+        selectedEdgeId,
+        setSelection,
+        nodeStatus,
+        edgeStatus,
+        valuesTick,
+        systemErrors,
+        registryErrors,
+        inputValidationErrors,
+        clearSystemErrors,
+        clearRegistryErrors,
+        clearInputValidationErrors,
+        removeSystemError,
+        removeRegistryError,
+        removeInputValidationError,
+        handlesMap,
+        inputsMap,
+        inputDefaultsMap,
+        outputsMap,
+        validationByNode,
+        validationByEdge,
+        validationGlobal,
+        events,
+        clearEvents,
+        isRunning,
+        runMode,
+        setRunMode,
+        runNodeAction,
+        runFromHereAction,
+        abortNodeAction,
+        runAutoLayout,
+        wb,
+        runner,
+        uiVersion,
+        registryVersion,
+        registryReady,
+        overrides,
+        getNodeDisplayName,
+        setNodeName,
+    ]);
+    return _jsx(WorkbenchContext.Provider, { value: value, children: children });
+}
+//# sourceMappingURL=WorkbenchContext.provider.js.map