@copilotkit/react-core 2.0.0-next.1 → 2.0.0-rc.0

package/dist/MarkdownSurfaces-ChSlVYOk.mjs

@@ -0,0 +1,3655 @@
+import { extractFenceOperations, flattenInformationalCards, getMarkdownOperationSurfaceId, prepareSurfaceOperations, segmentSurfaceProse, splitA2UIMarkdown } from "@copilotkit/core";
+import React, { Component, createContext, memo, useCallback, useContext, useEffect, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { StreamingMarkdownRenderer, createStreamingMarkdownNodeRenderers } from "@copilotkit/markdown-renderer/react";
+import { warnUnsupportedRichSyntaxOnce } from "@copilotkit/markdown-renderer";
+import { twMerge } from "tailwind-merge";
+import { A2UI_COMPONENT_ENVELOPE_KEYS, A2UI_INDEX_FUNCTION, A2UI_VERSION, DEFAULT_AGENT_ID, GENERATIVE_UI_ACTIVITY_TYPE, GENERATIVE_UI_CHAT_TARGET, GENERATIVE_UI_FUNCTIONS, GENERATIVE_UI_FUNCTION_CALL_ACTIVITY_TYPE, GENERATIVE_UI_RENDER_TOOL, GENERATIVE_UI_ROOT_ID, applyChildRefMarks, childIdsAtRefs, collectChildRefs, functionCallers, getOperationKind, hasBoundChildRef, isActionBinding, isCallBinding, isPathBinding, isValidationResult, mapAtChildRef, randomUUID, schemaToJsonSchema, validateOperation } from "@copilotkit/shared";
+import { CopilotKitContext, useCopilotKit, useDefaultAgentId } from "@copilotkit/react-core/context";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+//#region src/components/chat/StreamingMarkdownDefaultRenderer.tsx
+const defaultNodeRenderers = createStreamingMarkdownNodeRenderers({ codeBlock: ({ node }) => /* @__PURE__ */ jsx("pre", {
+	className: "cpk:overflow-x-auto cpk:rounded-lg cpk:bg-muted cpk:text-foreground cpk:p-3",
+	children: /* @__PURE__ */ jsx("code", {
+		"data-code-info": node.info ?? void 0,
+		children: node.text
+	})
+}) });
+/**
+* react-core's built-in default markdown renderer — a thin adapter over
+* `@copilotkit/markdown-renderer`'s streaming renderer. Maps the pluggable
+* renderer contract (`{ content, isStreaming, className }`) onto the streaming
+* renderer for streaming-safe incremental rendering + per-token animation.
+* Still overridable via the slot/provider pluggable interface.
+*/
+function StreamingMarkdownDefaultRenderer({ content, isStreaming, className, nodeRenderers, caret, options, onLinkClick, onCitationClick }) {
+	const mergedNodeRenderers = useMemo(() => nodeRenderers ? createStreamingMarkdownNodeRenderers({
+		...defaultNodeRenderers,
+		...nodeRenderers
+	}) : defaultNodeRenderers, [nodeRenderers]);
+	if (!content) return null;
+	warnUnsupportedRichSyntaxOnce(content);
+	return /* @__PURE__ */ jsx(StreamingMarkdownRenderer, {
+		className,
+		isComplete: !isStreaming,
+		caret: caret ?? !!isStreaming,
+		nodeRenderers: mergedNodeRenderers,
+		options,
+		onLinkClick,
+		onCitationClick,
+		children: content
+	});
+}
+StreamingMarkdownDefaultRenderer.displayName = "StreamingMarkdownDefaultRenderer";
+
+//#endregion
+//#region src/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 = 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/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?",
+	reasoningMessageThinkingLabel: "Thinking…",
+	chatInputSlashMenuLabel: "Slash commands",
+	chatInputSlashMenuEmptyText: "No commands found",
+	attachmentRemoveButtonLabel: "Remove attachment",
+	attachmentPlayVideoButtonLabel: "Play video",
+	attachmentPreviewCloseButtonLabel: "Close preview",
+	modalHeaderCloseButtonLabel: "Close",
+	modalHeaderThreadsButtonLabel: "Open threads",
+	sidebarLabel: "Copilot chat sidebar"
+};
+/**
+* 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 = createContext(null);
+const CopilotChatConfigurationProvider = ({ children, labels, agentId, threadId, hasExplicitThreadId, isModalDefaultOpen }) => {
+	const parentConfig = useContext(CopilotChatConfiguration);
+	const stableLabels = useShallowStableRef(labels);
+	const mergedLabels = useMemo(() => ({
+		...CopilotChatDefaultLabels,
+		...parentConfig?.labels,
+		...stableLabels
+	}), [stableLabels, parentConfig?.labels]);
+	const providerAgentId = useDefaultAgentId();
+	const resolvedAgentId = agentId ?? parentConfig?.agentId ?? providerAgentId ?? DEFAULT_AGENT_ID;
+	const threadIdPropIsAuthoritative = threadId !== void 0 && hasExplicitThreadId !== false;
+	const isThreadIdControlled = threadIdPropIsAuthoritative;
+	const [activeThreadOverride, setActiveThreadOverride] = useState(null);
+	const resolvedThreadId = useMemo(() => {
+		if (threadIdPropIsAuthoritative) return threadId;
+		if (activeThreadOverride) return activeThreadOverride.threadId;
+		if (parentConfig?.threadId) return parentConfig.threadId;
+		if (threadId) return threadId;
+		return randomUUID();
+	}, [
+		threadIdPropIsAuthoritative,
+		threadId,
+		parentConfig?.threadId,
+		activeThreadOverride
+	]);
+	const copilotkit = useContext(CopilotKitContext)?.copilotkit;
+	const openThreadRef = useRef(null);
+	const latestThreadIdRef = useRef(resolvedThreadId);
+	latestThreadIdRef.current = resolvedThreadId;
+	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]);
+	useEffect(() => {
+		openThreadRef.current?.update(resolvedThreadId);
+	}, [resolvedThreadId]);
+	const resolvedHasExplicitThreadId = (threadIdPropIsAuthoritative ? true : activeThreadOverride?.explicit ?? hasExplicitThreadId ?? false) || !!parentConfig?.hasExplicitThreadId;
+	const [internalModalOpen, setInternalModalOpen] = useState(isModalDefaultOpen ?? true);
+	const hasExplicitDefault = isModalDefaultOpen !== void 0;
+	const setAndSync = useCallback((open) => {
+		setInternalModalOpen(open);
+		parentConfig?.setModalOpen(open);
+	}, [parentConfig?.setModalOpen]);
+	const isMounted = useRef(false);
+	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] = useState(false);
+	const [ownDrawerCount, setOwnDrawerCount] = useState(0);
+	const modalCloseRef = useRef(() => {});
+	modalCloseRef.current = resolvedSetModalOpen;
+	const registeredModalClosersRef = useRef([]);
+	const ownRegisterModalCloser = useCallback((closeModal) => {
+		registeredModalClosersRef.current.push(closeModal);
+		return () => {
+			registeredModalClosersRef.current = registeredModalClosersRef.current.filter((entry) => entry !== closeModal);
+		};
+	}, []);
+	const ownSetDrawerOpen = useCallback((open) => {
+		setOwnDrawerOpen(open);
+		if (open && isMobileViewport()) {
+			const registered = registeredModalClosersRef.current;
+			(registered.length > 0 ? registered[registered.length - 1] : modalCloseRef.current)(false);
+		}
+	}, []);
+	const ownRegisterDrawer = 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;
+	useEffect(() => {
+		if (!hasExplicitDefault) return;
+		return resolvedRegisterModalCloser(resolvedSetModalOpen);
+	}, [
+		hasExplicitDefault,
+		resolvedRegisterModalCloser,
+		resolvedSetModalOpen
+	]);
+	const isThreadIdControlledRef = useRef(isThreadIdControlled);
+	isThreadIdControlledRef.current = isThreadIdControlled;
+	const ownSetActiveThreadId = useCallback((id, options) => {
+		setActiveThreadOverride({
+			threadId: id,
+			explicit: options?.explicit ?? true
+		});
+	}, []);
+	const ownStartNewThread = useCallback(() => {
+		setActiveThreadOverride({
+			threadId: randomUUID(),
+			explicit: false
+		});
+	}, []);
+	const parentSetActiveThreadId = parentConfig?.setActiveThreadId;
+	const parentStartNewThread = parentConfig?.startNewThread;
+	const resolvedSetActiveThreadId = 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 = 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 = useCallback((open) => {
+		if (open && isMobileViewport()) resolvedSetDrawerOpen(false);
+		resolvedSetModalOpen(open);
+	}, [resolvedSetModalOpen, resolvedSetDrawerOpen]);
+	const configurationValue = 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__ */ jsx(CopilotChatConfiguration.Provider, {
+		value: configurationValue,
+		children
+	});
+};
+const useCopilotChatConfiguration = () => {
+	return 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 = useContext(CopilotChatConfiguration);
+	const parentSetModalOpen = parentConfig?.setModalOpen;
+	const registerModalCloser = parentConfig?.ɵregisterModalCloser;
+	const setModalOpen = useCallback((next) => {
+		parentSetModalOpen?.(next);
+		onOpenChange?.(next);
+	}, [parentSetModalOpen, onOpenChange]);
+	useEffect(() => {
+		if (!registerModalCloser) return;
+		return registerModalCloser(setModalOpen);
+	}, [registerModalCloser, setModalOpen]);
+	const configurationValue = useMemo(() => parentConfig ? {
+		...parentConfig,
+		isModalOpen: open ?? parentConfig.isModalOpen,
+		setModalOpen
+	} : null, [
+		parentConfig,
+		open,
+		setModalOpen
+	]);
+	if (!configurationValue) return /* @__PURE__ */ jsx(Fragment$1, { children });
+	return /* @__PURE__ */ jsx(CopilotChatConfiguration.Provider, {
+		value: configurationValue,
+		children
+	});
+};
+ControlledModalOpenScope.displayName = "ControlledModalOpenScope";
+
+//#endregion
+//#region src/lib/slots.tsx
+/**
+* Check if a value is a React component type (function, class, forwardRef, memo, etc.)
+*/
+function isReactComponentType(value) {
+	if (typeof value === "function") return true;
+	if (value && typeof value === "object" && "$$typeof" in value && !React.isValidElement(value)) return true;
+	return false;
+}
+/**
+* Internal function to render a slot value as a React element (non-memoized).
+*/
+function renderSlotElement(slot, DefaultComponent, props) {
+	if (typeof slot === "string") {
+		const existingClassName = props.className;
+		return React.createElement(DefaultComponent, {
+			...props,
+			className: twMerge(existingClassName, slot)
+		});
+	}
+	if (isReactComponentType(slot)) return React.createElement(slot, props);
+	if (slot && typeof slot === "object" && !React.isValidElement(slot)) return React.createElement(DefaultComponent, {
+		...props,
+		...slot
+	});
+	return React.createElement(DefaultComponent, props);
+}
+/**
+* Internal memoized wrapper component for renderSlot.
+* Uses forwardRef to support ref forwarding.
+*/
+const MemoizedSlotWrapper = React.memo(React.forwardRef(function MemoizedSlotWrapper(props, ref) {
+	const { $slot, $component, ...rest } = props;
+	return renderSlotElement($slot, $component, ref !== null ? {
+		...rest,
+		ref
+	} : rest);
+}), (prev, next) => {
+	if (prev.$slot !== next.$slot) return false;
+	if (prev.$component !== next.$component) return false;
+	const { $slot: _ps, $component: _pc, ...prevRest } = prev;
+	const { $slot: _ns, $component: _nc, ...nextRest } = next;
+	return shallowEqual(prevRest, nextRest);
+});
+/**
+* Renders a slot value as a memoized React element.
+* Automatically prevents unnecessary re-renders using shallow prop comparison.
+* Supports ref forwarding.
+*
+* @example
+* renderSlot(customInput, CopilotChatInput, { onSubmit: handleSubmit })
+*/
+function renderSlot(slot, DefaultComponent, props) {
+	return React.createElement(MemoizedSlotWrapper, {
+		...props,
+		$slot: slot,
+		$component: DefaultComponent
+	});
+}
+
+//#endregion
+//#region src/providers/MarkdownRendererContext.tsx
+const MarkdownRendererContext = createContext(void 0);
+const MarkdownRendererProvider = ({ renderer, children }) => /* @__PURE__ */ jsx(MarkdownRendererContext.Provider, {
+	value: renderer,
+	children
+});
+/**
+* The markdown renderer set at the provider level, or `undefined` when none was
+* supplied. Message components fall back to the built-in
+* `StreamingMarkdownDefaultRenderer` (via `CopilotChatAssistantMessage.MarkdownRenderer`)
+* when this is `undefined`.
+*/
+function useMarkdownRenderer() {
+	return useContext(MarkdownRendererContext);
+}
+
+//#endregion
+//#region src/types/defineToolCallRenderer.ts
+function defineToolCallRenderer(def) {
+	const argsSchema = def.name === "*" && !def.args ? 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/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 } = schemaToJsonSchema(schema, { zodToJsonSchema: (s) => zodToJsonSchema(s, { $refStrategy: "none" }) });
+	return applyChildRefMarks(rest);
+}
+
+//#endregion
+//#region src/generative-ui/catalog.ts
+/** The A2UI component envelope: `id`, `component`, `catalogId`, `accessibility`, `metadata`. */
+const RESERVED_KEYS = new Set([
+	"id",
+	"component",
+	...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 && !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: 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/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/generative-ui/errors.ts
+var GenerativeUIError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.name = "GenerativeUIError";
+		this.code = code;
+	}
+};
+
+//#endregion
+//#region src/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 (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 GENERATIVE_UI_FUNCTIONS[name]?.requiresUserActivation === true;
+}
+/** True when a basic function gives a ValidationResult. */
+function givesValidationResult(name) {
+	return GENERATIVE_UI_FUNCTIONS[name]?.returnType === "validationResult";
+}
+
+//#endregion
+//#region src/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 = extractFenceOperations(text);
+	if (!isStreaming || parsed.partialObject === null) return parsed.operations;
+	const complete = 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 = collectChildRefs(entry.props);
+			childRefCache.set(entry.props, refs);
+		}
+		if (refs.length === 0) return ids;
+		if (hasBoundChildRef(component, refs)) return "unknown";
+		return [...ids, ...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 = 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 === 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 === 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 = 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 = 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 = 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, () => splitA2UIMarkdown(content)) : 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 } = 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(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) => getOperationKind(op) !== "callRendererFunction");
+			for (const op of surfaceOperations) {
+				const requested = getMarkdownOperationSurfaceId(op) ?? fenceSurfaceId;
+				const surfaceId = scopedSurfaceId(requested, message.id, segment.target);
+				let draft = drafts.get(surfaceId);
+				if (!draft) {
+					draft = {
+						surfaceId,
+						target: segment.target ?? 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(prepareSurfaceOperations({
+			operations: draft.operations,
+			fallbackSurfaceId: draft.surfaceId,
+			catalogId: ui.id,
+			catalogIds: catalogIdsOf(ui)
+		}).operations)));
+		const parts = draft.target === GENERATIVE_UI_CHAT_TARGET ? liftProse(canFlattenCards ? 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 !== 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: GENERATIVE_UI_CHAT_TARGET,
+		catalogId,
+		status: "ready",
+		rejected: [],
+		operations: [{
+			version: A2UI_VERSION,
+			createSurface: {
+				surfaceId,
+				catalogId
+			}
+		}, {
+			version: 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/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/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 && 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 (isPathBinding(value)) {
+		const path = resolvePath(value["@path"], state.context.basePath);
+		state.paths.add(path);
+		return state.context.data.get(path);
+	}
+	if (isCallBinding(value)) return call(value, state, keepValidation);
+	if (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 === 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 (isPathBinding(value) || isCallBinding(value)) return true;
+	if (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/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/generative-ui/runtime-context.ts
+const GenerativeUIRuntimeContext = createContext(null);
+function useGenerativeUIRuntime() {
+	return useContext(GenerativeUIRuntimeContext);
+}
+function useRequiredGenerativeUIRuntime() {
+	const runtime = 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 = createContext(null);
+
+//#endregion
+//#region src/generative-ui/hooks.ts
+const noopSubscribe$1 = () => () => {};
+const zero = () => 0;
+/** Re-renders on any surface-manager change. */
+function useManagerVersion(runtime) {
+	return 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);
+	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
+	]);
+	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 = useRef(handler);
+	latest.current = handler;
+	useEffect(() => runtime.dispatcher.register(name, latest), [runtime, name]);
+}
+
+//#endregion
+//#region src/generative-ui/boundaries.tsx
+function DefaultNodeFallback({ message, componentId, retry }) {
+	return /* @__PURE__ */ 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__ */ 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 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__ */ 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 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__ */ jsx(DefaultNodeFallback, {
+			message: "this generated UI failed to render",
+			componentId: "surface"
+		});
+	}
+};
+
+//#endregion
+//#region src/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 = useContext(GenerativeUINodeContext)?.accessibility;
+	return 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/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/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/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 = useMemo(() => themeStyleSheet(theme), [theme]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "a2ui-surface",
+		"data-generative-ui-root": surface.surfaceId,
+		"data-a2ui-theme": sheet?.id,
+		style: ROOT_STYLE,
+		children: [sheet ? /* @__PURE__ */ jsx("style", { dangerouslySetInnerHTML: { __html: sheet.css } }) : null, /* @__PURE__ */ jsx(SurfaceBoundary, {
+			surfaceId: surface.surfaceId,
+			runtime,
+			children: /* @__PURE__ */ jsx(NodeView, {
+				surface,
+				componentId: 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 useSyncExternalStore(manager.subscribe, () => model.componentsModel.get(id), undefinedSnapshot);
+}
+/** Same reasoning as `useComponentModel`: never rely on web_core's emitters. */
+function useComponentProperties(manager, component) {
+	return 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 = 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__ */ jsx(DefaultNodeFallback, {
+		message: `cyclic reference to ${componentId}`,
+		componentId
+	});
+	if (!component || !properties) return /* @__PURE__ */ jsx(NodePlaceholder, { componentId });
+	const definition = runtime.ui.components.get(component.type);
+	if (!definition) return /* @__PURE__ */ jsx(DefaultNodeFallback, {
+		message: `unknown component "${component.type}"`,
+		componentId
+	});
+	return /* @__PURE__ */ jsx(NodeBoundary, {
+		surfaceId: surface.surfaceId,
+		componentId,
+		revision: properties,
+		runtime,
+		children: /* @__PURE__ */ 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 = 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 = useSyncExternalStore(subscribe, getCount, zeroSnapshot);
+	return /* @__PURE__ */ jsx(Fragment$1, { children: Array.from({ length: count }, (_, index) => index).map((index) => /* @__PURE__ */ 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 = useMemo(() => {
+		const list = [];
+		for (const key of Object.keys(properties)) {
+			if (definition.events?.[key] || definition.slots?.[key] || Object.hasOwn(definition.selectors, key) || 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] = useReducer((n) => n + 1, 0);
+	const cache = 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 (!isPathBinding(properties[key])) values[key] = value;
+	const rendered = useRef(next);
+	rendered.current = next;
+	const pathKey = [...paths].sort().join("\n");
+	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 = 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 = 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 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 = 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 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 = useRef(properties);
+	latest.current = properties;
+	const boundNames = Object.keys(definition.events ?? {}).filter((name) => Object.hasOwn(definition.eventFunctions, name) || isActionBinding(properties[name])).join("|");
+	return 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] = useState({});
+	const latest = useRef(properties);
+	latest.current = properties;
+	return {
+		overrides,
+		setters: useMemo(() => {
+			const result = {};
+			const writable = definition.writable ?? [];
+			for (const key of writable) result[setterNameOf(key)] = (value) => {
+				const binding = latest.current[key];
+				if (!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 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__ */ jsx(NodeView, {
+				surface,
+				componentId: value,
+				basePath,
+				ancestors: childAncestors
+			});
+			else if (kind === "multiple" && isTemplateChildren(value)) slots[name] = /* @__PURE__ */ 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__ */ 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 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__ */ jsx(NodeView, {
+				surface,
+				componentId: value,
+				basePath,
+				ancestors: childAncestors
+			}) : void 0;
+			if (isTemplateChildren(value)) return /* @__PURE__ */ 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__ */ jsx(NodeView, {
+				surface,
+				componentId: id,
+				basePath,
+				ancestors: childAncestors
+			}, id));
+		};
+		let result = props;
+		for (const ref of refs) result = 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 = useMemo(() => ({
+		surfaceKey: surface.key,
+		surfaceId: surface.surfaceId,
+		componentId,
+		accessibility
+	}), [
+		surface.key,
+		surface.surfaceId,
+		componentId,
+		accessibility
+	]);
+	const problem = dataProps.ok ? void 0 : dataProps.problem;
+	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__ */ jsx(DefaultNodeFallback, {
+		message: `invalid props (${problem})`,
+		componentId
+	});
+	const Component = definition.component;
+	const rendered = /* @__PURE__ */ jsx(Component, {
+		...childRefProps,
+		...eventProps,
+		...slotProps,
+		...setters
+	});
+	const hasEnvelope = properties.accessibility !== void 0 && definition.accessibility !== "self";
+	return /* @__PURE__ */ jsx(GenerativeUINodeContext.Provider, {
+		value: nodeContext,
+		children: hasEnvelope ? /* @__PURE__ */ jsx("span", {
+			"data-a2ui-accessibility": "",
+			style: ROOT_STYLE,
+			...wrapperAria(accessibilityAttributes(accessibility)),
+			children: rendered
+		}) : rendered
+	});
+}
+
+//#endregion
+//#region src/generative-ui/chat.tsx
+const GenerativeUIChatSlotContext = createContext(void 0);
+function DefaultGenerativeUIChatCard({ surfaceId, isStreaming, error, children }) {
+	return /* @__PURE__ */ 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__ */ 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 = z.object({
+	surfaceId: z.string(),
+	target: z.string(),
+	catalogId: z.string(),
+	operations: z.array(z.any()),
+	status: z.enum([
+		"streaming",
+		"ready",
+		"error"
+	]),
+	rejected: z.array(z.object({
+		index: z.number(),
+		reason: z.string()
+	})).default([])
+}).passthrough();
+function GenerativeUIChatActivity({ content, agent }) {
+	const runtime = useGenerativeUIRuntime();
+	const threadId = useCopilotChatConfiguration()?.threadId ?? agent?.threadId;
+	const Wrapper = useContext(GenerativeUIChatSlotContext) ?? DefaultGenerativeUIChatCard;
+	useManagerVersion(runtime);
+	useLayoutEffect(() => {
+		if (runtime && threadId) runtime.manager.ingest(threadId, agent?.agentId, content);
+	}, [
+		runtime,
+		threadId,
+		agent?.agentId,
+		content
+	]);
+	if (!runtime || !threadId || content.target !== 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__ */ jsx(Wrapper, {
+		surfaceId: content.surfaceId,
+		isStreaming: content.status === "streaming",
+		error,
+		rejected,
+		children: surface.failed ? null : /* @__PURE__ */ jsx(SurfaceView, { surface })
+	});
+}
+function createGenerativeUIActivityRenderer() {
+	return {
+		activityType: 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: GENERATIVE_UI_FUNCTION_CALL_ACTIVITY_TYPE,
+		content: z.unknown(),
+		render: () => null
+	};
+}
+/** Hides the raw `render_ui` tool call; the surface activity owns the UX. */
+function GenerativeUIToolCallRenderer() {
+	const { copilotkit } = useCopilotKit();
+	useEffect(() => {
+		const renderer = defineToolCallRenderer({
+			name: GENERATIVE_UI_RENDER_TOOL,
+			args: z.any(),
+			render: () => /* @__PURE__ */ jsx(Fragment$1, {})
+		});
+		const existing = copilotkit._renderToolCalls ?? [];
+		copilotkit.setRenderToolCalls([...existing.filter((rc) => rc.name !== GENERATIVE_UI_RENDER_TOOL), renderer]);
+	}, [copilotkit]);
+	return null;
+}
+
+//#endregion
+//#region src/generative-ui/markdown/ProviderMarkdown.tsx
+/**
+* Markdown prose inside generative UI, rendered like the chat text around
+* it: the renderer set on the provider when there is one, else the built-in
+* streaming renderer. Config passed here wins over provider config.
+*/
+function ProviderMarkdown({ content, isStreaming, className, ...config }) {
+	const renderer = useMarkdownRenderer();
+	if (renderer && isReactComponentType(renderer)) return /* @__PURE__ */ jsx(renderer, {
+		content,
+		isStreaming,
+		className
+	});
+	return /* @__PURE__ */ jsx(StreamingMarkdownDefaultRenderer, {
+		...renderer,
+		...config,
+		content,
+		isStreaming,
+		className
+	});
+}
+
+//#endregion
+//#region src/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 : 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__ */ 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__ */ 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(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__ */ jsx(Wrapper, {
+		surfaceId,
+		isStreaming: surface.status === "streaming",
+		error,
+		rejected,
+		children: surface.failed ? null : /* @__PURE__ */ jsx(SurfaceView, { surface })
+	});
+}
+/** The blocks of one fence: lifted prose and chat surfaces, in order. */
+function FenceBlocks({ blocks, runtime, threadId, isStreaming, markdownProps }) {
+	const Wrapper = useContext(GenerativeUIChatSlotContext) ?? DefaultMarkdownChatSurface;
+	let surfaceCount = 0;
+	return /* @__PURE__ */ jsx(Fragment$1, { children: blocks.map((block, index) => {
+		if (block.kind === "markdown") return /* @__PURE__ */ jsx(ProviderMarkdown, {
+			...markdownProps,
+			content: block.markdown,
+			isStreaming: isStreaming && index === blocks.length - 1
+		}, `md-${surfaceCount}`);
+		surfaceCount++;
+		return /* @__PURE__ */ 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, isStreaming = false, ...markdownProps }) {
+	const runtime = useRequiredGenerativeUIRuntime();
+	const chatThreadId = useCopilotChatConfiguration()?.threadId;
+	useManagerVersion(runtime);
+	const segments = useMemo(() => splitA2UIMarkdown(content), [content]);
+	const threadId = chatThreadId ?? runtime.manager.getActiveThread();
+	const source = getMarkdownSurfaceSource(runtime);
+	return /* @__PURE__ */ jsx(Fragment$1, { children: segments.map((segment, index) => {
+		const isLast = index === segments.length - 1;
+		if (segment.type === "markdown") return /* @__PURE__ */ jsx(ProviderMarkdown, {
+			...markdownProps,
+			content: segment.text,
+			isStreaming: isStreaming && isLast
+		}, `md-${index}`);
+		const blocks = threadId ? source.getFenceBlocks(threadId, messageId, segment.index) : void 0;
+		if (!threadId || !blocks) return null;
+		return /* @__PURE__ */ jsx(FenceBlocks, {
+			blocks,
+			runtime,
+			threadId,
+			isStreaming: isStreaming && isLast,
+			markdownProps
+		}, `a2ui-${segment.index}`);
+	}) });
+}
+
+//#endregion
+export { GenerativeUIError as A, renderSlot as B, issueKey as C, getMarkdownSurfaceSource as D, containsDynamicValue as E, toJsonSchema as F, useShallowStableRef as G, CopilotChatConfigurationProvider as H, defineToolCallRenderer as I, StreamingMarkdownDefaultRenderer as K, MarkdownRendererProvider as L, catalogIdsOf as M, componentCatalogIds as N, BASIC_FUNCTIONS as O, createGenerativeUI as P, useMarkdownRenderer as R, isAsyncIssue as S, withoutRejectedNulls as T, CopilotChatDefaultLabels as U, ControlledModalOpenScope as V, useCopilotChatConfiguration as W, GenerativeUINodeContext as _, GenerativeUIToolCallRenderer as a, useRequiredGenerativeUIRuntime as b, SurfaceView as c, namedRole as d, useGenerativeUIAccessibility as f, useManagerVersion as g, useGenerativeUIState as h, GenerativeUIChatSlotContext as i, isRecord as j, ExpressionError as k, DARK_THEME_CSS as l, useGenerativeUIFunction as m, ProviderMarkdown as n, createGenerativeUIActivityRenderer as o, wrapperAria as p, DefaultGenerativeUIChatCard as r, createGenerativeUIFunctionCallActivityRenderer as s, MarkdownSurfaces as t, controlAria as u, GenerativeUIRuntimeContext as v, validateSchemaSync as w, formatIssues as x, useGenerativeUIRuntime as y, isReactComponentType as z };
+//# sourceMappingURL=MarkdownSurfaces-ChSlVYOk.mjs.map