@foresthubai/workflow-builder 0.4.3 → 0.4.5

package/src/hooks/useResourceDiagnosticsSync.ts

@@ -1,58 +1,62 @@
-import { useEffect } from "react";
-import { useEditorStore } from "../stores/editorStore";
-import { useDiagnosticsStore } from "../stores/diagnosticsStore";
-import type { Diagnostic } from "@foresthubai/workflow-core/diagnostics";
-
-type EditorState = ReturnType<typeof useEditorStore.getState>;
-type DiagnosticsState = ReturnType<typeof useDiagnosticsStore.getState>;
-
-interface ResourceDiagnosticsSyncConfig<I extends { id: string }> {
-  /** Pick the resource map (e.g. `s.channels`) off the editor store. */
-  selectItems: (s: EditorState) => Record<string, I>;
-  /** Validate one instance into its diagnostics. */
-  validate: (item: I) => Diagnostic[];
-  /** Read the matching diagnostics slot (e.g. `d.byChannelId`). */
-  getStored: (d: DiagnosticsState) => Record<string, Diagnostic[]>;
-  /** Write one instance's diagnostics. */
-  set: (d: DiagnosticsState, id: string, diags: Diagnostic[]) => void;
-  /** Drop one instance's diagnostics. */
-  clear: (d: DiagnosticsState, id: string) => void;
-}
-
-/**
- * Keeps a project-scoped diagnostics slot (`byChannelId` / `byMemoryId` /
- * `byModelId`) in sync with the editor's resource map.
- *
- * These resources are project-scoped, not canvas-scoped, and are only rendered
- * visually when their sidebar tab is open. Tying diagnostic writes to card
- * lifecycles would mean errors vanish the moment that tab closes, so this hook
- * is mounted once at the workflow-builder root and reactively rewrites the store
- * whenever the resource map changes.
- *
- * Lifecycle handled implicitly by the effect:
- *  - Load   → setItems fires → effect re-runs → diagnostics written
- *  - Edit   → store mutates  → effect re-runs → entry replaced
- *  - Delete → item leaves    → orphan branch  → entry cleared
- *  - Unmount → store goes down with the app (no cleanup needed)
- */
-export function useResourceDiagnosticsSync<I extends { id: string }>(config: ResourceDiagnosticsSyncConfig<I>): void {
-  const items = useEditorStore(config.selectItems);
-
-  useEffect(() => {
-    const ds = useDiagnosticsStore.getState();
-
-    const seen = new Set<string>();
-    for (const item of Object.values(items)) {
-      seen.add(item.id);
-      config.set(ds, item.id, config.validate(item));
-    }
-
-    // Drop entries for items that have been deleted.
-    for (const id of Object.keys(config.getStored(ds))) {
-      if (!seen.has(id)) config.clear(ds, id);
-    }
-    // `config` is recreated each render but only `items` drives a resync; the
-    // effect reads the latest closure on every run.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [items]);
-}
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 ForestHub. All rights reserved.
+// For commercial licensing, contact root@foresthub.ai
+
+import { useEffect } from "react";
+import { useEditorStore } from "../stores/editorStore";
+import { useDiagnosticsStore } from "../stores/diagnosticsStore";
+import type { Diagnostic } from "@foresthubai/workflow-core/diagnostics";
+
+type EditorState = ReturnType<typeof useEditorStore.getState>;
+type DiagnosticsState = ReturnType<typeof useDiagnosticsStore.getState>;
+
+interface ResourceDiagnosticsSyncConfig<I extends { id: string }> {
+  /** Pick the resource map (e.g. `s.channels`) off the editor store. */
+  selectItems: (s: EditorState) => Record<string, I>;
+  /** Validate one instance into its diagnostics. */
+  validate: (item: I) => Diagnostic[];
+  /** Read the matching diagnostics slot (e.g. `d.byChannelId`). */
+  getStored: (d: DiagnosticsState) => Record<string, Diagnostic[]>;
+  /** Write one instance's diagnostics. */
+  set: (d: DiagnosticsState, id: string, diags: Diagnostic[]) => void;
+  /** Drop one instance's diagnostics. */
+  clear: (d: DiagnosticsState, id: string) => void;
+}
+
+/**
+ * Keeps a project-scoped diagnostics slot (`byChannelId` / `byMemoryId` /
+ * `byModelId`) in sync with the editor's resource map.
+ *
+ * These resources are project-scoped, not canvas-scoped, and are only rendered
+ * visually when their sidebar tab is open. Tying diagnostic writes to card
+ * lifecycles would mean errors vanish the moment that tab closes, so this hook
+ * is mounted once at the workflow-builder root and reactively rewrites the store
+ * whenever the resource map changes.
+ *
+ * Lifecycle handled implicitly by the effect:
+ *  - Load   → setItems fires → effect re-runs → diagnostics written
+ *  - Edit   → store mutates  → effect re-runs → entry replaced
+ *  - Delete → item leaves    → orphan branch  → entry cleared
+ *  - Unmount → store goes down with the app (no cleanup needed)
+ */
+export function useResourceDiagnosticsSync<I extends { id: string }>(config: ResourceDiagnosticsSyncConfig<I>): void {
+  const items = useEditorStore(config.selectItems);
+
+  useEffect(() => {
+    const ds = useDiagnosticsStore.getState();
+
+    const seen = new Set<string>();
+    for (const item of Object.values(items)) {
+      seen.add(item.id);
+      config.set(ds, item.id, config.validate(item));
+    }
+
+    // Drop entries for items that have been deleted.
+    for (const id of Object.keys(config.getStored(ds))) {
+      if (!seen.has(id)) config.clear(ds, id);
+    }
+    // `config` is recreated each render but only `items` drives a resync; the
+    // effect reads the latest closure on every run.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [items]);
+}

package/src/hooks/useSuppressThemeTransition.ts

@@ -1,79 +1,83 @@
-import { useEffect, useLayoutEffect } from "react";
-
-import { useResolvedTheme } from "./useResolvedTheme";
-
-/**
- * Makes color-mode switches snap instead of fade.
- *
- * The embedder toggles the `light` class on `<html>`. Two different mechanisms
- * recolor the UI when it does, and both would otherwise animate to the new
- * tokens over their transition duration:
- *
- *  1. CSS-variable cascade — components with `transition-all` (canvas tabs, the
- *     builder sidebar). These recolor the instant the class flips.
- *  2. React re-render — ReactFlow's controls and node chrome recolor only once
- *     `useResolvedTheme` re-renders and ReactFlow re-applies its `colorMode`
- *     class, which commits a tick or two *after* the class flip.
- *
- * So a fixed one-frame suppression window catches (1) but misses (2). Instead:
- *
- *  - A MutationObserver adds `theme-changing` (CSS kills all transitions under
- *    it) the moment the class flips — a microtask, before any paint — and forces
- *    a reflow so the cascade-driven colors commit with no transition.
- *  - A layout effect keyed on the resolved theme removes it. Parent layout
- *    effects run after children's, so this fires after ReactFlow has committed
- *    its `colorMode` change; a reflow first flushes those colors while
- *    transitions are still suppressed, then we restore them. Tying removal to
- *    the React commit (not a timer) makes it deterministic regardless of how
- *    late the re-render lands.
- *
- * A short fallback timer removes the class even if no re-render follows, so a
- * theme-only-affects-CSS flip can never leave transitions permanently off.
- *
- * Mount once at the builder root.
- */
-export function useSuppressThemeTransition(): void {
-  // Re-renders on every color-mode flip; drives the layout effect below.
-  const theme = useResolvedTheme();
-
-  useEffect(() => {
-    if (typeof document === "undefined") return;
-    const root = document.documentElement;
-
-    let wasLight = root.classList.contains("light");
-    let fallback = 0;
-
-    const observer = new MutationObserver(() => {
-      const isLight = root.classList.contains("light");
-      if (isLight === wasLight) return; // class changed for some other reason
-      wasLight = isLight;
-
-      root.classList.add("theme-changing");
-      // Force a synchronous reflow so cascade-driven colors commit while
-      // transitions are disabled, before the browser's next paint.
-      void root.offsetHeight;
-
-      // Safety net: if no React re-render follows (theme flip touched only CSS),
-      // the layout effect won't run — drop the class anyway after a beat.
-      clearTimeout(fallback);
-      fallback = window.setTimeout(() => root.classList.remove("theme-changing"), 120);
-    });
-
-    observer.observe(root, { attributes: true, attributeFilter: ["class"] });
-    return () => {
-      observer.disconnect();
-      clearTimeout(fallback);
-      root.classList.remove("theme-changing");
-    };
-  }, []);
-
-  useLayoutEffect(() => {
-    if (typeof document === "undefined") return;
-    const root = document.documentElement;
-    if (!root.classList.contains("theme-changing")) return; // initial mount, no flip
-    // ReactFlow has committed its colorMode change by now (child layout effects
-    // run first). Flush those colors under suppression, then restore transitions.
-    void root.offsetHeight;
-    root.classList.remove("theme-changing");
-  }, [theme]);
-}
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 ForestHub. All rights reserved.
+// For commercial licensing, contact root@foresthub.ai
+
+import { useEffect, useLayoutEffect } from "react";
+
+import { useResolvedTheme } from "./useResolvedTheme";
+
+/**
+ * Makes color-mode switches snap instead of fade.
+ *
+ * The embedder toggles the `light` class on `<html>`. Two different mechanisms
+ * recolor the UI when it does, and both would otherwise animate to the new
+ * tokens over their transition duration:
+ *
+ *  1. CSS-variable cascade — components with `transition-all` (canvas tabs, the
+ *     builder sidebar). These recolor the instant the class flips.
+ *  2. React re-render — ReactFlow's controls and node chrome recolor only once
+ *     `useResolvedTheme` re-renders and ReactFlow re-applies its `colorMode`
+ *     class, which commits a tick or two *after* the class flip.
+ *
+ * So a fixed one-frame suppression window catches (1) but misses (2). Instead:
+ *
+ *  - A MutationObserver adds `theme-changing` (CSS kills all transitions under
+ *    it) the moment the class flips — a microtask, before any paint — and forces
+ *    a reflow so the cascade-driven colors commit with no transition.
+ *  - A layout effect keyed on the resolved theme removes it. Parent layout
+ *    effects run after children's, so this fires after ReactFlow has committed
+ *    its `colorMode` change; a reflow first flushes those colors while
+ *    transitions are still suppressed, then we restore them. Tying removal to
+ *    the React commit (not a timer) makes it deterministic regardless of how
+ *    late the re-render lands.
+ *
+ * A short fallback timer removes the class even if no re-render follows, so a
+ * theme-only-affects-CSS flip can never leave transitions permanently off.
+ *
+ * Mount once at the builder root.
+ */
+export function useSuppressThemeTransition(): void {
+  // Re-renders on every color-mode flip; drives the layout effect below.
+  const theme = useResolvedTheme();
+
+  useEffect(() => {
+    if (typeof document === "undefined") return;
+    const root = document.documentElement;
+
+    let wasLight = root.classList.contains("light");
+    let fallback = 0;
+
+    const observer = new MutationObserver(() => {
+      const isLight = root.classList.contains("light");
+      if (isLight === wasLight) return; // class changed for some other reason
+      wasLight = isLight;
+
+      root.classList.add("theme-changing");
+      // Force a synchronous reflow so cascade-driven colors commit while
+      // transitions are disabled, before the browser's next paint.
+      void root.offsetHeight;
+
+      // Safety net: if no React re-render follows (theme flip touched only CSS),
+      // the layout effect won't run — drop the class anyway after a beat.
+      clearTimeout(fallback);
+      fallback = window.setTimeout(() => root.classList.remove("theme-changing"), 120);
+    });
+
+    observer.observe(root, { attributes: true, attributeFilter: ["class"] });
+    return () => {
+      observer.disconnect();
+      clearTimeout(fallback);
+      root.classList.remove("theme-changing");
+    };
+  }, []);
+
+  useLayoutEffect(() => {
+    if (typeof document === "undefined") return;
+    const root = document.documentElement;
+    if (!root.classList.contains("theme-changing")) return; // initial mount, no flip
+    // ReactFlow has committed its colorMode change by now (child layout effects
+    // run first). Flush those colors under suppression, then restore transitions.
+    void root.offsetHeight;
+    root.classList.remove("theme-changing");
+  }, [theme]);
+}

package/src/hooks/useWorkflowSerialization.ts

@@ -1,141 +1,145 @@
-import { useCallback } from "react";
-import { serialize, deserialize, type ApiWorkflow, type Workflow, type Canvas } from "@foresthubai/workflow-core/workflow";
-import { migrate } from "@foresthubai/workflow-core/migration";
-import type { NodeData } from "@foresthubai/workflow-core/node";
-import type { EdgeData } from "@foresthubai/workflow-core/edge";
-import type { Channel } from "@foresthubai/workflow-core/channel";
-import type { Memory } from "@foresthubai/workflow-core/memory";
-import type { Model } from "@foresthubai/workflow-core/model";
-import { Edge, Node } from "@xyflow/react";
-import { clearAllCanvasStores, getOrCreateCanvasStore, getAllCanvasStores, notifyCanvasRegistryChange, MAIN_CANVAS_ID } from "../stores/canvasStore";
-import { useEditorStore } from "../stores/editorStore";
-import { getReactFlowType } from "../utils/graphOperations";
-
-/**
- * Store-bound wrapper around the headless `serialize`/`deserialize` in
- * `@foresthubai/workflow-core/workflow`. All conversion logic lives in core;
- * this hook only mediates Zustand I/O.
- *
- * Core sets each node's outer `type` to the domain node type (e.g.
- * "Agent"); React Flow needs the *display* type — `getReactFlowType`
- * handles that on import.
- */
-export function useWorkflowSerialization() {
-  const importProject = useCallback((workflow: ApiWorkflow): void => {
-    // Migrate at the load boundary so an older saved document is brought current
-    // before deserialize ever sees it. A no-op on an already-current document.
-    const state = deserialize(migrate(workflow));
-
-    clearAllCanvasStores();
-
-    // Bodies → canvas stores. The function declarations are already in domain shape
-    // (FunctionDeclaration) on state.functions; the body is the canvas at the same id.
-    for (const [canvasId, canvas] of Object.entries(state.canvases)) {
-      const store = getOrCreateCanvasStore(canvasId);
-      const rfNodes: Node<NodeData>[] = canvas.nodes.map((n) => ({
-        id: n.id,
-        type: getReactFlowType(n.type),
-        position: n.position,
-        data: n,
-      }));
-      const rfEdges: Edge<EdgeData>[] = canvas.edges.map((e) => ({
-        id: e.id,
-        type: e.type,
-        source: e.source,
-        sourceHandle: e.sourceHandle,
-        target: e.target,
-        targetHandle: e.targetHandle,
-        ...(e.data ? { data: e.data } : {}),
-      }));
-      store.getState().initialize(rfNodes, rfEdges);
-      // `initialize` rebuilds node-output vars from the nodes. Replace with the
-      // fully merged set core already computed (includes declared + fnarg).
-      store.getState().setVariables(() => canvas.variables);
-    }
-
-    // Reconcile project-scoped resources to exactly what this workflow declares.
-    // The editor stores are module-level and outlive the previously loaded project,
-    // so a workflow that declares none of a given kind must still reset it —
-    // otherwise the prior project's channels/memory/models bleed in (the canvas
-    // stores get this for free via clearAllCanvasStores above, as does setFunctions).
-    const { channels, memory, models } = state;
-    useEditorStore.getState().setChannels(() => channels);
-    useEditorStore.getState().setMemory(() => memory);
-    useEditorStore.getState().setModels(() => models);
-    useEditorStore.getState().setFunctions(() => state.functions);
-
-    // The function canvas stores were created after clearAllCanvasStores' notify,
-    // so tell WorkflowBuilder to re-subscribe to the new set.
-    notifyCanvasRegistryChange();
-  }, []);
-
-  const exportProject = useCallback((): ApiWorkflow => {
-    return serialize(readStateFromStores());
-  }, []);
-
-  // Inverse of importProject: reset every (module-level) store to empty so a fresh
-  // builder never inherits the previously mounted project. Used by the clear() handle
-  // and on mount when no initialWorkflow is supplied.
-  const clearProject = useCallback((): void => {
-    clearAllCanvasStores(); // drops all canvas stores, re-seeds an empty main, notifies
-    const editor = useEditorStore.getState();
-    // A stale non-main activeCanvasId would lazily resurrect a phantom function body.
-    editor.setActiveCanvas(MAIN_CANVAS_ID);
-    // Project-scoped resources aren't touched by clearAllCanvasStores. Empty only when
-    // non-empty so an already-clean store doesn't bump mutationCount (as importProject).
-    editor.setChannels((c) => (Object.keys(c).length ? {} : c));
-    editor.setMemory((m) => (Object.keys(m).length ? {} : m));
-    editor.setModels((m) => (Object.keys(m).length ? {} : m));
-    editor.setFunctions((f) => (Object.keys(f).length ? {} : f));
-    editor.clearSelection();
-  }, []);
-
-  return { exportProject, importProject, clearProject };
-}
-
-/**
- * Read the editor's live Zustand state into a {@link Workflow} literal.
- * Peels the React Flow wrapper without recomputing anything; channels and
- * memory files are unprefixed for the core shape.
- *
- * Exported so the imperative handle can pass live state to
- * `validateWorkflowState` without a serialize/deserialize round-trip.
- */
-export function readStateFromStores(): Workflow {
-  const canvases: Record<string, Canvas> = {};
-  for (const [id, store] of Object.entries(getAllCanvasStores())) {
-    const s = store.getState();
-    canvases[id] = {
-      nodes: s.nodes.map((n) => ({ ...n.data, position: n.position })),
-      edges: s.edges.map((e) => ({
-        id: e.id,
-        type: e.type,
-        source: e.source,
-        sourceHandle: e.sourceHandle,
-        target: e.target,
-        targetHandle: e.targetHandle,
-        ...(e.data ? { data: e.data } : {}),
-      })),
-      variables: s.variables,
-    };
-  }
-
-  const channels: Record<string, Channel> = {};
-  for (const ch of Object.values(useEditorStore.getState().channels)) channels[ch.id] = ch;
-
-  const memory: Record<string, Memory> = {};
-  for (const m of Object.values(useEditorStore.getState().memory)) memory[m.id] = m;
-
-  const models: Record<string, Model> = {};
-  for (const m of Object.values(useEditorStore.getState().models)) models[m.id] = m;
-
-  // Function declarations are project-scoped and already in domain shape; the body
-  // for each is the canvas at the same id (above).
-  return {
-    canvases,
-    functions: useEditorStore.getState().functions,
-    channels,
-    memory,
-    models,
-  };
-}
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 ForestHub. All rights reserved.
+// For commercial licensing, contact root@foresthub.ai
+
+import { useCallback } from "react";
+import { serialize, deserialize, type ApiWorkflow, type Workflow, type Canvas } from "@foresthubai/workflow-core/workflow";
+import { migrate } from "@foresthubai/workflow-core/migration";
+import type { NodeData } from "@foresthubai/workflow-core/node";
+import type { EdgeData } from "@foresthubai/workflow-core/edge";
+import type { Channel } from "@foresthubai/workflow-core/channel";
+import type { Memory } from "@foresthubai/workflow-core/memory";
+import type { Model } from "@foresthubai/workflow-core/model";
+import { Edge, Node } from "@xyflow/react";
+import { clearAllCanvasStores, getOrCreateCanvasStore, getAllCanvasStores, notifyCanvasRegistryChange, MAIN_CANVAS_ID } from "../stores/canvasStore";
+import { useEditorStore } from "../stores/editorStore";
+import { getReactFlowType } from "../utils/graphOperations";
+
+/**
+ * Store-bound wrapper around the headless `serialize`/`deserialize` in
+ * `@foresthubai/workflow-core/workflow`. All conversion logic lives in core;
+ * this hook only mediates Zustand I/O.
+ *
+ * Core sets each node's outer `type` to the domain node type (e.g.
+ * "Agent"); React Flow needs the *display* type — `getReactFlowType`
+ * handles that on import.
+ */
+export function useWorkflowSerialization() {
+  const importProject = useCallback((workflow: ApiWorkflow): void => {
+    // Migrate at the load boundary so an older saved document is brought current
+    // before deserialize ever sees it. A no-op on an already-current document.
+    const state = deserialize(migrate(workflow));
+
+    clearAllCanvasStores();
+
+    // Bodies → canvas stores. The function declarations are already in domain shape
+    // (FunctionDeclaration) on state.functions; the body is the canvas at the same id.
+    for (const [canvasId, canvas] of Object.entries(state.canvases)) {
+      const store = getOrCreateCanvasStore(canvasId);
+      const rfNodes: Node<NodeData>[] = canvas.nodes.map((n) => ({
+        id: n.id,
+        type: getReactFlowType(n.type),
+        position: n.position,
+        data: n,
+      }));
+      const rfEdges: Edge<EdgeData>[] = canvas.edges.map((e) => ({
+        id: e.id,
+        type: e.type,
+        source: e.source,
+        sourceHandle: e.sourceHandle,
+        target: e.target,
+        targetHandle: e.targetHandle,
+        ...(e.data ? { data: e.data } : {}),
+      }));
+      store.getState().initialize(rfNodes, rfEdges);
+      // `initialize` rebuilds node-output vars from the nodes. Replace with the
+      // fully merged set core already computed (includes declared + fnarg).
+      store.getState().setVariables(() => canvas.variables);
+    }
+
+    // Reconcile project-scoped resources to exactly what this workflow declares.
+    // The editor stores are module-level and outlive the previously loaded project,
+    // so a workflow that declares none of a given kind must still reset it —
+    // otherwise the prior project's channels/memory/models bleed in (the canvas
+    // stores get this for free via clearAllCanvasStores above, as does setFunctions).
+    const { channels, memory, models } = state;
+    useEditorStore.getState().setChannels(() => channels);
+    useEditorStore.getState().setMemory(() => memory);
+    useEditorStore.getState().setModels(() => models);
+    useEditorStore.getState().setFunctions(() => state.functions);
+
+    // The function canvas stores were created after clearAllCanvasStores' notify,
+    // so tell WorkflowBuilder to re-subscribe to the new set.
+    notifyCanvasRegistryChange();
+  }, []);
+
+  const exportProject = useCallback((): ApiWorkflow => {
+    return serialize(readStateFromStores());
+  }, []);
+
+  // Inverse of importProject: reset every (module-level) store to empty so a fresh
+  // builder never inherits the previously mounted project. Used by the clear() handle
+  // and on mount when no initialWorkflow is supplied.
+  const clearProject = useCallback((): void => {
+    clearAllCanvasStores(); // drops all canvas stores, re-seeds an empty main, notifies
+    const editor = useEditorStore.getState();
+    // A stale non-main activeCanvasId would lazily resurrect a phantom function body.
+    editor.setActiveCanvas(MAIN_CANVAS_ID);
+    // Project-scoped resources aren't touched by clearAllCanvasStores. Empty only when
+    // non-empty so an already-clean store doesn't bump mutationCount (as importProject).
+    editor.setChannels((c) => (Object.keys(c).length ? {} : c));
+    editor.setMemory((m) => (Object.keys(m).length ? {} : m));
+    editor.setModels((m) => (Object.keys(m).length ? {} : m));
+    editor.setFunctions((f) => (Object.keys(f).length ? {} : f));
+    editor.clearSelection();
+  }, []);
+
+  return { exportProject, importProject, clearProject };
+}
+
+/**
+ * Read the editor's live Zustand state into a {@link Workflow} literal.
+ * Peels the React Flow wrapper without recomputing anything; channels and
+ * memory files are unprefixed for the core shape.
+ *
+ * Exported so the imperative handle can pass live state to
+ * `validateWorkflowState` without a serialize/deserialize round-trip.
+ */
+export function readStateFromStores(): Workflow {
+  const canvases: Record<string, Canvas> = {};
+  for (const [id, store] of Object.entries(getAllCanvasStores())) {
+    const s = store.getState();
+    canvases[id] = {
+      nodes: s.nodes.map((n) => ({ ...n.data, position: n.position })),
+      edges: s.edges.map((e) => ({
+        id: e.id,
+        type: e.type,
+        source: e.source,
+        sourceHandle: e.sourceHandle,
+        target: e.target,
+        targetHandle: e.targetHandle,
+        ...(e.data ? { data: e.data } : {}),
+      })),
+      variables: s.variables,
+    };
+  }
+
+  const channels: Record<string, Channel> = {};
+  for (const ch of Object.values(useEditorStore.getState().channels)) channels[ch.id] = ch;
+
+  const memory: Record<string, Memory> = {};
+  for (const m of Object.values(useEditorStore.getState().memory)) memory[m.id] = m;
+
+  const models: Record<string, Model> = {};
+  for (const m of Object.values(useEditorStore.getState().models)) models[m.id] = m;
+
+  // Function declarations are project-scoped and already in domain shape; the body
+  // for each is the canvas at the same id (above).
+  return {
+    canvases,
+    functions: useEditorStore.getState().functions,
+    channels,
+    memory,
+    models,
+  };
+}