@burdenoff/fluidgrids-fe-sdk 2026.1111.6 → 2026.1111.8

package/dist/{FluidGridsProvider-BNzMznqt.js → FluidGridsProvider-CGu1DfIa.js}

@@ -1,6 +1,6 @@
 "use client";
 import { t as __exportAll } from "./rolldown-runtime-hDbaFkMy.js";
-import { Ai as waitForFluidGridsClient, Bi as throwIfResultError, Ei as getFluidGridsClientSafe, Fi as emitOperationErrorEvent, Gn as TriggerWorkflowDocument, Ii as emitRunCompletedOnce, Ji as setFluidGridsConfig, Ki as resetFluidGridsConfig, Li as describeOperationError, Oi as resetFluidGridsClient, Pi as emitFluidGridsEvent, R as CreateWorkflowVersionDocument, Ti as getFluidGridsClient, Vi as createLiveTokenReader, Wi as getFluidGridsConfig, Wr as WorkflowRunDocument, Yi as validateTrustedOrigin, at as EventRegistrationsDocument, gn as RunFromNodeDocument, ir as UpdateWorkflowDefinitionDocument, j as CreateWorkflowDefinitionDocument, ji as createFluidGridsTokenRefreshLink, ki as setFluidGridsClient, kt as NodeManifestDocument, ot as ExecuteStepDocument, qi as resetFluidGridsExecutionState, st as ExecutionDetailDocument, t as fetchAllNodeEndpointConfigs, wi as createFluidGridsClient, wr as WorkflowDefinitionDocument } from "./node-endpoint-configs-Dol5ckHv.js";
+import { $i as validateTrustedOrigin, Ai as getFluidGridsClientSafe, At as NodeManifestsDocument, Bi as emitRunCompletedOnce, Dr as WorkflowDefinitionDocument, En as SaveWorkflowDraftDocument, Fi as createFluidGridsTokenRefreshLink, Gi as createLiveTokenReader, Ji as getFluidGridsConfig, Jn as TriggerWorkflowDocument, Jr as WorkflowRunDocument, Mi as resetFluidGridsClient, Ni as setFluidGridsClient, Oi as createFluidGridsClient, Pi as waitForFluidGridsClient, Qi as setFluidGridsConfig, R as CreateWorkflowVersionDocument, Ri as emitFluidGridsEvent, Vi as describeOperationError, Wi as throwIfResultError, Xi as resetFluidGridsConfig, Zi as resetFluidGridsExecutionState, at as EventRegistrationsDocument, j as CreateWorkflowDefinitionDocument, jt as NodePaletteEntriesDocument, ki as getFluidGridsClient, ot as ExecuteStepDocument, st as ExecutionDetailDocument, t as fetchAllNodeEndpointConfigs, vn as RunFromNodeDocument, zi as emitOperationErrorEvent } from "./node-endpoint-configs-n4xr62e4.js";
 import { A as nodeAccent, C as nodeAdaptersOf, D as NodeCard, E as resolveOutputHandles, H as useFlowStore, I as partitionStickyNotes, L as resolveStickyColor, N as DEFAULT_STICKY_COLOR, O as NodeCardBody, P as STICKY_COLORS, R as stickySurfaceStyle, T as resolveInputHandles, V as STICKY_NOTE_TYPE, W as isNodeTrigger, _ as LogicNodeCard, b as alignPlainOutputEdges, i as WAIT_FOR_SIGNAL_NODE_TYPE, j as NodeTypeIcon, k as NodeCardHeader, l as interfaceFields, m as readSignalName, n as synchronizeOperationUpdate, p as readCodeWorkflowState, r as CODE_WORKFLOW_NODE_TYPE, t as resolveOperationName, u as interfaceHandlers, v as InputHandles, w as outputHandlesSpacerHeight, x as hasNodeManifest, y as OutputHandles } from "./node-operation-selection--oy-yEq_.js";
 import { n as FluidGridsTranslationProvider, r as useTr, t as ENGLISH_FALLBACK_TRANSLATOR } from "./TranslationBridge-Da-TPgQm.js";
 import { createContext, memo, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
@@ -3769,8 +3769,10 @@ function prepareNodeForSave(node) {
 	return prepareNodeForSave$1(node, slimNodeDataToCurrentOperation);
 }
 /**
-* The stored `definitionJson` of a saved version, read fresh, so a save keeps
-* what other screens wrote there (the Settings page's `config`).
+* The stored `definitionJson` of a saved version, read fresh, so a save that
+* creates a new version from it keeps what other screens wrote there (the
+* Settings page's `config`). A save in place does not read it: the service
+* keeps those fields itself (`mergeStoredDefinition`).
 */
 async function readStoredDefinition(client, dbId) {
 	const { data } = throwIfResultError(await client.query({
@@ -3781,6 +3783,21 @@ async function readStoredDefinition(client, dbId) {
 	if (!data?.workflowDefinition) throw new Error("Could not read the saved workflow before saving it");
 	return data.workflowDefinition.definitionJson;
 }
+/**
+* Drop a saved version's cached `definitionJson`. The draft save no longer
+* reads the definition back (BOFF-10389), so the cached copy is the one from
+* before the save; a later cache-first read must go to the service instead.
+*/
+function forgetCachedDefinition(client, dbId) {
+	const id = client.cache.identify({
+		__typename: "WorkflowDefinition",
+		id: dbId
+	});
+	if (id) client.cache.evict({
+		id,
+		fieldName: "definitionJson"
+	});
+}
 /** The canvas part of `definitionJson`, as the builder has always written it. */
 function builderDefinition(snapshot, workflowKey, minted) {
 	const { workflow } = snapshot;
@@ -3839,20 +3856,22 @@ function useSaveWorkflow() {
 			const workflowKey = snapshot.key || mintedKey || "";
 			const forkRequested = asNewVersion && !!workflow.dbId;
 			const isDraft = !forkRequested && (!workflow.status || workflow.status === "DRAFT");
+			const inPlace = !forkRequested && savesInPlace(workflow);
 			const expectedRevision = revisionOf(workflow.dbId);
 			const client = getFluidGridsClient();
 			const { preparedWorkflow, owned } = builderDefinition(snapshot, workflowKey, !!mintedKey);
-			const definitionJson = workflow.dbId ? mergeDefinitionJson(await readStoredDefinition(client, workflow.dbId), owned) : owned;
+			const definitionJson = workflow.dbId && !inPlace ? mergeDefinitionJson(await readStoredDefinition(client, workflow.dbId), owned) : owned;
 			let savedVersion = workflow.version;
 			let savedDbId = workflow.dbId;
 			let operation = "updated";
-			if (workflow.dbId && savesInPlace(workflow)) {
+			if (workflow.dbId && inPlace) {
 				const { data } = throwIfResultError(await client.mutate({
-					mutation: UpdateWorkflowDefinitionDocument,
+					mutation: SaveWorkflowDraftDocument,
 					variables: {
 						id: workflow.dbId,
 						input: {
 							definitionJson,
+							mergeStoredDefinition: true,
 							name: workflow.name,
 							description: workflow.name || "Workflow update",
 							alias: workflow.alias?.trim() ? workflow.alias.trim() : null,
@@ -3865,6 +3884,7 @@ function useSaveWorkflow() {
 				savedVersion = data.updateWorkflowDefinition.version;
 				savedDbId = data.updateWorkflowDefinition.id;
 				rememberRevision(savedDbId, data.updateWorkflowDefinition.revision);
+				forgetCachedDefinition(client, savedDbId);
 				operation = "updated";
 				if (!silent) toast.success("Workflow saved", {
 					description: `Updated version ${savedVersion}`,
@@ -4063,14 +4083,23 @@ function isFlowComplete(nodes, edges) {
 	const hasAnyLoneNode = nodesWithEmptyTarget.length > 0;
 	return hasTriggerNode && isTriggerConnected && (!hasEndNode || isEndConnected) && !hasAnyLoneNode;
 }
+/**
+* Check the canvas with {@link isFlowComplete} and hand the answer to
+* `onValidate` (Save and Run). The check is synchronous and takes well under a
+* frame, so it runs at once (BOFF-10389: a fixed 300 ms wait used to delay
+* every Save and Run). `isValidating` stays true until `onValidate` settles,
+* so a second click while the save or run is starting is ignored.
+*/
 function useFlowValidator(onValidate) {
 	const [isValidating, setIsValidating] = useState(false);
 	const { getNodes, getEdges } = useReactFlow();
 	return [isValidating, useCallback(async () => {
 		setIsValidating(true);
-		await new Promise((resolve) => setTimeout(resolve, 300));
-		onValidate?.(isFlowComplete(getNodes(), getEdges()));
-		setIsValidating(false);
+		try {
+			await onValidate?.(isFlowComplete(getNodes(), getEdges()));
+		} finally {
+			setIsValidating(false);
+		}
 	}, [
 		getNodes,
 		getEdges,
@@ -10109,38 +10138,88 @@ const OrganizationPrivateNodesDocument = {
 // src/graphql/global-operations.ts
 var global_operations_exports = /* @__PURE__ */ __exportAll({ InstallWorkflowNodeDocument: () => InstallWorkflowNodeDocument });
 
-// src/builder/components/flow-builder/components/blocks/index.ts
-const NODE_MANIFEST = NodeManifestDocument;
-const NODE_CONFIGS = [];
-/**
-* Fetch node manifest using GraphQL
-*/
-async function fetchNodeManifest(nodeType, nodeVersion) {
-	try {
-		const { data } = await getFluidGridsClient().query({
-			query: NODE_MANIFEST,
-			variables: {
-				nodeType,
-				version: nodeVersion
-			}
-		});
-		return data?.nodeManifest ?? null;
-	} catch (error) {
-		const message = error instanceof Error ? error.message : "Unknown error";
-		console.error(`Error fetching manifest for ${nodeType} v${nodeVersion}:`, message);
-		return null;
+// src/builder/components/flow-builder/components/blocks/node-manifests.ts
+/**
+* Refs per request. The server takes up to 500; smaller requests keep each
+* response to a few megabytes (store manifests reach 370 KB each) and let the
+* gateway resolve them side by side.
+*/
+const NODE_MANIFEST_BATCH_SIZE = 100;
+const manifestCache = /* @__PURE__ */ new Map();
+function manifestKey(nodeType, version) {
+	return `${nodeType}@${version}`;
+}
+/** The value as a node manifest, or null when it lacks the identifying fields. */
+function asNodeManifest(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+	const record = value;
+	if (typeof record.nodeType !== "string" || !record.nodeType || typeof record.version !== "string" || !record.version) return null;
+	return {
+		...record,
+		name: typeof record.name === "string" ? record.name : record.nodeType
+	};
+}
+/** Keep manifests that arrived some other way (with a workflow) for the session. */
+function rememberNodeManifests(values) {
+	const manifests = [];
+	for (const value of values) {
+		const manifest = asNodeManifest(value);
+		if (!manifest) continue;
+		manifestCache.set(manifestKey(manifest.nodeType, manifest.version), manifest);
+		manifests.push(manifest);
 	}
+	return manifests;
+}
+/** The cached manifest of an exact node version, if this session loaded it. */
+function cachedNodeManifest(nodeType, version) {
+	return manifestCache.get(manifestKey(nodeType, version));
 }
 /**
-* Push a store node manifest entry into NODE_CONFIGS if not already present.
-* Used for both BUILTIN-registered store nodes and user-installed store nodes
-* whose manifest comes from the StoreAppInstallation record.
+* Manifests for `refs`: exact versions already in the session cache are served
+* from it; the rest are fetched with `nodeManifests`, at most
+* `NODE_MANIFEST_BATCH_SIZE` refs per request, all requests in parallel. Refs the
+* registry does not know are absent from the result. A failed request is logged
+* and its refs are treated as unknown, so one bad batch never empties the palette.
 */
-function pushStoreNodeConfig(manifest, publishType = "STORE") {
-	if (NODE_CONFIGS.some((c) => c.type === manifest.nodeType)) return;
+async function loadNodeManifests(client, refs) {
+	const result = [];
+	const missing = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const ref of refs) {
+		const key = manifestKey(ref.nodeType, ref.version ?? "");
+		if (!ref.nodeType || seen.has(key)) continue;
+		seen.add(key);
+		const cached = ref.version ? cachedNodeManifest(ref.nodeType, ref.version) : void 0;
+		if (cached) result.push(cached);
+		else missing.push(ref.version ? ref : { nodeType: ref.nodeType });
+	}
+	const batches = [];
+	for (let i = 0; i < missing.length; i += 100) batches.push(missing.slice(i, i + 100));
+	const fetched = await Promise.all(batches.map(async (batch) => {
+		try {
+			const { data } = await client.query({
+				query: NodeManifestsDocument,
+				variables: { refs: batch },
+				fetchPolicy: "no-cache"
+			});
+			return rememberNodeManifests(data?.nodeManifests ?? []);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			console.error(`[Workflows] Could not load ${batch.length} node manifest(s):`, message);
+			return [];
+		}
+	}));
+	for (const manifests of fetched) result.push(...manifests);
+	return result;
+}
+
+// src/builder/components/flow-builder/components/blocks/index.ts
+const NODE_CONFIGS = [];
+/** The registry entry for one manifest. */
+function toNodeConfig(manifest, publishType) {
 	const manifestOps = manifest.operations;
 	const operations = Array.isArray(manifestOps) ? manifestOps : manifestOps?.operations ?? manifestOps;
-	NODE_CONFIGS.push({
+	return {
 		type: manifest.nodeType,
 		detail: {
 			icon: manifest.icon || "mynaui:keyboard-solid",
@@ -10165,21 +10244,36 @@ function pushStoreNodeConfig(manifest, publishType = "STORE") {
 		},
 		operations,
 		publishType
-	});
+	};
+}
+function hasNodeConfig(type) {
+	return NODE_CONFIGS.some((config) => config.type === type);
+}
+/** Add a config unless its node type is already registered. */
+function addNodeConfig(config) {
+	if (hasNodeConfig(config.type)) return false;
+	NODE_CONFIGS.push(config);
+	return true;
 }
+/** Only one installations request at a time: the canvas and the palette may both ask. */
+let installationsRequest = null;
 /**
-* Load installed store nodes from the global store client.
-* Uses the manifest stored in each StoreAppInstallation (recorded at install time)
-* so store-svc is the single source of truth — no zip download or workflow-svc
-* NodeEndpointConfig entry needed for store nodes.
-*
-* Silently no-ops if the global store client or workspaceId is not yet configured.
+* The manifests of the workspace's ACTIVE store installations, recorded at install
+* time. Store-svc is the single source of truth for them: no zip download or
+* workflow-svc registry entry is needed. Empty when the global store client or the
+* workspace is not configured yet.
 */
-async function loadInstalledStoreNodes() {
+function fetchInstalledStoreNodeManifests() {
+	if (!installationsRequest) installationsRequest = queryInstalledStoreNodeManifests().finally(() => {
+		installationsRequest = null;
+	});
+	return installationsRequest;
+}
+async function queryInstalledStoreNodeManifests() {
 	const globalClient = getGlobalStoreClient();
-	if (!globalClient) return;
+	if (!globalClient) return [];
 	const { workspaceId } = getFluidGridsConfig();
-	if (!workspaceId) return;
+	if (!workspaceId) return [];
 	try {
 		const { data } = await globalClient.query({
 			query: GetMyNodeInstallationsDocument,
@@ -10190,25 +10284,36 @@ async function loadInstalledStoreNodes() {
 			},
 			fetchPolicy: "network-only"
 		});
-		const installations = data?.myStoreAppInstallations?.items ?? [];
-		let loaded = 0;
-		for (const installation of installations) {
+		const manifests = [];
+		for (const installation of data?.myStoreAppInstallations?.items ?? []) {
 			if (installation.status !== "ACTIVE") continue;
 			const manifest = installation.manifest;
-			if (!manifest?.nodeType) continue;
-			pushStoreNodeConfig(manifest, "STORE");
-			loaded++;
+			if (manifest?.nodeType) manifests.push(manifest);
 		}
-		if (loaded > 0) console.log(`[Workflows] Loaded ${loaded} installed store node(s) from workspace installations.`);
+		return manifests;
 	} catch (error) {
 		const message = error instanceof Error ? error.message : "Unknown error";
 		console.warn("[Workflows] Could not load installed store nodes:", message);
+		return [];
 	}
 }
 /**
-* Fetch all nodes from GraphQL and populate NODE_CONFIGS.
-* Loads BUILTIN nodes from workflow-svc, then overlays installed store nodes
-* from the global store (using the manifest stored at install time).
+* Register installed store nodes. Any node type already registered (a built-in, or
+* a store node the registry vendors) is skipped; only genuinely missing ones are
+* added. `onlyTypes` limits it to those node types.
+*/
+async function loadInstalledStoreNodes(onlyTypes) {
+	const manifests = await fetchInstalledStoreNodeManifests();
+	let loaded = 0;
+	for (const manifest of manifests) {
+		if (onlyTypes && !onlyTypes.has(manifest.nodeType)) continue;
+		if (addNodeConfig(toNodeConfig(manifest, "STORE"))) loaded++;
+	}
+	if (loaded > 0) console.log(`[Workflows] Loaded ${loaded} installed store node(s) from workspace installations.`);
+}
+/**
+* Load the full palette into NODE_CONFIGS: every available registry node in the
+* registry's order (newest first), then the installed store nodes.
 */
 async function initializeNodeConfigs() {
 	try {
@@ -10218,81 +10323,123 @@ async function initializeNodeConfigs() {
 			await loadInstalledStoreNodes();
 			return;
 		}
-		const nodes = await fetchAllNodeEndpointConfigs(client, { status: "AVAILABLE" }, "cache-first");
-		if (nodes.length === 0) {
+		const entries = await fetchAllNodeEndpointConfigs(client, { status: "AVAILABLE" }, "cache-first", NodePaletteEntriesDocument);
+		if (entries.length === 0) {
 			console.warn("No node endpoint configs found.");
 			await loadInstalledStoreNodes();
 			return;
 		}
-		const manifestPromises = nodes.map(async (node) => {
-			if (node?.nodeType && node?.nodeVersion) try {
-				return await fetchNodeManifest(node.nodeType, node.nodeVersion);
-			} catch {
-				console.error(`Failed to fetch manifest for node ${node.id} (${node.nodeType} v${node.nodeVersion})`);
-				return null;
-			}
-			else {
-				console.warn(`Node ${node?.id ?? "unknown"} is missing nodeType or nodeVersion. Skipping manifest fetch.`);
-				return null;
-			}
-		});
-		(await Promise.all(manifestPromises)).forEach((manifest, index) => {
-			if (manifest === null) return;
-			const node = nodes[index];
-			const manifestOps = manifest.operations;
-			const operations = Array.isArray(manifestOps) ? manifestOps : manifestOps?.operations ?? manifestOps;
-			NODE_CONFIGS.push({
-				type: manifest.nodeType,
-				detail: {
-					icon: manifest.icon || "mynaui:keyboard-solid",
-					title: manifest.name,
-					description: manifest.description,
-					gradientColor: "yellow"
-				},
-				defaultData: {
-					operation_name: "",
-					operation_type: "",
-					nodeData: manifest,
-					version: manifest.version,
-					args: {
-						context: { node: {
-							id: manifest.nodeType,
-							kind: manifest.kind,
-							type: manifest.nodeType
-						} },
-						state: {},
-						credentials: []
-					}
-				},
-				operations,
-				publishType: node.publishType
-			});
-		});
+		const manifests = await loadNodeManifests(client, entries.map((entry) => ({
+			nodeType: entry.nodeType,
+			version: entry.nodeVersion
+		})));
+		const byVersion = new Map(manifests.map((manifest) => [`${manifest.nodeType}@${manifest.version}`, manifest]));
+		const palette = [];
+		for (const entry of entries) {
+			const manifest = byVersion.get(`${entry.nodeType}@${entry.nodeVersion}`);
+			if (manifest) palette.push(toNodeConfig(manifest, entry.publishType ?? void 0));
+		}
+		const listed = new Set(palette.map((config) => config.type));
+		const earlier = NODE_CONFIGS.filter((config) => !listed.has(config.type));
+		NODE_CONFIGS.length = 0;
+		NODE_CONFIGS.push(...palette, ...earlier);
 		await loadInstalledStoreNodes();
 	} catch (error) {
 		const message = error instanceof Error ? error.message : "Unknown error";
 		console.error("Failed to fetch nodes or manifests:", message);
 	}
 }
+/** Node types the registry never has: canvas-only annotations. */
+function isRegistryNodeType(type) {
+	return Boolean(type) && type !== "sticky-note" && type !== "default";
+}
+/** Node types being loaded for a canvas, so concurrent callers share one request. */
+const nodeTypeLoads = /* @__PURE__ */ new Map();
+async function loadNodeTypes(types) {
+	try {
+		const client = await waitForFluidGridsClient(15e3, 150);
+		if (client) {
+			const manifests = await loadNodeManifests(client, types.map((nodeType) => ({ nodeType })));
+			for (const manifest of manifests) addNodeConfig(toNodeConfig(manifest, manifest.publishType));
+		}
+		const missing = new Set(types.filter((type) => !hasNodeConfig(type)));
+		if (missing.size > 0) await loadInstalledStoreNodes(missing);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		console.error("[Workflows] Could not load node types:", message);
+	}
+	rebuildNodeArrays();
+}
+/**
+* Make sure the given node types are registered, without loading the rest of the
+* palette: what a canvas needs before it is drawn. Types already registered cost
+* nothing; the rest are fetched with one batched request, and a type the registry
+* does not carry is looked up among the workspace's installed store nodes. Types
+* that resolve nowhere stay unregistered (the canvas draws them with the fallback
+* card). Never rejects.
+*/
+function ensureNodeTypesLoaded(types) {
+	if (isInitialized) return Promise.resolve();
+	const wanted = [...new Set(types)].filter((type) => isRegistryNodeType(type) && !hasNodeConfig(type));
+	if (wanted.length === 0) return Promise.resolve();
+	const pending = /* @__PURE__ */ new Set();
+	const fresh = [];
+	for (const type of wanted) {
+		const inFlight = nodeTypeLoads.get(type);
+		if (inFlight) pending.add(inFlight);
+		else fresh.push(type);
+	}
+	if (fresh.length > 0) {
+		const load = loadNodeTypes(fresh).finally(() => {
+			for (const type of fresh) if (nodeTypeLoads.get(type) === load) nodeTypeLoads.delete(type);
+		});
+		for (const type of fresh) nodeTypeLoads.set(type, load);
+		pending.add(load);
+	}
+	return Promise.all(pending).then(() => void 0);
+}
 /**
-* Refetch all nodes by re-running initializeNodeConfigs.
-* Called after installing/uninstalling a store node.
+* Register manifests that arrived with a workflow (`WorkflowDefinition.nodeManifests`)
+* and keep them in the session cache, so the canvas needs no further request.
+*/
+function registerNodeManifests(values) {
+	let added = false;
+	for (const manifest of rememberNodeManifests(values)) if (addNodeConfig(toNodeConfig(manifest, manifest.publishType))) added = true;
+	if (added) rebuildNodeArrays();
+}
+/** Register the client-side node components every canvas needs. */
+function registerBaseNodeTypes() {
+	const fallback = getNodeMetadata({ type: "__default_dynamic__" });
+	if (fallback?.node) NODE_TYPES["default"] = fallback.node;
+	NODE_TYPES[STICKY_NOTE_TYPE] = StickyNoteNode;
+}
+/** Empty the registry, keeping only the client-side node components. */
+function resetNodeRegistry() {
+	NODE_CONFIGS.length = 0;
+	NODES.length = 0;
+	AVAILABLE_NODES.length = 0;
+	for (const key of Object.keys(NODE_TYPES)) delete NODE_TYPES[key];
+	for (const key of Object.keys(NODES_METADATA)) delete NODES_METADATA[key];
+	isInitialized = false;
+	initPromise = null;
+	nodeTypeLoads.clear();
+	registerBaseNodeTypes();
+}
+/**
+* Reload the registry from scratch, as the full palette. Called after installing or
+* uninstalling a store node, and when the hosts set the workspace's clients.
+* Manifests stay in the session cache (they are fixed per version), so only new
+* ones are fetched.
 *
-* Resets the initialization guard and all derived arrays so
-* initializeNodeConfigs() runs a fresh fetch instead of returning early.
+* While nothing is loaded or loading there is nothing stale to refresh, and it does
+* nothing: the registry loads on demand (BOFF-10387). Hosts call this when they
+* mount, which used to load the whole palette before the builder had asked for
+* anything.
 */
 async function refetchStoreNodes() {
+	if (NODE_CONFIGS.length === 0 && !initPromise && nodeTypeLoads.size === 0) return;
 	try {
-		NODE_CONFIGS.length = 0;
-		NODES.length = 0;
-		AVAILABLE_NODES.length = 0;
-		for (const key of Object.keys(NODE_TYPES)) delete NODE_TYPES[key];
-		for (const key of Object.keys(NODES_METADATA)) delete NODES_METADATA[key];
-		isInitialized = false;
-		initPromise = null;
-		const fallback = getNodeMetadata({ type: "__default_dynamic__" });
-		if (fallback?.node) NODE_TYPES["default"] = fallback.node;
-		NODE_TYPES[STICKY_NOTE_TYPE] = StickyNoteNode;
+		resetNodeRegistry();
 		await initializeNodeConfigs();
 		isInitialized = NODE_CONFIGS.length > 0;
 		rebuildNodeArrays();
@@ -10350,7 +10497,7 @@ function registryNodeData(type) {
 	return manifest ? manifest : void 0;
 }
 /**
-* Ensure node configs are loaded. Safe to call multiple times.
+* Ensure the full palette is loaded. Safe to call multiple times.
 * Returns immediately if already initialized or initializing.
 */
 function ensureNodeConfigsLoaded() {
@@ -10363,33 +10510,74 @@ function ensureNodeConfigsLoaded() {
 	return initPromise;
 }
 /**
-* Check if node configs have been initialized
+* Check if the full palette has been loaded
 */
 function isNodeConfigsInitialized() {
 	return isInitialized;
 }
 /**
-* Rebuild NODES and derived arrays after NODE_CONFIGS is populated.
-* This is called after lazy initialization completes.
+* How long an idle palette load may wait for the browser to go idle. A canvas
+* opens the palette's panels on demand anyway; this only bounds the wait when
+* the page never idles.
 */
-function rebuildNodeArrays() {
-	NODE_CONFIGS.forEach((config) => {
-		const nodeMetadata = {
-			...getNodeMetadata(config),
-			detail: { ...config.detail }
-		};
-		if (!NODES.some((n) => n.type === nodeMetadata.type)) {
-			NODES.push(nodeMetadata);
-			NODE_TYPES[nodeMetadata.type] = nodeMetadata.node;
-			NODES_METADATA[nodeMetadata.type] = {
-				...nodeMetadata,
-				__details: {
-					type: nodeMetadata.type,
-					...nodeMetadata.detail
-				}
-			};
+const NODE_PALETTE_IDLE_TIMEOUT_MS = 5e3;
+let paletteLoadScheduled = false;
+/**
+* Load the full palette once the page is idle (BOFF-10387): after a canvas is
+* drawn, so the palette is ready when the person opens it without delaying the
+* canvas. Does nothing when it is loaded, loading or already scheduled.
+*/
+function scheduleNodePaletteLoad() {
+	if (isInitialized || initPromise || paletteLoadScheduled) return;
+	paletteLoadScheduled = true;
+	const load = () => {
+		paletteLoadScheduled = false;
+		ensureNodeConfigsLoaded().catch((error) => {
+			console.warn("[Workflows] Idle node palette load failed:", error);
+		});
+	};
+	if (typeof window !== "undefined" && "requestIdleCallback" in window) window.requestIdleCallback(load, { timeout: NODE_PALETTE_IDLE_TIMEOUT_MS });
+	else setTimeout(load, 1e3);
+}
+/** The registry entry of each config's node type, created on first sight. */
+function nodeMetadataFor(config) {
+	const nodeMetadata = {
+		...getNodeMetadata(config),
+		detail: { ...config.detail }
+	};
+	NODE_TYPES[nodeMetadata.type] = nodeMetadata.node;
+	NODES_METADATA[nodeMetadata.type] = {
+		...nodeMetadata,
+		__details: {
+			type: nodeMetadata.type,
+			...nodeMetadata.detail
 		}
-	});
+	};
+	return nodeMetadata;
+}
+/**
+* Rebuild NODES and derived arrays from NODE_CONFIGS, in its order.
+*
+* A node type keeps the entry (and the React component) it was first registered
+* with: replacing the component would remount every node of that type already on
+* the canvas. Called whenever the registry grows: the canvas's node types first,
+* the full palette later.
+*/
+function rebuildNodeArrays() {
+	const existing = new Map(NODES.map((node) => [node.type, node]));
+	const ordered = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const config of NODE_CONFIGS) {
+		if (seen.has(config.type)) continue;
+		seen.add(config.type);
+		ordered.push(existing.get(config.type) ?? nodeMetadataFor(config));
+	}
+	for (const node of NODES) if (!seen.has(node.type)) {
+		seen.add(node.type);
+		ordered.push(node);
+	}
+	NODES.length = 0;
+	NODES.push(...ordered);
 	const newAvailableNodes = NODES.filter((node) => node.available === void 0 || node.available).map((node) => {
 		const nodeConfig = NODE_CONFIGS.find((config) => config.type === node.type);
 		return {
@@ -10406,18 +10594,17 @@ function rebuildNodeArrays() {
 	AVAILABLE_NODES.push(...newAvailableNodes);
 	notifyNodeTypesListeners();
 }
-ensureNodeConfigsLoaded().catch((err) => {
-	console.warn("[Workflows] Background node config initialization failed:", err);
-});
-const fallbackDynamic = getNodeMetadata({ type: "__default_dynamic__" });
-if (fallbackDynamic?.node) NODE_TYPES["default"] = fallbackDynamic.node;
-NODE_TYPES[STICKY_NOTE_TYPE] = StickyNoteNode;
+registerBaseNodeTypes();
 /**
 * Pre-register node types from the workflow definition so React Flow never sees unknown types.
-* Called by FlowBuilderPage before hydrating the store.
+* Called by FlowBuilderPage before hydrating the store, and for nodes an assistant
+* adds to an open canvas. Unknown types get a fallback card at once; their real
+* registry entries load in the background and replace it (BOFF-10387).
 */
 function registerWorkflowNodeTypes(workflowNodes) {
+	const unknownTypes = [];
 	for (const node of workflowNodes) if (node.type && !NODE_TYPES[node.type]) {
+		unknownTypes.push(node.type);
 		const meta = getNodeMetadata({
 			type: node.type,
 			defaultData: {
@@ -10428,6 +10615,7 @@ function registerWorkflowNodeTypes(workflowNodes) {
 		});
 		if (meta?.node) NODE_TYPES[node.type] = meta.node;
 	}
+	ensureNodeTypesLoaded(unknownTypes);
 }
 
 // src/components/FluidGridsProvider.tsx
@@ -10628,4 +10816,4 @@ function useFluidGridsContext() {
 	return context;
 }
 
-export { casesFromRules as $, newConnectionProviderKey as $n, runDurationMs as $t, buildOperationSeed as A, declaredSignals as An, leaseCallSequence as At, nodeTitle as B, resolvePhaseCFlags as Bn, rememberOwnStatusChange as Bt, MyWorkflowTemplateSubmissionsDocument as C, findQuotaRefusal as Cn, saveIndicatorOf as Ct, UninstallWorkflowNodeDocument as D, loadDefinitionJson as Dn, bannerOf as Dt, UninstallOrganizationPrivateNodeDocument as E, clearCodeWorkflowDefinitionCache as En, useEditLeaseStore as Et, workflowParameterIssues as F, signalPayloadCard as Fn, tickAction as Ft, resolveUiSpec as G, useFluidGridsFlagsSettled as Gn, codeBuildIdOf as Gt, paramsFromOperation as H, useDurableFunctionNodesEnabled as Hn, AUTOSAVE_DEBOUNCE_MS as Ht, asRecord as I, FLUIDGRIDS_FLAGS as In, EDIT_SESSION_ID as It, optionListText as J, useSelfHostedWorkersEnabled as Jn, saveFailureActionOf as Jt, stripSubmitActions as K, usePaletteGates as Kn, findSaveConflict as Kt, coerceNumber as L, FLUIDGRIDS_FLAG_DEFAULTS as Ln, forgetSessionForReload as Lt, useInsertNode as M, parseRawSignalPayload as Mn, phaseAfterTakeOver as Mt, MissingParametersDialog as N, payloadFromCardValues as Nn, releasesOnClose as Nt, WithdrawWorkflowTemplateSubmissionDocument as O, useCodeWorkflowInterface as On, isLocked as Ot, useRunGuard as P, runSignalTargets as Pn, shouldReleaseForIdle as Pt, SwitchRulesEditor as Q, matchesAdapterProvider as Qn, nodeStateDurationMs as Qt, fixedParameterState as R, PHASE_C_FLAGS_OFF as Rn, rememberSessionForReload as Rt, InstallWorkflowNodeDocument as S, collectExtensions as Sn, refusalOfQuota as St, SubmitWorkflowTemplateDocument as T, useCanvasEdges as Tn, useEditLeaseLocked as Tt, selectedOperationOf as U, useDurableParityEnabled as Un, AUTOSAVE_RETRY_DELAYS_MS as Ut, optionText as V, useContinuousOptimisationEnabled as Vn, rememberRevision as Vt, useNodeConfig as W, useFluidGridsFlag as Wn, canAutosave as Wt, resolveLoadOptionsSpec as X, connectionsForAdapter as Xn, useNodeExecution as Xt, optionListValues as Y, useWorkflowTestsEnabled as Yn, workflowFingerprint as Yt, ConditionTreeBuilder as Z, isOptionalAdapter as Zn, formatElapsedMs as Zt, CreateStoreOrderDocument as _, nodesOf as _n, useSaveWorkflow as _t, NODES_METADATA as a, isParamVisible as an, createGlobalStoreClient as ar, useGuardedNavigate as at, InstallOrganizationPrivateNodeDocument as b, RUNS_QUOTA_NAME as bn, classifyCreateRefusal as bt, ensureNodeConfigsLoaded as c, emitNodeInstalled as cn, resetGlobalStoreClient as cr, departingSave as ct, refetchStoreNodes as d, emitRunStarted as dn, leavingLosesChanges as dt, formatParameterValue as en, replaceAdapterConnections as er, FieldTree as et, registerWorkflowNodeTypes as f, emitTemplateUsed as fn, savedEverythingBeforeLeaving as ft, BrowseWorkflowTemplatesDocument as g, emitWorkflowPublished as gn, useFlowValidator as gt, BrowseWorkflowNodesDocument as h, emitWorkflowLimitHit as hn, isFlowComplete as ht, AVAILABLE_NODES as i, resolveNodeOperation as in, useBuilderReadOnly as ir, missingRequiredParameters as it, createConfiguredNode as j, durableInterfaceOf as jn, phaseAfterAcquire as jt, getNodeMetadata as k, canSignalRun as kn, leaseCallQueue as kt, isNodeConfigsInitialized as l, emitRunFailed as ln, setGlobalStoreClient as lr, editStateFor as lt, global_operations_exports as m, emitWorkflowCreated as mn, watchLeavingLosesChanges as mt, FluidGridsProvider as n, structuredParameterType as nn, buildStickyNode as nr, latestNodeLog as nt, NODE_CONFIGS as o, useFluidGridsAnalytics as on, getGlobalStoreClient as or, useManualSave as ot, registryNodeData as p, emitUpgradeClicked as pn, touchesSavedFields as pt, isStringOptionList as q, usePhaseCFlags as qn, inAppLeaveTarget as qt, useFluidGridsContext as r, fieldsFromValue as rn, BuilderReadOnlyProvider as rr, boundFieldsOf as rt, NODE_TYPES as s, openRunQuotaUpgradePrompt as sn, global_client_exports as sr, autosaveAllowedFor as st, FluidGridsContext as t, parseParameterValue as tn, getNodeDetail as tr, parseMappingValue as tt, onNodeTypesUpdate as u, emitRunLimitHit as un, editingLeaseLocked as ut, GetMyNodeInstallationsDocument as v, runTriggerFromMode as vn, blankWorkflowCreateInput as vt, OrganizationPrivateNodesDocument as w, isQuotaExhaustedFailure as wn, useSaveStatusStore as wt, InstallPurchasedNodeDocument as x, WORKFLOWS_QUOTA_NAME as xn, createThenOpen as xt, GetNodeInstallableVersionsDocument as y, BILLING_PLANS_PATH as yn, builderPathOf as yt, nodeSubtitle as z, resolveFluidGridsFlagsSettled as zn, sessionBeforeReload as zt };
+export { resolveLoadOptionsSpec as $, useWorkflowTestsEnabled as $n, useNodeExecution as $t, UninstallWorkflowNodeDocument as A, clearCodeWorkflowDefinitionCache as An, bannerOf as At, coerceNumber as B, FLUIDGRIDS_FLAGS as Bn, forgetSessionForReload as Bt, InstallOrganizationPrivateNodeDocument as C, RUNS_QUOTA_NAME as Cn, classifyCreateRefusal as Ct, OrganizationPrivateNodesDocument as D, isQuotaExhaustedFailure as Dn, useSaveStatusStore as Dt, MyWorkflowTemplateSubmissionsDocument as E, findQuotaRefusal as En, saveIndicatorOf as Et, useInsertNode as F, durableInterfaceOf as Fn, phaseAfterTakeOver as Ft, paramsFromOperation as G, useContinuousOptimisationEnabled as Gn, AUTOSAVE_DEBOUNCE_MS as Gt, nodeSubtitle as H, PHASE_C_FLAGS_OFF as Hn, sessionBeforeReload as Ht, MissingParametersDialog as I, parseRawSignalPayload as In, releasesOnClose as It, resolveUiSpec as J, useFluidGridsFlag as Jn, codeBuildIdOf as Jt, selectedOperationOf as K, useDurableFunctionNodesEnabled as Kn, AUTOSAVE_RETRY_DELAYS_MS as Kt, useRunGuard as L, payloadFromCardValues as Ln, shouldReleaseForIdle as Lt, getNodeMetadata as M, useCodeWorkflowInterface as Mn, leaseCallQueue as Mt, buildOperationSeed as N, canSignalRun as Nn, leaseCallSequence as Nt, SubmitWorkflowTemplateDocument as O, useCanvasEdges as On, useEditLeaseLocked as Ot, createConfiguredNode as P, declaredSignals as Pn, phaseAfterAcquire as Pt, optionListValues as Q, useSelfHostedWorkersEnabled as Qn, workflowFingerprint as Qt, workflowParameterIssues as R, runSignalTargets as Rn, tickAction as Rt, GetNodeInstallableVersionsDocument as S, BILLING_PLANS_PATH as Sn, builderPathOf as St, InstallWorkflowNodeDocument as T, collectExtensions as Tn, refusalOfQuota as Tt, nodeTitle as U, resolveFluidGridsFlagsSettled as Un, rememberOwnStatusChange as Ut, fixedParameterState as V, FLUIDGRIDS_FLAG_DEFAULTS as Vn, rememberSessionForReload as Vt, optionText as W, resolvePhaseCFlags as Wn, rememberRevision as Wt, isStringOptionList as X, usePaletteGates as Xn, inAppLeaveTarget as Xt, stripSubmitActions as Y, useFluidGridsFlagsSettled as Yn, findSaveConflict as Yt, optionListText as Z, usePhaseCFlags as Zn, saveFailureActionOf as Zt, global_operations_exports as _, emitWorkflowCreated as _n, watchLeavingLosesChanges as _t, NODES_METADATA as a, structuredParameterType as an, getNodeDetail as ar, latestNodeLog as at, CreateStoreOrderDocument as b, nodesOf as bn, useSaveWorkflow as bt, ensureNodeConfigsLoaded as c, isParamVisible as cn, useBuilderReadOnly as cr, useGuardedNavigate as ct, onNodeTypesUpdate as d, emitNodeInstalled as dn, global_client_exports as dr, departingSave as dt, formatElapsedMs as en, connectionsForAdapter as er, ConditionTreeBuilder as et, refetchStoreNodes as f, emitRunFailed as fn, resetGlobalStoreClient as fr, editStateFor as ft, scheduleNodePaletteLoad as g, emitUpgradeClicked as gn, touchesSavedFields as gt, registryNodeData as h, emitTemplateUsed as hn, savedEverythingBeforeLeaving as ht, AVAILABLE_NODES as i, parseParameterValue as in, replaceAdapterConnections as ir, parseMappingValue as it, WithdrawWorkflowTemplateSubmissionDocument as j, loadDefinitionJson as jn, isLocked as jt, UninstallOrganizationPrivateNodeDocument as k, useNodeRegistryRevision as kn, useEditLeaseStore as kt, ensureNodeTypesLoaded as l, useFluidGridsAnalytics as ln, createGlobalStoreClient as lr, useManualSave as lt, registerWorkflowNodeTypes as m, emitRunStarted as mn, leavingLosesChanges as mt, FluidGridsProvider as n, runDurationMs as nn, matchesAdapterProvider as nr, casesFromRules as nt, NODE_CONFIGS as o, fieldsFromValue as on, buildStickyNode as or, boundFieldsOf as ot, registerNodeManifests as p, emitRunLimitHit as pn, setGlobalStoreClient as pr, editingLeaseLocked as pt, useNodeConfig as q, useDurableParityEnabled as qn, canAutosave as qt, useFluidGridsContext as r, formatParameterValue as rn, newConnectionProviderKey as rr, FieldTree as rt, NODE_TYPES as s, resolveNodeOperation as sn, BuilderReadOnlyProvider as sr, missingRequiredParameters as st, FluidGridsContext as t, nodeStateDurationMs as tn, isOptionalAdapter as tr, SwitchRulesEditor as tt, isNodeConfigsInitialized as u, openRunQuotaUpgradePrompt as un, getGlobalStoreClient as ur, autosaveAllowedFor as ut, BrowseWorkflowNodesDocument as v, emitWorkflowLimitHit as vn, isFlowComplete as vt, InstallPurchasedNodeDocument as w, WORKFLOWS_QUOTA_NAME as wn, createThenOpen as wt, GetMyNodeInstallationsDocument as x, runTriggerFromMode as xn, blankWorkflowCreateInput as xt, BrowseWorkflowTemplatesDocument as y, emitWorkflowPublished as yn, useFlowValidator as yt, asRecord as z, signalPayloadCard as zn, EDIT_SESSION_ID as zt };