@burdenoff/fluidgrids-fe-sdk 2026.1029.4 → 2026.1029.5

package/dist/{WorkflowBuilder-BJC6RCJ6.js → WorkflowBuilder-EVZGOXZZ.js}

@@ -1,5 +1,6 @@
-export { WorkflowBuilder } from './chunk-E25BCOT6.js';
+export { WorkflowBuilder } from './chunk-JUA57OVN.js';
 import './chunk-LGGHQ7UE.js';
+import './chunk-PIKYQE7P.js';
 import './chunk-O24MDGZY.js';
 import './chunk-GEMNVFPK.js';
 import './chunk-IEVSFCFS.js';

package/dist/assistant.d.ts

@@ -47,4 +47,63 @@ declare const AiCreditBalanceSlot: FC<FgAiCreditBalanceProps>;
  */
 declare function notifyFluidGridsAiCreditsUpdated(): void;
 
-export { AiCreditBalanceSlot, FLUIDGRIDS_AI_CREDITS_UPDATED_EVENT, FLUIDGRIDS_AI_PRODUCT_KEY, type FgAiCreditBalanceProps, FluidGridsAiCreditsBridge, type FluidGridsAiCreditsBridgeProps, notifyFluidGridsAiCreditsUpdated };
+/** Mirror of fe-libs' `AssistantPreviewRun`. */
+interface FgAssistantRun {
+    readonly runId: string;
+    readonly conversationId: string;
+    readonly messageId: string;
+    /** The workspace the run started in. */
+    readonly workspaceId: string | null;
+    /** The actor the run started as. */
+    readonly actorId: string | null;
+}
+/** Mirror of fe-libs' `action-result` preview event: one approved write's root field. */
+interface FgAssistantActionResult {
+    kind: "action-result";
+    run: FgAssistantRun;
+    action: {
+        id: string;
+        operation: string;
+        responseKey: string;
+        /** Approved inputs, with sensitive arguments omitted. */
+        arguments: Readonly<Record<string, unknown>>;
+        /** The redacted GraphQL response. */
+        result: unknown;
+    };
+}
+/**
+ * Mirror of fe-libs' `AssistantPreviewEvent`. Only `action-result` is read;
+ * the other kinds are listed loosely so every fe-libs event is accepted.
+ */
+type FgAssistantPreviewEvent = FgAssistantActionResult | {
+    kind: "start" | "snapshot" | "end";
+    run: FgAssistantRun;
+};
+/** Mirror of fe-libs' `AssistantPreviewController`, headless. */
+interface FgAssistantPreviewController {
+    onEvent: (event: FgAssistantPreviewEvent) => void;
+}
+interface FluidGridsAssistantLiveCanvasOptions {
+    /**
+     * The signed-in actor now. When given, a write from a run started by another
+     * actor (a late result after an account switch) is ignored. Read on every
+     * event, so it may read a token lazily.
+     */
+    getActorId?: () => string | null;
+}
+/**
+ * Build the headless controller outside React (one per panel mount).
+ * `options` is read on every event.
+ */
+declare function createFluidGridsAssistantLiveCanvas(options?: FluidGridsAssistantLiveCanvasOptions): FgAssistantPreviewController;
+/**
+ * The headless preview controller for the shared assistant panel, STABLE for
+ * the life of the calling component (fe-libs requires a stable controller).
+ * The latest `getActorId` is used on every event without changing identity.
+ *
+ *   const liveCanvas = useFluidGridsAssistantLiveCanvas({ getActorId });
+ *   const panelProps = useMemo(() => ({ ..., preview: liveCanvas }), [liveCanvas, ...]);
+ */
+declare function useFluidGridsAssistantLiveCanvas(options?: FluidGridsAssistantLiveCanvasOptions): FgAssistantPreviewController;
+
+export { AiCreditBalanceSlot, FLUIDGRIDS_AI_CREDITS_UPDATED_EVENT, FLUIDGRIDS_AI_PRODUCT_KEY, type FgAiCreditBalanceProps, type FgAssistantActionResult, type FgAssistantPreviewController, type FgAssistantPreviewEvent, type FgAssistantRun, FluidGridsAiCreditsBridge, type FluidGridsAiCreditsBridgeProps, type FluidGridsAssistantLiveCanvasOptions, createFluidGridsAssistantLiveCanvas, notifyFluidGridsAiCreditsUpdated, useFluidGridsAssistantLiveCanvas };

package/dist/assistant.js

