@burdenoff/fluidgrids-fe-sdk 2026.1105.4 → 2026.1107.1

package/dist/workflow-builder.js

@@ -1,31 +1,31 @@
-export { WorkflowBuilder, WorkflowBuilderCore, WorkflowSearchRedirect } from './chunk-GBQC5WDH.js';
-export { WorkflowBuilder as WorkflowBuilderPage } from './chunk-LLCVVRCE.js';
-import './chunk-Y4UCHFGK.js';
+export { WorkflowBuilder, WorkflowBuilderCore, WorkflowSearchRedirect } from './chunk-E3PNEIBJ.js';
+export { WorkflowBuilder as WorkflowBuilderPage } from './chunk-HY3XCZLB.js';
+import './chunk-752BT4WM.js';
 import './chunk-PIKYQE7P.js';
-import './chunk-OTOQFZFO.js';
-import './chunk-XWINH6CR.js';
+import './chunk-4F54UT62.js';
+import './chunk-NMYENCP2.js';
 import './chunk-GEMNVFPK.js';
 import './chunk-B6CCE2RW.js';
 import './chunk-IEVSFCFS.js';
 import './chunk-YXMFRQYV.js';
 import './chunk-BQXVT32O.js';
-import './chunk-43GSC5Y6.js';
-import './chunk-JRLBPR5U.js';
+import './chunk-JRSCUUBT.js';
+import './chunk-TDFC5U66.js';
 import './chunk-PASKZCII.js';
 import './chunk-JDLQ6QIB.js';
 import './chunk-KHS2DZHH.js';
 import './chunk-Y53CVZVV.js';
-import './chunk-5Z4F24QT.js';
-import './chunk-6VIG44VF.js';
-import './chunk-EIMTOK6E.js';
+import './chunk-OHKSDHNC.js';
+import './chunk-KE677WYY.js';
+import './chunk-V2K4HJY4.js';
 import './chunk-GLYINMOR.js';
 import './chunk-H4ERTSMX.js';
 import './chunk-4VJ3MDOV.js';
-export { refetchStoreNodes } from './chunk-HSTP2RX3.js';
+export { refetchStoreNodes } from './chunk-HUCRE45R.js';
 import './chunk-5375NUIO.js';
 import './chunk-JL7CASN5.js';
 import './chunk-SDZEAIIE.js';
-export { useFlowStore } from './chunk-TGWDFLEX.js';
+export { useFlowStore } from './chunk-UZJKX5FN.js';
 import './chunk-Y7FKJJMF.js';
 import './chunk-TYI2XOSI.js';
 import './chunk-G77IGC3Y.js';

package/dist/workflow-preview.d.ts

@@ -3,81 +3,35 @@ import { ReactNode, CSSProperties } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Node, Edge } from '@xyflow/react';
 
-/**
- * Pure handle-spec resolution for node cards — split from the rendering in
- * output-handles.tsx so non-UI code (attach helpers, tests) can use it
- * without dragging React/fe-libs into the import graph.
- */
-/**
- * Connection handle spec — mirrors IInternalNodeManifest.outputHandles in
- * wspace-workflow-svc (seeded into node_endpoint_configs.operations and
- * surfaced by the nodeManifest resolver).
- */
 interface NodeHandleSpec {
-    /** Handle id — MUST match the activeHandle values the executor returns */
     id: string;
-    /** Short label rendered next to the handle (n8n-style) */
     label: string;
-    /** Visual tone for the handle/label */
     tone?: "success" | "error" | "warning" | "info" | "neutral";
 }
 
