@burdenoff/fluidgrids-fe-sdk 2026.1111.13 → 2026.1111.15

package/dist/{useExecutions-BqoD7XWi.js → useExecutions-DkS0FTfw.js}

@@ -2,7 +2,8 @@
 import { Jn as TriggerWorkflowDocument, Kn as TerminateExecutionDocument, Li as emitFluidGridsEvent, Oi as getFluidGridsClient, Ri as emitOperationErrorEvent, Rt as PauseExecutionDocument, Ui as throwIfResultError, aa as useExecutionsStore, cn as ResumeExecutionDocument, ln as RetryNodeDocument, lt as ExecutionStatsDocument, st as ExecutionDetailDocument, ut as ExecutionsListDocument, y as CancelExecutionDocument } from "./node-endpoint-configs-DHFGA5MQ.js";
 import { hD as RunGroupBy, yP as VersioningBehavior } from "./graphql-types-XcDLtFwU.js";
 import { c as REPLAY_WORKFLOW_RUN, l as RETRY_WORKFLOW_RUNS } from "./operations-HU-xb78H.js";
-import { ln as useFluidGridsAnalytics, mn as emitRunStarted, un as openRunQuotaUpgradePrompt } from "./FluidGridsProvider-CDZjKmfD.js";
+import { fn as useFluidGridsAnalytics, pn as openRunQuotaUpgradePrompt } from "./FluidGridsProvider-B9RR_CI_.js";
+import { i as emitRunStarted } from "./fluidgridsEvents-CNdcrUNN.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 

package/dist/{useObservability-Cs-5_NHh.js → useObservability-BkxhHZsX.js}

@@ -1,7 +1,8 @@
 "use client";
 import { Bi as describeOperationError, Li as emitFluidGridsEvent, Oi as getFluidGridsClient, Ui as throwIfResultError } from "./node-endpoint-configs-DHFGA5MQ.js";
-import { ln as useFluidGridsAnalytics, mn as emitRunStarted, un as openRunQuotaUpgradePrompt } from "./FluidGridsProvider-CDZjKmfD.js";
+import { fn as useFluidGridsAnalytics, pn as openRunQuotaUpgradePrompt } from "./FluidGridsProvider-B9RR_CI_.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
+import { i as emitRunStarted } from "./fluidgridsEvents-CNdcrUNN.js";
 import { a as OBSERVABILITY_DATA_SINKS, c as REPLAY_WORKFLOW_RUN, d as UPDATE_LOG_STREAM_DESTINATION, i as OBSERVABILITY_DASHBOARD_SUMMARY, l as RETRY_WORKFLOW_RUNS, n as DELETE_LOG_STREAM_DESTINATION, o as OBSERVABILITY_DATA_SINK_DATA, r as LOG_STREAM_DESTINATIONS, s as OBSERVABILITY_FAILED_RUNS, t as CREATE_LOG_STREAM_DESTINATION, u as TEST_LOG_STREAM_DESTINATION } from "./operations-HU-xb78H.js";
 import { useCallback, useEffect, useState } from "react";
 

package/dist/{useRunHistory-CEL-CIz-.js → useRunHistory-DHehG09Z.js}

@@ -1,6 +1,6 @@
 "use client";
 import { Bi as describeOperationError, Oi as getFluidGridsClient, Pn as SignalWorkflowRunDocument, Qr as WorkflowRunHistoryDocument, Ui as throwIfResultError, hn as RunEventAppendedDocument, ki as getFluidGridsClientSafe, qn as TerminateWorkflowRunDocument, qr as WorkflowRunDeterminismStatusDocument, rt as DurableRunFieldsDocument, ti as WorkflowRunStackTraceDocument } from "./node-endpoint-configs-DHFGA5MQ.js";