@@ -1,3 +1,4 @@
+export { createFluidGridsAssistantLiveCanvas, useFluidGridsAssistantLiveCanvas } from './chunk-PIKYQE7P.js';
 export { AiCreditBalanceSlot, FLUIDGRIDS_AI_CREDITS_UPDATED_EVENT, FLUIDGRIDS_AI_PRODUCT_KEY, FluidGridsAiCreditsBridge, notifyFluidGridsAiCreditsUpdated } from './chunk-Y53CVZVV.js';
 export { FluidGridsAssistantBridge, useFluidGridsPageControls } from './chunk-PJAWNFJV.js';
 import './chunk-62GWEYJ5.js';

package/dist/{chunk-E25BCOT6.js → chunk-JUA57OVN.js}

@@ -1,8 +1,12 @@
 import { isGuidedTourIntent, pickGuidedTour, withoutGuidedTourIntent, isCreateIntent, CreateWorkflowRefusalDialog, decideMissingWorkflow } from './chunk-LGGHQ7UE.js';
+import { registerLiveCanvasHandler } from './chunk-PIKYQE7P.js';
 import { useInstalledNodes, buildNodeCheck, FlowBuilderPage, buildRequiredNodeTypes } from './chunk-O24MDGZY.js';
 import { useLazyWorkflowDefinition, useCreateWorkflow } from './chunk-SRE2JVSJ.js';
-import { useFlowStore, refetchStoreNodes, BILLING_PLANS_PATH, codeBuildIdOf, mergeStickyNotes, blankWorkflowCreateInput, classifyCreateRefusal } from './chunk-2U56452G.js';
+import { useFlowStore, refetchStoreNodes, BILLING_PLANS_PATH, codeBuildIdOf, mergeStickyNotes, blankWorkflowCreateInput, classifyCreateRefusal, useSaveStatusStore, workflowFingerprint, registerWorkflowNodeTypes, throwIfResultError } from './chunk-2U56452G.js';
+import { getFluidGridsConfig } from './chunk-CY6KX4RG.js';
+import { WorkflowDefinitionDocument } from './chunk-7PP6CRXS.js';
 import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useLocation, useNavigate, useParams } from 'react-router';
 import { toast } from 'sonner';
 import { Icon } from '@iconify/react';
@@ -12,6 +16,654 @@ import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { ErrorBoundary } from '@burdenoff/fe-libs/shared/components';
 import '@xyflow/react/dist/style.css';
 
