@atmos.build/ui 0.1.0

package/dist/flow/editor/use-dag-editor.d.ts

@@ -0,0 +1,94 @@
+import { type Dispatch, type SetStateAction } from 'react';
+import { type Connection, type Edge as RfEdge, type Node as RfNode, type OnEdgesChange, type OnNodesChange } from 'reactflow';
+import type { CollaborativeGraphPatch } from '../collaborative-graph-sync.js';
+export interface EdgeBridgeSpec<TEdge> {
+    readonly source: string;
+    readonly target: string;
+    readonly handle: string | null | undefined;
+    readonly upstream?: RfEdge<TEdge>;
+}
+export interface MakeNodeDataContext<TData> {
+    readonly fromNode?: RfNode<TData>;
+}
+export interface UseDagEditorOptions<TData, TEdge> {
+    readonly makeNodeData: (kind: string, title: string, ctx?: MakeNodeDataContext<TData>) => TData;
+    readonly cloneNodeData?: (data: TData) => TData;
+    readonly isProtected: (node: RfNode<TData>) => boolean;
+    readonly isValidConnection?: (connection: Connection, nodes: RfNode<TData>[], edges: RfEdge<TEdge>[]) => boolean;
+    readonly initialNodes: RfNode<TData>[];
+    readonly initialEdges: RfEdge<TEdge>[];
+    readonly nodeType?: string;
+    readonly clipboardKind?: string;
+    readonly buildEdge?: (spec: EdgeBridgeSpec<TEdge>) => RfEdge<TEdge>;
+    readonly isSingleHandle?: (sourceId: string, handle: string | null, nodes: RfNode<TData>[]) => boolean;
+    readonly handleOrderOf?: (sourceId: string, sourceHandle: string | null | undefined, nodes: RfNode<TData>[]) => number | null;
+}
+type Snapshot<TData, TEdge> = {
+    nodes: RfNode<TData>[];
+    edges: RfEdge<TEdge>[];
+};
+export type RemoteGraphPhase = 'bootstrap' | 'peer';
+export interface DagEditor<TData, TEdge> {
+    nodes: RfNode<TData>[];
+    edges: RfEdge<TEdge>[];
+    onNodesChange: OnNodesChange;
+    onEdgesChange: OnEdgesChange;
+    setNodes: Dispatch<SetStateAction<RfNode<TData>[]>>;
+    commitNodesQuiet: Dispatch<SetStateAction<RfNode<TData>[]>>;
+    setEdges: Dispatch<SetStateAction<RfEdge<TEdge>[]>>;
+    onConnect: (connection: Connection) => void;
+    isValidConnection: (connection: Connection) => boolean;
+    addNodeAt: (kind: string, at: {
+        x: number;
+        y: number;
+    }, title?: string) => string | null;
+    addNodeAtEnd: (kind: string, title?: string) => string;
+    addConnectedNodeAt: (args: {
+        kind: string;
+        title?: string;
+        at: {
+            x: number;
+            y: number;
+        };
+        from?: {
+            sourceId: string;
+            handleId?: string | null;
+        };
+        to?: {
+            targetId: string;
+        };
+    }) => string;
+    insertNodeOnEdge: (edgeId: string, kind: string, title?: string) => string | null;
+    removeNode: (id: string) => void;
+    removeNodesAndEdges: (nodeIds: readonly string[], edgeIds?: readonly string[]) => void;
+    duplicateNode: (id: string) => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    copy: () => void;
+    paste: () => void;
+    tidy: () => void;
+    selectNode: (id: string | null) => void;
+    deselectAll: () => void;
+    selectedNode: RfNode<TData> | null;
+    selectedNodeIds: string[];
+    updateNodeData: (id: string, patch: Partial<TData>) => void;
+    focusRequest: {
+        id: string;
+        seq: number;
+    } | null;
+    requestFocus: (id: string) => void;
+    isDirty: boolean;
+    dirtyRevision: number;
+    markSaved: () => void;
+    reset: (next?: {
+        nodes: RfNode<TData>[];
+        edges: RfEdge<TEdge>[];
+    }) => void;
+    applyRemoteGraph: (next: Snapshot<TData, TEdge>, phase: RemoteGraphPhase) => void;
+    applyRemotePatch: (patch: CollaborativeGraphPatch<TData, TEdge>, phase: RemoteGraphPhase) => void;
+    positionRevision: number;
+}
+export declare function useDagEditor<TData, TEdge = unknown>(opts: UseDagEditorOptions<TData, TEdge>): DagEditor<TData, TEdge>;
+export {};