-/**
- * Pure model behind `WorkflowPreviewCanvas` (BOFF-9806): what each node card
- * of a read-only workflow preview shows, read from a stored `definitionJson`
- * with no node registry, store, config or network.
- *
- * The derivations mirror the builder's node component (`blocks/nodes/node/
- * node.tsx`) so a preview card reads like the builder card for the same node:
- * the same trigger / logic / action role accent, the same compact logic card
- * for internal control-flow nodes, the same labelled output handles. Where the
- * builder reads the node registry (manifest name, icon, description), the
- * preview asks an optional resolver, then the node's own saved manifest
- * snapshot (`data.nodeData`), then a fallback derived from the node type.
- */
-
-/** What a host knows about a node type (typically from the node registry). */
 interface WorkflowPreviewNodeMeta {
-    /** Display name of the node type ("Gmail", "Schedule"). */
     title?: string;
-    /** Iconify name ("logos:slack-icon") or an image URL / data URI. */
     icon?: string;
     description?: string;
 }
-/**
- * Optional lookup of node-type metadata. Return `undefined` for a type the
- * host does not know; the preview then uses the node's saved manifest snapshot
- * and, failing that, a name and icon derived from the type.
- */
 type WorkflowPreviewNodeMetaResolver = (nodeType: string) => WorkflowPreviewNodeMeta | undefined;
-/** Everything one preview card draws. */
 interface PreviewCardModel {
-    /** `app`: the rich card (header + operation); `logic`: the compact card. */
     variant: "app" | "logic";
     nodeType: string;
-    /** Header text: the node's own label, else the node type's name (`""`
-     *  when neither is known; the card then shows its translated fallback). */
     title: string;
-    /** The node type's name (the rename placeholder in the builder). */
     appName: string;
     icon: string;
-    /** Operation shown in the card body; `null` shows the description only. */
     operation: string | null;
     description: string;
-    /** Logic card: short config summary under the title. */
     subtitle?: string;
     trigger: boolean;
     disabled: boolean;
-    /** Role accent (trigger / logic / action node-category token). */
     accent: string;
-    /** Key that picks the header's icon-square accent (`nodeAccent`). */
     accentKey: string;
     inputHandles: NodeHandleSpec[];
     outputHandles: NodeHandleSpec[];
-    /** Extra body height so many-output cards do not crowd. */
     handleSpacer: number;
 }
-/** A canvas node the preview renders (`type` is always the preview card). */
 type PreviewFlowNode = Node<{
     card: PreviewCardModel;
 }, "preview">;
@@ -85,62 +39,23 @@ interface PreviewCanvasModel {
     nodes: PreviewFlowNode[];
     edges: Edge[];
 }
-/** "store/gmail_reader" → "Gmail Reader"; "internal:http-request" → "Http Request". */
 declare function humanizeNodeType(nodeType: string): string;
-/** Icon for a node type with no manifest at hand. */
 declare function fallbackNodeIcon(nodeType: string): string;
-/** The card model of one stored node (sticky notes are not cards). */
 declare function previewCardModel(raw: Node, resolveMeta?: WorkflowPreviewNodeMetaResolver): PreviewCardModel;
-/**
- * The preview canvas of a stored definition, or `null` when it carries no
- * canvas. Sticky notes are annotations, not steps, so they are left out; an
- * edge to a node the preview does not draw is dropped, and a target handle
- * the target card does not have falls back to its first input.
- */
 declare function previewCanvasFromDefinition(definitionJson: unknown, resolveMeta?: WorkflowPreviewNodeMetaResolver): PreviewCanvasModel | null;
-/**
- * The order a sequenced reveal shows nodes in: along the flow (left to right),
- * then top to bottom. Ids in `shown` are already on screen and are skipped.
- */
 declare function previewRevealOrder(nodes: ReadonlyArray<Pick<Node, "id" | "position">>, shown?: ReadonlySet<string>): string[];
-/** An edge is drawn once both of its ends are on screen. */
 declare function edgesBetweenVisible<E extends Pick<Edge, "source" | "target">>(edges: readonly E[], visible: ReadonlySet<string>): E[];