+// src/builder/live/canvas-base.ts
+var base = null;
+function currentCanvasBase() {
+  const flow = useFlowStore.getState();
+  if (!base || base.generation !== flow.loadGeneration || base.dbId !== flow.workflow.dbId) {
+    return null;
+  }
+  return base;
+}
+function setCanvasBase(next) {
+  base = next;
+}
+function snapshotOf(state) {
+  const { workflow } = state;
+  return {
+    generation: state.loadGeneration,
+    dbId: workflow.dbId,
+    nodes: workflow.nodes,
+    edges: workflow.edges,
+    name: workflow.name ?? "",
+    alias: workflow.alias ?? ""
+  };
+}
+function captureHydratedCanvasBase() {
+  const flow = useFlowStore.getState();
+  if (!flow.workflow.dbId || currentCanvasBase()) return false;
+  base = snapshotOf(flow);
+  return true;
+}
+function captureCanvasBaseIfInSync() {
+  const flow = useFlowStore.getState();
+  const { baseline } = useSaveStatusStore.getState();
+  if (!baseline || baseline.generation !== flow.loadGeneration) return false;
+  if (workflowFingerprint(flow.workflow) !== baseline.fingerprint) return false;
+  base = snapshotOf(flow);
+  return true;
+}
+function watchCanvasBase() {
+  if (!captureCanvasBaseIfInSync()) captureHydratedCanvasBase();
+  const unsubscribeStatus = useSaveStatusStore.subscribe((state, previous) => {
+    if (state.baseline !== previous.baseline) captureCanvasBaseIfInSync();
+  });
+  const unsubscribeFlow = useFlowStore.subscribe((state, previous) => {
+    if (state.loadGeneration !== previous.loadGeneration) base = null;
+    if (state.workflow.dbId && state.workflow !== previous.workflow) {
+      captureHydratedCanvasBase();
+    }
+  });
+  return () => {
+    unsubscribeStatus();
+    unsubscribeFlow();
+  };
+}
+
+// src/builder/live/assistant-writes.ts
+var IN_PLACE = /* @__PURE__ */ new Set([
+  "updateWorkflowDefinition",
+  "pinNodeData",
+  "unpinNodeData",
+  "activateWorkflowDefinition",
+  "deactivateWorkflowDefinition"
+]);
+var VERSION_RESPONSE = /* @__PURE__ */ new Set([
+  "createWorkflowVersion",
+  "restoreWorkflowVersion"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function rootFieldResult(result, responseKey, operation) {
+  let value = result;
+  if (typeof value === "string") {
+    try {
+      value = JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  if (!isRecord(value)) return null;
+  if (Array.isArray(value.errors) && value.errors.length > 0) return null;
+  const data = isRecord(value.data) ? value.data : value;
+  const root = data[responseKey] ?? data[operation];
+  return isRecord(root) ? root : null;
+}
+function classifyWorkflowWrite(action) {
+  const { operation, responseKey } = action;
+  const args = action.arguments ?? {};
+  const root = rootFieldResult(action.result, responseKey, operation);
+  if (IN_PLACE.has(operation)) {
+    const dbId = text(args.id) ?? text(root?.id);
+    return dbId ? { kind: "in-place", dbId } : null;
+  }
+  if (VERSION_RESPONSE.has(operation)) {
+    if (root?.success === false) return null;
+    const workflow = isRecord(root?.workflow) ? root.workflow : null;
+    const workflowKey = text(args.workflowKey) ?? text(workflow?.workflowKey);
+    if (!workflowKey) return null;
+    return {
+      kind: "new-version",
+      workflowKey,
+      version: text(workflow?.version),
+      dbId: text(workflow?.id)
+    };
+  }
+  if (operation === "applyWorkflowProposal") {
+    const workflowKey = text(root?.appliedWorkflowKey);
+    if (!workflowKey) return null;
+    return {
+      kind: "new-version",
+      workflowKey,
+      version: text(root?.appliedVersion),
+      dbId: text(root?.appliedWorkflowId)
+    };
+  }
+  return null;
+}
+
+// src/builder/live/definition-canvas.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasId(item) {
+  return isRecord2(item) && typeof item.id === "string" && item.id.length > 0;
+}
+function canvasFromDefinition(definitionJson) {
+  let definition = definitionJson;
+  if (typeof definition === "string") {
+    try {
+      definition = JSON.parse(definition);
+    } catch {
+      return null;
+    }
+  }
+  if (!isRecord2(definition)) return null;
+  const data = isRecord2(definition.data) ? definition.data : definition;
+  if (!Array.isArray(data.nodes)) return null;
+  const nodes = mergeStickyNotes({
+    nodes: data.nodes,
+    stickyNotes: Array.isArray(data.stickyNotes) ? data.stickyNotes : []
+  }).filter(hasId);
+  const edges = (Array.isArray(data.edges) ? data.edges : []).filter(
+    hasId
+  );
+  return { nodes, edges };
+}
+
+// src/builder/live/graph-merge.ts
+var VOLATILE_NODE_KEYS = /* @__PURE__ */ new Set([
+  "selected",
+  "dragging",
+  "resizing",
+  "measured",
+  "positionAbsolute"
+]);
+var VOLATILE_EDGE_KEYS = /* @__PURE__ */ new Set(["selected"]);
+var NODE_STRUCTURE_KEYS = /* @__PURE__ */ new Set(["id", "type", "position", "data"]);
+var CARRIED_NODE_KEYS = ["selected", "measured"];
+var CARRIED_EDGE_KEYS = ["selected"];
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stableStringify(value) {
+  return JSON.stringify(value, (_key, inner) => {
+    if (isRecord3(inner)) {
+      return Object.fromEntries(
+        Object.entries(inner).sort(
+          ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+        )
+      );
+    }
+    return inner;
+  }) ?? "";
+}
+function canonicalNode(node) {
+  const entries = Object.entries(node);
+  const data = node.data;
+  const dataRecord = isRecord3(data) ? data : null;
+  const kept = entries.filter(([key]) => {
+    if (VOLATILE_NODE_KEYS.has(key)) return false;
+    if (NODE_STRUCTURE_KEYS.has(key)) return true;
+    return !(dataRecord && key in dataRecord);
+  });
+  const projected = Object.fromEntries(kept);
+  if (dataRecord) projected.data = savedNodeSettings(dataRecord);
+  return stableStringify(projected);
+}
+function savedNodeSettings(data) {
+  const nodeData = data.nodeData;
+  if (!isRecord3(nodeData)) return data;
+  const opName = data.operation_name;
+  const rawOps = nodeData.operations;
+  const ops = Array.isArray(rawOps) ? rawOps : isRecord3(rawOps) && Array.isArray(rawOps.operations) ? rawOps.operations : [];
+  const current = typeof opName === "string" && opName.length > 0 ? ops.find((op) => isRecord3(op) && op.name === opName) : void 0;
+  if (!current) {
+    const { nodeData: _unsaved, ...rest } = data;
+    return rest;
+  }
+  return { ...data, nodeData: { ...nodeData, operations: [current] } };
+}
+function canonicalEdge(edge) {
+  return stableStringify(
+    Object.fromEntries(
+      Object.entries(edge).filter(([key]) => !VOLATILE_EDGE_KEYS.has(key))
+    )
+  );
+}
+function indexById(items) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (typeof item?.id === "string" && !map.has(item.id))
+      map.set(item.id, item);
+  }
+  return map;
+}
+function carry(from, onto, keys) {
+  const carried = {};
+  for (const key of keys) {
+    if (key in from) carried[key] = from[key];
+  }
+  return Object.keys(carried).length === 0 ? onto : { ...onto, ...carried };
+}
+function mergeItems(kind, base2, local, remote, canonical, carriedKeys) {
+  const baseById = indexById(base2);
+  const localById = indexById(local);
+  const remoteById = indexById(remote);
+  const counts = { added: 0, updated: 0, removed: 0 };
+  const touched = [];
+  const conflicts = [];
+  const items = [];
+  let localEdits = false;
+  const conflict = (id, reason) => conflicts.push({ kind, id, reason });
+  for (const [id, mine] of localById) {
+    const original = baseById.get(id);
+    const theirs = remoteById.get(id);
+    const mineKey = canonical(mine);
+    if (!original) {
+      localEdits = true;
+      if (theirs && canonical(theirs) !== mineKey) conflict(id, "both-changed");
+      items.push(mine);
+      continue;
+    }
+    const originalKey = canonical(original);
+    const localChanged = mineKey !== originalKey;
+    if (localChanged) localEdits = true;
+    if (!theirs) {
+      if (localChanged) {
+        conflict(id, "deleted-remotely");
+        items.push(mine);
+      } else {
+        counts.removed += 1;
+      }
+      continue;
+    }
+    const theirsKey = canonical(theirs);
+    if (theirsKey === originalKey || theirsKey === mineKey) {
+      items.push(mine);
+    } else if (!localChanged) {
+      items.push(carry(mine, theirs, carriedKeys));
+      counts.updated += 1;
+      touched.push(id);
+    } else {
+      conflict(id, "both-changed");
+      items.push(mine);
+    }
+  }
+  for (const [id, original] of baseById) {
+    if (localById.has(id)) continue;
+    localEdits = true;
+    const theirs = remoteById.get(id);
+    if (theirs && canonical(theirs) !== canonical(original)) {
+      conflict(id, "deleted-locally");
+    }
+  }
+  for (const [id, theirs] of remoteById) {
+    if (localById.has(id) || baseById.has(id)) continue;
+    items.push(theirs);
+    counts.added += 1;
+    touched.push(id);
+  }
+  return { items, counts, touched, conflicts, localEdits };
+}
+function mergeItemsWithoutBase(kind, local, remote, canonical) {
+  const localById = indexById(local);
+  const remoteById = indexById(remote);
+  const conflicts = [];
+  for (const [id, mine] of localById) {
+    const theirs = remoteById.get(id);
+    if (!theirs || canonical(theirs) !== canonical(mine)) {
+      conflicts.push({ kind, id, reason: "no-base" });
+    }
+  }
+  for (const id of remoteById.keys()) {
+    if (!localById.has(id)) conflicts.push({ kind, id, reason: "no-base" });
+  }
+  return {
+    items: [...localById.values()],
+    counts: { added: 0, updated: 0, removed: 0 },
+    touched: [],
+    conflicts,
+    // Unknown, so assume the canvas holds edits: the save baseline stays.
+    localEdits: true
+  };
+}
+function mergeWorkflowGraph(base2, local, remote) {
+  const nodes = base2 ? mergeItems(
+    "node",
+    base2.nodes,
+    local.nodes,
+    remote.nodes,
+    canonicalNode,
+    CARRIED_NODE_KEYS
+  ) : mergeItemsWithoutBase("node", local.nodes, remote.nodes, canonicalNode);
+  const edges = base2 ? mergeItems(
+    "edge",
+    base2.edges,
+    local.edges,
+    remote.edges,
+    canonicalEdge,
+    CARRIED_EDGE_KEYS
+  ) : mergeItemsWithoutBase("edge", local.edges, remote.edges, canonicalEdge);
+  const nodeIds = new Set(nodes.items.map((node) => node.id));
+  const localEdgeIds = new Set(local.edges.map((edge) => edge.id));
+  const remoteTouched = new Set(edges.touched);
+  let detached = 0;
+  const keptEdges = edges.items.filter((edge) => {
+    const { source, target } = edge;
+    const attached = (typeof source !== "string" || nodeIds.has(source)) && (typeof target !== "string" || nodeIds.has(target));
+    if (attached) return true;
+    if (!localEdgeIds.has(edge.id)) {
+      edges.counts.added -= 1;
+      return false;
+    }
+    if (remoteTouched.has(edge.id)) edges.counts.updated -= 1;
+    edges.conflicts.push({ kind: "edge", id: edge.id, reason: "detached" });
+    detached += 1;
+    return false;
+  });
+  const total = (c) => c.added + c.updated + c.removed;
+  return {
+    nodes: nodes.items,
+    edges: keptEdges,
+    counts: { nodes: nodes.counts, edges: edges.counts },
+    touchedNodeIds: nodes.touched,
+    conflicts: [...nodes.conflicts, ...edges.conflicts],
+    changed: total(nodes.counts) + total(edges.counts) + detached > 0,
+    localEdits: nodes.localEdits || edges.localEdits
+  };
+}
+function mergeScalar(base2, local, remote) {
+  if (local === base2) return { value: remote, conflict: false };
+  return { value: local, conflict: remote !== base2 && remote !== local };
+}
+
+// src/builder/live/live-canvas-sync.ts
+var ASSISTANT_SYNC_HISTORY_KIND = "assistant:sync";
+var SETTLE_MS = 1500;
+var SEEN_LIMIT = 200;
+function createLiveCanvasSync(deps) {
+  const now = deps.now ?? Date.now;
+  const seen = /* @__PURE__ */ new Set();
+  let running = null;
+  let queued = false;
+  const remember = (id) => {
+    if (seen.has(id)) return false;
+    seen.add(id);
+    if (seen.size > SEEN_LIMIT) {
+      const oldest = seen.values().next().value;
+      if (oldest !== void 0) seen.delete(oldest);
+    }
+    return true;
+  };
+  async function syncOnce() {
+    const flow = useFlowStore.getState();
+    const dbId = flow.workflow.dbId;
+    if (!dbId) return;
+    const generation = flow.loadGeneration;
+    let remote;
+    try {
+      remote = await deps.fetchDefinition(dbId);
+    } catch {
+      remote = null;
+    }
+    const after = useFlowStore.getState();
+    if (after.loadGeneration !== generation || after.workflow.dbId !== dbId) {
+      return;
+    }
+    const canvas = remote ? canvasFromDefinition(remote.definitionJson) : null;
+    if (!remote || !canvas) {
+      deps.notify({ kind: "failed" });
+      return;
+    }
+    applyRemote(remote, canvas);
+  }
+  function applyRemote(remote, canvas) {
+    const flow = useFlowStore.getState();
+    const { workflow, actions } = flow;
+    const localName = workflow.name ?? "";
+    const localAlias = workflow.alias ?? "";
+    const base2 = currentCanvasBase();
+    const merge = mergeWorkflowGraph(
+      base2,
+      { nodes: workflow.nodes, edges: workflow.edges },
+      canvas
+    );
+    const remoteName = remote.name ?? localName;
+    const remoteAlias = remote.alias ?? "";
+    const name = base2 ? mergeScalar(base2.name, localName, remoteName) : { value: localName};
+    const alias = base2 ? mergeScalar(base2.alias, localAlias, remoteAlias) : { value: localAlias};
+    const localEdits = !base2 || merge.localEdits || localName !== base2.name || localAlias !== base2.alias;
+    if (merge.changed) {
+      deps.registerNodeTypes(merge.nodes);
+      actions.nodes.setNodes(merge.nodes, {
+        historyKind: ASSISTANT_SYNC_HISTORY_KIND
+      });
+      actions.edges.setEdges(merge.edges, { skipHistory: true });
+    }
+    const patch = {};
+    if (name.value !== localName) patch.name = name.value;
+    if (alias.value !== localAlias) patch.alias = alias.value;
+    if (remote.status && remote.status !== workflow.status) {
+      patch.status = remote.status;
+    }
+    if (Object.keys(patch).length > 0) actions.setWorkflow(patch);
+    const synced = useFlowStore.getState();
+    setCanvasBase({
+      generation: synced.loadGeneration,
+      dbId: synced.workflow.dbId,
+      nodes: canvas.nodes,
+      edges: canvas.edges,
+      name: remoteName,
+      alias: remoteAlias
+    });
+    const status = useSaveStatusStore.getState();
+    if ((merge.changed || Object.keys(patch).length > 0) && !localEdits && status.baseline && status.baseline.generation === synced.loadGeneration) {
+      status.actions.setBaseline({
+        fingerprint: workflowFingerprint(synced.workflow),
+        generation: synced.loadGeneration,
+        settleUntil: now() + SETTLE_MS,
+        editRevision: synced.editRevision
+      });
+    }
+    deps.onSynced?.(remote);
+    const renamed = patch.name !== void 0 || patch.alias !== void 0;
+    if (merge.changed || merge.conflicts.length > 0 || renamed) {
+      deps.notify({ kind: "applied", merge, renamed });
+    }
+  }
+  function scheduleSync() {
+    if (running) {
+      queued = true;
+      return;
+    }
+    running = (async () => {
+      try {
+        do {
+          queued = false;
+          await syncOnce();
+        } while (queued);
+      } catch (error) {
+        console.error("[FluidGrids] assistant live canvas sync:", error);
+      } finally {
+        running = null;
+      }
+    })();
+  }
+  function handle(event) {
+    try {
+      const workspaceId = deps.workspaceId();
+      if (event.run.workspaceId && workspaceId && event.run.workspaceId !== workspaceId) {
+        return;
+      }
+      const write = classifyWorkflowWrite(event.action);
+      if (!write) return;
+      const { workflow } = useFlowStore.getState();
+      if (!workflow.dbId) return;
+      if (write.kind === "in-place") {
+        if (write.dbId !== workflow.dbId) return;
+        if (!remember(event.action.id)) return;
+        scheduleSync();
+        return;
+      }
+      const openKey = workflow.workflowKey || workflow.id;
+      if (write.workflowKey !== openKey) return;
+      if (write.dbId === workflow.dbId) {
+        if (remember(event.action.id)) scheduleSync();
+        return;
+      }
+      if (write.version !== null && write.version === workflow.version) return;
+      if (!remember(event.action.id)) return;
+      deps.notify({
+        kind: "new-version",
+        workflowKey: write.workflowKey,
+        version: write.version
+      });
+    } catch (error) {
+      console.error("[FluidGrids] assistant live canvas:", error);
+    }
+  }
+  return {
+    handle,
+    idle: async () => {
+      while (running) await running;
+    }
+  };
+}
+
+// src/builder/live/sync-notice.ts
+var KEY = "fluidgrids.builder.assistantSync";
+var NODE_PARTS = {
+  added: ["1 node added", "{{count}} nodes added"],
+  updated: ["1 node changed", "{{count}} nodes changed"],
+  removed: ["1 node removed", "{{count}} nodes removed"]
+};
+var EDGE_PARTS = {
+  added: ["1 connection added", "{{count}} connections added"],
+  updated: ["1 connection changed", "{{count}} connections changed"],
+  removed: ["1 connection removed", "{{count}} connections removed"]
+};
+function parts(tr, counts, kind) {
+  const words = kind === "nodes" ? NODE_PARTS : EDGE_PARTS;
+  return ["added", "updated", "removed"].filter((part) => counts[part] > 0).map((part) => {
+    const count = counts[part];
+    const [one, other] = words[part];
+    return count === 1 ? tr(`${KEY}.${kind}.${part}.one`, one) : tr(`${KEY}.${kind}.${part}.other`, other, { count });
+  });
+}
+function describeAppliedSync(tr, merge, renamed) {
+  const changes = [
+    ...parts(tr, merge.counts.nodes, "nodes"),
+    ...parts(tr, merge.counts.edges, "edges")
+  ];
+  if (renamed) changes.push(tr(`${KEY}.renamed`, "name changed"));
+  const nodeConflicts = merge.conflicts.filter((c) => c.kind === "node").length;
+  const edgeConflicts = merge.conflicts.length - nodeConflicts;
+  let conflicts = null;
+  if (nodeConflicts > 0 || edgeConflicts > 0) {
+    const what = [
+      nodeConflicts === 1 ? tr(`${KEY}.conflicts.nodes.one`, "1 node") : nodeConflicts > 1 ? tr(`${KEY}.conflicts.nodes.other`, "{{count}} nodes", {
+        count: nodeConflicts
+      }) : null,
+      edgeConflicts === 1 ? tr(`${KEY}.conflicts.edges.one`, "1 connection") : edgeConflicts > 1 ? tr(`${KEY}.conflicts.edges.other`, "{{count}} connections", {
+        count: edgeConflicts
+      }) : null
+    ].filter((item) => item !== null).join(tr(`${KEY}.and`, " and "));
+    conflicts = tr(
+      `${KEY}.conflicts.summary`,
+      "Kept your edits on {{what}} the assistant also changed",
+      { what }
+    );
+  }
+  return {
+    title: tr(`${KEY}.title`, "Assistant updated this workflow"),
+    summary: changes.length > 0 ? changes.join(", ") : null,
+    conflicts
+  };
+}
+function describeNewVersion(tr, version) {
+  if (!version) {
+    return {
+      title: tr(
+        `${KEY}.newVersion.unknown`,
+        "The assistant saved a new version of this workflow"
+      ),
+      action: null
+    };
+  }
+  return {
+    title: tr(
+      `${KEY}.newVersion.title`,
+      "The assistant saved version {{version}} of this workflow",
+      { version }
+    ),
+    action: tr(`${KEY}.newVersion.open`, "Open {{version}}", { version })
+  };
+}
+function describeFailedSync(tr) {
+  return tr(
+    `${KEY}.failed`,
+    "The assistant changed this workflow, but the canvas could not be refreshed. Reopen the workflow to see the change."
+  );
+}
+
+// src/builder/live/assistant-live-canvas-host.tsx
+async function fetchDefinition(dbId) {
+  const { data } = throwIfResultError(
+    await getFluidGridsClient().query({
+      query: WorkflowDefinitionDocument,
+      variables: { id: dbId },
+      fetchPolicy: "network-only"
+    })
+  );
+  return data?.workflowDefinition ?? null;
+}
+function AssistantLiveCanvasHost() {
+  const tr = useTr();
+  const navigate = useNavigate();
+  const latest = useRef({ tr, navigate });
+  useEffect(() => {
+    latest.current = { tr, navigate };
+  });
+  useEffect(() => {
+    const notify = (notice) => {
+      const { tr: t, navigate: go } = latest.current;
+      if (notice.kind === "failed") {
+        toast.error(describeFailedSync(t));
+        return;
+      }
+      if (notice.kind === "new-version") {
+        const text3 = describeNewVersion(t, notice.version);
+        const { workflowKey, version } = notice;
+        toast.info(text3.title, {
+          dismissible: true,
+          duration: 1e4,
+          ...text3.action && version ? {
+            action: {
+              label: text3.action,
+              onClick: () => go(`../workflow/${workflowKey}/${version}`)
+            }
+          } : {}
+        });
+        return;
+      }
+      const text2 = describeAppliedSync(t, notice.merge, notice.renamed);
+      const description = [text2.summary, text2.conflicts].filter((line) => line !== null).join(". ");
+      const show = text2.conflicts ? toast.warning : toast.success;
+      show(text2.title, {
+        dismissible: true,
+        ...description ? { description } : {}
+      });
+    };
+    const sync = createLiveCanvasSync({
+      fetchDefinition,
+      registerNodeTypes: registerWorkflowNodeTypes,
+      notify,
+      workspaceId: () => getFluidGridsConfig().workspaceId || null
+    });
+    const stopWatching = watchCanvasBase();
+    const unregister = registerLiveCanvasHandler(sync.handle);
+    return () => {
+      unregister();
+      stopWatching();
+    };
+  }, []);
+  return null;
+}
 var START_DELAY_MS = 800;
 function StartGuidedTour() {
   const location = useLocation();
@@ -118,9 +770,9 @@ function WorkflowItem({
       try {
         const { getGlobalStoreClient } = await import('./global-client-KLOVTVPP.js');
         const { InstallWorkflowNodeDocument } = await import('./global-operations-D2USVOPM.js');
-        const { getFluidGridsConfig } = await import('./config-T7BQ7AO2.js');
+        const { getFluidGridsConfig: getFluidGridsConfig2 } = await import('./config-T7BQ7AO2.js');
         const storeClient = getGlobalStoreClient();
-        const cfg = getFluidGridsConfig();
+        const cfg = getFluidGridsConfig2();
         for (let i = 0; i < nodesToInstall.length; i++) {
           const node = nodesToInstall[i];
           setInstallProgress({
@@ -552,6 +1204,7 @@ function WorkflowItem({
       }
     ),
     workflow && !isLoading && /* @__PURE__ */ jsx(FlowBuilderPage, { workflow }),
+    workflow && !isLoading && /* @__PURE__ */ jsx(AssistantLiveCanvasHost, {}),
     /* @__PURE__ */ jsx(GuidedTourStarter, { ready: Boolean(workflow && !isLoading) })
   ] });
 }

package/dist/chunk-PIKYQE7P.js

@@ -0,0 +1,58 @@
+import { useRef, useEffect, useMemo } from 'react';
+
+var LIVE_CANVAS_RELAY_KEY = /* @__PURE__ */ Symbol.for(
+  "burdenoff.fluidgrids.liveCanvas"
+);
+function relaySlot() {
+  const scope = globalThis;
+  const existing = scope[LIVE_CANVAS_RELAY_KEY];
+  if (existing) return existing;
+  const created = { handler: null };
+  scope[LIVE_CANVAS_RELAY_KEY] = created;
+  return created;
+}
+function registerLiveCanvasHandler(next) {
+  const slot = relaySlot();
+  slot.handler = next;
+  return () => {
+    if (slot.handler === next) slot.handler = null;
+  };
+}
+function isActionResult(event) {
+  if (typeof event !== "object" || event === null) return false;
+  const candidate = event;
+  return candidate.kind === "action-result" && typeof candidate.run === "object" && candidate.run !== null && typeof candidate.action === "object" && candidate.action !== null && typeof candidate.action.operation === "string" && typeof candidate.action.id === "string";
+}
+function deliverLiveCanvasEvent(event, options = {}) {
+  try {
+    if (!isActionResult(event)) return;
+    const current = relaySlot().handler;
+    if (!current) return;
+    if (options.getActorId) {
+      const actorId = options.getActorId();
+      if (event.run.actorId !== null && actorId !== null && event.run.actorId !== actorId) {
+        return;
+      }
+    }
+    current(event);
+  } catch (error) {
+    console.error("[FluidGrids] assistant live canvas:", error);
+  }
+}
+function createFluidGridsAssistantLiveCanvas(options = {}) {
+  return { onEvent: (event) => deliverLiveCanvasEvent(event, options) };
+}
+function useFluidGridsAssistantLiveCanvas(options = {}) {
+  const latest = useRef(options);
+  useEffect(() => {
+    latest.current = options;
+  });
+  return useMemo(
+    () => ({
+      onEvent: (event) => deliverLiveCanvasEvent(event, latest.current)
+    }),
+    []
+  );
+}
+
+export { createFluidGridsAssistantLiveCanvas, registerLiveCanvasHandler, useFluidGridsAssistantLiveCanvas };

package/dist/index.js

@@ -1,8 +1,9 @@
 export { Label } from './chunk-VTQVPNUQ.js';
 export { WorkflowBuilder, WorkflowBuilderCore, WorkflowSearchRedirect } from './chunk-MNPZMFLF.js';
-export { GuidedTourStarter, WorkflowBuilder as WorkflowBuilderPage } from './chunk-E25BCOT6.js';
+export { GuidedTourStarter, WorkflowBuilder as WorkflowBuilderPage } from './chunk-JUA57OVN.js';
 export { FirstWorkflowChecklist, FirstWorkflowChecklistView, WorkflowsList, useCreateWorkflowFirst } from './chunk-XTXT4NHE.js';
 export { CreateWorkflowRefusalDialog, GUIDED_FIRST_WORKFLOW_NAV, GUIDED_FIRST_WORKFLOW_STATE, GUIDED_TOUR_STATE, firstWorkflowProgress, isGuidedTourIntent, pickGuidedTour } from './chunk-LGGHQ7UE.js';
+import './chunk-PIKYQE7P.js';
 import './chunk-AD3BXTJS.js';
 export { ExecutionsListPage } from './chunk-DASEJQ4G.js';
 import { usePendingHumanRequests, HumanRequestCard } from './chunk-6Y6I2ODM.js';
@@ -77,7 +78,7 @@ var WorkflowsList2 = lazy(
   () => import('./WorkflowsList-2OYIXGWQ.js').then((m) => ({ default: m.WorkflowsList }))
 );
 var WorkflowBuilder3 = lazy(
-  () => import('./WorkflowBuilder-BJC6RCJ6.js').then((m) => ({
+  () => import('./WorkflowBuilder-EVZGOXZZ.js').then((m) => ({
     default: m.WorkflowBuilder
   }))
 );

package/dist/workflow-builder.js

@@ -1,6 +1,7 @@
 export { WorkflowBuilder, WorkflowBuilderCore, WorkflowSearchRedirect } from './chunk-MNPZMFLF.js';
-export { WorkflowBuilder as WorkflowBuilderPage } from './chunk-E25BCOT6.js';
+export { WorkflowBuilder as WorkflowBuilderPage } from './chunk-JUA57OVN.js';
 import './chunk-LGGHQ7UE.js';
+import './chunk-PIKYQE7P.js';
 import './chunk-O24MDGZY.js';
 import './chunk-GEMNVFPK.js';
 import './chunk-IEVSFCFS.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burdenoff/fluidgrids-fe-sdk",
-  "version": "2026.1029.4",
+  "version": "2026.1029.5",
   "description": "FluidGrids Workflow Builder SDK - Embeddable visual workflow automation",
   "type": "module",
   "imports": {