@superblocksteam/library 2.0.104 → 2.0.105-next.1

package/dist/lib/index.js

@@ -1,5 +1,5 @@
 import { n as consoleLogAttributes, t as early_console_buffer_default } from "../early-console-buffer-D4wVuyBf.js";
-import { A as useSuperblocksProfiles, B as createManagedPropsList, C as rejectById, D as useSuperblocksContext, E as getAppMode, F as editorBridge, G as getEditStore, H as PropsCategory, I as iframeMessageHandler, L as isEmbeddedBySuperblocksFirstParty, M as generateId, N as sendNotification, O as useSuperblocksDataTags, P as colors$1, R as sendMessageImmediately, S as addNewPromise, T as SuperblocksContextProvider, U as Section, V as Prop, W as createPropertiesPanelDefinition, _ as root_store_default, a as FixWithClarkButton, b as getContextFromTraceHeaders, c as ErrorContent, d as ErrorMessage$1, f as ErrorStack, g as StyledClarkIcon, h as SecondaryButton, i as getWidgetRectAnchorName, j as useSuperblocksUser, k as useSuperblocksGroups, l as ErrorDetails, m as ErrorTitle, n as useJSXContext, o as ActionsContainer, p as ErrorSummary, r as getWidgetAnchorName, s as ErrorContainer, u as ErrorIconContainer, v as startEditorSync, w as resolveById, x as api_hmr_tracker_default, y as createIframeSpan, z as isEditMode } from "../jsx-wrapper-DnM3BCRU.js";
+import { A as useSuperblocksProfiles, B as createManagedPropsList, C as rejectById, D as useSuperblocksContext, E as getAppMode, F as editorBridge, G as getEditStore, H as PropsCategory, I as iframeMessageHandler, L as isEmbeddedBySuperblocksFirstParty, M as generateId, N as sendNotification, O as useSuperblocksDataTags, P as colors$1, R as sendMessageImmediately, S as addNewPromise, T as SuperblocksContextProvider, U as Section, V as Prop, W as createPropertiesPanelDefinition, _ as root_store_default, a as FixWithClarkButton, b as getContextFromTraceHeaders, c as ErrorContent, d as ErrorMessage$1, f as ErrorStack, g as StyledClarkIcon, h as SecondaryButton, i as getWidgetRectAnchorName, j as useSuperblocksUser, k as useSuperblocksGroups, l as ErrorDetails, m as ErrorTitle, n as useJSXContext, o as ActionsContainer, p as ErrorSummary, r as getWidgetAnchorName, s as ErrorContainer, u as ErrorIconContainer, v as startEditorSync, w as resolveById, x as api_hmr_tracker_default, y as createIframeSpan, z as isEditMode } from "../jsx-wrapper-BCVlG9Wg.js";
 import { n as initTracerProviderWithOrigin } from "../utils-BGEEeYie.js";
 import { action, autorun, computed, makeAutoObservable, makeObservable, observable, reaction, when } from "mobx";
 import { UNSAFE_DataRouterContext, generatePath, useLocation, useNavigate, useParams, useRouteError } from "react-router";
@@ -18,6 +18,7 @@ import colors from "tailwindcss/colors";
 import { Observer, observer } from "mobx-react-lite";
 import { getIntegrationDeclarations } from "@superblocksteam/sdk-api";
 import zodToJsonSchema from "zod-to-json-schema";
+import useSWR, { mutate } from "swr";
 import * as Dialog from "@radix-ui/react-dialog";
 import posthog from "posthog-js";
 import { Graph } from "@dagrejs/graphlib";
@@ -965,6 +966,24 @@ function useGetCurrentUserQuery() {
 	}, []);
 }
 