-/**
- * The node that just appeared: the last id of `next` (in `order`) that was not
- * in `previous`. Keeps the current newest when nothing was added, and drops it
- * when it left the canvas.
- */
 declare function newestNodeId(previous: ReadonlySet<string>, next: ReadonlySet<string>, order: readonly string[], current: string | null): string | null;
 
 interface WorkflowPreviewCanvasProps {
-    /**
-     * The stored `definitionJson` (object or JSON string): `{ data: { nodes,
-     * edges } }` or a flat `{ nodes, edges }`, read the way the builder loads
-     * it. A definition with no `nodes` array renders `emptyState`.
-     */
     definition: unknown;
-    /**
-     * Ids of the nodes on screen. Omit to show every node. Ids the definition
-     * does not have are ignored.
-     */
     visibleNodeIds?: Iterable<string>;
-    /** Ids of nodes that just appeared: drawn with a highlight ring. */
     freshNodeIds?: Iterable<string>;
-    /** The build is in progress: flow runs along the edges and the newest node pulses. */
     running?: boolean;
-    /**
-     * Node-type metadata (name, icon, description), e.g. from a loaded node
-     * registry. Without it, cards use each node's saved manifest snapshot, then
-     * a name and icon derived from the node type. Keep the function stable.
-     */
     resolveNodeMeta?: WorkflowPreviewNodeMetaResolver;
-    /** Upper zoom bound for the camera and the viewer. Default 1.5. */
     maxZoom?: number;
-    /** Padding the camera keeps around the visible nodes. Default 0.25. */
     fitPadding?: number;
-    /** Rendered instead of the canvas when the definition has no canvas. */
     emptyState?: ReactNode;
-    /** Accessible name of the canvas region. */
     ariaLabel?: string;
     className?: string;
     style?: CSSProperties;
@@ -148,11 +63,8 @@ interface WorkflowPreviewCanvasProps {
 declare function WorkflowPreviewCanvasComponent({ definition, visibleNodeIds, freshNodeIds, running, resolveNodeMeta, maxZoom, fitPadding, emptyState, ariaLabel, className, style, }: WorkflowPreviewCanvasProps): react_jsx_runtime.JSX.Element;
 declare const WorkflowPreviewCanvas: React.MemoExoticComponent<typeof WorkflowPreviewCanvasComponent>;
 
-/** Node enter: fade + pop. */
 declare const NODE_ENTER_MS = 260;
-/** Edge enter: the path draws from source to target. */
 declare const EDGE_DRAW_MS = 360;
-/** Camera move to take in a new node. */
 declare const CAMERA_MS = 350;
 
 export { type PreviewCanvasModel, type PreviewCardModel, type PreviewFlowNode, CAMERA_MS as WORKFLOW_PREVIEW_CAMERA_MS, EDGE_DRAW_MS as WORKFLOW_PREVIEW_EDGE_DRAW_MS, NODE_ENTER_MS as WORKFLOW_PREVIEW_NODE_ENTER_MS, WorkflowPreviewCanvas, type WorkflowPreviewCanvasProps, type WorkflowPreviewNodeMeta, type WorkflowPreviewNodeMetaResolver, edgesBetweenVisible, fallbackNodeIcon, humanizeNodeType, newestNodeId, previewCanvasFromDefinition, previewCardModel, previewRevealOrder };

package/dist/workflow-preview.js

@@ -1,5 +1,5 @@
-import { canvasFromDefinition } from './chunk-6VIG44VF.js';
-import { LogicNodeCard, NodeCard, NodeCardHeader, NodeCardBody, InputHandles, OutputHandles, STICKY_NOTE_TYPE, outputHandlesSpacerHeight, isNodeTrigger, resolveOutputHandles, resolveInputHandles, resolveOperationName, WAIT_FOR_SIGNAL_NODE_TYPE, CODE_WORKFLOW_NODE_TYPE, readSignalName } from './chunk-TGWDFLEX.js';
+import { canvasFromDefinition } from './chunk-KE677WYY.js';
+import { LogicNodeCard, NodeCard, NodeCardHeader, NodeCardBody, InputHandles, OutputHandles, STICKY_NOTE_TYPE, isNodeTrigger, resolveOutputHandles, resolveInputHandles, resolveOperationName, outputHandlesSpacerHeight, WAIT_FOR_SIGNAL_NODE_TYPE, CODE_WORKFLOW_NODE_TYPE, readSignalName } from './chunk-UZJKX5FN.js';
 import './chunk-Y7FKJJMF.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { memo, useMemo, useState, useCallback, useSyncExternalStore, useRef, useEffect } from 'react';
@@ -119,27 +119,14 @@ function previewCardModel(raw, resolveMeta) {
     )
   };
 }