-import { In as parseRawSignalPayload, Ln as payloadFromCardValues, zn as signalPayloadCard } from "./FluidGridsProvider-CDZjKmfD.js";
+import { Cn as payloadFromCardValues, Sn as parseRawSignalPayload, Tn as signalPayloadCard } from "./FluidGridsProvider-B9RR_CI_.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
 import { yd as ExecutionKind } from "./graphql-types-XcDLtFwU.js";
 import { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";

package/dist/{useWorkflows-Bwpvfdgv.js → useWorkflows-DyhtoVwp.js}

@@ -1,7 +1,9 @@
 "use client";
 import { Ci as WorkflowVersionsDocument, Dr as WorkflowDefinitionDocument, G as DeleteWorkflowDefinitionDocument, Jn as TriggerWorkflowDocument, Jr as WorkflowRunDocument, Li as emitFluidGridsEvent, Oi as getFluidGridsClient, Or as WorkflowDefinitionForBuilderDocument, R as CreateWorkflowVersionDocument, Ri as emitOperationErrorEvent, Ui as throwIfResultError, V as DeactivateWorkflowDefinitionDocument, Vt as PreviewN8nImportDocument, et as DuplicateWorkflowDocument, ii as WorkflowRunsDocument, j as CreateWorkflowDefinitionDocument, kr as WorkflowDefinitionsDocument, qi as getFluidGridsConfig, r as ActivateWorkflowDefinitionDocument, sn as RestoreWorkflowVersionDocument, sr as UpdateWorkflowDefinitionDocument, xt as ImportWorkflowDocument, z as DashboardSummaryDocument } from "./node-endpoint-configs-DHFGA5MQ.js";
-import { _n as emitWorkflowCreated, ln as useFluidGridsAnalytics, mn as emitRunStarted, un as openRunQuotaUpgradePrompt, xn as runTriggerFromMode, yn as emitWorkflowPublished } from "./FluidGridsProvider-CDZjKmfD.js";
+import { fn as useFluidGridsAnalytics, pn as openRunQuotaUpgradePrompt } from "./FluidGridsProvider-B9RR_CI_.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
+import { d as runTriggerFromMode, i as emitRunStarted, l as emitWorkflowPublished, s as emitWorkflowCreated } from "./fluidgridsEvents-CNdcrUNN.js";
+import { s as takePrefetchedWorkflowForBuilder } from "./workflowRouteData-BkfVOc-O.js";
 import { useCallback, useEffect, useMemo, useState } from "react";
 
 // src/hooks/useWorkflows.ts
@@ -144,16 +146,33 @@ function useWorkflowDefinition(workflowKey, id) {
 		refetch: fetchData
 	};
 }