+//#endregion
+//#region src/lib/internal-details/lib/registry-loader.ts
+/**
+* Dynamically import the SDK API registry module from the app origin.
+*
+* Uses a cache-busting parameter because the browser's ES module map
+* caches modules by URL — without it, subsequent import() calls return
+* the stale first-load module and newly created APIs are never discovered.
+*/
+async function loadRegistryModule() {
+	const registryUrl = new URL("/server/apis/index.ts", window.location.origin);
+	registryUrl.searchParams.set("t", String(Date.now()));
+	return (await import(
+		/* @vite-ignore */
+		registryUrl.href
+)).default;
+}
+
 //#endregion
 //#region src/lib/internal-details/lib/utils/zod-to-typescript.ts
 /**
@@ -1073,6 +1092,7 @@ function extractSdkApiMetadata(name, api, sourceCode) {
 		outputSchema,
 		isStreaming: false,
 		entryPoint,
+		exportName: root_store_default.getApiExportName(name),
 		integrations: (api.integrations ?? []).map((integration) => ({
 			key: integration.key,
 			pluginId: integration.pluginId,
@@ -1154,7 +1174,7 @@ async function discoverAndRegisterSdkApis() {
 	if (!root_store_default.sdkApiEnabled) return;
 	if (!root_store_default.hasUnresolvedGate()) root_store_default.initDiscoveryGate();
 	try {
-		const apis = (await import(new URL("/server/apis/index.ts", window.location.origin).href)).default;
+		const apis = await loadRegistryModule();
 		const apiNames = Object.keys(apis);
 		if (apiNames.length === 0) {
 			console.debug("[sdk-api-discovery] No SDK APIs found in registry");
@@ -1181,6 +1201,24 @@ async function discoverAndRegisterSdkApis() {
 			}
 		});
 		const sources = await Promise.all(sourcePromises);
+		const namedImportMap = await buildRegistryNamedImportMap();
+		for (let i = 0; i < apiNames.length; i++) {
+			const source = sources[i];
+			const name = apiNames[i];
+			if (!source) continue;
+			const namedExportName = namedImportMap.get(name);
+			if (namedExportName !== void 0) {
+				root_store_default.setApiExportName(name, namedExportName);
+				continue;
+			}
+			if (/export\s+default\b/.test(source)) continue;
+			const namedExportPattern = /export\s+(?:const|let|var)\s+(\w+)\s*=/g;
+			let match;
+			const exportNames = [];
+			while ((match = namedExportPattern.exec(source)) !== null) if (match[1]) exportNames.push(match[1]);
+			if (exportNames.length === 1) root_store_default.setApiExportName(name, exportNames[0]);
+			else if (exportNames.length > 1) root_store_default.setApiExportName(name, name);
+		}
 		const results = await Promise.allSettled(apiNames.map(async (name, i) => {
 			const apiModule = apis[name];
 			if (!apiModule) throw new Error(`API ${name} not found in registry`);
@@ -1195,6 +1233,47 @@ async function discoverAndRegisterSdkApis() {
 		root_store_default.notifyDiscoveryComplete();
 	}
 }
+/**
+* Fetches `server/apis/index.ts` and builds a map of ALL named imports:
+* `registryKey → originalExportName`.
+*
+* Given a registry line like:
+*   import { GetAllUsers as ListUsers, CreateOrder } from './users.js'
+*
+* The map will contain:
+*   ListUsers → GetAllUsers (aliased)
+*   CreateOrder → CreateOrder (non-aliased)
+*
+* Also handles mixed default+named imports:
+*   import Default, { GetOrders as ListOrders } from './orders.js'
+*   → ListOrders → GetOrders
+*
+* Default imports and type-only imports are excluded.
+*/
+async function buildRegistryNamedImportMap() {
+	const map = /* @__PURE__ */ new Map();
+	try {
+		const resp = await fetch("/sb-raw-source/server/apis/index.ts");
+		if (!resp.ok) return map;
+		const text = await resp.text();
+		const importBlockPattern = /import\s+(?:type\s+)?(?:\w+\s*,\s*)?\{([^}]+)\}\s*from\s*['"][^'"]+['"]/g;
+		let blockMatch;
+		while ((blockMatch = importBlockPattern.exec(text)) !== null) {
+			const fullStatement = blockMatch[0];
+			if (/^import\s+type\b/.test(fullStatement)) continue;
+			const specifiers = blockMatch[1].split(",");
+			for (const spec of specifiers) {
+				const trimmed = spec.trim();
+				if (!trimmed || /^type\s/.test(trimmed)) continue;
+				const parts = trimmed.split(/\s+as\s+/);
+				const originalName = parts[0].trim();
+				const localName = (parts[1] ?? originalName).trim();
+				if (/^\w+$/.test(originalName) && /^\w+$/.test(localName)) map.set(localName, originalName);
+			}
+		}
+	} catch {}
+	return map;
+}
 if (import.meta.hot) import.meta.hot.accept("/server/apis/index.ts", () => {
 	if (!root_store_default.sdkApiEnabled) return;
 	console.debug("[sdk-api-discovery] API registry updated via HMR, re-running discovery");
@@ -1204,6 +1283,360 @@ if (import.meta.hot) import.meta.hot.accept("/server/apis/index.ts", () => {
 	discoverAndRegisterSdkApis();
 });
 
+//#endregion
+//#region src/lib/internal-details/query-cache.ts
+/**
+* query-cache — thin SWR-backed QueryClient.
+*
+* Replaces the hand-rolled QueryCache/QueryEntry/QueryClient with SWR's
+* built-in cache and mutate API.  The module-scope `queryClient` singleton
+* survives React tree teardowns (critical for the iframe sb-init lifecycle)
+* because SWR's default cache is a module-scope Map.
+*
+* Public surface:
+*   - `queryClient.invalidateQueries(prefix)` — cache invalidation
+*   - `queryClient.setQueryData(key, data)` — optimistic updates
+*   - `queryClient.getQueryData(key)` — read cached data
+*   - `queryClient.buildCacheKey(apiName, inputs)` — deterministic key
+*   - `queryClient.cache.clear()` — test helper
+*/
+const KEY_SEPARATOR = "::";
+const dataStore = /* @__PURE__ */ new Map();
+/** Last successful write time per cache key (survives hook remounts; used for `isStale`). */
+const dataUpdatedAtByKey = /* @__PURE__ */ new Map();
+/**
+* Build a deterministic, string cache key from API name + inputs.
+* Sorts object entries so { b: 2, a: 1 } and { a: 1, b: 2 } produce
+* the same key.
+*/
+function buildCacheKey(apiName, inputs) {
+	return `${apiName}${KEY_SEPARATOR}${JSON.stringify(Object.entries(inputs).sort(([a], [b]) => a.localeCompare(b)))}`;
+}
+var QueryClient = class {
+	buildCacheKey = buildCacheKey;
+	getQueryData(key) {
+		return dataStore.get(key);
+	}
+	setQueryData(key, updater) {
+		const current = this.getQueryData(key);
+		const next = typeof updater === "function" ? updater(current) : updater;
+		dataStore.set(key, next);
+		dataUpdatedAtByKey.set(key, Date.now());
+		mutate(key, next, { revalidate: false }).catch(() => {});
+	}
+	async invalidateQueries(keyPrefix) {
+		const prefix = keyPrefix.includes(KEY_SEPARATOR) ? keyPrefix : keyPrefix + KEY_SEPARATOR;
+		for (const key of dataStore.keys()) if (key.startsWith(prefix)) {
+			dataStore.delete(key);
+			dataUpdatedAtByKey.delete(key);
+		}
+		await mutate((key) => typeof key === "string" && key.startsWith(prefix));
+	}
+	cache = { clear: () => {
+		dataStore.clear();
+		dataUpdatedAtByKey.clear();
+		mutate(() => true, void 0, { revalidate: false }).catch(() => {});
+	} };
+};
+const queryClient = new QueryClient();
+
+//#endregion
+//#region src/lib/internal-details/execute-api.ts
+/**
+* execute-api — framework-agnostic API execution function.
+*
+* Extracts the core SDK/legacy routing logic from useSdkApi so it can be:
+*   1. Called as a plain Promise outside any React component.
+*   2. Used as the `queryFn` inside useApiData's QueryEntry.
+*   3. Exported as a public primitive for utility functions and tests.
+*
+* Edit-mode tracking messages (execution-started / completed / failed) are
+* sent to the parent frame when isEditMode() is true, matching the behaviour
+* of the original useSdkApi implementation.
+*/
+/**
+* Returns true for every error except user-cancelled aborts.
+* Only `DOMException` with `name === "AbortError"` is treated as non-retryable.
+*/
+function isRetryableError(error) {
+	if (error instanceof DOMException && error.name === "AbortError") return false;
+	return true;
+}
+/** Default exponential backoff: 1s, 2s, 4s, …, capped at 30s. */
+function defaultRetryDelay(attempt) {
+	return Math.min(1e3 * Math.pow(2, attempt), 3e4);
+}
+/**
+* Execute a Superblocks API as a plain Promise, without any React lifecycle.
+*
+* Routes to the SDK path (`executeSdkApiV3`) when the API has an entry point
+* or when `sdkApiEnabled` is set on rootStore. Falls back to the legacy YAML
+* path otherwise.
+*
+* Sends edit-mode tracking messages to the parent frame when in edit mode,
+* keeping the Requests Panel in sync even for out-of-React calls.
+*
+* @throws {DOMException} with name "AbortError" if cancelled via signal.
+* @throws The orchestrator error object on API failure.
+*/
+async function executeApi(apiName, inputs, options) {
+	const inputRecord = inputs ?? {};
+	let sdkApiEnabled = root_store_default.sdkApiEnabled;
+	let hasEntryPoint = !!root_store_default.getApiEntryPoint(apiName);
+	if (!sdkApiEnabled && !hasEntryPoint) {
+		await root_store_default.awaitDiscovery();
+		sdkApiEnabled = root_store_default.sdkApiEnabled;
+		hasEntryPoint = !!root_store_default.getApiEntryPoint(apiName);
+	}
+	if (sdkApiEnabled || hasEntryPoint) {
+		const executionId = options?.executionId ?? generateId();
+		const startTime = Date.now();
+		const editMode = isEditMode();
+		if (editMode) sendMessageImmediately({
+			type: "sdk-api-execution-started",
+			payload: {
+				executionId,
+				apiName,
+				input: inputRecord
+			}
+		});
+		try {
+			const result$1 = await root_store_default.apis.executeSdkApiV3(apiName, inputRecord, { signal: options?.signal });
+			const durationMs = Date.now() - startTime;
+			if (result$1 == null) {
+				const nullError = {
+					code: "NO_RESPONSE",
+					message: `API "${apiName}" returned no response`
+				};
+				if (editMode) sendMessageImmediately({
+					type: "sdk-api-execution-failed",
+					payload: {
+						executionId,
+						apiName,
+						error: nullError,
+						durationMs
+					}
+				});
+				throw new Error(nullError.message);
+			}
+			if (result$1.error?.code === "ABORTED") {
+				if (editMode) sendMessageImmediately({
+					type: "sdk-api-execution-failed",
+					payload: {
+						executionId,
+						apiName,
+						error: result$1.error,
+						durationMs
+					}
+				});
+				throw new DOMException(`API "${apiName}" execution was aborted`, "AbortError");
+			}
+			if (result$1.success) {
+				if (editMode) sendMessageImmediately({
+					type: "sdk-api-execution-completed",
+					payload: {
+						executionId,
+						apiName,
+						output: result$1.output,
+						durationMs,
+						diagnostics: result$1.diagnostics,
+						orchestratorStartMs: result$1.executionStartMs,
+						orchestratorDurationMs: result$1.executionDurationMs,
+						fetchStartMs: result$1.fetchStartMs
+					}
+				});
+				return result$1.output;
+			}
+			const error = result$1.error ?? {
+				code: "UNKNOWN",
+				message: "API execution failed"
+			};
+			if (editMode) sendMessageImmediately({
+				type: "sdk-api-execution-failed",
+				payload: {
+					executionId,
+					apiName,
+					error,
+					durationMs,
+					diagnostics: result$1.diagnostics,
+					orchestratorStartMs: result$1.executionStartMs,
+					orchestratorDurationMs: result$1.executionDurationMs,
+					fetchStartMs: result$1.fetchStartMs
+				}
+			});
+			throw error;
+		} catch (err) {
+			if (editMode && !(err instanceof DOMException && err.name === "AbortError") && !(err instanceof Error && err.message === `API "${apiName}" returned no response`) && !(typeof err === "object" && err !== null && "code" in err)) {
+				const durationMs = Date.now() - startTime;
+				sendMessageImmediately({
+					type: "sdk-api-execution-failed",
+					payload: {
+						executionId,
+						apiName,
+						error: {
+							code: "UNKNOWN",
+							message: err instanceof Error ? err.message : "API execution failed"
+						},
+						durationMs
+					}
+				});
+			}
+			throw err;
+		}
+	}
+	const apiPath = getApiPath(apiName);
+	const result = await root_store_default.apis.runApiByPath({
+		path: apiPath,
+		inputs: inputRecord
+	});
+	if (result == null) throw new Error(`API "${apiName}" returned no response`);
+	if (result.error != null) throw result.error;
+	return result.data;
+}
+/**
+* Creates a typed version of executeApi bound to a specific API registry.
+*
+* @example
+* ```typescript
+* import type { ApiRegistry } from "../../server/apis/index.js";
+* import { createTypedExecuteApi } from "@superblocksteam/library";
+* export const executeApi = createTypedExecuteApi<ApiRegistry>();
+* ```
+*/
+function createTypedExecuteApi() {
+	return executeApi;
+}
+
+//#endregion
+//#region src/lib/internal-details/use-api-data.ts
+/**
+* useApiData — declarative data-fetching hook backed by SWR.
+*
+* Designed for GET-style reads that auto-fetch on mount and when inputs change.
+* Uses SWR for caching, deduplication, revalidation, and shared state.
+*
+* Use this hook for data loading. For mutations and event-driven calls use
+* `useApi`. For utility functions outside React use `executeApi`.
+*
+* @example
+* ```tsx
+* const { data, loading, isError, error } = useApiData("GetUsers", { email });
+* if (loading) return <Skeleton />;
+* if (isError) return <ErrorBanner error={error} />;
+* return <UserList users={data.users} />;
+* ```
+*/
+const EXEC_ID_PREFIX = "sb-exec-id:";
+function getOrCreateExecId(cacheKey) {
+	const key = EXEC_ID_PREFIX + cacheKey;
+	try {
+		const id$1 = sessionStorage.getItem(key);
+		if (id$1) return id$1;
+	} catch {}
+	const id = generateId();
+	try {
+		sessionStorage.setItem(key, id);
+	} catch {}
+	return id;
+}
+function rotateExecId(cacheKey) {
+	const key = EXEC_ID_PREFIX + cacheKey;
+	const id = generateId();
+	try {
+		sessionStorage.setItem(key, id);
+	} catch {}
+	return id;
+}
+function useApiData(apiName, inputs, options = {}) {
+	const { enabled = true, staleTime = 0, gcTime: _gcTime = 3e5, retry = 3, retryDelay = defaultRetryDelay, refetchOnWindowFocus = false, refetchOnReconnect = true, refetchInterval = false, structuralSharing = false } = options;
+	const cacheKey = buildCacheKey(apiName, inputs);
+	const controllerRef = useRef(null);
+	const dataUpdatedAtRef = useRef(0);
+	const fetcher = useCallback(async (_key) => {
+		controllerRef.current?.abort();
+		const controller = new AbortController();
+		controllerRef.current = controller;
+		const executionId = getOrCreateExecId(cacheKey);
+		try {
+			const result = await executeApi(apiName, inputs, {
+				signal: controller.signal,
+				executionId
+			});
+			const now = Date.now();
+			dataUpdatedAtRef.current = now;
+			dataUpdatedAtByKey.set(cacheKey, now);
+			dataStore.set(cacheKey, result);
+			return result;
+		} finally {
+			rotateExecId(cacheKey);
+		}
+	}, [cacheKey]);
+	const swrConfig = {
+		revalidateOnFocus: refetchOnWindowFocus,
+		revalidateOnReconnect: refetchOnReconnect,
+		refreshInterval: refetchInterval || 0,
+		dedupingInterval: staleTime,
+		compare: structuralSharing ? void 0 : (a, b) => a === b,
+		onErrorRetry: (err, _key, _config, revalidate, { retryCount }) => {
+			if (err instanceof DOMException && err.name === "AbortError") return;
+			if (retry === false || retry === 0) return;
+			if (!isRetryableError(err)) return;
+			if (retryCount > retry) return;
+			const delay = retryDelay(retryCount - 1);
+			const timer = setTimeout(() => void revalidate({ retryCount }), delay);
+			controllerRef.current?.signal.addEventListener("abort", () => clearTimeout(timer), { once: true });
+		},
+		shouldRetryOnError: true,
+		revalidateOnMount: staleTime > 0 ? void 0 : true,
+		keepPreviousData: true,
+		fallbackData: options.placeholderData
+	};
+	const { data, error, isValidating, isLoading, mutate: mutate$1 } = useSWR(enabled ? cacheKey : null, fetcher, swrConfig);
+	const effectiveError = error instanceof DOMException && error.name === "AbortError" ? void 0 : error;
+	const hasData = data !== void 0;
+	const hasError = effectiveError !== void 0;
+	const isFetching = isValidating;
+	const status = hasData ? "success" : hasError ? "error" : "pending";
+	const lastUpdatedAt = dataUpdatedAtByKey.get(cacheKey) ?? dataUpdatedAtRef.current;
+	const isStaleNow = hasData && staleTime > 0 && lastUpdatedAt > 0 && Date.now() - lastUpdatedAt >= staleTime;
+	const refetch = useCallback(async () => {
+		controllerRef.current?.abort();
+		controllerRef.current = null;
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		return await mutate$1();
+	}, [mutate$1]);
+	const cancel = useCallback(() => {
+		controllerRef.current?.abort();
+		controllerRef.current = null;
+	}, []);
+	return {
+		data: data ?? options.placeholderData,
+		error: effectiveError ?? void 0,
+		status,
+		fetchStatus: isFetching ? "fetching" : "idle",
+		loading: isLoading && !hasData,
+		fetching: isFetching,
+		isError: status === "error",
+		isSuccess: status === "success",
+		isStale: isStaleNow,
+		refetch,
+		cancel
+	};
+}
+/**
+* Creates a typed version of useApiData bound to a specific API registry.
+*
+* @example
+* ```typescript
+* import type { ApiRegistry } from "../../server/apis/index.js";
+* import { useTypedApiData } from "@superblocksteam/library";
+* export const useApiData = useTypedApiData<ApiRegistry>();
+* ```
+*/
+function useTypedApiData() {
+	return useApiData;
+}
+
 //#endregion
 //#region src/lib/internal-details/use-api.ts
 /**
@@ -1216,6 +1649,11 @@ if (import.meta.hot) import.meta.hot.accept("/server/apis/index.ts", () => {
 * Delegation happens at RUN TIME (when run() is invoked), not render time,
 * so components that mount before bootstrap completes still use the SDK path
 * once the user triggers execution.
+*
+* Three primitives are now available:
+*   - `useApi`      — imperative mutations (this file)
+*   - `useApiData`  — declarative reads with cache (use-api-data.ts)
+*   - `executeApi`  — plain Promise outside React (execute-api.ts)
 */
 /**
 * Get the API path for an API by name.
@@ -1314,7 +1752,10 @@ function useSdkApi(apiName) {
 							apiName,
 							output: result.output,
 							durationMs,
-							diagnostics: result.diagnostics
+							diagnostics: result.diagnostics,
+							orchestratorStartMs: result.executionStartMs,
+							orchestratorDurationMs: result.executionDurationMs,
+							fetchStartMs: result.fetchStartMs
 						}
 					});
 					return result.output;
@@ -1330,7 +1771,10 @@ function useSdkApi(apiName) {
 						apiName,
 						error,
 						durationMs,
-						diagnostics: result.diagnostics
+						diagnostics: result.diagnostics,
+						orchestratorStartMs: result.executionStartMs,
+						orchestratorDurationMs: result.executionDurationMs,
+						fetchStartMs: result.fetchStartMs
 					}
 				});
 				throw error;
@@ -1345,195 +1789,114 @@ function useSdkApi(apiName) {
 	};
 }
 /**
-* React hook for calling APIs with automatic type inference.
-*
-* Supports two modes:
-*
-* **Imperative** — call `run()` manually (e.g., on button click):
-* ```ts
-* const { run, loading, data } = useApi("CreateOrder");
-* await run({ item, qty });
-* ```
-*
-* **Declarative** — pass inputs to auto-fetch when they change:
-* ```ts
-* const { loading, data } = useApi("GetUsers", { email, name });
-* // re-fetches automatically when email or name changes
-* ```
-*
-* When the SDK API feature flag (`clark.sdk-api.enabled`) is on, this executes
-* via the orchestrator's v3/execute endpoint from within the library iframe.
-*
-* When the flag is off, this delegates to the legacy YAML-based API system
-* which uses `rootStore.apis.runApiByPath`.
-*
-* IMPORTANT: The path is chosen at RUN TIME (when run() is invoked), not at
-* render time. This ensures that if the component mounts before the bootstrap
-* response arrives (sdkApiEnabled still false), the API will still use the SDK
-* path once bootstrap completes.
+* Imperative state machine for useApi (no inputs / mutation mode).
+* Extracted so Rules of Hooks are satisfied when useApi conditionally routes
+* to the declarative path via useApiData.
 *
-* @param apiName - The name of the API to execute (e.g., "GetUsers")
-* @param inputs - Optional inputs object. When provided, the API is called
-*   automatically on mount and whenever the input values change (shallow compare).
-* @returns Object with `run`, `cancel`, `loading`, and `data`
+* Both useApiImperative and the useApiData call inside useApi are always
+* invoked on every render — React requires unconditional hook calls.
 */
-const INFLIGHT_KEY = "__sb_useApi_inflightFetches";
-const MOUNTS_KEY = "__sb_useApi_activeMounts";
-const EDIT_MODE_FETCH_DELAY_MS = 150;
-function getFetchDelayMs() {
-	return isEditMode() ? EDIT_MODE_FETCH_DELAY_MS : 0;
-}
-function getInflightFetches() {
-	const w = globalThis;
-	if (!w[INFLIGHT_KEY]) w[INFLIGHT_KEY] = /* @__PURE__ */ new Map();
-	return w[INFLIGHT_KEY];
-}
-function getActiveMounts() {
-	const w = globalThis;
-	if (!w[MOUNTS_KEY]) w[MOUNTS_KEY] = /* @__PURE__ */ new Map();
-	return w[MOUNTS_KEY];
-}
-function incMounts(key) {
-	const mounts = getActiveMounts();
-	const prev = mounts.get(key) ?? 0;
-	mounts.set(key, prev + 1);
-}
-function decMounts(key) {
-	const mounts = getActiveMounts();
-	const n = (mounts.get(key) ?? 1) - 1;
-	if (n <= 0) mounts.delete(key);
-	else mounts.set(key, n);
-}
-function scheduleInflightCleanup(cacheKey) {
-	setTimeout(() => {
-		if ((getActiveMounts().get(cacheKey) ?? 0) === 0) getInflightFetches().delete(cacheKey);
-	}, Math.max(getFetchDelayMs() * 2, 1));
-}
-/** Build a cache key from API name and input fingerprint. */
-function inflightKey(apiName, fingerprint) {
-	return `${apiName}::${fingerprint}`;
-}
-function useApi(apiName, inputs) {
+function useApiImperative(apiName) {
 	const { run: sdkRun, cancel: sdkCancel } = useSdkApi(apiName);
 	const { run: legacyRun, cancel: legacyCancel } = useApiStateful(apiName);
 	const [loading, setLoading] = useState(false);
 	const [data, setData] = useState(void 0);
 	const [error, setError] = useState(void 0);
+	const [status, setStatus] = useState("idle");
+	const [variables, setVariables] = useState(void 0);
 	const runIdRef = useRef(0);
-	const runRef = useRef(null);
-	const run = useCallback(async (runInputs) => {
-		getInflightFetches().delete(inflightKey(apiName, currentFingerprintRef.current ?? ""));
-		const thisRun = ++runIdRef.current;
-		setLoading(true);
-		setError(void 0);
-		try {
-			let sdkApiEnabled = root_store_default.sdkApiEnabled;
-			let hasEntryPoint = !!root_store_default.getApiEntryPoint(apiName);
-			if (!sdkApiEnabled && !hasEntryPoint) {
-				await root_store_default.awaitDiscovery();
-				sdkApiEnabled = root_store_default.sdkApiEnabled;
-				hasEntryPoint = !!root_store_default.getApiEntryPoint(apiName);
-			}
-			const result = sdkApiEnabled || hasEntryPoint ? await sdkRun(runInputs ?? {}) : await legacyRun(runInputs);
-			if (thisRun === runIdRef.current) {
-				setData(result);
-				setError(void 0);
-			}
-			return result;
-		} catch (err) {
-			if (thisRun === runIdRef.current) setError(err);
-			throw err;
-		} finally {
-			if (thisRun === runIdRef.current) setLoading(false);
-		}
-	}, [
-		apiName,
-		sdkRun,
-		legacyRun
-	]);
-	runRef.current = run;
-	const cancel = useCallback(async () => {
-		++runIdRef.current;
-		setLoading(false);
-		setError(void 0);
-		getInflightFetches().delete(inflightKey(apiName, currentFingerprintRef.current ?? ""));
-		if (root_store_default.sdkApiEnabled || !!root_store_default.getApiEntryPoint(apiName)) return sdkCancel();
-		return legacyCancel();
-	}, [
-		apiName,
-		sdkCancel,
-		legacyCancel
-	]);
-	const inputRecord = inputs;
-	const inputFingerprint = inputRecord ? JSON.stringify(Object.entries(inputRecord).sort(([a], [b]) => a.localeCompare(b))) : null;
-	const currentFingerprintRef = useRef(inputFingerprint);
-	currentFingerprintRef.current = inputFingerprint;
-	useEffect(() => {
-		if (!inputRecord || inputFingerprint === null) return;
-		const cacheKey = inflightKey(apiName, inputFingerprint);
-		const inflightPromise = getInflightFetches().get(cacheKey);
-		if (inflightPromise) {
-			incMounts(cacheKey);
-			setLoading(true);
+	return {
+		run: useCallback(async (runInputs) => {
 			const thisRun = ++runIdRef.current;
-			inflightPromise.then((result) => {
-				if (thisRun === runIdRef.current && result !== void 0) {
+			setLoading(true);
+			setError(void 0);
+			setStatus("pending");
+			setVariables(runInputs);
+			try {
+				let sdkApiEnabled = root_store_default.sdkApiEnabled;
+				let hasEntryPoint = !!root_store_default.getApiEntryPoint(apiName);
+				if (!sdkApiEnabled && !hasEntryPoint) {
+					await root_store_default.awaitDiscovery();
+					sdkApiEnabled = root_store_default.sdkApiEnabled;
+					hasEntryPoint = !!root_store_default.getApiEntryPoint(apiName);
+				}
+				const result = sdkApiEnabled || hasEntryPoint ? await sdkRun(runInputs ?? {}) : await legacyRun(runInputs);
+				if (thisRun === runIdRef.current) {
 					setData(result);
 					setError(void 0);
+					setStatus("success");
+				}
+				return result;
+			} catch (thrown) {
+				if (thisRun === runIdRef.current) {
+					setError(thrown);
+					setStatus("error");
 				}
-			}).catch((err) => {
-				if (thisRun === runIdRef.current) setError(err);
-			}).finally(() => {
+				throw thrown;
+			} finally {
 				if (thisRun === runIdRef.current) setLoading(false);
-			});
-			return () => {
-				++runIdRef.current;
-				setLoading(false);
-				decMounts(cacheKey);
-				scheduleInflightCleanup(cacheKey);
-			};
-		}
-		incMounts(cacheKey);
-		let resolveFetch;
-		let rejectFetch;
-		const placeholder = new Promise((resolve, reject) => {
-			resolveFetch = resolve;
-			rejectFetch = reject;
-		});
-		placeholder.catch(() => {});
-		getInflightFetches().set(cacheKey, placeholder);
-		let timerFired = false;
-		const timer = setTimeout(() => {
-			timerFired = true;
-			const fetchResult = runRef.current(inputRecord).catch((err) => {
-				rejectFetch(err);
-			});
-			getInflightFetches().set(cacheKey, placeholder);
-			fetchResult.then((result) => {
-				resolveFetch(result);
-				if (result !== void 0) scheduleInflightCleanup(cacheKey);
-				else if (getInflightFetches().get(cacheKey) === placeholder) getInflightFetches().delete(cacheKey);
-			});
-		}, getFetchDelayMs());
-		return () => {
-			clearTimeout(timer);
-			if (!timerFired) {
-				if (getInflightFetches().get(cacheKey) === placeholder) getInflightFetches().delete(cacheKey);
-				resolveFetch(void 0);
 			}
+		}, [
+			apiName,
+			sdkRun,
+			legacyRun
+		]),
+		cancel: useCallback(async () => {
 			++runIdRef.current;
 			setLoading(false);
-			decMounts(cacheKey);
-		};
-	}, [apiName, inputFingerprint]);
-	return {
-		run,
-		cancel,
+			setError(void 0);
+			setStatus("idle");
+			if (root_store_default.sdkApiEnabled || !!root_store_default.getApiEntryPoint(apiName)) return sdkCancel();
+			return legacyCancel();
+		}, [
+			apiName,
+			sdkCancel,
+			legacyCancel
+		]),
+		reset: useCallback(() => {
+			++runIdRef.current;
+			setLoading(false);
+			setData(void 0);
+			setError(void 0);
+			setStatus("idle");
+			setVariables(void 0);
+		}, []),
 		loading,
 		data,
-		error
+		error,
+		status,
+		variables
 	};
 }
+function useApi(apiName, inputs) {
+	const isDeclarative = inputs !== void 0;
+	const imperativeResult = useApiImperative(apiName);
+	const declarativeResult = useApiData(apiName, inputs ?? {}, {
+		enabled: isDeclarative,
+		refetchOnWindowFocus: false,
+		refetchOnReconnect: false,
+		retry: false
+	});
+	if (isDeclarative) {
+		const imperativeUsed = imperativeResult.status !== "idle";
+		return {
+			run: imperativeResult.run,
+			cancel: async () => {
+				await imperativeResult.cancel();
+				declarativeResult.cancel();
+			},
+			reset: () => {
+				imperativeResult.reset();
+			},
+			loading: imperativeUsed ? imperativeResult.loading : declarativeResult.fetching || declarativeResult.loading,
+			data: imperativeUsed ? imperativeResult.data : declarativeResult.data,
+			error: imperativeUsed ? imperativeResult.error : declarativeResult.error,
+			status: imperativeUsed ? imperativeResult.status : declarativeResult.status,
+			variables: imperativeUsed ? imperativeResult.variables : inputs
+		};
+	}
+	return imperativeResult;
+}
 /**
 * Creates a typed version of useApi bound to a specific API registry type.
 *
@@ -4861,7 +5224,10 @@ const EmbedWrapper$2 = (props) => {
 										executionId,
 										apiName,
 										output: result.output,
-										durationMs
+										durationMs,
+										orchestratorStartMs: result.executionStartMs,
+										orchestratorDurationMs: result.executionDurationMs,
+										fetchStartMs: result.fetchStartMs
 									}
 								});
 								else sendMessageImmediately({
@@ -4873,7 +5239,10 @@ const EmbedWrapper$2 = (props) => {
 											code: "UNKNOWN",
 											message: "API execution failed"
 										},
-										durationMs
+										durationMs,
+										orchestratorStartMs: result.executionStartMs,
+										orchestratorDurationMs: result.executionDurationMs,
+										fetchStartMs: result.fetchStartMs
 									}
 								});
 							}).catch((error$1) => {
@@ -5608,6 +5977,7 @@ async function loadBuildManifest() {
 			root_store_default.clearApiIntegrations();
 			for (const [name, meta] of Object.entries(sdkApis)) {
 				root_store_default.setApiEntryPoint(name, meta.entryPoint);
+				if (meta.exportName) root_store_default.setApiExportName(name, meta.exportName);
 				if (meta.integrations) root_store_default.setApiIntegrations(name, meta.integrations);
 			}
 		} else root_store_default.apis.loadApiManifest(mod.default);
@@ -5768,7 +6138,7 @@ const SbProvider = function SbProvider$1({ name = "codemode", children, classNam
 				value: context$1 ?? void 0,
 				children: isEmbedded ? /* @__PURE__ */ jsx(EmbedWrapper, { children }) : /* @__PURE__ */ jsx(Auth0Wrapper, { children })
 			}), /* @__PURE__ */ jsx(DevTools, {})]
-		}) }), /* @__PURE__ */ jsx(interaction_layer_default, {})]
+		}) }), isEditMode() && /* @__PURE__ */ jsx(interaction_layer_default, {})]
 	});
 };
 var sb_provider_default = SbProvider;
@@ -6997,5 +7367,5 @@ early_console_buffer_default.getInstance().patchEarly();
 registerHtmlElements();
 
 //#endregion
-export { App, PageNotFound, Prop, Property, PropsCategory, RouteLoadError, Section, Superblocks, sb_provider_default as SuperblocksProvider, createElement, embedStore, getAppMode, logoutIntegrations, registerComponent, tailwindStylesCategory, useApi, useApiStateful, useEmbedEvent, useEmbedProperties, useEmitEmbedEvent, useSuperblocksDataTags, useSuperblocksGroups, useSuperblocksProfiles, useSuperblocksUser, useTypedApi };
+export { App, PageNotFound, Prop, Property, PropsCategory, RouteLoadError, Section, Superblocks, sb_provider_default as SuperblocksProvider, createElement, createTypedExecuteApi, embedStore, executeApi, getAppMode, logoutIntegrations, queryClient, registerComponent, tailwindStylesCategory, useApi, useApiData, useApiStateful, useEmbedEvent, useEmbedProperties, useEmitEmbedEvent, useSuperblocksDataTags, useSuperblocksGroups, useSuperblocksProfiles, useSuperblocksUser, useTypedApi, useTypedApiData };
 //# sourceMappingURL=index.js.map