@burdenoff/fluidgrids-fe-sdk 2026.1114.7 → 2026.1115.2

package/dist/{FluidGridsProvider-C-WGQwuT.js → FluidGridsProvider-CDjkq3Zj.js}

@@ -15,6 +15,7 @@ import { a as collectExtensions, n as QUOTA_EXHAUSTED_CODE, o as errorCodesOf, r
 import { c as setFluidGridsConfig, l as validateTrustedOrigin, o as resetFluidGridsConfig, r as getFluidGridsConfig, s as resetFluidGridsExecutionState } from "./config-X97zrIvn.js";
 import { a as useFgAskableAction } from "./askAboutBridge-ByYsQams.js";
 import { i as readableNodeType } from "./run-display-UjLAoYqQ.js";
+import { Fw as NodeManifestDetail } from "./graphql-types-dS3Fk9Z5.js";
 import { t as provideNodeRegistryRefresh } from "./node-registry-refresh-s3okf83X.js";
 import { createContext, memo, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { useNavigate, useParams } from "react-router";
@@ -3559,6 +3560,23 @@ const NodeManifestsDocument = {
 				}
 			},
 			"directives": []
+		}, {
+			"kind": "VariableDefinition",
+			"variable": {
+				"kind": "Variable",
+				"name": {
+					"kind": "Name",
+					"value": "detail"
+				}
+			},
+			"type": {
+				"kind": "NamedType",
+				"name": {
+					"kind": "Name",
+					"value": "NodeManifestDetail"
+				}
+			},
+			"directives": []
 		}],
 		"directives": [],
 		"selectionSet": {
@@ -3582,6 +3600,19 @@ const NodeManifestsDocument = {
 							"value": "refs"
 						}
 					}
+				}, {
+					"kind": "Argument",
+					"name": {
+						"kind": "Name",
+						"value": "detail"
+					},
+					"value": {
+						"kind": "Variable",
+						"name": {
+							"kind": "Name",
+							"value": "detail"
+						}
+					}
 				}],
 				"directives": []
 			}]
