@01.software/sdk 0.6.0 → 0.7.1

package/dist/ui/{flow.d.ts → canvas.d.ts}

@@ -1,21 +1,21 @@
-import { C as CanvasData, N as NodeTypeDef, E as EdgeTypeDef, F as FlowNode, a as NodeTypeFieldDef, D as DynamicNodeSlotProps, b as FlowEdge, c as FrameNodeSlotProps, d as EdgeSlotProps, e as NodeWrapperSlotProps, f as FlowViewport, g as FlowBounds, S as SDKClient, h as FrameData } from '../server-StNHlSjW.js';
-export { o as BUILT_IN_EDGE_TYPES, B as BUILT_IN_NODE_TYPES, k as DynamicNodeData, j as FlowNodeData, i as FlowNodePosition, l as FrameNodeData, P as PrefetchFlowOptions, U as UseFlowOptions, p as UseFlowResult, t as getFrameData, s as getFrames, r as getNodeBounds, m as isDynamicNode, n as isFrameNode, q as prefetchFlow, u as useFlow } from '../server-StNHlSjW.js';
+import { C as CanvasData, N as NodeTypeDef, E as EdgeTypeDef, a as CanvasNode, b as NodeTypeFieldDef, D as DynamicNodeSlotProps, c as CanvasEdge, F as FrameNodeSlotProps, d as EdgeSlotProps, e as NodeWrapperSlotProps, f as CanvasViewport, g as CanvasBounds, S as SDKClient, h as FrameData } from '../server-DxhuG-_s.js';
+export { o as BUILT_IN_EDGE_TYPES, B as BUILT_IN_NODE_TYPES, j as CanvasNodeData, i as CanvasNodePosition, k as DynamicNodeData, l as FrameNodeData, P as PrefetchCanvasOptions, U as UseCanvasOptions, p as UseCanvasResult, t as getFrameData, s as getFrames, r as getNodeBounds, m as isDynamicNode, n as isFrameNode, q as prefetchCanvas, u as useCanvas } from '../server-DxhuG-_s.js';
 import { Edge } from '@xyflow/react';
 import React from 'react';
 import { I as ImageData } from '../image-TT8lTsk5.js';
 import '@tanstack/react-query';
 
