@cimplify/sdk 0.89.0 → 0.90.0

package/dist/react.mjs

@@ -1,12 +1,14 @@
 "use client";
 import { DURATION_UNIT, getVariantDisplayName, INPUT_FIELD_TYPE, PRODUCT_TYPE, BOUNDARY_KIND, resolveGallery, RENDER_HINT, DEFAULT_CDN_BASE_URL } from './chunk-OZDDHSIB.mjs';
 export { getVariantDisplayName } from './chunk-OZDDHSIB.mjs';
-import { createCimplifyClient } from './chunk-DENWOZEA.mjs';
+import { messagePreview } from './chunk-U4MW6PYU.mjs';
+export { messagePreview, splitGenUIContent } from './chunk-U4MW6PYU.mjs';
+import { createCimplifyClient } from './chunk-2UDEWILL.mjs';
 import { ELEMENT_TYPES, EVENT_TYPES, startSignIn } from './chunk-ZU4ZRYUR.mjs';
 import { parsePrice, formatMoney, formatPrice, getProductCurrency, getUnitPriceAtQuantity, isOnSale, getDiscountPercentage, getBasePrice, getPriceRange, formatPriceRange } from './chunk-KFLGQGMC.mjs';
 import { isSupportedCurrency } from './chunk-K5EN2W2Q.mjs';
 import './chunk-3G6RQLXK.mjs';
-import React14, { createContext, useRef, useState, useCallback, useEffect, useContext, useMemo, useId, useSyncExternalStore } from 'react';
+import React14, { createContext, lazy, memo, Suspense, useContext, useMemo, useRef, useState, useCallback, useEffect, useId, useSyncExternalStore } from 'react';
 import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
 import * as ReactDOM from 'react-dom';
 import { clsx } from 'clsx';
@@ -24,6 +26,8 @@ import { FilterXSS, safeAttrValue as safeAttrValue$1 } from 'xss';
 import { Dialog } from '@base-ui/react/dialog';
 import { Field } from '@base-ui/react/field';
 import { Input } from '@base-ui/react/input';
+import DOMPurify from 'dompurify';
+import { marked } from 'marked';
 
 // src/ads/identity.ts
 var COOKIE_NAME = "_cimplify_uid";
@@ -766,15 +770,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", {
@@ -814,7 +818,7 @@ function getOrCreateStore(params) {
     optimisticEnabled,
     initialized: false,
     initializePromise: null,
-    syncing: false,
+    syncTail: Promise.resolve(),
     failedOpRemovers: /* @__PURE__ */ new Set()
   };
   cartStores.set(storeKey, entry);
@@ -4279,7 +4283,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;
@@ -4288,8 +4292,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 = {}) {
@@ -4307,13 +4311,13 @@ function createCachedQuery(config) {
     const optionsRef = 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] = useState(cached?.data ?? null);
     const [isLoading, setIsLoading] = useState(enabled && !cached);
     const [error, setError] = useState(null);
@@ -4326,7 +4330,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);
@@ -4343,7 +4347,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);
@@ -4364,23 +4368,23 @@ function createCachedQuery(config) {
       void load(false);
     }, [load]);
     const refetch = 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;