@@ -5383,7 +5414,9 @@ function useNodeExecution() {
 		}
 		setNodeStatus(nodeId, "running");
 		try {
-			normalizeWorkflowParameters(workflow.nodes.filter((node) => node.id === nodeId), workflow.edges, (type) => NODE_CONFIGS.find((config) => config.type === type)?.operations);
+			const stepNodes = workflow.nodes.filter((node) => node.id === nodeId);
+			await loadFullManifestsOfSummaries(stepNodes.map((node) => node.type));
+			normalizeWorkflowParameters(stepNodes, workflow.edges, (type) => NODE_CONFIGS.find((config) => config.type === type)?.operations);
 			const client = getFluidGridsClient();
 			const stepResult = throwIfResultError(await client.mutate({
 				mutation: EXECUTE_STEP,
@@ -5498,7 +5531,9 @@ function useNodeExecution() {
 		}
 		setNodeStatus(triggerNode.id, "running");
 		try {
-			normalizeWorkflowParameters(workflow.nodes.filter((node) => node.data.disabled !== true), workflow.edges, (type) => NODE_CONFIGS.find((config) => config.type === type)?.operations);
+			const runNodes = workflow.nodes.filter((node) => node.data.disabled !== true);
+			await loadFullManifestsOfSummaries(runNodes.map((node) => node.type));
+			normalizeWorkflowParameters(runNodes, workflow.edges, (type) => NODE_CONFIGS.find((config) => config.type === type)?.operations);
 			const client = getFluidGridsClient();
 			const triggerResult = throwIfResultError(await client.mutate({
 				mutation: TRIGGER_WORKFLOW,
@@ -6827,6 +6862,7 @@ function useSaveWorkflow() {
 			const inPlace = !forkRequested && savesInPlace(workflow);
 			const expectedRevision = revisionOf(workflow.dbId);
 			const client = getFluidGridsClient();
+			await loadFullManifestsOfSummaries((workflow.nodes ?? []).map((node) => node.type));
 			const { preparedWorkflow, owned } = builderDefinition(snapshot, workflowKey, !!mintedKey);
 			const definitionJson = workflow.dbId && !inPlace ? mergeDefinitionJson(await readStoredDefinition(client, workflow.dbId), owned) : owned;
 			let savedVersion = workflow.version;
@@ -8670,7 +8706,8 @@ function asRecord(value) {
 }
 function fallbackOperations(type) {
 	if (!type) return void 0;
-	return NODE_CONFIGS.find((c) => c.type === type)?.operations;
+	const config = NODE_CONFIGS.find((c) => c.type === type);
+	return config?.manifestDetail === "SUMMARY" ? void 0 : config?.operations;
 }
 function selectedOperationOf(data, type) {
 	const live = liveInternalOperations(type);
@@ -8813,6 +8850,11 @@ function useNodeConfig(target, options) {
 	}, [nodeId, selectedSource]);
 	const sourceNode = useMemo(() => nodes.find((n) => n.id === selectedSource), [nodes, selectedSource]);
 	const currentEdge = useMemo(() => incoming.find((e) => e.source === selectedSource), [incoming, selectedSource]);
+	const nodeType = node?.type;
+	const sourceType = sourceNode?.type;
+	useEffect(() => {
+		loadFullManifestsOfSummaries([nodeType, sourceType]);
+	}, [nodeType, sourceType]);
 	const registryRevision = useNodeRegistryRevision();
 	const currentOp = useMemo(() => {
 		return selectedOperationOf(asRecord(node?.data), node?.type);
@@ -9349,7 +9391,9 @@ function pickOperationToPin(type, operationName) {
 /**
 * A new canvas node of `type` at `position`, pinned to its operation the way
 * the Node Store pins it. Pure: no React Flow instance needed, so the builder's
-* agent tools create nodes exactly as a person's click does.
+* agent tools create nodes exactly as a person's click does. The node type's
+* full manifest must be registered (`ensureNodeTypeReady`): a palette summary
+* lacks the operation's form and defaults.
 */
 function createConfiguredNode(type, position, operationName) {
 	const newNode = createNodeWithDefaultData(type, {
@@ -9363,13 +9407,25 @@ function createConfiguredNode(type, position, operationName) {
 	}
 	return newNode;
 }
+/**
+* Place a node of `type` on the canvas, selected, at `pos` (the viewport centre
+* when left out). The palette lists summaries, so the node type's full manifest
+* is loaded first (BOFF-13066); a type already used in this session is placed at
+* once. Resolves to the new node, or null when its manifest could not be loaded
+* (the person is told, and nothing is placed).
+*/
 function useInsertNode() {
 	const { addNodes, screenToFlowPosition, getNodes, updateNode } = useReactFlow();
-	return useCallback((type, pos, operationName) => {
+	const tr = useTr();
+	return useCallback(async (type, pos, operationName) => {
 		const _pos = pos || screenToFlowPosition({
 			x: window.innerWidth / 2,
 			y: window.innerHeight / 2
 		});
+		if (!await ensureNodeTypeReady(type)) {
+			toast.error(tr("fluidgrids.builder.insertNode.loadFailed", "Could not load this node. Check your connection and try again."));
+			return null;
+		}
 		getNodes().forEach((node) => {
 			if (node.selected) updateNode(node.id, { selected: false });
 		});
@@ -9380,7 +9436,8 @@ function useInsertNode() {
 		screenToFlowPosition,
 		getNodes,
 		addNodes,
-		updateNode
+		updateNode,
+		tr
 	]);
 }
 
@@ -9831,7 +9888,7 @@ function AdapterPort({ nodeId, adapter, index, total }) {
 	const diamondColor = hasConnection ? "bg-[var(--color-accent-primary)]" : "bg-[var(--color-text-muted)]";
 	const lineColor = hasConnection ? "before:bg-[var(--color-accent-primary)]" : "before:bg-[var(--color-border-strong)]";
 	/** Create the chosen sub-node below the parent and attach it to this port. */
-	const addSubNode = useCallback((candidate) => {
+	const addSubNode = useCallback(async (candidate) => {
 		setPickerOpen(false);
 		const parent = getNode(nodeId);
 		const origin = parent?.position ?? {
@@ -9843,7 +9900,7 @@ function AdapterPort({ nodeId, adapter, index, total }) {
 			x: origin.x + (index - (total - 1) / 2) * 180,
 			y: origin.y + parentHeight + 190
 		};
-		const created = insertNode(candidate.type, position, candidate.adapterOperation);
+		const created = await insertNode(candidate.type, position, candidate.adapterOperation);
 		if (!created?.id) return;
 		created.data = {
 			...created.data,
@@ -10201,7 +10258,7 @@ const getNodeMetadata = (value) => {
 		}, [executeStep, id]);
 		const stepGuard = useRunGuard(handleExecuteStep, { nodeId: id });
 		const missingCredentials = useMemo(() => {
-			const visibleAdapters = getVisibleConnectionAdapters(String(value?.type ?? ""), data?.operation_name, value?.operations ?? (data?.nodeData)?.operations, data?.nodeData);
+			const visibleAdapters = getVisibleConnectionAdapters(String(value?.type ?? ""), data?.operation_name, (value?.manifestDetail === "SUMMARY" ? void 0 : value?.operations) ?? (data?.nodeData)?.operations, data?.nodeData);
 			if (visibleAdapters.length === 0) return false;
 			const selected = (data?.args)?.connections ?? (data?.args)?.credentials ?? [];
 			return missingRequiredAdapters(visibleAdapters, selected).length > 0;
@@ -10761,12 +10818,19 @@ const GetMyNodeInstallationsDocument = {
 
 // 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.
+* Full manifests per request. The server takes up to 500; smaller requests keep
+* each response smaller (a store manifest reaches 620 KB) and let the gateway
+* resolve them side by side. The builder asks for full manifests only for the
+* node types it uses, rarely more than a few dozen.
 */
 const NODE_MANIFEST_BATCH_SIZE = 100;
+/**
+* Summaries per request: the server's limit. The whole prod palette (about 370
+* nodes) is one request of well under a megabyte.
+*/
+const NODE_MANIFEST_SUMMARY_BATCH_SIZE = 500;
 const manifestCache = /* @__PURE__ */ new Map();
+const summaryCache = /* @__PURE__ */ new Map();
 function manifestKey(nodeType, version) {
 	return `${nodeType}@${version}`;
 }
@@ -10791,18 +10855,42 @@ function rememberNodeManifests(values) {
 	}
 	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));
+/**
+* Whether `manifest` is a full manifest this session loaded: the one the session
+* cache holds for its version. A summary never is.
+*/
+function isFullNodeManifest(manifest) {
+	return manifestCache.get(manifestKey(manifest.nodeType, manifest.version)) === manifest;
+}
+/** Keep summaries for the session, apart from the full manifests. */
+function rememberNodeManifestSummaries(values) {
+	const summaries = [];
+	for (const value of values) {
+		const summary = asNodeManifest(value);
+		if (!summary) continue;
+		const key = manifestKey(summary.nodeType, summary.version);
+		const known = manifestCache.get(key);
+		if (known) {
+			summaries.push(known);
+			continue;
+		}
+		summaryCache.set(key, summary);
+		summaries.push(summary);
+	}
+	return summaries;
 }
 /**
-* 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.
+* Manifests for `refs` at the given detail (full by default): exact versions
+* already in the session cache are served from it; the rest are fetched with
+* `nodeManifests`, all requests in parallel, at most `NODE_MANIFEST_BATCH_SIZE`
+* refs per request for full manifests and `NODE_MANIFEST_SUMMARY_BATCH_SIZE` for
+* summaries. A full manifest in the cache also answers a request for a summary.
+* 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.
 */
-async function loadNodeManifests(client, refs) {
+async function loadNodeManifests(client, refs, detail = "FULL") {
+	const summary = detail === "SUMMARY";
 	const result = [];
 	const missing = [];
 	const seen = /* @__PURE__ */ new Set();
@@ -10810,20 +10898,25 @@ async function loadNodeManifests(client, 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;
+		const cached = ref.version ? manifestCache.get(key) ?? (summary ? summaryCache.get(key) : void 0) : void 0;
 		if (cached) result.push(cached);
 		else missing.push(ref.version ? ref : { nodeType: ref.nodeType });
 	}
+	const batchSize = summary ? 500 : 100;
 	const batches = [];
-	for (let i = 0; i < missing.length; i += 100) batches.push(missing.slice(i, i + 100));
+	for (let i = 0; i < missing.length; i += batchSize) batches.push(missing.slice(i, i + batchSize));
 	const fetched = await Promise.all(batches.map(async (batch) => {
 		try {
 			const { data } = await client.query({
 				query: NodeManifestsDocument,
-				variables: { refs: batch },
+				variables: summary ? {
+					refs: batch,
+					detail: "SUMMARY"
+				} : { refs: batch },
 				fetchPolicy: "no-cache"
 			});
-			return rememberNodeManifests(data?.nodeManifests ?? []);
+			const manifests = data?.nodeManifests ?? [];
+			return summary ? rememberNodeManifestSummaries(manifests) : rememberNodeManifests(manifests);
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			console.error(`[Workflows] Could not load ${batch.length} node manifest(s):`, message);
@@ -10837,7 +10930,7 @@ async function loadNodeManifests(client, refs) {
 // src/builder/components/flow-builder/components/blocks/index.ts
 const NODE_CONFIGS = [];
 /** The registry entry for one manifest. */
-function toNodeConfig(manifest, publishType) {
+function toNodeConfig(manifest, publishType, manifestDetail = "FULL") {
 	const manifestOps = manifest.operations;
 	const operations = Array.isArray(manifestOps) ? manifestOps : manifestOps?.operations ?? manifestOps;
 	return {
@@ -10864,12 +10957,68 @@ function toNodeConfig(manifest, publishType) {
 			}
 		},
 		operations,
-		publishType
+		publishType,
+		manifestDetail
 	};
 }
+/** The registry entry of a node type: the first one, as every reader takes it. */
+function nodeConfigOf(type) {
+	return type ? NODE_CONFIGS.find((config) => config.type === type) : void 0;
+}
 function hasNodeConfig(type) {
 	return NODE_CONFIGS.some((config) => config.type === type);
 }
+/**
+* Whether the node type's registry entry carries its full manifest. False for a
+* palette summary and for a type the registry does not hold.
+*/
+function hasFullNodeConfig(type) {
+	const config = nodeConfigOf(type);
+	return config !== void 0 && config.manifestDetail !== "SUMMARY";
+}
+/** The node types whose registry entry carries its full manifest. */
+function fullNodeConfigTypes() {
+	const types = /* @__PURE__ */ new Set();
+	for (const config of NODE_CONFIGS) if (config.manifestDetail !== "SUMMARY") types.add(config.type);
+	return types;
+}
+/**
+* Turn a summary entry into the full one, in place: node components already
+* created for it read the same object. The node type's registry metadata
+* (`NODES`, `NODES_METADATA`), which new canvas nodes copy their data from,
+* takes the full manifest too.
+*/
+function upgradeNodeConfig(config, manifest) {
+	Object.assign(config, toNodeConfig(manifest, config.publishType ?? manifest.publishType));
+	const entry = NODES.find((node) => node.type === config.type);
+	if (entry) {
+		entry.defaultData = {
+			...entry.defaultData,
+			version: config.defaultData.version,
+			nodeData: config.defaultData.nodeData
+		};
+		const metadata = NODES_METADATA[config.type];
+		if (metadata) metadata.defaultData = entry.defaultData;
+	}
+}
+/**
+* Register a full manifest: a new entry when its node type has none, or the full
+* form of the type's summary entry of the same version. An entry that is already
+* full, or a summary of another version, is left as it is. True when the
+* registry changed.
+*/
+function registerFullManifest(manifest) {
+	const config = nodeConfigOf(manifest.nodeType);
+	if (!config) {
+		NODE_CONFIGS.push(toNodeConfig(manifest, manifest.publishType));
+		return true;
+	}
+	if (config.manifestDetail === "SUMMARY" && config.defaultData.version === manifest.version) {
+		upgradeNodeConfig(config, manifest);
+		return true;
+	}
+	return false;
+}
 /** Add a config unless its node type is already registered. */
 function addNodeConfig(config) {
 	if (hasNodeConfig(config.type)) return false;
@@ -10935,8 +11084,13 @@ async function loadInstalledStoreNodes(onlyTypes) {
 /**
 * Load the full palette into NODE_CONFIGS: every available registry node in the
 * registry's order (newest first), then the installed store nodes.
+*
+* Palette entries are summaries, except where this session holds the full
+* manifest of the entry's version. Node types whose entry was full before the
+* load (the canvas's), and those in `keepFull`, keep a full entry: their full
+* manifests are loaded before the palette replaces the registry.
 */
-async function initializeNodeConfigs() {
+async function initializeNodeConfigs(keepFull = /* @__PURE__ */ new Set()) {
 	try {
 		const client = await waitForFluidGridsClient(15e3, 150);
 		if (!client) {
@@ -10953,12 +11107,22 @@ async function initializeNodeConfigs() {
 		const manifests = await loadNodeManifests(client, entries.map((entry) => ({
 			nodeType: entry.nodeType,
 			version: entry.nodeVersion
-		})));
+		})), "SUMMARY");
 		const byVersion = new Map(manifests.map((manifest) => [`${manifest.nodeType}@${manifest.version}`, manifest]));
+		const full = /* @__PURE__ */ new Set([...keepFull, ...fullNodeConfigTypes()]);
+		const fullRefs = [];
+		for (const entry of entries) {
+			const manifest = byVersion.get(`${entry.nodeType}@${entry.nodeVersion}`);
+			if (manifest && full.has(entry.nodeType) && !isFullNodeManifest(manifest)) fullRefs.push({
+				nodeType: entry.nodeType,
+				version: entry.nodeVersion
+			});
+		}
+		if (fullRefs.length > 0) for (const manifest of await loadNodeManifests(client, fullRefs)) byVersion.set(`${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));
+			if (manifest) palette.push(toNodeConfig(manifest, entry.publishType ?? void 0, isFullNodeManifest(manifest) ? "FULL" : "SUMMARY"));
 		}
 		const listed = new Set(palette.map((config) => config.type));
 		const earlier = NODE_CONFIGS.filter((config) => !listed.has(config.type));
@@ -10988,12 +11152,30 @@ function unregisteredTypes(types) {
 	if (isInitialized) return [];
 	return [...new Set(types)].filter((type) => isRegistryNodeType(type) && !hasNodeConfig(type));
 }
+/**
+* The distinct registry node types of `types` whose full manifest the registry
+* should load: those without an entry (until the full palette is in, after which
+* a type it lacks is not available anywhere) and those with a palette summary.
+*/
+function typesNeedingFullManifest(types) {
+	return [...new Set(types)].filter((type) => {
+		if (!isRegistryNodeType(type)) return false;
+		const config = nodeConfigOf(type);
+		return config ? config.manifestDetail === "SUMMARY" : !isInitialized;
+	});
+}
 async function loadRegistryNodeTypes(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 manifests = await loadNodeManifests(client, types.map((nodeType) => {
+				const version = nodeConfigOf(nodeType)?.defaultData.version;
+				return version ? {
+					nodeType,
+					version
+				} : { nodeType };
+			}));
+			for (const manifest of manifests) registerFullManifest(manifest);
 		}
 	} catch (error) {
 		const message = error instanceof Error ? error.message : "Unknown error";
@@ -11002,12 +11184,13 @@ async function loadRegistryNodeTypes(types) {
 	rebuildNodeArrays();
 }
 /**
-* Register the given node types from the node registry: one batched
-* `nodeManifests` request for the ones not registered yet. Types the registry is
-* known to lack (see `registerNodeManifests`) are not asked about. Never rejects.
+* Register the given node types from the node registry, with their full
+* manifests: one batched `nodeManifests` request for the ones not registered
+* yet or registered as a palette summary. Types the registry is known to lack
+* (see `registerNodeManifests`) are not asked about. Never rejects.
 */
 function ensureRegistryNodeTypesLoaded(types) {
-	const wanted = unregisteredTypes(types).filter((type) => !registryLacks.has(type));
+	const wanted = typesNeedingFullManifest(types).filter((type) => !registryLacks.has(type));
 	if (wanted.length === 0) return Promise.resolve();
 	const pending = /* @__PURE__ */ new Set();
 	const fresh = [];
@@ -11042,12 +11225,13 @@ async function ensureInstalledNodeTypesLoaded(types) {
 	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.
+* Make sure the given node types are registered with their full manifests,
+* without loading the rest of the palette: what a canvas needs before it is
+* drawn, saved or run. Types already registered in full cost nothing; the rest
+* (unregistered, or a palette summary) 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.
 */
 async function ensureNodeTypesLoaded(types) {
 	const wanted = [...types];
@@ -11055,6 +11239,37 @@ async function ensureNodeTypesLoaded(types) {
 	await ensureInstalledNodeTypesLoaded(wanted);
 }
 /**
+* Load a node type's full manifest before a node of it is placed (BOFF-13066):
+* the palette holds only summaries. Resolves true when the node can be placed:
+* its registry entry is full, or the registry holds no entry for it (a
+* client-side node type, placed from its own defaults as before). False when
+* only the summary is available, because the full manifest could not be loaded.
+*/
+async function ensureNodeTypeReady(type) {
+	await ensureNodeTypesLoaded([type]);
+	return nodeConfigOf(type)?.manifestDetail !== "SUMMARY";
+}
+/**
+* Load the full manifests of the given node types that the registry holds only
+* as palette summaries (BOFF-13066); every other type is left as it is, so this
+* costs nothing where a canvas's node types are loaded. What the builder's save
+* and run paths and the node panel call before they read a node's operation
+* fields. Never rejects.
+*/
+function loadFullManifestsOfSummaries(types) {
+	const summaries = [...types].filter((type) => nodeConfigOf(type ?? void 0)?.manifestDetail === "SUMMARY");
+	return summaries.length > 0 ? ensureRegistryNodeTypesLoaded(summaries) : Promise.resolve();
+}
+/**
+* Start loading a node type's full manifest ahead of use (a drag that has just
+* started, a Node Store detail that has just opened), so placing it does not
+* wait. Never rejects.
+*/
+function prefetchNodeType(type) {
+	if (!type || hasFullNodeConfig(type)) return;
+	ensureNodeTypesLoaded([type]);
+}
+/**
 * Register manifests that arrived with a workflow (`WorkflowDefinition.nodeManifests`)
 * and keep them in the session cache, so the canvas needs no further request.
 *
@@ -11064,7 +11279,7 @@ async function ensureNodeTypesLoaded(types) {
 */
 function registerNodeManifests(values, lookedUp = []) {
 	let added = false;
-	for (const manifest of rememberNodeManifests(values)) if (addNodeConfig(toNodeConfig(manifest, manifest.publishType))) added = true;
+	for (const manifest of rememberNodeManifests(values)) if (registerFullManifest(manifest)) added = true;
 	for (const type of lookedUp) if (isRegistryNodeType(type) && !hasNodeConfig(type)) registryLacks.add(type);
 	if (added) rebuildNodeArrays();
 }
@@ -11104,8 +11319,9 @@ async function refetchStoreNodes() {
 		return;
 	}
 	try {
+		const keepFull = fullNodeConfigTypes();
 		resetNodeRegistry();
-		await initializeNodeConfigs();
+		await initializeNodeConfigs(keepFull);
 		isInitialized = NODE_CONFIGS.length > 0;
 		rebuildNodeArrays();
 	} catch (error) {
@@ -11147,7 +11363,9 @@ function notifyNodeTypesListeners() {
 */
 function liveInternalOperations(type) {
 	if (!type?.startsWith("internal:")) return void 0;
-	const operations = NODE_CONFIGS.find((c) => c.type === type)?.operations;
+	const config = nodeConfigOf(type);
+	if (!config || config.manifestDetail === "SUMMARY") return void 0;
+	const operations = config.operations;
 	return Array.isArray(operations) && operations.length > 0 ? operations : void 0;
 }
 /**
@@ -11268,20 +11486,24 @@ registerBaseNodeTypes();
 * 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: {
-				version: node.data?.version,
-				nodeData: node.data?.nodeData
-			},
-			operations: node.data?.operations
-		});
-		if (meta?.node) NODE_TYPES[node.type] = meta.node;
+	const wanted = [];
+	for (const node of workflowNodes) {
+		if (!node.type) continue;
+		if (nodeConfigOf(node.type)?.manifestDetail === "SUMMARY") wanted.push(node.type);
+		if (!NODE_TYPES[node.type]) {
+			wanted.push(node.type);
+			const meta = getNodeMetadata({
+				type: node.type,
+				defaultData: {
+					version: node.data?.version,
+					nodeData: node.data?.nodeData
+				},
+				operations: node.data?.operations
+			});
+			if (meta?.node) NODE_TYPES[node.type] = meta.node;
+		}
 	}
-	ensureNodeTypesLoaded(unknownTypes);
+	ensureNodeTypesLoaded(wanted);
 }
 
 // src/components/FluidGridsProvider.tsx
@@ -11482,4 +11704,4 @@ function useFluidGridsContext() {
 	return context;
 }
 
-export { SwitchRulesEditor as $, workflowFingerprint as $t, SENSITIVE_PARAM as A, TriggerWorkflowDocument as An, isLocked as At, nodeSubtitle as B, matchesAdapterProvider as Bn, rememberSessionForReload as Bt, failureQuestions as C, signalPayloadCard as Cn, refusalOfQuota as Ct, describeRun as D, EventRegistrationsDocument as Dn, useEditLeaseLocked as Dt, runStepQuestions as E, NodeEndpointConfigsDocument as En, workflowSaveQueue as Et, useRunGuard as F, ExecutionDetailDocument as Fn, releasesOnClose as Ft, useNodeConfig as G, loadMarkdown as Gn, AUTOSAVE_DEBOUNCE_MS as Gt, optionText as H, replaceAdapterConnections as Hn, rememberOwnStatusChange as Ht, workflowParameterIssues as I, RunFromNodeDocument as In, shouldReleaseForIdle as It, isStringOptionList as J, codeBuildIdOf as Jt, resolveUiSpec as K, useMarkdownRenderer as Kn, AUTOSAVE_RETRY_DELAYS_MS as Kt, asRecord as L, ExecuteStepDocument as Ln, tickAction as Lt, createConfiguredNode as M, CreateWorkflowVersionDocument as Mn, leaseCallSequence as Mt, useInsertNode as N, CreateWorkflowDefinitionDocument as Nn, phaseAfterAcquire as Nt, describeRunError as O, BuilderRunStatusDocument as On, useEditLeaseStore as Ot, MissingParametersDialog as P, ExecutionsListDocument as Pn, phaseAfterTakeOver as Pt, ConditionTreeBuilder as Q, saveFailureActionOf as Qt, coerceNumber as R, connectionsForAdapter as Rn, EDIT_SESSION_ID as Rt, useLatestFailedRun as S, runSignalTargets as Sn, createThenOpen as St, runQuestions as T, NodeManifestsDocument as Tn, useSaveStatusStore as Tt, paramsFromOperation as U, getNodeDetail as Un, rememberRevision as Ut, nodeTitle as V, newConnectionProviderKey as Vn, sessionBeforeReload as Vt, selectedOperationOf as W, buildStickyNode as Wn, revisionOf as Wt, optionListValues as X, inAppLeaveTarget as Xt, optionListText as Y, findSaveConflict as Yt, resolveLoadOptionsSpec as Z, resettledBaseline as Zt, registryNodeData as _, canSignalRun as _n, useFlowValidator as _t, NODES_METADATA as a, parseParameterValue as an, missingRequiredParameters as at, fetchAllNodeEndpointConfigs as b, parseRawSignalPayload as bn, builderPathOf as bt, ensureInstalledNodeTypesLoaded as c, resolveNodeOperation as cn, autosaveAllowedFor as ct, ensureRegistryNodeTypesLoaded as d, openRunQuotaUpgradePrompt as dn, editingLeaseLocked as dt, useNodeExecution as en, casesFromRules as et, isNodeConfigsInitialized as f, useCanvasEdges as fn, leavingLosesChanges as ft, registerWorkflowNodeTypes as g, useCodeWorkflowInterface as gn, isFlowComplete as gt, registerNodeManifests as h, loadDefinitionJson as hn, watchLeavingLosesChanges as ht, AVAILABLE_NODES as i, formatParameterValue as in, boundFieldsOf as it, buildOperationSeed as j, SaveWorkflowDraftDocument as jn, leaseCallQueue as jt, describeRunStep as k, BuilderRunNodeDetailsDocument as kn, bannerOf as kt, ensureNodeConfigsLoaded as l, isParamVisible as ln, departingSave as lt, refetchStoreNodes as m, clearCodeWorkflowDefinitionCache as mn, touchesSavedFields as mt, FluidGridsProvider as n, nodeStateDurationMs as nn, parseMappingValue as nt, NODE_CONFIGS as o, structuredParameterType as on, useGuardedNavigate as ot, onNodeTypesUpdate as p, useNodeRegistryRevision as pn, savedEverythingBeforeLeaving as pt, stripSubmitActions as q, canAutosave as qt, useFluidGridsContext as r, runDurationMs as rn, latestNodeLog as rt, NODE_TYPES as s, fieldsFromValue as sn, useManualSave as st, FluidGridsContext as t, formatElapsedMs as tn, FieldTree as tt, ensureNodeTypesLoaded as u, useFluidGridsAnalytics as un, editStateFor as ut, scheduleNodePaletteLoad as v, declaredSignals as vn, useSaveWorkflow as vt, isFailedStatus as w, NodePaletteEntriesDocument as wn, saveIndicatorOf as wt, getNodeMetadata as x, payloadFromCardValues as xn, classifyCreateRefusal as xt, GetMyNodeInstallationsDocument as y, durableInterfaceOf as yn, blankWorkflowCreateInput as yt, fixedParameterState as z, isOptionalAdapter as zn, forgetSessionForReload as zt };
+export { resolveLoadOptionsSpec as $, resettledBaseline as $t, describeRunError as A, BuilderRunStatusDocument as An, useEditLeaseStore as At, coerceNumber as B, connectionsForAdapter as Bn, EDIT_SESSION_ID as Bt, getNodeMetadata as C, payloadFromCardValues as Cn, classifyCreateRefusal as Ct, runQuestions as D, NodeManifestsDocument as Dn, useSaveStatusStore as Dt, isFailedStatus as E, NodePaletteEntriesDocument as En, saveIndicatorOf as Et, useInsertNode as F, CreateWorkflowDefinitionDocument as Fn, phaseAfterAcquire as Ft, paramsFromOperation as G, getNodeDetail as Gn, rememberRevision as Gt, nodeSubtitle as H, matchesAdapterProvider as Hn, rememberSessionForReload as Ht, MissingParametersDialog as I, ExecutionsListDocument as In, phaseAfterTakeOver as It, resolveUiSpec as J, useMarkdownRenderer as Jn, AUTOSAVE_RETRY_DELAYS_MS as Jt, selectedOperationOf as K, buildStickyNode as Kn, revisionOf as Kt, useRunGuard as L, ExecutionDetailDocument as Ln, releasesOnClose as Lt, SENSITIVE_PARAM as M, TriggerWorkflowDocument as Mn, isLocked as Mt, buildOperationSeed as N, SaveWorkflowDraftDocument as Nn, leaseCallQueue as Nt, runStepQuestions as O, NodeEndpointConfigsDocument as On, workflowSaveQueue as Ot, createConfiguredNode as P, CreateWorkflowVersionDocument as Pn, leaseCallSequence as Pt, optionListValues as Q, inAppLeaveTarget as Qt, workflowParameterIssues as R, RunFromNodeDocument as Rn, shouldReleaseForIdle as Rt, fetchAllNodeEndpointConfigs as S, parseRawSignalPayload as Sn, builderPathOf as St, failureQuestions as T, signalPayloadCard as Tn, refusalOfQuota as Tt, nodeTitle as U, newConnectionProviderKey as Un, sessionBeforeReload as Ut, fixedParameterState as V, isOptionalAdapter as Vn, forgetSessionForReload as Vt, optionText as W, replaceAdapterConnections as Wn, rememberOwnStatusChange as Wt, isStringOptionList as X, codeBuildIdOf as Xt, stripSubmitActions as Y, canAutosave as Yt, optionListText as Z, findSaveConflict as Zt, registerNodeManifests as _, loadDefinitionJson as _n, watchLeavingLosesChanges as _t, NODES_METADATA as a, runDurationMs as an, latestNodeLog as at, scheduleNodePaletteLoad as b, declaredSignals as bn, useSaveWorkflow as bt, ensureInstalledNodeTypesLoaded as c, structuredParameterType as cn, useGuardedNavigate as ct, ensureNodeTypesLoaded as d, isParamVisible as dn, departingSave as dt, saveFailureActionOf as en, ConditionTreeBuilder as et, ensureRegistryNodeTypesLoaded as f, useFluidGridsAnalytics as fn, editStateFor as ft, refetchStoreNodes as g, clearCodeWorkflowDefinitionCache as gn, touchesSavedFields as gt, prefetchNodeType as h, useNodeRegistryRevision as hn, savedEverythingBeforeLeaving as ht, AVAILABLE_NODES as i, nodeStateDurationMs as in, parseMappingValue as it, describeRunStep as j, BuilderRunNodeDetailsDocument as jn, bannerOf as jt, describeRun as k, EventRegistrationsDocument as kn, useEditLeaseLocked as kt, ensureNodeConfigsLoaded as l, fieldsFromValue as ln, useManualSave as lt, onNodeTypesUpdate as m, useCanvasEdges as mn, leavingLosesChanges as mt, FluidGridsProvider as n, useNodeExecution as nn, casesFromRules as nt, NODE_CONFIGS as o, formatParameterValue as on, boundFieldsOf as ot, isNodeConfigsInitialized as p, openRunQuotaUpgradePrompt as pn, editingLeaseLocked as pt, useNodeConfig as q, loadMarkdown as qn, AUTOSAVE_DEBOUNCE_MS as qt, useFluidGridsContext as r, formatElapsedMs as rn, FieldTree as rt, NODE_TYPES as s, parseParameterValue as sn, missingRequiredParameters as st, FluidGridsContext as t, workflowFingerprint as tn, SwitchRulesEditor as tt, ensureNodeTypeReady as u, resolveNodeOperation as un, autosaveAllowedFor as ut, registerWorkflowNodeTypes as v, useCodeWorkflowInterface as vn, isFlowComplete as vt, useLatestFailedRun as w, runSignalTargets as wn, createThenOpen as wt, GetMyNodeInstallationsDocument as x, durableInterfaceOf as xn, blankWorkflowCreateInput as xt, registryNodeData as y, canSignalRun as yn, useFlowValidator as yt, asRecord as z, ExecuteStepDocument as zn, tickAction as zt };

package/dist/{HistoryPage-D4rkw4zu.js → HistoryPage-fMZlXsIY.js}

@@ -1,6 +1,6 @@
 "use client";
 import { t as __exportAll } from "./rolldown-runtime-hDbaFkMy.js";
-import { d as useRestoreWorkflowVersion, h as useWorkflowDefinitions } from "./useWorkflows-BrqrVT8h.js";
+import { d as useRestoreWorkflowVersion, h as useWorkflowDefinitions } from "./useWorkflows-Dg7q_Tzf.js";
 import { t as VersionDiffDialog } from "./VersionDiffDialog-D9W5Fm56.js";
 import { c as versionsOfWorkflow } from "./VersionLifecycleBar-DuphLOT0.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";

package/dist/{InsightsPage-CVzNu4F7.js → InsightsPage-DozSYGVD.js}

@@ -3,7 +3,7 @@ import { t as __exportAll } from "./rolldown-runtime-hDbaFkMy.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
 import { n as useNavigationV2 } from "./useNavigationV2-C2WeqN7d.js";
 import { t as TechnicalDetails } from "./TechnicalDetails-r5JXr1jZ.js";
-import { o as useRunReplayActions, r as useInsightsData } from "./useObservability-CjZTYldC.js";
+import { o as useRunReplayActions, r as useInsightsData } from "./useObservability-mXM7lCop.js";
 import { a as getTopFailingNodes, i as getFailureBreakdown, l as rankedFailingWorkflows, n as formatDuration, o as getTopFailingWorkflows, s as percentage, u as summarySuccessRate } from "./utils-C0dtnN4R.js";
 import { n as FailureTriagePanel } from "./FailureTriagePanel-Ddua9uxn.js";
 import { c as useContinuousOptimisationEnabled } from "./feature-flags-B_b8PJ6Z.js";

package/dist/{PaidTemplateConfirm-IWOHVR6s.js → PaidTemplateConfirm-Crs0CXXl.js}

@@ -1,6 +1,6 @@
 "use client";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
-import { n as formatTemplatePrice } from "./TemplateCard-9Beuqm5_.js";
+import { n as formatTemplatePrice } from "./TemplateCard-BsrXJ1Su.js";
 import { t as ConfirmActionDialog } from "./ConfirmActionDialog-D9Pir3bc.js";
 import { jsx } from "react/jsx-runtime";
 

package/dist/{SettingsPage-DwA2ZjyH.js → SettingsPage-qSvV7r0y.js}

@@ -12,10 +12,10 @@ import { $I as WorkflowSecuritySeverity, QI as WorkflowSecurityCheck, ZI as Work
 import { M as saveCodecServerSettings, _ as fetchPauseRules, a as createPauseRule, c as deletePauseRule, f as fetchArchiveSettings, g as fetchCodecServerSettings, j as saveArchiveSettings, l as deleteSearchAttribute, o as createSearchAttribute, r as clearArchiveSettings, x as fetchSearchAttributes } from "./api-o5UUDbr8.js";
 import { i as NativeSelect, o as StatusPill, t as FieldError, u as useResource } from "./shared-mbyvDPde.js";
 import { A as useFlowStore } from "./node-operation-selection-DHbtGNrG.js";
-import { Tt as useSaveStatusStore, Yt as findSaveConflict } from "./FluidGridsProvider-C-WGQwuT.js";
-import { a as useLogStreamDestinations, i as useLogStreamDestinationActions } from "./useObservability-CjZTYldC.js";
+import { Dt as useSaveStatusStore, Zt as findSaveConflict } from "./FluidGridsProvider-CDjkq3Zj.js";
+import { a as useLogStreamDestinations, i as useLogStreamDestinationActions } from "./useObservability-mXM7lCop.js";
 import { r as useConnections } from "./useConnections-CmnwGk09.js";
-import { Nt as useUpdateWorkflowDefinitionMutation, Rt as useWorkflowDefinitionQuery, Vt as useWorkflowDefinitionsQuery, n as useAgentDefinitions } from "./useAgentDefinitions-9pmnEpb8.js";
+import { Nt as useUpdateWorkflowDefinitionMutation, Rt as useWorkflowDefinitionQuery, Vt as useWorkflowDefinitionsQuery, n as useAgentDefinitions } from "./useAgentDefinitions-YUDx_OW2.js";
 import { a as formToInput$2, i as emptyAgentForm, n as agentToForm, o as grantDays, r as describeRule, t as AgentFormError } from "./agent-form-D0uLvzx4.js";
 import { r as getFluidGridsConfig } from "./config-X97zrIvn.js";
 import { n as getGlobalStoreClient } from "./global-client-DP_Wxe5t.js";