package/dist/flow/editor/use-dag-editor.js

@@ -0,0 +1,502 @@
+'use client';
+import { useCallback, useEffect, useMemo, useRef, useState, } from 'react';
+import { useEdgesState, useNodesState, } from 'reactflow';
+import { createDagHistory, deserializeClipboard, edgeId, findFreePosition, inlineInsertOnEdge, layeredLayout, restitchEdgesWithoutNode, rfEdge as rfEdgeCore, serializeClipboard, wouldCycle, wouldCycleFromAdjacency, } from '../canvas/graph-core.js';
+let nodeSeq = 0;
+function freshNodeId(kind) {
+    nodeSeq += 1;
+    return `${kind}-${Date.now().toString(36)}-${nodeSeq.toString(36)}`;
+}
+export function useDagEditor(opts) {
+    const { makeNodeData, cloneNodeData, isProtected, isValidConnection: domainIsValidConnection, initialNodes, initialEdges, nodeType = 'atmos', clipboardKind = 'atmos-dag', buildEdge: buildEdgeOpt, isSingleHandle: isSingleHandleOpt, handleOrderOf, } = opts;
+    const buildEdge = useCallback((spec) => buildEdgeOpt
+        ? buildEdgeOpt(spec)
+        : rfEdgeCore(spec.source, spec.target, {
+            ...(spec.handle ? { handle: spec.handle } : {}),
+            type: nodeType,
+        }), [buildEdgeOpt, nodeType]);
+    const [nodes, setNodes, applyNodesChange] = useNodesState(initialNodes);
+    const [edges, setEdges, applyEdgesChange] = useEdgesState(initialEdges);
+    const [savedSnapshotKey, setSavedSnapshotKey] = useState(() => snapshotKey({ nodes: initialNodes, edges: initialEdges }));
+    const [dirtyRevision, setDirtyRevision] = useState(0);
+    const markDirty = useCallback(() => setDirtyRevision((r) => r + 1), []);
+    const [positionRevision, setPositionRevision] = useState(0);
+    const bumpPosition = useCallback(() => setPositionRevision((r) => r + 1), []);
+    const nodesRef = useRef(nodes);
+    const edgesRef = useRef(edges);
+    useEffect(() => {
+        nodesRef.current = nodes;
+    }, [nodes]);
+    useEffect(() => {
+        edgesRef.current = edges;
+    }, [edges]);
+    const isSingleHandle = useCallback((sourceId, handle) => isSingleHandleOpt ? isSingleHandleOpt(sourceId, handle, nodesRef.current) : false, [isSingleHandleOpt]);
+    const historyRef = useRef(null);
+    if (historyRef.current == null)
+        historyRef.current = createDagHistory();
+    const [historyState, setHistoryState] = useState({ canUndo: false, canRedo: false });
+    const dragRecordedRef = useRef(false);
+    const [focusRequest, setFocusRequest] = useState(null);
+    const focusSeqRef = useRef(0);
+    const requestFocus = useCallback((id) => {
+        focusSeqRef.current += 1;
+        setFocusRequest({ id, seq: focusSeqRef.current });
+    }, []);
+    const syncHistoryState = useCallback(() => {
+        const history = historyRef.current;
+        if (!history)
+            return;
+        setHistoryState((cur) => {
+            const next = { canUndo: history.canUndo(), canRedo: history.canRedo() };
+            return cur.canUndo === next.canUndo && cur.canRedo === next.canRedo ? cur : next;
+        });
+    }, []);
+    const clearHistory = useCallback(() => {
+        historyRef.current?.clear();
+        syncHistoryState();
+    }, [syncHistoryState]);
+    const recordHistory = useCallback((coalesceKey) => {
+        historyRef.current?.record({ nodes: nodesRef.current, edges: edgesRef.current }, coalesceKey ?? null);
+        syncHistoryState();
+    }, [syncHistoryState]);
+    const restitchWithoutNode = useCallback((currentEdges, id) => restitchEdgesWithoutNode(currentEdges, id, ({ source, target, handle, upstream }) => buildEdge({ source, target, handle, upstream })), [buildEdge]);
+    const onNodesChange = useCallback((changes) => {
+        const dragStart = changes.some((c) => c.type === 'position' && c.dragging === true);
+        const dragEnd = changes.some((c) => c.type === 'position' && c.dragging === false);
+        if (dragStart && !dragRecordedRef.current) {
+            dragRecordedRef.current = true;
+            recordHistory();
+        }
+        if (dragEnd)
+            dragRecordedRef.current = false;
+        if (changes.some((c) => c.type === 'remove'))
+            recordHistory();
+        if (changes.some((c) => c.type !== 'select' && c.type !== 'dimensions' && c.type !== 'position')) {
+            markDirty();
+        }
+        if (dragEnd) {
+            markDirty();
+            bumpPosition();
+        }
+        applyNodesChange(changes);
+    }, [applyNodesChange, bumpPosition, markDirty, recordHistory]);
+    const onEdgesChange = useCallback((changes) => {
+        if (changes.some((c) => c.type === 'remove'))
+            recordHistory();
+        if (changes.some((c) => c.type !== 'select'))
+            markDirty();
+        applyEdgesChange(changes);
+    }, [applyEdgesChange, markDirty, recordHistory]);
+    const nodeById = useMemo(() => new Map(nodes.map((n) => [n.id, n])), [nodes]);
+    const edgeKeys = useMemo(() => new Set(edges.map((e) => edgeId(e.source, e.target, e.sourceHandle))), [edges]);
+    const adjacency = useMemo(() => {
+        const map = new Map();
+        for (const e of edges) {
+            const list = map.get(e.source) ?? [];
+            list.push(e.target);
+            map.set(e.source, list);
+        }
+        return map;
+    }, [edges]);
+    const isValidConnection = useCallback((connection) => {
+        if (!connection.source || !connection.target)
+            return false;
+        if (connection.source === connection.target)
+            return false;
+        if (!nodeById.has(connection.source) || !nodeById.has(connection.target))
+            return false;
+        if (edgeKeys.has(edgeId(connection.source, connection.target, connection.sourceHandle))) {
+            return false;
+        }
+        if (wouldCycleFromAdjacency(adjacency, connection.source, connection.target))
+            return false;
+        if (domainIsValidConnection && !domainIsValidConnection(connection, nodes, edges))
+            return false;
+        return true;
+    }, [adjacency, domainIsValidConnection, edgeKeys, edges, nodeById, nodes]);
+    const onConnect = useCallback((connection) => {
+        if (!isValidConnection(connection))
+            return;
+        const source = connection.source;
+        const target = connection.target;
+        if (!source || !target)
+            return;
+        recordHistory();
+        markDirty();
+        const handle = connection.sourceHandle ?? null;
+        setEdges((cur) => {
+            const filtered = isSingleHandle(source, handle)
+                ? cur.filter((e) => !(e.source === source && (e.sourceHandle ?? null) === handle))
+                : cur;
+            return [...filtered, buildEdge({ source, target, handle })];
+        });
+    }, [buildEdge, isSingleHandle, isValidConnection, markDirty, recordHistory, setEdges]);
+    const makeNode = useCallback((kind, title, position, ctx) => ({
+        id: freshNodeId(kind),
+        type: nodeType,
+        position,
+        selected: true,
+        data: makeNodeData(kind, title ?? kind, ctx),
+    }), [makeNodeData, nodeType]);
+    const addNodeAt = useCallback((kind, at, title) => {
+        recordHistory();
+        markDirty();
+        const position = findFreePosition(nodesRef.current, at);
+        const node = makeNode(kind, title, position);
+        setNodes((cur) => [...cur.map((n) => ({ ...n, selected: false })), node]);
+        requestFocus(node.id);
+        return node.id;
+    }, [makeNode, markDirty, recordHistory, requestFocus, setNodes]);
+    const addNodeAtEnd = useCallback((kind, title) => {
+        recordHistory();
+        markDirty();
+        const fallbackX = nodesRef.current.reduce((max, n) => Math.max(max, n.position.x), 32) + 240;
+        const position = findFreePosition(nodesRef.current, { x: fallbackX, y: 160 });
+        const node = makeNode(kind, title, position);
+        setNodes((cur) => [...cur.map((n) => ({ ...n, selected: false })), node]);
+        requestFocus(node.id);
+        return node.id;
+    }, [makeNode, markDirty, recordHistory, requestFocus, setNodes]);
+    const addConnectedNodeAt = useCallback((args) => {
+        recordHistory();
+        markDirty();
+        const position = findFreePosition(nodesRef.current, args.at);
+        const fromNode = args.from
+            ? nodesRef.current.find((n) => n.id === args.from?.sourceId)
+            : undefined;
+        const node = makeNode(args.kind, args.title, position, fromNode ? { fromNode } : undefined);
+        setNodes((cur) => [...cur.map((n) => ({ ...n, selected: false })), node]);
+        const from = args.from;
+        const to = args.to;
+        if (from) {
+            const handle = from.handleId ?? null;
+            setEdges((cur) => {
+                if (cur.some((e) => e.id === edgeId(from.sourceId, node.id, handle)))
+                    return cur;
+                const filtered = isSingleHandle(from.sourceId, handle)
+                    ? cur.filter((e) => !(e.source === from.sourceId && (e.sourceHandle ?? null) === handle))
+                    : cur;
+                return [...filtered, buildEdge({ source: from.sourceId, target: node.id, handle })];
+            });
+        }
+        else if (to && !wouldCycle(edgesRef.current, node.id, to.targetId)) {
+            setEdges((cur) => {
+                if (cur.some((e) => e.id === edgeId(node.id, to.targetId, null)))
+                    return cur;
+                return [...cur, buildEdge({ source: node.id, target: to.targetId, handle: null })];
+            });
+        }
+        requestFocus(node.id);
+        return node.id;
+    }, [
+        buildEdge,
+        isSingleHandle,
+        makeNode,
+        markDirty,
+        recordHistory,
+        requestFocus,
+        setEdges,
+        setNodes,
+    ]);
+    const insertNodeOnEdge = useCallback((targetEdgeId, kind, title) => {
+        const edge = edgesRef.current.find((e) => e.id === targetEdgeId);
+        if (!edge)
+            return null;
+        const source = nodeById.get(edge.source);
+        const target = nodeById.get(edge.target);
+        recordHistory();
+        markDirty();
+        const inline = source && target ? inlineInsertOnEdge(source, target) : null;
+        const position = inline
+            ? inline.position
+            : findFreePosition(nodesRef.current, { x: 256, y: 160 });
+        const node = makeNode(kind, title, position);
+        if (inline) {
+            setNodes((cur) => [
+                ...cur.map((n) => ({ ...inline.shiftDownstream(n), selected: false })),
+                node,
+            ]);
+        }
+        else {
+            setNodes((cur) => [...cur.map((n) => ({ ...n, selected: false })), node]);
+        }
+        setEdges((cur) => [
+            ...cur.filter((e) => e.id !== targetEdgeId),
+            buildEdge({
+                source: edge.source,
+                target: node.id,
+                handle: edge.sourceHandle,
+                upstream: edge,
+            }),
+            buildEdge({ source: node.id, target: edge.target, handle: null }),
+        ]);
+        requestFocus(node.id);
+        return node.id;
+    }, [buildEdge, makeNode, markDirty, nodeById, recordHistory, requestFocus, setEdges, setNodes]);
+    const removeNode = useCallback((id) => {
+        const node = nodeById.get(id);
+        if (node && isProtected(node))
+            return;
+        recordHistory();
+        markDirty();
+        setEdges((cur) => restitchWithoutNode(cur, id));
+        setNodes((cur) => cur.filter((n) => n.id !== id));
+    }, [isProtected, markDirty, nodeById, recordHistory, restitchWithoutNode, setEdges, setNodes]);
+    const removeNodesAndEdges = useCallback((nodeIds, edgeIds = []) => {
+        const removable = nodeIds.filter((id) => {
+            const node = nodeById.get(id);
+            return !(node && isProtected(node));
+        });
+        if (removable.length === 0 && edgeIds.length === 0)
+            return;
+        recordHistory();
+        markDirty();
+        const droppedEdges = new Set(edgeIds);
+        setEdges((cur) => {
+            let working = cur.filter((e) => !droppedEdges.has(e.id));
+            for (const id of removable)
+                working = restitchWithoutNode(working, id);
+            return working;
+        });
+        if (removable.length > 0) {
+            const dropped = new Set(removable);
+            setNodes((cur) => cur.filter((n) => !dropped.has(n.id)));
+        }
+    }, [isProtected, markDirty, nodeById, recordHistory, restitchWithoutNode, setEdges, setNodes]);
+    const duplicateNode = useCallback((id) => {
+        const original = nodesRef.current.find((n) => n.id === id);
+        if (!original)
+            return;
+        if (isProtected(original))
+            return;
+        recordHistory();
+        markDirty();
+        const copyId = freshNodeId(nodeType);
+        const position = findFreePosition(nodesRef.current, {
+            x: original.position.x + 48,
+            y: original.position.y + 48,
+        });
+        const data = cloneNodeData ? cloneNodeData(original.data) : { ...original.data };
+        setNodes((cur) => [
+            ...cur.map((n) => ({ ...n, selected: false })),
+            { ...original, id: copyId, selected: true, position, data },
+        ]);
+        requestFocus(copyId);
+    }, [cloneNodeData, isProtected, markDirty, nodeType, recordHistory, requestFocus, setNodes]);
+    const updateNodeData = useCallback((id, patch) => {
+        recordHistory(`node:${id}`);
+        markDirty();
+        setNodes((cur) => cur.map((n) => (n.id === id ? { ...n, data: { ...n.data, ...patch } } : n)));
+    }, [markDirty, recordHistory, setNodes]);
+    const selectNode = useCallback((id) => {
+        setNodes((cur) => cur.map((n) => ({ ...n, selected: n.id === id })));
+    }, [setNodes]);
+    const deselectAll = useCallback(() => {
+        setNodes((cur) => cur.some((n) => n.selected) ? cur.map((n) => ({ ...n, selected: false })) : cur);
+        setEdges((cur) => cur.some((e) => e.selected) ? cur.map((e) => ({ ...e, selected: false })) : cur);
+    }, [setEdges, setNodes]);
+    const tidy = useCallback(() => {
+        recordHistory();
+        markDirty();
+        setNodes((cur) => {
+            if (cur.length === 0)
+                return cur;
+            const layout = layeredLayout(cur, edgesRef.current, handleOrderOf
+                ? (sourceId, sourceHandle) => handleOrderOf(sourceId, sourceHandle, cur)
+                : undefined);
+            return cur.map((n) => ({ ...n, position: layout.get(n.id) ?? n.position }));
+        });
+    }, [handleOrderOf, markDirty, recordHistory, setNodes]);
+    const copy = useCallback(() => {
+        const selectedIds = new Set(nodesRef.current.filter((n) => n.selected).map((n) => n.id));
+        if (selectedIds.size === 0)
+            return;
+        const payload = serializeClipboard(clipboardKind, nodesRef.current, edgesRef.current, selectedIds);
+        clipboardRef.current = payload;
+    }, [clipboardKind]);
+    const clipboardRef = useRef(null);
+    const paste = useCallback(() => {
+        const payload = clipboardRef.current;
+        if (!payload)
+            return;
+        const decoded = deserializeClipboard(clipboardKind, payload, { nodeType });
+        if (!decoded || decoded.nodes.length === 0)
+            return;
+        recordHistory();
+        markDirty();
+        setNodes((cur) => [...cur.map((n) => ({ ...n, selected: false })), ...decoded.nodes]);
+        setEdges((cur) => [...cur, ...decoded.edges]);
+        const first = decoded.nodes[0];
+        if (first)
+            requestFocus(first.id);
+    }, [clipboardKind, markDirty, nodeType, recordHistory, requestFocus, setEdges, setNodes]);
+    const applySnapshot = useCallback((snapshot) => {
+        nodesRef.current = snapshot.nodes;
+        edgesRef.current = snapshot.edges;
+        setNodes(snapshot.nodes);
+        setEdges(snapshot.edges);
+        markDirty();
+    }, [markDirty, setEdges, setNodes]);
+    const markSaved = useCallback(() => {
+        setSavedSnapshotKey(snapshotKey({ nodes: nodesRef.current, edges: edgesRef.current }));
+        setDirtyRevision(0);
+    }, []);
+    const undo = useCallback(() => {
+        const history = historyRef.current;
+        if (!history)
+            return;
+        const previous = history.undo({ nodes: nodesRef.current, edges: edgesRef.current });
+        if (!previous)
+            return;
+        applySnapshot(previous);
+        syncHistoryState();
+    }, [applySnapshot, syncHistoryState]);
+    const redo = useCallback(() => {
+        const history = historyRef.current;
+        if (!history)
+            return;
+        const next = history.redo({ nodes: nodesRef.current, edges: edgesRef.current });
+        if (!next)
+            return;
+        applySnapshot(next);
+        syncHistoryState();
+    }, [applySnapshot, syncHistoryState]);
+    const reset = useCallback((next) => {
+        const nextNodes = next?.nodes ?? [];
+        const nextEdges = next?.edges ?? [];
+        nodesRef.current = nextNodes;
+        edgesRef.current = nextEdges;
+        setNodes(nextNodes);
+        setEdges(nextEdges);
+        clearHistory();
+        setSavedSnapshotKey(snapshotKey({ nodes: nextNodes, edges: nextEdges }));
+        setDirtyRevision(0);
+    }, [clearHistory, setEdges, setNodes]);
+    const applyRemoteGraph = useCallback((next, phase) => {
+        nodesRef.current = next.nodes;
+        edgesRef.current = next.edges;
+        setNodes(next.nodes);
+        setEdges(next.edges);
+        clearHistory();
+        const nextKey = snapshotKey(next);
+        if (phase === 'bootstrap') {
+            setSavedSnapshotKey(nextKey);
+            setDirtyRevision(0);
+        }
+        else {
+            setDirtyRevision((revision) => (nextKey === savedSnapshotKey ? 0 : revision + 1));
+        }
+    }, [clearHistory, savedSnapshotKey, setEdges, setNodes]);
+    const applyRemotePatch = useCallback((patch, phase) => {
+        applyRemoteGraph(applySnapshotPatch(nodesRef.current, edgesRef.current, patch), phase);
+    }, [applyRemoteGraph]);
+    const setDirtyNodes = useCallback((value) => {
+        recordHistory();
+        markDirty();
+        setNodes(value);
+    }, [markDirty, recordHistory, setNodes]);
+    // A quiet commit for internal, non-user edits (e.g. freezing node identity at
+    // save): it must NOT push an undo checkpoint or mark the graph dirty, so undo
+    // can never revert an identity stamp back to an unfrozen state.
+    const commitNodesQuiet = useCallback((value) => {
+        setNodes(value);
+    }, [setNodes]);
+    const setDirtyEdges = useCallback((value) => {
+        recordHistory();
+        markDirty();
+        setEdges(value);
+    }, [markDirty, recordHistory, setEdges]);
+    const selectedNodeIds = useMemo(() => nodes.filter((n) => n.selected).map((n) => n.id), [nodes]);
+    const selectedNode = useMemo(() => selectedNodeIds.length === 1 ? (nodeById.get(selectedNodeIds[0]) ?? null) : null, [nodeById, selectedNodeIds]);
+    return {
+        nodes,
+        edges,
+        onNodesChange,
+        onEdgesChange,
+        setNodes: setDirtyNodes,
+        commitNodesQuiet,
+        setEdges: setDirtyEdges,
+        onConnect,
+        isValidConnection,
+        addNodeAt,
+        addNodeAtEnd,
+        addConnectedNodeAt,
+        insertNodeOnEdge,
+        removeNode,
+        removeNodesAndEdges,
+        duplicateNode,
+        undo,
+        redo,
+        canUndo: historyState.canUndo,
+        canRedo: historyState.canRedo,
+        copy,
+        paste,
+        tidy,
+        selectNode,
+        deselectAll,
+        selectedNode,
+        selectedNodeIds,
+        updateNodeData,
+        focusRequest,
+        requestFocus,
+        isDirty: snapshotKey({ nodes, edges }) !== savedSnapshotKey,
+        dirtyRevision,
+        markSaved,
+        reset,
+        applyRemoteGraph,
+        applyRemotePatch,
+        positionRevision,
+    };
+}
+function snapshotKey(snapshot) {
+    return JSON.stringify({
+        nodes: snapshot.nodes.map((node) => ({
+            id: node.id,
+            type: node.type ?? 'atmos',
+            position: { x: Math.round(node.position.x), y: Math.round(node.position.y) },
+            data: node.data,
+        })),
+        edges: snapshot.edges.map((edge) => ({
+            id: edge.id,
+            source: edge.source,
+            target: edge.target,
+            type: edge.type ?? 'atmos',
+            sourceHandle: edge.sourceHandle ?? null,
+            targetHandle: edge.targetHandle ?? null,
+            data: edge.data ?? null,
+        })),
+    });
+}
+function applySnapshotPatch(currentNodes, currentEdges, patch) {
+    const selected = new Set(currentNodes.filter((node) => node.selected).map((node) => node.id));
+    const deletedNodeIds = new Set(patch.nodes?.deleteIds ?? []);
+    const nodes = currentNodes.filter((node) => !deletedNodeIds.has(node.id));
+    const nodeIndex = new Map(nodes.map((node, index) => [node.id, index]));
+    for (const node of patch.nodes?.upsert ?? []) {
+        const next = { ...node, selected: selected.has(node.id) };
+        const index = nodeIndex.get(node.id);
+        if (index === undefined) {
+            nodeIndex.set(node.id, nodes.length);
+            nodes.push(next);
+        }
+        else {
+            nodes[index] = next;
+        }
+    }
+    const deletedEdgeIds = new Set(patch.edges?.deleteIds ?? []);
+    const edges = currentEdges
+        .filter((edge) => !deletedNodeIds.has(edge.source) && !deletedNodeIds.has(edge.target))
+        .filter((edge) => !deletedEdgeIds.has(edge.id));
+    const edgeIndex = new Map(edges.map((edge, index) => [edge.id, index]));
+    for (const edge of patch.edges?.upsert ?? []) {
+        const index = edgeIndex.get(edge.id);
+        if (index === undefined) {
+            edgeIndex.set(edge.id, edges.length);
+            edges.push(edge);
+        }
+        else {
+            edges[index] = edge;
+        }
+    }
+    return { nodes, edges };
+}