-interface UseFlowDataOptions {
-    /** Canvas data from Flow document's `canvas` field */
+interface UseCanvasDataOptions {
+    /** Canvas data from Canvas document's `canvas` field */
     data: CanvasData | undefined;
     /** Node type definitions (defaults to built-in types) */
     nodeTypeDefs?: NodeTypeDef[];
     /** Edge type definitions (defaults to built-in types) */
     edgeTypeDefs?: EdgeTypeDef[];
 }
-interface UseFlowDataResult {
+interface UseCanvasDataResult {
     /** Nodes from canvas data */
-    nodes: FlowNode[];
+    nodes: CanvasNode[];
     /** Edges from canvas data (typed for @xyflow/react) */
     edges: Edge[];
     /** Map of node type slug to definition */
@@ -28,7 +28,7 @@ interface UseFlowDataResult {
  * maps from canvas data without any rendering. Useful for headless usage
  * (custom layouts, analytics, server-side processing).
  */
-declare function useFlowData(options: UseFlowDataOptions): UseFlowDataResult;
+declare function useCanvasData(options: UseCanvasDataOptions): UseCanvasDataResult;
 
 interface CodeComponentProps {
     fields: Record<string, unknown>;
@@ -67,7 +67,7 @@ declare function getBooleanField(fields: Record<string, unknown>, name: string):
 declare function sanitizeCSS(css: string, scopeClass?: string): string;
 
 /**
- * Renders a Flow canvas in read-only mode.
+ * Renders a Canvas in read-only mode.
  *
  * Requires `@xyflow/react` peer dependency and its CSS:
  * ```ts
@@ -78,8 +78,8 @@ declare function sanitizeCSS(css: string, scopeClass?: string): string;
  * and `edgeRenderers` must be stable (defined outside render or wrapped with `useCallback`/`useMemo`).
  * Unstable references recreate `nodeTypes`/`edgeTypes` every render, causing React Flow to remount all nodes.
  */
-interface FlowRendererProps {
-    /** Canvas data from Flow document's `canvas` field */
+interface CanvasRendererProps {
+    /** Canvas data from Canvas document's `canvas` field */
     data: CanvasData;
     /** Container className */
     className?: string;
@@ -98,17 +98,17 @@ interface FlowRendererProps {
     /** Fit view on mount (default: true) */
     fitView?: boolean;
     /** Called when a node is clicked */
-    onNodeClick?: (event: React.MouseEvent, node: FlowNode) => void;
+    onNodeClick?: (event: React.MouseEvent, node: CanvasNode) => void;
     /** Called when a node is double-clicked */
-    onNodeDoubleClick?: (event: React.MouseEvent, node: FlowNode) => void;
+    onNodeDoubleClick?: (event: React.MouseEvent, node: CanvasNode) => void;
     /** Called on node right-click / context menu */
-    onNodeContextMenu?: (event: React.MouseEvent, node: FlowNode) => void;
+    onNodeContextMenu?: (event: React.MouseEvent, node: CanvasNode) => void;
     /** Called when mouse enters a node */
-    onNodeMouseEnter?: (event: React.MouseEvent, node: FlowNode) => void;
+    onNodeMouseEnter?: (event: React.MouseEvent, node: CanvasNode) => void;
     /** Called when mouse leaves a node */
-    onNodeMouseLeave?: (event: React.MouseEvent, node: FlowNode) => void;
+    onNodeMouseLeave?: (event: React.MouseEvent, node: CanvasNode) => void;
     /** Called when an edge is clicked */
-    onEdgeClick?: (event: React.MouseEvent, edge: FlowEdge) => void;
+    onEdgeClick?: (event: React.MouseEvent, edge: CanvasEdge) => void;
     /** S1: Custom frame node renderer */
     frameRenderer?: React.ComponentType<FrameNodeSlotProps>;
     /** Hide frame nodes. Shorthand for `frameRenderer={() => null}`. Default: false */
@@ -122,19 +122,19 @@ interface FlowRendererProps {
     /** S4: Show minimap (default: false) */
     minimap?: boolean;
     /** S4: Custom minimap node color function */
-    minimapNodeColor?: (node: FlowNode) => string;
+    minimapNodeColor?: (node: CanvasNode) => string;
     /** S4: Additional children rendered inside ReactFlow */
     children?: React.ReactNode;
     /** S5: Global override for all dynamic nodes. `content` is the resolved rendering (custom renderer output or default). `props.defaultRender` contains the original template/field-based rendering. */
     renderNode?: (props: DynamicNodeSlotProps, content: React.ReactElement) => React.ReactElement | null;
     /** S6: Called when viewport changes (pan/zoom) */
-    onViewportChange?: (viewport: FlowViewport) => void;
+    onViewportChange?: (viewport: CanvasViewport) => void;
     /** S6: Default viewport (used when fitView is false) */
-    defaultViewport?: FlowViewport;
+    defaultViewport?: CanvasViewport;
     /** S8: Focus on specific bounds (used for initial viewport fit). */
-    bounds?: FlowBounds;
+    bounds?: CanvasBounds;
     /** S8: Separate bounds for panning/zoom restriction. When set, overrides bounds-based translateExtent. Useful when fitBounds (content) differs from clampBounds (frame area). */
-    clampBounds?: FlowBounds;
+    clampBounds?: CanvasBounds;
     /** S8: Padding for focus bounds (default: 0.1) */
     focusPadding?: number;
     /** S8: Animate focus transition (true=300ms, number=custom ms, false=instant) */
@@ -150,14 +150,14 @@ interface FlowRendererProps {
     /** Maximum zoom level */
     maxZoom?: number;
 }
-declare function FlowRenderer({ data, className, style, nodeRenderers, nodeTypeDefs, edgeTypeDefs, background, interactive, fitView, onNodeClick, onNodeDoubleClick, onNodeContextMenu, onNodeMouseEnter, onNodeMouseLeave, onEdgeClick, frameRenderer, hideFrames, edgeRenderers, nodeWrapper, controls, minimap, minimapNodeColor, children, renderNode, onViewportChange, defaultViewport: defaultViewportProp, bounds, clampBounds, focusPadding, focusAnimation, focusMode, responsiveFit, translateExtent: translateExtentProp, minZoom: minZoomProp, maxZoom: maxZoomProp, }: FlowRendererProps): React.JSX.Element | null;
+declare function CanvasRenderer({ data, className, style, nodeRenderers, nodeTypeDefs, edgeTypeDefs, background, interactive, fitView, onNodeClick, onNodeDoubleClick, onNodeContextMenu, onNodeMouseEnter, onNodeMouseLeave, onEdgeClick, frameRenderer, hideFrames, edgeRenderers, nodeWrapper, controls, minimap, minimapNodeColor, children, renderNode, onViewportChange, defaultViewport: defaultViewportProp, bounds, clampBounds, focusPadding, focusAnimation, focusMode, responsiveFit, translateExtent: translateExtentProp, minZoom: minZoomProp, maxZoom: maxZoomProp, }: CanvasRendererProps): React.JSX.Element | null;
 
-interface FlowFrameProps extends Omit<FlowRendererProps, 'data' | 'nodeTypeDefs' | 'edgeTypeDefs' | 'bounds' | 'clampBounds' | 'fitView' | 'hideFrames' | 'translateExtent' | 'defaultViewport'> {
+interface CanvasFrameProps extends Omit<CanvasRendererProps, 'data' | 'nodeTypeDefs' | 'edgeTypeDefs' | 'bounds' | 'clampBounds' | 'fitView' | 'hideFrames' | 'translateExtent' | 'defaultViewport'> {
     /** SDK client instance (Client or ServerClient) */
     client: SDKClient;
-    /** Flow slug (URL-friendly identifier) */
+    /** Canvas slug (URL-friendly identifier) */
     slug?: string;
-    /** Flow document ID (UUID) */
+    /** Canvas document ID (UUID) */
     id?: string;
     /** Frame node ID to render */
     frameId: string;
@@ -167,31 +167,31 @@ interface FlowFrameProps extends Omit<FlowRendererProps, 'data' | 'nodeTypeDefs'
     error?: (err: Error) => React.ReactNode;
     /**
      * Called when frame data is ready — escape hatch for raw data access.
-     * Use `prefetchFlow({ client, slug })` for SSR.
+     * Use `prefetchCanvas({ client, slug })` for SSR.
      */
-    onDataReady?: (frameData: FrameData, flow: Record<string, unknown>) => void;
+    onDataReady?: (frameData: FrameData, canvas: Record<string, unknown>) => void;
 }
 /**
- * Renders a single frame from a Flow document.
+ * Renders a single frame from a Canvas document.
  *
- * Fetches the flow via `useFlow`, extracts the frame with `getFrameData`,
- * and passes the result to `FlowRenderer` with correct bounds wired.
+ * Fetches the canvas via `useCanvas`, extracts the frame with `getFrameData`,
+ * and passes the result to `CanvasRenderer` with correct bounds wired.
  *
- * For SSR / prefetching use the existing `prefetchFlow({ client, slug })`.
+ * For SSR / prefetching use the existing `prefetchCanvas({ client, slug })`.
  *
  * @example
  * ```tsx
- * import { FlowFrame } from '@01.software/sdk/ui/flow'
+ * import { CanvasFrame } from '@01.software/sdk/ui/canvas'
  *
  * export default function Home() {
  *   return (
  *     <div className="w-full h-screen">
- *       <FlowFrame client={client} slug="home" frameId={FRAME_ID} interactive />
+ *       <CanvasFrame client={client} slug="home" frameId={FRAME_ID} interactive />
  *     </div>
  *   )
  * }
  * ```
  */
-declare function FlowFrame({ client, slug, id, frameId, loading, error: renderError, onDataReady, ...rendererProps }: FlowFrameProps): React.JSX.Element | null;
+declare function CanvasFrame({ client, slug, id, frameId, loading, error: renderError, onDataReady, ...rendererProps }: CanvasFrameProps): React.JSX.Element | null;
 
-export { CanvasData, type CodeComponentProps, DynamicNodeSlotProps, EdgeSlotProps, EdgeTypeDef, FlowBounds, FlowEdge, FlowFrame, type FlowFrameProps, FlowNode, FlowRenderer, type FlowRendererProps, FlowViewport, FrameData, FrameNodeSlotProps, NodeTypeDef, NodeTypeFieldDef, NodeWrapperSlotProps, SDKClient, type UseFlowDataOptions, type UseFlowDataResult, clearTemplateCache, compileTemplate, getBooleanField, getImageField, getNumberField, getTextField, renderFieldValue, sanitizeCSS, useFlowData };
+export { CanvasBounds, CanvasData, CanvasEdge, CanvasFrame, type CanvasFrameProps, CanvasNode, CanvasRenderer, type CanvasRendererProps, CanvasViewport, type CodeComponentProps, DynamicNodeSlotProps, EdgeSlotProps, EdgeTypeDef, FrameData, FrameNodeSlotProps, NodeTypeDef, NodeTypeFieldDef, NodeWrapperSlotProps, SDKClient, type UseCanvasDataOptions, type UseCanvasDataResult, clearTemplateCache, compileTemplate, getBooleanField, getImageField, getNumberField, getTextField, renderFieldValue, sanitizeCSS, useCanvasData };

package/dist/ui/{flow.js → canvas.js}

@@ -1,6 +1,6 @@
 "use client";
 
-// src/ui/Flow/types.ts
+// src/ui/Canvas/types.ts
 function isDynamicNode(node) {
   return node.type === "dynamic";
 }
@@ -8,7 +8,7 @@ function isFrameNode(node) {
   return node.type === "frame";
 }
 
-// src/ui/Flow/built-in-node-types.ts
+// src/ui/Canvas/built-in-node-types.ts
 var BUILT_IN_NODE_TYPES = [
   {
     slug: "text",
@@ -31,7 +31,7 @@ var BUILT_IN_NODE_TYPES = [
   }
 ];
 
-// src/ui/Flow/built-in-edge-types.ts
+// src/ui/Canvas/built-in-edge-types.ts
 var BUILT_IN_EDGE_TYPES = [
   {
     slug: "default",
@@ -46,7 +46,7 @@ var BUILT_IN_EDGE_TYPES = [
   }
 ];
 
-// src/ui/Flow/useFlow.ts
+// src/ui/Canvas/useCanvas.ts
 import { useQuery } from "@tanstack/react-query";
 import { useMemo } from "react";
 
@@ -63,43 +63,43 @@ function collectionKeys(collection) {
   };
 }
 
-// src/ui/Flow/query-options.ts
-function flowQueryOptions(client, slug, id) {
+// src/ui/Canvas/query-options.ts
+function canvasQueryOptions(client, slug, id) {
   const identifier = id ?? slug ?? "";
   return {
-    queryKey: collectionKeys("flows").detail(identifier),
+    queryKey: collectionKeys("canvases").detail(identifier),
     queryFn: async () => {
-      if (id) return client.from("flows").findById(id);
-      const result = await client.from("flows").find({
+      if (id) return client.from("canvases").findById(id);
+      const result = await client.from("canvases").find({
         where: { slug: { equals: slug } },
         limit: 1
       });
       const doc = result.docs[0];
-      if (!doc) throw new Error(`Flow not found: ${slug}`);
+      if (!doc) throw new Error(`Canvas not found: ${slug}`);
       return doc;
     }
   };
 }
 function nodeTypesQueryOptions(client) {
   return {
-    queryKey: collectionKeys("flow-node-types").lists(),
+    queryKey: collectionKeys("canvas-node-types").lists(),
     queryFn: async () => {
-      const result = await client.from("flow-node-types").find({ limit: 0 });
+      const result = await client.from("canvas-node-types").find({ limit: 0 });
       return result.docs;
     }
   };
 }
 function edgeTypesQueryOptions(client) {
   return {
-    queryKey: collectionKeys("flow-edge-types").lists(),
+    queryKey: collectionKeys("canvas-edge-types").lists(),
     queryFn: async () => {
-      const result = await client.from("flow-edge-types").find({ limit: 0 });
+      const result = await client.from("canvas-edge-types").find({ limit: 0 });
       return result.docs;
     }
   };
 }
 
-// src/ui/Flow/useFlow.ts
+// src/ui/Canvas/useCanvas.ts
 function toNodeTypeDef(doc) {
   return {
     slug: String(doc.slug ?? ""),
@@ -128,12 +128,12 @@ function toEdgeTypeDef(doc) {
     fields: Array.isArray(doc.fields) ? doc.fields : []
   };
 }
-function useFlow(options) {
+function useCanvas(options) {
   const { client, slug, id, enabled = true } = options;
   const hasIdentifier = !!(slug || id);
-  const flowQuery = useQuery(
+  const canvasQuery = useQuery(
     {
-      ...flowQueryOptions(client, slug, id),
+      ...canvasQueryOptions(client, slug, id),
       enabled: enabled && hasIdentifier
     },
     client.queryClient
@@ -164,34 +164,34 @@ function useFlow(options) {
     const customDefs = apiDefs.filter((d) => !builtInSlugs.has(d.slug));
     return [...BUILT_IN_EDGE_TYPES, ...customDefs];
   }, [edgeTypesQuery.data]);
-  const flow = flowQuery.data;
-  const canvas = flow?.canvas;
+  const canvasDoc = canvasQuery.data;
+  const canvasData = canvasDoc?.canvas;
   return {
-    data: canvas,
+    data: canvasData,
     nodeTypeDefs,
     edgeTypeDefs,
-    flow,
-    isLoading: flowQuery.isLoading || nodeTypesQuery.isLoading || edgeTypesQuery.isLoading,
-    error: flowQuery.error ?? nodeTypesQuery.error ?? edgeTypesQuery.error
+    canvas: canvasDoc,
+    isLoading: canvasQuery.isLoading || nodeTypesQuery.isLoading || edgeTypesQuery.isLoading,
+    error: canvasQuery.error ?? nodeTypesQuery.error ?? edgeTypesQuery.error
   };
 }
 
-// src/ui/Flow/prefetchFlow.ts
-async function prefetchFlow(options) {
+// src/ui/Canvas/prefetchCanvas.ts
+async function prefetchCanvas(options) {
   const { client, slug, id } = options;
   if (!slug && !id) {
-    throw new Error("prefetchFlow requires either slug or id");
+    throw new Error("prefetchCanvas requires either slug or id");
   }
   await Promise.all([
-    client.queryClient.prefetchQuery(flowQueryOptions(client, slug, id)),
+    client.queryClient.prefetchQuery(canvasQueryOptions(client, slug, id)),
     client.queryClient.prefetchQuery(nodeTypesQueryOptions(client)),
     client.queryClient.prefetchQuery(edgeTypesQueryOptions(client))
   ]);
 }
 
-// src/ui/Flow/useFlowData.ts
+// src/ui/Canvas/useCanvasData.ts
 import { useMemo as useMemo2 } from "react";
-function useFlowData(options) {
+function useCanvasData(options) {
   const { data, nodeTypeDefs: inputNodeDefs, edgeTypeDefs: inputEdgeDefs } = options;
   const nodeTypeDefsMap = useMemo2(() => {
     const allDefs = inputNodeDefs ?? BUILT_IN_NODE_TYPES;
@@ -211,7 +211,7 @@ function useFlowData(options) {
   };
 }
 
-// src/ui/Flow/utils.ts
+// src/ui/Canvas/utils.ts
 function getNodeSize(node) {
   return {
     width: node.style?.width ?? node.measured?.width ?? node.width ?? 200,
@@ -328,11 +328,11 @@ function getFrameData(data, frameId) {
   };
 }
 
-// src/ui/Flow/template-compiler.ts
+// src/ui/Canvas/template-compiler.ts
 import React from "react";
 import { transform } from "sucrase";
 
-// src/ui/Flow/quickjs-loader.ts
+// src/ui/Canvas/quickjs-loader.ts
 import { useSyncExternalStore } from "react";
 var _state = { status: "idle", module: null };
 var _listeners = /* @__PURE__ */ new Set();
@@ -363,7 +363,7 @@ function useQuickJS() {
   return useSyncExternalStore(subscribeQuickJS, getQuickJSSnapshot, () => null);
 }
 
-// src/ui/Flow/template-compiler.ts
+// src/ui/Canvas/template-compiler.ts
 var MAX_CACHE_SIZE = 100;
 var MAX_MATERIALIZE_DEPTH = 20;
 var IFRAME_BLOCKED_PROPS = /* @__PURE__ */ new Set([
@@ -641,7 +641,7 @@ function clearTemplateCache() {
   rendererCache.clear();
 }
 
-// src/ui/Flow/node-renderers.tsx
+// src/ui/Canvas/node-renderers.tsx
 import React2 from "react";
 function sanitizeUrl(url) {
   if (!url) return url;
@@ -810,7 +810,7 @@ function DefaultFrameNode({ data }) {
   );
 }
 
-// src/ui/Flow/field-helpers.ts
+// src/ui/Canvas/field-helpers.ts
 function getImageField(fields, name) {
   const val = fields?.[name];
   if (val && typeof val === "object" && val !== null && "url" in val)
@@ -830,7 +830,7 @@ function getBooleanField(fields, name) {
   return typeof val === "boolean" ? val : void 0;
 }
 
-// src/ui/Flow/css-sanitizer.ts
+// src/ui/Canvas/css-sanitizer.ts
 import postcss from "postcss";
 var ALLOWED_AT_RULES = /* @__PURE__ */ new Set(["keyframes", "media", "supports", "container", "layer"]);
 var BLOCKED_VALUE_PATTERNS = [/url\s*\(/i, /expression\s*\(/i, /paint\s*\(/i, /-moz-binding/i];
@@ -929,7 +929,7 @@ function sanitizeCSS(css, scopeClass) {
   return root.toString().replace(/<\/style/gi, "<\\/style");
 }
 
-// src/ui/Flow/FlowRenderer.tsx
+// src/ui/Canvas/CanvasRenderer.tsx
 import React6 from "react";
 import {
   ReactFlow,
@@ -939,7 +939,7 @@ import {
   MiniMap
 } from "@xyflow/react";
 
-// src/ui/Flow/node-types-factory.tsx
+// src/ui/Canvas/node-types-factory.tsx
 import React4 from "react";
 
 // src/ui/Image/index.tsx
@@ -1103,7 +1103,7 @@ function Image({
   ));
 }
 
-// src/ui/Flow/node-types-factory.tsx
+// src/ui/Canvas/node-types-factory.tsx
 function createNodeTypes(nodeRenderers, nodeTypeDefsMap, frameRenderer, nodeWrapper, renderNode) {
   const types = {};
   types.dynamic = ((props) => {
@@ -1216,7 +1216,7 @@ function createEdgeTypes(edgeRenderers, edgeTypeDefsMap) {
   return types;
 }
 
-// src/ui/Flow/edge-styles.ts
+// src/ui/Canvas/edge-styles.ts
 import { MarkerType } from "@xyflow/react";
 function toMarkerType(value) {
   if (value === "arrow") return MarkerType.Arrow;
@@ -1268,7 +1268,7 @@ function applyEdgeStyles(edges, edgeTypeDefsMap) {
   });
 }
 
-// src/ui/Flow/focus-handler.tsx
+// src/ui/Canvas/focus-handler.tsx
 import React5 from "react";
 import { useReactFlow, useStoreApi } from "@xyflow/react";
 function clampViewport(vp, cw, ch, extent) {
@@ -1398,9 +1398,9 @@ function FocusHandler({
   );
 }
 
-// src/ui/Flow/FlowRenderer.tsx
+// src/ui/Canvas/CanvasRenderer.tsx
 var NullFrameRenderer = () => null;
-function FlowRenderer({
+function CanvasRenderer({
   data,
   className,
   style,
@@ -1577,9 +1577,9 @@ function FlowRenderer({
   ));
 }
 
-// src/ui/Flow/FlowFrame.tsx
+// src/ui/Canvas/CanvasFrame.tsx
 import React7, { useMemo as useMemo3, useEffect, useRef as useRef2 } from "react";
-function FlowFrame({
+function CanvasFrame({
   client,
   slug,
   id,
@@ -1589,7 +1589,7 @@ function FlowFrame({
   onDataReady,
   ...rendererProps
 }) {
-  const { data, nodeTypeDefs, edgeTypeDefs, flow, isLoading, error } = useFlow({
+  const { data, nodeTypeDefs, edgeTypeDefs, canvas, isLoading, error } = useCanvas({
     client,
     slug,
     id
@@ -1601,12 +1601,12 @@ function FlowFrame({
   const onDataReadyRef = useRef2(onDataReady);
   onDataReadyRef.current = onDataReady;
   useEffect(() => {
-    if (frameData && flow) {
-      onDataReadyRef.current?.(frameData, flow);
+    if (frameData && canvas) {
+      onDataReadyRef.current?.(frameData, canvas);
     }
-  }, [frameData, flow]);
+  }, [frameData, canvas]);
   if (process.env.NODE_ENV !== "production" && !slug && !id) {
-    console.warn('[FlowFrame] Either "slug" or "id" must be provided.');
+    console.warn('[CanvasFrame] Either "slug" or "id" must be provided.');
   }
   if (isLoading) return /* @__PURE__ */ React7.createElement(React7.Fragment, null, loading);
   if (error) return renderError ? /* @__PURE__ */ React7.createElement(React7.Fragment, null, renderError(error)) : null;
@@ -1614,13 +1614,13 @@ function FlowFrame({
     if (process.env.NODE_ENV !== "production" && data) {
       const frames = data.nodes.filter(isFrameNode).map((n) => n.id);
       console.warn(
-        `[FlowFrame] Frame "${frameId}" not found. Available frames: ${frames.join(", ") || "(none)"}`
+        `[CanvasFrame] Frame "${frameId}" not found. Available frames: ${frames.join(", ") || "(none)"}`
       );
     }
     return null;
   }
   return /* @__PURE__ */ React7.createElement(
-    FlowRenderer,
+    CanvasRenderer,
     {
       ...rendererProps,
       data: frameData.data,
@@ -1635,8 +1635,8 @@ function FlowFrame({
 export {
   BUILT_IN_EDGE_TYPES,
   BUILT_IN_NODE_TYPES,
-  FlowFrame,
-  FlowRenderer,
+  CanvasFrame,
+  CanvasRenderer,
   clearTemplateCache,
   compileTemplate,
   getBooleanField,
@@ -1648,10 +1648,10 @@ export {
   getTextField,
   isDynamicNode,
   isFrameNode,
-  prefetchFlow,
+  prefetchCanvas,
   renderFieldValue,
   sanitizeCSS,
-  useFlow,
-  useFlowData
+  useCanvas,
+  useCanvasData
 };
-//# sourceMappingURL=flow.js.map
+//# sourceMappingURL=canvas.js.map