@@ -4508,6 +4512,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) {
@@ -5349,6 +5356,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;
@@ -5854,6 +5864,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;
@@ -5862,6 +5873,10 @@ function useChat(options = {}) {
   const [isSending, setIsSending] = useState(false);
   const [error, setError] = useState(null);
   const [conversationOpened, setConversationOpened] = useState(false);
+  const [humanRequested, setHumanRequested] = useState(false);
+  const [awaitingReply, setAwaitingReply] = useState(false);
+  const [seenAt, setSeenAt] = useState(null);
+  const [mayHaveOlder, setMayHaveOlder] = useState(false);
   const pollRef = useRef(null);
   const lastActivityRef = useRef(Date.now());
   const openedRef = useRef(false);
@@ -5870,17 +5885,42 @@ function useChat(options = {}) {
   const wsRef = useRef(null);
   const wsReconnectAttemptRef = useRef(0);
   const wsReconnectTimerRef = useRef(null);
+  const aiEnabledRef = useRef(false);
+  const humanRequestedRef = useRef(false);
+  const awaitReplyTimerRef = 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 = 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 = useCallback(() => {
+    if (awaitReplyTimerRef.current) {
+      clearTimeout(awaitReplyTimerRef.current);
+      awaitReplyTimerRef.current = null;
+    }
+    setAwaitingReply(false);
+  }, []);
+  const startAwaitingReply = useCallback(() => {
+    setAwaitingReply(true);
+    if (awaitReplyTimerRef.current) clearTimeout(awaitReplyTimerRef.current);
+    awaitReplyTimerRef.current = setTimeout(() => {
+      awaitReplyTimerRef.current = null;
+      setAwaitingReply(false);
+    }, AWAIT_REPLY_TIMEOUT_MS);
   }, []);
+  const appendMessages = 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 = useCallback(async () => {
     const c = clientRef.current;
     if (!c) return;
@@ -5929,6 +5969,13 @@ 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];
@@ -5959,6 +6006,7 @@ function useChat(options = {}) {
     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();
@@ -5974,6 +6022,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;
@@ -5982,27 +6034,39 @@ function useChat(options = {}) {
     setIsLoading(false);
   }, [client, connectWebSocket]);
   const send = 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: 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(
@@ -6013,13 +6077,17 @@ function useChat(options = {}) {
             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 = useCallback(
     async (starterText) => {
@@ -6030,14 +6098,65 @@ function useChat(options = {}) {
     },
     [openConversation, send]
   );
+  const react = 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 = 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 = 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 = createContext({
@@ -9335,6 +9454,7 @@ function ProductCustomizer({
   onAddToCart,
   onVariantChange,
   showSpecialInstructions = true,
+  submitLabel,
   className,
   classNames
 }) {
@@ -9723,8 +9843,10 @@ function ProductCustomizer({
                   isAdded && classNames?.submitButtonAdded,
                   classNames?.submitButton
                 ),
-                children: isAdded ? "Added to Cart" : /* @__PURE__ */ jsxs(Fragment, { children: [
-                  "Add to Cart \xB7 ",
+                children: isAdded ? "Added" : /* @__PURE__ */ jsxs(Fragment, { children: [
+                  submitLabel ?? "Add to Cart",
+                  " \xB7",
+                  " ",
                   /* @__PURE__ */ jsx(Price, { amount: displayTotalPrice, currency })
                 ] })
               }
@@ -9884,13 +10006,13 @@ function StoreVideo({
   autoplay = true,
   loop = true,
   muted = true,
-  lazy = true,
+  lazy: lazy2 = true,
   className
 }) {
   const ref = useRef(null);
-  const [inView, setInView] = useState(!lazy);
+  const [inView, setInView] = useState(!lazy2);
   useEffect(() => {
-    if (!lazy || inView) return;
+    if (!lazy2 || inView) return;
     const node = ref.current;
     if (!node || typeof IntersectionObserver === "undefined") {
       setInView(true);
@@ -9907,7 +10029,7 @@ function StoreVideo({
     );
     observer.observe(node);
     return () => observer.disconnect();
-  }, [lazy, inView]);
+  }, [lazy2, inView]);
   return /* @__PURE__ */ jsx(
     "div",
     {
@@ -9925,7 +10047,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__ */ jsx(
@@ -16727,6 +16849,112 @@ function CurrencySelector({
     );
   }) });
 }
+var Streamdown = lazy(() => import('streamdown').then((m) => ({ default: m.Streamdown })));
+function detectLookbehindSupport() {
+  try {
+    new RegExp("(?<=a)b");
+    return true;
+  } catch {
+    return false;
+  }
+}
+var supportsRegExpLookbehind = detectLookbehindSupport();
+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.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.sanitize(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 = useMemo(() => renderMarkdown(text), [text]);
+  return /* @__PURE__ */ jsx("div", { className, dangerouslySetInnerHTML: { __html: html } });
+}
+var ChatMarkdown = 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__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(SettledMarkdown, { text, className }), children: /* @__PURE__ */ jsx(Streamdown, { className, children: text }) })
+    );
+  }
+  return /* @__PURE__ */ 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",
@@ -16744,7 +16972,35 @@ function ChatWidget({
   const client = clientProp ?? context?.client;
   const [open, setOpen] = useState(defaultOpen);
   const [unread, setUnread] = 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 = 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 = useRef(messages.length);
   useEffect(() => {
     if (!open && messages.length > prevCountRef.current) {
@@ -16791,11 +17047,15 @@ function ChatWidget({
             messages,
             isLoading,
             isSending,
+            isTyping: showTyping,
+            seenAt,
             error,
             isActive,
             isLeft,
             onClose: handleClose,
             onSend: send,
+            onReact: react,
+            onAttach: attachPhoto,
             onStartConversation: startConversation,
             classNames
           }
@@ -16848,11 +17108,15 @@ function Panel({
   messages,
   isLoading,
   isSending,
+  isTyping,
+  seenAt,
   error,
   isActive,
   isLeft,
   onClose,
   onSend,
+  onReact,
+  onAttach,
   onStartConversation,
   classNames
 }) {
@@ -16890,7 +17154,9 @@ function Panel({
           {
             messages,
             isLoading,
-            isSending,
+            isSending: isTyping,
+            seenAt,
+            onReact,
             className: classNames?.messages
           }
         ),
@@ -16901,6 +17167,7 @@ function Panel({
             placeholder,
             isSending,
             onSend,
+            onAttach,
             className: classNames?.input
           }
         ),
@@ -16996,16 +17263,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 = useRef(null);
   useEffect(() => {
     bottomRef.current?.scrollIntoView({ behavior: "smooth" });
   }, [messages.length, isSending]);
+  const { bubbles, reactionsByTarget } = partitionMessages(messages);
+  const seenMessageId = lastSeenCustomerMessageId(bubbles, seenAt);
   return /* @__PURE__ */ jsxs(
     "div",
     {
@@ -17015,40 +17295,111 @@ function MessageList({
       ),
       children: [
         isLoading && messages.length === 0 && /* @__PURE__ */ jsx("div", { className: "flex flex-1 items-center justify-center", children: /* @__PURE__ */ 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__ */ jsxs("div", { children: [
             !sameSenderAsPrev && i > 0 && /* @__PURE__ */ jsx("div", { className: "h-3" }),
-            /* @__PURE__ */ jsx(
+            /* @__PURE__ */ jsxs(
               "div",
               {
                 className: cn(
-                  "flex max-w-[85%]",
+                  "group relative flex max-w-[85%]",
                   isCustomer ? "ml-auto" : "mr-auto"
                 ),
-                children: /* @__PURE__ */ 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__ */ 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__ */ jsx(SparkleIcon, { className: "h-[11px] w-[11px]" }),
-                        "AI"
-                      ] }),
-                      /* @__PURE__ */ jsx("div", { className: "whitespace-pre-wrap", children: msg.content })
-                    ]
-                  }
-                )
+                children: [
+                  !isCustomer && !isOptimistic && /* @__PURE__ */ 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__ */ 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__ */ 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__ */ 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__ */ jsx(SparkleIcon, { className: "h-[11px] w-[11px]" }),
+                          "AI"
+                        ] }),
+                        msg.reply_to && /* @__PURE__ */ 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__ */ jsx(
+                                "span",
+                                {
+                                  className: cn(
+                                    "w-[3px] shrink-0 self-stretch rounded-full",
+                                    isCustomer ? "bg-background/40" : "bg-muted-foreground/40"
+                                  )
+                                }
+                              ),
+                              /* @__PURE__ */ jsx("span", { className: "min-w-0 truncate opacity-80", children: msg.reply_to.preview })
+                            ]
+                          }
+                        ),
+                        msg.attachments.length > 0 && /* @__PURE__ */ 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__ */ jsx("a", { href: attachment.url, target: "_blank", rel: "noreferrer", children: /* @__PURE__ */ jsx(
+                            "img",
+                            {
+                              src: attachment.url,
+                              alt: attachment.filename ?? "Photo",
+                              loading: "lazy",
+                              className: "max-h-48 max-w-full rounded-lg object-cover"
+                            }
+                          ) }, index) : /* @__PURE__ */ jsx(
+                            "a",
+                            {
+                              href: attachment.url,
+                              target: "_blank",
+                              rel: "noreferrer",
+                              className: "truncate text-xs underline",
+                              children: attachment.filename ?? "Attachment"
+                            },
+                            index
+                          )
+                        ) }),
+                        isCustomer ? msg.content && /* @__PURE__ */ jsx("div", { className: "whitespace-pre-wrap", children: msg.content }) : /* @__PURE__ */ 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__ */ jsx("div", { className: cn("mt-0.5 flex gap-1", isCustomer ? "justify-end" : "justify-start"), children: reactions.map((reaction) => /* @__PURE__ */ 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__ */ jsx("div", { className: "mt-0.5 text-right text-[10px] font-medium text-muted-foreground", children: "Seen" })
           ] }, msg.id);
         }),
         isSending && /* @__PURE__ */ jsx("div", { className: "mr-auto mt-1", children: /* @__PURE__ */ jsx(TypingDots, {}) }),
@@ -17061,10 +17412,24 @@ function ChatInput({
   placeholder,
   isSending,
   onSend,
+  onAttach,
   className
 }) {
   const [value, setValue] = useState("");
+  const [uploading, setUploading] = useState(false);
   const textareaRef = useRef(null);
+  const fileRef = useRef(null);
+  const handleAttach = useCallback(
+    async (file) => {
+      setUploading(true);
+      try {
+        await onAttach(file);
+      } finally {
+        setUploading(false);
+      }
+    },
+    [onAttach]
+  );
   const handleSend = useCallback(() => {
     const trimmed = value.trim();
     if (!trimmed || isSending) return;
@@ -17098,6 +17463,37 @@ function ChatInput({
         className
       ),
       children: [
+        /* @__PURE__ */ 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__ */ 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__ */ jsx(ImageIcon, { className: "h-[18px] w-[18px]" })
+          }
+        ),
         /* @__PURE__ */ jsx(
           "div",
           {
@@ -17200,6 +17596,25 @@ function SendIcon({ className }) {
     }
   );
 }
+function ImageIcon({ className }) {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      className,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: 2,
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2", ry: "2" }),
+        /* @__PURE__ */ jsx("circle", { cx: "8.5", cy: "8.5", r: "1.5" }),
+        /* @__PURE__ */ jsx("polyline", { points: "21 15 16 10 5 21" })
+      ]
+    }
+  );
+}
 function SparkleIcon({ className }) {
   return /* @__PURE__ */ jsx(
     "svg",
@@ -17214,4 +17629,1825 @@ function SparkleIcon({ className }) {
   );
 }
 
-export { AccommodationCard, AccountContent, AccountDashboardPage, AccountHero, AccountIdentityStrip, AccountLineItem, AccountLineItems, AccountNav, AccountOrderDetailPage, AccountOrderView, AccountOrdersPage, AccountShell, AccountSidebar, AccountSignedOutPrompt, AccountSubscriptionDetailPage, AccountSubscriptionsPage, Ad, AdProvider, AddOnSelector, AddressElement, AuthElement, AvailabilityBadge, BackLink, BillingPlanSelector, BookingCard, BookingList, BookingPage, BookingSummary, BookingsPage, BoxIcon24, BundleProductCard, BundleProductLayout, BundleSelector, Button, CardImage, CardShell, CardVariant, CartDrawer, CartDrawerProvider, CartPage, CartSummary, CartTemplate, CatalogueCollectionLayout, CataloguePage, CatalogueTemplate, CategoryFilter, CategoryGrid, ChatWidget, CheckIcon, CheckoutPage, CimplifyCheckout, CimplifyProvider, CimplifySignInButton, CimplifyUserButton, CollectionPage, CollectionTemplate, CompactCartLayout, CompactCatalogueLayout, CompactSearchLayout, CompactServiceCard, CompositeProductCard, CompositeProductLayout, CompositeSelector, ContextCard, ContinuityCard, CurrencySelector, CustomAttributesTable, CustomerInputFields, DashboardIcon, DashboardIcon20, DatePicker, DateSlotPicker, DealBanner, DealsPage, DefaultCartLayout, DefaultCatalogueLayout, DefaultCollectionLayout, DefaultProductLayout, DefaultSearchLayout, DeliveryEstimate, DeliveryTracker, DeliveryTruckIcon, DigitalProductCard, DigitalProductLayout, DiscountInput, ElementsProvider, EmptyState, ErrorState, FeaturedCollectionLayout, FilterTabs, FoodProductCard, FoodProductLayout, HappeningCard, IdentityIcon, IdentityOfframp, InventoryBadge, ItemsCard, LeaseServiceCard, LineItemDetails, LocationPicker, MediaGallery, MetadataStringList, MobileAccountShell, MobileBackButton, MobileMoreButton, MobileTabBar, NextDeliveryCard, OrderDetailHeader, OrderDetailMetaPipe, OrderDetailPage, OrderHistory, OrderHistoryPage, OrderList, OrderRow, OrderSummary, OrderTimeline, OrderTotals, OrdersIcon, OrdersIcon20, OvenIcon, PackageIcon, PaymentElement, Price, PriceRange, ProductCard, ProductCustomizer, ProductGrid, ProductImageGallery, ProductModel3D, ProductPage, ProductSheet, ProductTemplate, PropertiesTable, QuantitySelector, QuickAddButton, RecentlyViewed, RecommendationCarousel, RelatedProductsSection, RentalServiceCard, ResourcePicker, RetailProductCard, RichText, SaleBadge, SalePrice, SaleTeaser, ScheduleServiceCard, SearchInput, SearchPage, SearchTemplate, Section, SectionMore, ServiceProductLayout, SessionMessageBanner, SignOutIcon, Skeleton, SlotPicker, SoldOutOverlay, StaffPicker, StandardServiceCard, Status, StoreNav, StoreVideo, SubscriptionCard, SubscriptionList, SubscriptionRow, SubscriptionsIcon, SubscriptionsIcon20, TagPills, TimePicker, Toast, TwoColumnGrid, VariantSelector, VolumePricing, WelcomeCard, WholesaleProductCard, WholesaleProductLayout, WishlistButton, cn, defaultBoundaryKind, getBoundaryLabels, prefetchProduct, prefetchProducts, resolveBoundaryKind, roomToResource, sanitizeRichTextHtml, stripHtmlToText, toAccountLineItem, toAccountLineItems, toAccountOrderView, useActivityState, useAds, useAttributeDefinitions, useAvailableSlots, useBillingPlans, useBookings, useBootstrap, useBundles, useCart, useCartDrawer, useCategories, useChat, useCheckout, useCimplify, useCimplifyClient, useCimplifySession, useCollection, useCollections, useDeals, useDeliveryFee, useDeliveryOptions, useElements, useElementsReady, useFxRate, useLocations, useOptionalCimplify, useOrder, useOrders, useProduct, useProductAvailability, useProductDeals, useProductPrice, useProductSchedules, useProducts, useProductsOnSale, usePropertyFacets, useQuote, useRecommendations, useSearch, useServiceAvailability, useServices, useStoreCredit, useSubscription, useSubscriptions, useTaxonomies, useTaxonomy, useTaxonomyPath, useValidateDiscount, useVariantSelector };
+// 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 = useRef(
+    null
+  );
+  if (!parserRef.current || parserRef.current.catalog !== catalog) {
+    parserRef.current = { catalog, parser: createStreamParser(catalog, "root") };
+  }
+  const lastGoodRef = useRef(null);
+  return 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 = createContext(0);
+var MAX_DEPTH = 64;
+var GenUINode = memo(function GenUINode2({
+  node,
+  components,
+  onAction,
+  isStreaming,
+  onTelemetry
+}) {
+  const depth = 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__ */ jsx(RenderDepthContext.Provider, { value: depth + 1, children: /* @__PURE__ */ jsx(
+        GenUINode2,
+        {
+          node: value,
+          components,
+          onAction,
+          isStreaming,
+          onTelemetry
+        }
+      ) });
+    }
+    if (Array.isArray(value)) {
+      return value.map((item, index) => /* @__PURE__ */ jsx(React14.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__ */ 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);
+}
+
+export { AccommodationCard, AccountContent, AccountDashboardPage, AccountHero, AccountIdentityStrip, AccountLineItem, AccountLineItems, AccountNav, AccountOrderDetailPage, AccountOrderView, AccountOrdersPage, AccountShell, AccountSidebar, AccountSignedOutPrompt, AccountSubscriptionDetailPage, AccountSubscriptionsPage, Ad, AdProvider, AddOnSelector, AddressElement, AuthElement, AvailabilityBadge, BackLink, BillingPlanSelector, BookingCard, BookingList, BookingPage, BookingSummary, BookingsPage, BoxIcon24, BundleProductCard, BundleProductLayout, BundleSelector, Button, CIMPLIFY_GENUI_REGISTRY, CardImage, CardShell, CardVariant, CartDrawer, CartDrawerProvider, CartPage, CartSummary, CartTemplate, CatalogueCollectionLayout, CataloguePage, CatalogueTemplate, CategoryFilter, CategoryGrid, ChatMarkdown, ChatWidget, CheckIcon, CheckoutPage, CimplifyCheckout, CimplifyProvider, CimplifySignInButton, CimplifyUserButton, CollectionPage, CollectionTemplate, CompactCartLayout, CompactCatalogueLayout, CompactSearchLayout, CompactServiceCard, CompositeProductCard, CompositeProductLayout, CompositeSelector, ContextCard, ContinuityCard, CurrencySelector, CustomAttributesTable, CustomerInputFields, DashboardIcon, DashboardIcon20, DatePicker, DateSlotPicker, DealBanner, DealsPage, DefaultCartLayout, DefaultCatalogueLayout, DefaultCollectionLayout, DefaultProductLayout, DefaultSearchLayout, DeliveryEstimate, DeliveryTracker, DeliveryTruckIcon, DigitalProductCard, DigitalProductLayout, DiscountInput, ElementsProvider, EmptyState, ErrorState, FeaturedCollectionLayout, FilterTabs, FoodProductCard, FoodProductLayout, GenUIView, HappeningCard, IdentityIcon, IdentityOfframp, InventoryBadge, ItemsCard, LeaseServiceCard, LineItemDetails, LocationPicker, MediaGallery, MetadataStringList, MobileAccountShell, MobileBackButton, MobileMoreButton, MobileTabBar, NextDeliveryCard, OrderDetailHeader, OrderDetailMetaPipe, OrderDetailPage, OrderHistory, OrderHistoryPage, OrderList, OrderRow, OrderSummary, OrderTimeline, OrderTotals, OrdersIcon, OrdersIcon20, OvenIcon, PackageIcon, PaymentElement, Price, PriceRange, ProductCard, ProductCustomizer, ProductGrid, ProductImageGallery, ProductModel3D, ProductPage, ProductSheet, ProductTemplate, PropertiesTable, QuantitySelector, QuickAddButton, RecentlyViewed, RecommendationCarousel, RelatedProductsSection, RentalServiceCard, ResourcePicker, RetailProductCard, RichText, SaleBadge, SalePrice, SaleTeaser, ScheduleServiceCard, SearchInput, SearchPage, SearchTemplate, Section, SectionMore, ServiceProductLayout, SessionMessageBanner, SignOutIcon, Skeleton, SlotPicker, SoldOutOverlay, StaffPicker, StandardServiceCard, Status, StoreNav, StoreVideo, SubscriptionCard, SubscriptionList, SubscriptionRow, SubscriptionsIcon, SubscriptionsIcon20, TagPills, TimePicker, Toast, TwoColumnGrid, VariantSelector, VolumePricing, WelcomeCard, WholesaleProductCard, WholesaleProductLayout, WishlistButton, clearOrdersCache, cn, defaultBoundaryKind, genUICatalog, genUIFingerprint, genUIManifest, genUIManifestJson, getBoundaryLabels, isTerminalOrderStatus, parse as parseGenUIProgram, partitionMessages, prefetchProduct, prefetchProducts, resolveBoundaryKind, roomToResource, sanitizeRichTextHtml, stripHtmlToText, toAccountLineItem, toAccountLineItems, toAccountOrderView, useActivityState, useAds, useAttributeDefinitions, useAvailableSlots, useBillingPlans, useBookings, useBootstrap, useBundles, useCart, useCartDrawer, useCategories, useChat, useCheckout, useCimplify, useCimplifyClient, useCimplifySession, useCollection, useCollections, useDeals, useDeliveryFee, useDeliveryOptions, useElements, useElementsReady, useFxRate, useGenUIProgram, useLocations, useOptionalCimplify, useOrder, useOrders, useProduct, useProductAvailability, useProductDeals, useProductPrice, useProductSchedules, useProducts, useProductsOnSale, usePropertyFacets, useQuote, useRecommendations, useSearch, useServiceAvailability, useServices, useStoreCredit, useSubscription, useSubscriptions, useTaxonomies, useTaxonomy, useTaxonomyPath, useValidateDiscount, useVariantSelector };