@copilotkit/react-core 1.79.2-canary.1792172552 → 1.81.0

package/dist/MarkdownSurfaces-D-OkjUpU.cjs

@@ -0,0 +1,3807 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let react = require("react");
+react = __toESM(react);
+let _copilotkit_core = require("@copilotkit/core");
+let _copilotkit_shared = require("@copilotkit/shared");
+let _copilotkit_react_core_v2_context = require("@copilotkit/react-core/v2/context");
+let react_jsx_runtime = require("react/jsx-runtime");
+let streamdown = require("streamdown");
+let zod = require("zod");
+let zod_to_json_schema = require("zod-to-json-schema");
+
+//#region src/v2/lib/shallow-stable-ref.ts
+/**
+* Shallow equality comparison for objects.
+*/
+function shallowEqual(obj1, obj2) {
+	const keys1 = Object.keys(obj1);
+	const keys2 = Object.keys(obj2);
+	if (keys1.length !== keys2.length) return false;
+	for (const key of keys1) if (obj1[key] !== obj2[key]) return false;
+	return true;
+}
+/**
+* Returns true only for plain JS objects (`{}`), excluding arrays, Dates,
+* class instances, and other exotic objects that happen to have typeof "object".
+*/
+function isPlainObject(obj) {
+	return obj !== null && typeof obj === "object" && Object.prototype.toString.call(obj) === "[object Object]";
+}
+/**
+* Returns the same reference as long as the value is shallowly equal to the
+* previous render's value.
+*
+* - Identical references bail out immediately (O(1)).
+* - Plain objects ({}) are shallow-compared key-by-key.
+* - Arrays, Dates, class instances, functions, and primitives are compared by
+*   reference only — shallowEqual is never called on non-plain objects, which
+*   avoids incorrect equality for e.g. [1,2] vs [1,2] (different arrays).
+*
+* Typical use: stabilize inline slot props so MemoizedSlotWrapper's shallow
+* equality check isn't defeated by a new object reference on every render.
+*/
+function useShallowStableRef(value) {
+	const ref = (0, react.useRef)(value);
+	if (ref.current === value) return ref.current;
+	if (isPlainObject(ref.current) && isPlainObject(value)) {
+		if (shallowEqual(ref.current, value)) return ref.current;
+	}
+	ref.current = value;
+	return ref.current;
+}
+
+//#endregion
+//#region src/v2/providers/CopilotChatConfigurationProvider.tsx
+const CopilotChatDefaultLabels = {
+	chatInputPlaceholder: "Type a message...",
+	chatInputToolbarStartTranscribeButtonLabel: "Transcribe",
+	chatInputToolbarCancelTranscribeButtonLabel: "Cancel",
+	chatInputToolbarFinishTranscribeButtonLabel: "Finish",
+	chatInputToolbarAddButtonLabel: "Add attachments",
+	chatInputToolbarToolsButtonLabel: "Tools",
+	chatInputToolbarSendButtonLabel: "Send message",
+	chatInputToolbarStopButtonLabel: "Stop",
+	assistantMessageToolbarCopyCodeLabel: "Copy",
+	assistantMessageToolbarCopyCodeCopiedLabel: "Copied",
+	assistantMessageToolbarCopyMessageLabel: "Copy",
+	assistantMessageToolbarInspectorLabel: "View in Inspector",
+	assistantMessageToolbarInspectorDescription: "Open this message in the Inspector",
+	assistantMessageToolbarInspectorLocalOnlyLabel: "Local only",
+	assistantMessageToolbarInspectorLocalOnlyDescription: "Only visible on localhost or loopback hosts in development. Never shown in production.",
+	assistantMessageToolbarInspectorTitle: "CopilotKit Inspector",
+	assistantMessageToolbarInspectorHideLabel: "Hide this icon",
+	assistantMessageToolbarInspectorHideDescription: "Until you reload this page",
+	assistantMessageToolbarThumbsUpLabel: "Good response",
+	assistantMessageToolbarThumbsDownLabel: "Bad response",
+	assistantMessageFeedbackCommentPlaceholder: "Add a comment (optional)",
+	assistantMessageFeedbackCommentSubmitLabel: "Send comment",
+	assistantMessageToolbarReadAloudLabel: "Read aloud",
+	assistantMessageToolbarRegenerateLabel: "Regenerate",
+	userMessageToolbarCopyMessageLabel: "Copy",
+	userMessageToolbarEditMessageLabel: "Edit",
+	userMessageToolbarPreviousBranchLabel: "Previous branch",
+	userMessageToolbarNextBranchLabel: "Next branch",
+	chatDisclaimerText: "AI can make mistakes. Please verify important information.",
+	chatToggleOpenLabel: "Open chat",
+	chatToggleCloseLabel: "Close chat",
+	chatScrollToBottomLabel: "Scroll to bottom",
+	modalHeaderTitle: "CopilotKit Chat",
+	welcomeMessageText: "How can I help you today?"
+};
+/**
+* Mobile breakpoint below which the chat modal and the thread-list drawer are
+* mutually exclusive. At or above this width both surfaces may coexist. This
+* mirrors the `(max-width: 767px)` / `(min-width: 768px)` split already used by
+* CopilotChatInput and CopilotSidebarView.
+*/
+const MOBILE_MAX_WIDTH_PX = 767;
+/**
+* Reports whether the current viewport is in the mobile range (`<768px`), where
+* the chat modal and drawer must not be open simultaneously. SSR-safe and
+* defensive against environments without `matchMedia` (treated as desktop, so
+* no mutual-exclusion constraint is applied).
+*
+* @returns `true` when the viewport is mobile-width, `false` otherwise.
+*/
+function isMobileViewport() {
+	if (typeof window === "undefined" || typeof window.matchMedia !== "function") return false;
+	return window.matchMedia(`(max-width: ${MOBILE_MAX_WIDTH_PX}px)`).matches;
+}
+const CopilotChatConfiguration = (0, react.createContext)(null);
+const CopilotChatConfigurationProvider = ({ children, labels, agentId, threadId, hasExplicitThreadId, isModalDefaultOpen }) => {
+	const parentConfig = (0, react.useContext)(CopilotChatConfiguration);
+	const stableLabels = useShallowStableRef(labels);
+	const mergedLabels = (0, react.useMemo)(() => ({
+		...CopilotChatDefaultLabels,
+		...parentConfig?.labels,
+		...stableLabels
+	}), [stableLabels, parentConfig?.labels]);
+	const providerAgentId = (0, _copilotkit_react_core_v2_context.useDefaultAgentId)();
+	const resolvedAgentId = agentId ?? parentConfig?.agentId ?? providerAgentId ?? _copilotkit_shared.DEFAULT_AGENT_ID;
+	const threadIdPropIsAuthoritative = threadId !== void 0 && hasExplicitThreadId !== false;
+	const isThreadIdControlled = threadIdPropIsAuthoritative;
+	const [activeThreadOverride, setActiveThreadOverride] = (0, react.useState)(null);
+	const resolvedThreadId = (0, react.useMemo)(() => {
+		if (threadIdPropIsAuthoritative) return threadId;
+		if (activeThreadOverride) return activeThreadOverride.threadId;
+		if (parentConfig?.threadId) return parentConfig.threadId;
+		if (threadId) return threadId;
+		return (0, _copilotkit_shared.randomUUID)();
+	}, [
+		threadIdPropIsAuthoritative,
+		threadId,
+		parentConfig?.threadId,
+		activeThreadOverride
+	]);
+	const copilotkit = (0, react.useContext)(_copilotkit_react_core_v2_context.CopilotKitContext)?.copilotkit;
+	const openThreadRef = (0, react.useRef)(null);
+	const latestThreadIdRef = (0, react.useRef)(resolvedThreadId);
+	latestThreadIdRef.current = resolvedThreadId;
+	(0, react.useEffect)(() => {
+		if (copilotkit === void 0) return;
+		const registration = copilotkit.registerOpenThread({
+			agentId: resolvedAgentId,
+			threadId: latestThreadIdRef.current
+		});
+		openThreadRef.current = registration;
+		return () => {
+			registration.unregister();
+			openThreadRef.current = null;
+		};
+	}, [copilotkit, resolvedAgentId]);
+	(0, react.useEffect)(() => {
+		openThreadRef.current?.update(resolvedThreadId);
+	}, [resolvedThreadId]);
+	const resolvedHasExplicitThreadId = (threadIdPropIsAuthoritative ? true : activeThreadOverride?.explicit ?? hasExplicitThreadId ?? false) || !!parentConfig?.hasExplicitThreadId;
+	const [internalModalOpen, setInternalModalOpen] = (0, react.useState)(isModalDefaultOpen ?? true);
+	const hasExplicitDefault = isModalDefaultOpen !== void 0;
+	const setAndSync = (0, react.useCallback)((open) => {
+		setInternalModalOpen(open);
+		parentConfig?.setModalOpen(open);
+	}, [parentConfig?.setModalOpen]);
+	const isMounted = (0, react.useRef)(false);
+	(0, react.useEffect)(() => {
+		if (!hasExplicitDefault) return;
+		if (!isMounted.current) {
+			isMounted.current = true;
+			return;
+		}
+		if (parentConfig?.isModalOpen === void 0) return;
+		setInternalModalOpen(parentConfig.isModalOpen);
+	}, [parentConfig?.isModalOpen, hasExplicitDefault]);
+	const resolvedIsModalOpen = hasExplicitDefault ? internalModalOpen : parentConfig?.isModalOpen ?? internalModalOpen;
+	const resolvedSetModalOpen = hasExplicitDefault ? setAndSync : parentConfig?.setModalOpen ?? setInternalModalOpen;
+	const [ownDrawerOpen, setOwnDrawerOpen] = (0, react.useState)(false);
+	const [ownDrawerCount, setOwnDrawerCount] = (0, react.useState)(0);
+	const modalCloseRef = (0, react.useRef)(() => {});
+	modalCloseRef.current = resolvedSetModalOpen;
+	const registeredModalClosersRef = (0, react.useRef)([]);
+	const ownRegisterModalCloser = (0, react.useCallback)((closeModal) => {
+		registeredModalClosersRef.current.push(closeModal);
+		return () => {
+			registeredModalClosersRef.current = registeredModalClosersRef.current.filter((entry) => entry !== closeModal);
+		};
+	}, []);
+	const ownSetDrawerOpen = (0, react.useCallback)((open) => {
+		setOwnDrawerOpen(open);
+		if (open && isMobileViewport()) {
+			const registered = registeredModalClosersRef.current;
+			(registered.length > 0 ? registered[registered.length - 1] : modalCloseRef.current)(false);
+		}
+	}, []);
+	const ownRegisterDrawer = (0, react.useCallback)(() => {
+		setOwnDrawerCount((count) => count + 1);
+		return () => {
+			setOwnDrawerCount((count) => Math.max(0, count - 1));
+		};
+	}, []);
+	const resolvedDrawerOpen = parentConfig ? parentConfig.drawerOpen : ownDrawerOpen;
+	const resolvedSetDrawerOpen = parentConfig ? parentConfig.setDrawerOpen : ownSetDrawerOpen;
+	const resolvedDrawerRegistered = parentConfig ? parentConfig.drawerRegistered : ownDrawerCount > 0;
+	const resolvedRegisterDrawer = parentConfig ? parentConfig.registerDrawer : ownRegisterDrawer;
+	const resolvedRegisterModalCloser = parentConfig ? parentConfig.ɵregisterModalCloser : ownRegisterModalCloser;
+	(0, react.useEffect)(() => {
+		if (!hasExplicitDefault) return;
+		return resolvedRegisterModalCloser(resolvedSetModalOpen);
+	}, [
+		hasExplicitDefault,
+		resolvedRegisterModalCloser,
+		resolvedSetModalOpen
+	]);
+	const isThreadIdControlledRef = (0, react.useRef)(isThreadIdControlled);
+	isThreadIdControlledRef.current = isThreadIdControlled;
+	const ownSetActiveThreadId = (0, react.useCallback)((id, options) => {
+		setActiveThreadOverride({
+			threadId: id,
+			explicit: options?.explicit ?? true
+		});
+	}, []);
+	const ownStartNewThread = (0, react.useCallback)(() => {
+		setActiveThreadOverride({
+			threadId: (0, _copilotkit_shared.randomUUID)(),
+			explicit: false
+		});
+	}, []);
+	const parentSetActiveThreadId = parentConfig?.setActiveThreadId;
+	const parentStartNewThread = parentConfig?.startNewThread;
+	const resolvedSetActiveThreadId = (0, react.useCallback)((id, options) => {
+		if (isThreadIdControlledRef.current) {
+			console.warn("[CopilotKit] Ignoring setActiveThreadId(): threadId is controlled via the `threadId` prop on CopilotChatConfigurationProvider.");
+			return;
+		}
+		if (parentSetActiveThreadId) {
+			parentSetActiveThreadId(id, options);
+			return;
+		}
+		ownSetActiveThreadId(id, options);
+	}, [parentSetActiveThreadId, ownSetActiveThreadId]);
+	const resolvedStartNewThread = (0, react.useCallback)(() => {
+		if (isThreadIdControlledRef.current) {
+			console.warn("[CopilotKit] Ignoring startNewThread(): threadId is controlled via the `threadId` prop on CopilotChatConfigurationProvider.");
+			return;
+		}
+		if (parentStartNewThread) {
+			parentStartNewThread();
+			return;
+		}
+		ownStartNewThread();
+	}, [parentStartNewThread, ownStartNewThread]);
+	const setModalOpenWithDrawerExclusion = (0, react.useCallback)((open) => {
+		if (open && isMobileViewport()) resolvedSetDrawerOpen(false);
+		resolvedSetModalOpen(open);
+	}, [resolvedSetModalOpen, resolvedSetDrawerOpen]);
+	const configurationValue = (0, react.useMemo)(() => ({
+		labels: mergedLabels,
+		agentId: resolvedAgentId,
+		threadId: resolvedThreadId,
+		hasExplicitThreadId: resolvedHasExplicitThreadId,
+		isModalOpen: resolvedIsModalOpen,
+		setModalOpen: setModalOpenWithDrawerExclusion,
+		drawerOpen: resolvedDrawerOpen,
+		setDrawerOpen: resolvedSetDrawerOpen,
+		drawerRegistered: resolvedDrawerRegistered,
+		registerDrawer: resolvedRegisterDrawer,
+		ɵregisterModalCloser: resolvedRegisterModalCloser,
+		setActiveThreadId: resolvedSetActiveThreadId,
+		startNewThread: resolvedStartNewThread
+	}), [
+		mergedLabels,
+		resolvedAgentId,
+		resolvedThreadId,
+		resolvedHasExplicitThreadId,
+		resolvedIsModalOpen,
+		setModalOpenWithDrawerExclusion,
+		resolvedDrawerOpen,
+		resolvedSetDrawerOpen,
+		resolvedDrawerRegistered,
+		resolvedRegisterDrawer,
+		resolvedRegisterModalCloser,
+		resolvedSetActiveThreadId,
+		resolvedStartNewThread
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotChatConfiguration.Provider, {
+		value: configurationValue,
+		children
+	});
+};
+const useCopilotChatConfiguration = () => {
+	return (0, react.useContext)(CopilotChatConfiguration);
+};
+/**
+* Reports modal open/close requests to the host, and — when `open` is
+* supplied — makes the modal state of an already-established chat
+* configuration **controlled** for the subtree it wraps.
+*
+* This is deliberately a scope component rather than another mode inside
+* {@link CopilotChatConfigurationProvider}. The provider resolves modal state
+* across a nested chain (own state, parent sync, drawer mutual-exclusion, the
+* modal-closer registry); a controlled branch inside that resolution would add
+* a fourth interacting mode. Overriding the context for the subtree instead
+* leaves every one of those paths untouched:
+*
+* - `isModalOpen` is replaced with the host's `open`, so the rendered surface
+*   follows the prop from the very first frame (no open-then-close flash).
+* - `setModalOpen` still calls the underlying setter, so the existing
+*   parent-sync and drawer mutual-exclusion side effects continue to run, and
+*   *then* reports the request through `onOpenChange`.
+* - The wrapped setter is registered as the modal closer, so the drawer's
+*   mobile mutual-exclusion reaches the host instead of silently flipping
+*   state that nothing displays.
+*
+* A host that supplies `open` and ignores `onOpenChange` gets a modal pinned
+* to `open`, which is the standard controlled-component contract. A host that
+* supplies only `onOpenChange` is notified while the modal keeps managing
+* itself.
+*
+* Renders `children` unchanged when no chat configuration is in scope.
+*/
+const ControlledModalOpenScope = ({ children, open, onOpenChange }) => {
+	const parentConfig = (0, react.useContext)(CopilotChatConfiguration);
+	const parentSetModalOpen = parentConfig?.setModalOpen;
+	const registerModalCloser = parentConfig?.ɵregisterModalCloser;
+	const setModalOpen = (0, react.useCallback)((next) => {
+		parentSetModalOpen?.(next);
+		onOpenChange?.(next);
+	}, [parentSetModalOpen, onOpenChange]);
+	(0, react.useEffect)(() => {
+		if (!registerModalCloser) return;
+		return registerModalCloser(setModalOpen);
+	}, [registerModalCloser, setModalOpen]);
+	const configurationValue = (0, react.useMemo)(() => parentConfig ? {
+		...parentConfig,
+		isModalOpen: open ?? parentConfig.isModalOpen,
+		setModalOpen
+	} : null, [
+		parentConfig,
+		open,
+		setModalOpen
+	]);
+	if (!configurationValue) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children });
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotChatConfiguration.Provider, {
+		value: configurationValue,
+		children
+	});
+};
+ControlledModalOpenScope.displayName = "ControlledModalOpenScope";
+
+//#endregion
+//#region src/v2/hooks/useKatexStyles.ts
+let injected = false;
+/**
+* Dynamically injects KaTeX CSS at runtime to avoid the Next.js
+* "Global CSS cannot be imported from within node_modules" build error.
+*
+* Uses a singleton flag so the stylesheet is only injected once.
+*/
+function useKatexStyles() {
+	(0, react.useEffect)(() => {
+		if (injected || typeof document === "undefined") return;
+		injected = true;
+		import("katex/dist/katex.min.css").catch(() => {
+			console.warn("[CopilotKit] Failed to load katex styles — math content may render without formatting");
+		});
+	}, []);
+}
+
+//#endregion
+//#region src/v2/types/defineToolCallRenderer.ts
+function defineToolCallRenderer(def) {
+	const argsSchema = def.name === "*" && !def.args ? zod.z.any() : def.args;
+	return {
+		name: def.name,
+		args: argsSchema,
+		render: def.render,
+		...def.agentId ? { agentId: def.agentId } : {},
+		...def.group ? { group: true } : {}
+	};
+}
+
+//#endregion
+//#region src/v2/generative-ui/json-schema.ts
+/**
+* JSON Schema for a Standard Schema (zod v3 via zod-to-json-schema),
+* inlined, no `$schema`. A prop marked by `child()` or `childList()`
+* becomes an A2UI `$ref` to `ComponentId` or `ChildList`.
+*/
+function toJsonSchema(schema) {
+	const { $schema: _omit, ...rest } = (0, _copilotkit_shared.schemaToJsonSchema)(schema, { zodToJsonSchema: (s) => (0, zod_to_json_schema.zodToJsonSchema)(s, { $refStrategy: "none" }) });
+	return (0, _copilotkit_shared.applyChildRefMarks)(rest);
+}
+
+//#endregion
+//#region src/v2/generative-ui/catalog.ts
+/** The A2UI component envelope: `id`, `component`, `catalogId`, `accessibility`, `metadata`. */
+const RESERVED_KEYS = new Set([
+	"id",
+	"component",
+	..._copilotkit_shared.A2UI_COMPONENT_ENVELOPE_KEYS
+]);
+/** The id of the catalog that declared each component, for the inspector. */
+const componentCatalogs = /* @__PURE__ */ new WeakMap();
+/**
+* The id of the catalog that declared each component of `ui`. A component
+* from `extends` keeps the id of its base. Not exported from the package.
+*/
+function componentCatalogIds(ui) {
+	return componentCatalogs.get(ui) ?? /* @__PURE__ */ new Map();
+}
+/**
+* The catalogs that an operation can name: the id of `ui`, then the ids of
+* the catalogs in its `extends` that declared a component. Not exported
+* from the package.
+*/
+function catalogIdsOf(ui) {
+	const declared = componentCatalogs.get(ui)?.values() ?? [];
+	return [...new Set([ui.id, ...declared])];
+}
+/**
+* Experimental. Declares the components the model can render, the app state
+* they read, and the functions they call.
+*
+* - A prop with the name of a top-level state key is bound to that state.
+* - `bind: { prop: (state, props) => value }` binds a prop to a selector.
+* - An event binds to the function with its name, else to the name without
+*   `on` (`onAddToCart` calls `addToCart`).
+* - `writable: ["value"]` gives the component a `setValue` prop. See
+*   `GenerativeUIComponentDefinition.writable`.
+*
+* The model does not see bound props or matched events.
+*
+* @param config - `id`, then optional `extends`, `state`, `functions` and
+*   `overrides`, then `components`. Put `state` before `components`, so the selectors
+*   get typed state.
+* @throws Error when a name comes from two places, an override names no
+*   component of the bases, `props` is not an object
+*   schema with a JSON Schema, a key is reserved or used
+*   twice on a component, an event matches two functions, an unmatched event
+*   has no `parameters`, a `bind` key is not a prop, a `writable` key is not
+*   a prop or is a bound prop, or a setter name is already a key of the
+*   component. Also throws when `parameterOrder` contains duplicate or unknown
+*   keys, or an ordered component declares integer-index keys whose JSON object
+*   enumeration order cannot be controlled.
+*
+* @example
+* ```ts
+* const ui = createGenerativeUI({
+*   id: "acme/store@1",
+*   state: { cart: cartSchema },
+*   functions: { addToCart: { parameters: z.object({ productId: z.string() }) } },
+*   components: {
+*     CartSummary: {
+*       component: CartSummary,
+*       props: z.object({ count: z.number() }),
+*       bind: { count: (state) => state.cart.count },
+*     },
+*   },
+* });
+* ```
+*/
+function createGenerativeUI(config) {
+	return buildGenerativeUI(config);
+}
+function buildGenerativeUI(config) {
+	const where = `generative UI "${config.id}"`;
+	const state = /* @__PURE__ */ new Map();
+	const functions = /* @__PURE__ */ new Map();
+	const definitions = /* @__PURE__ */ new Map();
+	const catalogs = /* @__PURE__ */ new Map();
+	function add(map, kind, name, value) {
+		if (map.has(name)) throw new Error(`[generativeUI] ${kind} "${name}" is defined more than once in ${where}.`);
+		map.set(name, value);
+	}
+	const bases = config.extends ?? [];
+	for (const base of bases) {
+		for (const [name, schema] of base.state) add(state, "State key", name, schema);
+		for (const [name, fn] of base.functions) add(functions, "Function", name, fn);
+		const baseCatalogs = componentCatalogIds(base);
+		for (const [name, component] of base.components) {
+			add(definitions, "Component", name, component);
+			catalogs.set(name, baseCatalogs.get(name) ?? base.id);
+		}
+	}
+	for (const [name, override] of Object.entries(config.overrides ?? {})) {
+		const base = definitions.get(name);
+		if (!base) throw new Error(`[generativeUI] Override "${name}" is not a component of the bases of ${where}.`);
+		definitions.set(name, {
+			...base,
+			component: override.component
+		});
+	}
+	for (const [name, schema] of Object.entries(config.state ?? {})) add(state, "State key", name, schema);
+	for (const [name, fn] of Object.entries(config.functions ?? {})) add(functions, "Function", name, fn);
+	for (const [name, fn] of functions) if (fn.requiresUserActivation === true && fn.allowedCallers !== void 0 && fn.allowedCallers !== "rendererOnly") throw new Error(`[generativeUI] Function "${name}" in ${where} requires user activation, so its allowedCallers must be "rendererOnly", not "${fn.allowedCallers}".`);
+	for (const [name, component] of Object.entries(config.components)) {
+		add(definitions, "Component", name, component);
+		catalogs.set(name, config.id);
+	}
+	const components = /* @__PURE__ */ new Map();
+	const manifestComponents = {};
+	for (const [name, definition] of definitions) {
+		const { component, manifest } = resolveComponent(name, definition, {
+			state,
+			functions,
+			where
+		});
+		components.set(name, component);
+		manifestComponents[name] = manifest;
+	}
+	return withOmit({
+		id: config.id,
+		state,
+		functions,
+		components,
+		manifestComponents
+	}, catalogs);
+}
+/** Adds the `omit` method to the data of a generative UI. */
+function withOmit(data, catalogs) {
+	const omit = (names) => {
+		for (const name of names) if (!data.components.has(name)) throw new Error(`[generativeUI] Cannot omit "${name}": it is not a component of generative UI "${data.id}".`);
+		const isKept = (name) => !names.includes(name);
+		return withOmit({
+			id: data.id,
+			state: data.state,
+			functions: data.functions,
+			components: new Map([...data.components].filter(([name]) => isKept(name))),
+			manifestComponents: Object.fromEntries(Object.entries(data.manifestComponents).filter(([name]) => isKept(name)))
+		}, catalogs);
+	};
+	const ui = {
+		...data,
+		omit
+	};
+	componentCatalogs.set(ui, catalogs);
+	return ui;
+}
+/** Builds the selectors, the event map and the manifest of one component. */
+function resolveComponent(name, definition, context) {
+	const propsJson = propsJsonSchema(name, definition, context.where);
+	const propKeys = Object.keys(propsJson.properties);
+	assertDisjointKeys(name, definition, propKeys);
+	assertParameterOrder(name, definition, propKeys);
+	const selectors = {};
+	for (const key of propKeys) if (context.state.has(key)) selectors[key] = (state) => state[key];
+	const bind = definition.bind ?? {};
+	for (const [key, selector] of Object.entries(bind)) {
+		if (!propKeys.includes(key)) throw new Error(`[generativeUI] bind key "${key}" is not a prop of component "${name}" in ${context.where}.`);
+		selectors[key] = selector;
+	}
+	const eventFunctions = {};
+	const modelEvents = {};
+	const events = definition.events ?? {};
+	for (const [eventName, event] of Object.entries(events)) {
+		const functionName = matchFunction(eventName, name, context);
+		if (functionName !== void 0) {
+			const matched = context.functions.get(functionName);
+			if (matched && !(0, _copilotkit_shared.functionCallers)(matched).renderer) throw new Error(`[generativeUI] Event "${eventName}" of component "${name}" matches function "${functionName}", which the UI cannot call (allowedCallers "agentOnly") in ${context.where}.`);
+			eventFunctions[eventName] = functionName;
+			continue;
+		}
+		if (!event.parameters) throw new Error(`[generativeUI] Event "${eventName}" of component "${name}" matches no function in ${context.where}, so it needs "parameters".`);
+		modelEvents[eventName] = {
+			...event.description ? { description: event.description } : {},
+			parameters: toJsonSchema(event.parameters)
+		};
+	}
+	assertWritable(name, definition, propKeys, selectors, context.where);
+	return {
+		component: {
+			component: definition.component,
+			description: definition.description,
+			parameterOrder: definition.parameterOrder?.slice(),
+			props: definition.props,
+			bind: definition.bind,
+			events: definition.events,
+			slots: definition.slots,
+			writable: definition.writable,
+			accessibility: definition.accessibility ?? "wrapper",
+			selectors,
+			eventFunctions,
+			propKeys,
+			childRefs: (0, _copilotkit_shared.collectChildRefs)(propsJson)
+		},
+		manifest: toManifest(definition, modelPropsJsonSchema(propsJson, selectors), modelEvents)
+	};
+}
+/** The JSON Schema of `props`. A component without `props` has none. */
+function propsJsonSchema(name, definition, where) {
+	if (!definition.props) return {
+		type: "object",
+		properties: {}
+	};
+	const json = toJsonSchema(definition.props);
+	const { properties } = json;
+	if (!(typeof properties === "object" && properties !== null && !Array.isArray(properties))) throw new Error(`[generativeUI] the props of component "${name}" in ${where} must be an object schema.`);
+	return json;
+}
+/**
+* What the model sees of the props: the JSON Schema without the bound props,
+* and with no other keys allowed.
+*/
+function modelPropsJsonSchema(json, bound) {
+	const isModelKey = (key) => !Object.hasOwn(bound, key);
+	const { properties, required, additionalProperties: _additionalProperties, ...rest } = json;
+	const modelRequired = Array.isArray(required) ? required.filter((key) => isModelKey(String(key))) : [];
+	return {
+		...rest,
+		type: "object",
+		properties: Object.fromEntries(Object.entries(properties).filter(([key]) => isModelKey(key))),
+		...modelRequired.length > 0 ? { required: modelRequired } : {},
+		additionalProperties: false
+	};
+}
+/** `onAddToCart` to `addToCart`. `undefined` when the name has no `on` prefix. */
+function withoutOnPrefix(eventName) {
+	if (!(eventName.length > 2 && eventName.startsWith("on"))) return void 0;
+	return eventName.charAt(2).toLowerCase() + eventName.slice(3);
+}
+/** The declared function an event calls, or `undefined` when none matches. */
+function matchFunction(eventName, componentName, context) {
+	const exact = context.functions.has(eventName) ? eventName : void 0;
+	const stripped = withoutOnPrefix(eventName);
+	const fromPrefix = stripped !== void 0 && context.functions.has(stripped) ? stripped : void 0;
+	if (exact !== void 0 && fromPrefix !== void 0) throw new Error(`[generativeUI] Event "${eventName}" of component "${componentName}" matches two functions, "${exact}" and "${fromPrefix}", in ${context.where}.`);
+	return exact ?? fromPrefix;
+}
+/** The setter prop of a writable prop: `value` gives `setValue`. */
+function setterNameOf(key) {
+	return `set${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+}
+/** Why a `writable` key is not valid, or `undefined` when it is valid. */
+function writableProblem(key, definition, propKeys, selectors) {
+	if (Object.hasOwn(definition.events ?? {}, key)) return "an event";
+	if (Object.hasOwn(definition.slots ?? {}, key)) return "a slot";
+	if (!propKeys.includes(key)) return "not a prop";
+	if (Object.hasOwn(selectors, key)) return "a bound prop";
+}
+function assertWritable(name, definition, propKeys, selectors, where) {
+	const writable = definition.writable ?? [];
+	const keys = new Set([
+		...propKeys,
+		...Object.keys(definition.events ?? {}),
+		...Object.keys(definition.slots ?? {})
+	]);
+	for (const key of writable) {
+		const problem = writableProblem(key, definition, propKeys, selectors);
+		if (problem) throw new Error(`[generativeUI] writable key "${key}" of component "${name}" is ${problem} in ${where}.`);
+		const setter = setterNameOf(key);
+		if (keys.has(setter)) throw new Error(`[generativeUI] the setter "${setter}" of writable key "${key}" is already a key of component "${name}" in ${where}.`);
+	}
+}
+function assertDisjointKeys(name, definition, propKeys) {
+	const seen = /* @__PURE__ */ new Set();
+	const keys = [
+		...propKeys,
+		...Object.keys(definition.events ?? {}),
+		...Object.keys(definition.slots ?? {})
+	];
+	for (const key of keys) {
+		if (RESERVED_KEYS.has(key)) throw new Error(`[generativeUI] "${key}" is reserved by A2UI and cannot be a prop, event or slot of component "${name}".`);
+		if (seen.has(key)) throw new Error(`[generativeUI] "${key}" is declared as more than one of prop, event, slot on component "${name}".`);
+		seen.add(key);
+	}
+}
+function assertParameterOrder(name, definition, propKeys) {
+	const order = definition.parameterOrder;
+	if (order === void 0) return;
+	const keys = new Set([
+		...propKeys,
+		...Object.keys(definition.slots ?? {}),
+		...Object.keys(definition.events ?? {})
+	]);
+	if ([...keys].some((key) => {
+		const index = Number(key);
+		return Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === key;
+	})) throw new Error(`[generativeUI] Component "${name}" with parameterOrder cannot declare integer-index keys: JSON object enumeration sorts them numerically before other keys, ignoring the requested order.`);
+	if (!Array.isArray(order) || new Set(order).size !== order.length || order.some((key) => !keys.has(key))) throw new Error(`[generativeUI] parameterOrder of component "${name}" must contain unique declared prop, slot or event names.`);
+}
+function toManifest(definition, modelProps, modelEvents) {
+	const manifest = { props: modelProps };
+	if (definition.description) manifest.description = definition.description;
+	if (Object.keys(modelEvents).length > 0) manifest.events = modelEvents;
+	if (definition.slots) manifest.slots = { ...definition.slots };
+	if (definition.parameterOrder !== void 0) {
+		const visible = new Set([
+			...Object.keys(modelProps.properties ?? {}),
+			...Object.keys(definition.slots ?? {}),
+			...Object.keys(modelEvents)
+		]);
+		manifest.parameterOrder = [...new Set([...definition.parameterOrder.filter((key) => visible.has(key)), ...visible])];
+	}
+	return manifest;
+}
+
+//#endregion
+//#region src/v2/generative-ui/is-record.ts
+/** True for a plain object: not null, not an array. Internal, not exported. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/v2/generative-ui/errors.ts
+var GenerativeUIError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.name = "GenerativeUIError";
+		this.code = code;
+	}
+};
+
+//#endregion
+//#region src/v2/generative-ui/functions.ts
+/**
+* The renderer-side functions of the A2UI 1.0 basic catalog. Each one takes
+* resolved args (no bindings left in them) and gives a plain value. They
+* run synchronously, so a prop bound to one updates in the same render as
+* the data it reads. The signatures the model sees are in
+* `@copilotkit/shared` (`A2UI_BASIC_FUNCTIONS`).
+*/
+/** Thrown for a bad call: an unknown function, bad args, or a bad value. */
+var ExpressionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ExpressionError";
+	}
+};
+/** The boolean of a DynamicBoolean: a ValidationResult counts as `valid`. */
+function truthOf(value) {
+	if ((0, _copilotkit_shared.isValidationResult)(value)) return value.valid;
+	return Boolean(value);
+}
+const valid = () => ({ valid: true });
+/** A failed result. `code` names the failure, the same for every locale. */
+const invalid = (message, code) => ({
+	valid: false,
+	message,
+	code
+});
+function text(value) {
+	if (value === void 0 || value === null) return "";
+	return typeof value === "string" ? value : String(value);
+}
+function numberOf$1(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "string" && value.trim() !== "") return Number(value);
+	return NaN;
+}
+function optionalNumber(value, name) {
+	if (value === void 0 || value === null) return void 0;
+	const parsed = numberOf$1(value);
+	if (Number.isNaN(parsed)) throw new ExpressionError(`${name} must be a number`);
+	return parsed;
+}
+const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+/** The locale of the user. `undefined` lets Intl pick the default. */
+function locale() {
+	return typeof navigator !== "undefined" ? navigator.language : void 0;
+}
+function numberFormat(args, options) {
+	const decimals = optionalNumber(args.decimals, "decimals");
+	return new Intl.NumberFormat(locale(), {
+		...options,
+		useGrouping: args.grouping !== false,
+		...decimals === void 0 ? {} : {
+			minimumFractionDigits: decimals,
+			maximumFractionDigits: decimals
+		}
+	});
+}
+/** A date from an ISO string, a timestamp, or a Date. */
+function dateOf(value) {
+	const date = value instanceof Date ? value : typeof value === "number" ? new Date(value) : typeof value === "string" ? new Date(/^\d{4}-\d{2}-\d{2}$/.test(value) ? `${value}T00:00` : value) : void 0;
+	if (date === void 0 || Number.isNaN(date.getTime())) throw new ExpressionError("value must be a date");
+	return date;
+}
+const pad = (value, width) => String(value).padStart(width, "0");
+/**
+* A TR35 field is a run of one letter ("EEE" is one abbreviated weekday,
+* not three), and text in single quotes is literal. Letters that are not
+* fields stay as they are.
+*/
+const DATE_FIELD = /([A-Za-z])\1*|'(?:[^']|'')*'/g;
+function formatDatePattern(date, pattern) {
+	const parts = (options) => new Intl.DateTimeFormat(locale(), options).format(date);
+	const hours12 = date.getHours() % 12 || 12;
+	const numeric = (value, width) => width >= 2 ? pad(value, 2) : String(value);
+	return pattern.replace(DATE_FIELD, (token) => {
+		if (token.startsWith("'")) return token.slice(1, -1).replace(/''/g, "'");
+		const width = token.length;
+		switch (token[0]) {
+			case "y": return width === 2 ? pad(date.getFullYear() % 100, 2) : String(date.getFullYear());
+			case "M":
+				if (width >= 4) return parts({ month: "long" });
+				if (width === 3) return parts({ month: "short" });
+				return numeric(date.getMonth() + 1, width);
+			case "d": return numeric(date.getDate(), width);
+			case "E": return parts({ weekday: width >= 4 ? "long" : "short" });
+			case "H": return numeric(date.getHours(), width);
+			case "h": return numeric(hours12, width);
+			case "m": return pad(date.getMinutes(), 2);
+			case "s": return pad(date.getSeconds(), 2);
+			case "a": return date.getHours() < 12 ? "AM" : "PM";
+			default: return token;
+		}
+	});
+}
+/** Opens an http(s) URL in a new tab. Any other scheme is refused. */
+function openUrlSafely(url) {
+	if (typeof url !== "string" || url === "") throw new ExpressionError("url must be a string");
+	if (typeof window === "undefined") return;
+	let parsed;
+	try {
+		parsed = new URL(url, window.location.href);
+	} catch {
+		throw new ExpressionError(`"${url}" is not a URL`);
+	}
+	if (parsed.protocol !== "https:" && parsed.protocol !== "http:") throw new ExpressionError(`openUrl takes only http(s) URLs, not ${parsed.protocol}`);
+	window.open(parsed.href, "_blank", "noopener,noreferrer");
+}
+/**
+* The basic functions, except `formatString`, which needs the resolver.
+* `calc` and `series` are added by `resolve.ts`, which imports both.
+*/
+const BASIC_FUNCTIONS = {
+	required: ({ value }) => {
+		return value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0 ? invalid("Required", "required") : valid();
+	},
+	regex: ({ value, pattern }) => {
+		if (typeof pattern !== "string") throw new ExpressionError("pattern must be a string");
+		let expression;
+		try {
+			expression = new RegExp(pattern, "u");
+		} catch {
+			throw new ExpressionError(`"${pattern}" is not a regular expression`);
+		}
+		return expression.test(text(value)) ? valid() : invalid("Invalid format", "pattern");
+	},
+	length: ({ value, min, max }) => {
+		const size = text(value).length;
+		const low = optionalNumber(min, "min");
+		const high = optionalNumber(max, "max");
+		if (low !== void 0 && size < low) return invalid(`At least ${low} characters`, "tooShort");
+		if (high !== void 0 && size > high) return invalid(`At most ${high} characters`, "tooLong");
+		return valid();
+	},
+	numeric: ({ value, min, max }) => {
+		const parsed = numberOf$1(value);
+		if (Number.isNaN(parsed)) return invalid("Must be a number", "notANumber");
+		const low = optionalNumber(min, "min");
+		const high = optionalNumber(max, "max");
+		if (low !== void 0 && parsed < low) return invalid(`At least ${low}`, "tooSmall");
+		if (high !== void 0 && parsed > high) return invalid(`At most ${high}`, "tooLarge");
+		return valid();
+	},
+	email: ({ value }) => EMAIL.test(text(value)) ? valid() : invalid("Invalid email address", "email"),
+	formatNumber: (args) => {
+		const parsed = numberOf$1(args.value);
+		if (Number.isNaN(parsed)) throw new ExpressionError("value must be a number");
+		return numberFormat(args, {}).format(parsed);
+	},
+	formatCurrency: (args) => {
+		const parsed = numberOf$1(args.value);
+		if (Number.isNaN(parsed)) throw new ExpressionError("value must be a number");
+		if (typeof args.currency !== "string" || args.currency === "") throw new ExpressionError("currency must be an ISO 4217 code");
+		try {
+			return numberFormat(args, {
+				style: "currency",
+				currency: args.currency
+			}).format(parsed);
+		} catch {
+			throw new ExpressionError(`"${args.currency}" is not a currency code`);
+		}
+	},
+	formatDate: ({ value, format }) => {
+		if (typeof format !== "string") throw new ExpressionError("format must be a string");
+		return formatDatePattern(dateOf(value), format);
+	},
+	pluralize: (args) => {
+		const parsed = numberOf$1(args.value);
+		if (Number.isNaN(parsed)) throw new ExpressionError("value must be a number");
+		const category = new Intl.PluralRules(locale()).select(parsed);
+		return text((parsed === 0 ? args.zero : void 0) ?? args[category] ?? args.other);
+	},
+	and: ({ values }) => {
+		if (!Array.isArray(values)) throw new ExpressionError("values must be a list");
+		return values.every(truthOf);
+	},
+	or: ({ values }) => {
+		if (!Array.isArray(values)) throw new ExpressionError("values must be a list");
+		return values.some(truthOf);
+	},
+	not: ({ value }) => !truthOf(value),
+	openUrl: ({ url }) => {
+		openUrlSafely(url);
+	}
+};
+/** True when the basic function `name` must run from a user gesture. */
+function requiresUserActivation(name) {
+	return _copilotkit_shared.GENERATIVE_UI_FUNCTIONS[name]?.requiresUserActivation === true;
+}
+/** True when a basic function gives a ValidationResult. */
+function givesValidationResult(name) {
+	return _copilotkit_shared.GENERATIVE_UI_FUNCTIONS[name]?.returnType === "validationResult";
+}
+
+//#endregion
+//#region src/v2/generative-ui/markdown/source.ts
+/**
+* Values by key, from the latest build. A value that a build does not use
+* is dropped at the end of that build, so the cache does not grow.
+*/
+var BuildMemo = class {
+	constructor() {
+		this.previous = /* @__PURE__ */ new Map();
+		this.current = /* @__PURE__ */ new Map();
+	}
+	/**
+	* The value of `key`. It is computed when no earlier value is there, or
+	* when `isFresh` says that the earlier value is out of date.
+	*/
+	get(key, compute, isFresh = () => true) {
+		let value = this.current.get(key) ?? this.previous.get(key);
+		if (value === void 0 || !isFresh(value)) value = compute();
+		this.current.set(key, value);
+		return value;
+	}
+	endBuild() {
+		this.previous = this.current;
+		this.current = /* @__PURE__ */ new Map();
+	}
+};
+/** The results of the builds of one thread. See `BuildMarkdownSurfacesOptions.cache`. */
+var MarkdownBuildCache = class {
+	constructor() {
+		this.segments = new BuildMemo();
+		this.fences = new BuildMemo();
+		this.drafts = new BuildMemo();
+		this.readdressed = /* @__PURE__ */ new WeakMap();
+	}
+	endBuild() {
+		this.segments.endBuild();
+		this.fences.endBuild();
+		this.drafts.endBuild();
+	}
+};
+/** True when both lists hold the same objects in the same order. */
+function sameItems(a, b) {
+	return a.length === b.length && a.every((item, index) => item === b[index]);
+}
+function isString(value) {
+	return typeof value === "string";
+}
+/** The key of one fence of one message. */
+function fenceKey(messageId, fenceIndex) {
+	return `${messageId}:${fenceIndex}`;
+}
+/**
+* The operations of a fence body. While the fence streams, the last object
+* can be unfinished. Of an unfinished updateComponents or createSurface, the
+* components that are complete render at once (a createSurface also keeps
+* its data model when all of it arrived). Any other unfinished object is
+* left out, because a part of a data model value can still change. A final
+* fence keeps what can be saved from an unfinished object.
+*/
+function fenceOperations(text, isStreaming) {
+	const parsed = (0, _copilotkit_core.extractFenceOperations)(text);
+	if (!isStreaming || parsed.partialObject === null) return parsed.operations;
+	const complete = (0, _copilotkit_core.extractFenceOperations)(text.slice(0, text.length - parsed.partialObject.length)).operations;
+	const partial = parsed.operations.length > complete.length ? parsed.operations[parsed.operations.length - 1] : void 0;
+	return partial !== void 0 && (isRecord(partial.updateComponents) || isRecord(partial.createSurface)) ? [...complete, partial] : complete;
+}
+/**
+* An inline createSurface becomes a createSurface with only its surfaceId
+* and catalog, then an updateDataModel for its data model, then an
+* updateComponents for its components. The prose lift and the split per
+* component read only updateComponents, so they then work for an inline
+* surface too. A createSurface with a data model or components of a wrong
+* shape does not change, so that validation rejects it with the reason.
+*/
+function expandInlineCreate(operations) {
+	return operations.flatMap((op) => {
+		const create = op.createSurface;
+		if (!isRecord(create)) return [op];
+		const { dataModel, components, ...rest } = create;
+		const hasData = isRecord(dataModel);
+		const hasComponents = Array.isArray(components) && components.length > 0;
+		if (!((dataModel === void 0 || hasData) && (components === void 0 || hasComponents)) || !hasData && !hasComponents) return [op];
+		const { surfaceId } = create;
+		const expanded = [{
+			...op,
+			createSurface: rest
+		}];
+		if (hasData) expanded.push({
+			version: op.version,
+			updateDataModel: {
+				surfaceId,
+				path: "/",
+				value: dataModel
+			}
+		});
+		if (hasComponents) expanded.push({
+			version: op.version,
+			updateComponents: {
+				surfaceId,
+				components
+			}
+		});
+		return expanded;
+	});
+}
+/**
+* Each updateComponents becomes one operation per component, in order. The
+* complete components of a streaming line then give the same first
+* operations as the finished line, so the operation list only grows and the
+* manager never has to start the surface again.
+*/
+function splitComponentUpdates(operations) {
+	return operations.flatMap((op) => {
+		const update = op.updateComponents;
+		if (!isRecord(update) || !Array.isArray(update.components)) return [op];
+		if (update.components.length <= 1) return [op];
+		return update.components.map((component) => ({
+			...op,
+			updateComponents: {
+				...update,
+				components: [component]
+			}
+		}));
+	});
+}
+/** createSurface first, the other operations after it in their order. */
+function createSurfaceFirst(operations) {
+	const creates = operations.filter((op) => isRecord(op.createSurface));
+	const others = operations.filter((op) => !isRecord(op.createSurface));
+	return [...creates, ...others];
+}
+/** True when the component of `name` has the prop `prop`. */
+function hasProp(ui, name, prop) {
+	const properties = ui.manifestComponents[name]?.props.properties;
+	return isRecord(properties) && Object.hasOwn(properties, prop);
+}
+const childRefCache = /* @__PURE__ */ new WeakMap();
+/** The ids in a slot value: an id, a list of ids, or a template. */
+function slotIds(value) {
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value)) return value.filter(isString);
+	return isRecord(value) && isString(value.componentId) ? [value.componentId] : [];
+}
+/**
+* A reader of the ids a component renders beyond `child` and `children`:
+* its declared slots (the `trigger` and `content` of a Modal) and its typed
+* child references (the `child` of each entry of `tabs`), from its catalog
+* entry. The prose lift follows these ids like `children`, so a panel is
+* never cut off from its Tabs. A reference that is bound to the data
+* model is "unknown": its ids exist only at render time.
+*/
+function childIdsReader(ui) {
+	return (component) => {
+		const name = component.component;
+		const entry = typeof name === "string" && Object.hasOwn(ui.manifestComponents, name) ? ui.manifestComponents[name] : void 0;
+		if (!entry) return [];
+		const ids = [];
+		for (const slot of Object.keys(entry.slots ?? {})) if (slot !== "child" && slot !== "children") ids.push(...slotIds(component[slot]));
+		let refs = childRefCache.get(entry.props);
+		if (!refs) {
+			refs = (0, _copilotkit_shared.collectChildRefs)(entry.props);
+			childRefCache.set(entry.props, refs);
+		}
+		if (refs.length === 0) return ids;
+		if ((0, _copilotkit_shared.hasBoundChildRef)(component, refs)) return "unknown";
+		return [...ids, ...(0, _copilotkit_shared.childIdsAtRefs)(component, refs)];
+	};
+}
+/** Every component of the operations by id, last definition wins. */
+function collectComponents(operations) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const op of operations) {
+		const update = op.updateComponents;
+		const list = isRecord(update) ? update.components : void 0;
+		if (!Array.isArray(list)) continue;
+		for (const component of list) if (isRecord(component) && isString(component.id)) byId.set(component.id, component);
+	}
+	return [...byId.values()];
+}
+/**
+* The data model must not be shared between two surfaces. A data model
+* keeps the object it gets, so an input in one surface would change the
+* data of the other one.
+*/
+function cloneData(value) {
+	return value === void 0 ? void 0 : structuredClone(value);
+}
+/** The operation sent to `surfaceId`, with a copy of its data model value. */
+function readdress(op, surfaceId) {
+	const kind = (0, _copilotkit_shared.getOperationKind)(op);
+	const payload = kind ? op[kind] : void 0;
+	if (!kind || !isRecord(payload)) return op;
+	const next = {
+		...payload,
+		surfaceId
+	};
+	if (kind === "updateDataModel" && "value" in payload) next.value = cloneData(payload.value);
+	return {
+		...op,
+		[kind]: next
+	};
+}
+/**
+* The operations of one sub-surface. Each updateComponents keeps only the
+* components of the sub-surface, with its own root. The other operations
+* are sent to the sub-surface. The order stays the same, so a new operation
+* of the fence only adds operations at the end.
+*/
+function subSurfaceOperations(operations, components, surfaceId) {
+	const root = components.find((c) => c.id === _copilotkit_shared.GENERATIVE_UI_ROOT_ID);
+	const ids = new Set(components.map((c) => c.id));
+	const out = [];
+	for (const op of operations) {
+		const update = op.updateComponents;
+		if (!isRecord(update) || !Array.isArray(update.components)) {
+			out.push(readdress(op, surfaceId));
+			continue;
+		}
+		const kept = update.components.filter((c) => isRecord(c) && ids.has(c.id)).map((c) => isRecord(c) && c.id === _copilotkit_shared.GENERATIVE_UI_ROOT_ID ? root : c);
+		if (kept.length === 0) continue;
+		out.push({
+			...op,
+			updateComponents: {
+				...update,
+				surfaceId,
+				components: kept
+			}
+		});
+	}
+	return out;
+}
+/**
+* Prose lift. Text components in the main stack of the surface (titles,
+* paragraphs, text lists and the dividers between them) become chat
+* markdown. The surface splits around them: the first surface keeps
+* `surfaceId`, the next ones are `<surfaceId>#1`, `<surfaceId>#2`, and so
+* on. A surface with no prose comes back as one part with the same
+* operations.
+*/
+function liftProse(operations, surfaceId, childIds) {
+	const components = collectComponents(operations);
+	const segments = (0, _copilotkit_core.segmentSurfaceProse)(components, { childIds });
+	const [first] = segments;
+	if (segments.length === 1 && first?.kind === "surface" && first.components === components) return [{
+		kind: "surface",
+		surfaceId,
+		operations
+	}];
+	let surfaceIndex = 0;
+	return segments.map((segment) => {
+		if (segment.kind === "markdown") return segment;
+		const id = surfaceIndex === 0 ? surfaceId : `${surfaceId}#${surfaceIndex}`;
+		surfaceIndex++;
+		return {
+			kind: "surface",
+			surfaceId: id,
+			operations: subSurfaceOperations(operations, segment.components, id)
+		};
+	});
+}
+/** `validateOperation`, with the operation typed when it is valid. */
+function checkOperation(op, options) {
+	const validation = (0, _copilotkit_shared.validateOperation)(op, options);
+	if (!validation.ok) return validation;
+	return {
+		ok: true,
+		operation: op
+	};
+}
+/**
+* The content of one surface. Each operation is validated against the
+* manifest. A valid operation goes in `operations`. A rejected one goes in
+* `rejected`, with its position and the reason.
+*/
+function surfaceContent(surfaceId, draft, operations, options) {
+	const { ui, functions } = options;
+	const knownSurfaces = /* @__PURE__ */ new Set();
+	const manifest = {
+		catalogId: ui.id,
+		catalogIds: catalogIdsOf(ui),
+		components: ui.manifestComponents
+	};
+	const valid = [];
+	const rejected = [];
+	operations.forEach((op, index) => {
+		const result = checkOperation(op, {
+			manifest,
+			knownSurfaces,
+			functions
+		});
+		if (!result.ok) {
+			rejected.push({
+				index,
+				reason: result.reason
+			});
+			return;
+		}
+		valid.push(result.operation);
+		const kind = (0, _copilotkit_shared.getOperationKind)(result.operation);
+		if (kind === "createSurface") knownSurfaces.add(surfaceId);
+		if (kind === "deleteSurface") knownSurfaces.delete(surfaceId);
+	});
+	const create = valid.find((op) => "createSurface" in op);
+	return {
+		surfaceId,
+		target: draft.target,
+		catalogId: create?.createSurface.catalogId ?? ui.id,
+		operations: valid,
+		status: draft.streaming ? "streaming" : "ready",
+		rejected
+	};
+}
+/**
+* Builds the surfaces of a thread from the ```a2ui fences of its assistant
+* messages, in message order.
+*
+* - Operations are grouped by surfaceId across all messages. An operation
+*   with no surfaceId goes to the first surface of its fence, else to
+*   `<messageId>-<fenceIndex>`.
+* - The fence that first writes a surface creates it. The `target=<id>` of
+*   that fence sets the target. With no target, the surface goes to the
+*   chat.
+* - A later fence of the same reply for the same surfaceId updates it. A
+*   later reply that reuses the id of a chat surface gets a surface of its
+*   own, `<id>@<messageId>`. A page target is updated from any reply.
+* - The status is "streaming" while the creating fence streams, else
+*   "ready".
+* - Each operation is validated with `validateOperation`. Rejected ones are
+*   left out and listed in `rejected`.
+* - Chat surfaces get the prose lift: informational cards lose their box,
+*   and prose becomes markdown that renders between sub-surfaces
+*   (`<surfaceId>#<n>`). An inline createSurface is split into its
+*   createSurface, updateDataModel and updateComponents first.
+* - A `callRendererFunction` line is not part of a surface. It goes to
+*   `functionCalls`. A streaming line gives nothing, so a function never
+*   runs with a part of its args.
+*
+* The function is pure. Call it again on each stream update. The manager
+* applies only the new operations, so unchanged surfaces do not render
+* again.
+*
+* @param messages - The messages of one thread.
+* @param options - The generative UI, its declared functions, and whether
+*   the last message can still grow.
+* @returns `surfaces`, one content for each surface and sub-surface;
+*   `fences`, the blocks that each fence renders, by `fenceKey` (a fence
+*   that is not in `fences` renders nothing); `functionCalls`, the function
+*   calls of the fences in order; and `parts`, the surface ids of the parts
+*   of each surface, by surface id.
+*
+* @example
+* ```ts
+* const { surfaces } = buildMarkdownSurfaces(agent.messages, {
+*   ui,
+*   functions: {},
+*   running: agent.isRunning,
+* });
+* for (const content of surfaces) manager.ingest(threadId, agentId, content);
+* ```
+*/
+function buildMarkdownSurfaces(messages, options) {
+	const { ui, cache } = options;
+	const drafts = /* @__PURE__ */ new Map();
+	const readdressOnce = (op, surfaceId) => {
+		if (!cache) return readdress(op, surfaceId);
+		let copies = cache.readdressed.get(op);
+		if (!copies) {
+			copies = /* @__PURE__ */ new Map();
+			cache.readdressed.set(op, copies);
+		}
+		let copy = copies.get(surfaceId);
+		if (!copy) {
+			copy = readdress(op, surfaceId);
+			copies.set(surfaceId, copy);
+		}
+		return copy;
+	};
+	/** The surfaces that each fence created, in order. */
+	const created = /* @__PURE__ */ new Map();
+	const functionCalls = [];
+	/** The message that owns each chat surface id, by the id the model wrote. */
+	const chatOwners = /* @__PURE__ */ new Map();
+	const lastMessage = messages[messages.length - 1];
+	/**
+	* A chat surface belongs to the reply that wrote it: the chat is a
+	* transcript, so a later reply that reuses an id gets a surface of its
+	* own (`<id>@<messageId>`) instead of changing the earlier reply. A fence
+	* for a page target keeps its id, because a target is a place on the
+	* page that a later reply updates on purpose.
+	*/
+	const scopedSurfaceId = (requested, messageId, target) => {
+		if (target !== void 0) return requested;
+		const owner = chatOwners.get(requested);
+		if (owner === void 0) {
+			chatOwners.set(requested, messageId);
+			return requested;
+		}
+		return owner === messageId ? requested : `${requested}@${messageId}`;
+	};
+	for (const message of messages) {
+		if (message.role !== "assistant" || !isString(message.content)) continue;
+		const isLastMessage = message === lastMessage;
+		const content = message.content;
+		const segments = cache ? cache.segments.get(content, () => (0, _copilotkit_core.splitA2UIMarkdown)(content)) : (0, _copilotkit_core.splitA2UIMarkdown)(content);
+		for (const segment of segments) {
+			if (segment.type !== "a2ui") continue;
+			const isStreaming = !segment.closed && isLastMessage && options.running;
+			const parseFence = () => {
+				const parsed = fenceOperations(segment.text, isStreaming);
+				const { functionCalls } = (0, _copilotkit_core.prepareSurfaceOperations)({
+					operations: parsed,
+					fallbackSurfaceId: "",
+					catalogId: ui.id
+				});
+				return {
+					operations: parsed,
+					functionCalls
+				};
+			};
+			const fence = cache ? cache.fences.get(`${isStreaming}:${segment.text}`, parseFence) : parseFence();
+			const { operations } = fence;
+			const key = fenceKey(message.id, segment.index);
+			const fenceSurfaceId = operations.map(_copilotkit_core.getMarkdownOperationSurfaceId).find(isString) ?? `${message.id}-${segment.index}`;
+			for (const operation of fence.functionCalls) functionCalls.push({
+				messageId: message.id,
+				fenceIndex: segment.index,
+				operation
+			});
+			const surfaceOperations = operations.filter((op) => (0, _copilotkit_shared.getOperationKind)(op) !== "callRendererFunction");
+			for (const op of surfaceOperations) {
+				const requested = (0, _copilotkit_core.getMarkdownOperationSurfaceId)(op) ?? fenceSurfaceId;
+				const surfaceId = scopedSurfaceId(requested, message.id, segment.target);
+				let draft = drafts.get(surfaceId);
+				if (!draft) {
+					draft = {
+						surfaceId,
+						target: segment.target ?? _copilotkit_shared.GENERATIVE_UI_CHAT_TARGET,
+						operations: [],
+						streaming: isStreaming
+					};
+					drafts.set(surfaceId, draft);
+					created.set(key, [...created.get(key) ?? [], surfaceId]);
+				}
+				draft.operations.push(surfaceId === requested ? op : readdressOnce(op, surfaceId));
+			}
+		}
+	}
+	const canFlattenCards = hasProp(ui, "Card", "variant");
+	const surfaces = [];
+	const partsBySurface = /* @__PURE__ */ new Map();
+	const childIds = childIdsReader(ui);
+	const buildDraft = (draft) => {
+		const operations = splitComponentUpdates(expandInlineCreate(createSurfaceFirst((0, _copilotkit_core.prepareSurfaceOperations)({
+			operations: draft.operations,
+			fallbackSurfaceId: draft.surfaceId,
+			catalogId: ui.id,
+			catalogIds: catalogIdsOf(ui)
+		}).operations)));
+		const parts = draft.target === _copilotkit_shared.GENERATIVE_UI_CHAT_TARGET ? liftProse(canFlattenCards ? (0, _copilotkit_core.flattenInformationalCards)(operations, { childIds }) : operations, draft.surfaceId, childIds) : [{
+			kind: "surface",
+			surfaceId: draft.surfaceId,
+			operations
+		}];
+		const contents = parts.flatMap((part) => part.kind === "surface" ? [surfaceContent(part.surfaceId, draft, part.operations, options)] : []);
+		return {
+			...draft,
+			parts,
+			contents
+		};
+	};
+	for (const draft of drafts.values()) {
+		const built = cache ? cache.drafts.get(draft.surfaceId, () => buildDraft(draft), (last) => last.target === draft.target && last.streaming === draft.streaming && sameItems(last.operations, draft.operations)) : buildDraft(draft);
+		partsBySurface.set(draft.surfaceId, built.parts);
+		surfaces.push(...built.contents);
+	}
+	cache?.endBuild();
+	/** The surface ids of the parts of each split surface, by surface id. */
+	const parts = /* @__PURE__ */ new Map();
+	for (const [surfaceId, surfaceParts] of partsBySurface) {
+		const ids = surfaceParts.flatMap((part) => part.kind === "surface" ? [part.surfaceId] : []);
+		parts.set(surfaceId, ids);
+	}
+	const fences = /* @__PURE__ */ new Map();
+	for (const [key, surfaceIds] of created) {
+		const blocks = [];
+		for (const surfaceId of surfaceIds) {
+			if (drafts.get(surfaceId)?.target !== _copilotkit_shared.GENERATIVE_UI_CHAT_TARGET) continue;
+			for (const part of partsBySurface.get(surfaceId) ?? []) blocks.push(part.kind === "markdown" ? part : {
+				kind: "surface",
+				surfaceId: part.surfaceId
+			});
+		}
+		if (blocks.length > 0) fences.set(key, blocks);
+	}
+	return {
+		surfaces,
+		fences,
+		functionCalls,
+		parts
+	};
+}
+/** The declared functions, as `validateOperation` takes them. */
+function declaredFunctions(ui) {
+	const functions = {};
+	for (const [name, fn] of ui.functions) try {
+		functions[name] = {
+			...fn.description ? { description: fn.description } : {},
+			parameters: toJsonSchema(fn.parameters)
+		};
+	} catch {
+		functions[name] = { parameters: {} };
+	}
+	return functions;
+}
+/** True when `list` starts with all the items of `prefix`. */
+function startsWith(list, prefix) {
+	return list.length >= prefix.length && prefix.every((item, index) => item === list[index]);
+}
+/** A content that deletes a surface that the fences no longer write. */
+function removalContent(surfaceId, catalogId) {
+	return {
+		surfaceId,
+		target: _copilotkit_shared.GENERATIVE_UI_CHAT_TARGET,
+		catalogId,
+		status: "ready",
+		rejected: [],
+		operations: [{
+			version: _copilotkit_shared.A2UI_VERSION,
+			createSurface: {
+				surfaceId,
+				catalogId
+			}
+		}, {
+			version: _copilotkit_shared.A2UI_VERSION,
+			deleteSurface: { surfaceId }
+		}]
+	};
+}
+/**
+* The markdown transport source of one surface manager. It turns the
+* messages of a thread into surfaces in the manager, and keeps the blocks
+* that each fence renders.
+*/
+var MarkdownSurfaceSource = class {
+	constructor(manager, ui) {
+		this.manager = manager;
+		this.ui = ui;
+		this.fences = /* @__PURE__ */ new Map();
+		this.ingested = /* @__PURE__ */ new Map();
+		this.contents = /* @__PURE__ */ new Map();
+		this.caches = /* @__PURE__ */ new Map();
+		this.functions = declaredFunctions(ui);
+	}
+	/**
+	* Builds the surfaces of `threadId` from `messages` and gives them to the
+	* manager. A surface that an earlier sync of the thread made, and that the
+	* messages no longer write, is deleted. Other threads do not change.
+	*
+	* @param threadId - The thread of the messages.
+	* @param agentId - The agent that owns the thread.
+	* @param messages - All messages of the thread.
+	* @param options - `running`: the last message can still grow.
+	* @returns The function calls of the fences, in order. The source does
+	*   not run them.
+	*/
+	sync(threadId, agentId, messages, options) {
+		let cache = this.caches.get(threadId);
+		if (!cache) {
+			cache = new MarkdownBuildCache();
+			this.caches.set(threadId, cache);
+		}
+		const result = buildMarkdownSurfaces(messages, {
+			ui: this.ui,
+			functions: this.functions,
+			running: options.running,
+			cache
+		});
+		this.fences.set(threadId, result.fences);
+		for (const parts of result.parts.values()) this.manager.linkSurfaces(threadId, parts);
+		const previous = this.ingested.get(threadId) ?? /* @__PURE__ */ new Map();
+		const previousContents = this.contents.get(threadId) ?? /* @__PURE__ */ new Map();
+		const next = /* @__PURE__ */ new Map();
+		const nextContents = /* @__PURE__ */ new Map();
+		for (const content of result.surfaces) {
+			nextContents.set(content.surfaceId, content);
+			const before = previous.get(content.surfaceId);
+			if (before && previousContents.get(content.surfaceId) === content) {
+				next.set(content.surfaceId, before);
+				continue;
+			}
+			const fingerprints = content.operations.map((op) => JSON.stringify(op));
+			if (before && !startsWith(fingerprints, before)) this.manager.ingest(threadId, agentId, {
+				...content,
+				operations: []
+			});
+			this.manager.ingest(threadId, agentId, content);
+			next.set(content.surfaceId, fingerprints);
+		}
+		for (const surfaceId of previous.keys()) {
+			if (next.has(surfaceId)) continue;
+			this.manager.ingest(threadId, agentId, removalContent(surfaceId, this.ui.id));
+		}
+		this.ingested.set(threadId, next);
+		this.contents.set(threadId, nextContents);
+		return result.functionCalls;
+	}
+	/**
+	* The blocks that a fence renders in the chat, from the latest sync of the
+	* thread. `undefined` when the fence renders nothing: it updates a surface
+	* of an earlier fence, its surface is for a named target, or it has no
+	* complete operation yet.
+	*/
+	getFenceBlocks(threadId, messageId, fenceIndex) {
+		return this.fences.get(threadId)?.get(fenceKey(messageId, fenceIndex));
+	}
+};
+const sources = /* @__PURE__ */ new WeakMap();
+/**
+* The markdown source of a generative UI runtime. There is one source for
+* each surface manager. The root syncs it, and the chat messages read the
+* fence blocks from it.
+*/
+function getMarkdownSurfaceSource(runtime) {
+	let source = sources.get(runtime.manager);
+	if (!source) {
+		source = new MarkdownSurfaceSource(runtime.manager, runtime.ui);
+		sources.set(runtime.manager, source);
+	}
+	return source;
+}
+
+//#endregion
+//#region src/v2/generative-ui/calc.ts
+const MAX_SERIES = 1e3;
+const OPERATORS = [
+	"&&",
+	"||",
+	"==",
+	"!=",
+	"<=",
+	">=",
+	"<",
+	">",
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"(",
+	")",
+	",",
+	"?",
+	":",
+	"!"
+];
+function tokenize(source) {
+	const tokens = [];
+	let i = 0;
+	while (i < source.length) {
+		const char = source[i];
+		if (/\s/.test(char)) {
+			i++;
+			continue;
+		}
+		if (/[0-9.]/.test(char)) {
+			const match = /^\d*\.?\d+(?:[eE][-+]?\d+)?|^\d+\.?/.exec(source.slice(i));
+			if (!match) throw new ExpressionError(`calc: bad number at "${source.slice(i, i + 8)}"`);
+			tokens.push({
+				kind: "number",
+				value: Number(match[0])
+			});
+			i += match[0].length;
+			continue;
+		}
+		if (char === "'" || char === "\"") {
+			let value = "";
+			i++;
+			while (i < source.length && source[i] !== char) {
+				if (source[i] === "\\" && i + 1 < source.length) i++;
+				value += source[i++];
+			}
+			if (i >= source.length) throw new ExpressionError("calc: unclosed string");
+			i++;
+			tokens.push({
+				kind: "string",
+				value
+			});
+			continue;
+		}
+		if (/[A-Za-z_]/.test(char)) {
+			const match = /^[A-Za-z_][A-Za-z0-9_]*/.exec(source.slice(i));
+			tokens.push({
+				kind: "name",
+				value: match[0]
+			});
+			i += match[0].length;
+			continue;
+		}
+		const op = OPERATORS.find((candidate) => source.startsWith(candidate, i));
+		if (!op) throw new ExpressionError(`calc: unexpected "${char}"`);
+		tokens.push({
+			kind: "op",
+			value: op
+		});
+		i += op.length;
+	}
+	tokens.push({ kind: "end" });
+	return tokens;
+}
+function numberOf(value, what) {
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new ExpressionError(`calc: ${what} is not finite`);
+		return value;
+	}
+	if (typeof value === "boolean") return value ? 1 : 0;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		if (Number.isFinite(parsed)) return parsed;
+	}
+	if (value === null || value === void 0) throw new ExpressionError(`calc: ${what} has no value`);
+	throw new ExpressionError(`calc: ${what} is not a number`);
+}
+function describe(value) {
+	return typeof value === "string" ? `"${value}"` : String(value);
+}
+const MATH = {
+	min: (args) => Math.min(...args),
+	max: (args) => Math.max(...args),
+	abs: ([x]) => Math.abs(x),
+	floor: ([x]) => Math.floor(x),
+	ceil: ([x]) => Math.ceil(x),
+	round: ([x, decimals = 0]) => {
+		const factor = 10 ** Math.trunc(decimals);
+		return Math.round(x * factor) / factor;
+	}
+};
+var CalcParser = class {
+	constructor(tokens, scope, source) {
+		this.tokens = tokens;
+		this.scope = scope;
+		this.source = source;
+		this.pos = 0;
+		this.skipDepth = 0;
+	}
+	parse() {
+		const value = this.ternary();
+		if (this.tokens[this.pos].kind !== "end") this.fail(`unexpected "${this.text(this.tokens[this.pos])}"`);
+		return value;
+	}
+	fail(what) {
+		throw new ExpressionError(`calc: ${what} in "${this.source}"`);
+	}
+	text(token) {
+		return token.kind === "end" ? "end" : String(token.value);
+	}
+	peekOp(...ops) {
+		const token = this.tokens[this.pos];
+		return token.kind === "op" && ops.includes(token.value) ? token.value : void 0;
+	}
+	expectOp(op) {
+		if (this.peekOp(op) === void 0) this.fail(`expected "${op}" but found "${this.text(this.tokens[this.pos])}"`);
+		this.pos++;
+	}
+	/**
+	* Parses a part of the expression that the result does not need (the
+	* other branch of `?:`, the right side of a decided `&&` or `||`). It
+	* still has to be parsed to find where it ends, so syntax errors are
+	* reported, but no value is checked or computed: `n == 0 ? 0 : 10 / n`
+	* is a valid guard.
+	*/
+	skipped(parse) {
+		this.skipDepth++;
+		try {
+			parse();
+		} finally {
+			this.skipDepth--;
+		}
+		return null;
+	}
+	/** The number of a value, or 0 while skipping. */
+	num(value, what) {
+		return this.skipDepth > 0 ? 0 : numberOf(value, what);
+	}
+	ternary() {
+		const condition = this.or();
+		if (this.peekOp("?") === void 0) return condition;
+		this.pos++;
+		const takesFirst = truthOf(condition);
+		const whenTrue = takesFirst ? this.ternary() : this.skipped(() => this.ternary());
+		this.expectOp(":");
+		const whenFalse = takesFirst ? this.skipped(() => this.ternary()) : this.ternary();
+		return takesFirst ? whenTrue : whenFalse;
+	}
+	or() {
+		let left = this.and();
+		while (this.peekOp("||")) {
+			this.pos++;
+			if (truthOf(left)) {
+				this.skipped(() => this.and());
+				left = true;
+			} else left = truthOf(this.and());
+		}
+		return left;
+	}
+	and() {
+		let left = this.equality();
+		while (this.peekOp("&&")) {
+			this.pos++;
+			if (!truthOf(left)) {
+				this.skipped(() => this.equality());
+				left = false;
+			} else left = truthOf(this.equality());
+		}
+		return left;
+	}
+	equality() {
+		let left = this.comparison();
+		for (let op = this.peekOp("==", "!="); op; op = this.peekOp("==", "!=")) {
+			this.pos++;
+			const right = this.comparison();
+			const isEqual = typeof left === "number" || typeof right === "number" ? this.num(left, "the left side of ==") === this.num(right, "the right side of ==") : left === right;
+			left = op === "==" ? isEqual : !isEqual;
+		}
+		return left;
+	}
+	comparison() {
+		let left = this.additive();
+		for (let op = this.peekOp("<", "<=", ">", ">="); op; op = this.peekOp("<", "<=", ">", ">=")) {
+			this.pos++;
+			const a = this.num(left, `the left side of ${op}`);
+			const b = this.num(this.additive(), `the right side of ${op}`);
+			left = op === "<" ? a < b : op === "<=" ? a <= b : op === ">" ? a > b : a >= b;
+		}
+		return left;
+	}
+	additive() {
+		let left = this.multiplicative();
+		for (let op = this.peekOp("+", "-"); op; op = this.peekOp("+", "-")) {
+			this.pos++;
+			const right = this.multiplicative();
+			if (op === "+" && (typeof left === "string" || typeof right === "string")) left = `${left ?? ""}${right ?? ""}`;
+			else {
+				const a = this.num(left, `the left side of ${op}`);
+				const b = this.num(right, `the right side of ${op}`);
+				left = op === "+" ? a + b : a - b;
+			}
+		}
+		return left;
+	}
+	multiplicative() {
+		let left = this.unary();
+		for (let op = this.peekOp("*", "/", "%"); op; op = this.peekOp("*", "/", "%")) {
+			this.pos++;
+			const a = this.num(left, `the left side of ${op}`);
+			const b = this.num(this.unary(), `the right side of ${op}`);
+			if (op !== "*" && b === 0 && this.skipDepth === 0) this.fail("division by zero");
+			left = op === "*" ? a * b : op === "/" ? a / b : a % b;
+		}
+		return left;
+	}
+	unary() {
+		if (this.peekOp("-")) {
+			this.pos++;
+			return -this.num(this.unary(), "the operand of -");
+		}
+		if (this.peekOp("!")) {
+			this.pos++;
+			return !truthOf(this.unary());
+		}
+		return this.primary();
+	}
+	primary() {
+		const token = this.tokens[this.pos++];
+		switch (token.kind) {
+			case "number": return token.value;
+			case "string": return token.value;
+			case "name": return this.name(token.value);
+			case "op":
+				if (token.value === "(") {
+					const value = this.ternary();
+					this.expectOp(")");
+					return value;
+				}
+				return this.fail(`unexpected "${token.value}"`);
+			case "end": return this.fail("missing value");
+		}
+	}
+	name(name) {
+		if (name === "true") return true;
+		if (name === "false") return false;
+		if (name === "null") return null;
+		if (this.peekOp("(")) {
+			this.pos++;
+			const args = [];
+			if (this.peekOp(")") === void 0) for (;;) {
+				args.push(this.num(this.ternary(), `an argument of ${name}`));
+				if (this.peekOp(",") === void 0) break;
+				this.pos++;
+			}
+			this.expectOp(")");
+			if (this.skipDepth > 0) return null;
+			const fn = Object.prototype.hasOwnProperty.call(MATH, name) ? MATH[name] : void 0;
+			if (!fn) this.fail(`unknown function ${name}`);
+			if (args.length === 0) this.fail(`${name} needs an argument`);
+			return fn(args);
+		}
+		if (this.skipDepth > 0) return null;
+		if (!Object.prototype.hasOwnProperty.call(this.scope, name)) this.fail(`unknown name ${name}; pass it as an arg`);
+		const value = this.scope[name];
+		if (value !== null && typeof value !== "number" && typeof value !== "string" && typeof value !== "boolean") this.fail(`${name} is not a number, text or boolean (${describe(value)})`);
+		return value;
+	}
+};
+/**
+* Evaluates `expression` with the names in `scope`. Gives a number, a
+* string, a boolean or null. Throws an {@link ExpressionError} for a bad
+* expression or a missing name.
+*/
+function evaluateCalc(expression, scope) {
+	if (typeof expression !== "string" || expression.trim() === "") throw new ExpressionError("calc: expression must be a string");
+	return new CalcParser(tokenize(expression), scope, expression).parse();
+}
+/** The `calc` function: the expression is `args.expression`, the rest is the scope. */
+function calc(args) {
+	const { expression, ...scope } = args;
+	return evaluateCalc(expression, scope);
+}
+const WHOLE_EXPRESSION = /^\$\{([^}]*)\}$/;
+/**
+* Fills `item` for one iteration: a string that is one `${...}` gives the
+* typed value of the expression, a string with `${...}` inside it is
+* interpolated as text, and objects and arrays are walked.
+*/
+function fillItem(item, scope) {
+	if (typeof item === "string") {
+		const whole = WHOLE_EXPRESSION.exec(item);
+		if (whole) return evaluateCalc(whole[1], scope);
+		return item.replace(/\$\{([^}]*)\}/g, (_, expression) => {
+			const value = evaluateCalc(expression, scope);
+			return value === null ? "" : String(value);
+		});
+	}
+	if (Array.isArray(item)) return item.map((entry) => fillItem(entry, scope));
+	if (typeof item === "object" && item !== null) return Object.fromEntries(Object.entries(item).map(([key, value]) => [key, fillItem(value, scope)]));
+	return item;
+}
+/**
+* The `series` function: `count` copies of `item`, with the loop variable
+* (`variable`, default "i") counting from `start` (default 1) and the other
+* args in scope of the `${...}` expressions of the item.
+*/
+function series(args) {
+	const { count, item, variable, start, ...scope } = args;
+	const length = numberOf(count, "count");
+	if (!Number.isInteger(length) || length < 0) throw new ExpressionError("series: count must be a whole number");
+	if (length > MAX_SERIES) throw new ExpressionError(`series: count is at most ${MAX_SERIES}`);
+	if (item === void 0) throw new ExpressionError("series: item is required");
+	const name = variable === void 0 ? "i" : variable;
+	if (typeof name !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) throw new ExpressionError("series: variable must be a name");
+	const first = start === void 0 ? 1 : numberOf(start, "start");
+	return Array.from({ length }, (_, index) => fillItem(item, {
+		...scope,
+		[name]: first + index
+	}));
+}
+
+//#endregion
+//#region src/v2/generative-ui/resolve.ts
+BASIC_FUNCTIONS.calc = calc;
+BASIC_FUNCTIONS.series = series;
+const NO_DATA = { get: () => void 0 };
+BASIC_FUNCTIONS.formatString = (args) => resolveDynamicValue({
+	"@call": "formatString",
+	args
+}, {
+	data: NO_DATA,
+	basePath: void 0
+}).value;
+/** Adds one segment to a JSON pointer: ("/items", "0") gives "/items/0". */
+function joinPath(base, segment) {
+	return base === "/" ? `/${segment}` : `${base}/${segment}`;
+}
+/**
+* The absolute data model path of a binding. A path without a leading "/"
+* is relative to the current template item, or to the root outside of one.
+*/
+function resolvePath(path, basePath) {
+	if (path.startsWith("/")) return path;
+	return joinPath(basePath ?? "/", path);
+}
+/**
+* The index of the template item at `basePath`: its last segment.
+* `undefined` outside of a template.
+*/
+function templateIndex(basePath) {
+	if (basePath === void 0) return void 0;
+	const index = Number(basePath.slice(basePath.lastIndexOf("/") + 1));
+	return Number.isInteger(index) ? index : void 0;
+}
+/** The value of a ValidationResult where a boolean is expected. */
+function coerce(value, keep) {
+	return !keep && (0, _copilotkit_shared.isValidationResult)(value) ? value.valid : value;
+}
+/**
+* Resolves `value`. `keepValidation` keeps a ValidationResult as it is; by
+* default it becomes its `valid` boolean, which is what every prop except
+* a check condition wants.
+*/
+function walk(value, state, keepValidation, scope = "outside") {
+	if (Array.isArray(value)) {
+		let changed = false;
+		const itemScope = scope === "list" ? "check" : "outside";
+		const items = value.map((item) => {
+			const next = walk(item, state, keepValidation, itemScope);
+			if (next !== item) changed = true;
+			return next;
+		});
+		return changed ? items : value;
+	}
+	if (!isRecord(value)) return value;
+	if ((0, _copilotkit_shared.isPathBinding)(value)) {
+		const path = resolvePath(value["@path"], state.context.basePath);
+		state.paths.add(path);
+		return state.context.data.get(path);
+	}
+	if ((0, _copilotkit_shared.isCallBinding)(value)) return call(value, state, keepValidation);
+	if ((0, _copilotkit_shared.isActionBinding)(value)) return value;
+	let changed = false;
+	const entries = Object.entries(value).map(([key, item]) => {
+		const next = walk(item, state, keepValidation || scope === "check" && key === "condition", key === "checks" ? "list" : "outside");
+		if (next !== item) changed = true;
+		return [key, next];
+	});
+	return changed ? Object.fromEntries(entries) : value;
+}
+function call(binding, state, keepValidation) {
+	const name = binding["@call"];
+	const rawArgs = binding.args ?? {};
+	if (!isRecord(rawArgs)) throw new ExpressionError(`the args of "${name}" must be an object`);
+	if (name === _copilotkit_shared.A2UI_INDEX_FUNCTION) {
+		const index = templateIndex(state.context.basePath);
+		if (index === void 0) return void 0;
+		const offset = walk(rawArgs.offset, state, false);
+		return index + (typeof offset === "number" ? offset : 0);
+	}
+	if (name === "formatString") {
+		const template = walk(rawArgs.value, state, false);
+		if (typeof template !== "string") throw new ExpressionError("formatString takes a string value");
+		return formatString(template, state);
+	}
+	const fn = Object.prototype.hasOwnProperty.call(BASIC_FUNCTIONS, name) ? BASIC_FUNCTIONS[name] : void 0;
+	if (!fn) throw new ExpressionError(`"${name}" is not a basic function`);
+	if (requiresUserActivation(name)) throw new ExpressionError(`"${name}" is not a value; bind it as the functionCall of an event`);
+	const result = fn(walk(rawArgs, state, false));
+	return givesValidationResult(name) ? coerce(result, keepValidation) : result;
+}
+function resolveDynamicValue(value, context, options = {}) {
+	const result = tryResolveDynamicValue(value, context, options);
+	if (!result.ok) throw result.error;
+	return result;
+}
+/**
+* Like {@link resolveDynamicValue}, but a failure comes back as a result
+* with the paths read so far, so the caller can keep watching them: a
+* function that fails on an empty field works once the user fills it.
+*/
+function tryResolveDynamicValue(value, context, options = {}) {
+	const state = {
+		context,
+		paths: /* @__PURE__ */ new Set()
+	};
+	try {
+		return {
+			ok: true,
+			value: walk(value, state, options.keepValidation ?? false, options.isChecks ? "list" : "outside"),
+			paths: state.paths
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: error instanceof Error ? error : new Error(String(error)),
+			paths: state.paths
+		};
+	}
+}
+/** True when `value` holds a `{"@path"}` or `{"@call"}` at any depth. */
+function containsDynamicValue(value) {
+	if (Array.isArray(value)) return value.some(containsDynamicValue);
+	if (!isRecord(value)) return false;
+	if ((0, _copilotkit_shared.isPathBinding)(value) || (0, _copilotkit_shared.isCallBinding)(value)) return true;
+	if ((0, _copilotkit_shared.isActionBinding)(value)) return false;
+	return Object.values(value).some(containsDynamicValue);
+}
+/**
+* The `${...}` grammar of `formatString`:
+*
+*   expression := path | literal | call
+*   path       := "/" segments | identifier ("/" segments)*
+*   literal    := 'text' | "text" | number | true | false | null
+*   call       := identifier "(" [ name ":" expression ("," name ":" expression)* ] ")"
+*
+* A `\${` in the template is a literal `${`.
+*/
+function formatString(template, state) {
+	let out = "";
+	let index = 0;
+	while (index < template.length) {
+		const start = template.indexOf("${", index);
+		if (start === -1) {
+			out += template.slice(index);
+			break;
+		}
+		if (start > 0 && template[start - 1] === "\\") {
+			out += `${template.slice(index, start - 1)}\${`;
+			index = start + 2;
+			continue;
+		}
+		out += template.slice(index, start);
+		const end = matchingBrace(template, start + 2);
+		if (end === -1) throw new ExpressionError("formatString: unclosed ${");
+		const value = new ExpressionParser(template.slice(start + 2, end).trim(), state).parse();
+		out += value === void 0 || value === null ? "" : String(value);
+		index = end + 1;
+	}
+	return out;
+}
+/** The index of the `}` that closes the block opened at `from`, or -1. */
+function matchingBrace(template, from) {
+	let depth = 1;
+	let quote;
+	for (let i = from; i < template.length; i++) {
+		const char = template[i];
+		if (quote) {
+			if (char === "\\") i++;
+			else if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "'" || char === "\"") quote = char;
+		else if (char === "{") depth++;
+		else if (char === "}" && --depth === 0) return i;
+	}
+	return -1;
+}
+const IDENTIFIER = /@?[A-Za-z_][A-Za-z0-9_-]*/y;
+const NUMBER = /-?\d+(?:\.\d+)?/y;
+const PATH_SEGMENT = /[^\s,():'"]+/y;
+var ExpressionParser = class {
+	constructor(source, state) {
+		this.source = source;
+		this.state = state;
+		this.pos = 0;
+	}
+	parse() {
+		const value = this.expression();
+		this.skipSpace();
+		if (this.pos < this.source.length) throw new ExpressionError(`formatString: unexpected "${this.source.slice(this.pos)}" in \${${this.source}}`);
+		return value;
+	}
+	fail(what) {
+		throw new ExpressionError(`formatString: ${what} in \${${this.source}}`);
+	}
+	skipSpace() {
+		while (this.pos < this.source.length && /\s/.test(this.source[this.pos])) this.pos++;
+	}
+	match(pattern) {
+		pattern.lastIndex = this.pos;
+		const found = pattern.exec(this.source);
+		if (!found) return void 0;
+		this.pos = pattern.lastIndex;
+		return found[0];
+	}
+	expression() {
+		this.skipSpace();
+		const char = this.source[this.pos];
+		if (char === void 0) this.fail("missing expression");
+		if (char === "'" || char === "\"") return this.quoted(char);
+		if (char === "/") return this.path(this.match(PATH_SEGMENT) ?? "/");
+		const number = this.match(NUMBER);
+		if (number !== void 0) return Number(number);
+		const name = this.match(IDENTIFIER);
+		if (name === void 0) this.fail(`unexpected "${char}"`);
+		if (name === "true") return true;
+		if (name === "false") return false;
+		if (name === "null") return null;
+		this.skipSpace();
+		if (this.source[this.pos] === "(") return this.call(name);
+		if (name.startsWith("@")) return call({ "@call": name }, this.state, false);
+		const rest = this.source[this.pos] === "/" ? this.match(PATH_SEGMENT) : "";
+		return this.path(`${name}${rest ?? ""}`);
+	}
+	quoted(quote) {
+		let value = "";
+		this.pos++;
+		while (this.pos < this.source.length) {
+			const char = this.source[this.pos++];
+			if (char === "\\" && this.pos < this.source.length) value += this.source[this.pos++];
+			else if (char === quote) return value;
+			else value += char;
+		}
+		return this.fail("unclosed string");
+	}
+	path(path) {
+		const absolute = resolvePath(path, this.state.context.basePath);
+		this.state.paths.add(absolute);
+		return this.state.context.data.get(absolute);
+	}
+	call(name) {
+		this.pos++;
+		const args = {};
+		this.skipSpace();
+		if (this.source[this.pos] === ")") {
+			this.pos++;
+			return call({
+				"@call": name,
+				args
+			}, this.state, false);
+		}
+		for (;;) {
+			this.skipSpace();
+			const key = this.match(IDENTIFIER);
+			if (key === void 0) this.fail("expected an argument name");
+			this.skipSpace();
+			if (this.source[this.pos] !== ":") this.fail(`expected ":" after ${key}`);
+			this.pos++;
+			args[key] = this.expression();
+			this.skipSpace();
+			const next = this.source[this.pos++];
+			if (next === ")") break;
+			if (next !== ",") this.fail(`expected "," or ")" after ${key}`);
+		}
+		return call({
+			"@call": name,
+			args
+		}, this.state, false);
+	}
+};
+
+//#endregion
+//#region src/v2/generative-ui/schema.ts
+const ASYNC_ISSUE = { message: "the schema validates asynchronously; component props and state need a schema that validates synchronously" };
+function toResult(result) {
+	return result.issues ? {
+		success: false,
+		issues: result.issues
+	} : {
+		success: true,
+		data: result.value
+	};
+}
+/**
+* Validates `value` with `schema`. The result comes back at once when the
+* schema validates synchronously, else as a promise.
+*/
+function validateSchema(schema, value) {
+	const result = schema["~standard"].validate(value);
+	return result instanceof Promise ? result.then(toResult) : toResult(result);
+}
+/**
+* Validates `value` synchronously, for code that runs during render. A
+* schema that validates asynchronously fails with an issue that says so.
+*/
+function validateSchemaSync(schema, value) {
+	const result = validateSchema(schema, value);
+	if (!(result instanceof Promise)) return result;
+	result.catch(() => {});
+	return {
+		success: false,
+		issues: [ASYNC_ISSUE]
+	};
+}
+/** True for the issue that `validateSchemaSync` gives for an async schema. */
+function isAsyncIssue(issue) {
+	return issue === ASYNC_ISSUE;
+}
+/** The first key of an issue path: the prop the issue is about. */
+function issueKey(issue) {
+	const first = issue.path?.[0];
+	const key = typeof first === "object" ? first.key : first;
+	return key === void 0 ? void 0 : String(key);
+}
+/**
+* `props` without the top-level props whose `null` the schema rejected, or
+* `undefined` when there are none. A model writes `null` for "not set" (an
+* empty selection, a value it has not filled yet), and A2UI deletes a data
+* model key that is set to `null`, so a rejected `null` is read as an unset
+* prop. A prop whose schema accepts `null` keeps it.
+*/
+function withoutRejectedNulls(props, issues) {
+	const rejected = /* @__PURE__ */ new Set();
+	for (const issue of issues) {
+		const key = issueKey(issue);
+		if (key !== void 0 && issue.path?.length === 1 && props[key] === null) rejected.add(key);
+	}
+	if (rejected.size === 0) return void 0;
+	return Object.fromEntries(Object.entries(props).filter(([key]) => !rejected.has(key)));
+}
+/** `"a.b: message; c: message"`. A path-less issue gets `fallback`. */
+function formatIssues(issues, fallback = "props") {
+	return issues.map((issue) => {
+		return `${(issue.path ?? []).map((segment) => String(typeof segment === "object" ? segment.key : segment)).join(".") || fallback}: ${issue.message}`;
+	}).join("; ");
+}
+
+//#endregion
+//#region src/v2/generative-ui/runtime-context.ts
+const GenerativeUIRuntimeContext = (0, react.createContext)(null);
+function useGenerativeUIRuntime() {
+	return (0, react.useContext)(GenerativeUIRuntimeContext);
+}
+function useRequiredGenerativeUIRuntime() {
+	const runtime = (0, react.useContext)(GenerativeUIRuntimeContext);
+	if (!runtime) throw new Error("Generative UI components must be rendered inside <CopilotKitProvider generativeUI={{ ui }}>.");
+	return runtime;
+}
+/**
+* Reports an error without ever throwing: `reportError` reaches host code
+* (`onError`), and a throwing host callback must not break rendering or an
+* event handler.
+*/
+function reportErrorSafely(runtime, info) {
+	try {
+		runtime.reportError(info);
+	} catch {}
+}
+const GenerativeUINodeContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/v2/generative-ui/hooks.ts
+const noopSubscribe$1 = () => () => {};
+const zero = () => 0;
+/** Re-renders on any surface-manager change. */
+function useManagerVersion(runtime) {
+	return (0, react.useSyncExternalStore)(runtime?.manager.subscribe ?? noopSubscribe$1, runtime?.manager.getVersion ?? zero, zero);
+}
+/**
+* Experimental. Gives one key of the app state declared in
+* `createGenerativeUI({ state })` its value. Bound props of generated
+* components read it. The model does not see it.
+*
+* The key is set on mount and when the value changes (compared as JSON). It
+* is removed on unmount.
+*
+* @param ui - The object from `createGenerativeUI`. It gives the key and the
+*   value their types.
+* @param key - A top-level key of `state`.
+* @param value - The value of that key. It must fit the key's schema.
+*
+* @example
+* ```tsx
+* useGenerativeUIState(storeUI, "cart", { count, total, coupon, items });
+* ```
+*/
+function useGenerativeUIState(ui, key, value) {
+	const runtime = useRequiredGenerativeUIRuntime();
+	const serialized = JSON.stringify(value);
+	(0, react.useEffect)(() => {
+		const raw = JSON.parse(serialized ?? "null");
+		let current = true;
+		const apply = (parsed) => {
+			if (!current) return;
+			if (parsed.success) {
+				runtime.manager.setState(key, parsed.data);
+				return;
+			}
+			runtime.manager.removeState(key);
+			if (process.env.NODE_ENV !== "production") console.error(`[generativeUI] useGenerativeUIState: invalid value for "${key}": ${formatIssues(parsed.issues, "value")}`);
+		};
+		const schema = runtime.ui.state.get(key);
+		const parsed = schema ? validateSchema(schema, raw) : {
+			success: true,
+			data: raw
+		};
+		if (parsed instanceof Promise) parsed.then(apply);
+		else apply(parsed);
+		return () => {
+			current = false;
+		};
+	}, [
+		runtime,
+		key,
+		serialized
+	]);
+	(0, react.useEffect)(() => () => runtime.manager.removeState(key), [runtime, key]);
+}
+/**
+* Experimental. Mounts the handler of a function declared in
+* `createGenerativeUI({ functions })`. Generated UI can call the function
+* only while exactly one handler for it is mounted.
+*
+* The handler gets the parsed arguments: schema defaults are set. It can
+* change on each render. The latest handler always runs, and the hook does
+* not register again.
+*
+* @param ui - The object from `createGenerativeUI`. It gives the name and the
+*   handler arguments their types.
+* @param name - A key of `functions`.
+* @param handler - Runs when generated UI calls the function. Its return
+*   value goes back to the caller as `{ ok: true, result }`.
+*
+* @example
+* ```tsx
+* useGenerativeUIFunction(storeUI, "addToCart", ({ productId, quantity }) =>
+*   cart.addItem(productId, quantity),
+* );
+* ```
+*/
+function useGenerativeUIFunction(ui, name, handler) {
+	const runtime = useRequiredGenerativeUIRuntime();
+	const latest = (0, react.useRef)(handler);
+	latest.current = handler;
+	(0, react.useEffect)(() => runtime.dispatcher.register(name, latest), [runtime, name]);
+}
+
+//#endregion
+//#region src/v2/generative-ui/boundaries.tsx
+function DefaultNodeFallback({ message, componentId, retry }) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+		role: "alert",
+		"data-generative-ui-error": componentId,
+		style: {
+			border: "1px solid #fca5a5",
+			background: "#fef2f2",
+			color: "#991b1b",
+			borderRadius: 8,
+			padding: "8px 12px",
+			fontSize: 13
+		},
+		children: [
+			"Couldn’t display this part: ",
+			message,
+			retry && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+				type: "button",
+				onClick: retry,
+				style: {
+					marginLeft: 8,
+					textDecoration: "underline"
+				},
+				children: "Retry"
+			})
+		]
+	});
+}
+/**
+* A child that has not streamed yet renders nothing. The prose keeps
+* streaming above the surface, and each component appears as soon as it is
+* complete. A grey block in its place would read as a broken layout.
+*/
+function NodePlaceholder(_props) {
+	return null;
+}
+/** Per-node boundary. Resets on retry or a new agent revision, not on data ticks. */
+var NodeBoundary = class extends react.Component {
+	constructor(..._args) {
+		super(..._args);
+		this.state = {
+			error: null,
+			revision: this.props.revision
+		};
+		this.retry = () => this.setState({ error: null });
+	}
+	static getDerivedStateFromError(error) {
+		return { error };
+	}
+	static getDerivedStateFromProps(props, state) {
+		return props.revision !== state.revision ? {
+			error: null,
+			revision: props.revision
+		} : null;
+	}
+	componentDidCatch(error) {
+		const { runtime, surfaceId, componentId } = this.props;
+		reportErrorSafely(runtime, {
+			kind: "render",
+			surfaceId,
+			componentId,
+			error
+		});
+	}
+	render() {
+		const { error } = this.state;
+		if (!error) return this.props.children;
+		const { runtime, surfaceId, componentId } = this.props;
+		const fallback = runtime.errorFallback;
+		return fallback ? fallback({
+			error,
+			retry: this.retry,
+			surfaceId,
+			componentId
+		}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DefaultNodeFallback, {
+			message: error.message,
+			componentId,
+			retry: this.retry
+		});
+	}
+};
+/** Outer boundary: a failure here must not reach the chat or the host page. */
+var SurfaceBoundary = class extends react.Component {
+	constructor(..._args2) {
+		super(..._args2);
+		this.state = { error: null };
+	}
+	static getDerivedStateFromError(error) {
+		return { error };
+	}
+	componentDidCatch(error) {
+		reportErrorSafely(this.props.runtime, {
+			kind: "render",
+			surfaceId: this.props.surfaceId,
+			error
+		});
+	}
+	render() {
+		if (!this.state.error) return this.props.children;
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DefaultNodeFallback, {
+			message: "this generated UI failed to render",
+			componentId: "surface"
+		});
+	}
+};
+
+//#endregion
+//#region src/v2/generative-ui/accessibility.ts
+const LIVE = new Set([
+	"off",
+	"polite",
+	"assertive"
+]);
+/**
+* The accessibility of a component from its resolved `accessibility`
+* value. Fields of the wrong type are left out: a label that is still a
+* binding, or a list, names nothing.
+*/
+function readAccessibility(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return;
+	const { label, description, live, hidden } = value;
+	const result = {};
+	if (typeof label === "string" && label !== "") result.label = label;
+	if (typeof description === "string" && description !== "") result.description = description;
+	if (typeof live === "string" && LIVE.has(live)) result.live = live;
+	if (typeof hidden === "boolean") result.hidden = hidden;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/**
+* The ARIA attributes for an `accessibility`. `live: "off"` is written out:
+* a region inherits the live setting of its ancestors, and a `status` role
+* is live on its own, so only the explicit value silences it.
+*
+* @example
+* ```ts
+* accessibilityAttributes({ label: "Totals", live: "polite" });
+* // { "aria-label": "Totals", "aria-live": "polite" }
+* ```
+*/
+function accessibilityAttributes(accessibility) {
+	if (!accessibility) return {};
+	const { label, description, live, hidden } = accessibility;
+	return {
+		...label === void 0 ? {} : { "aria-label": label },
+		...description === void 0 ? {} : { "aria-description": description },
+		...live === void 0 ? {} : { "aria-live": live },
+		...hidden ? { "aria-hidden": true } : {}
+	};
+}
+/**
+* Experimental. The ARIA attributes of the `accessibility` that the model
+* gave the component being rendered, to spread on its root element. The
+* standard components do this; a custom component does it itself:
+*
+* @example
+* ```tsx
+* function Panel({ children }: { children?: ReactNode }) {
+*   const aria = useGenerativeUIAccessibility();
+*   return <section {...aria}>{children}</section>;
+* }
+* ```
+*
+* Outside of generated UI it gives `{}`.
+*/
+function useGenerativeUIAccessibility() {
+	const accessibility = (0, react.useContext)(GenerativeUINodeContext)?.accessibility;
+	return (0, react.useMemo)(() => accessibilityAttributes(accessibility), [accessibility]);
+}
+/**
+* The role of a container that the envelope names. A generic element
+* cannot carry a name, so a label or a description makes it a `group`,
+* unless the component has a role of its own.
+*/
+function namedRole(aria, explicit) {
+	if (explicit !== void 0) return explicit;
+	return aria["aria-label"] !== void 0 || aria["aria-description"] !== void 0 ? "group" : void 0;
+}
+/**
+* The part of the attributes for the focusable control of a labelled pair:
+* its name and its description. ARIA names are not inherited, so the
+* wrapper of a control cannot name it.
+*/
+function controlAria(aria) {
+	const { "aria-label": label, "aria-description": description } = aria;
+	return {
+		...label === void 0 ? {} : { "aria-label": label },
+		...description === void 0 ? {} : { "aria-description": description }
+	};
+}
+/**
+* The part of the attributes for the wrapper around a control: hidden and
+* live cover the label and the control together.
+*/
+function wrapperAria(aria) {
+	const { "aria-hidden": hidden, "aria-live": live } = aria;
+	return {
+		...hidden === void 0 ? {} : { "aria-hidden": hidden },
+		...live === void 0 ? {} : { "aria-live": live }
+	};
+}
+
+//#endregion
+//#region src/v2/generative-ui/events.ts
+/**
+* The context of a running event binding: it reads the surface data model
+* and resolves relative paths against the template item of the component.
+* A function that needs a user gesture (openUrl) is not a value here
+* either; it runs through the dispatcher as the binding's functionCall.
+*/
+function eventContext(surface, basePath) {
+	return {
+		data: surface.model.dataModel,
+		basePath
+	};
+}
+/**
+* A value of an event binding with its dynamic values resolved: `{"@path"}`
+* bindings and function values, at any depth.
+*/
+function resolveValue(surface, basePath, value) {
+	return resolveDynamicValue(value, eventContext(surface, basePath)).value;
+}
+/**
+* The entries of an args or context record, each resolved on its own. The
+* record is not resolved as a whole, because a record with one `event` or
+* `functionCall` key would look like an action binding and stay as it is.
+*/
+function resolveValues(surface, basePath, values) {
+	return Object.fromEntries(Object.entries(values ?? {}).map(([key, value]) => [key, resolveValue(surface, basePath, value)]));
+}
+/**
+* The `userMessage` of an event binding, as text. A `{"@path"}` or a
+* function value is resolved. `undefined` when there is no message, or
+* the value is not a string.
+*/
+function resolveUserMessage(surface, basePath, userMessage) {
+	const value = resolveValue(surface, basePath, userMessage);
+	return typeof value === "string" ? value : void 0;
+}
+/**
+* Validates the component's args with the event `parameters`, then runs
+* `send` with them. Never throws: every failure is reported and becomes
+* `{ ok: false, error }`.
+*/
+async function runEvent(call, send) {
+	const { runtime, surface, componentId, name, parameters, args } = call;
+	const origin = {
+		surfaceId: surface.surfaceId,
+		componentId
+	};
+	try {
+		if (!parameters) return await send(args ?? {}, origin);
+		const result = validateSchema(parameters, args ?? {});
+		const parsed = result instanceof Promise ? await result : result;
+		if (!parsed.success) {
+			const error = new GenerativeUIError("invalid_event_args", `${name}: ${formatIssues(parsed.issues, "args")}`);
+			reportErrorSafely(runtime, {
+				kind: "event",
+				...origin,
+				error
+			});
+			return {
+				ok: false,
+				error
+			};
+		}
+		return await send(parsed.data ?? {}, origin);
+	} catch (cause) {
+		const error = new GenerativeUIError("event_forward_failed", `${name}: ${cause instanceof Error ? cause.message : String(cause)}`);
+		reportErrorSafely(runtime, {
+			kind: "event",
+			...origin,
+			error
+		});
+		return {
+			ok: false,
+			error
+		};
+	}
+}
+/**
+* Runs one call of an event that the model bound: validates the component's
+* args, merges them with the args from the binding (binding literals win),
+* then calls a declared function or forwards an agent event. Never throws.
+*/
+function invokeBoundEvent(params) {
+	const { runtime, surface, binding, basePath } = params;
+	return runEvent(params, (args, origin) => {
+		const componentArgs = args;
+		if ("functionCall" in binding) return runtime.dispatcher.invoke(binding.functionCall["@call"], {
+			...componentArgs,
+			...resolveValues(surface, basePath, binding.functionCall.args)
+		}, origin);
+		const { event } = binding;
+		const forwarded = {
+			name: event.name,
+			...origin,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			userMessage: resolveUserMessage(surface, basePath, event.userMessage),
+			context: {
+				...componentArgs,
+				...resolveValues(surface, basePath, event.context)
+			}
+		};
+		return runtime.forwardEvent(forwarded, surface.agentId);
+	});
+}
+/**
+* Runs one call of an event that matches a declared function: validates the
+* component's args with the event `parameters` (if any), then calls the
+* function, which validates them with its own schema. Never throws.
+*/
+function invokeMatchedEvent(params) {
+	const { runtime, functionName } = params;
+	return runEvent(params, (componentArgs, origin) => runtime.dispatcher.invoke(functionName, componentArgs, origin));
+}
+
+//#endregion
+//#region src/v2/generative-ui/theme.ts
+/**
+* The built-in dark values. The light values are the fallbacks in the
+* components, so a surface is light when no variable is set.
+*/
+const DARK_THEME = {
+	"--a2ui-color-text-default": "#ececec",
+	"--a2ui-color-text-prose": "#ececec",
+	"--a2ui-color-text-primary": "#ececec",
+	"--a2ui-color-text-emphasis": "#fff",
+	"--a2ui-color-text-secondary": "#b4b4b4",
+	"--a2ui-color-text-tertiary": "#8e8e8e",
+	"--a2ui-color-text-success": "#4fd1a5",
+	"--a2ui-color-text-info": "#6cb6ff",
+	"--a2ui-color-text-warning": "#e3b341",
+	"--a2ui-color-text-caution": "#e3b341",
+	"--a2ui-color-text-danger": "#ff7b72",
+	"--a2ui-color-text-discovery": "#bc9cff",
+	"--a2ui-color-surface": "#1f1f1f",
+	"--a2ui-color-surface-secondary": "#2a2a2a",
+	"--a2ui-color-surface-tertiary": "#3a3a3a",
+	"--a2ui-color-surface-elevated": "#262626",
+	"--a2ui-color-surface-elevated-secondary": "#2f2f2f",
+	"--a2ui-color-surface-inverted": "#f2f2f2",
+	"--a2ui-color-surface-soft": "#232323",
+	"--a2ui-color-info": "rgba(80, 160, 255, 0.14)",
+	"--a2ui-color-warning": "rgba(240, 180, 60, 0.14)",
+	"--a2ui-color-caution": "rgba(240, 180, 60, 0.14)",
+	"--a2ui-color-success": "rgba(60, 200, 150, 0.14)",
+	"--a2ui-color-danger": "rgba(255, 110, 100, 0.14)",
+	"--a2ui-color-discovery": "rgba(170, 130, 255, 0.14)",
+	"--a2ui-color-info-soft": "rgba(80, 160, 255, 0.08)",
+	"--a2ui-color-warning-soft": "rgba(240, 180, 60, 0.08)",
+	"--a2ui-color-caution-soft": "rgba(240, 180, 60, 0.08)",
+	"--a2ui-color-success-soft": "rgba(60, 200, 150, 0.08)",
+	"--a2ui-color-danger-soft": "rgba(255, 110, 100, 0.08)",
+	"--a2ui-color-discovery-soft": "rgba(170, 130, 255, 0.08)",
+	"--a2ui-color-info-solid": "#3b8eea",
+	"--a2ui-color-warning-solid": "#c99a2e",
+	"--a2ui-color-caution-solid": "#c99a2e",
+	"--a2ui-color-success-solid": "#2fae86",
+	"--a2ui-color-danger-solid": "#e5534b",
+	"--a2ui-color-discovery-solid": "#9a6ff0",
+	"--a2ui-color-border-default": "rgba(255, 255, 255, 0.12)",
+	"--a2ui-color-border-subtle": "rgba(255, 255, 255, 0.06)",
+	"--a2ui-color-border-strong": "#4a4a4a",
+	"--a2ui-color-border-info": "#2f5f8f",
+	"--a2ui-color-border-warning": "#6b5420",
+	"--a2ui-color-border-caution": "#6b5420",
+	"--a2ui-color-border-success": "#1f5f4b",
+	"--a2ui-color-border-danger": "#7a2f2b",
+	"--a2ui-color-border-discovery": "#4f3a80",
+	"--a2ui-color-border-control": "rgba(255, 255, 255, 0.2)",
+	"--a2ui-color-accent": "#f2f2f2",
+	"--a2ui-color-on-accent": "#0d0d0d",
+	"--a2ui-color-panel": "#262626",
+	"--a2ui-color-control": "#2f2f2f",
+	"--a2ui-color-focus": "#3b9bff",
+	"--a2ui-color-shimmer": "rgba(255, 255, 255, 0.12)",
+	"--a2ui-color-chart-cursor": "rgba(255, 255, 255, 0.06)",
+	"--a2ui-color-slider-track": "rgba(255, 255, 255, 0.1)",
+	"--a2ui-color-badge-secondary": "rgba(255, 255, 255, 0.08)",
+	"--a2ui-color-highlight-green": "#1d4a37",
+	"--a2ui-color-highlight-orange": "#4d3418",
+	"--a2ui-color-highlight-pink": "#4d2338",
+	"--a2ui-shadow-xs": "0 1px 2px rgba(0, 0, 0, 0.5)",
+	"--a2ui-shadow-sm": "0 1px 3px rgba(0, 0, 0, 0.5)",
+	"--a2ui-shadow-soft": "0 1px 3px rgba(0, 0, 0, 0.3)",
+	"--a2ui-shadow-md": "0 4px 12px rgba(0, 0, 0, 0.4)"
+};
+const VARIABLE_NAME = /^--a2ui-[a-z0-9-]+$/;
+const UNSAFE_VALUE = /[{};<>]/;
+/** Matches the `dark` class on an ancestor of a surface, or on the surface. */
+const DARK = ":where(.dark)";
+/** The default dark values, as a rule that any theme rule beats. */
+const DARK_THEME_CSS = `:where(.dark .a2ui-surface,.a2ui-surface.dark){${declarations(DARK_THEME)}}`;
+function declarations(values) {
+	return Object.entries(values ?? {}).filter(([name, value]) => VARIABLE_NAME.test(name) && typeof value === "string" && !UNSAFE_VALUE.test(value)).map(([name, value]) => `${name}:${value}`).join(";");
+}
+/** A short, stable id for a stylesheet. */
+function hashOf(text) {
+	let hash = 5381;
+	for (let index = 0; index < text.length; index++) hash = hash * 33 ^ text.charCodeAt(index);
+	return `t${(hash >>> 0).toString(36)}`;
+}
+/**
+* The stylesheet of a theme: its values on the surfaces that carry its id,
+* then its dark values in dark mode. `undefined` when the theme sets no
+* variable. Values that could break out of the rule are left out.
+*
+* @example
+* ```ts
+* themeStyleSheet({ "--a2ui-color-accent": "red" });
+* // { id: "t…", css: '.a2ui-surface[data-a2ui-theme="t…"]{--a2ui-color-accent:red}' }
+* ```
+*/
+function themeStyleSheet(theme) {
+	const { dark, ...base } = theme ?? {};
+	const both = declarations(base);
+	const darkOnly = declarations(dark);
+	if (!both && !darkOnly) return void 0;
+	const id = hashOf(`${both}|${darkOnly}`);
+	const self = `.a2ui-surface[data-a2ui-theme="${id}"]`;
+	return {
+		id,
+		css: [both && `${self}{${both}}`, darkOnly && `${DARK} ${self},${self}${DARK}{${darkOnly}}`].filter(Boolean).join("")
+	};
+}
+
+//#endregion
+//#region src/v2/generative-ui/SurfaceView.tsx
+const NO_ANCESTORS = [];
+const ROOT_STYLE = { display: "contents" };
+const undefinedSnapshot = () => void 0;
+const noopSubscribe = () => () => {};
+const zeroSnapshot = () => 0;
+/** A "multiple" slot value that repeats a component for each list item. */
+function isTemplateChildren(value) {
+	return typeof value === "object" && value !== null && "componentId" in value && typeof value.componentId === "string" && "path" in value && typeof value.path === "string";
+}
+function SurfaceView({ surface }) {
+	const runtime = useRequiredGenerativeUIRuntime();
+	const { theme } = runtime;
+	const sheet = (0, react.useMemo)(() => themeStyleSheet(theme), [theme]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+		className: "a2ui-surface",
+		"data-generative-ui-root": surface.surfaceId,
+		"data-a2ui-theme": sheet?.id,
+		style: ROOT_STYLE,
+		children: [sheet ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("style", { dangerouslySetInnerHTML: { __html: sheet.css } }) : null, /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SurfaceBoundary, {
+			surfaceId: surface.surfaceId,
+			runtime,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeView, {
+				surface,
+				componentId: _copilotkit_shared.GENERATIVE_UI_ROOT_ID,
+				basePath: void 0,
+				ancestors: NO_ANCESTORS
+			})
+		})]
+	});
+}
+/**
+* Resolves a component by id. Subscribes to the manager rather than web_core's
+* `onCreated`/`onDeleted`: web_core's EventEmitter awaits each listener in turn,
+* so with several subscribers (one per slotted child, or one per mount of the
+* same surface) all but the first are notified a microtask late. That is only
+* visible inside synchronous flushes such as `act()` / `flushSync`, where the
+* old tree would still be on screen, but it makes updates order-dependent.
+* The manager notifies synchronously once an ingest has been fully applied.
+*/
+function useComponentModel(manager, model, id) {
+	return (0, react.useSyncExternalStore)(manager.subscribe, () => model.componentsModel.get(id), undefinedSnapshot);
+}
+/** Same reasoning as `useComponentModel`: never rely on web_core's emitters. */
+function useComponentProperties(manager, component) {
+	return (0, react.useSyncExternalStore)(manager.subscribe, () => component?.properties, undefinedSnapshot);
+}
+/**
+* The id of a node in the ancestor list. A template renders the same
+* component once per item, so the item path is part of the id. A real cycle
+* repeats both.
+*/
+function scopedId(componentId, basePath) {
+	return `${basePath ?? ""}#${componentId}`;
+}
+const NodeView = (0, react.memo)(function NodeView({ surface, componentId, basePath, ancestors }) {
+	const runtime = useRequiredGenerativeUIRuntime();
+	const component = useComponentModel(runtime.manager, surface.model, componentId);
+	const properties = useComponentProperties(runtime.manager, component);
+	if (ancestors.includes(scopedId(componentId, basePath))) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DefaultNodeFallback, {
+		message: `cyclic reference to ${componentId}`,
+		componentId
+	});
+	if (!component || !properties) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodePlaceholder, { componentId });
+	const definition = runtime.ui.components.get(component.type);
+	if (!definition) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DefaultNodeFallback, {
+		message: `unknown component "${component.type}"`,
+		componentId
+	});
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeBoundary, {
+		surfaceId: surface.surfaceId,
+		componentId,
+		revision: properties,
+		runtime,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ResolvedNode, {
+			surface,
+			componentId,
+			definition,
+			properties,
+			runtime,
+			basePath,
+			ancestors
+		})
+	}, component.type);
+});
+/**
+* Renders the component of a template once for each item of the list at the
+* template path, keyed by index. Renders nothing when there is no list.
+*/
+function TemplateChildren({ surface, template, basePath, ancestors }) {
+	const dataModel = surface.model.dataModel;
+	const listPath = resolvePath(template.path, basePath);
+	const subscribe = (0, react.useCallback)((onChange) => {
+		const subscription = dataModel.subscribe(listPath, onChange);
+		return () => subscription.unsubscribe();
+	}, [dataModel, listPath]);
+	const getCount = () => {
+		const list = dataModel.get(listPath);
+		return Array.isArray(list) ? list.length : 0;
+	};
+	const count = (0, react.useSyncExternalStore)(subscribe, getCount, zeroSnapshot);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: Array.from({ length: count }, (_, index) => index).map((index) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeView, {
+		surface,
+		componentId: template.componentId,
+		basePath: joinPath(listPath, String(index)),
+		ancestors
+	}, index)) });
+}
+/**
+* The props the model sets, with their dynamic values resolved from the
+* surface data model: `{"@path"}` bindings, `{"@call"}` function values and
+* `{"@call":"@index"}` in a template, at any depth. A literal writable prop
+* that the component set shows the local value from `overrides`. Bound
+* props, events and slots are left out, and so are the keys of the A2UI
+* component envelope; `accessibility` is resolved the same way and given
+* on its own.
+*
+* A prop is resolved again only when its raw value or a data model value it
+* read has changed, so the result keeps its identity otherwise. A function
+* value that cannot be computed gives a problem instead of values.
+*/
+function useModelDataProps(surface, definition, properties, basePath, overrides) {
+	const dataModel = surface.model.dataModel;
+	const units = (0, react.useMemo)(() => {
+		const list = [];
+		for (const key of Object.keys(properties)) {
+			if (definition.events?.[key] || definition.slots?.[key] || Object.hasOwn(definition.selectors, key) || _copilotkit_shared.A2UI_COMPONENT_ENVELOPE_KEYS.has(key)) continue;
+			list.push({
+				key,
+				raw: properties[key]
+			});
+		}
+		const a11y = properties.accessibility;
+		if (typeof a11y === "object" && a11y !== null && !Array.isArray(a11y)) for (const [field, raw] of Object.entries(a11y)) list.push({
+			key: `accessibility/${field}`,
+			raw,
+			field
+		});
+		return list;
+	}, [properties, definition]);
+	const [, rerender] = (0, react.useReducer)((n) => n + 1, 0);
+	const cache = (0, react.useRef)(/* @__PURE__ */ new Map());
+	const values = {};
+	const a11yValues = {};
+	const paths = /* @__PURE__ */ new Set();
+	let problem;
+	const next = /* @__PURE__ */ new Map();
+	for (const { key, raw, field } of units) {
+		const cached = cache.current.get(key);
+		const isFresh = cached !== void 0 && cached.raw === raw && cached.basePath === basePath && [...cached.reads].every(([path, value]) => Object.is(dataModel.get(path), value));
+		const resolve = () => {
+			const resolved = tryResolveDynamicValue(raw, {
+				data: dataModel,
+				basePath
+			}, { isChecks: key === "checks" });
+			const reads = /* @__PURE__ */ new Map();
+			for (const path of resolved.paths) reads.set(path, dataModel.get(path));
+			return {
+				raw,
+				basePath,
+				reads,
+				outcome: resolved.ok ? {
+					ok: true,
+					value: resolved.value
+				} : {
+					ok: false,
+					message: resolved.error.message
+				}
+			};
+		};
+		const entry = isFresh && cached ? cached : resolve();
+		next.set(key, entry);
+		if (field !== void 0) {
+			if (entry.outcome.ok) a11yValues[field] = entry.outcome.value;
+		} else if (entry.outcome.ok) values[key] = entry.outcome.value;
+		else problem ??= `${key}: ${entry.outcome.message}`;
+		for (const path of entry.reads.keys()) paths.add(path);
+	}
+	cache.current = next;
+	const accessibility = readAccessibility(a11yValues);
+	for (const [key, value] of Object.entries(overrides)) if (!(0, _copilotkit_shared.isPathBinding)(properties[key])) values[key] = value;
+	const rendered = (0, react.useRef)(next);
+	rendered.current = next;
+	const pathKey = [...paths].sort().join("\n");
+	(0, react.useEffect)(() => {
+		const list = pathKey === "" ? [] : pathKey.split("\n");
+		const onChange = () => {
+			cache.current = /* @__PURE__ */ new Map();
+			rerender();
+		};
+		const subscriptions = list.map((path) => dataModel.subscribe(path, onChange));
+		if ([...rendered.current.values()].some((entry) => [...entry.reads].some(([path, value]) => !Object.is(dataModel.get(path), value)))) rerender();
+		return () => subscriptions.forEach((s) => s.unsubscribe());
+	}, [dataModel, pathKey]);
+	const stable = (0, react.useRef)({
+		ok: true,
+		values: {},
+		accessibility: void 0
+	});
+	const result = problem === void 0 ? {
+		ok: true,
+		values,
+		accessibility
+	} : {
+		ok: false,
+		problem
+	};
+	const last = stable.current;
+	if (!(result.ok && last.ok ? shallowEqual(last.values, result.values) && shallowEqual(last.accessibility ?? {}, result.accessibility ?? {}) : !result.ok && !last.ok && last.problem === result.problem)) stable.current = result;
+	return stable.current;
+}
+const NO_SELECTION = {
+	ok: true,
+	values: {}
+};
+function isSameSelection(a, b) {
+	if (a.ok && b.ok) return shallowEqual(a.values, b.values);
+	if (!a.ok && !b.ok) return a.problem === b.problem;
+	return false;
+}
+/** Runs every selector of a node. A selector that throws gives a problem. */
+function select(definition, state, modelProps) {
+	const values = {};
+	const selectors = Object.entries(definition.selectors);
+	for (const [key, selector] of selectors) try {
+		values[key] = selector(state, modelProps);
+	} catch (error) {
+		return {
+			ok: false,
+			problem: `${key}: selector threw: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+	return {
+		ok: true,
+		values
+	};
+}
+/**
+* The values of the bound props of a node, read from the app state.
+*
+* The selectors run again only when the state object or the parsed model
+* props change. When the new values are shallow-equal to the last ones, the
+* last snapshot is kept. So the node re-renders only when a selected value
+* changes. A selector that returns a new array on each call cannot cause a
+* render loop: with the same inputs, the cached snapshot comes back.
+*
+* A node without bound props does not subscribe to the state.
+*/
+function useSelection(manager, definition, modelProps) {
+	const hasSelectors = Object.keys(definition.selectors).length > 0;
+	const cache = (0, react.useRef)(void 0);
+	const getSnapshot = () => {
+		if (!hasSelectors || modelProps === void 0) return NO_SELECTION;
+		const state = manager.getState();
+		const cached = cache.current;
+		if (cached !== void 0 && cached.state === state && cached.modelProps === modelProps) return cached.selection;
+		const next = select(definition, state, modelProps);
+		const selection = cached !== void 0 && isSameSelection(cached.selection, next) ? cached.selection : next;
+		cache.current = {
+			state,
+			modelProps,
+			selection
+		};
+		return selection;
+	};
+	return (0, react.useSyncExternalStore)(hasSelectors ? manager.subscribe : noopSubscribe, getSnapshot, getSnapshot);
+}
+/**
+* Checks the model-set props with the props schema before the selectors run.
+* The bound props are not set yet, so their issues do not count. Neither do
+* issues with no path (a check over several props), which the full check
+* after the selectors reports.
+*/
+function checkModelProps(definition, modelData) {
+	if (!definition.props) return {
+		ok: true,
+		values: {}
+	};
+	let values = modelData;
+	let result = validateSchemaSync(definition.props, values);
+	if (!result.success) {
+		const unset = withoutRejectedNulls(values, result.issues);
+		if (unset) {
+			values = unset;
+			result = validateSchemaSync(definition.props, values);
+		}
+	}
+	if (!result.success) {
+		const issues = result.issues.filter((issue) => {
+			const key = issueKey(issue);
+			return key === void 0 ? isAsyncIssue(issue) : !Object.hasOwn(definition.selectors, key);
+		});
+		if (issues.length > 0) return {
+			ok: false,
+			problem: formatIssues(issues)
+		};
+	}
+	return {
+		ok: true,
+		values
+	};
+}
+/**
+* The data props of a node, in three steps: check the model-set props with
+* the props schema, run the selectors with them, then parse all props with
+* the props schema. Gives the reason when a step fails.
+*/
+function useDataProps(runtime, surface, definition, properties, basePath, overrides) {
+	const modelData = useModelDataProps(surface, definition, properties, basePath, overrides);
+	const modelCheck = (0, react.useMemo)(() => modelData.ok ? checkModelProps(definition, modelData.values) : modelData, [definition, modelData]);
+	const selection = useSelection(runtime.manager, definition, modelCheck.ok ? modelCheck.values : void 0);
+	const accessibility = modelData.ok ? modelData.accessibility : void 0;
+	return (0, react.useMemo)(() => {
+		if (!modelCheck.ok) return modelCheck;
+		if (!selection.ok) return selection;
+		if (!definition.props) return {
+			ok: true,
+			props: {},
+			accessibility
+		};
+		const input = {
+			...modelCheck.values,
+			...selection.values
+		};
+		let parsed = validateSchemaSync(definition.props, input);
+		if (!parsed.success) {
+			const unset = withoutRejectedNulls(input, parsed.issues);
+			if (unset) parsed = validateSchemaSync(definition.props, unset);
+		}
+		if (!parsed.success) return {
+			ok: false,
+			problem: formatIssues(parsed.issues)
+		};
+		return {
+			ok: true,
+			props: parsed.data,
+			accessibility
+		};
+	}, [
+		definition,
+		modelCheck,
+		selection,
+		accessibility
+	]);
+}
+/**
+* The event props of a node. A matched event (one that matches a declared
+* function) is always bound. An unmatched event is bound only when the model
+* bound it.
+*/
+function useEventProps(runtime, surface, componentId, definition, properties, basePath) {
+	const latest = (0, react.useRef)(properties);
+	latest.current = properties;
+	const boundNames = Object.keys(definition.events ?? {}).filter((name) => Object.hasOwn(definition.eventFunctions, name) || (0, _copilotkit_shared.isActionBinding)(properties[name])).join("|");
+	return (0, react.useMemo)(() => {
+		const handlers = {};
+		const names = boundNames ? boundNames.split("|") : [];
+		for (const name of names) {
+			const call = {
+				runtime,
+				surface,
+				componentId,
+				name,
+				parameters: definition.events?.[name]?.parameters
+			};
+			const functionName = Object.hasOwn(definition.eventFunctions, name) ? definition.eventFunctions[name] : void 0;
+			handlers[name] = functionName === void 0 ? (args) => invokeBoundEvent({
+				...call,
+				binding: latest.current[name],
+				basePath,
+				args
+			}) : (args) => invokeMatchedEvent({
+				...call,
+				functionName,
+				args
+			});
+		}
+		return handlers;
+	}, [
+		boundNames,
+		runtime,
+		surface,
+		componentId,
+		definition,
+		basePath
+	]);
+}
+/**
+* The setter props of a node: `setValue` for the writable prop `value`. For
+* a prop the model bound to `{"@path"}`, the setter writes the data model
+* and makes the path user-owned. For a literal prop, it sets `overrides`, a
+* local value of this mounted node. The setters keep their identity.
+*/
+function useSetterProps(runtime, surface, componentId, definition, properties, basePath) {
+	const [overrides, setOverrides] = (0, react.useState)({});
+	const latest = (0, react.useRef)(properties);
+	latest.current = properties;
+	return {
+		overrides,
+		setters: (0, react.useMemo)(() => {
+			const result = {};
+			const writable = definition.writable ?? [];
+			for (const key of writable) result[setterNameOf(key)] = (value) => {
+				const binding = latest.current[key];
+				if (!(0, _copilotkit_shared.isPathBinding)(binding)) {
+					setOverrides((current) => ({
+						...current,
+						[key]: value
+					}));
+					return;
+				}
+				try {
+					runtime.manager.setOwnedValue(surface.key, resolvePath(binding["@path"], basePath), value);
+				} catch (cause) {
+					const message = cause instanceof Error ? cause.message : String(cause);
+					reportErrorSafely(runtime, {
+						kind: "props",
+						surfaceId: surface.surfaceId,
+						componentId,
+						error: /* @__PURE__ */ new Error(`${setterNameOf(key)}: ${message}`)
+					});
+				}
+			};
+			return result;
+		}, [
+			runtime,
+			surface,
+			componentId,
+			definition,
+			basePath
+		])
+	};
+}
+function useSlotProps(surface, definition, properties, componentId, basePath, ancestors) {
+	return (0, react.useMemo)(() => {
+		const childAncestors = [...ancestors, scopedId(componentId, basePath)];
+		const slots = {};
+		for (const [name, kind] of Object.entries(definition.slots ?? {})) {
+			const value = properties[name];
+			if (kind === "single" && typeof value === "string") slots[name] = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeView, {
+				surface,
+				componentId: value,
+				basePath,
+				ancestors: childAncestors
+			});
+			else if (kind === "multiple" && isTemplateChildren(value)) slots[name] = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TemplateChildren, {
+				surface,
+				template: value,
+				basePath,
+				ancestors: childAncestors
+			});
+			else if (kind === "multiple" && Array.isArray(value)) slots[name] = [...new Set(value.filter((id) => typeof id === "string"))].map((id) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeView, {
+				surface,
+				componentId: id,
+				basePath,
+				ancestors: childAncestors
+			}, id));
+		}
+		return slots;
+	}, [
+		surface,
+		definition,
+		properties,
+		componentId,
+		basePath,
+		ancestors
+	]);
+}
+/**
+* The parsed data props with every typed child reference (`child()`,
+* `childList()`, at any depth) replaced by the rendered component. Without
+* references, the parsed props come back as they are.
+*/
+function useChildRefProps(surface, refs, props, componentId, basePath, ancestors) {
+	return (0, react.useMemo)(() => {
+		if (props === void 0 || refs.length === 0) return props;
+		const childAncestors = [...ancestors, scopedId(componentId, basePath)];
+		const render = (kind, value) => {
+			if (kind === "single") return typeof value === "string" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeView, {
+				surface,
+				componentId: value,
+				basePath,
+				ancestors: childAncestors
+			}) : void 0;
+			if (isTemplateChildren(value)) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TemplateChildren, {
+				surface,
+				template: value,
+				basePath,
+				ancestors: childAncestors
+			});
+			if (!Array.isArray(value)) return void 0;
+			return [...new Set(value.filter((id) => typeof id === "string"))].map((id) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeView, {
+				surface,
+				componentId: id,
+				basePath,
+				ancestors: childAncestors
+			}, id));
+		};
+		let result = props;
+		for (const ref of refs) result = (0, _copilotkit_shared.mapAtChildRef)(result, ref.path, (found) => render(ref.kind, found));
+		return result;
+	}, [
+		surface,
+		refs,
+		props,
+		componentId,
+		basePath,
+		ancestors
+	]);
+}
+function ResolvedNode({ surface, componentId, definition, properties, runtime, basePath, ancestors }) {
+	const { overrides, setters } = useSetterProps(runtime, surface, componentId, definition, properties, basePath);
+	const dataProps = useDataProps(runtime, surface, definition, properties, basePath, overrides);
+	const eventProps = useEventProps(runtime, surface, componentId, definition, properties, basePath);
+	const slotProps = useSlotProps(surface, definition, properties, componentId, basePath, ancestors);
+	const childRefProps = useChildRefProps(surface, definition.childRefs, dataProps.ok ? dataProps.props : void 0, componentId, basePath, ancestors);
+	const accessibility = dataProps.ok ? dataProps.accessibility : void 0;
+	const nodeContext = (0, react.useMemo)(() => ({
+		surfaceKey: surface.key,
+		surfaceId: surface.surfaceId,
+		componentId,
+		accessibility
+	}), [
+		surface.key,
+		surface.surfaceId,
+		componentId,
+		accessibility
+	]);
+	const problem = dataProps.ok ? void 0 : dataProps.problem;
+	(0, react.useEffect)(() => {
+		if (problem) reportErrorSafely(runtime, {
+			kind: "props",
+			surfaceId: surface.surfaceId,
+			componentId,
+			error: /* @__PURE__ */ new Error(`Invalid props: ${problem}`)
+		});
+	}, [
+		problem,
+		runtime,
+		surface.surfaceId,
+		componentId
+	]);
+	if (!dataProps.ok) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DefaultNodeFallback, {
+		message: `invalid props (${problem})`,
+		componentId
+	});
+	const Component = definition.component;
+	const rendered = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Component, {
+		...childRefProps,
+		...eventProps,
+		...slotProps,
+		...setters
+	});
+	const hasEnvelope = properties.accessibility !== void 0 && definition.accessibility !== "self";
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(GenerativeUINodeContext.Provider, {
+		value: nodeContext,
+		children: hasEnvelope ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+			"data-a2ui-accessibility": "",
+			style: ROOT_STYLE,
+			...wrapperAria(accessibilityAttributes(accessibility)),
+			children: rendered
+		}) : rendered
+	});
+}
+
+//#endregion
+//#region src/v2/generative-ui/chat.tsx
+const GenerativeUIChatSlotContext = (0, react.createContext)(void 0);
+function DefaultGenerativeUIChatCard({ surfaceId, isStreaming, error, children }) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+		"data-generative-ui-chat-surface": surfaceId,
+		className: "cpk:my-2 cpk:w-full cpk:rounded-xl cpk:border cpk:border-gray-200 cpk:p-3",
+		children: [children, error && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			role: "alert",
+			className: "cpk:mt-2 cpk:text-xs cpk:text-red-600",
+			children: "Part of this UI couldn't be shown."
+		})]
+	});
+}
+const ContentSchema = zod.z.object({
+	surfaceId: zod.z.string(),
+	target: zod.z.string(),
+	catalogId: zod.z.string(),
+	operations: zod.z.array(zod.z.any()),
+	status: zod.z.enum([
+		"streaming",
+		"ready",
+		"error"
+	]),
+	rejected: zod.z.array(zod.z.object({
+		index: zod.z.number(),
+		reason: zod.z.string()
+	})).default([])
+}).passthrough();
+function GenerativeUIChatActivity({ content, agent }) {
+	const runtime = useGenerativeUIRuntime();
+	const threadId = useCopilotChatConfiguration()?.threadId ?? agent?.threadId;
+	const Wrapper = (0, react.useContext)(GenerativeUIChatSlotContext) ?? DefaultGenerativeUIChatCard;
+	useManagerVersion(runtime);
+	(0, react.useLayoutEffect)(() => {
+		if (runtime && threadId) runtime.manager.ingest(threadId, agent?.agentId, content);
+	}, [
+		runtime,
+		threadId,
+		agent?.agentId,
+		content
+	]);
+	if (!runtime || !threadId || content.target !== _copilotkit_shared.GENERATIVE_UI_CHAT_TARGET) return null;
+	const surface = runtime.manager.getSurface(threadId, content.surfaceId) ?? runtime.manager.getFailedSurface(threadId, content.surfaceId);
+	if (!surface) return null;
+	const rejected = [...content.rejected ?? [], ...surface.clientRejected];
+	const error = rejected.length ? new Error(`${rejected.length} UI update(s) could not be shown`, { cause: rejected }) : void 0;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Wrapper, {
+		surfaceId: content.surfaceId,
+		isStreaming: content.status === "streaming",
+		error,
+		rejected,
+		children: surface.failed ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SurfaceView, { surface })
+	});
+}
+function createGenerativeUIActivityRenderer() {
+	return {
+		activityType: _copilotkit_shared.GENERATIVE_UI_ACTIVITY_TYPE,
+		content: ContentSchema,
+		render: GenerativeUIChatActivity
+	};
+}
+/**
+* Shows nothing in the chat for an agent-called function. The root reads the
+* function-call activities from the messages and runs them. This renderer
+* only keeps a wildcard ("*") activity renderer from showing them.
+*/
+function createGenerativeUIFunctionCallActivityRenderer() {
+	return {
+		activityType: _copilotkit_shared.GENERATIVE_UI_FUNCTION_CALL_ACTIVITY_TYPE,
+		content: zod.z.unknown(),
+		render: () => null
+	};
+}
+/** Hides the raw `render_ui` tool call; the surface activity owns the UX. */
+function GenerativeUIToolCallRenderer() {
+	const { copilotkit } = (0, _copilotkit_react_core_v2_context.useCopilotKit)();
+	(0, react.useEffect)(() => {
+		const renderer = defineToolCallRenderer({
+			name: _copilotkit_shared.GENERATIVE_UI_RENDER_TOOL,
+			args: zod.z.any(),
+			render: () => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, {})
+		});
+		const existing = copilotkit._renderToolCalls ?? [];
+		copilotkit.setRenderToolCalls([...existing.filter((rc) => rc.name !== _copilotkit_shared.GENERATIVE_UI_RENDER_TOOL), renderer]);
+	}, [copilotkit]);
+	return null;
+}
+
+//#endregion
+//#region src/v2/generative-ui/markdown/MarkdownSurfaces.tsx
+const FADE_STYLE_ID = "a2ui-markdown-fade";
+/**
+* Components fade in as they stream: each element that appears under a
+* markdown surface runs the keyframes once on mount. React keeps the keys
+* stable per component id, so an element that is already there never
+* animates again. SVG internals are left out: a chart library re-creates
+* its nodes on each render, and a fade on each of them would read as the
+* chart flashing whenever a sibling arrives. The fade runs under reduced
+* motion too, because it moves nothing.
+*/
+const FADE_CSS = ["@keyframes a2ui-fade-in{from{opacity:0}}", "[data-a2ui-markdown-surface] .a2ui-surface *:not(svg):not(svg *){animation:a2ui-fade-in .35s ease-out backwards}"].join("\n");
+const noEffect = () => {};
+const useInjectEffect = typeof document === "undefined" ? noEffect : react.useInsertionEffect;
+function useFadeStyles() {
+	useInjectEffect(() => {
+		if (document.getElementById(FADE_STYLE_ID)) return;
+		const style = document.createElement("style");
+		style.id = FADE_STYLE_ID;
+		style.textContent = FADE_CSS;
+		document.head.appendChild(style);
+	}, []);
+}
+/**
+* The default wrapper of a chat surface in the markdown transport. It draws
+* no box: a surface sits in the flow of the reply like a paragraph, and a
+* Card draws its own box when it is interactive. Nothing shows while the
+* surface streams. A rejected operation gets one line.
+*/
+function DefaultMarkdownChatSurface({ surfaceId, error, children }) {
+	useFadeStyles();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+		"data-generative-ui-chat-surface": surfaceId,
+		"data-a2ui-markdown-surface": surfaceId,
+		className: "cpk:relative cpk:my-4 cpk:flex cpk:w-full cpk:min-w-0 cpk:max-w-full cpk:flex-col",
+		children: [children, error && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			role: "alert",
+			className: "cpk:mt-2 cpk:text-xs cpk:text-red-600",
+			children: "Part of this UI couldn't be shown."
+		})]
+	});
+}
+/**
+* One chat surface in the chat wrapper. Nothing renders until the surface
+* has its root component, so a half-streamed fence shows no empty card.
+*/
+function ChatSurface({ runtime, threadId, surfaceId, Wrapper }) {
+	const surface = runtime.manager.getSurface(threadId, surfaceId) ?? runtime.manager.getFailedSurface(threadId, surfaceId);
+	const root = surface?.model.componentsModel.get(_copilotkit_shared.GENERATIVE_UI_ROOT_ID);
+	if (!surface || !root && !surface.failed) return null;
+	const rejected = [...surface.serverRejected, ...surface.clientRejected];
+	const error = rejected.length ? new Error(`${rejected.length} UI update(s) could not be shown`, { cause: rejected }) : void 0;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Wrapper, {
+		surfaceId,
+		isStreaming: surface.status === "streaming",
+		error,
+		rejected,
+		children: surface.failed ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SurfaceView, { surface })
+	});
+}
+/** The blocks of one fence: lifted prose and chat surfaces, in order. */
+function FenceBlocks({ blocks, runtime, threadId, markdownProps }) {
+	const Wrapper = (0, react.useContext)(GenerativeUIChatSlotContext) ?? DefaultMarkdownChatSurface;
+	let surfaceCount = 0;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: blocks.map((block) => {
+		if (block.kind === "markdown") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(streamdown.Streamdown, {
+			...markdownProps,
+			children: block.markdown
+		}, `md-${surfaceCount}`);
+		surfaceCount++;
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ChatSurface, {
+			runtime,
+			threadId,
+			surfaceId: block.surfaceId,
+			Wrapper
+		}, block.surfaceId);
+	}) });
+}
+/**
+* Experimental. Renders an assistant message of the markdown transport.
+* Prose renders as markdown. In place of each ```a2ui fence:
+*
+* - the fence that created a chat surface renders that surface (and the
+*   prose lifted out of it) in the chat wrapper;
+* - every other fence renders nothing: a fence that updates the surface of
+*   an earlier fence, or a fence for a named target, which
+*   `<GenerativeUISurface id>` renders.
+*
+* Use it inside `<CopilotKitProvider generativeUI={{ ui, transport: "markdown" }}>`.
+* `CopilotChatAssistantMessage` uses it there on its own.
+*
+* @example
+* ```tsx
+* <MarkdownSurfaces content={message.content} messageId={message.id} />
+* ```
+*/
+function MarkdownSurfaces({ content, messageId, ...markdownProps }) {
+	const runtime = useRequiredGenerativeUIRuntime();
+	const chatThreadId = useCopilotChatConfiguration()?.threadId;
+	useManagerVersion(runtime);
+	const segments = (0, react.useMemo)(() => (0, _copilotkit_core.splitA2UIMarkdown)(content), [content]);
+	const threadId = chatThreadId ?? runtime.manager.getActiveThread();
+	const source = getMarkdownSurfaceSource(runtime);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: segments.map((segment, index) => {
+		if (segment.type === "markdown") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(streamdown.Streamdown, {
+			...markdownProps,
+			children: segment.text
+		}, `md-${index}`);
+		const blocks = threadId ? source.getFenceBlocks(threadId, messageId, segment.index) : void 0;
+		if (!threadId || !blocks) return null;
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FenceBlocks, {
+			blocks,
+			runtime,
+			threadId,
+			markdownProps
+		}, `a2ui-${segment.index}`);
+	}) });
+}
+
+//#endregion
+Object.defineProperty(exports, 'BASIC_FUNCTIONS', {
+  enumerable: true,
+  get: function () {
+    return BASIC_FUNCTIONS;
+  }
+});
+Object.defineProperty(exports, 'ControlledModalOpenScope', {
+  enumerable: true,
+  get: function () {
+    return ControlledModalOpenScope;
+  }
+});
+Object.defineProperty(exports, 'CopilotChatConfigurationProvider', {
+  enumerable: true,
+  get: function () {
+    return CopilotChatConfigurationProvider;
+  }
+});
+Object.defineProperty(exports, 'CopilotChatDefaultLabels', {
+  enumerable: true,
+  get: function () {
+    return CopilotChatDefaultLabels;
+  }
+});
+Object.defineProperty(exports, 'DARK_THEME_CSS', {
+  enumerable: true,
+  get: function () {
+    return DARK_THEME_CSS;
+  }
+});
+Object.defineProperty(exports, 'DefaultGenerativeUIChatCard', {
+  enumerable: true,
+  get: function () {
+    return DefaultGenerativeUIChatCard;
+  }
+});
+Object.defineProperty(exports, 'ExpressionError', {
+  enumerable: true,
+  get: function () {
+    return ExpressionError;
+  }
+});
+Object.defineProperty(exports, 'GenerativeUIChatSlotContext', {
+  enumerable: true,
+  get: function () {
+    return GenerativeUIChatSlotContext;
+  }
+});
+Object.defineProperty(exports, 'GenerativeUIError', {
+  enumerable: true,
+  get: function () {
+    return GenerativeUIError;
+  }
+});
+Object.defineProperty(exports, 'GenerativeUINodeContext', {
+  enumerable: true,
+  get: function () {
+    return GenerativeUINodeContext;
+  }
+});
+Object.defineProperty(exports, 'GenerativeUIRuntimeContext', {
+  enumerable: true,
+  get: function () {
+    return GenerativeUIRuntimeContext;
+  }
+});
+Object.defineProperty(exports, 'GenerativeUIToolCallRenderer', {
+  enumerable: true,
+  get: function () {
+    return GenerativeUIToolCallRenderer;
+  }
+});
+Object.defineProperty(exports, 'MarkdownSurfaces', {
+  enumerable: true,
+  get: function () {
+    return MarkdownSurfaces;
+  }
+});
+Object.defineProperty(exports, 'SurfaceView', {
+  enumerable: true,
+  get: function () {
+    return SurfaceView;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'catalogIdsOf', {
+  enumerable: true,
+  get: function () {
+    return catalogIdsOf;
+  }
+});
+Object.defineProperty(exports, 'componentCatalogIds', {
+  enumerable: true,
+  get: function () {
+    return componentCatalogIds;
+  }
+});
+Object.defineProperty(exports, 'containsDynamicValue', {
+  enumerable: true,
+  get: function () {
+    return containsDynamicValue;
+  }
+});
+Object.defineProperty(exports, 'controlAria', {
+  enumerable: true,
+  get: function () {
+    return controlAria;
+  }
+});
+Object.defineProperty(exports, 'createGenerativeUI', {
+  enumerable: true,
+  get: function () {
+    return createGenerativeUI;
+  }
+});
+Object.defineProperty(exports, 'createGenerativeUIActivityRenderer', {
+  enumerable: true,
+  get: function () {
+    return createGenerativeUIActivityRenderer;
+  }
+});
+Object.defineProperty(exports, 'createGenerativeUIFunctionCallActivityRenderer', {
+  enumerable: true,
+  get: function () {
+    return createGenerativeUIFunctionCallActivityRenderer;
+  }
+});
+Object.defineProperty(exports, 'defineToolCallRenderer', {
+  enumerable: true,
+  get: function () {
+    return defineToolCallRenderer;
+  }
+});
+Object.defineProperty(exports, 'formatIssues', {
+  enumerable: true,
+  get: function () {
+    return formatIssues;
+  }
+});
+Object.defineProperty(exports, 'getMarkdownSurfaceSource', {
+  enumerable: true,
+  get: function () {
+    return getMarkdownSurfaceSource;
+  }
+});
+Object.defineProperty(exports, 'isAsyncIssue', {
+  enumerable: true,
+  get: function () {
+    return isAsyncIssue;
+  }
+});
+Object.defineProperty(exports, 'isRecord', {
+  enumerable: true,
+  get: function () {
+    return isRecord;
+  }
+});
+Object.defineProperty(exports, 'issueKey', {
+  enumerable: true,
+  get: function () {
+    return issueKey;
+  }
+});
+Object.defineProperty(exports, 'namedRole', {
+  enumerable: true,
+  get: function () {
+    return namedRole;
+  }
+});
+Object.defineProperty(exports, 'shallowEqual', {
+  enumerable: true,
+  get: function () {
+    return shallowEqual;
+  }
+});
+Object.defineProperty(exports, 'toJsonSchema', {
+  enumerable: true,
+  get: function () {
+    return toJsonSchema;
+  }
+});
+Object.defineProperty(exports, 'useCopilotChatConfiguration', {
+  enumerable: true,
+  get: function () {
+    return useCopilotChatConfiguration;
+  }
+});
+Object.defineProperty(exports, 'useGenerativeUIAccessibility', {
+  enumerable: true,
+  get: function () {
+    return useGenerativeUIAccessibility;
+  }
+});
+Object.defineProperty(exports, 'useGenerativeUIFunction', {
+  enumerable: true,
+  get: function () {
+    return useGenerativeUIFunction;
+  }
+});
+Object.defineProperty(exports, 'useGenerativeUIRuntime', {
+  enumerable: true,
+  get: function () {
+    return useGenerativeUIRuntime;
+  }
+});
+Object.defineProperty(exports, 'useGenerativeUIState', {
+  enumerable: true,
+  get: function () {
+    return useGenerativeUIState;
+  }
+});
+Object.defineProperty(exports, 'useKatexStyles', {
+  enumerable: true,
+  get: function () {
+    return useKatexStyles;
+  }
+});
+Object.defineProperty(exports, 'useManagerVersion', {
+  enumerable: true,
+  get: function () {
+    return useManagerVersion;
+  }
+});
+Object.defineProperty(exports, 'useRequiredGenerativeUIRuntime', {
+  enumerable: true,
+  get: function () {
+    return useRequiredGenerativeUIRuntime;
+  }
+});
+Object.defineProperty(exports, 'useShallowStableRef', {
+  enumerable: true,
+  get: function () {
+    return useShallowStableRef;
+  }
+});
+Object.defineProperty(exports, 'validateSchemaSync', {
+  enumerable: true,
+  get: function () {
+    return validateSchemaSync;
+  }
+});
+Object.defineProperty(exports, 'withoutRejectedNulls', {
+  enumerable: true,
+  get: function () {
+    return withoutRejectedNulls;
+  }
+});
+Object.defineProperty(exports, 'wrapperAria', {
+  enumerable: true,
+  get: function () {
+    return wrapperAria;
+  }
+});
+//# sourceMappingURL=MarkdownSurfaces-D-OkjUpU.cjs.map