-function branchTone(id) {
-  const key = id.toLowerCase();
-  if (key === "true" || key === "success" || key === "approved")
-    return "success";
-  if (key === "false" || key === "done") return "neutral";
-  if (key === "error" || key === "failed" || key === "declined") return "error";
-  return void 0;
-}
-function withEdgeSourceHandles(card, edgeHandleIds) {
+function withAdapterPorts(card, edgeHandleIds) {
   const known = new Set(card.outputHandles.map((handle) => handle.id));
   const missing = [...new Set(edgeHandleIds)].filter((id) => !known.has(id));
   if (missing.length === 0) return card;
-  const isDefault = card.outputHandles.length === 1 && card.outputHandles[0]?.label === "";
-  const named = missing.map((id) => ({
-    id,
-    label: id,
-    tone: branchTone(id)
-  }));
-  if (isDefault && named.length === 1)
-    return { ...card, outputHandles: [{ id: named[0].id, label: "" }] };
-  const outputHandles = isDefault ? named : [...card.outputHandles, ...named];
+  const outputHandles = [
+    ...card.outputHandles,
+    ...missing.map((id) => ({ id, label: id }))
+  ];
   return {
     ...card,
     outputHandles,
@@ -148,28 +135,82 @@ function withEdgeSourceHandles(card, edgeHandleIds) {
     )
   };
 }
+function adapterPortNames(data) {
+  const manifest = isRecord(data.nodeData) ? data.nodeData : {};
+  const adapters = Array.isArray(manifest.nodeAdapters) ? manifest.nodeAdapters : [];
+  return adapters.map((adapter) => isRecord(adapter) ? adapter.name : void 0).filter((name) => typeof name === "string" && !!name);
+}
+function builderCardPorts(nodes, edges, cards) {
+  const adapters = /* @__PURE__ */ new Map();
+  for (const node of nodes)
+    adapters.set(node.id, adapterPortNames(cardData(node)));
+  const adapterSets = new Map(
+    [...adapters].map(([id, names]) => [id, new Set(names)])
+  );
+  const subNodes = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (cardData(node).isAdapterInstance) subNodes.add(node.id);
+  }
+  for (const edge of edges) {
+    const handle = edge.sourceHandle;
+    if (!handle || handle === "source") continue;
+    if (adapterSets.get(edge.source)?.has(handle)) subNodes.add(edge.target);
+  }
+  const ports = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const card = cards.get(node.id);
+    if (!card) continue;
+    const own = adapters.get(node.id) ?? [];
+    if (subNodes.has(node.id)) {
+      ports.set(node.id, { sources: own, targets: ["target"] });
+      continue;
+    }
+    const hasInputs = card.variant === "logic" || !card.trigger;
+    ports.set(node.id, {
+      sources: [...card.outputHandles.map((handle) => handle.id), ...own],
+      targets: hasInputs ? card.inputHandles.map((handle) => handle.id) : []
+    });
+  }
+  return ports;
+}
+function builderHandle(ports, handle) {
+  if (!handle) return ports[0] ?? null;
+  return ports.includes(handle) ? handle : null;
+}
 function previewCanvasFromDefinition(definitionJson, resolveMeta) {
   const canvas = canvasFromDefinition(definitionJson);
   if (!canvas) return null;
   const steps = canvas.nodes.filter((node) => node.type !== STICKY_NOTE_TYPE);
   const ids = new Set(steps.map((node) => node.id));
-  const rawEdges = canvas.edges.filter(
+  const betweenSteps = canvas.edges.filter(
     (edge) => ids.has(edge.source) && ids.has(edge.target)
   );
+  const resolved = /* @__PURE__ */ new Map();
+  for (const raw of steps)
+    resolved.set(raw.id, previewCardModel(raw, resolveMeta));
+  const ports = builderCardPorts(steps, betweenSteps, resolved);
+  const rawEdges = betweenSteps.flatMap((edge) => {
+    const sourceHandle = builderHandle(
+      ports.get(edge.source)?.sources ?? [],
+      edge.sourceHandle
+    );
+    const targetHandle = builderHandle(
+      ports.get(edge.target)?.targets ?? [],
+      edge.targetHandle
+    );
+    return sourceHandle && targetHandle ? [{ ...edge, sourceHandle, targetHandle }] : [];
+  });
   const sourceHandles = /* @__PURE__ */ new Map();
   for (const edge of rawEdges) {
-    if (!edge.sourceHandle) continue;
     const list = sourceHandles.get(edge.source) ?? [];
     list.push(edge.sourceHandle);
     sourceHandles.set(edge.source, list);
   }
-  const cards = /* @__PURE__ */ new Map();
   const nodes = steps.map((raw) => {
-    const card = withEdgeSourceHandles(
-      previewCardModel(raw, resolveMeta),
+    const card = withAdapterPorts(
+      resolved.get(raw.id) ?? previewCardModel(raw, resolveMeta),
       sourceHandles.get(raw.id) ?? []
     );
-    cards.set(raw.id, card);
     const position = isRecord(raw.position) ? raw.position : {};
     return {
       id: raw.id,
@@ -185,23 +226,17 @@ function previewCanvasFromDefinition(definitionJson, resolveMeta) {
       deletable: false
     };
   });
-  const edges = rawEdges.map((edge) => {
-    const sourceCard = cards.get(edge.source);
-    const targetCard = cards.get(edge.target);
-    const targetHandle = edge.targetHandle && targetCard?.inputHandles.some((h) => h.id === edge.targetHandle) ? edge.targetHandle : targetCard?.inputHandles[0]?.id ?? null;
-    const sourceHandle = edge.sourceHandle ?? sourceCard?.outputHandles[0]?.id ?? null;
-    return {
-      id: edge.id,
-      source: edge.source,
-      target: edge.target,
-      sourceHandle,
-      targetHandle,
-      type: PREVIEW_EDGE_TYPE,
-      selectable: false,
-      deletable: false,
-      focusable: false
-    };
-  });
+  const edges = rawEdges.map((edge) => ({
+    id: edge.id,
+    source: edge.source,
+    target: edge.target,
+    sourceHandle: edge.sourceHandle,
+    targetHandle: edge.targetHandle,
+    type: PREVIEW_EDGE_TYPE,
+    selectable: false,
+    deletable: false,
+    focusable: false
+  }));
   return { nodes, edges };
 }
 function previewRevealOrder(nodes, shown = /* @__PURE__ */ new Set()) {

package/dist/workflows-list.js

@@ -1,18 +1,18 @@
-export { WorkflowsList } from './chunk-M72SMQOS.js';
-import './chunk-Y4UCHFGK.js';
-import './chunk-WC526MLS.js';
+export { WorkflowsList } from './chunk-RI4NFNDX.js';
+import './chunk-752BT4WM.js';
+import './chunk-ZWDKN6PU.js';
 import './chunk-5ERAJC2I.js';
-import './chunk-JRLBPR5U.js';
+import './chunk-TDFC5U66.js';
 import './chunk-FNZZ5JJL.js';
-import './chunk-EIMTOK6E.js';
+import './chunk-V2K4HJY4.js';
 import './chunk-PJAWNFJV.js';
 import './chunk-H4ERTSMX.js';
 import './chunk-4VJ3MDOV.js';
-import './chunk-HSTP2RX3.js';
+import './chunk-HUCRE45R.js';
 import './chunk-5375NUIO.js';
 import './chunk-JL7CASN5.js';
 import './chunk-SDZEAIIE.js';
-import './chunk-TGWDFLEX.js';
+import './chunk-UZJKX5FN.js';
 import './chunk-Y7FKJJMF.js';
 import './chunk-TYI2XOSI.js';
 import './chunk-G77IGC3Y.js';

package/package.json

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

package/dist/pageControlsBridge-D6y36qi5.d.ts

@@ -1,87 +0,0 @@
-import { FC, ReactNode } from 'react';
-
-/**
- * Assistant page-controls bridge (BOFF-8679 / BOFF-8988, P3).
- *
- * The pages in this SDK can tell a host's assistant which controls they show
- * right now (tabs, filters, search), so a typed or spoken "show failed runs"
- * does exactly what a click on the page's own Status dropdown does.
- *
- * The SDK deliberately does NOT import `@burdenoff/fe-libs/shared/assistant/*`:
- * many consumers pin an older fe-libs, and a runtime import would raise their
- * floor. Instead the host mounts {@link FluidGridsAssistantBridge} with a
- * `register` function (the host maps a spec onto its own assistant), and the
- * pages call {@link useFluidGridsPageControls}. The types below are structural
- * mirrors of the fe-libs `TabsSpec` / `EnumFilterSpec`, so a host can pass a
- * spec straight into `tabsOf` / `enumFilter` with no conversion.
- *
- * Contract:
- * - No provider mounted: every hook call is a no-op (the SDK works unchanged).
- * - A spec describes ONLY what the page shows on screen at this moment; a page
- *   passes `null` while it shows no toolbar.
- * - Every `set` is the page's own state setter (the one its dropdown calls).
- *   There is no submit, save, create, delete, run or retry in a spec.
- * - Pass a memoised spec; a new object every render re-registers every render.
- */
-
-/** One option of an enum filter, in the page's own words. */
-interface FgFilterOption {
-    value: string;
-    label: string;
-}
-/** A single-choice filter (a dropdown or a chip group). */
-interface FgEnumFilterSpec {
-    id: string;
-    /** The filter's own name on the page ("Status"). */
-    label: string;
-    /**
-     * The options the page offers. The NEUTRAL one ("All") must be included so
-     * the host can clear the filter; the host does not list it as a choice.
-     */
-    options: readonly FgFilterOption[];
-    /** The value that means "no filter". */
-    neutral: string;
-    /** The value applied now. */
-    value: string;
-    /** The page's own setter. */
-    set(value: string): void;
-}
-interface FgTabsSpec {
-    items: readonly {
-        id: string;
-        label: string;
-    }[];
-    /** The tab shown now. */
-    value: string;
-    /** The page's own setter. */
-    set(id: string): void;
-}
-interface FgPageControlsSpec {
-    /** The page's title in the product's words ("Workflows"). */
-    page: string;
-    tabs?: FgTabsSpec;
-    filters?: readonly FgEnumFilterSpec[];
-    /** The page's own search setter; `""` clears the search. */
-    search?(query: string): void;
-}
-/** Registers a page's controls; the returned function removes exactly that registration. */
-type FgRegisterPageControls = (spec: FgPageControlsSpec) => () => void;
-interface FluidGridsAssistantBridgeProps {
-    /**
-     * The host's registration function. Give it a STABLE identity (a module
-     * constant or `useCallback`): a new function every render re-registers the
-     * mounted page every render.
-     */
-    register: FgRegisterPageControls;
-    children: ReactNode;
-}
-/** Context provider a host mounts around the FluidGrids routes. */
-declare const FluidGridsAssistantBridge: FC<FluidGridsAssistantBridgeProps>;
-/**
- * Register a page's controls for as long as the calling component is mounted
- * (and `spec` is non-null). With no {@link FluidGridsAssistantBridge} above,
- * this does nothing.
- */
-declare function useFluidGridsPageControls(spec: FgPageControlsSpec | null): void;
-
-export { type FgEnumFilterSpec as F, type FgFilterOption as a, type FgPageControlsSpec as b, type FgRegisterPageControls as c, type FgTabsSpec as d, FluidGridsAssistantBridge as e, type FluidGridsAssistantBridgeProps as f, useFluidGridsPageControls as u };