@bian-womp/spark-workbench 0.3.90 → 0.3.92

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

@@ -1,995 +0,0 @@
-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