@cimplify/sdk 0.88.0 → 0.90.0

package/dist/react.js

@@ -2,7 +2,8 @@
 'use strict';
 
 var chunkT7Z25EY4_js = require('./chunk-T7Z25EY4.js');
-var chunkW5BVGAO6_js = require('./chunk-W5BVGAO6.js');
+var chunkXREIZ56K_js = require('./chunk-XREIZ56K.js');
+var chunkBN4V4ONE_js = require('./chunk-BN4V4ONE.js');
 var chunkGHFDYM5K_js = require('./chunk-GHFDYM5K.js');
 var chunkPTPOQVXS_js = require('./chunk-PTPOQVXS.js');
 var chunkAETVRBKI_js = require('./chunk-AETVRBKI.js');
@@ -25,6 +26,8 @@ var xss = require('xss');
 var dialog = require('@base-ui/react/dialog');
 var field = require('@base-ui/react/field');
 var input = require('@base-ui/react/input');
+var DOMPurify = require('dompurify');
+var marked = require('marked');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -48,6 +51,7 @@ function _interopNamespace(e) {
 
 var React14__default = /*#__PURE__*/_interopDefault(React14);
 var ReactDOM__namespace = /*#__PURE__*/_interopNamespace(ReactDOM);
+var DOMPurify__default = /*#__PURE__*/_interopDefault(DOMPurify);
 
 // src/ads/identity.ts
 var COOKIE_NAME = "_cimplify_uid";
@@ -790,15 +794,15 @@ function deriveView(base, ops) {
   };
 }
 async function syncFromServer(entry) {
-  if (entry.syncing) return;
-  entry.syncing = true;
-  try {
+  const run = async () => {
     const result = await entry.client.cart.get();
     if (!result.ok) throw result.error;
     entry.collection.setBase(mapServerCart(result.value, entry.currency));
-  } finally {
-    entry.syncing = false;
-  }
+  };
+  const next = entry.syncTail.then(run, run);
+  entry.syncTail = next.catch(() => {
+  });
+  return next;
 }
 function emitMutationError(entry, operation, opId, idempotencyKey, error) {
   entry.client.events.emit("mutation:error", {
@@ -838,7 +842,7 @@ function getOrCreateStore(params) {
     optimisticEnabled,
     initialized: false,
     initializePromise: null,
-    syncing: false,
+    syncTail: Promise.resolve(),
     failedOpRemovers: /* @__PURE__ */ new Set()
   };
   cartStores.set(storeKey, entry);
@@ -1132,7 +1136,7 @@ var DEFAULT_COUNTRY = "US";
 function createDefaultClient() {
   const processRef = globalThis.process;
   const envPublicKey = processRef?.env?.NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY || "";
-  return chunkW5BVGAO6_js.createCimplifyClient({ publicKey: envPublicKey });
+  return chunkBN4V4ONE_js.createCimplifyClient({ publicKey: envPublicKey });
 }
 function getStoredLocationId() {
   if (typeof window === "undefined" || !window.localStorage) {
@@ -4303,7 +4307,7 @@ function Price({
   ] });
 }
 function createCachedQuery(config) {
-  const cache = /* @__PURE__ */ new Map();
+  const cache2 = /* @__PURE__ */ new Map();
   const inflight = /* @__PURE__ */ new Map();
   const gcMaxAge = config.gcMaxAge ?? 3e5;
   let lastSweep = 0;
@@ -4312,8 +4316,8 @@ function createCachedQuery(config) {
     if (now - lastSweep < 6e4) return;
     lastSweep = now;
     const cutoff = now - gcMaxAge;
-    for (const [key, entry] of cache) {
-      if (entry.ts < cutoff) cache.delete(key);
+    for (const [key, entry] of cache2) {
+      if (entry.ts < cutoff) cache2.delete(key);
     }
   }
   function useCachedQuery(options = {}) {
@@ -4331,13 +4335,13 @@ function createCachedQuery(config) {
     const optionsRef = React14.useRef(options);
     optionsRef.current = options;
     if (config.locationSensitive && previousLocationRef.current !== locationId) {
-      cache.clear();
+      cache2.clear();
       inflight.clear();
       previousLocationRef.current = locationId;
     }
     sweep();
     const cacheKey2 = config.key(client, options);
-    const cached = cache.get(cacheKey2);
+    const cached = cache2.get(cacheKey2);
     const [data, setData] = React14.useState(cached?.data ?? null);
     const [isLoading, setIsLoading] = React14.useState(enabled && !cached);
     const [error, setError] = React14.useState(null);
@@ -4350,7 +4354,7 @@ function createCachedQuery(config) {
         const nextRequestId = ++requestIdRef.current;
         setError(null);
         if (!force) {
-          const hit = cache.get(cacheKey2);
+          const hit = cache2.get(cacheKey2);
           if (hit) {
             setData(hit.data);
             setIsLoading(false);
@@ -4367,7 +4371,7 @@ function createCachedQuery(config) {
             });
           }
           const value = await promise;
-          cache.set(cacheKey2, { data: value, ts: Date.now() });
+          cache2.set(cacheKey2, { data: value, ts: Date.now() });
           if (nextRequestId === requestIdRef.current) {
             setData(value);
             setError(null);
@@ -4388,23 +4392,23 @@ function createCachedQuery(config) {
       void load(false);
     }, [load]);
     const refetch = React14.useCallback(async () => {
-      cache.delete(cacheKey2);
+      cache2.delete(cacheKey2);
       await load(true);
     }, [cacheKey2, load]);
     return { data, isLoading, error, refetch };
   }
   useCachedQuery.prefetch = (client, options) => {
     const key = config.key(client, options);
-    if (cache.has(key) || inflight.has(key)) return void 0;
+    if (cache2.has(key) || inflight.has(key)) return void 0;
     const promise = config.fetch(client, options);
     inflight.set(key, promise);
     return promise.then((value) => {
-      cache.set(key, { data: value, ts: Date.now() });
+      cache2.set(key, { data: value, ts: Date.now() });
     }).catch(() => {
     }).finally(() => inflight.delete(key));
   };
   useCachedQuery.clear = () => {
-    cache.clear();
+    cache2.clear();
     inflight.clear();
   };
   return useCachedQuery;
@@ -4532,6 +4536,9 @@ function useCategories(options = {}) {
   return { categories: data ?? [], isLoading, error, refetch };
 }
 var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "cancelled", "refunded"]);
+function isTerminalOrderStatus(status) {
+  return TERMINAL_STATUSES.has(status);
+}
 var orderCache = /* @__PURE__ */ new Map();
 var orderInflight = /* @__PURE__ */ new Map();
 function buildOrderCacheKey(client, orderId) {
@@ -5373,6 +5380,9 @@ function useOrders(options = {}) {
   const { data, isLoading, error, refetch } = ordersQuery(options);
   return { orders: data ?? [], isLoading, error, refetch };
 }
+function clearOrdersCache() {
+  ordersQuery.clear();
+}
 function useSubscriptions(options = {}) {
   const { client } = useCimplifyClient();
   const { status, enabled = true } = options;
@@ -5878,6 +5888,7 @@ var POLL_IDLE_INTERVAL_MS = 15e3;
 var IDLE_TIMEOUT_MS = 6e4;
 var WS_MAX_RECONNECT_ATTEMPTS = 10;
 var WS_PATH = "/api/v1/support/conversation/ws";
+var AWAIT_REPLY_TIMEOUT_MS = 3e4;
 function useChat(options = {}) {
   const context = useOptionalCimplifyClient();
   const client = options.client ?? context?.client;
@@ -5886,6 +5897,10 @@ function useChat(options = {}) {
   const [isSending, setIsSending] = React14.useState(false);
   const [error, setError] = React14.useState(null);
   const [conversationOpened, setConversationOpened] = React14.useState(false);
+  const [humanRequested, setHumanRequested] = React14.useState(false);
+  const [awaitingReply, setAwaitingReply] = React14.useState(false);
+  const [seenAt, setSeenAt] = React14.useState(null);
+  const [mayHaveOlder, setMayHaveOlder] = React14.useState(false);
   const pollRef = React14.useRef(null);
   const lastActivityRef = React14.useRef(Date.now());
   const openedRef = React14.useRef(false);
@@ -5894,21 +5909,45 @@ function useChat(options = {}) {
   const wsRef = React14.useRef(null);
   const wsReconnectAttemptRef = React14.useRef(0);
   const wsReconnectTimerRef = React14.useRef(null);
+  const aiEnabledRef = React14.useRef(false);
+  const humanRequestedRef = React14.useRef(false);
+  const awaitReplyTimerRef = React14.useRef(null);
   messagesRef.current = messages;
   clientRef.current = client;
+  humanRequestedRef.current = humanRequested;
   const pollInterval = options.pollInterval ?? POLL_INTERVAL_MS;
   const pollIdleInterval = options.pollIdleInterval ?? POLL_IDLE_INTERVAL_MS;
-  const appendMessages = React14.useCallback((incoming) => {
-    setMessages((prev) => {
-      const ids = new Set(prev.map((m) => m.id));
-      const fresh = incoming.filter((m) => !ids.has(m.id));
-      return fresh.length > 0 ? [...prev, ...fresh] : prev;
-    });
+  const stopAwaitingReply = React14.useCallback(() => {
+    if (awaitReplyTimerRef.current) {
+      clearTimeout(awaitReplyTimerRef.current);
+      awaitReplyTimerRef.current = null;
+    }
+    setAwaitingReply(false);
   }, []);
-  const pollMessages = React14.useCallback(async () => {
+  const startAwaitingReply = React14.useCallback(() => {
+    setAwaitingReply(true);
+    if (awaitReplyTimerRef.current) clearTimeout(awaitReplyTimerRef.current);
+    awaitReplyTimerRef.current = setTimeout(() => {
+      awaitReplyTimerRef.current = null;
+      setAwaitingReply(false);
+    }, AWAIT_REPLY_TIMEOUT_MS);
+  }, []);
+  const appendMessages = React14.useCallback(
+    (incoming) => {
+      if (incoming.some((m) => m.sender_type === "bot" || m.sender_type === "agent")) {
+        stopAwaitingReply();
+      }
+      setMessages((prev) => {
+        const ids = new Set(prev.map((m) => m.id));
+        const fresh = incoming.filter((m) => !ids.has(m.id));
+        return fresh.length > 0 ? [...prev, ...fresh] : prev;
+      });
+    },
+    [stopAwaitingReply]
+  );
+  const fetchNewMessages = React14.useCallback(async () => {
     const c = clientRef.current;
     if (!c) return;
-    if (Date.now() - lastActivityRef.current > IDLE_TIMEOUT_MS) return;
     const last = messagesRef.current[messagesRef.current.length - 1];
     const result = await c.support.getMessages({
       after: last?.created_at,
@@ -5918,6 +5957,10 @@ function useChat(options = {}) {
       appendMessages(result.value);
     }
   }, [appendMessages]);
+  const pollMessages = React14.useCallback(async () => {
+    if (Date.now() - lastActivityRef.current > IDLE_TIMEOUT_MS) return;
+    await fetchNewMessages();
+  }, [fetchNewMessages]);
   const startPolling = React14.useCallback(() => {
     if (pollRef.current) clearInterval(pollRef.current);
     const interval = Date.now() - lastActivityRef.current > IDLE_TIMEOUT_MS ? pollIdleInterval : pollInterval;
@@ -5950,6 +5993,19 @@ function useChat(options = {}) {
         const envelope = JSON.parse(event.data);
         if (envelope.type === "message.created" && envelope.data) {
           appendMessages([envelope.data]);
+        } else if (envelope.type === "thread.read") {
+          const at = envelope.data?.last_read_at;
+          if (at) setSeenAt((prev) => !prev || prev < at ? at : prev);
+        } else if (envelope.type === "thread.responding") {
+          const active = envelope.data?.active;
+          if (active) startAwaitingReply();
+          else stopAwaitingReply();
+        } else if (envelope.type === "resync") {
+          const latest = envelope.latest_message_at;
+          const last = messagesRef.current[messagesRef.current.length - 1];
+          if (latest && (!last || new Date(last.created_at).getTime() < new Date(latest).getTime())) {
+            fetchNewMessages();
+          }
         }
       } catch {
       }
@@ -5957,7 +6013,7 @@ function useChat(options = {}) {
     ws.onclose = () => {
       wsRef.current = null;
       if (!openedRef.current) return;
-      pollMessages();
+      fetchNewMessages();
       if (wsReconnectAttemptRef.current < WS_MAX_RECONNECT_ATTEMPTS) {
         const attempt = wsReconnectAttemptRef.current++;
         const delay = Math.min(1e3 * Math.pow(2, attempt) + Math.random() * 500, 3e4);
@@ -5969,11 +6025,12 @@ function useChat(options = {}) {
     ws.onerror = () => {
     };
     wsRef.current = ws;
-  }, [appendMessages, startPolling, stopPolling, pollMessages]);
+  }, [appendMessages, startPolling, stopPolling, fetchNewMessages]);
   React14.useEffect(() => {
     return () => {
       if (pollRef.current) clearInterval(pollRef.current);
       if (wsReconnectTimerRef.current) clearTimeout(wsReconnectTimerRef.current);
+      if (awaitReplyTimerRef.current) clearTimeout(awaitReplyTimerRef.current);
       if (wsRef.current) {
         wsRef.current.onclose = null;
         wsRef.current.close();
@@ -5989,6 +6046,10 @@ function useChat(options = {}) {
     if (result.ok) {
       setMessages(result.value.messages);
       setConversationOpened(true);
+      aiEnabledRef.current = result.value.conversation.ai_enabled;
+      setHumanRequested(result.value.conversation.needs_human_review ?? false);
+      setSeenAt(result.value.conversation.team_read_at ?? null);
+      setMayHaveOlder(result.value.messages.length >= 50);
       connectWebSocket();
     } else {
       openedRef.current = false;
@@ -5997,38 +6058,60 @@ function useChat(options = {}) {
     setIsLoading(false);
   }, [client, connectWebSocket]);
   const send = React14.useCallback(
-    async (content) => {
-      if (!client || !content.trim()) return;
+    async (content, opts) => {
+      const attachments = opts?.attachments ?? [];
+      if (!client || !content.trim() && attachments.length === 0) return false;
       setError(null);
       lastActivityRef.current = Date.now();
       if (!openedRef.current) {
         await openConversation();
-        if (!openedRef.current) return;
+        if (!openedRef.current) return false;
       }
+      const replyTo = opts?.replyTo;
       const optimisticId = `opt_${Date.now()}`;
       const optimistic = {
         id: optimisticId,
         sender_type: "customer",
         content: content.trim(),
-        content_type: "text",
-        attachments: [],
+        content_type: attachments.length > 0 ? "image" : "text",
+        attachments,
         metadata: {},
+        // Same shape the server echoes back, so the bubble doesn't reflow
+        // when the confirmed message replaces it.
+        reply_to: replyTo ? {
+          id: replyTo.id,
+          sender_type: replyTo.sender_type,
+          preview: chunkXREIZ56K_js.messagePreview(replyTo.content)
+        } : void 0,
         created_at: (/* @__PURE__ */ new Date()).toISOString()
       };
       setMessages((prev) => [...prev, optimistic]);
       setIsSending(true);
-      const result = await client.support.sendMessage(content.trim());
+      const result = await client.support.sendMessage(content.trim(), {
+        replyToMessageId: replyTo?.id,
+        attachments: attachments.length > 0 ? attachments : void 0
+      });
       if (result.ok) {
+        const confirmed = result.value;
         setMessages(
-          (prev) => prev.map((m) => m.id === optimisticId ? result.value : m)
+          (prev) => (
+            // The websocket may have already streamed the confirmed message
+            // in while the POST was in flight; drop the optimistic bubble
+            // instead of inserting a duplicate.
+            prev.some((m) => m.id === confirmed.id) ? prev.filter((m) => m.id !== optimisticId) : prev.map((m) => m.id === optimisticId ? confirmed : m)
+          )
         );
+        if (aiEnabledRef.current && !humanRequestedRef.current) {
+          startAwaitingReply();
+        }
       } else {
         setMessages((prev) => prev.filter((m) => m.id !== optimisticId));
         setError(result.error);
       }
       setIsSending(false);
+      return result.ok;
     },
-    [client, openConversation]
+    [client, openConversation, startAwaitingReply]
   );
   const startConversation = React14.useCallback(
     async (starterText) => {
@@ -6039,14 +6122,65 @@ function useChat(options = {}) {
     },
     [openConversation, send]
   );
+  const react = React14.useCallback(
+    async (message, emoji) => {
+      if (!client || message.id.startsWith("opt_")) return false;
+      const result = await client.support.reactToMessage(message.id, emoji);
+      if (result.ok) appendMessages([result.value]);
+      return result.ok;
+    },
+    [client, appendMessages]
+  );
+  const requestHuman = React14.useCallback(async () => {
+    if (!client) return false;
+    setError(null);
+    if (!openedRef.current) {
+      await openConversation();
+      if (!openedRef.current) return false;
+    }
+    const result = await client.support.requestHuman();
+    if (result.ok) {
+      setHumanRequested(true);
+      return true;
+    }
+    setError(result.error);
+    return false;
+  }, [client, openConversation]);
+  const loadOlder = React14.useCallback(async () => {
+    const c = clientRef.current;
+    const earliest = messagesRef.current[0];
+    if (!c || !earliest) return false;
+    const result = await c.support.getMessages({ before: earliest.created_at, limit: 50 });
+    if (!result.ok) {
+      setError(result.error);
+      return false;
+    }
+    const older = result.value;
+    setMayHaveOlder(older.length >= 50);
+    if (older.length === 0) return false;
+    setMessages((prev) => {
+      const ids = new Set(prev.map((m) => m.id));
+      const fresh = older.filter((m) => !ids.has(m.id));
+      return fresh.length > 0 ? [...fresh, ...prev] : prev;
+    });
+    return true;
+  }, []);
+  const agentArrived = messages.some((m) => m.sender_type === "agent");
   return {
     messages,
     isLoading,
     isSending,
     error,
     isActive: conversationOpened && messages.length > 0,
+    humanRequested: humanRequested && !agentArrived,
+    awaitingReply,
+    seenAt,
+    mayHaveOlder,
     send,
-    startConversation
+    startConversation,
+    react,
+    requestHuman,
+    loadOlder
   };
 }
 var ElementsContext = React14.createContext({
@@ -9344,6 +9478,7 @@ function ProductCustomizer({
   onAddToCart,
   onVariantChange,
   showSpecialInstructions = true,
+  submitLabel,
   className,
   classNames
 }) {
@@ -9732,8 +9867,10 @@ function ProductCustomizer({
                   isAdded && classNames?.submitButtonAdded,
                   classNames?.submitButton
                 ),
-                children: isAdded ? "Added to Cart" : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-                  "Add to Cart \xB7 ",
+                children: isAdded ? "Added" : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                  submitLabel ?? "Add to Cart",
+                  " \xB7",
+                  " ",
                   /* @__PURE__ */ jsxRuntime.jsx(Price, { amount: displayTotalPrice, currency })
                 ] })
               }
@@ -9893,13 +10030,13 @@ function StoreVideo({
   autoplay = true,
   loop = true,
   muted = true,
-  lazy = true,
+  lazy: lazy2 = true,
   className
 }) {
   const ref = React14.useRef(null);
-  const [inView, setInView] = React14.useState(!lazy);
+  const [inView, setInView] = React14.useState(!lazy2);
   React14.useEffect(() => {
-    if (!lazy || inView) return;
+    if (!lazy2 || inView) return;
     const node = ref.current;
     if (!node || typeof IntersectionObserver === "undefined") {
       setInView(true);
@@ -9916,7 +10053,7 @@ function StoreVideo({
     );
     observer.observe(node);
     return () => observer.disconnect();
-  }, [lazy, inView]);
+  }, [lazy2, inView]);
   return /* @__PURE__ */ jsxRuntime.jsx(
     "div",
     {
@@ -9934,7 +10071,7 @@ function StoreVideo({
           muted,
           playsInline: true,
           controls,
-          preload: lazy ? "metadata" : "auto",
+          preload: lazy2 ? "metadata" : "auto",
           "aria-label": alt,
           style: { width: "100%", height: "100%", objectFit: "cover", display: "block" },
           children: poster ? /* @__PURE__ */ jsxRuntime.jsx(
@@ -16736,6 +16873,112 @@ function CurrencySelector({
     );
   }) });
 }
+var Streamdown = React14.lazy(() => import('streamdown').then((m) => ({ default: m.Streamdown })));
+function detectLookbehindSupport() {
+  try {
+    new RegExp("(?<=a)b");
+    return true;
+  } catch {
+    return false;
+  }
+}
+var supportsRegExpLookbehind = detectLookbehindSupport();
+marked.marked.setOptions({
+  gfm: true,
+  breaks: true
+});
+var ALLOWED_TAGS = [
+  "a",
+  "b",
+  "blockquote",
+  "br",
+  "code",
+  "del",
+  "em",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "hr",
+  "i",
+  "li",
+  "ol",
+  "p",
+  "pre",
+  "strong",
+  "table",
+  "tbody",
+  "td",
+  "th",
+  "thead",
+  "tr",
+  "ul"
+];
+var ALLOWED_ATTR = ["href", "rel", "target", "title", "start"];
+var hooksInstalled = false;
+function installHooks() {
+  if (hooksInstalled) return;
+  hooksInstalled = true;
+  DOMPurify__default.default.addHook("afterSanitizeAttributes", (node) => {
+    if (!(node instanceof HTMLAnchorElement)) return;
+    if (!node.getAttribute("href")) return;
+    node.setAttribute("rel", "noreferrer noopener");
+    node.setAttribute("target", "_blank");
+  });
+}
+var CACHE_LIMIT = 300;
+var cache = /* @__PURE__ */ new Map();
+function renderMarkdown(text) {
+  const cached = cache.get(text);
+  if (cached !== void 0) return cached;
+  installHooks();
+  const html = DOMPurify__default.default.sanitize(marked.marked.parse(text), {
+    ALLOWED_TAGS,
+    ALLOWED_ATTR
+  });
+  if (cache.size >= CACHE_LIMIT) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+  cache.set(text, html);
+  return html;
+}
+function SettledMarkdown({ text, className }) {
+  const html = React14.useMemo(() => renderMarkdown(text), [text]);
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className, dangerouslySetInnerHTML: { __html: html } });
+}
+var ChatMarkdown = React14.memo(function ChatMarkdown2({
+  text,
+  className,
+  streaming = false
+}) {
+  if (streaming && supportsRegExpLookbehind) {
+    return (
+      // While the streamdown chunk loads, the settled renderer keeps the
+      // text on screen — no blank frame at stream start.
+      /* @__PURE__ */ jsxRuntime.jsx(React14.Suspense, { fallback: /* @__PURE__ */ jsxRuntime.jsx(SettledMarkdown, { text, className }), children: /* @__PURE__ */ jsxRuntime.jsx(Streamdown, { className, children: text }) })
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(SettledMarkdown, { text, className });
+});
+
+// src/react/chat-model.ts
+function partitionMessages(messages) {
+  const bubbles = [];
+  const reactionsByTarget = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.content_type === "reaction") {
+      const targetId = message.reply_to?.id;
+      if (!targetId) continue;
+      const list = reactionsByTarget.get(targetId);
+      if (list) list.push(message);
+      else reactionsByTarget.set(targetId, [message]);
+      continue;
+    }
+    bubbles.push(message);
+  }
+  return { bubbles, reactionsByTarget };
+}
 function ChatWidget({
   client: clientProp,
   businessName = "Support",
@@ -16753,7 +16996,35 @@ function ChatWidget({
   const client = clientProp ?? context?.client;
   const [open, setOpen] = React14.useState(defaultOpen);
   const [unread, setUnread] = React14.useState(0);
-  const { messages, isLoading, isSending, error, isActive, send, startConversation } = useChat({ client, pollInterval });
+  const {
+    messages,
+    isLoading,
+    isSending,
+    awaitingReply,
+    seenAt,
+    error,
+    isActive,
+    send,
+    react,
+    startConversation
+  } = useChat({ client, pollInterval });
+  const showTyping = isSending || awaitingReply;
+  const attachPhoto = React14.useCallback(
+    async (file) => {
+      if (!client || !file.type.startsWith("image/") || file.size > 5 * 1024 * 1024) return;
+      const uploaded = await client.uploads.upload(file);
+      if (!uploaded.ok) return;
+      const attachment = {
+        upload_id: uploaded.value.id,
+        url: uploaded.value.url,
+        mime_type: uploaded.value.content_type,
+        filename: uploaded.value.filename,
+        size: uploaded.value.size_bytes
+      };
+      await send("", { attachments: [attachment] });
+    },
+    [client, send]
+  );
   const prevCountRef = React14.useRef(messages.length);
   React14.useEffect(() => {
     if (!open && messages.length > prevCountRef.current) {
@@ -16800,11 +17071,15 @@ function ChatWidget({
             messages,
             isLoading,
             isSending,
+            isTyping: showTyping,
+            seenAt,
             error,
             isActive,
             isLeft,
             onClose: handleClose,
             onSend: send,
+            onReact: react,
+            onAttach: attachPhoto,
             onStartConversation: startConversation,
             classNames
           }
@@ -16857,11 +17132,15 @@ function Panel({
   messages,
   isLoading,
   isSending,
+  isTyping,
+  seenAt,
   error,
   isActive,
   isLeft,
   onClose,
   onSend,
+  onReact,
+  onAttach,
   onStartConversation,
   classNames
 }) {
@@ -16899,7 +17178,9 @@ function Panel({
           {
             messages,
             isLoading,
-            isSending,
+            isSending: isTyping,
+            seenAt,
+            onReact,
             className: classNames?.messages
           }
         ),
@@ -16910,6 +17191,7 @@ function Panel({
             placeholder,
             isSending,
             onSend,
+            onAttach,
             className: classNames?.input
           }
         ),
@@ -17005,16 +17287,29 @@ function Welcome({
     }
   );
 }
+var QUICK_REACTIONS = ["\u{1F44D}", "\u2764\uFE0F"];
+function lastSeenCustomerMessageId(bubbles, seenAt) {
+  if (!seenAt || !bubbles.some((m) => m.sender_type === "agent")) return null;
+  for (let i = bubbles.length - 1; i >= 0; i--) {
+    if (bubbles[i].sender_type !== "customer") continue;
+    return bubbles[i].created_at <= seenAt ? bubbles[i].id : null;
+  }
+  return null;
+}
 function MessageList({
   messages,
   isLoading,
   isSending,
+  seenAt,
+  onReact,
   className
 }) {
   const bottomRef = React14.useRef(null);
   React14.useEffect(() => {
     bottomRef.current?.scrollIntoView({ behavior: "smooth" });
   }, [messages.length, isSending]);
+  const { bubbles, reactionsByTarget } = partitionMessages(messages);
+  const seenMessageId = lastSeenCustomerMessageId(bubbles, seenAt);
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "div",
     {
@@ -17024,40 +17319,111 @@ function MessageList({
       ),
       children: [
         isLoading && messages.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-1 items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(TypingDots, {}) }),
-        messages.map((msg, i) => {
+        bubbles.map((msg, i) => {
           const isCustomer = msg.sender_type === "customer";
-          const prev = messages[i - 1];
+          const prev = bubbles[i - 1];
           const sameSenderAsPrev = prev?.sender_type === msg.sender_type;
           const isOptimistic = msg.id.startsWith("opt_");
+          const reactions = reactionsByTarget.get(msg.id);
           return /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
             !sameSenderAsPrev && i > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-3" }),
-            /* @__PURE__ */ jsxRuntime.jsx(
+            /* @__PURE__ */ jsxRuntime.jsxs(
               "div",
               {
                 className: cn(
-                  "flex max-w-[85%]",
+                  "group relative flex max-w-[85%]",
                   isCustomer ? "ml-auto" : "mr-auto"
                 ),
-                children: /* @__PURE__ */ jsxRuntime.jsxs(
-                  "div",
-                  {
-                    className: cn(
-                      "rounded-2xl px-3.5 py-2.5 text-sm leading-relaxed",
-                      isCustomer ? "bg-foreground text-background" : "border border-border bg-background text-foreground",
-                      isCustomer ? sameSenderAsPrev ? "rounded-tr" : "rounded-br" : sameSenderAsPrev ? "rounded-tl" : "rounded-bl",
-                      isOptimistic && "opacity-70"
-                    ),
-                    children: [
-                      !isCustomer && !sameSenderAsPrev && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "mb-1 inline-flex items-center gap-1 rounded bg-violet-100 px-1.5 py-0.5 text-[10px] font-semibold text-violet-600", children: [
-                        /* @__PURE__ */ jsxRuntime.jsx(SparkleIcon, { className: "h-[11px] w-[11px]" }),
-                        "AI"
-                      ] }),
-                      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "whitespace-pre-wrap", children: msg.content })
-                    ]
-                  }
-                )
+                children: [
+                  !isCustomer && !isOptimistic && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute -top-3 right-0 z-10 hidden gap-0.5 rounded-full border border-border bg-background px-1 py-0.5 shadow-sm group-hover:flex", children: QUICK_REACTIONS.map((emoji) => /* @__PURE__ */ jsxRuntime.jsx(
+                    "button",
+                    {
+                      type: "button",
+                      "aria-label": `React ${emoji}`,
+                      onClick: () => void onReact(msg, emoji),
+                      className: "flex h-6 w-6 items-center justify-center rounded-full text-[13px] hover:bg-muted",
+                      children: emoji
+                    },
+                    emoji
+                  )) }),
+                  /* @__PURE__ */ jsxRuntime.jsxs(
+                    "div",
+                    {
+                      className: cn(
+                        "rounded-2xl px-3.5 py-2.5 text-sm leading-relaxed",
+                        isCustomer ? "bg-foreground text-background" : "border border-border bg-background text-foreground",
+                        isCustomer ? sameSenderAsPrev ? "rounded-tr" : "rounded-br" : sameSenderAsPrev ? "rounded-tl" : "rounded-bl",
+                        isOptimistic && "opacity-70"
+                      ),
+                      children: [
+                        !isCustomer && !sameSenderAsPrev && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "mb-1 inline-flex items-center gap-1 rounded bg-violet-100 px-1.5 py-0.5 text-[10px] font-semibold text-violet-600", children: [
+                          /* @__PURE__ */ jsxRuntime.jsx(SparkleIcon, { className: "h-[11px] w-[11px]" }),
+                          "AI"
+                        ] }),
+                        msg.reply_to && /* @__PURE__ */ jsxRuntime.jsxs(
+                          "div",
+                          {
+                            className: cn(
+                              "mb-1.5 flex gap-1.5 rounded-lg px-2 py-1 text-xs",
+                              isCustomer ? "bg-background/15" : "bg-muted"
+                            ),
+                            children: [
+                              /* @__PURE__ */ jsxRuntime.jsx(
+                                "span",
+                                {
+                                  className: cn(
+                                    "w-[3px] shrink-0 self-stretch rounded-full",
+                                    isCustomer ? "bg-background/40" : "bg-muted-foreground/40"
+                                  )
+                                }
+                              ),
+                              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "min-w-0 truncate opacity-80", children: msg.reply_to.preview })
+                            ]
+                          }
+                        ),
+                        msg.attachments.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn("flex flex-wrap gap-1.5", msg.content && "mb-1.5"), children: msg.attachments.map(
+                          (attachment, index) => attachment.mime_type?.startsWith("image/") ? /* @__PURE__ */ jsxRuntime.jsx("a", { href: attachment.url, target: "_blank", rel: "noreferrer", children: /* @__PURE__ */ jsxRuntime.jsx(
+                            "img",
+                            {
+                              src: attachment.url,
+                              alt: attachment.filename ?? "Photo",
+                              loading: "lazy",
+                              className: "max-h-48 max-w-full rounded-lg object-cover"
+                            }
+                          ) }, index) : /* @__PURE__ */ jsxRuntime.jsx(
+                            "a",
+                            {
+                              href: attachment.url,
+                              target: "_blank",
+                              rel: "noreferrer",
+                              className: "truncate text-xs underline",
+                              children: attachment.filename ?? "Attachment"
+                            },
+                            index
+                          )
+                        ) }),
+                        isCustomer ? msg.content && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "whitespace-pre-wrap", children: msg.content }) : /* @__PURE__ */ jsxRuntime.jsx(
+                          ChatMarkdown,
+                          {
+                            text: msg.content,
+                            className: "[&_p]:my-0 [&_p+p]:mt-1.5 [&_ul]:my-1 [&_ul]:list-disc [&_ul]:pl-4 [&_ol]:my-1 [&_ol]:list-decimal [&_ol]:pl-4 [&_li]:my-0.5 [&_h1]:text-sm [&_h1]:font-bold [&_h2]:text-sm [&_h2]:font-bold [&_h3]:text-sm [&_h3]:font-semibold [&_hr]:my-2 [&_table]:my-1 [&_table]:w-full [&_th]:pb-1 [&_th]:text-left [&_th]:text-[10px] [&_th]:font-semibold [&_th]:uppercase [&_td]:py-1 [&_td:last-child]:text-right [&_td:last-child]:font-semibold [&_td:last-child]:tabular-nums [&_a]:underline"
+                          }
+                        )
+                      ]
+                    }
+                  )
+                ]
               }
-            )
+            ),
+            reactions && reactions.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn("mt-0.5 flex gap-1", isCustomer ? "justify-end" : "justify-start"), children: reactions.map((reaction) => /* @__PURE__ */ jsxRuntime.jsx(
+              "span",
+              {
+                className: "rounded-full border border-border bg-background px-1.5 py-0.5 text-xs shadow-sm",
+                children: reaction.content
+              },
+              reaction.id
+            )) }),
+            msg.id === seenMessageId && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-0.5 text-right text-[10px] font-medium text-muted-foreground", children: "Seen" })
           ] }, msg.id);
         }),
         isSending && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mr-auto mt-1", children: /* @__PURE__ */ jsxRuntime.jsx(TypingDots, {}) }),
@@ -17070,10 +17436,24 @@ function ChatInput({
   placeholder,
   isSending,
   onSend,
+  onAttach,
   className
 }) {
   const [value, setValue] = React14.useState("");
+  const [uploading, setUploading] = React14.useState(false);
   const textareaRef = React14.useRef(null);
+  const fileRef = React14.useRef(null);
+  const handleAttach = React14.useCallback(
+    async (file) => {
+      setUploading(true);
+      try {
+        await onAttach(file);
+      } finally {
+        setUploading(false);
+      }
+    },
+    [onAttach]
+  );
   const handleSend = React14.useCallback(() => {
     const trimmed = value.trim();
     if (!trimmed || isSending) return;
@@ -17107,6 +17487,37 @@ function ChatInput({
         className
       ),
       children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            ref: fileRef,
+            type: "file",
+            accept: "image/*",
+            className: "hidden",
+            "aria-hidden": "true",
+            tabIndex: -1,
+            onChange: (e) => {
+              const file = e.target.files?.[0];
+              e.target.value = "";
+              if (file) void handleAttach(file);
+            }
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": "Attach a photo",
+            disabled: uploading,
+            onClick: () => fileRef.current?.click(),
+            className: cn(
+              "flex h-10 w-10 flex-shrink-0 items-center justify-center rounded-[10px]",
+              "bg-muted text-muted-foreground transition-colors hover:text-foreground",
+              uploading && "animate-pulse"
+            ),
+            children: /* @__PURE__ */ jsxRuntime.jsx(ImageIcon, { className: "h-[18px] w-[18px]" })
+          }
+        ),
         /* @__PURE__ */ jsxRuntime.jsx(
           "div",
           {
@@ -17209,6 +17620,25 @@ function SendIcon({ className }) {
     }
   );
 }
+function ImageIcon({ className }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "svg",
+    {
+      className,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: 2,
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2", ry: "2" }),
+        /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "8.5", cy: "8.5", r: "1.5" }),
+        /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "21 15 16 10 5 21" })
+      ]
+    }
+  );
+}
 function SparkleIcon({ className }) {
   return /* @__PURE__ */ jsxRuntime.jsx(
     "svg",
@@ -17223,9 +17653,1838 @@ function SparkleIcon({ className }) {
   );
 }
 
-Object.defineProperty(exports, "getVariantDisplayName", {
-  enumerable: true,
-  get: function () { return chunkT7Z25EY4_js.getVariantDisplayName; }
+// src/react/genui/catalog.ts
+function genUICatalog(registry) {
+  return new Map(
+    registry.components.map((component) => [
+      component.name,
+      {
+        params: component.params.map((param) => ({
+          name: param.name,
+          required: param.required ?? false
+        }))
+      }
+    ])
+  );
+}
+
+// src/genui/lang/parser/ast.ts
+function isRuntimeExpr(node) {
+  switch (node.k) {
+    case "StateRef":
+    case "RuntimeRef":
+    case "BinOp":
+    case "UnaryOp":
+    case "Ternary":
+    case "Member":
+    case "Index":
+    case "Assign":
+      return true;
+    default:
+      return false;
+  }
+}
+var AST_KINDS = /* @__PURE__ */ new Set([
+  "Comp",
+  "Ref",
+  "StateRef",
+  "RuntimeRef",
+  "BinOp",
+  "UnaryOp",
+  "Ternary",
+  "Member",
+  "Index",
+  "Assign",
+  "Str",
+  "Num",
+  "Bool",
+  "Null",
+  "Arr",
+  "Obj",
+  "Ph"
+]);
+function isASTNode(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return AST_KINDS.has(value.k);
+}
+function walkAST(node, visit) {
+  const walk = (current) => {
+    visit(current);
+    switch (current.k) {
+      case "Comp":
+        current.args.forEach(walk);
+        Object.values(current.mappedProps ?? {}).forEach(walk);
+        break;
+      case "Arr":
+        current.els.forEach(walk);
+        break;
+      case "Obj":
+        current.entries.forEach(([, value]) => walk(value));
+        break;
+      case "BinOp":
+        walk(current.left);
+        walk(current.right);
+        break;
+      case "UnaryOp":
+        walk(current.operand);
+        break;
+      case "Ternary":
+        walk(current.cond);
+        walk(current.then);
+        walk(current.else);
+        break;
+      case "Member":
+        walk(current.obj);
+        break;
+      case "Index":
+        walk(current.obj);
+        walk(current.index);
+        break;
+      case "Assign":
+        walk(current.value);
+        break;
+    }
+  };
+  walk(node);
+}
+
+// src/genui/lang/parser/builtins.ts
+function resolveField(obj, path) {
+  if (!path || obj == null) return void 0;
+  if (!path.includes(".")) return obj[path];
+  let cur = obj;
+  for (const p of path.split(".")) {
+    if (cur == null) return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+function toNumber2(val) {
+  if (typeof val === "number") return val;
+  if (typeof val === "string") {
+    const n = Number(val);
+    return isNaN(n) ? 0 : n;
+  }
+  if (typeof val === "boolean") return val ? 1 : 0;
+  return 0;
+}
+var BUILTINS = {
+  Count: {
+    name: "Count",
+    signature: "Count(array) \u2192 number",
+    description: "Returns array length",
+    fn: (arr) => Array.isArray(arr) ? arr.length : 0
+  },
+  First: {
+    name: "First",
+    signature: "First(array) \u2192 element",
+    description: "Returns first element of array",
+    fn: (arr) => Array.isArray(arr) ? arr[0] ?? null : null
+  },
+  Last: {
+    name: "Last",
+    signature: "Last(array) \u2192 element",
+    description: "Returns last element of array",
+    fn: (arr) => Array.isArray(arr) ? arr[arr.length - 1] ?? null : null
+  },
+  Sum: {
+    name: "Sum",
+    signature: "Sum(numbers[]) \u2192 number",
+    description: "Sum of numeric array",
+    fn: (arr) => Array.isArray(arr) ? arr.reduce((a, b) => a + toNumber2(b), 0) : 0
+  },
+  Avg: {
+    name: "Avg",
+    signature: "Avg(numbers[]) \u2192 number",
+    description: "Average of numeric array",
+    fn: (arr) => Array.isArray(arr) && arr.length ? arr.reduce((a, b) => a + toNumber2(b), 0) / arr.length : 0
+  },
+  Min: {
+    name: "Min",
+    signature: "Min(numbers[]) \u2192 number",
+    description: "Minimum value in array",
+    fn: (arr) => Array.isArray(arr) && arr.length ? arr.reduce((acc, b) => Math.min(acc, toNumber2(b)), toNumber2(arr[0])) : 0
+  },
+  Max: {
+    name: "Max",
+    signature: "Max(numbers[]) \u2192 number",
+    description: "Maximum value in array",
+    fn: (arr) => Array.isArray(arr) && arr.length ? arr.reduce((acc, b) => Math.max(acc, toNumber2(b)), toNumber2(arr[0])) : 0
+  },
+  Sort: {
+    name: "Sort",
+    signature: "Sort(array, field, direction?) \u2192 sorted array",
+    description: 'Sort array by field. Direction: "asc" (default) or "desc"',
+    fn: (arr, field, dir) => {
+      if (!Array.isArray(arr)) return arr;
+      const f = String(field ?? "");
+      const desc = String(dir ?? "asc") === "desc";
+      return [...arr].sort((a, b) => {
+        const av = f ? resolveField(a, f) : a;
+        const bv = f ? resolveField(b, f) : b;
+        const aIsNumeric = typeof av === "number" || typeof av === "string" && !isNaN(Number(av)) && av !== "";
+        const bIsNumeric = typeof bv === "number" || typeof bv === "string" && !isNaN(Number(bv)) && bv !== "";
+        if (aIsNumeric && bIsNumeric) {
+          const diff = toNumber2(av) - toNumber2(bv);
+          return desc ? -diff : diff;
+        }
+        const cmp = String(av ?? "").localeCompare(String(bv ?? ""));
+        return desc ? -cmp : cmp;
+      });
+    }
+  },
+  Filter: {
+    name: "Filter",
+    signature: 'Filter(array, field, operator: "==" | "!=" | ">" | "<" | ">=" | "<=" | "contains", value) \u2192 filtered array',
+    description: "Filter array by field value",
+    fn: (arr, field, op, value) => {
+      if (!Array.isArray(arr)) return [];
+      const f = String(field ?? "");
+      const o = String(op ?? "==");
+      return arr.filter((item) => {
+        const v = f ? resolveField(item, f) : item;
+        switch (o) {
+          case "==":
+            return v == value;
+          case "!=":
+            return v != value;
+          case ">":
+            return toNumber2(v) > toNumber2(value);
+          case "<":
+            return toNumber2(v) < toNumber2(value);
+          case ">=":
+            return toNumber2(v) >= toNumber2(value);
+          case "<=":
+            return toNumber2(v) <= toNumber2(value);
+          case "contains":
+            return String(v ?? "").includes(String(value ?? ""));
+          default:
+            return false;
+        }
+      });
+    }
+  },
+  Round: {
+    name: "Round",
+    signature: "Round(number, decimals?) \u2192 number",
+    description: "Round to N decimal places (default 0)",
+    fn: (n, decimals) => {
+      const num = toNumber2(n);
+      const d = decimals != null ? toNumber2(decimals) : 0;
+      const factor = Math.pow(10, d);
+      return Math.round(num * factor) / factor;
+    }
+  },
+  Abs: {
+    name: "Abs",
+    signature: "Abs(number) \u2192 number",
+    description: "Absolute value",
+    fn: (n) => Math.abs(toNumber2(n))
+  },
+  Floor: {
+    name: "Floor",
+    signature: "Floor(number) \u2192 number",
+    description: "Round down to nearest integer",
+    fn: (n) => Math.floor(toNumber2(n))
+  },
+  Ceil: {
+    name: "Ceil",
+    signature: "Ceil(number) \u2192 number",
+    description: "Round up to nearest integer",
+    fn: (n) => Math.ceil(toNumber2(n))
+  }
+};
+var LAZY_BUILTINS = /* @__PURE__ */ new Set(["Each"]);
+var ACTION_STEPS = {
+  Run: "run",
+  ToAssistant: "continue_conversation",
+  OpenUrl: "open_url",
+  Set: "set",
+  Reset: "reset"
+};
+var ACTION_NAMES = /* @__PURE__ */ new Set(["Action", ...Object.keys(ACTION_STEPS)]);
+var BUILTIN_NAMES = /* @__PURE__ */ new Set([
+  ...Object.keys(BUILTINS),
+  ...LAZY_BUILTINS,
+  ...ACTION_NAMES
+]);
+function isBuiltin(name) {
+  return BUILTIN_NAMES.has(name);
+}
+var RESERVED_CALLS = { Query: "Query", Mutation: "Mutation" };
+function isReservedCall(name) {
+  return name in RESERVED_CALLS;
+}
+
+// src/genui/lang/parser/expressions.ts
+var PREC_TERNARY = 1;
+var PREC_OR = 2;
+var PREC_AND = 3;
+var PREC_EQ = 4;
+var PREC_CMP = 5;
+var PREC_ADD = 6;
+var PREC_MUL = 7;
+var PREC_UNARY = 8;
+var PREC_MEMBER = 9;
+function parseExpression(tokens) {
+  let pos = 0;
+  const cur = () => tokens[pos] ?? { t: 13 /* EOF */ };
+  const adv = () => {
+    const tok = cur();
+    pos++;
+    return tok;
+  };
+  const eat = (kind) => {
+    if (cur().t === kind) pos++;
+  };
+  function getInfixPrec(tok) {
+    switch (tok.t) {
+      case 34 /* Question */:
+        return PREC_TERNARY;
+      case 32 /* Or */:
+        return PREC_OR;
+      case 31 /* And */:
+        return PREC_AND;
+      case 25 /* EqEq */:
+      case 26 /* NotEq */:
+        return PREC_EQ;
+      case 27 /* Greater */:
+      case 28 /* Less */:
+      case 29 /* GreaterEq */:
+      case 30 /* LessEq */:
+        return PREC_CMP;
+      case 20 /* Plus */:
+      case 21 /* Minus */:
+        return PREC_ADD;
+      case 22 /* Star */:
+      case 23 /* Slash */:
+      case 24 /* Percent */:
+        return PREC_MUL;
+      case 19 /* Dot */:
+      case 3 /* LBrack */:
+        return PREC_MEMBER;
+      default:
+        return 0;
+    }
+  }
+  function parseExpr(minPrec = 0) {
+    let left = parsePrefix();
+    while (getInfixPrec(cur()) > minPrec) {
+      left = parseInfix(left);
+    }
+    return left;
+  }
+  function parsePrefix() {
+    const tok = cur();
+    if (tok.t === 14 /* Str */) {
+      adv();
+      return { k: "Str", v: tok.v };
+    }
+    if (tok.t === 15 /* Num */) {
+      adv();
+      return { k: "Num", v: tok.v };
+    }
+    if (tok.t === 10 /* True */) {
+      adv();
+      return { k: "Bool", v: true };
+    }
+    if (tok.t === 11 /* False */) {
+      adv();
+      return { k: "Bool", v: false };
+    }
+    if (tok.t === 12 /* Null */) {
+      adv();
+      return { k: "Null" };
+    }
+    if (tok.t === 3 /* LBrack */) return parseArr();
+    if (tok.t === 5 /* LBrace */) return parseObj();
+    if (tok.t === 18 /* StateVar */) {
+      const name = tok.v;
+      adv();
+      if (cur().t === 9 /* Equals */) {
+        adv();
+        const value = parseExpr(0);
+        return { k: "Assign", target: name, value };
+      }
+      return { k: "StateRef", n: name };
+    }
+    if (tok.t === 17 /* Type */) {
+      const name = tok.v;
+      if (tokens[pos + 1]?.t === 1 /* LParen */ && (!isBuiltin(name) || name === "Action"))
+        return parseComp();
+      adv();
+      return { k: "Ref", n: name };
+    }
+    if (tok.t === 35 /* BuiltinCall */) {
+      if (tokens[pos + 1]?.t === 1 /* LParen */) return parseComp();
+      adv();
+      return { k: "Ref", n: tok.v };
+    }
+    if (tok.t === 16 /* Ident */) {
+      adv();
+      return { k: "Ref", n: tok.v };
+    }
+    if (tok.t === 33 /* Not */) {
+      adv();
+      return { k: "UnaryOp", op: "!", operand: parseExpr(PREC_UNARY) };
+    }
+    if (tok.t === 21 /* Minus */) {
+      adv();
+      return { k: "UnaryOp", op: "-", operand: parseExpr(PREC_UNARY) };
+    }
+    if (tok.t === 1 /* LParen */) {
+      adv();
+      const inner = parseExpr(0);
+      eat(2 /* RParen */);
+      return inner;
+    }
+    adv();
+    return { k: "Null" };
+  }
+  function parseInfix(left) {
+    const tok = cur();
+    if (tok.t === 20 /* Plus */) {
+      adv();
+      return { k: "BinOp", op: "+", left, right: parseExpr(PREC_ADD) };
+    }
+    if (tok.t === 21 /* Minus */) {
+      adv();
+      return { k: "BinOp", op: "-", left, right: parseExpr(PREC_ADD) };
+    }
+    if (tok.t === 22 /* Star */) {
+      adv();
+      return { k: "BinOp", op: "*", left, right: parseExpr(PREC_MUL) };
+    }
+    if (tok.t === 23 /* Slash */) {
+      adv();
+      return { k: "BinOp", op: "/", left, right: parseExpr(PREC_MUL) };
+    }
+    if (tok.t === 24 /* Percent */) {
+      adv();
+      return { k: "BinOp", op: "%", left, right: parseExpr(PREC_MUL) };
+    }
+    if (tok.t === 25 /* EqEq */) {
+      adv();
+      return { k: "BinOp", op: "==", left, right: parseExpr(PREC_EQ) };
+    }
+    if (tok.t === 26 /* NotEq */) {
+      adv();
+      return { k: "BinOp", op: "!=", left, right: parseExpr(PREC_EQ) };
+    }
+    if (tok.t === 27 /* Greater */) {
+      adv();
+      return { k: "BinOp", op: ">", left, right: parseExpr(PREC_CMP) };
+    }
+    if (tok.t === 28 /* Less */) {
+      adv();
+      return { k: "BinOp", op: "<", left, right: parseExpr(PREC_CMP) };
+    }
+    if (tok.t === 29 /* GreaterEq */) {
+      adv();
+      return { k: "BinOp", op: ">=", left, right: parseExpr(PREC_CMP) };
+    }
+    if (tok.t === 30 /* LessEq */) {
+      adv();
+      return { k: "BinOp", op: "<=", left, right: parseExpr(PREC_CMP) };
+    }
+    if (tok.t === 31 /* And */) {
+      adv();
+      return { k: "BinOp", op: "&&", left, right: parseExpr(PREC_AND) };
+    }
+    if (tok.t === 32 /* Or */) {
+      adv();
+      return { k: "BinOp", op: "||", left, right: parseExpr(PREC_OR) };
+    }
+    if (tok.t === 34 /* Question */) {
+      adv();
+      const then = parseExpr(0);
+      eat(8 /* Colon */);
+      const els = parseExpr(0);
+      return { k: "Ternary", cond: left, then, else: els };
+    }
+    if (tok.t === 19 /* Dot */) {
+      adv();
+      const fieldTok = cur();
+      const field = fieldTok.t === 16 /* Ident */ || fieldTok.t === 17 /* Type */ || fieldTok.t === 14 /* Str */ || fieldTok.t === 15 /* Num */ ? (adv(), String(fieldTok.v)) : fieldTok.t === 18 /* StateVar */ ? (adv(), fieldTok.v.replace(/^\$/, "")) : (adv(), "?");
+      return { k: "Member", obj: left, field };
+    }
+    if (tok.t === 3 /* LBrack */) {
+      adv();
+      const index = parseExpr(0);
+      eat(4 /* RBrack */);
+      return { k: "Index", obj: left, index };
+    }
+    return left;
+  }
+  function parseComp() {
+    const name = cur().v;
+    adv();
+    eat(1 /* LParen */);
+    const args = [];
+    while (cur().t !== 2 /* RParen */ && cur().t !== 13 /* EOF */) {
+      args.push(parseExpr(0));
+      if (cur().t === 7 /* Comma */) adv();
+    }
+    eat(2 /* RParen */);
+    return { k: "Comp", name, args };
+  }
+  function parseArr() {
+    adv();
+    const els = [];
+    while (cur().t !== 4 /* RBrack */ && cur().t !== 13 /* EOF */) {
+      els.push(parseExpr(0));
+      if (cur().t === 7 /* Comma */) adv();
+    }
+    eat(4 /* RBrack */);
+    return { k: "Arr", els };
+  }
+  function parseObj() {
+    adv();
+    const entries = [];
+    while (cur().t !== 6 /* RBrace */ && cur().t !== 13 /* EOF */) {
+      const kt = cur();
+      const key = kt.t === 16 /* Ident */ || kt.t === 14 /* Str */ || kt.t === 17 /* Type */ || kt.t === 15 /* Num */ ? (adv(), String(kt.v)) : kt.t === 18 /* StateVar */ ? (adv(), kt.v.replace(/^\$/, "")) : (adv(), "?");
+      eat(8 /* Colon */);
+      entries.push([key, parseExpr(0)]);
+      if (cur().t === 7 /* Comma */) adv();
+    }
+    eat(6 /* RBrace */);
+    return { k: "Obj", entries };
+  }
+  return parseExpr(0);
+}
+
+// src/genui/lang/parser/lexer.ts
+function tokenize(src) {
+  const tokens = [];
+  let i = 0;
+  const n = src.length;
+  while (i < n) {
+    while (i < n && (src[i] === " " || src[i] === "	" || src[i] === "\r")) i++;
+    if (i >= n) break;
+    const c = src[i];
+    if (c === "\n") {
+      tokens.push({ t: 0 /* Newline */ });
+      i++;
+      continue;
+    }
+    if (c === "(") {
+      tokens.push({ t: 1 /* LParen */ });
+      i++;
+      continue;
+    }
+    if (c === ")") {
+      tokens.push({ t: 2 /* RParen */ });
+      i++;
+      continue;
+    }
+    if (c === "[") {
+      tokens.push({ t: 3 /* LBrack */ });
+      i++;
+      continue;
+    }
+    if (c === "]") {
+      tokens.push({ t: 4 /* RBrack */ });
+      i++;
+      continue;
+    }
+    if (c === "{") {
+      tokens.push({ t: 5 /* LBrace */ });
+      i++;
+      continue;
+    }
+    if (c === "}") {
+      tokens.push({ t: 6 /* RBrace */ });
+      i++;
+      continue;
+    }
+    if (c === ",") {
+      tokens.push({ t: 7 /* Comma */ });
+      i++;
+      continue;
+    }
+    if (c === ":") {
+      tokens.push({ t: 8 /* Colon */ });
+      i++;
+      continue;
+    }
+    if (c === "=") {
+      if (i + 1 < n && src[i + 1] === "=") {
+        tokens.push({ t: 25 /* EqEq */ });
+        i += 2;
+      } else {
+        tokens.push({ t: 9 /* Equals */ });
+        i++;
+      }
+      continue;
+    }
+    if (c === "!") {
+      if (i + 1 < n && src[i + 1] === "=") {
+        tokens.push({ t: 26 /* NotEq */ });
+        i += 2;
+      } else {
+        tokens.push({ t: 33 /* Not */ });
+        i++;
+      }
+      continue;
+    }
+    if (c === ">") {
+      if (i + 1 < n && src[i + 1] === "=") {
+        tokens.push({ t: 29 /* GreaterEq */ });
+        i += 2;
+      } else {
+        tokens.push({ t: 27 /* Greater */ });
+        i++;
+      }
+      continue;
+    }
+    if (c === "<") {
+      if (i + 1 < n && src[i + 1] === "=") {
+        tokens.push({ t: 30 /* LessEq */ });
+        i += 2;
+      } else {
+        tokens.push({ t: 28 /* Less */ });
+        i++;
+      }
+      continue;
+    }
+    if (c === "&") {
+      if (i + 1 < n && src[i + 1] === "&") {
+        tokens.push({ t: 31 /* And */ });
+        i += 2;
+      } else {
+        tokens.push({ t: 31 /* And */ });
+        i++;
+      }
+      continue;
+    }
+    if (c === "|") {
+      if (i + 1 < n && src[i + 1] === "|") {
+        tokens.push({ t: 32 /* Or */ });
+        i += 2;
+      } else {
+        tokens.push({ t: 32 /* Or */ });
+        i++;
+      }
+      continue;
+    }
+    if (c === ".") {
+      tokens.push({ t: 19 /* Dot */ });
+      i++;
+      continue;
+    }
+    if (c === "?") {
+      tokens.push({ t: 34 /* Question */ });
+      i++;
+      continue;
+    }
+    if (c === "+") {
+      tokens.push({ t: 20 /* Plus */ });
+      i++;
+      continue;
+    }
+    if (c === "*") {
+      tokens.push({ t: 22 /* Star */ });
+      i++;
+      continue;
+    }
+    if (c === "/") {
+      tokens.push({ t: 23 /* Slash */ });
+      i++;
+      continue;
+    }
+    if (c === "%") {
+      tokens.push({ t: 24 /* Percent */ });
+      i++;
+      continue;
+    }
+    if (c === '"') {
+      const start = i;
+      i++;
+      let isClosed = false;
+      while (i < n) {
+        if (src[i] === "\\") {
+          i += 2;
+        } else if (src[i] === '"') {
+          i++;
+          isClosed = true;
+          break;
+        } else {
+          i++;
+        }
+      }
+      const rawString = src.slice(start, i);
+      try {
+        const validJsonString = isClosed ? rawString : rawString + '"';
+        tokens.push({ t: 14 /* Str */, v: JSON.parse(validJsonString) });
+      } catch {
+        const stripped = rawString.replace(/^"|"$/g, "");
+        tokens.push({ t: 14 /* Str */, v: stripped });
+      }
+      continue;
+    }
+    if (c === "'") {
+      i++;
+      let result = "";
+      while (i < n) {
+        if (src[i] === "\\") {
+          i++;
+          if (i < n) {
+            const esc = src[i];
+            if (esc === "'") result += "'";
+            else if (esc === "\\") result += "\\";
+            else if (esc === "n") result += "\n";
+            else if (esc === "t") result += "	";
+            else result += esc;
+            i++;
+          }
+        } else if (src[i] === "'") {
+          i++;
+          break;
+        } else {
+          result += src[i];
+          i++;
+        }
+      }
+      tokens.push({ t: 14 /* Str */, v: result });
+      continue;
+    }
+    if (c === "-") {
+      const prev = tokens.length > 0 ? tokens[tokens.length - 1] : null;
+      const afterValue = prev != null && (prev.t === 15 /* Num */ || prev.t === 14 /* Str */ || prev.t === 16 /* Ident */ || prev.t === 17 /* Type */ || prev.t === 2 /* RParen */ || prev.t === 4 /* RBrack */ || prev.t === 10 /* True */ || prev.t === 11 /* False */ || prev.t === 12 /* Null */ || prev.t === 18 /* StateVar */ || prev.t === 35 /* BuiltinCall */);
+      if (!afterValue && i + 1 < n && src[i + 1] >= "0" && src[i + 1] <= "9") ; else {
+        tokens.push({ t: 21 /* Minus */ });
+        i++;
+        continue;
+      }
+    }
+    const isDigit = c >= "0" && c <= "9";
+    const isNegDigit = c === "-" && i + 1 < n && src[i + 1] >= "0" && src[i + 1] <= "9";
+    if (isDigit || isNegDigit) {
+      const start = i;
+      if (src[i] === "-") i++;
+      while (i < n && src[i] >= "0" && src[i] <= "9") i++;
+      if (i < n && src[i] === "." && i + 1 < n && src[i + 1] >= "0" && src[i + 1] <= "9") {
+        i++;
+        while (i < n && src[i] >= "0" && src[i] <= "9") i++;
+      }
+      if (i < n && (src[i] === "e" || src[i] === "E")) {
+        i++;
+        if (i < n && (src[i] === "+" || src[i] === "-")) i++;
+        while (i < n && src[i] >= "0" && src[i] <= "9") i++;
+      }
+      tokens.push({ t: 15 /* Num */, v: +src.slice(start, i) });
+      continue;
+    }
+    if (c === "$" && i + 1 < n && (src[i + 1] >= "a" && src[i + 1] <= "z" || src[i + 1] >= "A" && src[i + 1] <= "Z" || src[i + 1] === "_")) {
+      const start = i;
+      i++;
+      while (i < n && (src[i] >= "a" && src[i] <= "z" || src[i] >= "A" && src[i] <= "Z" || src[i] >= "0" && src[i] <= "9" || src[i] === "_"))
+        i++;
+      tokens.push({ t: 18 /* StateVar */, v: src.slice(start, i) });
+      continue;
+    }
+    const isAlpha = c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_";
+    if (isAlpha) {
+      const start = i;
+      while (i < n && (src[i] >= "a" && src[i] <= "z" || src[i] >= "A" && src[i] <= "Z" || src[i] >= "0" && src[i] <= "9" || src[i] === "_"))
+        i++;
+      const word = src.slice(start, i);
+      if (word === "true") {
+        tokens.push({ t: 10 /* True */ });
+        continue;
+      }
+      if (word === "false") {
+        tokens.push({ t: 11 /* False */ });
+        continue;
+      }
+      if (word === "null") {
+        tokens.push({ t: 12 /* Null */ });
+        continue;
+      }
+      const kind = c >= "A" && c <= "Z" ? 17 /* Type */ : 16 /* Ident */;
+      tokens.push({ t: kind, v: word });
+      continue;
+    }
+    if (c === "@" && i + 1 < n && (src[i + 1] >= "a" && src[i + 1] <= "z" || src[i + 1] >= "A" && src[i + 1] <= "Z" || src[i + 1] === "_")) {
+      i++;
+      const start = i;
+      while (i < n && (src[i] >= "a" && src[i] <= "z" || src[i] >= "A" && src[i] <= "Z" || src[i] >= "0" && src[i] <= "9" || src[i] === "_"))
+        i++;
+      tokens.push({ t: 35 /* BuiltinCall */, v: src.slice(start, i) });
+      continue;
+    }
+    i++;
+  }
+  tokens.push({ t: 13 /* EOF */ });
+  return tokens;
+}
+
+// src/genui/lang/parser/types.ts
+function isElementNode(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const node = value;
+  return node.type === "element" && typeof node.typeName === "string" && typeof node.props === "object" && node.props !== null && typeof node.partial === "boolean";
+}
+
+// src/genui/lang/parser/materialize.ts
+function containsDynamicValue(v) {
+  if (v == null || typeof v !== "object") return false;
+  if (isASTNode(v)) return true;
+  if (Array.isArray(v)) return v.some(containsDynamicValue);
+  if (isElementNode(v)) {
+    return Object.values(v.props).some(containsDynamicValue);
+  }
+  const obj = v;
+  return Object.values(obj).some(containsDynamicValue);
+}
+function resolveRef(name, ctx, mode) {
+  if (ctx.visited.has(name)) {
+    ctx.unres.push(name);
+    return mode === "expr" ? { k: "Ph", n: name } : null;
+  }
+  if (!ctx.syms.has(name)) {
+    ctx.unres.push(name);
+    return mode === "expr" ? { k: "Ph", n: name } : null;
+  }
+  const target = ctx.syms.get(name);
+  ctx.unreached?.delete(name);
+  if (target.k === "Comp" && isReservedCall(target.name)) {
+    const refType = target.name === RESERVED_CALLS.Mutation ? "mutation" : "query";
+    return { k: "RuntimeRef", n: name, refType };
+  }
+  ctx.visited.add(name);
+  const prevStatementId = ctx.currentStatementId;
+  ctx.currentStatementId = name;
+  try {
+    const result = mode === "value" ? materializeValue(target, ctx) : materializeExpr(target, ctx);
+    if (mode === "value" && isElementNode(result)) {
+      result.statementId = name;
+    }
+    return result;
+  } finally {
+    ctx.currentStatementId = prevStatementId;
+    ctx.visited.delete(name);
+  }
+}
+function materializeLazyBuiltin(node, ctx, scopedRefs) {
+  if (!LAZY_BUILTINS.has(node.name) || node.args.length < 3) return null;
+  const varArg = node.args[1];
+  const varName = varArg.k === "Ref" ? varArg.n : varArg.k === "Str" ? varArg.v : null;
+  if (!varName) return null;
+  const nextScopedRefs = new Set(scopedRefs);
+  nextScopedRefs.add(varName);
+  const recursedArgs = node.args.map(
+    (a, i) => i === 1 ? a : materializeExprInternal(a, ctx, nextScopedRefs)
+  );
+  return { ...node, args: recursedArgs };
+}
+function materializeExprInternal(node, ctx, scopedRefs) {
+  switch (node.k) {
+    case "Ref":
+      return scopedRefs.has(node.n) ? node : resolveRef(node.n, ctx, "expr");
+    case "Ph":
+      return node;
+    case "Comp": {
+      const lazy2 = materializeLazyBuiltin(node, ctx, scopedRefs);
+      if (lazy2) return lazy2;
+      const recursedArgs = node.args.map((a) => materializeExprInternal(a, ctx, scopedRefs));
+      if (isBuiltin(node.name) || isReservedCall(node.name)) {
+        return { ...node, args: recursedArgs };
+      }
+      const def = ctx.cat?.get(node.name);
+      if (def) {
+        const mappedProps = {};
+        for (let i = 0; i < def.params.length && i < recursedArgs.length; i++) {
+          mappedProps[def.params[i].name] = recursedArgs[i];
+        }
+        return { ...node, args: recursedArgs, mappedProps };
+      }
+      ctx.errors.push({
+        code: "unknown-component",
+        component: node.name,
+        path: "",
+        message: `Unknown component "${node.name}" \u2014 not found in catalog or builtins`,
+        statementId: ctx.currentStatementId
+      });
+      return { ...node, args: recursedArgs };
+    }
+    case "Arr":
+      return { ...node, els: node.els.map((e) => materializeExprInternal(e, ctx, scopedRefs)) };
+    case "Obj":
+      return {
+        ...node,
+        entries: node.entries.map(
+          ([k, v]) => [k, materializeExprInternal(v, ctx, scopedRefs)]
+        )
+      };
+    case "BinOp":
+      return {
+        ...node,
+        left: materializeExprInternal(node.left, ctx, scopedRefs),
+        right: materializeExprInternal(node.right, ctx, scopedRefs)
+      };
+    case "UnaryOp":
+      return { ...node, operand: materializeExprInternal(node.operand, ctx, scopedRefs) };
+    case "Ternary":
+      return {
+        ...node,
+        cond: materializeExprInternal(node.cond, ctx, scopedRefs),
+        then: materializeExprInternal(node.then, ctx, scopedRefs),
+        else: materializeExprInternal(node.else, ctx, scopedRefs)
+      };
+    case "Member":
+      return { ...node, obj: materializeExprInternal(node.obj, ctx, scopedRefs) };
+    case "Index":
+      return {
+        ...node,
+        obj: materializeExprInternal(node.obj, ctx, scopedRefs),
+        index: materializeExprInternal(node.index, ctx, scopedRefs)
+      };
+    case "Assign":
+      return { ...node, value: materializeExprInternal(node.value, ctx, scopedRefs) };
+    // Literals, StateRef, RuntimeRef — pass through unchanged
+    default:
+      return node;
+  }
+}
+function materializeExpr(node, ctx) {
+  return materializeExprInternal(node, ctx, /* @__PURE__ */ new Set());
+}
+function materializeValue(node, ctx) {
+  switch (node.k) {
+    // ── Ref resolution ───────────────────────────────────────────────────
+    case "Ref":
+      return resolveRef(node.n, ctx, "value");
+    // ── Literals → plain values ──────────────────────────────────────────
+    case "Str":
+      return node.v;
+    case "Num":
+      return node.v;
+    case "Bool":
+      return node.v;
+    case "Null":
+      return null;
+    case "Ph":
+      return null;
+    // ── Collections ──────────────────────────────────────────────────────
+    case "Arr": {
+      const items = [];
+      for (const e of node.els) {
+        if (e.k === "Ph") continue;
+        const value = materializeValue(e, ctx);
+        if (value === null && (e.k === "Comp" || e.k === "Ref")) continue;
+        items.push(value);
+      }
+      return items;
+    }
+    case "Obj": {
+      const o = {};
+      for (const [k, v] of node.entries) o[k] = materializeValue(v, ctx);
+      return o;
+    }
+    // ── Component nodes ──────────────────────────────────────────────────
+    case "Comp": {
+      const { name, args } = node;
+      if (isBuiltin(name)) {
+        const lazy2 = materializeLazyBuiltin(node, ctx, /* @__PURE__ */ new Set());
+        if (lazy2) return lazy2;
+        return { ...node, args: args.map((a) => materializeExpr(a, ctx)) };
+      }
+      if (isReservedCall(name)) {
+        ctx.errors.push({
+          code: "inline-reserved",
+          component: name,
+          path: "",
+          message: `${name}() must be declared as a top-level statement, not used inline as a value`,
+          statementId: ctx.currentStatementId
+        });
+        return null;
+      }
+      const def = ctx.cat?.get(name);
+      const props = {};
+      if (def) {
+        for (let i = 0; i < def.params.length && i < args.length; i++) {
+          props[def.params[i].name] = materializeValue(args[i], ctx);
+        }
+        if (args.length > def.params.length) {
+          const excessCount = args.length - def.params.length;
+          ctx.errors.push({
+            code: "excess-args",
+            component: name,
+            path: "",
+            message: `${name} takes ${def.params.length} arg(s), got ${args.length} (${excessCount} excess dropped)`,
+            statementId: ctx.currentStatementId
+          });
+        }
+        const missingRequired = def.params.filter(
+          (p) => p.required && (!(p.name in props) || props[p.name] === null)
+        );
+        if (missingRequired.length) {
+          const stillInvalid = missingRequired.filter((p) => {
+            if (p.defaultValue !== void 0) {
+              props[p.name] = p.defaultValue;
+              return false;
+            }
+            return true;
+          });
+          if (stillInvalid.length) {
+            for (const p of stillInvalid) {
+              const isNull = p.name in props;
+              ctx.errors.push({
+                code: isNull ? "null-required" : "missing-required",
+                component: name,
+                path: `/${p.name}`,
+                message: isNull ? `required field "${p.name}" cannot be null` : `missing required field "${p.name}"`,
+                statementId: ctx.currentStatementId
+              });
+            }
+            return null;
+          }
+        }
+      } else if (!isBuiltin(name) && !isReservedCall(name)) {
+        ctx.errors.push({
+          code: "unknown-component",
+          component: name,
+          path: "",
+          message: `Unknown component "${name}" \u2014 not found in catalog or builtins`,
+          statementId: ctx.currentStatementId
+        });
+        return null;
+      }
+      const hasDynamicProps = Object.values(props).some((v) => containsDynamicValue(v));
+      return { type: "element", typeName: name, props, partial: ctx.partial, hasDynamicProps };
+    }
+    // ── Runtime expression nodes → preserve as ASTNode, normalize children ─
+    default: {
+      if (isRuntimeExpr(node)) {
+        return materializeExpr(node, ctx);
+      }
+      return node;
+    }
+  }
+}
+
+// src/genui/lang/parser/statements.ts
+function autoClose(input) {
+  const stack = [];
+  let inStr = false;
+  let esc = false;
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i];
+    if (esc) {
+      esc = false;
+      continue;
+    }
+    if (c === "\\" && inStr) {
+      esc = true;
+      continue;
+    }
+    if (inStr) {
+      if (c === inStr) inStr = false;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      inStr = c;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{") stack.push(c);
+    else if (c === ")" && stack[stack.length - 1] === "(") stack.pop();
+    else if (c === "]" && stack[stack.length - 1] === "[") stack.pop();
+    else if (c === "}" && stack[stack.length - 1] === "{") stack.pop();
+  }
+  const wasIncomplete = !!inStr || stack.length > 0;
+  if (!wasIncomplete) return { text: input, wasIncomplete: false };
+  let out = input;
+  if (inStr) {
+    if (esc) out += "\\";
+    out += inStr;
+  }
+  for (let j = stack.length - 1; j >= 0; j--)
+    out += stack[j] === "(" ? ")" : stack[j] === "[" ? "]" : "}";
+  return { text: out, wasIncomplete: true };
+}
+function split(tokens) {
+  const stmts = [];
+  let pos = 0;
+  while (pos < tokens.length) {
+    while (pos < tokens.length && tokens[pos].t === 0 /* Newline */) pos++;
+    if (pos >= tokens.length || tokens[pos].t === 13 /* EOF */) break;
+    const tok = tokens[pos];
+    if (tok.t !== 16 /* Ident */ && tok.t !== 17 /* Type */ && tok.t !== 18 /* StateVar */) {
+      while (pos < tokens.length && tokens[pos].t !== 0 /* Newline */ && tokens[pos].t !== 13 /* EOF */) pos++;
+      continue;
+    }
+    const id = tok.v;
+    const idTokenType = tok.t;
+    pos++;
+    if (pos >= tokens.length || tokens[pos].t !== 9 /* Equals */) {
+      while (pos < tokens.length && tokens[pos].t !== 0 /* Newline */ && tokens[pos].t !== 13 /* EOF */) pos++;
+      continue;
+    }
+    pos++;
+    const expr = [];
+    let depth = 0;
+    let ternaryDepth = 0;
+    while (pos < tokens.length && tokens[pos].t !== 13 /* EOF */) {
+      const tt = tokens[pos].t;
+      if (tt === 0 /* Newline */ && depth <= 0 && ternaryDepth <= 0) {
+        let peek = pos + 1;
+        while (peek < tokens.length && tokens[peek].t === 0 /* Newline */) peek++;
+        const nextT = peek < tokens.length ? tokens[peek].t : 13 /* EOF */;
+        if (nextT === 34 /* Question */ || nextT === 8 /* Colon */ && ternaryDepth > 0) {
+          pos++;
+          continue;
+        }
+        break;
+      }
+      if (tt === 0 /* Newline */) {
+        pos++;
+        continue;
+      }
+      if (tt === 1 /* LParen */ || tt === 3 /* LBrack */ || tt === 5 /* LBrace */) depth++;
+      else if ((tt === 2 /* RParen */ || tt === 4 /* RBrack */ || tt === 6 /* RBrace */) && depth > 0) depth--;
+      else if (tt === 34 /* Question */ && depth === 0) ternaryDepth++;
+      else if (tt === 8 /* Colon */ && depth === 0 && ternaryDepth > 0) ternaryDepth--;
+      expr.push(tokens[pos++]);
+    }
+    if (expr.length) stmts.push({ id, idTokenType, tokens: expr });
+  }
+  return stmts;
+}
+
+// src/genui/lang/parser/parser.ts
+function emptyResult(incomplete = true) {
+  return {
+    root: null,
+    meta: {
+      incomplete,
+      unresolved: [],
+      orphaned: [],
+      statementCount: 0,
+      errors: []
+    },
+    stateDeclarations: {},
+    queryStatements: [],
+    mutationStatements: []
+  };
+}
+function collectQueryDeps(node) {
+  if (!isASTNode(node)) return [];
+  const refs = /* @__PURE__ */ new Set();
+  walkAST(node, (current) => {
+    if (current.k === "StateRef") refs.add(current.n);
+  });
+  return [...refs];
+}
+function classifyStatement(raw, expr) {
+  if (expr.k === "Comp" && expr.name === RESERVED_CALLS.Query) {
+    const deps = collectQueryDeps(expr.args[1]);
+    return {
+      kind: "query",
+      id: raw.id,
+      call: { callee: RESERVED_CALLS.Query, args: expr.args },
+      expr,
+      deps: deps.length > 0 ? deps : void 0
+    };
+  }
+  if (expr.k === "Comp" && expr.name === RESERVED_CALLS.Mutation) {
+    return {
+      kind: "mutation",
+      id: raw.id,
+      call: { callee: RESERVED_CALLS.Mutation, args: expr.args },
+      expr
+    };
+  }
+  if (raw.idTokenType === 18 /* StateVar */) {
+    return { kind: "state", id: raw.id, init: expr };
+  }
+  return { kind: "value", id: raw.id, expr };
+}
+function extractStatements(stmts, ctx) {
+  const stateDeclarations = {};
+  const queryStatements = [];
+  const mutationStatements = [];
+  for (const stmt of stmts) {
+    switch (stmt.kind) {
+      case "state":
+        stateDeclarations[stmt.id] = materializeValue(stmt.init, ctx);
+        break;
+      case "query":
+        queryStatements.push({
+          statementId: stmt.id,
+          toolAST: stmt.call.args[0] ?? null,
+          argsAST: stmt.call.args[1] ?? null,
+          defaultsAST: stmt.call.args[2] ?? null,
+          refreshAST: stmt.call.args[3] ?? null,
+          deps: stmt.deps,
+          complete: true
+        });
+        break;
+      case "mutation":
+        mutationStatements.push({
+          statementId: stmt.id,
+          toolAST: stmt.call.args[0] ?? null,
+          argsAST: stmt.call.args[1] ?? null
+        });
+        break;
+    }
+  }
+  for (const stmt of stmts) {
+    const nodes = stmt.kind === "state" ? [stmt.init] : stmt.kind === "value" ? [stmt.expr] : stmt.kind === "query" || stmt.kind === "mutation" ? stmt.call.args : [];
+    for (const node of nodes) {
+      for (const dep of collectQueryDeps(node)) {
+        if (!(dep in stateDeclarations)) {
+          stateDeclarations[dep] = null;
+        }
+      }
+    }
+  }
+  return { stateDeclarations, queryStatements, mutationStatements };
+}
+var DEFAULT_ROOT_STATEMENT_ID = "root";
+function isComponentStatement(stmt) {
+  return stmt.kind === "value" && stmt.expr.k === "Comp" && !isBuiltin(stmt.expr.name) && stmt.expr.name !== RESERVED_CALLS.Query && stmt.expr.name !== RESERVED_CALLS.Mutation;
+}
+function pickEntryId(stmtMap, typedStmts, firstId, rootName) {
+  if (stmtMap.has(DEFAULT_ROOT_STATEMENT_ID)) return DEFAULT_ROOT_STATEMENT_ID;
+  if (rootName && stmtMap.has(rootName)) return rootName;
+  const preferredComponent = rootName ? typedStmts.find((stmt) => isComponentStatement(stmt) && stmt.expr.name === rootName) : void 0;
+  if (preferredComponent) return preferredComponent.id;
+  const firstComponent = typedStmts.find(isComponentStatement);
+  return firstComponent?.id ?? firstId;
+}
+function buildResult(stmtMap, typedStmts, firstId, wasIncomplete, stmtCount, cat, rootName) {
+  const entryId = pickEntryId(stmtMap, typedStmts, firstId, rootName);
+  if (!stmtMap.has(entryId)) return emptyResult(wasIncomplete);
+  const syms = /* @__PURE__ */ new Map();
+  for (const [id, stmt] of stmtMap) {
+    syms.set(id, stmt.kind === "state" ? stmt.init : stmt.expr);
+  }
+  const unres = [];
+  const errors = [];
+  const unreached = /* @__PURE__ */ new Set();
+  for (const [id, stmt] of stmtMap) {
+    if (id === entryId) continue;
+    if (stmt.kind === "state" || stmt.kind === "query" || stmt.kind === "mutation") continue;
+    unreached.add(id);
+  }
+  const ctx = {
+    syms,
+    cat,
+    errors,
+    unres,
+    visited: /* @__PURE__ */ new Set(),
+    partial: wasIncomplete,
+    currentStatementId: entryId,
+    unreached
+  };
+  const materialized = materializeValue(syms.get(entryId), ctx);
+  const root = isElementNode(materialized) ? materialized : null;
+  if (root) root.statementId = entryId;
+  const { stateDeclarations, queryStatements, mutationStatements } = extractStatements(
+    typedStmts,
+    ctx
+  );
+  const orphaned = [...unreached];
+  return {
+    root,
+    meta: {
+      incomplete: wasIncomplete,
+      unresolved: unres,
+      orphaned,
+      statementCount: stmtCount,
+      errors
+    },
+    stateDeclarations,
+    queryStatements,
+    mutationStatements
+  };
+}
+function skipString(input, start) {
+  if (input[start] !== '"') return start;
+  let i = start + 1;
+  while (i < input.length) {
+    const c = input[i];
+    if (c === "\\") {
+      i += 2;
+    } else if (c === '"') {
+      return i + 1;
+    } else {
+      i++;
+    }
+  }
+  return i;
+}
+function stripFences(input) {
+  const blocks = [];
+  let i = 0;
+  while (i < input.length) {
+    let fenceStart = -1;
+    while (i < input.length) {
+      const nextI = skipString(input, i);
+      if (nextI > i) {
+        i = nextI;
+        continue;
+      }
+      const c = input[i];
+      if (c === "`" && i + 1 < input.length && input[i + 1] === "`" && i + 2 < input.length && input[i + 2] === "`") {
+        fenceStart = i;
+        break;
+      }
+      i++;
+    }
+    if (fenceStart === -1) break;
+    let j = fenceStart + 3;
+    while (j < input.length && input[j] !== "\n") j++;
+    if (j >= input.length) {
+      blocks.push(input.slice(fenceStart + 3).replace(/^[^\n]*\n?/, ""));
+      i = input.length;
+      break;
+    }
+    j++;
+    let closePos = -1;
+    let k = j;
+    while (k < input.length) {
+      const nextK = skipString(input, k);
+      if (nextK > k) {
+        k = nextK;
+        continue;
+      }
+      const c = input[k];
+      if (c === "`" && k + 1 < input.length && input[k + 1] === "`" && k + 2 < input.length && input[k + 2] === "`") {
+        closePos = k;
+        break;
+      }
+      k++;
+    }
+    if (closePos !== -1) {
+      blocks.push(input.slice(j, closePos));
+      i = closePos + 3;
+    } else {
+      blocks.push(input.slice(j));
+      i = input.length;
+    }
+  }
+  if (blocks.length > 0) return blocks.join("\n");
+  if (input.startsWith("```")) {
+    let j = 3;
+    while (j < input.length && input[j] !== "\n") j++;
+    const start = j < input.length ? j + 1 : 3;
+    const body = input.slice(start);
+    const trailingFence = body.lastIndexOf("```");
+    if (trailingFence !== -1) {
+      return body.slice(0, trailingFence);
+    }
+    return body;
+  }
+  return input;
+}
+function stripComments(input) {
+  let inStr = false;
+  return input.split("\n").map((line) => {
+    for (let i = 0; i < line.length; i++) {
+      const c = line[i];
+      if (inStr) {
+        if (c === "\\" && i + 1 < line.length) {
+          i++;
+          continue;
+        }
+        if (c === inStr) inStr = false;
+        continue;
+      }
+      if (c === '"' || c === "'") {
+        inStr = c;
+        continue;
+      }
+      if (c === "/" && line[i + 1] === "/") {
+        return line.substring(0, i).trimEnd();
+      }
+      if (c === "#") {
+        return line.substring(0, i).trimEnd();
+      }
+    }
+    return line;
+  }).join("\n");
+}
+function preprocess(input) {
+  return stripComments(stripFences(input.trim())).trim();
+}
+function parse(input, cat, rootName) {
+  const trimmed = preprocess(input);
+  if (!trimmed) return emptyResult();
+  const { text, wasIncomplete } = autoClose(trimmed);
+  const stmts = split(tokenize(text));
+  if (!stmts.length) return emptyResult(wasIncomplete);
+  const stmtMap = /* @__PURE__ */ new Map();
+  let firstId = "";
+  for (const s of stmts) {
+    const expr = parseExpression(s.tokens);
+    const stmt = classifyStatement(s, expr);
+    stmtMap.set(s.id, stmt);
+    if (!firstId) firstId = s.id;
+  }
+  const typedStmts = [...stmtMap.values()];
+  return buildResult(stmtMap, typedStmts, firstId, wasIncomplete, stmtMap.size, cat, rootName);
+}
+function createStreamParser(cat, rootName) {
+  let buf = "";
+  let cleaned = "";
+  let completedEnd = 0;
+  const completedStmtMap = /* @__PURE__ */ new Map();
+  let firstId = "";
+  function addStmt(text) {
+    const t = text.trim();
+    if (!t) return;
+    for (const s of split(tokenize(t))) {
+      const expr = parseExpression(s.tokens);
+      const stmt = classifyStatement(s, expr);
+      completedStmtMap.set(s.id, stmt);
+      if (!firstId) firstId = s.id;
+    }
+  }
+  function refreshCleaned() {
+    const next = preprocess(buf);
+    if (!next.startsWith(cleaned.slice(0, completedEnd))) {
+      completedEnd = 0;
+      completedStmtMap.clear();
+      firstId = "";
+    }
+    cleaned = next;
+  }
+  function scanNewCompleted() {
+    let depth = 0, ternaryDepth = 0, inStr = false, esc = false;
+    let stmtStart = completedEnd;
+    for (let i = completedEnd; i < cleaned.length; i++) {
+      const c = cleaned[i];
+      if (esc) {
+        esc = false;
+        continue;
+      }
+      if (c === "\\" && inStr) {
+        esc = true;
+        continue;
+      }
+      if (inStr) {
+        if (c === inStr) inStr = false;
+        continue;
+      }
+      if (c === '"' || c === "'") {
+        inStr = c;
+        continue;
+      }
+      if (c === "(" || c === "[" || c === "{") depth++;
+      else if (c === ")" || c === "]" || c === "}") depth = Math.max(0, depth - 1);
+      else if (c === "?" && depth === 0) ternaryDepth++;
+      else if (c === ":" && depth === 0 && ternaryDepth > 0) ternaryDepth--;
+      else if (c === "\n" && depth <= 0 && ternaryDepth <= 0) {
+        let peek = i + 1;
+        while (peek < cleaned.length && (cleaned[peek] === " " || cleaned[peek] === "	" || cleaned[peek] === "\r" || cleaned[peek] === "\n"))
+          peek++;
+        if (peek < cleaned.length && (cleaned[peek] === "?" || cleaned[peek] === ":" && ternaryDepth > 0)) {
+          continue;
+        }
+        const t = cleaned.slice(stmtStart, i).trim();
+        if (t) addStmt(t);
+        stmtStart = i + 1;
+        completedEnd = i + 1;
+      }
+    }
+    return stmtStart;
+  }
+  function currentResult() {
+    refreshCleaned();
+    const pendingStart = scanNewCompleted();
+    const pendingText = cleaned.slice(pendingStart).trim();
+    if (!pendingText) {
+      if (completedStmtMap.size === 0) return emptyResult();
+      return buildResult(
+        completedStmtMap,
+        [...completedStmtMap.values()],
+        firstId,
+        false,
+        completedStmtMap.size,
+        cat,
+        rootName
+      );
+    }
+    const { text: closed, wasIncomplete } = autoClose(pendingText);
+    const stmts = split(tokenize(closed));
+    if (!stmts.length) {
+      if (completedStmtMap.size === 0) return emptyResult(wasIncomplete);
+      return buildResult(
+        completedStmtMap,
+        [...completedStmtMap.values()],
+        firstId,
+        wasIncomplete,
+        completedStmtMap.size,
+        cat,
+        rootName
+      );
+    }
+    const allStmtMap = new Map(completedStmtMap);
+    for (const s of stmts) {
+      const expr = parseExpression(s.tokens);
+      const stmt = classifyStatement(s, expr);
+      allStmtMap.set(s.id, stmt);
+    }
+    const allTypedStmts = [...allStmtMap.values()];
+    const fid = firstId || stmts[0].id;
+    return buildResult(
+      allStmtMap,
+      allTypedStmts,
+      fid,
+      wasIncomplete,
+      allStmtMap.size,
+      cat,
+      rootName
+    );
+  }
+  function reset() {
+    buf = "";
+    cleaned = "";
+    completedEnd = 0;
+    completedStmtMap.clear();
+    firstId = "";
+  }
+  return {
+    push(chunk) {
+      buf += chunk;
+      return currentResult();
+    },
+    set(fullText) {
+      if (fullText.length < buf.length || !fullText.startsWith(buf)) {
+        reset();
+      }
+      const delta = fullText.slice(buf.length);
+      if (delta) buf += delta;
+      return currentResult();
+    },
+    getResult: currentResult
+  };
+}
+function useGenUIProgram(text, catalog) {
+  const parserRef = React14.useRef(
+    null
+  );
+  if (!parserRef.current || parserRef.current.catalog !== catalog) {
+    parserRef.current = { catalog, parser: createStreamParser(catalog, "root") };
+  }
+  const lastGoodRef = React14.useRef(null);
+  return React14.useMemo(() => {
+    const result = parserRef.current.parser.set(text);
+    if (result.root) {
+      lastGoodRef.current = result.root;
+    }
+    return { result, root: result.root ?? lastGoodRef.current };
+  }, [text, catalog]);
+}
+var noop = () => {
+};
+function childKey(value, index) {
+  if (isElementNode(value) && value.statementId) return `s:${value.statementId}`;
+  return `i:${index}`;
+}
+var RenderDepthContext = React14.createContext(0);
+var MAX_DEPTH = 64;
+var GenUINode = React14.memo(function GenUINode2({
+  node,
+  components,
+  onAction,
+  isStreaming,
+  onTelemetry
+}) {
+  const depth = React14.useContext(RenderDepthContext);
+  if (depth > MAX_DEPTH) {
+    onTelemetry?.({ kind: "dropped-node", typeName: node.typeName });
+    return null;
+  }
+  const renderer = components[node.typeName];
+  if (!renderer) {
+    onTelemetry?.({ kind: "unknown-component", typeName: node.typeName });
+    return null;
+  }
+  const render = (value) => {
+    if (value == null) return null;
+    if (isElementNode(value)) {
+      return /* @__PURE__ */ jsxRuntime.jsx(RenderDepthContext.Provider, { value: depth + 1, children: /* @__PURE__ */ jsxRuntime.jsx(
+        GenUINode2,
+        {
+          node: value,
+          components,
+          onAction,
+          isStreaming,
+          onTelemetry
+        }
+      ) });
+    }
+    if (Array.isArray(value)) {
+      return value.map((item, index) => /* @__PURE__ */ jsxRuntime.jsx(React14__default.default.Fragment, { children: render(item) }, childKey(item, index)));
+    }
+    if (typeof value === "object" && isRuntimeExpr(value)) return null;
+    if (typeof value === "string" || typeof value === "number") return String(value);
+    return null;
+  };
+  return renderer({ node, ctx: { render, onAction, isStreaming } });
+});
+function GenUIView({
+  root,
+  components,
+  onAction = noop,
+  isStreaming = false,
+  onTelemetry,
+  placeholder = null
+}) {
+  if (!root) return placeholder;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    GenUINode,
+    {
+      node: root,
+      components,
+      onAction,
+      isStreaming,
+      onTelemetry
+    }
+  );
+}
+
+// src/genui/registry.ts
+var CIMPLIFY_GENUI_REGISTRY = {
+  version: "3",
+  components: [
+    {
+      name: "Stack",
+      description: 'Layout container. direction: "column" (default) or "row"; gap in points (default 12)',
+      params: [{ name: "children", required: true }, { name: "direction" }, { name: "gap" }]
+    },
+    {
+      name: "Card",
+      description: "Elevated surface grouping related content, with an optional title",
+      params: [{ name: "children", required: true }, { name: "title" }]
+    },
+    {
+      name: "TextContent",
+      description: 'Text block. size: "display", "heading", "title", "body" (default), "label", "caption"',
+      params: [{ name: "text", required: true }, { name: "size" }]
+    },
+    {
+      name: "Stat",
+      description: "Compact stat: small label over a bold value, optional sub line and tone",
+      params: [
+        { name: "label", required: true },
+        { name: "value", required: true },
+        { name: "sub" },
+        { name: "tone" }
+      ]
+    },
+    {
+      name: "Metric",
+      description: "KPI card with label, value, optional percent change and SF Symbol icon",
+      params: [
+        { name: "label", required: true },
+        { name: "value", required: true },
+        { name: "change" },
+        { name: "icon" }
+      ]
+    },
+    {
+      name: "KeyValue",
+      description: "Label/value row; set mono true for numeric values",
+      params: [
+        { name: "label", required: true },
+        { name: "value", required: true },
+        { name: "mono" }
+      ]
+    },
+    {
+      name: "Badge",
+      description: "Small status chip. tone: neutral, positive, info, indigo, violet, warning, danger",
+      params: [{ name: "label", required: true }, { name: "tone" }]
+    },
+    {
+      name: "Callout",
+      description: "Inline alert with title, optional message. tone: info (default), success, warning, danger, accent, neutral",
+      params: [{ name: "title", required: true }, { name: "message" }, { name: "tone" }]
+    },
+    {
+      name: "Button",
+      description: 'Action button. action: "action:name" string or Action([...]) steps. variant: primary, cta, secondary (default), ghost, destructive',
+      params: [
+        { name: "label", required: true },
+        { name: "action", required: true },
+        { name: "variant" }
+      ]
+    },
+    {
+      name: "Buttons",
+      description: 'Row (default) or column of Buttons; direction: "row" or "column"',
+      params: [{ name: "children", required: true }, { name: "direction" }]
+    },
+    {
+      name: "Divider",
+      description: "Hairline separator",
+      params: []
+    },
+    {
+      name: "Table",
+      description: "Data table: headers is an array of strings, rows an array of cell arrays",
+      params: [
+        { name: "headers", required: true },
+        { name: "rows", required: true }
+      ]
+    },
+    {
+      name: "BarChart",
+      description: "Bar chart: labels (x axis strings) and values (numbers), optional title",
+      params: [
+        { name: "labels", required: true },
+        { name: "values", required: true },
+        { name: "title" }
+      ]
+    },
+    {
+      name: "LineChart",
+      description: "Line chart with area fill: labels and values, optional title",
+      params: [
+        { name: "labels", required: true },
+        { name: "values", required: true },
+        { name: "title" }
+      ]
+    },
+    {
+      name: "Money",
+      description: "Formatted money amount, never abbreviated. currency: ISO code (default USD)",
+      params: [{ name: "amount", required: true }, { name: "currency" }]
+    },
+    {
+      name: "Image",
+      description: "Remote image by URL with optional caption",
+      params: [{ name: "url", required: true }, { name: "caption" }]
+    },
+    {
+      name: "ListRow",
+      description: "Entity row for orders/customers/products/invoices: initials avatar (or SF Symbol tile via symbol), title + subtitle, trailing value and badge with tone",
+      params: [
+        { name: "title", required: true },
+        { name: "subtitle" },
+        { name: "value" },
+        { name: "badge" },
+        { name: "tone" },
+        { name: "symbol" }
+      ]
+    },
+    {
+      name: "Timeline",
+      description: "Event history (order journey, payment trail): events is an array of {title, detail?, time?, tone?} objects, newest first",
+      params: [{ name: "events", required: true }]
+    },
+    {
+      name: "Progress",
+      description: "Amount toward a bound (goal, stock cover, capacity): numeric value and target (default 100), optional detail caption and tone",
+      params: [
+        { name: "label", required: true },
+        { name: "value", required: true },
+        { name: "target" },
+        { name: "detail" },
+        { name: "tone" }
+      ]
+    },
+    {
+      name: "DonutChart",
+      description: "Share of a whole (sales by channel, revenue by category): labels + values, optional title and center display string (e.g. the formatted total)",
+      params: [
+        { name: "labels", required: true },
+        { name: "values", required: true },
+        { name: "title" },
+        { name: "center" }
+      ]
+    },
+    {
+      name: "StatusTrack",
+      description: "Stage tracker (order fulfilment, invoice lifecycle): steps are stage names, current is the active step name or index",
+      params: [
+        { name: "steps", required: true },
+        { name: "current", required: true }
+      ]
+    },
+    {
+      name: "LineItems",
+      description: "Order/quote/invoice money block: items is an array of {qty?, name, amount} with display-ready amount strings, adjustments an array of {label, amount, tone?}, total the anchored display string",
+      params: [
+        { name: "items", required: true },
+        { name: "total", required: true },
+        { name: "adjustments" }
+      ]
+    },
+    {
+      name: "Grid",
+      description: "Tile layout for Stat/Metric children, columns default 2",
+      params: [{ name: "children", required: true }, { name: "columns" }]
+    },
+    {
+      name: "Banner",
+      description: "Hero-stat moment on a tonal wash: big value, label, optional percent delta. tone: positive (default), warning, danger, info, neutral",
+      params: [
+        { name: "value", required: true },
+        { name: "label", required: true },
+        { name: "delta" },
+        { name: "tone" }
+      ]
+    },
+    {
+      name: "EmptyState",
+      description: "Nothing-to-show state with an SF Symbol and optional message",
+      params: [{ name: "title", required: true }, { name: "message" }, { name: "symbol" }]
+    }
+  ]
+};
+
+// src/genui/manifest.ts
+function genUIManifest(registry) {
+  return {
+    version: registry.version,
+    components: registry.components.map((component) => ({
+      name: component.name,
+      description: component.description,
+      params: component.params.map((param) => ({
+        name: param.name,
+        required: param.required ?? false
+      }))
+    }))
+  };
+}
+function encodeString(value) {
+  return JSON.stringify(value).replace(/\//g, "\\/");
+}
+function canonicalize(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return encodeString(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalize).join(",")}]`;
+  const keys = Object.keys(value).sort();
+  const entries = keys.map((key) => `${encodeString(key)}:${canonicalize(value[key])}`);
+  return `{${entries.join(",")}}`;
+}
+function genUIManifestJson(manifest) {
+  return canonicalize(manifest);
+}
+async function genUIFingerprint(manifest) {
+  const bytes = new TextEncoder().encode(genUIManifestJson(manifest));
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, 16);
+}
+
+Object.defineProperty(exports, "getVariantDisplayName", {
+  enumerable: true,
+  get: function () { return chunkT7Z25EY4_js.getVariantDisplayName; }
+});
+Object.defineProperty(exports, "messagePreview", {
+  enumerable: true,
+  get: function () { return chunkXREIZ56K_js.messagePreview; }
+});
+Object.defineProperty(exports, "splitGenUIContent", {
+  enumerable: true,
+  get: function () { return chunkXREIZ56K_js.splitGenUIContent; }
 });
 exports.AccommodationCard = AccommodationCard;
 exports.AccountContent = AccountContent;
@@ -17261,6 +19520,7 @@ exports.BundleProductCard = BundleProductCard;
 exports.BundleProductLayout = BundleProductLayout;
 exports.BundleSelector = BundleSelector;
 exports.Button = Button;
+exports.CIMPLIFY_GENUI_REGISTRY = CIMPLIFY_GENUI_REGISTRY;
 exports.CardImage = CardImage;
 exports.CardShell = CardShell;
 exports.CardVariant = CardVariant;
@@ -17274,6 +19534,7 @@ exports.CataloguePage = CataloguePage;
 exports.CatalogueTemplate = CatalogueTemplate;
 exports.CategoryFilter = CategoryFilter;
 exports.CategoryGrid = CategoryGrid;
+exports.ChatMarkdown = ChatMarkdown;
 exports.ChatWidget = ChatWidget;
 exports.CheckIcon = CheckIcon;
 exports.CheckoutPage = CheckoutPage;
@@ -17319,6 +19580,7 @@ exports.FeaturedCollectionLayout = FeaturedCollectionLayout;
 exports.FilterTabs = FilterTabs;
 exports.FoodProductCard = FoodProductCard;
 exports.FoodProductLayout = FoodProductLayout;
+exports.GenUIView = GenUIView;
 exports.HappeningCard = HappeningCard;
 exports.IdentityIcon = IdentityIcon;
 exports.IdentityOfframp = IdentityOfframp;
@@ -17404,9 +19666,17 @@ exports.WelcomeCard = WelcomeCard;
 exports.WholesaleProductCard = WholesaleProductCard;
 exports.WholesaleProductLayout = WholesaleProductLayout;
 exports.WishlistButton = WishlistButton;
+exports.clearOrdersCache = clearOrdersCache;
 exports.cn = cn;
 exports.defaultBoundaryKind = defaultBoundaryKind;
+exports.genUICatalog = genUICatalog;
+exports.genUIFingerprint = genUIFingerprint;
+exports.genUIManifest = genUIManifest;
+exports.genUIManifestJson = genUIManifestJson;
 exports.getBoundaryLabels = getBoundaryLabels;
+exports.isTerminalOrderStatus = isTerminalOrderStatus;
+exports.parseGenUIProgram = parse;
+exports.partitionMessages = partitionMessages;
 exports.prefetchProduct = prefetchProduct;
 exports.prefetchProducts = prefetchProducts;
 exports.resolveBoundaryKind = resolveBoundaryKind;
@@ -17440,6 +19710,7 @@ exports.useDeliveryOptions = useDeliveryOptions;
 exports.useElements = useElements;
 exports.useElementsReady = useElementsReady;
 exports.useFxRate = useFxRate;
+exports.useGenUIProgram = useGenUIProgram;
 exports.useLocations = useLocations;
 exports.useOptionalCimplify = useOptionalCimplify;
 exports.useOrder = useOrder;