+/**
+* Sends an operation on its own request, at once, in a host whose client
+* batches requests (fe-libs' `SEND_UNBATCHED_CONTEXT_KEY`). Clients that do
+* not batch ignore it.
+*/
+const SEND_UNBATCHED = { sendUnbatched: true };
 function useLazyWorkflowDefinition(options = {}) {
-	const { withNodeManifests = false } = options;
+	const { withNodeManifests = false, routeCritical = false } = options;
 	const [workflow, setWorkflow] = useState(null);
 	const [loading, setLoading] = useState(false);
 	const [error, setError] = useState(null);
 	return {
-		getWorkflow: useCallback(async (workflowKey, id, version) => {
+		getWorkflow: useCallback(async (workflowKey, id, version, { reusePrefetched = false } = {}) => {
 			setLoading(true);
 			setError(null);
 			try {
+				const started = routeCritical && withNodeManifests && reusePrefetched && workflowKey && version && !id ? takePrefetchedWorkflowForBuilder({
+					workspaceId: getFluidGridsConfig().workspaceId,
+					workflowKey,
+					version
+				}) : null;
+				const prefetched = started ? await started : null;
+				if (prefetched) {
+					const data = prefetched;
+					setWorkflow(data);
+					return data;
+				}
 				const data = (await getFluidGridsClient().query({
 					query: withNodeManifests ? WorkflowDefinitionForBuilderDocument : WORKFLOW_DEFINITION,
 					variables: {
@@ -161,7 +180,8 @@ function useLazyWorkflowDefinition(options = {}) {
 						id,
 						...version ? { version } : {}
 					},
-					fetchPolicy: "network-only"
+					fetchPolicy: "network-only",
+					...routeCritical ? { context: SEND_UNBATCHED } : {}
 				})).data?.workflowDefinition ?? null;
 				setWorkflow(data);
 				return data;
@@ -171,7 +191,7 @@ function useLazyWorkflowDefinition(options = {}) {
 			} finally {
 				setLoading(false);
 			}
-		}, [withNodeManifests]),
+		}, [withNodeManifests, routeCritical]),
 		workflow,
 		loading,
 		error

package/dist/workflow-builder.js

@@ -1,6 +1,6 @@
 "use client";
-import { d as WorkflowBuilder, f as WorkflowBuilderCore, n as WorkflowBuilder$1, t as WorkflowSearchRedirect } from "./WorkflowSearchRedirect-B4nHALJg.js";
+import { d as WorkflowBuilder, f as WorkflowBuilderCore, n as WorkflowBuilder$1, t as WorkflowSearchRedirect } from "./WorkflowSearchRedirect-3gyHcYY2.js";
 import { H as useFlowStore } from "./node-operation-selection--oy-yEq_.js";
-import { f as refetchStoreNodes } from "./FluidGridsProvider-CDZjKmfD.js";
+import { m as refetchStoreNodes } from "./FluidGridsProvider-B9RR_CI_.js";
 
 export { WorkflowBuilder, WorkflowBuilderCore, WorkflowBuilder$1 as WorkflowBuilderPage, WorkflowSearchRedirect, refetchStoreNodes, useFlowStore };

package/dist/workflow-route.d.ts

@@ -0,0 +1,33 @@
+
+export declare const WORKFLOW_DEFINITION_FOR_BUILDER_QUERY = "\n  query WorkflowDefinitionForBuilder($workflowKey: String, $id: ID, $version: String) {\n    workflowDefinition(workflowKey: $workflowKey, id: $id, version: $version) {\n      id\n      workflowKey\n      version\n      name\n      description\n      status\n      definitionJson\n      pinnedNodeData\n      alias\n      icon\n      category\n      tags\n      context\n      projectId\n      tenantId\n      workspaceId\n      createdAt\n      updatedAt\n      createdById\n      revision\n      updatedById\n      nodeManifests\n    }\n  }\n";
+export declare const WORKFLOW_DEFINITION_FOR_BUILDER_OPERATION = "WorkflowDefinitionForBuilder";
+export declare const PREFETCHED_WORKFLOW_TTL_MS = 15000;
+interface WorkflowBuilderRoute {
+  workflowKey: string;
+  version: string;
+}
+interface WorkflowRouteOperation {
+  operationName: string;
+  query: string;
+  variables: Record<string, unknown>;
+}
+interface WorkflowRouteResponse {
+  data?: unknown;
+  errors?: ReadonlyArray<unknown> | null;
+}
+type WorkflowRouteRequest = (operation: WorkflowRouteOperation) => Promise<WorkflowRouteResponse>;
+interface WorkflowRouteTarget extends WorkflowBuilderRoute {
+  workspaceId: string;
+}
+interface PrefetchWorkflowForBuilderInput extends WorkflowRouteTarget {
+  request: WorkflowRouteRequest;
+}
+interface PrefetchedWorkflowDefinition {
+  readonly workflowKey: string;
+  readonly version: string;
+  readonly [field: string]: unknown;
+}
+export declare function matchWorkflowBuilderRoute(pathname: string, basePath?: string): WorkflowBuilderRoute | null;
+export declare function prefetchWorkflowForBuilder({ request, ...target }: PrefetchWorkflowForBuilderInput): boolean;
+export declare function clearPrefetchedWorkflowsForBuilder(): void;
+export type { PrefetchWorkflowForBuilderInput, PrefetchedWorkflowDefinition, WorkflowBuilderRoute, WorkflowRouteOperation, WorkflowRouteRequest, WorkflowRouteResponse, WorkflowRouteTarget };

package/dist/workflow-route.js

@@ -0,0 +1,4 @@
+"use client";
+import { a as matchWorkflowBuilderRoute, i as clearPrefetchedWorkflowsForBuilder, n as WORKFLOW_DEFINITION_FOR_BUILDER_OPERATION, o as prefetchWorkflowForBuilder, r as WORKFLOW_DEFINITION_FOR_BUILDER_QUERY, t as PREFETCHED_WORKFLOW_TTL_MS } from "./workflowRouteData-BkfVOc-O.js";
+
+export { PREFETCHED_WORKFLOW_TTL_MS, WORKFLOW_DEFINITION_FOR_BUILDER_OPERATION, WORKFLOW_DEFINITION_FOR_BUILDER_QUERY, clearPrefetchedWorkflowsForBuilder, matchWorkflowBuilderRoute, prefetchWorkflowForBuilder };

package/dist/workflowRouteData-BkfVOc-O.js

@@ -0,0 +1,169 @@
+"use client";
+// src/routing/workflowRouteData.ts
+/**
+* The builder's route data, started by the host before the builder's code has
+* loaded (BOFF-11585).
+*
+* On a cold load of a workflow's builder page the route's code (the host's
+* workflows module, the SDK pages and the canvas) takes a second or more to
+* arrive and run, and only then did the builder ask for the workflow. The host
+* knows the route and the person's workspace token long before that. It starts
+* the builder's one read itself, through its own GraphQL fetch (so the gateway's
+* `@rbac` and the workspace boundary decide exactly as they do for the
+* builder), and the builder takes the answer instead of asking again.
+*
+* The hand-off is deliberately narrow:
+* - a read is kept per workspace, workflow key and version, and is handed over
+*   once;
+* - it is handed over only within `PREFETCHED_WORKFLOW_TTL_MS` of its start,
+*   and a read still unanswered by then is given up;
+* - a read that failed, came back with errors or answered for another workflow
+*   is not handed over: the builder then sends its own read, which reports the
+*   problem the way it always has.
+*
+* This module imports nothing, so a host can put it on its entry without the
+* builder.
+*/
+/**
+* The builder's read (BOFF-10387): the workflow with the manifests of the node
+* types it uses. The same selection as
+* `src/operations/workflows/queries/workflowDefinitionForBuilder.graphql`
+* (`workflowRouteData.test.ts` keeps the two equal and checks this one against
+* the composed workspace schema); a plain string, so the hand-off does not
+* pull the SDK's generated documents onto a host's entry.
+*/
+const WORKFLOW_DEFINITION_FOR_BUILDER_QUERY = `
+  query WorkflowDefinitionForBuilder($workflowKey: String, $id: ID, $version: String) {
+    workflowDefinition(workflowKey: $workflowKey, id: $id, version: $version) {
+      id
+      workflowKey
+      version
+      name
+      description
+      status
+      definitionJson
+      pinnedNodeData
+      alias
+      icon
+      category
+      tags
+      context
+      projectId
+      tenantId
+      workspaceId
+      createdAt
+      updatedAt
+      createdById
+      revision
+      updatedById
+      nodeManifests
+    }
+  }
+`;
+/** The operation name of `WORKFLOW_DEFINITION_FOR_BUILDER_QUERY`. */
+const WORKFLOW_DEFINITION_FOR_BUILDER_OPERATION = "WorkflowDefinitionForBuilder";
+/** How long a started read may be handed to the builder, counted from its start. */
+const PREFETCHED_WORKFLOW_TTL_MS = 15e3;
+const started = /* @__PURE__ */ new Map();
+const keyOf = ({ workspaceId, workflowKey, version }) => JSON.stringify([
+	workspaceId,
+	workflowKey,
+	version
+]);
+/**
+* The workflow a builder path opens, or null for any other path. The builder
+* routes are `<basePath>/workflow/:key/:version` and
+* `<basePath>/builder/:key/:version`; the key and version are decoded the way
+* the router decodes route parameters.
+*/
+function matchWorkflowBuilderRoute(pathname, basePath = "/workflows") {
+	const base = basePath.replace(/\/+$/, "");
+	if (!pathname.startsWith(`${base}/`)) return null;
+	const match = /^(?:workflow|builder)\/([^/]+)\/([^/]+)\/?$/.exec(pathname.slice(base.length + 1));
+	if (!match) return null;
+	try {
+		const workflowKey = decodeURIComponent(match[1] ?? "");
+		const version = decodeURIComponent(match[2] ?? "");
+		return workflowKey && version ? {
+			workflowKey,
+			version
+		} : null;
+	} catch {
+		return null;
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The requested workflow from a response, or null when it cannot be used. */
+function usableDefinition(response, { workflowKey, version }) {
+	if (typeof response !== "object" || response === null) return null;
+	if (Array.isArray(response.errors) && response.errors.length > 0) return null;
+	const data = response.data;
+	if (!isRecord(data)) return null;
+	const definition = data.workflowDefinition;
+	if (!isRecord(definition) || definition.workflowKey !== workflowKey || definition.version !== version) return null;
+	return definition;
+}
+function dropExpired(now) {
+	for (const [key, read] of started) if (now - read.startedAt >= 15e3) started.delete(key);
+}
+/**
+* Starts the builder's read for a workflow, to be handed to the builder when
+* it opens that workflow. Returns false, and sends nothing, when the target is
+* incomplete or a read for it is already waiting to be handed over.
+*/
+function prefetchWorkflowForBuilder({ request, ...target }) {
+	if (!target.workspaceId || !target.workflowKey || !target.version) return false;
+	const now = Date.now();
+	dropExpired(now);
+	const key = keyOf(target);
+	if (started.has(key)) return false;
+	let response;
+	try {
+		response = request({
+			operationName: WORKFLOW_DEFINITION_FOR_BUILDER_OPERATION,
+			query: WORKFLOW_DEFINITION_FOR_BUILDER_QUERY,
+			variables: {
+				workflowKey: target.workflowKey,
+				version: target.version
+			}
+		});
+	} catch {
+		return false;
+	}
+	started.set(key, {
+		startedAt: now,
+		result: Promise.resolve(response).then((answer) => usableDefinition(answer, target), () => null)
+	});
+	return true;
+}
+/**
+* Takes the read started for this workflow, if there is one: a promise of the
+* workflow, or of null when the read cannot be used (the caller then sends its
+* own). Returns null when nothing was started for it, or it started too long
+* ago. A read is handed over once.
+*/
+function takePrefetchedWorkflowForBuilder(target, { maxAgeMs = PREFETCHED_WORKFLOW_TTL_MS } = {}) {
+	const now = Date.now();
+	dropExpired(now);
+	const key = keyOf(target);
+	const read = started.get(key);
+	if (!read) return null;
+	started.delete(key);
+	const remaining = read.startedAt + maxAgeMs - now;
+	if (remaining <= 0) return null;
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => resolve(null), remaining);
+		read.result.then((definition) => {
+			clearTimeout(timer);
+			resolve(definition);
+		});
+	});
+}
+/** Forgets every started read (for a host that signs the person out in place, and tests). */
+function clearPrefetchedWorkflowsForBuilder() {
+	started.clear();
+}
+
+export { matchWorkflowBuilderRoute as a, clearPrefetchedWorkflowsForBuilder as i, WORKFLOW_DEFINITION_FOR_BUILDER_OPERATION as n, prefetchWorkflowForBuilder as o, WORKFLOW_DEFINITION_FOR_BUILDER_QUERY as r, takePrefetchedWorkflowForBuilder as s, PREFETCHED_WORKFLOW_TTL_MS as t };

package/dist/workflows-list.js

@@ -1,4 +1,4 @@
 "use client";
-import { t as WorkflowsList } from "./WorkflowsList-B9F2e8M6.js";
+import { t as WorkflowsList } from "./WorkflowsList-CJ3KmMHX.js";
 
 export { WorkflowsList };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burdenoff/fluidgrids-fe-sdk",
-  "version": "2026.1111.13",
+  "version": "2026.1111.15",
   "description": "FluidGrids Workflow Builder SDK - Embeddable visual workflow automation",
   "type": "module",
   "imports": {
@@ -54,6 +54,14 @@
       "types": "./dist/workflow-preview.d.ts",
       "import": "./dist/workflow-preview.js"
     },
+    "./agent-tools": {
+      "types": "./dist/agent-tools.d.ts",
+      "import": "./dist/agent-tools.js"
+    },
+    "./workflow-route": {
+      "types": "./dist/workflow-route.d.ts",
+      "import": "./dist/workflow-route.js"
+    },
     "./styles.css": "./dist/styles.css"
   },
   "files": [