package/dist/flow/index.d.ts

@@ -0,0 +1,25 @@
+import '../lib/react-19-jsx.js';
+export * from './canvas/canvas-frame.js';
+export * from './canvas/connector-edge.js';
+export * from './canvas/editor-context.js';
+export * from './canvas/graph-core.js';
+export * from './canvas/node-card.js';
+export * from './canvas/node-library.js';
+export * from './canvas/sticky-notes.js';
+export * from './collaborative-graph-presence.js';
+export * from './collaborative-graph-sync.js';
+export * from './use-collaborative-graph.js';
+export * from './editor/adapter.js';
+export * from './editor/command-registry.js';
+export * from './editor/dag-canvas.js';
+export * from './editor/flow-editor.js';
+export * from './editor/issues-popover.js';
+export * from './editor/library-rail.js';
+export * from './editor/make-controller.js';
+export * from './editor/node-chip.js';
+export * from './editor/save-publish-bar.js';
+export * from './editor/settings-dialog.js';
+export * from './editor/settings-shell.js';
+export * from './editor/side-rail.js';
+export * from './editor/use-dag-editor.js';
+export * from './use-debounced-value.js';

package/dist/flow/index.js

@@ -0,0 +1,25 @@
+import '../lib/react-19-jsx.js';
+export * from './canvas/canvas-frame.js';
+export * from './canvas/connector-edge.js';
+export * from './canvas/editor-context.js';
+export * from './canvas/graph-core.js';
+export * from './canvas/node-card.js';
+export * from './canvas/node-library.js';
+export * from './canvas/sticky-notes.js';
+export * from './collaborative-graph-presence.js';
+export * from './collaborative-graph-sync.js';
+export * from './use-collaborative-graph.js';
+export * from './editor/adapter.js';
+export * from './editor/command-registry.js';
+export * from './editor/dag-canvas.js';
+export * from './editor/flow-editor.js';
+export * from './editor/issues-popover.js';
+export * from './editor/library-rail.js';
+export * from './editor/make-controller.js';
+export * from './editor/node-chip.js';
+export * from './editor/save-publish-bar.js';
+export * from './editor/settings-dialog.js';
+export * from './editor/settings-shell.js';
+export * from './editor/side-rail.js';
+export * from './editor/use-dag-editor.js';
+export * from './use-debounced-value.js';

package/dist/flow/presence-motion.d.ts

@@ -0,0 +1,10 @@
+interface MotionPoint {
+    x: number;
+    y: number;
+}
+interface MotionTarget {
+    id: string;
+    point: MotionPoint | null | undefined;
+}
+export declare function useSmoothedFlowPoints(targets: readonly MotionTarget[]): ReadonlyMap<string, MotionPoint>;
+export {};