@exponential-at/ui 0.0.0-stage → 0.1.0

package/dist/chunks/index-98npjvsd.js

@@ -0,0 +1,3940 @@
+import {
+  basic_map_default,
+  coreCatalog2,
+  CORE_CATALOG_ID2,
+  CORE_LITE_CATALOG_ID2,
+  A2UI_BASIC_CATALOG_ID2,
+  A2UI_VERSION2,
+  UNKNOWN_COMPONENT2,
+  TOKEN_GROUPS2,
+  parseTokenRef2,
+  isKnownToken2,
+  sharedCatalogView2
+} from "./index-gwkt14w3.js";
+import {
+  validateStyle2,
+  tryLoadTheme2,
+  BUILTIN_THEMES2,
+  BUILTIN_THEME_IDS2,
+  builtinTheme2,
+  MESSAGE_KINDS2,
+  DEFAULT_URL_SCHEMES2,
+  DEFAULT_MEDIA_SCHEMES2,
+  MEDIA_LIMITS2,
+  RENDER_FAILED2,
+  MCP_MIME_TYPES2,
+  MCP_ACTION_TOOL2,
+  SSE_EVENTS2,
+  errorMessage2,
+  actionMessage2
+} from "./index-we7va6v6.js";
+
+// packages/exponential-ui/src/catalog.generated.ts
+var CATALOG_ID2 = "https://ui.exponential.at/catalogs/core/v1";
+var LITE_CATALOG_ID2 = "https://ui.exponential.at/catalogs/core-lite/v1";
+var BASIC_CATALOG_ID2 = "https://a2ui.org/specification/v0_9/basic_catalog.json";
+var BASIC_VERSION2 = "v0.9";
+var CATALOG_VERSION2 = "1";
+var UNKNOWN_COMPONENT_NAME2 = "Unknown";
+var COMPONENT_NAMES2 = ["Box", "Stack", "Grid", "Card", "Separator", "List", "Resizable", "ScrollArea", "Sidebar", "SplitView", "AppBar", "Page", "Toolbar", "Section", "Group", "Text", "Heading", "Markdown", "CodeBlock", "Kbd", "Label", "Image", "Icon", "Video", "AudioPlayer", "Avatar", "Carousel", "Tabs", "Segmented", "Accordion", "Collapsible", "Trace", "TraceItem", "Pagination", "Breadcrumb", "Stepper", "Dialog", "Drawer", "DockCard", "AlertDialog", "Popover", "Tooltip", "Menu", "Toast", "Badge", "Alert", "Chip", "EmptyState", "Progress", "Meter", "Ring", "Spinner", "Skeleton", "Table", "Chart", "Sparkline", "StatTile", "Button", "Link", "Toggle", "Form", "FieldGroup", "FormActions", "Input", "Textarea", "NumberField", "Checkbox", "Radio", "ChoiceTiles", "Switch", "Slider", "Rating", "Select", "SearchList", "ChipInput", "DatePicker", "DateRangePicker", "TimePicker", "FileUpload", "Composer", "Row", "TreeGuides", "Unknown"];
+var NATIVE_COMPONENTS2 = ["Box", "List", "Resizable", "Text", "Markdown", "CodeBlock", "Image", "Icon", "Video", "AudioPlayer", "Avatar", "Carousel", "Tabs", "Segmented", "Accordion", "Dialog", "Drawer", "Popover", "Tooltip", "Menu", "Toast", "Ring", "Spinner", "Skeleton", "Table", "Chart", "Button", "Link", "Toggle", "Form", "Input", "Textarea", "NumberField", "Checkbox", "Radio", "ChoiceTiles", "Switch", "Slider", "Select", "SearchList", "ChipInput", "DatePicker", "DateRangePicker", "TimePicker", "FileUpload", "Composer", "TreeGuides", "Unknown"];
+var MACRO_COMPONENTS2 = ["Stack", "Grid", "Card", "Separator", "ScrollArea", "Sidebar", "SplitView", "AppBar", "Page", "Toolbar", "Section", "Group", "Heading", "Kbd", "Label", "Collapsible", "Trace", "TraceItem", "Pagination", "Breadcrumb", "Stepper", "DockCard", "AlertDialog", "Badge", "Alert", "Chip", "EmptyState", "Progress", "Meter", "Sparkline", "StatTile", "FieldGroup", "FormActions", "Rating", "Row"];
+var LITE_COMPONENTS2 = ["Box", "Stack", "Grid", "Card", "Separator", "List", "Resizable", "ScrollArea", "Sidebar", "SplitView", "AppBar", "Page", "Toolbar", "Section", "Group", "Text", "Heading", "Markdown", "CodeBlock", "Kbd", "Label", "Icon", "Avatar", "Tabs", "Segmented", "Collapsible", "Trace", "TraceItem", "Breadcrumb", "Stepper", "Badge", "Alert", "Chip", "EmptyState", "Progress", "Meter", "Ring", "Skeleton", "StatTile", "Button", "Link", "Form", "FieldGroup", "FormActions", "Input", "Textarea", "NumberField", "Checkbox", "Switch", "Rating", "Select", "SearchList", "ChipInput", "DatePicker", "DateRangePicker", "TimePicker", "FileUpload", "Composer", "Row"];
+var COMPONENT_GROUPS2 = { Box: "layout", Stack: "layout", Grid: "layout", Card: "layout", Separator: "layout", List: "layout", Resizable: "layout", ScrollArea: "layout", Sidebar: "layout", SplitView: "layout", AppBar: "layout", Page: "layout", Toolbar: "layout", Section: "list", Group: "list", Text: "text", Heading: "text", Markdown: "text", CodeBlock: "text", Kbd: "text", Label: "text", Image: "media", Icon: "media", Video: "media", AudioPlayer: "media", Avatar: "media", Carousel: "media", Tabs: "navigation", Segmented: "navigation", Accordion: "navigation", Collapsible: "navigation", Trace: "list", TraceItem: "list", Pagination: "navigation", Breadcrumb: "navigation", Stepper: "navigation", Dialog: "overlay", Drawer: "overlay", DockCard: "overlay", AlertDialog: "overlay", Popover: "overlay", Tooltip: "overlay", Menu: "overlay", Toast: "overlay", Badge: "feedback", Alert: "feedback", Chip: "feedback", EmptyState: "feedback", Progress: "feedback", Meter: "feedback", Ring: "feedback", Spinner: "feedback", Skeleton: "feedback", Table: "data", Chart: "data", Sparkline: "data", StatTile: "data", Button: "action", Link: "action", Toggle: "action", Form: "input", FieldGroup: "input", FormActions: "input", Input: "input", Textarea: "input", NumberField: "input", Checkbox: "input", Radio: "input", ChoiceTiles: "input", Switch: "input", Slider: "input", Rating: "input", Select: "input", SearchList: "input", ChipInput: "input", DatePicker: "input", DateRangePicker: "input", TimePicker: "input", FileUpload: "input", Composer: "input", Row: "list", TreeGuides: "list", Unknown: "feedback" };
+var SPECIMEN_IDS2 = { Box: "exponential-ui-box", Stack: "exponential-ui-stack", Grid: "exponential-ui-grid", Card: "exponential-ui-card", Separator: "exponential-ui-separator", List: "exponential-ui-list", Resizable: "exponential-ui-resizable", ScrollArea: "exponential-ui-scroll-area", Sidebar: "exponential-ui-sidebar", SplitView: "exponential-ui-split-view", AppBar: "exponential-ui-app-bar", Page: "exponential-ui-page", Toolbar: "exponential-ui-toolbar", Section: "exponential-ui-section", Group: "exponential-ui-group", Text: "exponential-ui-text", Heading: "exponential-ui-heading", Markdown: "exponential-ui-markdown", CodeBlock: "exponential-ui-code-block", Kbd: "exponential-ui-kbd", Label: "exponential-ui-label", Image: "exponential-ui-image", Icon: "exponential-ui-icon", Video: "exponential-ui-video", AudioPlayer: "exponential-ui-audio-player", Avatar: "exponential-ui-avatar", Carousel: "exponential-ui-carousel", Tabs: "exponential-ui-tabs", Segmented: "exponential-ui-segmented", Accordion: "exponential-ui-accordion", Collapsible: "exponential-ui-collapsible", Trace: "exponential-ui-trace", TraceItem: "exponential-ui-trace-item", Pagination: "exponential-ui-pagination", Breadcrumb: "exponential-ui-breadcrumb", Stepper: "exponential-ui-stepper", Dialog: "exponential-ui-dialog", Drawer: "exponential-ui-drawer", DockCard: "exponential-ui-dock-card", AlertDialog: "exponential-ui-alert-dialog", Popover: "exponential-ui-popover", Tooltip: "exponential-ui-tooltip", Menu: "exponential-ui-menu", Toast: "exponential-ui-toast", Badge: "exponential-ui-badge", Alert: "exponential-ui-alert", Chip: "exponential-ui-chip", EmptyState: "exponential-ui-empty-state", Progress: "exponential-ui-progress", Meter: "exponential-ui-meter", Ring: "exponential-ui-ring", Spinner: "exponential-ui-spinner", Skeleton: "exponential-ui-skeleton", Table: "exponential-ui-table", Chart: "exponential-ui-chart", Sparkline: "exponential-ui-sparkline", StatTile: "exponential-ui-stat-tile", Button: "exponential-ui-button", Link: "exponential-ui-link", Toggle: "exponential-ui-toggle", Form: "exponential-ui-form", FieldGroup: "exponential-ui-field-group", FormActions: "exponential-ui-form-actions", Input: "exponential-ui-input", Textarea: "exponential-ui-textarea", NumberField: "exponential-ui-number-field", Checkbox: "exponential-ui-checkbox", Radio: "exponential-ui-radio", ChoiceTiles: "exponential-ui-choice-tiles", Switch: "exponential-ui-switch", Slider: "exponential-ui-slider", Rating: "exponential-ui-rating", Select: "exponential-ui-select", SearchList: "exponential-ui-search-list", ChipInput: "exponential-ui-chip-input", DatePicker: "exponential-ui-date-picker", DateRangePicker: "exponential-ui-date-range-picker", TimePicker: "exponential-ui-time-picker", FileUpload: "exponential-ui-file-upload", Composer: "exponential-ui-composer", Row: "exponential-ui-row", TreeGuides: "exponential-ui-tree-guides", Unknown: "exponential-ui-unknown" };
+var ENUMS2 = {
+  variant: ["default", "secondary", "outline", "ghost", "destructive", "link"],
+  size: ["sm", "default", "lg", "icon"],
+  tone: ["neutral", "primary", "success", "warning", "danger", "info"],
+  gap: ["none", "xs", "sm", "md", "lg", "xl"],
+  align: ["start", "center", "end", "stretch"],
+  justify: ["start", "center", "end", "between", "around", "evenly"],
+  textVariant: ["body", "caption", "muted", "lead", "code", "label", "title"],
+  headingLevel: ["h1", "h2", "h3", "h4"],
+  imageFit: ["contain", "cover", "fill", "none", "scaleDown"],
+  orientation: ["horizontal", "vertical"],
+  side: ["top", "right", "bottom", "left"],
+  inputType: ["text", "email", "password", "number", "search", "url", "tel"],
+  validateOn: ["change", "blur", "submit"],
+  alertType: ["info", "success", "warning", "error"],
+  controlSize: ["sm", "default", "lg"],
+  spinnerSize: ["xs", "sm", "default", "lg"],
+  tabClosable: ["none", "hover", "always"],
+  groupType: ["single", "multiple"],
+  rowChevron: ["none", "right", "selector"],
+  rowSurface: ["flat", "card"],
+  chipShape: ["pill", "rect"],
+  density: ["default", "compact"],
+  listDirection: ["vertical", "horizontal"],
+  chartKind: ["bar", "stackedBar", "line", "area", "pie", "donut", "sparkline"],
+  segmentedVariant: ["segmented", "toggles", "outline", "bar"],
+  liveTone: ["live", "attention", "done", "unread", "idle", "muted"],
+  menuItemKind: ["item", "checkbox", "separator", "label", "submenu"],
+  openOn: ["press", "hover"],
+  menuOpenOn: ["press", "contextmenu"],
+  live: ["off", "polite", "assertive"],
+  selectable: ["none", "single", "multiple"],
+  cellType: ["text", "number", "date", "boolean", "badge", "slot", "currency", "percent", "relativeTime"],
+  sortDirection: ["asc", "desc"],
+  imageLoading: ["lazy", "eager"],
+  scrollDirection: ["vertical", "horizontal", "both"],
+  collapseBelow: ["never", "sm", "md", "lg", "xl"],
+  codeLanguage: ["plain", "json", "js", "ts", "tsx", "rust", "swift", "kotlin", "python", "bash", "html", "css", "sql", "yaml", "markdown", "ansi"],
+  codeToken: ["plain", "keyword", "string", "number", "comment", "punctuation", "operator", "type", "function", "property", "tag", "attribute", "success", "warning", "error"],
+  codeBlockVariant: ["default", "destructive"],
+  codeBlockSize: ["default", "sm"],
+  traceStatus: ["running", "error", "pending"],
+  traceSize: ["default", "sm"]
+};
+var TOKEN_NAMES2 = {
+  color: ["background", "foreground", "card", "cardForeground", "popover", "popoverForeground", "primary", "primaryForeground", "secondary", "secondaryForeground", "muted", "mutedForeground", "accent", "accentForeground", "destructive", "destructiveForeground", "success", "successForeground", "warning", "warningForeground", "info", "infoForeground", "border", "input", "ring", "chart1", "chart2", "chart3", "chart4", "chart5", "chart6", "chart7", "chart8"],
+  spacing: ["none", "xxs", "xs", "sm", "md", "lg", "xl", "xl2", "xl3"],
+  radius: ["none", "sm", "md", "lg", "xl", "xl2", "xl3", "full"],
+  "type.size": ["xs", "sm", "base", "lg", "xl", "xl2", "xl3"],
+  "type.lineHeight": ["xs", "sm", "base", "lg", "xl", "xl2", "xl3"],
+  "type.weight": ["regular", "medium", "semibold", "bold"],
+  "type.family": ["sans", "mono"],
+  control: ["buttonSm", "buttonMd", "buttonLg", "buttonIcon", "input", "textarea", "row", "rowCompact", "pill", "badge", "chip", "toggle", "switch", "checkbox", "slider", "progress", "meter", "avatarSm", "avatarMd", "avatarLg", "iconSm", "iconMd", "iconLg", "hairline", "appBar", "tabBar", "toast"],
+  shadow: ["none", "sm", "md", "lg", "xl"],
+  opacity: ["primary", "secondary", "tertiary", "quaternary", "disabled"],
+  border: ["none", "hairline", "thick"],
+  motion: ["fast", "standard", "slow"],
+  breakpoint: ["sm", "md", "lg", "xl"],
+  ease: ["standard", "decelerate", "accelerate"],
+  density: ["compact", "comfortable"],
+  blur: ["sm", "md", "lg", "xl"],
+  scale: ["press", "popoverFrom"]
+};
+var STYLE_KEY_NAMES2 = ["display", "flexDirection", "flexWrap", "justifyContent", "alignItems", "alignContent", "alignSelf", "justifySelf", "flexGrow", "flexShrink", "flexBasis", "gap", "rowGap", "columnGap", "direction", "overflow", "overflowX", "overflowY", "width", "height", "minWidth", "minHeight", "maxWidth", "maxHeight", "aspectRatio", "position", "top", "right", "bottom", "left", "inset", "insetInlineStart", "insetInlineEnd", "insetBlockStart", "insetBlockEnd", "padding", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft", "paddingHorizontal", "paddingVertical", "paddingInlineStart", "paddingInlineEnd", "margin", "marginTop", "marginRight", "marginBottom", "marginLeft", "marginHorizontal", "marginVertical", "marginInlineStart", "marginInlineEnd", "gridTemplateColumns", "gridTemplateRows", "gridTemplateAreas", "gridArea", "gridColumn", "gridRow", "backgroundColor", "backgroundGradient", "color", "borderWidth", "borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth", "borderColor", "borderStyle", "borderRadius", "borderTopLeftRadius", "borderTopRightRadius", "borderBottomRightRadius", "borderBottomLeftRadius", "opacity", "boxShadow", "fontSize", "fontWeight", "lineHeight", "letterSpacing", "textAlign", "textDecoration", "textTransform", "fontStyle", "fontFamily", "transition", "transitionEasing", "transform", "visibility", "pointerEvents", "userSelect", "cursor", "backdropBlur", "animation", "animationDuration"];
+var STYLE_STATE_NAMES2 = [":hover", ":focus-visible", ":pressed"];
+var ICON_NAMES2 = ["a-large-small", "action-chat", "action-create", "action-default", "action-repository", "action-run", "action-suggestion", "activity", "anchor", "app-editor-chat", "archive", "arrow-down", "arrow-down-left", "arrow-left", "arrow-left-right", "arrow-right", "arrow-up-right", "at-sign", "atom", "auth-passkey", "award", "ban", "bell", "bell-off", "bold", "book-open", "bookmark", "bot", "boxes", "braces", "brain", "briefcase", "brush-cleaning", "bug", "building", "building-2", "calculator", "calendar", "calendar-days", "camera", "car", "chart-line", "check", "chevron-down", "chevron-left", "chevron-right", "chevron-up", "chevrons-up-down", "circle", "circle-arrow-up", "circle-check", "circle-dashed", "circle-dot", "circle-minus", "circle-question-mark", "circle-slash", "circle-stop", "circle-user", "circle-x", "clipboard-list", "clock", "cloud", "code", "coding-assistant", "coding-command", "coding-compact", "coding-diff", "coding-ended", "coding-in-review", "coding-needs-input", "coding-plan", "coding-running", "coding-stop", "coding-subagent", "coding-tool", "coffee", "compass", "computer", "copy", "corner-down-right", "cpu", "credit-card", "crown", "database", "download", "droplet", "dumbbell", "editor-bold", "editor-clear-formatting", "editor-code", "editor-emoji", "editor-heading-1", "editor-heading-2", "editor-heading-3", "editor-image", "editor-issue-ref", "editor-italic", "editor-link", "editor-list", "editor-list-ordered", "editor-list-todo", "editor-mention", "editor-quote", "editor-strikethrough", "editor-text", "editor-text-format", "editor-unlink", "ellipsis", "ellipsis-vertical", "event-assignee-changed", "event-board-moved", "event-estimate-changed", "event-label-added", "event-label-removed", "event-priority-changed", "event-relation-added", "event-relation-removed", "event-status-changed", "event-title-changed", "external-link", "eye", "eye-off", "fast-forward", "file", "file-diff", "file-pen-line", "file-text", "fingerprint", "flag", "flame", "flask-conical", "fold-vertical", "folder", "folder-kanban", "folder-open", "gamepad-2", "gauge", "gem", "gift", "git-branch", "git-merge", "git-pull-request", "github", "globe", "graduation-cap", "guide-changes", "hammer", "hard-drive", "hash", "heading-1", "heading-2", "heading-3", "headphones", "heart", "heart-off", "history", "hourglass", "house", "image", "images", "inbox", "info", "italic", "key", "landmark", "laptop", "layers", "layers-2", "layout-grid", "leaf", "lightbulb", "link", "link-2", "list", "list-checks", "list-end", "list-ordered", "list-todo", "list-tree", "loader-circle", "lock", "lock-open", "log-in", "log-out", "mail", "map", "map-pin", "maximize-2", "media-fast-forward", "media-rewind", "media-skip-next", "media-skip-previous", "media-volume-down", "media-volume-mute", "media-volume-off", "media-volume-up", "megaphone", "menu", "message-circle", "message-square", "message-square-plus", "message-square-reply", "mic", "microscope", "minimize-2", "minus", "monitor", "monitor-off", "moon", "mountain", "move", "music", "nav-account", "nav-actions", "nav-admin", "nav-apps", "nav-boards", "nav-changelog", "nav-computer", "nav-create-issue", "nav-devices", "nav-drafts", "nav-files", "nav-getting-started", "nav-inbox", "nav-issues", "nav-my-issues", "nav-notifications", "nav-rail-collapse", "nav-rail-expand", "nav-report-bug", "nav-search", "nav-settings", "nav-sign-out", "nav-source-control", "nav-team-switcher", "nav-terminal", "nav-threads", "newspaper", "notification-agent-message", "notification-issue-assigned", "notification-issue-comment", "notification-issue-created", "notification-issue-mention", "notification-issue-status-changed", "notification-mark-read", "notification-mute", "notification-pr-merged", "notification-pr-opened", "notification-reporter-reply", "notification-session-blocked", "os-apple", "os-linux", "os-windows", "package", "paintbrush", "palette", "panel-left-close", "panel-left-open", "paperclip", "pause", "pen-tool", "pencil", "phone", "pin", "pin-off", "plane", "play", "plug", "plus", "pr-batch", "pr-closed", "pr-draft", "pr-merged", "pr-open", "pr-stack", "printer", "priority-high", "priority-low", "priority-medium", "priority-none", "priority-urgent", "progress-1-4", "progress-1-5", "progress-2-4", "progress-2-5", "progress-3-4", "progress-3-5", "progress-4-5", "puzzle", "quote", "refresh-cw", "relation-blocked-by", "relation-blocks", "relation-duplicate", "relation-parent", "relation-related", "relation-section", "relation-sub-issue", "remove-formatting", "repeat", "rewind", "rocket", "rotate-ccw", "run-pause", "run-resume", "sc-push", "scale", "search", "search-x", "send", "server", "session-shell", "session-tree", "settings", "settings-about", "settings-account", "settings-agents", "settings-api", "settings-billing", "settings-boards", "settings-general", "settings-import", "settings-issues", "settings-labels", "settings-licenses", "settings-local-repos", "settings-mcp", "settings-members", "settings-notifications", "settings-rate", "settings-repositories", "settings-servers", "settings-sessions", "settings-statuses", "settings-storage", "settings-sync", "settings-tools", "settings-widget", "share-2", "shield", "shield-check", "shield-question-mark", "shopping-bag", "shopping-cart", "signal-high", "signal-low", "signal-medium", "skip-back", "skip-forward", "sliders-horizontal", "smartphone", "smile", "sparkles", "square-kanban", "square-pen", "square-slash", "square-terminal", "star", "star-half", "star-off", "status-backlog", "status-cancelled", "status-done", "status-duplicate", "status-in-progress", "status-in-review", "status-todo", "stethoscope", "store", "strikethrough", "sun", "support-open", "support-resolved", "tag", "target", "terminal", "tool-script", "trace-background", "trace-chevron", "trace-completed", "trace-edit", "trace-failed", "trace-fetch", "trace-read", "trace-reasoning", "trace-search", "trace-subagent", "trace-task-done", "trace-task-pending", "trace-task-running", "trace-terminal", "trace-todo", "trace-tool", "trash-2", "tree-pine", "triangle-alert", "trigger-event", "trigger-schedule", "trophy", "truck", "type", "ui-add", "ui-agent-source", "ui-archive", "ui-arrow-down", "ui-arrow-right", "ui-assignee", "ui-attach", "ui-avatar-placeholder", "ui-back", "ui-branch", "ui-check", "ui-checklist", "ui-chevron-down", "ui-chevron-left", "ui-chevron-right", "ui-chevron-up", "ui-clean", "ui-clear", "ui-clock", "ui-close", "ui-cloud", "ui-copy", "ui-delete", "ui-delete-account", "ui-device", "ui-device-default", "ui-device-offline", "ui-dock-side", "ui-docs", "ui-download", "ui-due-date", "ui-edit", "ui-empty-search", "ui-error", "ui-estimate", "ui-external-link", "ui-favorite-off", "ui-file", "ui-float", "ui-folder", "ui-folder-open", "ui-fullscreen", "ui-fullscreen-exit", "ui-github", "ui-help", "ui-hide", "ui-history", "ui-icon-placeholder", "ui-indeterminate", "ui-info", "ui-invite", "ui-issue", "ui-link", "ui-loading", "ui-mail", "ui-mcp", "ui-member", "ui-menu", "ui-minus", "ui-more", "ui-more-vertical", "ui-offline", "ui-organization", "ui-owner", "ui-permission", "ui-pin", "ui-print", "ui-private", "ui-properties", "ui-queued", "ui-redock", "ui-refresh", "ui-remove-member", "ui-repeat", "ui-repository", "ui-selected", "ui-selector", "ui-send", "ui-server", "ui-share", "ui-sign-in", "ui-sign-out", "ui-staging", "ui-star-half", "ui-star-off", "ui-stop", "ui-submit", "ui-subscribe", "ui-success", "ui-swap", "ui-team", "ui-unassigned", "ui-undo", "ui-undock", "ui-unlock", "ui-unpin", "ui-unselected", "ui-unsubscribe", "ui-update", "ui-usage", "ui-warning", "ui-watch", "ui-widget", "undo-2", "unlink", "upload", "user", "user-minus", "user-plus", "user-x", "users", "video", "volume-1", "volume-2", "volume-off", "volume-x", "wallet", "wifi-off", "work-faces", "work-results", "workflow", "wrench", "x", "zap"];
+var FUNCTION_NAMES2 = ["required", "regex", "length", "numeric", "email", "formatString", "formatNumber", "formatCurrency", "formatDate", "pluralize", "openUrl", "and", "or", "not", "percent", "add", "sub", "eq", "lt", "clamp", "cond", "fallback", "concat", "coalesce", "text", "map", "len", "fill", "set", "formatPercent", "formatRelativeTime", "filter"];
+var BASIC_COMPONENT_MAP2 = { Text: "Text", Image: "Image", Icon: "Icon", Video: "Video", AudioPlayer: "AudioPlayer", Row: "Stack", Column: "Stack", List: "List", Card: "Card", Tabs: "Tabs", Modal: "Dialog", Divider: "Separator", Button: "Button", TextField: "Input", CheckBox: "Checkbox", ChoicePicker: "Radio", Slider: "Slider", DateTimeInput: "DatePicker" };
+var BASIC_ICON_MAP2 = { accountCircle: "ui-assignee", add: "ui-add", arrowBack: "ui-back", arrowForward: "ui-arrow-right", attachFile: "ui-attach", calendarToday: "calendar", call: "phone", camera: "camera", check: "ui-check", close: "ui-close", delete: "ui-delete", download: "ui-download", edit: "ui-edit", event: "ui-due-date", error: "ui-error", fastForward: "media-fast-forward", favorite: "heart", favoriteOff: "ui-favorite-off", folder: "ui-folder", help: "ui-help", home: "house", info: "ui-info", locationOn: "map-pin", lock: "ui-private", lockOpen: "ui-unlock", mail: "ui-mail", menu: "ui-menu", moreVert: "ui-more-vertical", moreHoriz: "ui-more", notificationsOff: "ui-unsubscribe", notifications: "ui-subscribe", pause: "run-pause", payment: "credit-card", person: "ui-avatar-placeholder", phone: "smartphone", photo: "image", play: "action-run", print: "ui-print", refresh: "ui-refresh", rewind: "media-rewind", search: "nav-search", send: "ui-send", settings: "nav-settings", share: "ui-share", shoppingCart: "shopping-cart", skipNext: "media-skip-next", skipPrevious: "media-skip-previous", star: "star", starHalf: "ui-star-half", starOff: "ui-star-off", stop: "ui-stop", upload: "sc-push", visibility: "ui-watch", visibilityOff: "ui-hide", volumeDown: "media-volume-down", volumeMute: "media-volume-mute", volumeOff: "media-volume-off", volumeUp: "media-volume-up", warning: "ui-warning" };
+var BASIC_PLACEHOLDER_ICON2 = "ui-icon-placeholder";
+// packages/exponential-ui/catalog/strings.json
+var strings_default = {
+  $comment: "Round 1 (docs/round-1-contract.md §4): the built-in UI STRINGS every renderer shows — the copy no author writes (a Select's search placeholder, the calendar's month buttons, the copy button, the Pagination arrows' labels). Keys are the ids, values the English defaults. A renderer ships this table (generated into TS/Swift/Kotlin/Rust as STRING_IDS + STRING_DEFAULTS) and lets the HOST override any id per surface (`strings: {search: \"Suchen…\"}`); the catalog refers to an entry as `$string.<id>` in a prop default or a macro template (`$string.previous`), which the renderer resolves at bind time like a token. `{name}` placeholders are filled by the renderer (src/strings.ts formatString; a macro template uses `$fill` → the core `fill` function): a sentence is ONE id with placeholders, never concatenated fragments. Round 2 adds the names the renderers still hard-coded (`invalidValue` = a failed check without a message, `message` = the Composer field, `codeBlock` = an untitled CodeBlock, `dialog` = an untitled Dialog/Drawer, `table` = an uncaptioned Table, `carousel`/`slide` = the carousel's role descriptions, `resize` = a Resizable handle). EXP-1259 adds `closeTab` and `newTab` (the Tabs close glyph and + button). Append-only (round 1 dropped the unused fragment `of`).",
+  strings: {
+    back: "Back",
+    breadcrumb: "Breadcrumb",
+    browse: "Browse",
+    cancel: "Cancel",
+    carousel: "Carousel",
+    chartSummary: "Chart of {series}, values from {min} to {max}",
+    choose: "Choose",
+    clear: "Clear",
+    close: "Close",
+    closeTab: "Close {name}",
+    codeBlock: "Code",
+    collapse: "Collapse",
+    confirm: "Confirm",
+    copied: "Copied",
+    copy: "Copy",
+    decrement: "Decrease",
+    dialog: "Dialog",
+    dismiss: "Dismiss",
+    dropFiles: "Drop files here",
+    expand: "Expand",
+    fileTooLarge: "File too large",
+    fileTooLargeNamed: "{name}: File too large",
+    increment: "Increase",
+    invalidFields: "Check the highlighted fields",
+    invalidValue: "Invalid value",
+    loading: "Loading",
+    menu: "Menu",
+    message: "Message",
+    more: "More",
+    newTab: "New tab",
+    next: "Next",
+    nextMonth: "Next month",
+    noResults: "No results",
+    optional: "Optional",
+    pageOf: "Page {page} of {total}",
+    pagination: "Pagination",
+    previous: "Previous",
+    previousMonth: "Previous month",
+    ratingStar: "{value} of {max}",
+    ratingValue: "Rated {value} of {max}",
+    remove: "Remove",
+    removeItem: "Remove {name}",
+    required: "Required",
+    resize: "Resize",
+    search: "Search…",
+    selectAll: "Select all",
+    selectedCount: "{count} selected",
+    selectRow: "Select row",
+    send: "Send",
+    showLess: "Show less",
+    showMore: "Show more",
+    slide: "Slide",
+    sortAscending: "Sort ascending",
+    sortByAscending: "{name}: Sort ascending",
+    sortByDescending: "{name}: Sort descending",
+    sortDescending: "Sort descending",
+    sparklineSummary: "Trend from {first} to {last}, low {min}, high {max}",
+    stepCurrent: "Step {step} of {total}: {label}, current",
+    stepDone: "Step {step} of {total}: {label}, completed",
+    stepUpcoming: "Step {step} of {total}: {label}",
+    stop: "Stop",
+    submit: "Submit",
+    table: "Table",
+    today: "Today",
+    unknownComponent: "Unknown component",
+    unsupportedFile: "Unsupported file",
+    unsupportedFileNamed: "{name}: Unsupported file"
+  }
+};
+
+// packages/exponential-ui/src/strings.ts
+var DEFAULT_STRINGS2 = strings_default.strings;
+var STRING_IDS2 = Object.keys(DEFAULT_STRINGS2);
+var REF = /^\$string\.([a-zA-Z][a-zA-Z0-9]*)$/;
+var PLACEHOLDER = /\{([a-zA-Z][a-zA-Z0-9]*)\}/g;
+function parseStringRef2(value) {
+  if (typeof value !== `string`)
+    return null;
+  const m = REF.exec(value);
+  return m ? m[1] : null;
+}
+function isStringRef2(value) {
+  const id = parseStringRef2(value);
+  return id !== null && id in DEFAULT_STRINGS2;
+}
+function stringTable2(overrides = {}) {
+  return { ...DEFAULT_STRINGS2, ...overrides };
+}
+function formatString2(template, params = {}) {
+  return template.replace(PLACEHOLDER, (whole, name) => (name in params) && params[name] !== undefined && params[name] !== null ? String(params[name]) : whole);
+}
+function resolveString2(value, table = DEFAULT_STRINGS2) {
+  const id = parseStringRef2(value);
+  if (id === null)
+    return value;
+  return table[id] ?? id;
+}
+// packages/exponential-ui/catalog/locale.json
+var locale_default = {
+  $comment: "Round 1 (docs/round-1-contract.md §4): the LOCALE contract. A surface carries one BCP 47 `locale` (SurfaceSettings.locale, default `en-US`); it drives the basic catalog's formatNumber/formatCurrency/formatDate/pluralize, NumberField's display, the calendar's month and weekday names and the default week start, and the text direction. Platforms format with their own ICU (Intl, Foundation, java.text, icu4x); what must not differ is decided HERE so every renderer agrees: `weekStart` = CLDR supplemental weekData `firstDay` by REGION (0 = Sunday … 6 = Saturday; a region not listed = `default`); a locale without a region takes `likelyRegion[language]` (CLDR likelySubtags: every rtl language and the most spoken ~90; else `default`); `languageAliases` = deprecated codes normalised FIRST (Java/Android still emit `iw`, `ji`, `in`); `rtl` = the languages whose text direction is right-to-left (the surface root gets `direction: rtl` unless the author set one); `rtlMirroredIcons` = the DIRECTIONAL glyphs (icons.json names, semantic and Lucide) a painter MIRRORS under rtl: scaleX(-1) as the OUTERMOST transform of the glyph, after the node's own `transform` (CSS `transform: scaleX(-1) <own>`), so a back arrow, a prev/next or breadcrumb chevron and a submenu indicator point the reading direction; media transport glyphs and everything else are never mirrored. Round 2: formatting goes through a host-supplied Formatter (SurfaceSettings.locale + timeZone; TS = Intl, Rust = a Formatter trait with the `englishFallback` below, FFI = a foreign Formatter). src/locale.ts + src/format.ts are the reference; generated into every target as constants. Append-only.",
+  default: "en-US",
+  weekStart: {
+    default: 1,
+    regions: {
+      "0": ["AG", "AS", "BD", "BR", "BS", "BT", "BW", "BZ", "CA", "CN", "CO", "DM", "DO", "ET", "GT", "GU", "HK", "HN", "ID", "IL", "IN", "JM", "JP", "KE", "KH", "KR", "LA", "MH", "MM", "MO", "MT", "MX", "MZ", "NI", "NP", "PA", "PE", "PH", "PK", "PR", "PT", "PY", "SA", "SG", "SV", "TH", "TT", "TW", "UM", "US", "VE", "VI", "WS", "YE", "ZA", "ZW"],
+      "5": ["MV"],
+      "6": ["AE", "AF", "BH", "DJ", "DZ", "EG", "IQ", "IR", "JO", "KW", "LY", "OM", "QA", "SD", "SY"]
+    }
+  },
+  likelyRegion: {
+    af: "ZA",
+    am: "ET",
+    ar: "EG",
+    az: "AZ",
+    be: "BY",
+    bg: "BG",
+    bn: "BD",
+    bs: "BA",
+    ca: "ES",
+    ckb: "IQ",
+    cs: "CZ",
+    cy: "GB",
+    da: "DK",
+    de: "DE",
+    dv: "MV",
+    el: "GR",
+    en: "US",
+    es: "ES",
+    et: "EE",
+    eu: "ES",
+    fa: "IR",
+    fi: "FI",
+    fil: "PH",
+    fr: "FR",
+    ga: "IE",
+    gl: "ES",
+    gu: "IN",
+    ha: "NG",
+    he: "IL",
+    hi: "IN",
+    hr: "HR",
+    hu: "HU",
+    hy: "AM",
+    id: "ID",
+    ig: "NG",
+    is: "IS",
+    it: "IT",
+    ja: "JP",
+    jv: "ID",
+    ka: "GE",
+    kk: "KZ",
+    km: "KH",
+    kn: "IN",
+    ko: "KR",
+    ku: "TR",
+    ky: "KG",
+    lo: "LA",
+    lt: "LT",
+    lv: "LV",
+    mk: "MK",
+    ml: "IN",
+    mn: "MN",
+    mr: "IN",
+    ms: "MY",
+    mt: "MT",
+    my: "MM",
+    nb: "NO",
+    ne: "NP",
+    nl: "NL",
+    nn: "NO",
+    no: "NO",
+    or: "IN",
+    pa: "IN",
+    pl: "PL",
+    ps: "AF",
+    pt: "BR",
+    ro: "RO",
+    ru: "RU",
+    sd: "PK",
+    si: "LK",
+    sk: "SK",
+    sl: "SI",
+    so: "SO",
+    sq: "AL",
+    sr: "RS",
+    sv: "SE",
+    sw: "TZ",
+    ta: "IN",
+    te: "IN",
+    th: "TH",
+    tl: "PH",
+    tr: "TR",
+    ug: "CN",
+    uk: "UA",
+    ur: "PK",
+    uz: "UZ",
+    vi: "VN",
+    yi: "001",
+    yo: "NG",
+    zh: "CN",
+    zu: "ZA"
+  },
+  languageAliases: { in: "id", iw: "he", ji: "yi", jw: "jv", mo: "ro", tl: "fil" },
+  rtl: ["ar", "ckb", "dv", "fa", "he", "ps", "sd", "ug", "ur", "yi"],
+  rtlMirroredIcons: ["ui-back", "ui-chevron-left", "ui-chevron-right", "ui-arrow-right", "ui-send", "ui-undo", "ui-external-link", "arrow-left", "arrow-right", "chevron-left", "chevron-right", "send", "undo-2", "external-link"],
+  englishFallback: {
+    $comment: "Round 2 (docs/round-2-contract.md §3): the data of the ENGLISH fallback Formatter (src/format.ts englishFormatter; the Rust core's fallback reads the same): what a renderer without a platform ICU prints, equal to Intl en-US (ICU 74+) for every case of fixtures/format.json. `currencyPrefix` = the en-US prefix per ISO 4217 code (a code not listed prints `unknownCurrency`: `<CODE>` + U+00A0); `currencyDigits` = the minor digits where they are not 2; `relative` = the numeric:auto phrases of a unit at -1/0/+1 and the unit names (singular, plural); `datePatterns` = the TR35 pattern per `style`, `timePattern` = what `time: true` adds, joined by `dateTimeJoin[style]`. Instants show in the surface zone: the fallback takes the zone as a UTC offset per instant from the host (fixtures: `offsetMinutes`).",
+    months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
+    monthsShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
+    weekdays: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+    weekdaysShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+    dayPeriods: ["AM", "PM"],
+    currencyPrefix: {
+      USD: "$",
+      EUR: "€",
+      GBP: "£",
+      JPY: "¥",
+      CNY: "CN¥",
+      INR: "₹",
+      KRW: "₩",
+      CAD: "CA$",
+      AUD: "A$",
+      MXN: "MX$",
+      BRL: "R$",
+      ILS: "₪",
+      NZD: "NZ$",
+      HKD: "HK$",
+      TWD: "NT$",
+      VND: "₫",
+      PHP: "₱",
+      XAF: "FCFA ",
+      XOF: "F CFA "
+    },
+    currencyDigits: { JPY: 0, KRW: 0, VND: 0, CLP: 0, ISK: 0, UGX: 0, PYG: 0, XAF: 0, XOF: 0, BHD: 3, IQD: 3, JOD: 3, KWD: 3, OMR: 3, TND: 3 },
+    relative: {
+      units: { second: ["second", "seconds"], minute: ["minute", "minutes"], hour: ["hour", "hours"], day: ["day", "days"], week: ["week", "weeks"], month: ["month", "months"], year: ["year", "years"] },
+      auto: { second: { "0": "now" }, day: { "-1": "yesterday", "1": "tomorrow" }, week: { "-1": "last week", "1": "next week" }, month: { "-1": "last month", "1": "next month" }, year: { "-1": "last year", "1": "next year" } },
+      past: "{value} {unit} ago",
+      future: "in {value} {unit}"
+    },
+    unknownCurrency: "{code} ",
+    datePatterns: { short: "M/d/yy", medium: "MMM d, y", long: "MMMM d, y", full: "EEEE, MMMM d, y" },
+    timePattern: "h:mm a",
+    dateTimeJoin: { short: "{date}, {time}", medium: "{date}, {time}", long: "{date} at {time}", full: "{date} at {time}" }
+  }
+};
+
+// packages/exponential-ui/src/format.ts
+var FALLBACK = locale_default.englishFallback;
+var MS = { second: 1000, minute: 60000, hour: 3600000, day: 86400000 };
+function displayString2(value) {
+  if (typeof value === `string`)
+    return value;
+  if (typeof value === `number`)
+    return Number.isFinite(value) ? String(value) : ``;
+  if (typeof value === `boolean`)
+    return String(value);
+  return ``;
+}
+function decimalOf(abs) {
+  const m = /^(\d+)(?:\.(\d+))?(?:e([+-]\d+))?$/.exec(String(abs));
+  if (!m)
+    return { int: `0`, frac: `` };
+  const digits = m[1] + (m[2] ?? ``);
+  let point = m[1].length + (m[3] ? Number(m[3]) : 0);
+  let all = digits;
+  if (point <= 0) {
+    all = `0`.repeat(1 - point) + all;
+    point = 1;
+  }
+  if (point > all.length)
+    all = all + `0`.repeat(point - all.length);
+  const int = all.slice(0, point).replace(/^0+(?=\d)/, ``);
+  return { int, frac: all.slice(point).replace(/0+$/, ``) };
+}
+function shift(d, places) {
+  const frac = d.frac + `0`.repeat(Math.max(0, places - d.frac.length));
+  const int = (d.int + frac.slice(0, places)).replace(/^0+(?=\d)/, ``);
+  return { int, frac: frac.slice(places).replace(/0+$/, ``) };
+}
+function round(d, min, max) {
+  let { int, frac } = d;
+  if (frac.length > max) {
+    const up = frac.charCodeAt(max) >= 53;
+    let kept = int + frac.slice(0, max);
+    if (up) {
+      const chars = kept.split(``);
+      let i = chars.length - 1;
+      for (;i >= 0; i--) {
+        if (chars[i] === `9`)
+          chars[i] = `0`;
+        else {
+          chars[i] = String(Number(chars[i]) + 1);
+          break;
+        }
+      }
+      kept = (i < 0 ? `1` : ``) + chars.join(``);
+    }
+    const intLen = kept.length - max;
+    int = kept.slice(0, intLen) || `0`;
+    frac = kept.slice(intLen).replace(/0+$/, ``);
+  }
+  if (frac.length < min)
+    frac = frac + `0`.repeat(min - frac.length);
+  return { int, frac };
+}
+function group(int, on) {
+  if (!on || int.length < 4)
+    return int;
+  let out = ``;
+  for (let i = 0;i < int.length; i++) {
+    if (i > 0 && (int.length - i) % 3 === 0)
+      out += `,`;
+    out += int[i];
+  }
+  return out;
+}
+function englishNumber(value, min, max, grouping) {
+  const neg = value < 0 || Object.is(value, -0);
+  if (Number.isNaN(value))
+    return { sign: ``, body: `NaN` };
+  if (!Number.isFinite(value))
+    return { sign: neg ? `-` : ``, body: `∞` };
+  const d = round(decimalOf(Math.abs(value)), min, max);
+  return { sign: neg ? `-` : ``, body: `${group(d.int, grouping)}${d.frac ? `.${d.frac}` : ``}` };
+}
+var fixedDigits = (decimals) => typeof decimals === `number` && Number.isFinite(decimals) ? Math.max(0, Math.min(20, Math.trunc(decimals))) : undefined;
+function currencyDigits2(code) {
+  return FALLBACK.currencyDigits[code.toUpperCase()] ?? 2;
+}
+function parseDateValue2(value) {
+  if (typeof value === `number`)
+    return Number.isFinite(value) ? { ms: value, dateOnly: false } : null;
+  if (typeof value !== `string` || value.trim() === ``)
+    return null;
+  const day = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (day) {
+    const ms = Date.UTC(Number(day[1]), Number(day[2]) - 1, Number(day[3]));
+    return Number.isFinite(ms) ? { ms, dateOnly: true } : null;
+  }
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2})?$/.test(value))
+    return null;
+  const zoned = /(Z|[+-]\d{2}:\d{2})$/.test(value) ? value : `${value}Z`;
+  const ms = Date.parse(zoned);
+  return Number.isFinite(ms) ? { ms, dateOnly: false } : null;
+}
+function utcFields(ms) {
+  const d = new Date(ms);
+  return { year: d.getUTCFullYear(), month: d.getUTCMonth() + 1, day: d.getUTCDate(), weekday: d.getUTCDay(), hour: d.getUTCHours(), minute: d.getUTCMinutes(), second: d.getUTCSeconds() };
+}
+var pad = (n, width) => String(n).padStart(width, `0`);
+function formatPattern2(pattern, f, names) {
+  let out = ``;
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === `'`) {
+      if (pattern[i + 1] === `'`) {
+        out += `'`;
+        i += 2;
+        continue;
+      }
+      i++;
+      while (i < pattern.length) {
+        if (pattern[i] === `'`) {
+          if (pattern[i + 1] === `'`) {
+            out += `'`;
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        out += pattern[i];
+        i++;
+      }
+      continue;
+    }
+    if (!/[A-Za-z]/.test(ch)) {
+      out += ch;
+      i++;
+      continue;
+    }
+    let n = 1;
+    while (pattern[i + n] === ch)
+      n++;
+    const run = pattern.slice(i, i + n);
+    i += n;
+    const h12 = f.hour % 12 === 0 ? 12 : f.hour % 12;
+    switch (ch) {
+      case `y`:
+        out += n === 2 ? pad(f.year % 100, 2) : pad(f.year, n);
+        break;
+      case `M`:
+        out += n >= 4 ? names.months[f.month - 1] : n === 3 ? names.monthsShort[f.month - 1] : pad(f.month, n);
+        break;
+      case `d`:
+        out += pad(f.day, n);
+        break;
+      case `E`:
+        out += n >= 4 ? names.weekdays[f.weekday] : names.weekdaysShort[f.weekday];
+        break;
+      case `h`:
+        out += pad(h12, n);
+        break;
+      case `H`:
+        out += pad(f.hour, n);
+        break;
+      case `m`:
+        out += pad(f.minute, n);
+        break;
+      case `s`:
+        out += pad(f.second, n);
+        break;
+      case `a`:
+        out += names.dayPeriods[f.hour < 12 ? 0 : 1];
+        break;
+      default:
+        out += run;
+    }
+  }
+  return out;
+}
+var ENGLISH_DATE_PATTERNS2 = FALLBACK.datePatterns;
+var ENGLISH_TIME_PATTERN2 = FALLBACK.timePattern;
+var ENGLISH_DATE_TIME_JOIN2 = FALLBACK.dateTimeJoin;
+var fixedOffset2 = (minutes) => () => minutes;
+function intlZoneOffset2(timeZone) {
+  const dtf = new Intl.DateTimeFormat(`en-US`, { timeZone, year: `numeric`, month: `numeric`, day: `numeric`, hour: `numeric`, minute: `numeric`, second: `numeric`, hourCycle: `h23` });
+  return (ms) => {
+    const at = Math.floor(ms / 1000) * 1000;
+    const p = Object.fromEntries(dtf.formatToParts(new Date(at)).map((x) => [x.type, x.value]));
+    const local = Date.UTC(Number(p.year), Number(p.month) - 1, Number(p.day), Number(p.hour) % 24, Number(p.minute), Number(p.second));
+    return Math.round((local - at) / 60000);
+  };
+}
+function relativeTimeUnit2(deltaMs) {
+  const abs = Math.abs(deltaMs);
+  const t = (unit) => Math.trunc(deltaMs / unit) || 0;
+  if (abs < MS.minute)
+    return { value: t(MS.second), unit: `second` };
+  if (abs < MS.hour)
+    return { value: t(MS.minute), unit: `minute` };
+  if (abs < MS.day)
+    return { value: t(MS.hour), unit: `hour` };
+  if (abs < 7 * MS.day)
+    return { value: t(MS.day), unit: `day` };
+  if (abs < 30 * MS.day)
+    return { value: t(7 * MS.day), unit: `week` };
+  if (abs < 365 * MS.day)
+    return { value: t(30 * MS.day), unit: `month` };
+  return { value: t(365 * MS.day), unit: `year` };
+}
+var ENGLISH_NAMES = FALLBACK;
+function englishFormatter2(zone = fixedOffset2(0)) {
+  return {
+    locale: `en-US`,
+    number(value, options = {}) {
+      const fixed = fixedDigits(options.decimals);
+      const { sign, body } = englishNumber(value, fixed ?? 0, fixed ?? 3, options.grouping !== false);
+      return `${sign}${body}`;
+    },
+    currency(value, currency, options = {}) {
+      const code = currency.toUpperCase();
+      const digits = fixedDigits(options.decimals) ?? currencyDigits2(code);
+      const { sign, body } = englishNumber(value, digits, digits, options.grouping !== false);
+      const prefix = FALLBACK.currencyPrefix[code] ?? FALLBACK.unknownCurrency.replace(`{code}`, code);
+      return `${sign}${prefix}${body}`;
+    },
+    percent(value, options = {}) {
+      const digits = fixedDigits(options.decimals) ?? 0;
+      if (!Number.isFinite(value)) {
+        const { sign, body } = englishNumber(value, 0, 0, true);
+        return `${sign}${body}%`;
+      }
+      const neg = value < 0 || Object.is(value, -0);
+      const d = round(shift(decimalOf(Math.abs(value)), 2), digits, digits);
+      return `${neg ? `-` : ``}${group(d.int, true)}${d.frac ? `.${d.frac}` : ``}%`;
+    },
+    date(value, options = {}) {
+      const parsed = parseDateValue2(value);
+      if (!parsed)
+        return ``;
+      const f = utcFields(parsed.dateOnly ? parsed.ms : parsed.ms + zone(parsed.ms) * 60000);
+      if (options.format)
+        return formatPattern2(options.format, f, ENGLISH_NAMES);
+      const style = options.style ?? `medium`;
+      const date = formatPattern2(ENGLISH_DATE_PATTERNS2[style], f, ENGLISH_NAMES);
+      if (!options.time)
+        return date;
+      const time = formatPattern2(ENGLISH_TIME_PATTERN2, f, ENGLISH_NAMES);
+      return ENGLISH_DATE_TIME_JOIN2[style].replace(`{date}`, date).replace(`{time}`, time);
+    },
+    relativeTime(value, now) {
+      const parsed = parseDateValue2(value);
+      if (!parsed)
+        return ``;
+      const { value: n, unit } = relativeTimeUnit2(parsed.ms - now);
+      const auto = FALLBACK.relative.auto[unit]?.[String(n)];
+      if (auto)
+        return auto;
+      const [one, many] = FALLBACK.relative.units[unit];
+      const count = englishNumber(Math.abs(n), 0, 0, true).body;
+      const unitName = Math.abs(n) === 1 ? one : many;
+      const template = n < 0 ? FALLBACK.relative.past : FALLBACK.relative.future;
+      return template.replace(`{value}`, count).replace(`{unit}`, unitName);
+    },
+    plural(value) {
+      return Math.abs(value) === 1 ? `one` : `other`;
+    }
+  };
+}
+function intlFormatter2(locale, timeZone = `UTC`) {
+  const nf = (o) => new Intl.NumberFormat(locale, o);
+  let names = null;
+  const dateNames = () => {
+    if (names)
+      return names;
+    const at = (o, ms) => new Intl.DateTimeFormat(locale, { ...o, timeZone: `UTC` }).format(new Date(ms));
+    const months = Array.from({ length: 12 }, (_, i) => Date.UTC(2026, i, 1));
+    const days = Array.from({ length: 7 }, (_, i) => Date.UTC(2026, 0, 4 + i));
+    const period = (h) => new Intl.DateTimeFormat(locale, { hour: `numeric`, hour12: true, timeZone: `UTC` }).formatToParts(new Date(Date.UTC(2026, 0, 1, h))).find((p) => p.type === `dayPeriod`)?.value ?? (h < 12 ? `AM` : `PM`);
+    names = {
+      months: months.map((ms) => at({ month: `long` }, ms)),
+      monthsShort: months.map((ms) => at({ month: `short` }, ms)),
+      weekdays: days.map((ms) => at({ weekday: `long` }, ms)),
+      weekdaysShort: days.map((ms) => at({ weekday: `short` }, ms)),
+      dayPeriods: [period(9), period(15)]
+    };
+    return names;
+  };
+  const zonedFields = (ms) => {
+    const parts = new Intl.DateTimeFormat(`en-US`, { timeZone, year: `numeric`, month: `numeric`, day: `numeric`, hour: `numeric`, minute: `numeric`, second: `numeric`, weekday: `short`, hourCycle: `h23` }).formatToParts(new Date(ms));
+    const get = (t) => parts.find((p) => p.type === t)?.value ?? `0`;
+    return { year: Number(get(`year`)), month: Number(get(`month`)), day: Number(get(`day`)), weekday: [`Sun`, `Mon`, `Tue`, `Wed`, `Thu`, `Fri`, `Sat`].indexOf(get(`weekday`)), hour: Number(get(`hour`)) % 24, minute: Number(get(`minute`)), second: Number(get(`second`)) };
+  };
+  return {
+    locale,
+    number(value, options = {}) {
+      const fixed = fixedDigits(options.decimals);
+      return nf({ minimumFractionDigits: fixed ?? 0, maximumFractionDigits: fixed ?? 3, useGrouping: options.grouping !== false }).format(value);
+    },
+    currency(value, currency, options = {}) {
+      const fixed = fixedDigits(options.decimals);
+      return nf({ style: `currency`, currency, ...fixed !== undefined ? { minimumFractionDigits: fixed, maximumFractionDigits: fixed } : {}, useGrouping: options.grouping !== false }).format(value);
+    },
+    percent(value, options = {}) {
+      const fixed = fixedDigits(options.decimals) ?? 0;
+      return nf({ style: `percent`, minimumFractionDigits: fixed, maximumFractionDigits: fixed }).format(value);
+    },
+    date(value, options = {}) {
+      const parsed = parseDateValue2(value);
+      if (!parsed)
+        return ``;
+      const zone = parsed.dateOnly ? `UTC` : timeZone;
+      if (options.format)
+        return formatPattern2(options.format, parsed.dateOnly ? utcFields(parsed.ms) : zonedFields(parsed.ms), dateNames());
+      return new Intl.DateTimeFormat(locale, { dateStyle: options.style ?? `medium`, ...options.time ? { timeStyle: `short` } : {}, timeZone: zone }).format(new Date(parsed.ms));
+    },
+    relativeTime(value, now) {
+      const parsed = parseDateValue2(value);
+      if (!parsed)
+        return ``;
+      const { value: n, unit } = relativeTimeUnit2(parsed.ms - now);
+      return new Intl.RelativeTimeFormat(locale, { numeric: `auto` }).format(n, unit);
+    },
+    plural(value) {
+      return new Intl.PluralRules(locale).select(value);
+    }
+  };
+}
+var FORMAT_FUNCTION_NAMES2 = [`formatNumber`, `formatCurrency`, `formatPercent`, `formatDate`, `formatRelativeTime`, `pluralize`];
+var NUMERIC = /^[ \t\n\r]*[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?[ \t\n\r]*$/;
+var toNum = (v) => typeof v === `number` ? v : typeof v === `string` && NUMERIC.test(v) ? Number(v) : NaN;
+var optNum = (v) => v === undefined || v === null ? undefined : toNum(v);
+function formatFunctions2(formatter, now = () => Date.now()) {
+  const numberOr = (value, f) => {
+    const n = toNum(value);
+    return Number.isFinite(n) ? f(n) : ``;
+  };
+  return {
+    formatNumber: ({ value, decimals, grouping }) => numberOr(value, (n) => formatter.number(n, { decimals: optNum(decimals), grouping: grouping === undefined ? undefined : grouping !== false })),
+    formatCurrency: ({ value, currency, decimals, grouping }) => numberOr(value, (n) => typeof currency === `string` && /^[A-Za-z]{3}$/.test(currency) ? formatter.currency(n, currency, { decimals: optNum(decimals), grouping: grouping === undefined ? undefined : grouping !== false }) : ``),
+    formatPercent: ({ value, decimals }) => numberOr(value, (n) => formatter.percent(n, { decimals: optNum(decimals) })),
+    formatDate: ({ value, format, style, time }) => formatter.date(value, { ...typeof format === `string` && format ? { format } : {}, ...style === `short` || style === `medium` || style === `long` || style === `full` ? { style } : {}, ...time === true ? { time: true } : {} }),
+    formatRelativeTime: ({ value, now: at }) => formatter.relativeTime(value, typeof at === `number` ? at : parseDateValue2(at)?.ms ?? now()),
+    pluralize: (args) => {
+      const n = toNum(args.value);
+      if (!Number.isFinite(n))
+        return args.other;
+      if (n === 0 && args.zero !== undefined)
+        return args.zero;
+      const category = formatter.plural(n);
+      return args[category] ?? args.other;
+    }
+  };
+}
+var ENGLISH_FORMAT_FUNCTIONS2 = formatFunctions2(englishFormatter2());
+
+// packages/exponential-ui/src/expr.ts
+var WHOLE = /^\{([^{}]+)\}$/;
+var EMBEDDED = /\{([^{}]+)\}/g;
+var FUNCTION = /^(len|range)\((.+)\)$/;
+function isBinding2(value) {
+  return typeof value === `object` && value !== null && !Array.isArray(value) && typeof value.path === `string` && Object.keys(value).length === 1;
+}
+function isCall2(value) {
+  return typeof value === `object` && value !== null && !Array.isArray(value) && typeof value.call === `string`;
+}
+function isDynamic2(value) {
+  return isBinding2(value) || isCall2(value);
+}
+function truthy2(value) {
+  return value !== undefined && value !== null && value !== false && value !== ``;
+}
+function call(name, args) {
+  const out = {};
+  for (const [k, v] of Object.entries(args))
+    if (v !== undefined)
+      out[k] = v;
+  return { call: name, args: out };
+}
+function parseLiteral(text) {
+  if (text === `true`)
+    return true;
+  if (text === `false`)
+    return false;
+  if (text === `null`)
+    return null;
+  if (/^-?\d+(\.\d+)?$/.test(text))
+    return Number(text);
+  return text;
+}
+function lookup(path, ctx) {
+  if (path === `id`)
+    return ctx.id;
+  const [head, ...rest] = path.split(`.`);
+  let cur;
+  if (head === `props`)
+    cur = ctx.props;
+  else if (head in ctx.vars)
+    cur = ctx.vars[head];
+  else
+    return;
+  for (const key of rest) {
+    if (cur === undefined || cur === null)
+      return;
+    cur = cur[key];
+  }
+  return cur;
+}
+function toNumber(value) {
+  return typeof value === `number` ? value : Number(value ?? 0) || 0;
+}
+function numericString(value) {
+  const text = value.trim();
+  if (text === ``)
+    return;
+  const n = Number(text);
+  return Number.isFinite(n) ? n : undefined;
+}
+function valuesEqual2(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a === `number` && typeof b === `string`)
+    return numericString(b) === a;
+  if (typeof b === `number` && typeof a === `string`)
+    return numericString(a) === b;
+  return false;
+}
+function clampNumber2(value, min, max) {
+  let n = toNumber(value);
+  if (max !== undefined && max !== null)
+    n = Math.min(n, toNumber(max));
+  if (min !== undefined && min !== null)
+    n = Math.max(n, toNumber(min));
+  return n;
+}
+function fillTemplate2(template, params) {
+  const text = template === undefined || template === null ? `` : String(template);
+  return formatString2(text, typeof params === `object` && params !== null ? params : {});
+}
+var MAX_RANGE_ITEMS = 1e4;
+function evalExpr2(expr, ctx) {
+  const text = expr.trim();
+  const fn = FUNCTION.exec(text);
+  if (fn) {
+    const inner = evalExpr2(fn[2], ctx);
+    if (fn[1] === `len`) {
+      if (isDynamic2(inner))
+        return call(`len`, { value: inner });
+      return Array.isArray(inner) ? inner.length : typeof inner === `string` ? inner.length : 0;
+    }
+    if (isDynamic2(inner))
+      return;
+    const n = Math.min(MAX_RANGE_ITEMS, Math.max(0, Math.floor(toNumber(inner))) || 0);
+    return Array.from({ length: n }, (_, i) => i);
+  }
+  const bar = text.indexOf(`|`);
+  if (bar >= 0) {
+    const value = evalExpr2(text.slice(0, bar), ctx);
+    const fallback = parseLiteral(text.slice(bar + 1));
+    if (value === undefined || value === null)
+      return fallback;
+    if (isDynamic2(value))
+      return call(`fallback`, { value, default: fallback });
+    return value;
+  }
+  if (text.startsWith(`!`)) {
+    const value = evalExpr2(text.slice(1), ctx);
+    if (isDynamic2(value))
+      return call(`not`, { value });
+    return !truthy2(value);
+  }
+  return lookup(text, ctx);
+}
+function passThrough(value) {
+  if (isCall2(value) && value.call === `fallback` && isDynamic2(value.args?.value))
+    return value.args?.value;
+  return value;
+}
+function evalOperand(value, ctx) {
+  if (typeof value === `string`) {
+    const whole = WHOLE.exec(value);
+    if (whole)
+      return evalExpr2(whole[1], ctx);
+  }
+  return evalValue2(value, ctx);
+}
+function evalConditionValue2(cond, ctx) {
+  const value = typeof cond === `string` ? evalExpr2(cond, ctx) : evalOperand(cond, ctx);
+  if (isDynamic2(value))
+    return value;
+  return truthy2(value);
+}
+function evalCondition2(cond, ctx) {
+  const value = evalConditionValue2(cond, ctx);
+  return value === true || isDynamic2(value);
+}
+function interpolate(value, ctx) {
+  const parts = [];
+  let dynamic = false;
+  let last = 0;
+  for (const match of value.matchAll(EMBEDDED)) {
+    const at = match.index ?? 0;
+    if (at > last)
+      parts.push(value.slice(last, at));
+    const v = evalExpr2(match[1], ctx);
+    if (isDynamic2(v))
+      dynamic = true;
+    parts.push(v);
+    last = at + match[0].length;
+  }
+  if (last < value.length)
+    parts.push(value.slice(last));
+  if (dynamic)
+    return call(`concat`, { values: parts.filter((p) => p !== undefined && p !== null && p !== ``) });
+  return parts.map((p) => p === undefined || p === null ? `` : String(p)).join(``);
+}
+function evalValue2(value, ctx) {
+  if (typeof value === `string`) {
+    const whole = WHOLE.exec(value);
+    if (whole)
+      return passThrough(evalExpr2(whole[1], ctx));
+    return interpolate(value, ctx);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => evalValue2(item, ctx)).filter((item) => item !== undefined);
+  }
+  if (typeof value !== `object` || value === null)
+    return value;
+  const obj = value;
+  if (`$map` in obj) {
+    const spec = obj.$map;
+    const from = evalExpr2(spec.from, ctx);
+    if (isDynamic2(from)) {
+      const cases = {};
+      for (const [k, v] of Object.entries(spec.cases)) {
+        const evaluated = evalOperand(v, ctx);
+        if (evaluated !== undefined)
+          cases[k] = evaluated;
+      }
+      return call(`map`, { value: from, cases, default: evalOperand(spec.default, ctx) });
+    }
+    const key = from === undefined || from === null ? `` : String(from);
+    const hit = Object.prototype.hasOwnProperty.call(spec.cases, key) ? spec.cases[key] : spec.default;
+    return evalOperand(hit, ctx);
+  }
+  if (`$cond` in obj) {
+    const [cond, then, otherwise] = obj.$cond;
+    const decided = evalConditionValue2(cond, ctx);
+    if (isDynamic2(decided))
+      return call(`cond`, { if: decided, then: evalOperand(then, ctx), else: evalOperand(otherwise, ctx) });
+    return evalOperand(decided ? then : otherwise, ctx);
+  }
+  if (`$eq` in obj) {
+    const [a, b] = obj.$eq.map((x) => evalOperand(x, ctx));
+    if (isDynamic2(a) || isDynamic2(b))
+      return call(`eq`, { a, b });
+    return valuesEqual2(a, b);
+  }
+  if (`$lt` in obj) {
+    const [a, b] = obj.$lt.map((x) => evalOperand(x, ctx));
+    if (isDynamic2(a) || isDynamic2(b))
+      return call(`lt`, { a, b });
+    return toNumber(a) < toNumber(b);
+  }
+  if (`$add` in obj) {
+    const [a, b] = obj.$add.map((x) => evalOperand(x, ctx));
+    if (isDynamic2(a) || isDynamic2(b))
+      return call(`add`, { a, b });
+    return toNumber(a) + toNumber(b);
+  }
+  if (`$sub` in obj) {
+    const [a, b] = obj.$sub.map((x) => evalOperand(x, ctx));
+    if (isDynamic2(a) || isDynamic2(b))
+      return call(`sub`, { a, b });
+    return toNumber(a) - toNumber(b);
+  }
+  if (`$clamp` in obj) {
+    const [v, min, max] = obj.$clamp.map((x) => evalOperand(x, ctx));
+    if (isDynamic2(v) || isDynamic2(min) || isDynamic2(max))
+      return call(`clamp`, { value: v, min, max });
+    return clampNumber2(v, min, max);
+  }
+  if (`$fill` in obj) {
+    const [template, params] = obj.$fill;
+    const filled = {};
+    for (const [k, v] of Object.entries(params ?? {})) {
+      const evaluated = evalOperand(v, ctx);
+      if (evaluated !== undefined)
+        filled[k] = evaluated;
+    }
+    return call(`fill`, { template: evalOperand(template, ctx), params: filled });
+  }
+  if (`$percent` in obj) {
+    const [v, max] = obj.$percent.map((x) => evalOperand(x, ctx));
+    if (isDynamic2(v) || isDynamic2(max))
+      return call(`percent`, { value: v, max });
+    return percent2(v, max);
+  }
+  if (`$text` in obj) {
+    const spec = obj.$text;
+    const v = typeof spec === `string` ? evalExpr2(spec, ctx) : evalOperand(spec, ctx);
+    if (isDynamic2(v))
+      return call(`text`, { value: v });
+    return v === undefined || v === null ? undefined : String(v);
+  }
+  if (`$coalesce` in obj) {
+    const out = [];
+    for (const candidate of obj.$coalesce) {
+      const v = evalOperand(candidate, ctx);
+      if (v === undefined)
+        continue;
+      if (isDynamic2(v)) {
+        out.push(v);
+        continue;
+      }
+      if (!truthy2(v))
+        continue;
+      if (out.length === 0)
+        return v;
+      out.push(v);
+      break;
+    }
+    if (out.length === 0)
+      return;
+    if (out.length === 1)
+      return out[0];
+    return call(`coalesce`, { values: out });
+  }
+  if (`$not` in obj) {
+    const decided = evalConditionValue2(obj.$not, ctx);
+    if (isDynamic2(decided))
+      return call(`not`, { value: decided });
+    return !decided;
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const evaluated = evalValue2(v, ctx);
+    if (evaluated === undefined)
+      continue;
+    const key = k.includes(`{`) ? evalValue2(k, ctx) : k;
+    out[typeof key === `string` ? key : k] = evaluated;
+  }
+  return out;
+}
+function percent2(value, max) {
+  const m = toNumber(max);
+  const pct = m > 0 ? toNumber(value) / m * 100 : 0;
+  const clamped = Math.min(100, Math.max(0, pct));
+  return `${Math.round(clamped * 100) / 100}%`;
+}
+function filterItems2(items, query, fields, where) {
+  if (!Array.isArray(items))
+    return [];
+  const needle = typeof query === `string` ? query.trim().toLowerCase() : typeof query === `number` ? String(query) : ``;
+  const keys = Array.isArray(fields) ? fields.filter((f) => typeof f === `string`) : null;
+  const conditions = typeof where === `object` && where !== null && !Array.isArray(where) ? Object.entries(where).filter(([, v]) => v !== undefined && v !== null && v !== ``) : [];
+  const searchable = (v) => typeof v === `string` ? v : typeof v === `number` ? String(v) : null;
+  return items.filter((item) => {
+    const record = typeof item === `object` && item !== null && !Array.isArray(item) ? item : null;
+    for (const [field, want] of conditions)
+      if (!valuesEqual2(record?.[field], want))
+        return false;
+    if (needle === ``)
+      return true;
+    const values = record ? (keys ?? Object.keys(record)).map((k) => record[k]) : [item];
+    return values.some((v) => searchable(v)?.toLowerCase().includes(needle) ?? false);
+  });
+}
+var CORE_FUNCTIONS2 = {
+  percent: ({ value, max }) => percent2(value, max),
+  add: ({ a, b }) => toNumber(a) + toNumber(b),
+  sub: ({ a, b }) => toNumber(a) - toNumber(b),
+  eq: ({ a, b }) => valuesEqual2(a, b),
+  lt: ({ a, b }) => toNumber(a) < toNumber(b),
+  clamp: ({ value, min, max }) => clampNumber2(value, min, max),
+  cond: ({ if: test, then, else: otherwise }) => truthy2(test) ? then : otherwise,
+  fallback: ({ value, default: fallback }) => value === undefined || value === null ? fallback : value,
+  concat: ({ values }) => Array.isArray(values) ? values.map((v) => v === undefined || v === null ? `` : String(v)).join(``) : ``,
+  coalesce: ({ values }) => Array.isArray(values) ? values.find(truthy2) : undefined,
+  text: ({ value }) => value === undefined || value === null ? undefined : String(value),
+  map: ({ value, cases, default: fallback }) => {
+    const key = value === undefined || value === null ? `` : String(value);
+    const table = cases ?? {};
+    return Object.prototype.hasOwnProperty.call(table, key) ? table[key] : fallback;
+  },
+  len: ({ value }) => Array.isArray(value) ? value.length : typeof value === `string` ? value.length : 0,
+  fill: ({ template, params }) => fillTemplate2(template, params),
+  filter: ({ items, query, fields, where }) => filterItems2(items, query, fields, where),
+  formatPercent: ENGLISH_FORMAT_FUNCTIONS2.formatPercent,
+  formatRelativeTime: ENGLISH_FORMAT_FUNCTIONS2.formatRelativeTime
+};
+var CORE_FUNCTION_NAMES2 = Object.keys(CORE_FUNCTIONS2);
+// packages/exponential-ui/catalog/limits.json
+var limits_default = {
+  $comment: "VAPP-103: the input LIMITS every core enforces (the TS reference, the Rust core and through it Swift, Compose and gpui). An agent's input past a limit is refused with an issue, never worked on. `maxComponents` = nodes the reducer places in one surface's tree, template nodes included (the rest is dropped: `surface: more than N components; the rest is dropped`); a renderer's build holds at most `maxComponents` nodes too: the reduced tree's (after expansion, children and slots) plus, per template ITEM, its template subtree's (nested items charged when they are instantiated); the first item that does not fit and every later one are not rendered, with ONE issue on the template component (the same message). `maxDepth` = nesting levels of the REDUCED tree, after macro expansion (the root and every lifted template = 1, children and slots one level down; a Card, Section or Group macro adds a level; a deeper node is the Unknown placeholder, its subtree dropped: `nesting deeper than N levels`); 48 keeps every tree a core emits (2 JSON levels per node) inside serde_json's default recursion limit of 128, so reduced trees, fixtures and the FFI's JSON round-trip; the Rust core's recursive passes switch to a heap-allocated stack segment when the host thread runs low, so an iOS secondary thread's 512 KB never decides (a 48-level surface lays out on a 128 KB thread, debug build). `maxMessageBytes` = one server message as UTF-8 JSON (host routers refuse it: INVALID_MESSAGE). `maxTemplateItems` = template items one surface instantiates (beyond it the items are not rendered: `template: more than N items; the rest is not rendered`). `maxPointerBytes` / `maxPointerSegments` = a data pointer's length and token count (a longer write is refused). Generated into every target; src/limits.ts reads it.",
+  maxComponents: 20000,
+  maxDepth: 48,
+  maxMessageBytes: 4194304,
+  maxTemplateItems: 1e4,
+  maxPointerBytes: 1024,
+  maxPointerSegments: 64
+};
+
+// packages/exponential-ui/src/limits.ts
+var LIMITS2 = Object.fromEntries(Object.entries(limits_default).filter(([k]) => !k.startsWith(`$`)));
+var MAX_COMPONENTS2 = limits_default.maxComponents;
+var MAX_DEPTH2 = limits_default.maxDepth;
+var MAX_MESSAGE_BYTES2 = limits_default.maxMessageBytes;
+var MAX_TEMPLATE_ITEMS2 = limits_default.maxTemplateItems;
+var MAX_POINTER_BYTES2 = limits_default.maxPointerBytes;
+var MAX_POINTER_SEGMENTS2 = limits_default.maxPointerSegments;
+var LIMIT_ISSUES2 = {
+  usedTwice: `id used twice; only its first place renders`,
+  depth: `nesting deeper than ${MAX_DEPTH2} levels`,
+  components: `surface: more than ${MAX_COMPONENTS2} components; the rest is dropped`,
+  templateItems: `template: more than ${MAX_TEMPLATE_ITEMS2} items; the rest is not rendered`,
+  messageBytes: `message larger than ${MAX_MESSAGE_BYTES2} bytes`
+};
+
+// packages/exponential-ui/src/dynamic.ts
+var unescape = (token) => token.replace(/~1/g, `/`).replace(/~0/g, `~`);
+function own(table, key) {
+  return table !== undefined && Object.prototype.hasOwnProperty.call(table, key) ? table[key] : undefined;
+}
+function absolutePath2(path, scope = {}) {
+  if (path.startsWith(`/`))
+    return path;
+  const base = scope.base ?? ``;
+  if (path === ``)
+    return base;
+  return `${base}/${path}`;
+}
+function hasItem2(scope) {
+  return scope !== undefined && Object.prototype.hasOwnProperty.call(scope, `item`);
+}
+function readPath2(data, path, scope = {}) {
+  if (!path.startsWith(`/`) && hasItem2(scope))
+    return path === `` ? scope.item : readPointer2(scope.item, `/${path}`);
+  return readPointer2(data, absolutePath2(path, scope));
+}
+function readPointer2(data, pointer) {
+  if (pointer === `` || pointer === `/`)
+    return data;
+  let cur = data;
+  for (const raw of (pointer.startsWith(`/`) ? pointer.slice(1) : pointer).split(`/`)) {
+    if (cur === undefined || cur === null || typeof cur !== `object`)
+      return;
+    const token = unescape(raw);
+    if (Array.isArray(cur))
+      cur = /^[0-9]+$/.test(token) ? cur[Number(token)] : undefined;
+    else
+      cur = Object.prototype.hasOwnProperty.call(cur, token) ? cur[token] : undefined;
+  }
+  return cur;
+}
+var utf8Length = (text) => new TextEncoder().encode(text).length;
+function writeTokens2(pointer) {
+  if (utf8Length(pointer) > MAX_POINTER_BYTES2)
+    return POINTER_ISSUES2.bytes;
+  if (pointer === `` || pointer === `/`)
+    return [];
+  const tokens = (pointer.startsWith(`/`) ? pointer.slice(1) : pointer).split(`/`);
+  if (tokens.length > MAX_POINTER_SEGMENTS2)
+    return POINTER_ISSUES2.segments;
+  return tokens.map(unescape);
+}
+var POINTER_ISSUES2 = {
+  bytes: `data: pointer longer than ${MAX_POINTER_BYTES2} bytes`,
+  segments: `data: pointer has more than ${MAX_POINTER_SEGMENTS2} segments`,
+  notIndex: (token) => `data: ${JSON.stringify(token)} is not an array index`,
+  pastEnd: (token, length) => `data: index ${token} is past the end of the array (${length} items)`
+};
+function arrayIndex(token, length) {
+  if (token === `-`)
+    return length;
+  if (!/^[0-9]+$/.test(token))
+    return POINTER_ISSUES2.notIndex(token);
+  const index = Number(token);
+  return index <= length ? index : POINTER_ISSUES2.pastEnd(token, length);
+}
+function setOwn(target, key, value) {
+  Object.defineProperty(target, key, { value, writable: true, enumerable: true, configurable: true });
+}
+function writePointer2(data, pointer, value) {
+  const tokens = writeTokens2(pointer);
+  if (typeof tokens === `string`)
+    return { data, error: tokens };
+  if (tokens.length === 0)
+    return { data: value === undefined ? {} : value };
+  const chain = [];
+  const keys = [];
+  let cur = data;
+  for (let i = 0;i < tokens.length; i++) {
+    const token = tokens[i];
+    const last = i === tokens.length - 1;
+    if (Array.isArray(cur)) {
+      const index = arrayIndex(token, cur.length);
+      if (typeof index === `string`)
+        return { data, error: index };
+      const next = [...cur];
+      if (!last)
+        cur = next[index];
+      else if (value === undefined) {
+        if (index < next.length)
+          next.splice(index, 1);
+      } else
+        next[index] = value;
+      chain.push(next);
+      keys.push(index);
+    } else {
+      const next = {};
+      if (cur !== null && typeof cur === `object`)
+        for (const [k, v] of Object.entries(cur))
+          setOwn(next, k, v);
+      if (!last)
+        cur = Object.prototype.hasOwnProperty.call(next, token) ? next[token] : undefined;
+      else if (value === undefined)
+        delete next[token];
+      else
+        setOwn(next, token, value);
+      chain.push(next);
+      keys.push(token);
+    }
+  }
+  for (let i = chain.length - 2;i >= 0; i--) {
+    const parent = chain[i];
+    if (Array.isArray(parent))
+      parent[keys[i]] = chain[i + 1];
+    else
+      setOwn(parent, keys[i], chain[i + 1]);
+  }
+  return { data: chain[0] };
+}
+var LOGIC_FUNCTIONS = {
+  and: ({ values }) => Array.isArray(values) && values.every(truthy2),
+  or: ({ values }) => Array.isArray(values) && values.some(truthy2),
+  not: ({ value }) => !truthy2(value),
+  required: ({ value }) => truthy2(value) && !(Array.isArray(value) && value.length === 0)
+};
+var BIND_FUNCTIONS2 = { ...LOGIC_FUNCTIONS, ...CORE_FUNCTIONS2, ...ENGLISH_FORMAT_FUNCTIONS2 };
+var BIND_FUNCTION_NAMES2 = Object.keys(BIND_FUNCTIONS2);
+var FORMAT_NAMES = new Set(FORMAT_FUNCTION_NAMES2);
+var FORMAT_TABLES = new WeakMap;
+function formatTable(options) {
+  if (!options.formatter && !options.now)
+    return;
+  const formatter = options.formatter ?? (english ??= englishFormatter2());
+  if (options.now)
+    return formatFunctions2(formatter, options.now);
+  let table = FORMAT_TABLES.get(formatter);
+  if (!table)
+    FORMAT_TABLES.set(formatter, table = formatFunctions2(formatter));
+  return table;
+}
+var english;
+function resolveDynamic2(value, data, options = {}) {
+  if (isBinding2(value))
+    return readPath2(data, value.path, options.scope);
+  if (isCall2(value)) {
+    const args = {};
+    for (const [k, v] of Object.entries(value.args ?? {}))
+      args[k] = resolveDynamic2(v, data, options);
+    const fn = own(options.functions, value.call) ?? (FORMAT_NAMES.has(value.call) ? own(formatTable(options), value.call) : undefined) ?? own(BIND_FUNCTIONS2, value.call);
+    return fn ? fn(args) : undefined;
+  }
+  if (typeof value === `string`)
+    return options.strings ? resolveString2(value, options.strings) : value;
+  if (Array.isArray(value))
+    return value.map((v) => resolveDynamic2(v, data, options));
+  if (typeof value === `object` && value !== null) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      const r = resolveDynamic2(v, data, options);
+      if (r !== undefined)
+        out[k] = r;
+    }
+    return out;
+  }
+  return value;
+}
+function isVisible2(visible, data, options = {}) {
+  if (visible === undefined)
+    return true;
+  return truthy2(resolveDynamic2(visible, data, options));
+}
+function withOwnWrites2(data, props, own, scope = {}) {
+  let out = data;
+  for (const [key, value] of Object.entries(own ?? {})) {
+    const bound = props[key];
+    if (!isBinding2(bound))
+      continue;
+    if (!bound.path.startsWith(`/`) && hasItem2(scope))
+      continue;
+    out = writePointer2(out, absolutePath2(bound.path, scope), value).data;
+  }
+  return out;
+}
+var OVERLAY_COMPONENTS = [`Dialog`, `Drawer`, `AlertDialog`, `Popover`, `Tooltip`, `Menu`, `Toast`];
+var OVERLAYS = new Set(OVERLAY_COMPONENTS);
+function submitClosesOverlay2(root, formId) {
+  const walk = (n, overlay) => {
+    const here = OVERLAYS.has(n.component) && n.id !== formId ? n : overlay;
+    if (n.id === formId && n.component === `Form`)
+      return here;
+    for (const slot of Object.values(n.slots ?? {})) {
+      const hit = walk(slot, here);
+      if (hit !== undefined)
+        return hit;
+    }
+    for (const child of n.children) {
+      const hit = walk(child, here);
+      if (hit !== undefined)
+        return hit;
+    }
+    return;
+  };
+  const nearest = walk(root, null);
+  if (!nearest || nearest.component !== `Dialog` && nearest.component !== `Drawer` || nearest.props.dismissible === false)
+    return null;
+  return nearest.id;
+}
+function runAction2(action, data, options = {}) {
+  const out = { data };
+  const event = action.event ? { name: action.event.name, ...action.event.context ? { context: resolveDynamic2(action.event.context, data, options) } : {} } : undefined;
+  const fn = action.functionCall;
+  if (fn) {
+    const args = resolveDynamic2(fn.args ?? {}, data, options);
+    if (fn.call === `set`) {
+      if (typeof args.path === `string` && (args.path.startsWith(`/`) || !hasItem2(options.scope))) {
+        const pointer = absolutePath2(args.path, options.scope);
+        const written = writePointer2(data, pointer, args.value === undefined ? null : args.value);
+        const final = args.value === undefined && !written.error ? writePointer2(written.data, pointer, undefined) : written;
+        out.data = final.data;
+        if (final.error)
+          out.error = final.error;
+      }
+    } else
+      out.call = { call: fn.call, args };
+  }
+  if (event)
+    out.event = event;
+  return out;
+}
+function isDataSchema2(schema) {
+  if (!schema)
+    return false;
+  if (schema.type === `object`)
+    return schema.shape === undefined;
+  if (schema.type === `array`)
+    return schema.items !== undefined && isDataSchema2(schema.items);
+  return false;
+}
+var isObj = (v) => typeof v === `object` && v !== null && !Array.isArray(v);
+function resolveProp2(value, schema, data, options = {}, defs = {}) {
+  if (isDynamic2(value))
+    return resolveDynamic2(value, data, options);
+  if (isDataSchema2(schema))
+    return value;
+  if (schema?.type === `array` && schema.items && Array.isArray(value))
+    return value.map((item) => resolveProp2(item, schema.items, data, options, defs));
+  const shape = schema?.type === `object` && schema.shape ? defs[schema.shape] : undefined;
+  if (shape && isObj(value)) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      const r = resolveProp2(v, shape.properties[k], data, options, defs);
+      if (r !== undefined)
+        out[k] = r;
+    }
+    return out;
+  }
+  return resolveDynamic2(value, data, options);
+}
+function resolveNodeProps2(def, props, data, options = {}, defs = {}) {
+  const out = {};
+  for (const [k, v] of Object.entries(props)) {
+    const r = resolveProp2(v, def?.props[k], data, options, defs);
+    if (r !== undefined)
+      out[k] = r;
+  }
+  return out;
+}
+function hasRowSlots2(def) {
+  return def?.slotScope === `row`;
+}
+function rowScope2(rowsProp, rows, index, scope = {}) {
+  if (isBinding2(rowsProp))
+    return { base: `${absolutePath2(rowsProp.path, scope)}/${index}` };
+  return { ...scope.base !== undefined ? { base: scope.base } : {}, item: rows[index] };
+}
+function bindRowSlot2(slot, rowsProp, rows, index, data, options = {}) {
+  return bindTree2(slot, data, { ...options, scope: rowScope2(rowsProp, rows, index, options.scope) });
+}
+function sectionScope2(section, index, scope = {}) {
+  return { ...scope.base !== undefined ? { base: scope.base } : {}, item: { value: section.value, count: section.count, index } };
+}
+function bindSectionHeader2(slot, section, index, data, options = {}) {
+  return bindTree2(slot, data, { ...options, scope: sectionScope2(section, index, options.scope) });
+}
+var viewFor = (extensions) => sharedCatalogView2(extensions);
+function bindTree2(node, data, options = {}) {
+  const view = viewFor(options.extensions);
+  const walk = (n) => {
+    if (!isVisible2(n.visible, data, options))
+      return null;
+    const def = view.components[n.component];
+    const out = { id: n.id, component: n.component, props: resolveNodeProps2(def, n.props, data, options, view.defs), children: [] };
+    if (n.style)
+      out.style = resolveDynamic2(n.style, data, options);
+    if (n.on)
+      out.on = n.on;
+    if (n.accessibility) {
+      const a11y = resolveDynamic2(n.accessibility, data, options);
+      if (Object.keys(a11y).length > 0)
+        out.accessibility = a11y;
+    }
+    for (const child of n.children) {
+      const bound = walk(child);
+      if (bound)
+        out.children.push(bound);
+    }
+    if (n.slots) {
+      if (hasRowSlots2(def))
+        out.slots = n.slots;
+      else
+        for (const [slot, child] of Object.entries(n.slots)) {
+          const bound = walk(child);
+          if (bound)
+            (out.slots ??= {})[slot] = bound;
+        }
+    }
+    if (n.template)
+      out.template = n.template;
+    if (n.recipe)
+      out.recipe = { ...n.recipe, props: resolveDynamic2(n.recipe.props, data, options) };
+    return out;
+  };
+  return walk(node);
+}
+
+// packages/exponential-ui/src/tree-guides.ts
+function continuesAfter(depths, index, level) {
+  for (let at = index + 1;at < depths.length; at += 1) {
+    const depth = depths[at];
+    if (depth <= level)
+      return false;
+    if (depth === level + 1)
+      return true;
+  }
+  return false;
+}
+function treeGuides2(depths) {
+  return depths.map((depth, index) => {
+    if (depth <= 0)
+      return { elbowAt: null, tee: false, passThrough: [] };
+    const passThrough = [];
+    for (let level = 0;level <= depth - 2; level += 1) {
+      if (continuesAfter(depths, index, level))
+        passThrough.push(level);
+    }
+    return { elbowAt: depth - 1, tee: continuesAfter(depths, index, depth - 1), passThrough };
+  });
+}
+function isRowRoot2(node) {
+  return node.recipe?.macro === `Row` && node.recipe.part === `root`;
+}
+function siblingDepth(node) {
+  const depth = isRowRoot2(node) ? node.recipe?.props.depth : node.props.depth;
+  return typeof depth === `number` && Number.isFinite(depth) && depth > 0 ? Math.floor(depth) : 0;
+}
+function hasDepth(node) {
+  return !isRowRoot2(node) && node.component !== `TreeGuides` && typeof node.props.depth === `number`;
+}
+function guideProps(depth, g) {
+  const props = { depth };
+  if (g.elbowAt !== null)
+    props.elbowAt = g.elbowAt;
+  props.tee = g.tee;
+  props.passThrough = g.passThrough;
+  return props;
+}
+function fillSiblings(nodes) {
+  const depths = nodes.map(siblingDepth);
+  const guides = treeGuides2(depths);
+  nodes.forEach((node, i) => {
+    const g = guides[i];
+    if (isRowRoot2(node)) {
+      const part = guidesPart(node);
+      if (part)
+        part.props = guideProps(depths[i], g);
+    } else if (hasDepth(node)) {
+      const { depth: _d, ...guide } = guideProps(depths[i], g);
+      node.props = { ...node.props, guide };
+    }
+  });
+}
+function guidesPart(row) {
+  return row.children.find((c) => c.component === `TreeGuides` && c.recipe?.part === `guides`);
+}
+function applyTreeGuides2(root) {
+  const visit = (node) => {
+    fillSiblings(node.children);
+    for (const slot of Object.values(node.slots ?? {})) {
+      fillSiblings([slot]);
+      visit(slot);
+    }
+    node.children.forEach(visit);
+  };
+  fillSiblings([root]);
+  visit(root);
+  return root;
+}
+
+// packages/exponential-ui/src/macros.ts
+var MAX_DEPTH = 16;
+var BREAKPOINTS2 = TOKEN_GROUPS2.breakpoint;
+function clone(value) {
+  return value === undefined ? value : JSON.parse(JSON.stringify(value));
+}
+var isObj2 = (v) => typeof v === `object` && v !== null && !Array.isArray(v);
+function isResponsiveValue2(value) {
+  if (!isObj2(value) || !(`base` in value))
+    return false;
+  return Object.keys(value).every((k) => k === `base` || BREAKPOINTS2.includes(k));
+}
+function responsiveAt2(value, breakpoint) {
+  let out = value.base;
+  if (breakpoint === null)
+    return out;
+  for (const bp of BREAKPOINTS2) {
+    if (bp in value)
+      out = value[bp];
+    if (bp === breakpoint)
+      break;
+  }
+  return out;
+}
+function propsAt2(props, breakpoint) {
+  const out = {};
+  for (const [k, v] of Object.entries(props))
+    out[k] = isResponsiveValue2(v) ? responsiveAt2(v, breakpoint) : v;
+  return out;
+}
+function responsiveVariants(props) {
+  const used = new Set;
+  for (const v of Object.values(props))
+    if (isResponsiveValue2(v)) {
+      for (const k of Object.keys(v))
+        if (k !== `base`)
+          used.add(k);
+    }
+  return BREAKPOINTS2.filter((bp) => used.has(bp)).map((bp) => ({ breakpoint: bp, props: propsAt2(props, bp) }));
+}
+function mergeStyle(base, over) {
+  if (!base && !over)
+    return;
+  const out = { ...base ?? {} };
+  for (const [k, v] of Object.entries(over ?? {})) {
+    const nested = typeof v === `object` && v !== null && !Array.isArray(v);
+    out[k] = nested ? { ...out[k] ?? {}, ...v } : v;
+  }
+  return out;
+}
+function routedAction(action, context) {
+  const out = clone(action);
+  if (context && out.event) {
+    out.event.context = { ...out.event.context ?? {}, ...context };
+  }
+  return out;
+}
+function recipeProps(exp, ctx, extra) {
+  const props = {};
+  const schema = exp.view.components[exp.macro]?.props ?? {};
+  for (const name of exp.def.recipeProps) {
+    const value = exp.baseProps[name] ?? schema[name]?.default;
+    if (value !== undefined)
+      props[name] = value;
+  }
+  if (extra) {
+    const evaluated = evalValue2(extra, ctx);
+    for (const [k, v] of Object.entries(evaluated))
+      props[k] = v;
+  }
+  return props;
+}
+function andOf(conditions, op) {
+  if (conditions.length === 1)
+    return conditions[0];
+  return { call: op, args: { values: conditions } };
+}
+function decideConditions(tpl, ctx) {
+  const bound = [];
+  if (tpl.$if !== undefined) {
+    const conds = Array.isArray(tpl.$if) ? tpl.$if : [tpl.$if];
+    for (const c of conds) {
+      const r = evalConditionValue2(c, ctx);
+      if (r === false)
+        return false;
+      if (r !== true)
+        bound.push(r);
+    }
+  }
+  if (tpl.$any !== undefined) {
+    let decided = false;
+    const any = [];
+    for (const c of tpl.$any) {
+      const r = evalConditionValue2(c, ctx);
+      if (r === true) {
+        decided = true;
+        break;
+      }
+      if (r !== false)
+        any.push(r);
+    }
+    if (!decided) {
+      if (any.length === 0)
+        return false;
+      bound.push(andOf(any, `or`));
+    }
+  }
+  return bound.length === 0 ? true : andOf(bound, `and`);
+}
+function expandTemplate(tpl, exp, ctx, parentId) {
+  const decided = decideConditions(tpl, ctx);
+  if (decided === false)
+    return [];
+  const visible = decided === true ? undefined : decided;
+  if (tpl.$each !== undefined) {
+    const items = evalValue2(`{${tpl.$each}}`, ctx);
+    if (!Array.isArray(items))
+      return [];
+    const as = tpl.$as ?? `item`;
+    return items.map((item, index) => buildNode(tpl, exp, { ...ctx, vars: { ...ctx.vars, [as]: item, index } }, `${parentId}.${tpl.part}.${index}`, visible));
+  }
+  const id = tpl.part === `root` ? exp.source.id : `${parentId}.${tpl.part}`;
+  return [buildNode(tpl, exp, ctx, id, visible)];
+}
+var canon = (v) => JSON.stringify(v);
+function partStyle(tpl, exp, ctx) {
+  if (!tpl.style)
+    return;
+  const style = evalValue2(tpl.style, ctx);
+  let previous = style;
+  for (const variant of exp.variants) {
+    const at = evalValue2(tpl.style, { ...ctx, props: variant.props });
+    const diff = {};
+    for (const [k, v] of Object.entries(at))
+      if (!k.startsWith(`@`) && !k.startsWith(`:`) && canon(previous[k]) !== canon(v))
+        diff[k] = v;
+    if (Object.keys(diff).length > 0) {
+      const key = `@media (min-width: $breakpoint.${variant.breakpoint})`;
+      style[key] = { ...style[key] ?? {}, ...diff };
+    }
+    previous = at;
+  }
+  return Object.keys(style).length > 0 ? style : undefined;
+}
+function buildNode(tpl, exp, ctx, id, visible) {
+  const props = evalValue2(tpl.props ?? {}, ctx) ?? {};
+  const style = partStyle(tpl, exp, ctx);
+  const node = { id, component: tpl.component, props, children: [] };
+  if (style)
+    node.style = style;
+  if (visible !== undefined)
+    node.visible = visible;
+  node.recipe = { macro: exp.macro, part: tpl.part, props: recipeProps(exp, ctx, tpl.$recipe) };
+  if (tpl.$on) {
+    const on = {};
+    for (const [partEvent, macroEvent] of Object.entries(tpl.$on)) {
+      const action = exp.source.on?.[macroEvent];
+      if (!action)
+        continue;
+      exp.claimed.add(macroEvent);
+      const context = tpl.$context ? evalValue2(tpl.$context, ctx) : undefined;
+      on[partEvent] = routedAction(action, context);
+    }
+    if (Object.keys(on).length > 0)
+      node.on = on;
+  }
+  if (tpl.$set) {
+    for (const [partEvent, spec] of Object.entries(tpl.$set)) {
+      const bound = exp.baseProps[spec.prop];
+      if (!isBinding2(bound))
+        continue;
+      const on = node.on ??= {};
+      if (on[partEvent]?.functionCall) {
+        const macroEvent = tpl.$on?.[partEvent] ?? partEvent;
+        const message = `on.${macroEvent}: a function action replaces the two-way set of props.${spec.prop}; write it in that function's handler or use an event`;
+        if (!exp.issues?.some((i) => i.id === exp.source.id && i.message === message))
+          exp.issues?.push({ id: exp.source.id, message });
+        continue;
+      }
+      const value = evalValue2(spec.value, ctx);
+      on[partEvent] = { ...on[partEvent] ?? {}, functionCall: { call: `set`, args: value === undefined ? { path: bound.path } : { path: bound.path, value } } };
+    }
+  }
+  if (tpl.$a11y) {
+    const a11y = evalValue2(tpl.$a11y, ctx);
+    if (Object.keys(a11y).length > 0)
+      node.accessibility = a11y;
+  }
+  if (tpl.slots) {
+    for (const [slot, ref] of Object.entries(tpl.slots)) {
+      if (typeof ref === `string`) {
+        const name = ref.startsWith(`$slot:`) ? ref.slice(6) : null;
+        const value = name ? exp.source.slots?.[name] : undefined;
+        if (value)
+          (node.slots ??= {})[slot] = value;
+        continue;
+      }
+      const [built] = expandTemplate(ref, exp, ctx, id);
+      if (built)
+        (node.slots ??= {})[slot] = built;
+    }
+  }
+  for (const child of tpl.children ?? []) {
+    if (child === `$children`) {
+      node.children.push(...exp.source.children);
+      if (exp.source.template)
+        node.template = exp.source.template;
+      continue;
+    }
+    if (typeof child === `string`) {
+      if (child.startsWith(`$slot:`)) {
+        const value = exp.source.slots?.[child.slice(6)];
+        if (value)
+          node.children.push(value);
+      }
+      continue;
+    }
+    node.children.push(...expandTemplate(child, exp, ctx, id));
+  }
+  return node;
+}
+function expandMacro(node, macro, def, view, depth, issues) {
+  if (depth > MAX_DEPTH)
+    throw new Error(`macro ${macro}: expansion deeper than ${MAX_DEPTH}`);
+  const baseProps = propsAt2(node.props, null);
+  if (node.on?.press && baseProps.pressable === undefined && view.components[macro]?.props.pressable)
+    baseProps.pressable = true;
+  const exp = { view, macro, def, source: node, baseProps, variants: responsiveVariants(node.props), claimed: new Set, issues };
+  const ctx = { id: node.id, props: baseProps, vars: {} };
+  const [root] = expandTemplate(def.root, exp, ctx, node.id);
+  root.style = mergeStyle(root.style, node.style);
+  if (root.style && Object.keys(root.style).length === 0)
+    delete root.style;
+  if (node.visible !== undefined)
+    root.visible = node.visible;
+  if (node.accessibility)
+    root.accessibility = { ...root.accessibility ?? {}, ...node.accessibility };
+  const remaining = { ...root.on ?? {} };
+  for (const [event, action] of Object.entries(node.on ?? {})) {
+    if (!exp.claimed.has(event))
+      remaining[event] = action;
+  }
+  if (Object.keys(remaining).length > 0)
+    root.on = remaining;
+  else
+    delete root.on;
+  return expandTree(root, view, depth + 1, issues);
+}
+function expandTree(node, view, depth, issues) {
+  const out = { ...node, children: node.children.map((c) => expandTree(c, view, depth, issues)) };
+  if (node.slots) {
+    out.slots = {};
+    for (const [slot, child] of Object.entries(node.slots))
+      out.slots[slot] = expandTree(child, view, depth, issues);
+  }
+  const def = view.macros[out.component];
+  if (def && view.components[out.component]?.kind === `macro`) {
+    return expandMacro(out, out.component, def, view, depth, issues);
+  }
+  return out;
+}
+function expandMacros2(root, options = {}) {
+  return applyTreeGuides2(expandTree(clone(root), sharedCatalogView2(options.extensions), 0, options.issues));
+}
+
+// packages/exponential-ui/src/validate.ts
+var ICONS = new Set(ICON_NAMES2);
+var viewOf = (extensions) => sharedCatalogView2(extensions);
+var FUNCTIONS = new Set(FUNCTION_NAMES2);
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+function checkScalar(schema, value, path, view, issues) {
+  switch (schema.type) {
+    case `string`:
+    case `markdown`:
+    case `url`:
+      if (typeof value !== `string`)
+        issues.push({ path, message: `expected a string` });
+      else if (parseStringRef2(value) !== null && !isStringRef2(value))
+        issues.push({ path, message: `unknown built-in string ${value} (catalog/strings.json)` });
+      return;
+    case `date`:
+      if (typeof value !== `string` || value !== `` && !ISO_DATE.test(value))
+        issues.push({ path, message: `expected yyyy-mm-dd` });
+      return;
+    case `number`:
+      if (typeof value !== `number` || !Number.isFinite(value))
+        issues.push({ path, message: `expected a number` });
+      else if (schema.minimum !== undefined && value < schema.minimum)
+        issues.push({ path, message: `expected at least ${schema.minimum}` });
+      else if (schema.maximum !== undefined && value > schema.maximum)
+        issues.push({ path, message: `expected at most ${schema.maximum}` });
+      return;
+    case `boolean`:
+      if (typeof value !== `boolean`)
+        issues.push({ path, message: `expected a boolean` });
+      return;
+    case `enum`: {
+      const values = schema.values ?? (schema.enum ? view.enums[schema.enum] : undefined);
+      if (!values)
+        issues.push({ path, message: `enum ${schema.enum} is not defined` });
+      else if (!values.includes(value))
+        issues.push({ path, message: `expected one of ${values.join(`|`)}` });
+      return;
+    }
+    case `icon`:
+      if (typeof value !== `string` || !ICONS.has(value))
+        issues.push({ path, message: `not an icons.json name` });
+      return;
+    case `color`:
+      if (isKnownToken2(value) && parseTokenRef2(value)?.group === `color`)
+        return;
+      issues.push({ path, message: `expected $color.<name>` });
+      return;
+    case `style`:
+      for (const issue of validateStyle2(value, { path, root: false }))
+        issues.push(issue);
+      return;
+    case `array`:
+      if (!Array.isArray(value)) {
+        issues.push({ path, message: `expected an array` });
+        return;
+      }
+      if (schema.items)
+        value.forEach((item, i) => checkValue(schema.items, item, `${path}[${i}]`, view, issues));
+      return;
+    case `object`: {
+      if (typeof value !== `object` || value === null || Array.isArray(value)) {
+        issues.push({ path, message: `expected an object` });
+        return;
+      }
+      if (!schema.shape)
+        return;
+      const def = view.defs[schema.shape];
+      if (!def) {
+        issues.push({ path, message: `shape ${schema.shape} is not defined` });
+        return;
+      }
+      checkProps(def.properties, value, path, view, issues);
+      return;
+    }
+  }
+}
+function checkValue(schema, value, path, view, issues) {
+  if (schema.bindable && isDynamic2(value))
+    return;
+  if (schema.responsive && isResponsiveValue2(value)) {
+    for (const [bp, v] of Object.entries(value))
+      checkScalar(schema, v, `${path}.${bp}`, view, issues);
+    return;
+  }
+  if (schema.responsive && typeof value === `object` && value !== null && !Array.isArray(value) && !isDynamic2(value)) {
+    issues.push({ path, message: `a responsive value needs base and only ${BREAKPOINTS2.join(`|`)} besides` });
+    return;
+  }
+  checkScalar(schema, value, path, view, issues);
+}
+function checkProps(schemas, props, path, view, issues) {
+  for (const [name, schema] of Object.entries(schemas)) {
+    const value = props[name];
+    if (value === undefined || value === null) {
+      if (schema.required)
+        issues.push({ path: `${path}.${name}`, message: `required` });
+      continue;
+    }
+    checkValue(schema, value, `${path}.${name}`, view, issues);
+  }
+  for (const name of Object.keys(props)) {
+    if (!(name in schemas))
+      issues.push({ path: `${path}.${name}`, message: `unknown prop` });
+  }
+}
+function isCallableName2(name) {
+  return FUNCTIONS.has(name) || /^[A-Za-z_][\w-]*(\.[A-Za-z_][\w-]*)+$/.test(name);
+}
+function checkCall(value, path, issues) {
+  if (!isCallableName2(value.call))
+    issues.push({ path, message: `unknown function "${value.call}"; known: the catalog functions, or a namespaced host function (app.toast)` });
+}
+function checkCallsDeep(value, path, issues) {
+  if (Array.isArray(value)) {
+    value.forEach((v, i) => checkCallsDeep(v, `${path}[${i}]`, issues));
+    return;
+  }
+  if (typeof value !== `object` || value === null)
+    return;
+  if (isCall2(value))
+    checkCall(value, path, issues);
+  for (const [k, v] of Object.entries(value))
+    checkCallsDeep(v, `${path}.${k}`, issues);
+}
+function checkPropCalls(value, schema, path, view, issues) {
+  if (isCall2(value)) {
+    checkCall(value, path, issues);
+    checkCallsDeep(value.args, `${path}.args`, issues);
+    return;
+  }
+  if (!schema || isDataSchema2(schema))
+    return;
+  if (schema.type === `style`)
+    return checkCallsDeep(value, path, issues);
+  if (schema.type === `array` && schema.items && Array.isArray(value)) {
+    value.forEach((item, i) => checkPropCalls(item, schema.items, `${path}[${i}]`, view, issues));
+    return;
+  }
+  const shape = schema.type === `object` && schema.shape ? view.defs[schema.shape] : undefined;
+  if (shape && typeof value === `object` && value !== null && !Array.isArray(value))
+    for (const [k, v] of Object.entries(value))
+      checkPropCalls(v, shape.properties[k], `${path}.${k}`, view, issues);
+}
+function checkActionCalls(action, path, issues) {
+  if (typeof action !== `object` || action === null)
+    return;
+  const { functionCall, event } = action;
+  if (isCall2(functionCall)) {
+    checkCall(functionCall, `${path}.functionCall`, issues);
+    checkCallsDeep(functionCall.args, `${path}.functionCall.args`, issues);
+  }
+  if (typeof event === `object` && event !== null)
+    checkCallsDeep(event.context, `${path}.event.context`, issues);
+}
+function validateNode2(node, options = {}) {
+  const issues = [];
+  const view = viewOf(options.extensions);
+  const def = view.components[node.component];
+  if (node.style !== undefined)
+    for (const issue of validateStyle2(node.style, { path: `style` }))
+      issues.push(issue);
+  for (const [k, v] of Object.entries(node.props))
+    checkPropCalls(v, def?.props[k], `props.${k}`, view, issues);
+  if (node.visible !== undefined)
+    checkCallsDeep(node.visible, `visible`, issues);
+  for (const [event, action] of Object.entries(node.on ?? {}))
+    checkActionCalls(action, `on.${event}`, issues);
+  if (node.component === `Table` && Array.isArray(node.props.columns)) {
+    const slots = Object.keys(node.slots ?? {});
+    node.props.columns.forEach((column, i) => {
+      if (typeof column !== `object` || column === null || column.type !== `slot`)
+        return;
+      const slot = column.slot;
+      if (typeof slot !== `string`)
+        issues.push({ path: `props.columns[${i}].slot`, message: `a slot column names one of the Table's slots` });
+      else if (!slots.includes(slot))
+        issues.push({ path: `props.columns[${i}].slot`, message: `no slot "${slot}" on this Table; slots: ${slots.join(`|`) || `none`}` });
+    });
+  }
+  return issues;
+}
+function validateProps2(def, props, options = {}) {
+  const issues = [];
+  checkProps(def.props, props, options.path ?? `props`, viewOf(options.extensions), issues);
+  return issues;
+}
+
+// packages/exponential-ui/src/basic-map.ts
+var basicMap2 = basic_map_default;
+function mapBasicIcon2(name) {
+  if (typeof name !== `string`)
+    return basicMap2.placeholderIcon;
+  return (own2(basicMap2.icons, name) ? basicMap2.icons[name] : undefined) ?? basicMap2.placeholderIcon;
+}
+function isBinding(value) {
+  return typeof value === `object` && value !== null && typeof value.path === `string`;
+}
+var transforms = {
+  textVariant(out, flat) {
+    const variant = flat.variant;
+    if (variant === `h1` || variant === `h2` || variant === `h3` || variant === `h4`) {
+      out.component = `Heading`;
+      out.props = { text: out.props.text, level: variant };
+      return;
+    }
+    out.props.variant = variant === `h5` ? `label` : variant === `caption` ? `caption` : `body`;
+  },
+  imageVariant(out, flat) {
+    const variant = flat.variant ?? `mediumFeature`;
+    if (variant === `avatar`) {
+      out.component = `Avatar`;
+      out.props = { src: out.props.src, name: flat.description ?? `` };
+      return;
+    }
+    const style = variant === `icon` ? { width: 24, height: 24 } : variant === `smallFeature` ? { width: 120, height: 120 } : variant === `header` ? { width: `100%`, aspectRatio: 3 } : { width: `100%`, aspectRatio: 1.7777778 };
+    out.style = { ...out.style ?? {}, ...style };
+  },
+  iconName(out, flat) {
+    out.props.name = mapBasicIcon2(flat.name);
+  },
+  tabs(out, flat) {
+    const tabs = Array.isArray(flat.tabs) ? flat.tabs : [];
+    out.props.tabs = tabs.map((tab) => ({ label: tab.title, value: tab.child }));
+    out.childrenIds = tabs.map((tab) => tab.child);
+    if (tabs.length > 0)
+      out.props.value = tabs[0].child;
+  },
+  modal(out, flat) {
+    if (typeof flat.trigger === `string`)
+      out.slots.trigger = flat.trigger;
+    if (typeof flat.content === `string`)
+      out.childrenIds = [flat.content];
+    out.props.open = false;
+  },
+  buttonChild(out, flat, lookup) {
+    const childId = typeof flat.child === `string` ? flat.child : undefined;
+    const child = childId ? lookup(childId) : undefined;
+    if (child?.component === `Text`)
+      out.props.label = child.text;
+    else if (child?.component === `Icon`)
+      out.props.icon = mapBasicIcon2(child.name);
+    else if (childId)
+      out.childrenIds = [childId];
+    if (out.props.icon !== undefined && out.props.label === undefined)
+      out.props.size = `icon`;
+    if (flat.action !== undefined)
+      out.on = { press: flat.action };
+  },
+  textField(out, flat) {
+    out.props.name = flat.id;
+    const variant = flat.variant ?? `shortText`;
+    if (variant === `longText`)
+      out.component = `Textarea`;
+    else
+      out.props.type = variant === `number` ? `number` : variant === `obscured` ? `password` : `text`;
+    if (typeof flat.validationRegexp === `string`) {
+      const value = isBinding(flat.value) ? flat.value.path : flat.id;
+      const checks = Array.isArray(out.props.checks) ? [...out.props.checks] : [];
+      checks.push({
+        condition: { call: `regex`, args: { value: { path: value }, pattern: flat.validationRegexp } },
+        message: `Invalid value`
+      });
+      out.props.checks = checks;
+    }
+  },
+  fieldName(out, flat) {
+    out.props.name = flat.id;
+  },
+  choicePicker(out, flat) {
+    out.props.name = flat.id;
+    const multiple = flat.variant === `multipleSelection`;
+    const value = flat.value;
+    const joined = Array.isArray(value) ? multiple ? value.join(`,`) : value[0] ?? `` : value;
+    if (joined !== undefined)
+      out.props.value = joined;
+    if (flat.filterable === true) {
+      out.component = `Select`;
+      out.props.searchable = true;
+      out.props.multiple = multiple;
+    } else if (flat.displayStyle === `chips`) {
+      out.component = `Segmented`;
+      out.props = { items: out.props.options, type: multiple ? `multiple` : `single`, variant: `outline`, value: out.props.value };
+    } else if (multiple) {
+      out.component = `Select`;
+      out.props.multiple = true;
+    }
+  }
+};
+function own2(table, key) {
+  return Object.prototype.hasOwnProperty.call(table, key);
+}
+function mapBasicComponent2(flat, lookup) {
+  const rule = own2(basicMap2.components, flat.component) ? basicMap2.components[flat.component] : undefined;
+  if (!rule)
+    return null;
+  const props = {};
+  for (const [coreProp, spec] of Object.entries(rule.props)) {
+    if (typeof spec === `string`) {
+      if (flat[spec] !== undefined)
+        props[coreProp] = flat[spec];
+      continue;
+    }
+    if (`const` in spec) {
+      props[coreProp] = spec.const;
+      continue;
+    }
+    let value = spec.from !== undefined ? flat[spec.from] : undefined;
+    if (spec.map && typeof value === `string` && own2(spec.map, value))
+      value = spec.map[value];
+    if (value === undefined && spec.default !== undefined)
+      value = spec.default;
+    if (value !== undefined)
+      props[coreProp] = value;
+  }
+  const out = { component: rule.to, props, childrenIds: [], slots: {} };
+  if (rule.children === `children`) {
+    const children = flat.children;
+    if (Array.isArray(children))
+      out.childrenIds = children;
+    else if (children && typeof children === `object`)
+      out.template = { component: children.componentId, path: children.path, ...typeof children.key === `string` ? { key: children.key } : {} };
+  } else if (rule.children === `child` && typeof flat.child === `string`) {
+    out.childrenIds = [flat.child];
+  }
+  if (rule.transform) {
+    const fn = transforms[rule.transform];
+    if (!fn)
+      throw new Error(`basic-map.json names an unimplemented transform: ${rule.transform}`);
+    fn(out, flat, lookup);
+  }
+  return out;
+}
+var BASIC_TRANSFORM_NAMES2 = Object.keys(transforms);
+
+// packages/exponential-ui/src/reducer.ts
+var RESERVED_KEYS2 = [`id`, `component`, `children`, `slots`, `on`, `style`, `visible`, `accessibility`, `template`];
+var RESERVED = new Set(RESERVED_KEYS2);
+function liftTemplates(root, issues, buildMissing) {
+  const order = [];
+  const want = new Set;
+  const found = new Map;
+  const missing = new Set;
+  let rootNamed = false;
+  const originals = new Map;
+  const collect = (n) => {
+    const id = n.template?.component;
+    if (id === root.id)
+      rootNamed = true;
+    else if (id !== undefined && !want.has(id)) {
+      want.add(id);
+      order.push(id);
+    }
+    for (const slot of Object.values(n.slots ?? {}))
+      collect(slot);
+    n.children.forEach(collect);
+  };
+  const strip = (n) => {
+    const lifts = n.children.some((c) => want.has(c.id)) || Object.values(n.slots ?? {}).some((c) => want.has(c.id));
+    if (lifts && !originals.has(n))
+      originals.set(n, { children: [...n.children], ...n.slots ? { slots: { ...n.slots } } : {} });
+    n.children = n.children.filter((c) => {
+      if (!want.has(c.id))
+        return true;
+      if (!found.has(c.id))
+        found.set(c.id, c);
+      return false;
+    });
+    if (n.slots) {
+      for (const [name, slot] of Object.entries(n.slots)) {
+        if (!want.has(slot.id))
+          continue;
+        if (!found.has(slot.id))
+          found.set(slot.id, slot);
+        delete n.slots[name];
+      }
+      if (Object.keys(n.slots).length === 0)
+        delete n.slots;
+    }
+    for (const slot of Object.values(n.slots ?? {}))
+      strip(slot);
+    n.children.forEach(strip);
+  };
+  collect(root);
+  for (let before = ``;before !== `${want.size}/${found.size}/${missing.size}`; ) {
+    before = `${want.size}/${found.size}/${missing.size}`;
+    strip(root);
+    for (let n = -1;n !== found.size; ) {
+      n = found.size;
+      for (const node of [...found.values()])
+        strip(node);
+    }
+    for (const id of order) {
+      if (found.has(id) || missing.has(id))
+        continue;
+      const built = buildMissing?.(id);
+      if (built)
+        found.set(id, built);
+      else {
+        missing.add(id);
+        issues.push({ id, message: `template: no component with this id` });
+      }
+    }
+    for (const node of [...found.values()])
+      collect(node);
+  }
+  if (rootNamed)
+    issues.push({ id: root.id, message: `template: cycle through this id` });
+  const lifted = new Set(found.keys());
+  for (;; ) {
+    for (const [node, orig] of originals) {
+      node.children = orig.children.filter((c) => !lifted.has(c.id));
+      if (orig.slots) {
+        const kept = Object.entries(orig.slots).filter(([, c]) => !lifted.has(c.id));
+        if (kept.length > 0)
+          node.slots = Object.fromEntries(kept);
+        else
+          delete node.slots;
+      }
+    }
+    const deps = new Map;
+    for (const id of lifted) {
+      const out = new Set;
+      const walk = (n) => {
+        const t = n.template?.component;
+        if (t !== undefined && lifted.has(t))
+          out.add(t);
+        for (const slot of Object.values(n.slots ?? {}))
+          walk(slot);
+        n.children.forEach(walk);
+      };
+      walk(found.get(id));
+      deps.set(id, out);
+    }
+    const reaches = (from, to) => {
+      const seen = new Set;
+      const stack = [...deps.get(from) ?? []];
+      while (stack.length > 0) {
+        const id = stack.pop();
+        if (id === to)
+          return true;
+        if (seen.has(id))
+          continue;
+        seen.add(id);
+        stack.push(...deps.get(id) ?? []);
+      }
+      return false;
+    };
+    const cyclic = order.filter((id) => lifted.has(id) && reaches(id, id));
+    if (cyclic.length === 0)
+      break;
+    for (const id of cyclic) {
+      lifted.delete(id);
+      issues.push({ id, message: `template: cycle through this id` });
+    }
+  }
+  const out = new Map;
+  for (const id of order) {
+    const node = found.get(id);
+    if (node && lifted.has(id))
+      out.set(id, node);
+  }
+  return out;
+}
+function finish(root, lifted, expand, extensions, catalogId, issues) {
+  const budget = { left: MAX_COMPONENTS2, reported: issues.some((i) => i.message === LIMIT_ISSUES2.components) };
+  root = capComponents(capDepth(expand ? expandMacros2(root, { extensions, issues }) : root, catalogId, issues), budget, issues);
+  if (lifted.size === 0)
+    return { root, issues };
+  const templates = {};
+  for (const [id, node] of lifted)
+    templates[id] = capComponents(capDepth(expand ? expandMacros2(node, { extensions, issues }) : node, catalogId, issues), budget, issues);
+  return { root, issues, templates };
+}
+function capComponents(root, budget, issues) {
+  spend(budget, root.id, issues);
+  const walk = (node) => {
+    node.children = node.children.filter((child) => {
+      if (!spend(budget, child.id, issues))
+        return false;
+      walk(child);
+      return true;
+    });
+    if (node.slots)
+      for (const [name, slot] of Object.entries(node.slots)) {
+        if (!spend(budget, slot.id, issues))
+          delete node.slots[name];
+        else
+          walk(slot);
+      }
+  };
+  walk(root);
+  return root;
+}
+function capDepth(root, catalogId, issues) {
+  const reported = new Set(issues.filter((i) => i.message === LIMIT_ISSUES2.depth).map((i) => i.id));
+  const stack = [{ node: root, depth: 1 }];
+  while (stack.length) {
+    const { node, depth } = stack.pop();
+    const cap = (child) => {
+      if (depth + 1 <= MAX_DEPTH2)
+        return child;
+      if (child.component === UNKNOWN_COMPONENT2 && child.children.length === 0 && child.slots === undefined)
+        return child;
+      if (!reported.has(child.id)) {
+        reported.add(child.id);
+        issues.push({ id: child.id, message: LIMIT_ISSUES2.depth });
+      }
+      return unknown(child.id, child.component, catalogId);
+    };
+    const next = [];
+    node.children = node.children.map((child) => {
+      const capped = cap(child);
+      next.push(capped);
+      return capped;
+    });
+    if (node.slots)
+      for (const [name, slot] of Object.entries(node.slots)) {
+        const capped = cap(slot);
+        node.slots[name] = capped;
+        next.push(capped);
+      }
+    if (depth + 1 > MAX_DEPTH2)
+      continue;
+    for (let i = next.length - 1;i >= 0; i--)
+      stack.push({ node: next[i], depth: depth + 1 });
+  }
+  return root;
+}
+function unknown(id, component, catalogId) {
+  return { id, component: UNKNOWN_COMPONENT2, props: { component, catalogId }, children: [] };
+}
+function ownProps(flat) {
+  const props = {};
+  for (const [key, value] of Object.entries(flat)) {
+    if (!RESERVED.has(key) && value !== undefined)
+      props[key] = value;
+  }
+  return props;
+}
+function knownCatalog(catalogId, extensions) {
+  return catalogId === CORE_CATALOG_ID2 || catalogId === CORE_LITE_CATALOG_ID2 || catalogId === A2UI_BASIC_CATALOG_ID2 || extensions.some((ext) => ext.id === catalogId);
+}
+function validVisible2(value) {
+  return typeof value === `boolean` || isDynamic2(value);
+}
+function childTemplate2(value) {
+  const out = { component: value.componentId, path: value.path };
+  if (typeof value.key === `string`)
+    out.key = value.key;
+  return out;
+}
+function reduceSurface2(components, options) {
+  const extensions = options.extensions ?? [];
+  const view = sharedCatalogView2(extensions);
+  const issues = [];
+  const byId = new Map;
+  components.forEach((flat, i) => {
+    if (!flat || typeof flat !== `object` || typeof flat.id !== `string` || typeof flat.component !== `string`) {
+      issues.push({ id: options.rootId ?? `root`, message: `components[${i}] is not a component (an object with a string id and component)` });
+      return;
+    }
+    if (byId.has(flat.id))
+      issues.push({ id: flat.id, message: `duplicate id; the last definition wins` });
+    byId.set(flat.id, flat);
+  });
+  const lookup = (id) => byId.get(id);
+  const basic = options.catalogId === A2UI_BASIC_CATALOG_ID2;
+  if (!knownCatalog(options.catalogId, extensions))
+    issues.push({ id: options.rootId ?? `root`, message: `unsupported catalog ${options.catalogId}` });
+  const visiting = new Set;
+  const placed = new Set;
+  const twiceReported = new Set;
+  const budget = { left: MAX_COMPONENTS2, reported: false };
+  const build = (id, depth) => {
+    const flat = byId.get(id);
+    if (flat) {
+      if (visiting.has(id)) {
+        if (!spend(budget, id, issues))
+          return;
+        issues.push({ id, message: `cycle through this id` });
+        return unknown(id, flat.component, options.catalogId);
+      }
+      if (placed.has(id)) {
+        if (!twiceReported.has(id)) {
+          twiceReported.add(id);
+          issues.push({ id, message: LIMIT_ISSUES2.usedTwice });
+        }
+        return;
+      }
+    }
+    if (!spend(budget, id, issues))
+      return;
+    if (!flat) {
+      issues.push({ id, message: `no component with this id` });
+      return unknown(id, `#${id}`, options.catalogId);
+    }
+    placed.add(id);
+    if (depth > MAX_DEPTH2) {
+      issues.push({ id, message: LIMIT_ISSUES2.depth });
+      return unknown(id, flat.component, options.catalogId);
+    }
+    const child = (childId) => build(childId, depth + 1);
+    const children = (ids) => ids.map(child).filter((n) => n !== undefined);
+    visiting.add(id);
+    let node;
+    if (basic) {
+      const mapped = mapBasicComponent2(flat, lookup);
+      if (!mapped) {
+        issues.push({ id, message: `basic component ${flat.component} has no mapping` });
+        node = unknown(id, flat.component, options.catalogId);
+      } else {
+        node = { id, component: mapped.component, props: mapped.props, children: children(mapped.childrenIds) };
+        if (mapped.template)
+          node.template = mapped.template;
+        if (mapped.style)
+          node.style = mapped.style;
+        if (mapped.on)
+          node.on = mapped.on;
+        for (const [slot, childId] of Object.entries(mapped.slots)) {
+          const built = child(childId);
+          if (built)
+            (node.slots ??= {})[slot] = built;
+        }
+      }
+    } else {
+      const def = view.components[flat.component];
+      if (!def) {
+        issues.push({ id, message: `unknown component ${flat.component}` });
+        node = unknown(id, flat.component, options.catalogId);
+      } else {
+        node = { id, component: flat.component, props: ownProps(flat), children: [] };
+        if (Array.isArray(flat.children))
+          node.children = children(flat.children);
+        else if (flat.children && typeof flat.children === `object`)
+          node.template = childTemplate2(flat.children);
+        if (flat.style)
+          node.style = flat.style;
+        if (flat.on)
+          node.on = flat.on;
+        for (const [slot, childId] of Object.entries(flat.slots ?? {})) {
+          const built = child(childId);
+          if (built)
+            (node.slots ??= {})[slot] = built;
+        }
+      }
+    }
+    if (flat.visible !== undefined) {
+      if (validVisible2(flat.visible))
+        node.visible = flat.visible;
+      else
+        issues.push({ id, message: `visible: expected a boolean, a binding or a function call` });
+    }
+    if (flat.accessibility)
+      node.accessibility = flat.accessibility;
+    visiting.delete(id);
+    if (options.validate !== false && node.component !== UNKNOWN_COMPONENT2) {
+      const def = view.components[node.component];
+      if (def) {
+        for (const issue of validateProps2(def, node.props, { path: `props`, extensions }))
+          issues.push({ id, message: `${issue.path}: ${issue.message}` });
+        if (def.children === `none` && node.children.length > 0)
+          issues.push({ id, message: `${node.component} takes no children` });
+        for (const slot of Object.keys(node.slots ?? {}))
+          if (!slotAllowed2(def.slots, slot))
+            issues.push({ id, message: `slots.${slot}: ${node.component} has no such slot` });
+        for (const issue of validateNode2(node, { extensions }))
+          issues.push({ id, message: `${issue.path}: ${issue.message}` });
+      }
+    }
+    return node;
+  };
+  const rootId = options.rootId ?? `root`;
+  let root = build(rootId, 1) ?? unknown(rootId, `#${rootId}`, options.catalogId);
+  const lifted = liftTemplates(root, issues, (id) => byId.has(id) && !placed.has(id) ? build(id, 1) : undefined);
+  return finish(root, lifted, options.expand !== false, extensions, options.catalogId, issues);
+}
+function spend(budget, id, issues) {
+  if (budget.left > 0) {
+    budget.left -= 1;
+    return true;
+  }
+  if (!budget.reported)
+    issues.push({ id, message: LIMIT_ISSUES2.components });
+  budget.reported = true;
+  return false;
+}
+function slotAllowed2(slots, name) {
+  return (slots ?? []).some((s) => s === `*` || s === name);
+}
+function reduceNested2(tree, options) {
+  const extensions = options.extensions ?? [];
+  const view = sharedCatalogView2(extensions);
+  const issues = [];
+  const budget = { left: MAX_COMPONENTS2, reported: false };
+  const walk = (n, depth) => {
+    if (!spend(budget, n.id, issues))
+      return;
+    if (depth > MAX_DEPTH2) {
+      issues.push({ id: n.id, message: LIMIT_ISSUES2.depth });
+      return unknown(n.id, n.component, options.catalogId);
+    }
+    const def = view.components[n.component];
+    if (!def) {
+      issues.push({ id: n.id, message: `unknown component ${n.component}` });
+      return unknown(n.id, n.component, options.catalogId);
+    }
+    const children = (n.children ?? []).map((c) => walk(c, depth + 1)).filter((c) => c !== undefined);
+    const node = { id: n.id, component: n.component, props: { ...n.props ?? {} }, children };
+    if (n.style)
+      node.style = n.style;
+    if (n.visible !== undefined) {
+      if (validVisible2(n.visible))
+        node.visible = n.visible;
+      else
+        issues.push({ id: n.id, message: `visible: expected a boolean, a binding or a function call` });
+    }
+    if (n.on)
+      node.on = n.on;
+    if (n.accessibility)
+      node.accessibility = n.accessibility;
+    if (n.template)
+      node.template = n.template;
+    if (n.slots) {
+      node.slots = {};
+      for (const [slot, child] of Object.entries(n.slots)) {
+        const built = walk(child, depth + 1);
+        if (built)
+          node.slots[slot] = built;
+      }
+    }
+    if (options.validate !== false) {
+      for (const issue of validateProps2(def, node.props, { path: `props`, extensions }))
+        issues.push({ id: n.id, message: `${issue.path}: ${issue.message}` });
+      if (def.children === `none` && node.children.length > 0)
+        issues.push({ id: n.id, message: `${n.component} takes no children` });
+      for (const slot of Object.keys(node.slots ?? {}))
+        if (!slotAllowed2(def.slots, slot))
+          issues.push({ id: n.id, message: `slots.${slot}: ${n.component} has no such slot` });
+      for (const issue of validateNode2(node, { extensions }))
+        issues.push({ id: n.id, message: `${issue.path}: ${issue.message}` });
+    }
+    return node;
+  };
+  let root = walk(tree, 1);
+  const lifted = liftTemplates(root, issues);
+  return finish(root, lifted, options.expand !== false, extensions, options.catalogId, issues);
+}
+function preorder2(root) {
+  const out = [];
+  const walk = (n) => {
+    out.push(n.id);
+    for (const slot of Object.values(n.slots ?? {}))
+      walk(slot);
+    n.children.forEach(walk);
+  };
+  walk(root);
+  return out;
+}
+// packages/exponential-ui/src/host/policy.ts
+var BUILTIN_FUNCTIONS2 = coreCatalog2.functions.names;
+function matchesPattern2(pattern, name) {
+  return pattern.endsWith(`*`) ? name.startsWith(pattern.slice(0, -1)) : pattern === name;
+}
+function decideFunction2(policy, name, registered) {
+  if (BUILTIN_FUNCTIONS2.includes(name))
+    return `allow`;
+  if (!registered)
+    return `not_found`;
+  const p = policy ?? {};
+  const any = (list) => (list ?? []).some((pattern) => matchesPattern2(pattern, name));
+  if (any(p.deny))
+    return `deny`;
+  if (any(p.allow))
+    return `allow`;
+  if (any(p.ask))
+    return `ask`;
+  return p.default ?? `allow`;
+}
+function combineDecisions2(a, b) {
+  const rank = { allow: 0, ask: 1, deny: 2, not_found: 3 };
+  return rank[a] >= rank[b] ? a : b;
+}
+function packagePolicy2(functions) {
+  return { allow: functions ?? [], default: `deny` };
+}
+function absolute(url, baseUrl) {
+  try {
+    return new URL(url);
+  } catch {
+    if (!baseUrl)
+      return null;
+    try {
+      return new URL(url, baseUrl);
+    } catch {
+      return null;
+    }
+  }
+}
+function hostMatches(pattern, host) {
+  const p = pattern.toLowerCase();
+  return p.startsWith(`*.`) ? host.endsWith(p.slice(1)) && host.length > p.length - 1 : host === p;
+}
+function ipv4(host) {
+  const m = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  if (!m)
+    return null;
+  const parts = m.slice(1).map(Number);
+  return parts.every((n) => n <= 255) ? parts : null;
+}
+function ipv6(host) {
+  if (!host.startsWith(`[`) || !host.endsWith(`]`))
+    return null;
+  const text = host.slice(1, -1);
+  const halves = text.split(`::`);
+  if (halves.length > 2)
+    return null;
+  const pieces = (part) => {
+    if (part === ``)
+      return [];
+    const out = [];
+    for (const p of part.split(`:`)) {
+      if (!/^[0-9a-f]{1,4}$/.test(p))
+        return null;
+      out.push(parseInt(p, 16));
+    }
+    return out;
+  };
+  const head = pieces(halves[0]);
+  const tail = halves.length === 2 ? pieces(halves[1]) : [];
+  if (!head || !tail)
+    return null;
+  if (halves.length === 1)
+    return head.length === 8 ? head : null;
+  if (head.length + tail.length > 7)
+    return null;
+  return [...head, ...new Array(8 - head.length - tail.length).fill(0), ...tail];
+}
+function privateV4([a, b]) {
+  return a === 0 || a === 10 || a === 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168;
+}
+function isPrivateHost2(hostname) {
+  const host = hostname.toLowerCase().replace(/\.$/, ``);
+  if (host === `localhost` || host.endsWith(`.localhost`) || host.endsWith(`.local`))
+    return true;
+  const v4 = ipv4(host);
+  if (v4)
+    return privateV4(v4);
+  const v6 = ipv6(host);
+  if (!v6)
+    return false;
+  if (v6.every((p) => p === 0))
+    return true;
+  if (v6.slice(0, 7).every((p) => p === 0) && v6[7] === 1)
+    return true;
+  if ((v6[0] & 65472) === 65152 || (v6[0] & 65024) === 64512)
+    return true;
+  if (v6.slice(0, 5).every((p) => p === 0) && v6[5] === 65535)
+    return privateV4([v6[6] >> 8, v6[6] & 255, v6[7] >> 8, v6[7] & 255]);
+  return false;
+}
+function privateAllowed(allow, host) {
+  return (allow ?? []).some((p) => p === `*` || hostMatches(p, host));
+}
+function decideUrl2(policy, url) {
+  const parsed = absolute(url.trim(), policy?.baseUrl);
+  if (!parsed)
+    return { allowed: false, reason: `invalid` };
+  const scheme = parsed.protocol.replace(/:$/, ``).toLowerCase();
+  const schemes = policy?.schemes ?? DEFAULT_URL_SCHEMES2;
+  if (!schemes.includes(scheme))
+    return { allowed: false, url: parsed.href, reason: `scheme` };
+  if (scheme === `http` || scheme === `https`) {
+    const host = parsed.hostname.toLowerCase();
+    if (policy?.hosts && !policy.hosts.some((h) => hostMatches(h, host)))
+      return { allowed: false, url: parsed.href, reason: `host` };
+    if (isPrivateHost2(host) && !privateAllowed(policy?.allowPrivate, host))
+      return { allowed: false, url: parsed.href, reason: `private` };
+  }
+  return { allowed: true, url: parsed.href };
+}
+function mediaRequest2(url, options = {}) {
+  const d = decideUrl2({ baseUrl: options.baseUrl, schemes: options.schemes ?? DEFAULT_MEDIA_SCHEMES2, hosts: options.hosts, allowPrivate: options.allowPrivate }, url);
+  if (!d.allowed || !d.url)
+    return null;
+  const href = d.url;
+  const headers = {};
+  for (const rule of options.rules ?? [])
+    if (href.startsWith(rule.prefix))
+      Object.assign(headers, rule.headers);
+  return { url: href, headers: sortKeys2(headers) };
+}
+function safeHref2(policy, url) {
+  if (typeof url !== `string` || !url)
+    return;
+  const d = decideUrl2(policy, url);
+  return d.allowed ? d.url : undefined;
+}
+function sortKeys2(record) {
+  return Object.fromEntries(Object.entries(record).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+}
+function imageDimensions2(bytes) {
+  if (isSvg(bytes))
+    return svgDimensions2(bytes);
+  const n = bytes.length;
+  const be16 = (i) => i + 2 <= n ? bytes[i] << 8 | bytes[i + 1] : null;
+  const le16 = (i) => i + 2 <= n ? bytes[i] | bytes[i + 1] << 8 : null;
+  const be32 = (i) => i + 4 <= n ? (bytes[i] << 24 | bytes[i + 1] << 16 | bytes[i + 2] << 8 | bytes[i + 3]) >>> 0 : null;
+  const le32 = (i) => i + 4 <= n ? (bytes[i] | bytes[i + 1] << 8 | bytes[i + 2] << 16 | bytes[i + 3] << 24) >>> 0 : null;
+  const le24 = (i) => i + 3 <= n ? bytes[i] | bytes[i + 1] << 8 | bytes[i + 2] << 16 : null;
+  const starts = (sig, at = 0) => sig.every((b, i) => bytes[at + i] === b);
+  const pair = (w, h) => w === null || h === null ? null : [w, h];
+  if (starts([137, 80, 78, 71, 13, 10, 26, 10]))
+    return pair(be32(16), be32(20));
+  if (starts([71, 73, 70, 56]) && (bytes[4] === 55 || bytes[4] === 57) && bytes[5] === 97)
+    return pair(le16(6), le16(8));
+  if (starts([66, 77])) {
+    const h = le32(22);
+    return pair(le32(18), h === null ? null : Math.abs(h | 0));
+  }
+  if (n >= 30 && starts([82, 73, 70, 70]) && starts([87, 69, 66, 80], 8)) {
+    const kind = String.fromCharCode(bytes[12], bytes[13], bytes[14], bytes[15]);
+    if (kind === `VP8 `)
+      return pair(le16(26) & 16383, le16(28) & 16383);
+    if (kind === `VP8L`) {
+      const b = le32(21);
+      return b === null ? null : [(b & 16383) + 1, (b >>> 14 & 16383) + 1];
+    }
+    if (kind === `VP8X`) {
+      const w = le24(24);
+      const h = le24(27);
+      return w === null || h === null ? null : [w + 1, h + 1];
+    }
+    return null;
+  }
+  if (starts([255, 216])) {
+    let i = 2;
+    while (i + 4 <= n) {
+      if (bytes[i] !== 255) {
+        i += 1;
+        continue;
+      }
+      const marker = bytes[i + 1];
+      if (marker === 255) {
+        i += 1;
+        continue;
+      }
+      if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) {
+        i += 2;
+        continue;
+      }
+      const len = be16(i + 2);
+      if (len === null)
+        return null;
+      if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204)
+        return pair(be16(i + 7), be16(i + 5));
+      i += 2 + len;
+    }
+  }
+  return null;
+}
+function isSvg(bytes) {
+  const head = bytes.subarray(0, 256);
+  let i = 0;
+  while (i < head.length && (head[i] === 32 || head[i] === 9 || head[i] === 10 || head[i] === 12 || head[i] === 13))
+    i += 1;
+  const text = String.fromCharCode(...head.subarray(i, i + 5)).toLowerCase();
+  return text.startsWith(`<svg`) || text.startsWith(`<?xml`);
+}
+var SVG_UNITS = { "": 1, px: 1, pt: 4 / 3, pc: 16, in: 96, cm: 96 / 2.54, mm: 96 / 25.4, em: 16, ex: 8 };
+function svgLength(value) {
+  const v = value.trim();
+  const m = /^[0-9.+\-eE]*/.exec(v);
+  let num = m[0];
+  let unit = v.slice(num.length);
+  if (/[eE]$/.test(num)) {
+    num = num.slice(0, -1);
+    unit = v.slice(num.length);
+  }
+  const scale = SVG_UNITS[unit.trim()];
+  if (scale === undefined || !/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(num))
+    return null;
+  const n = Number(num);
+  return Number.isFinite(n) && n >= 0 ? n * scale : null;
+}
+function svgViewBox(value) {
+  const parts = value.split(/[\s,]+/).filter((p) => p !== ``);
+  if (parts.length !== 4 || parts.some((p) => !/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(p)))
+    return null;
+  const w = Number(parts[2]);
+  const h = Number(parts[3]);
+  return w > 0 && h > 0 && Number.isFinite(w) && Number.isFinite(h) ? [w, h] : null;
+}
+function svgDimensions2(bytes) {
+  let at = -1;
+  for (let i = 0;i + 4 <= bytes.length; i++) {
+    if (bytes[i] === 60 && bytes[i + 1] === 115 && bytes[i + 2] === 118 && bytes[i + 3] === 103) {
+      at = i;
+      break;
+    }
+  }
+  if (at < 0)
+    return null;
+  let end = bytes.indexOf(62, at);
+  if (end < 0)
+    end = bytes.length;
+  const tag = new TextDecoder().decode(bytes.subarray(at + 4, end));
+  let width = null;
+  let height = null;
+  let viewBox = null;
+  for (const m of tag.matchAll(/(?<=\s)([A-Za-z_:][A-Za-z0-9_:.\-]*)\s*=\s*("([^"]*)"?|'([^']*)'?)/g)) {
+    const value = m[3] ?? m[4] ?? ``;
+    if (m[1] === `width`)
+      width = svgLength(value);
+    else if (m[1] === `height`)
+      height = svgLength(value);
+    else if (m[1] === `viewBox`)
+      viewBox = svgViewBox(value);
+  }
+  let w;
+  let h;
+  if (width !== null && height !== null)
+    [w, h] = [width, height];
+  else if (width !== null)
+    [w, h] = [width, viewBox ? width * viewBox[1] / viewBox[0] : 100];
+  else if (height !== null)
+    [w, h] = [viewBox ? height * viewBox[0] / viewBox[1] : 100, height];
+  else
+    [w, h] = viewBox ?? [100, 100];
+  const px = (v) => Number.isFinite(v) ? Math.min(Math.max(Math.ceil(v), 0), 4294967295) : 4294967295;
+  return [px(w), px(h)];
+}
+function imageFrames2(bytes) {
+  const n = bytes.length;
+  const be32 = (i) => i + 4 <= n ? (bytes[i] << 24 | bytes[i + 1] << 16 | bytes[i + 2] << 8 | bytes[i + 3]) >>> 0 : null;
+  const le32 = (i) => i + 4 <= n ? (bytes[i] | bytes[i + 1] << 8 | bytes[i + 2] << 16 | bytes[i + 3] << 24) >>> 0 : null;
+  const tag = (i) => i + 4 <= n ? String.fromCharCode(bytes[i], bytes[i + 1], bytes[i + 2], bytes[i + 3]) : null;
+  const starts = (sig) => sig.every((b, i) => bytes[i] === b);
+  let frames = 1;
+  if (starts([71, 73, 70, 56]) && (bytes[4] === 55 || bytes[4] === 57) && bytes[5] === 97) {
+    const skipBlocks = (i) => {
+      while (i < n) {
+        const size = bytes[i];
+        i += 1 + size;
+        if (size === 0)
+          break;
+      }
+      return i;
+    };
+    const table = (packed) => packed & 128 ? 3 << (packed & 7) + 1 : 0;
+    let i = 13 + (n > 10 ? table(bytes[10]) : 0);
+    frames = 0;
+    for (;; ) {
+      if (bytes[i] === 44) {
+        frames += 1;
+        if (i + 9 >= n)
+          break;
+        i = skipBlocks(i + 10 + table(bytes[i + 9]) + 1);
+      } else if (bytes[i] === 33)
+        i = skipBlocks(i + 2);
+      else
+        break;
+    }
+  } else if (starts([137, 80, 78, 71, 13, 10, 26, 10])) {
+    let i = 8;
+    for (;; ) {
+      const len = be32(i);
+      const kind = tag(i + 4);
+      if (len === null || kind === null || kind === `IDAT`)
+        break;
+      if (kind === `acTL`) {
+        frames = be32(i + 8) ?? 1;
+        break;
+      }
+      i += 12 + len;
+    }
+  } else if (n >= 21 && tag(0) === `RIFF` && tag(8) === `WEBP` && tag(12) === `VP8X` && bytes[20] & 2) {
+    let i = 12;
+    frames = 0;
+    for (;; ) {
+      const kind = tag(i);
+      const size = le32(i + 4);
+      if (kind === null || size === null)
+        break;
+      if (kind === `ANMF`)
+        frames += 1;
+      i += 8 + size + (size & 1);
+    }
+  }
+  return Math.max(frames, 1);
+}
+function mediaImageWithinLimits2(bytes, limits = MEDIA_LIMITS2) {
+  const { maxBytes, maxPixels } = limits;
+  if (bytes.length > maxBytes)
+    return `media is over ${maxBytes} bytes`;
+  const starts = (sig, at = 0) => sig.every((b, i) => bytes[at + i] === b);
+  const raster = starts([137, 80, 78, 71, 13, 10, 26, 10]) || starts([71, 73, 70, 56]) && (bytes[4] === 55 || bytes[4] === 57) && bytes[5] === 97 || starts([66, 77]) || starts([255, 216]) || bytes.length >= 12 && starts([82, 73, 70, 70]) && starts([87, 69, 66, 80], 8);
+  if (!raster && !isSvg(bytes))
+    return null;
+  const dims = imageDimensions2(bytes);
+  if (!dims)
+    return `media: image dimensions unreadable`;
+  const [w, h] = dims;
+  const frames = imageFrames2(bytes);
+  if (frames <= 1)
+    return w * h > maxPixels ? `media is ${w}×${h}, over ${maxPixels} pixels` : null;
+  return w * h * frames > maxPixels ? `media is ${w}×${h} × ${frames} frames, over ${maxPixels} pixels` : null;
+}
+// packages/exponential-ui/src/host/sources.ts
+var SOURCE = /^([a-zA-Z][a-zA-Z0-9+.-]*):([^?]+)(?:\?(.*))?$/;
+function decode(part) {
+  try {
+    return decodeURIComponent(part.replace(/\+/g, ` `));
+  } catch {
+    return part;
+  }
+}
+function parseSource2(uri) {
+  const m = SOURCE.exec(uri.trim());
+  if (!m)
+    return null;
+  const name = decode(m[2]);
+  if (!name)
+    return null;
+  const params = {};
+  for (const pair of (m[3] ?? ``).split(`&`)) {
+    if (!pair)
+      continue;
+    const eq = pair.indexOf(`=`);
+    const key = decode(eq < 0 ? pair : pair.slice(0, eq));
+    if (!key)
+      continue;
+    params[key] = eq < 0 ? `` : decode(pair.slice(eq + 1));
+  }
+  return { uri, scheme: m[1].toLowerCase(), name, params: sortKeys2(params) };
+}
+// packages/exponential-ui/src/host/decoders.ts
+function parseLine(line, at, out) {
+  const text = line.trim();
+  if (!text)
+    return;
+  try {
+    out.messages.push(JSON.parse(text));
+  } catch {
+    out.issues.push({ at, message: `line ${at} is not JSON` });
+  }
+}
+function utf8Bytes(text) {
+  let n = 0;
+  for (let i = 0;i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    n += c < 128 ? 1 : c < 2048 ? 2 : c >= 55296 && c <= 57343 ? 2 : 3;
+  }
+  return n;
+}
+
+class Lines {
+  parts = [];
+  bytes = 0;
+  skipping = false;
+  push(chunk) {
+    const out = [];
+    let start = 0;
+    if (this.skipping) {
+      const i = chunk.indexOf(`
+`);
+      if (i < 0)
+        return out;
+      this.skipping = false;
+      start = i + 1;
+    }
+    let nl = chunk.indexOf(`
+`, start);
+    while (nl >= 0) {
+      const piece = chunk.slice(start, nl);
+      const oversized = this.bytes + utf8Bytes(piece) > MAX_MESSAGE_BYTES2;
+      out.push(oversized ? null : this.parts.length ? this.parts.join(``) + piece : piece);
+      this.parts = [];
+      this.bytes = 0;
+      start = nl + 1;
+      nl = chunk.indexOf(`
+`, start);
+    }
+    if (start < chunk.length) {
+      const tail = chunk.slice(start);
+      this.parts.push(tail);
+      this.bytes += utf8Bytes(tail);
+    }
+    if (this.bytes > MAX_MESSAGE_BYTES2) {
+      out.push(null);
+      this.parts = [];
+      this.bytes = 0;
+      this.skipping = true;
+    }
+    return out;
+  }
+  end() {
+    const skipping = this.skipping;
+    const tail = this.parts.join(``);
+    this.parts = [];
+    this.bytes = 0;
+    this.skipping = false;
+    return skipping ? null : tail;
+  }
+}
+var oversized = (at, what) => ({ at, message: `${what} ${at}: ${LIMIT_ISSUES2.messageBytes}` });
+
+class JsonlDecoder2 {
+  lines = new Lines;
+  line = 0;
+  push(chunk) {
+    const out = { messages: [], issues: [] };
+    for (const raw of this.lines.push(chunk)) {
+      this.line += 1;
+      if (raw === null)
+        out.issues.push(oversized(this.line, `line`));
+      else
+        parseLine(raw, this.line, out);
+    }
+    return out;
+  }
+  end() {
+    const out = { messages: [], issues: [] };
+    const raw = this.lines.end();
+    if (raw !== null && raw.trim()) {
+      this.line += 1;
+      parseLine(raw, this.line, out);
+    }
+    return out;
+  }
+}
+function decodeJsonl2(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith(`[`)) {
+    try {
+      const value = JSON.parse(trimmed);
+      if (Array.isArray(value))
+        return { messages: value, issues: [] };
+    } catch {}
+  }
+  const d = new JsonlDecoder2;
+  const a = d.push(text);
+  const b = d.end();
+  return { messages: [...a.messages, ...b.messages], issues: [...a.issues, ...b.issues] };
+}
+
+class SseDecoder2 {
+  retryMs;
+  lines = new Lines;
+  data = [];
+  dataBytes = 0;
+  oversized = false;
+  event = ``;
+  count = 0;
+  push(chunk) {
+    const out = { messages: [], issues: [] };
+    for (const raw of this.lines.push(chunk)) {
+      if (raw === null)
+        this.dropData();
+      else
+        this.line(raw.endsWith(`\r`) ? raw.slice(0, -1) : raw, out);
+    }
+    return out;
+  }
+  end() {
+    const out = { messages: [], issues: [] };
+    const raw = this.lines.end();
+    if (raw === null)
+      this.dropData();
+    else if (raw)
+      this.line(raw, out);
+    this.dispatch(out);
+    return out;
+  }
+  dropData() {
+    this.data = [];
+    this.dataBytes = 0;
+    this.oversized = true;
+  }
+  line(line, out) {
+    if (line === ``)
+      return this.dispatch(out);
+    if (line.startsWith(`:`))
+      return;
+    const colon = line.indexOf(`:`);
+    const field = colon < 0 ? line : line.slice(0, colon);
+    let value = colon < 0 ? `` : line.slice(colon + 1);
+    if (value.startsWith(` `))
+      value = value.slice(1);
+    if (field === `data`) {
+      if (this.oversized)
+        return;
+      this.dataBytes += utf8Bytes(value) + 1;
+      if (this.dataBytes > MAX_MESSAGE_BYTES2)
+        return this.dropData();
+      this.data.push(value);
+    } else if (field === `event`)
+      this.event = value;
+    else if (field === `retry` && /^\d+$/.test(value))
+      this.retryMs = Number(value);
+  }
+  dispatch(out) {
+    this.dataBytes = 0;
+    if (this.oversized) {
+      this.oversized = false;
+      this.count += 1;
+      this.data = [];
+      this.event = ``;
+      out.issues.push(oversized(this.count, `event`));
+      return;
+    }
+    if (!this.data.length) {
+      this.event = ``;
+      return;
+    }
+    this.count += 1;
+    const name = this.event || `message`;
+    const data = this.data.join(`
+`);
+    this.data = [];
+    this.event = ``;
+    if (!SSE_EVENTS2.includes(name))
+      return;
+    const d = decodeJsonl2(data);
+    out.messages.push(...d.messages);
+    if (d.issues.length)
+      out.issues.push({ at: this.count, message: `event ${this.count} is not JSON` });
+  }
+}
+function messagesFromMcpResult2(result) {
+  const out = { messages: [], issues: [] };
+  if (!result || typeof result !== `object`)
+    return out;
+  const r = result;
+  const structured = r.structuredContent?.a2ui;
+  if (Array.isArray(structured))
+    out.messages.push(...structured);
+  if (Array.isArray(r.content)) {
+    r.content.forEach((item, i) => {
+      const resource = item?.resource;
+      if (item?.type !== `resource` || !resource || !MCP_MIME_TYPES2.includes(resource.mimeType ?? ``))
+        return;
+      if (typeof resource.text !== `string`)
+        return;
+      const d = decodeJsonl2(resource.text);
+      out.messages.push(...d.messages);
+      for (const issue of d.issues)
+        out.issues.push({ at: i + 1, message: `content[${i}]: ${issue.message}` });
+    });
+  }
+  return out;
+}
+function mcpActionCall2(message, tool = MCP_ACTION_TOOL2) {
+  return { method: `tools/call`, params: { name: tool, arguments: { message } } };
+}
+// packages/exponential-ui/src/host/package.ts
+function supportedCatalogIds2(extensionIds = []) {
+  const out = [];
+  for (const id of [CORE_CATALOG_ID2, CORE_LITE_CATALOG_ID2, A2UI_BASIC_CATALOG_ID2, ...extensionIds])
+    if (!out.includes(id))
+      out.push(id);
+  return out;
+}
+function clientCapabilities2(extensionIds = []) {
+  return { "v0.9": { supportedCatalogIds: supportedCatalogIds2(extensionIds) } };
+}
+var isObject = (v) => !!v && typeof v === `object` && !Array.isArray(v);
+var POINTER = /^(\/([^/~]|~[01])*)*$/;
+function validatePackage2(pkg, catalogIds = supportedCatalogIds2()) {
+  const issues = [];
+  if (!isObject(pkg))
+    return [{ path: ``, message: `a package is an object` }];
+  for (const key of [`id`, `name`, `version`, `catalogId`])
+    if (typeof pkg[key] !== `string` || !pkg[key])
+      issues.push({ path: `/${key}`, message: `${key} is a required string` });
+  if (typeof pkg.catalogId === `string` && pkg.catalogId && !catalogIds.includes(pkg.catalogId))
+    issues.push({ path: `/catalogId`, message: `unsupported catalog ${pkg.catalogId}` });
+  if (!isObject(pkg.templates) || !Object.keys(pkg.templates).length)
+    issues.push({ path: `/templates`, message: `templates is a non-empty object` });
+  else
+    for (const [id, template] of Object.entries(pkg.templates)) {
+      const at = `/templates/${id}`;
+      if (!isObject(template)) {
+        issues.push({ path: at, message: `a template is an object` });
+        continue;
+      }
+      const components = template.components;
+      if (!Array.isArray(components) || !components.length)
+        issues.push({ path: `${at}/components`, message: `components is a non-empty array` });
+      else {
+        const ids = new Set;
+        components.forEach((c, i) => {
+          if (!isObject(c) || typeof c.id !== `string` || typeof c.component !== `string`)
+            issues.push({ path: `${at}/components/${i}`, message: `a component needs an id and a component` });
+          else if (ids.has(c.id))
+            issues.push({ path: `${at}/components/${i}/id`, message: `duplicate id ${c.id}` });
+          else
+            ids.add(c.id);
+        });
+        if (!ids.has(`root`))
+          issues.push({ path: `${at}/components`, message: `no component has the id root` });
+      }
+      if (template.bindings !== undefined) {
+        if (!Array.isArray(template.bindings))
+          issues.push({ path: `${at}/bindings`, message: `bindings is an array` });
+        else
+          template.bindings.forEach((b, i) => {
+            const bp = `${at}/bindings/${i}`;
+            if (!isObject(b) || typeof b.path !== `string` || !POINTER.test(b.path))
+              issues.push({ path: `${bp}/path`, message: `path is a JSON pointer` });
+            if (!isObject(b) || typeof b.source !== `string` || !parseSource2(b.source))
+              issues.push({ path: `${bp}/source`, message: `source is a scheme:name URI` });
+          });
+      }
+    }
+  if (pkg.functions !== undefined && (!Array.isArray(pkg.functions) || pkg.functions.some((f) => typeof f !== `string` || !f)))
+    issues.push({ path: `/functions`, message: `functions is a list of names or prefix* patterns` });
+  if (pkg.sources !== undefined && (!Array.isArray(pkg.sources) || pkg.sources.some((f) => typeof f !== `string` || !f)))
+    issues.push({ path: `/sources`, message: `sources is a list of scheme:name sources or prefix* patterns` });
+  else if (Array.isArray(pkg.sources) && isObject(pkg.templates))
+    for (const [id, template] of Object.entries(pkg.templates)) {
+      if (!isObject(template) || !Array.isArray(template.bindings))
+        continue;
+      template.bindings.forEach((b, i) => {
+        if (isObject(b) && typeof b.source === `string` && parseSource2(b.source) && !sourceAllowed2(pkg.sources, b.source))
+          issues.push({ path: `/templates/${id}/bindings/${i}/source`, message: `source ${b.source} is not in the package's sources` });
+      });
+    }
+  return issues;
+}
+function sourceAllowed2(allowed, source) {
+  if (allowed === undefined)
+    return true;
+  const parsed = parseSource2(source);
+  if (!parsed)
+    return false;
+  const name = `${parsed.scheme}:${parsed.name}`;
+  return allowed.some((p) => matchesPattern2(p, name) || matchesPattern2(p, source));
+}
+function templateMessages2(pkg, templateId, surfaceId, data) {
+  const template = pkg.templates[templateId];
+  if (!template)
+    return null;
+  const version = A2UI_VERSION2;
+  const out = [
+    { version, createSurface: { surfaceId, catalogId: pkg.catalogId } },
+    { version, updateComponents: { surfaceId, components: template.components } }
+  ];
+  const merged = mergeData2(template.data, data);
+  if (merged !== undefined)
+    out.push({ version, updateDataModel: { surfaceId, path: `/`, value: merged } });
+  for (const b of template.bindings ?? [])
+    out.push({ version, bindDataModel: { surfaceId, path: b.path, source: b.source } });
+  return out;
+}
+function mergeData2(base, over) {
+  if (over === undefined)
+    return base;
+  if (isObject(base) && isObject(over))
+    return { ...base, ...over };
+  return over;
+}
+// packages/exponential-ui/src/host/router.ts
+var isObject2 = (v) => !!v && typeof v === `object` && !Array.isArray(v);
+
+class HostRouter2 {
+  extensionIds;
+  surfaces = new Map;
+  packages = new Map;
+  constructor(options = {}) {
+    this.extensionIds = [...options.extensionIds ?? []];
+  }
+  get supportedCatalogIds() {
+    return supportedCatalogIds2(this.extensionIds);
+  }
+  registerExtension(id) {
+    if (!this.extensionIds.includes(id))
+      this.extensionIds.push(id);
+  }
+  installPackage(pkg) {
+    const issues = validatePackage2(pkg, this.supportedCatalogIds);
+    if (!issues.length)
+      this.packages.set(pkg.id, pkg);
+    return issues;
+  }
+  package(id) {
+    return this.packages.get(id);
+  }
+  surface(id) {
+    return this.surfaces.get(id);
+  }
+  surfaceIds() {
+    return [...this.surfaces.keys()];
+  }
+  route(message) {
+    if (oversized2(message))
+      return [this.invalid(isObject2(message) ? surfaceIdOf(message) : ``, LIMIT_ISSUES2.messageBytes)];
+    if (!isObject2(message))
+      return [this.invalid(``, `a message is a JSON object`)];
+    if (message.version !== undefined && message.version !== A2UI_VERSION2)
+      return [this.invalid(surfaceIdOf(message), `unsupported version ${String(message.version)}`)];
+    const kinds = Object.keys(message).filter((k) => k !== `version`);
+    if (kinds.length !== 1 || !MESSAGE_KINDS2.includes(kinds[0]))
+      return [this.invalid(surfaceIdOf(message), `expected exactly one of ${MESSAGE_KINDS2.join(`, `)}`)];
+    const kind = kinds[0];
+    const body = message[kind];
+    if (!isObject2(body) || typeof body.surfaceId !== `string` || !body.surfaceId)
+      return [this.invalid(``, `${kind}.surfaceId is required`)];
+    const surfaceId = body.surfaceId;
+    switch (kind) {
+      case `createSurface`: {
+        if (typeof body.catalogId !== `string`)
+          return [this.invalid(surfaceId, `createSurface.catalogId is required`)];
+        if (!this.supportedCatalogIds.includes(body.catalogId))
+          return [{ op: `send`, message: errorMessage2(`UNSUPPORTED_CATALOG`, surfaceId, `catalog ${body.catalogId} is not supported`) }];
+        this.surfaces.set(surfaceId, { surfaceId, catalogId: body.catalogId });
+        const op = { op: `create`, surfaceId, catalogId: body.catalogId };
+        if (body.theme !== undefined)
+          op.theme = body.theme;
+        if (body.sendDataModel === true)
+          op.sendDataModel = true;
+        return [op];
+      }
+      case `updateComponents`: {
+        if (!Array.isArray(body.components))
+          return [this.invalid(surfaceId, `updateComponents.components is required`)];
+        if (!this.surfaces.has(surfaceId))
+          return [this.missing(surfaceId)];
+        return [{ op: `components`, surfaceId, components: body.components }];
+      }
+      case `updateDataModel`: {
+        if (!this.surfaces.has(surfaceId))
+          return [this.missing(surfaceId)];
+        if (body.path !== undefined && typeof body.path !== `string`)
+          return [this.invalid(surfaceId, `updateDataModel.path is a string`)];
+        const path = normalizePath2(body.path);
+        return [`value` in body ? { op: `data`, surfaceId, path, value: body.value } : { op: `data`, surfaceId, path }];
+      }
+      case `deleteSurface`: {
+        if (!this.surfaces.has(surfaceId))
+          return [this.missing(surfaceId)];
+        this.surfaces.delete(surfaceId);
+        return [{ op: `delete`, surfaceId }];
+      }
+      case `bindDataModel`: {
+        const info = this.surfaces.get(surfaceId);
+        if (!info)
+          return [this.missing(surfaceId)];
+        if (typeof body.path !== `string` || typeof body.source !== `string` || !parseSource2(body.source))
+          return [this.invalid(surfaceId, `bindDataModel needs a path and a scheme:name source`)];
+        const pkg = info.packageId ? this.packages.get(info.packageId) : undefined;
+        if (pkg && !sourceAllowed2(pkg.sources, body.source))
+          return [{ op: `send`, message: errorMessage2(`SOURCE_DENIED`, surfaceId, `source ${body.source} is not in package ${pkg.id}'s sources`, normalizePath2(body.path) || `/`) }];
+        return [{ op: `bind`, surfaceId, path: normalizePath2(body.path), source: body.source }];
+      }
+      case `applyTemplate`: {
+        if (typeof body.templateId !== `string`)
+          return [this.invalid(surfaceId, `applyTemplate.templateId is required`)];
+        const pkg = this.findPackage(body.templateId, typeof body.packageId === `string` ? body.packageId : undefined);
+        if (!pkg)
+          return [{ op: `send`, message: errorMessage2(`TEMPLATE_NOT_FOUND`, surfaceId, `no installed package has the template ${body.templateId}`) }];
+        const ops = [];
+        for (const m of templateMessages2(pkg, body.templateId, surfaceId, body.data) ?? []) {
+          ops.push(...this.route(m));
+          const info = this.surfaces.get(surfaceId);
+          if (info)
+            info.packageId = pkg.id;
+        }
+        return ops;
+      }
+    }
+    return [this.invalid(surfaceId, `unknown message`)];
+  }
+  findPackage(templateId, packageId) {
+    if (packageId !== undefined) {
+      const pkg = this.packages.get(packageId);
+      return pkg && pkg.templates[templateId] ? pkg : undefined;
+    }
+    for (const pkg of this.packages.values())
+      if (pkg.templates[templateId])
+        return pkg;
+    return;
+  }
+  invalid(surfaceId, message) {
+    return { op: `send`, message: errorMessage2(`INVALID_MESSAGE`, surfaceId, message) };
+  }
+  missing(surfaceId) {
+    return { op: `send`, message: errorMessage2(`SURFACE_NOT_FOUND`, surfaceId, `no surface ${surfaceId}; send createSurface first`) };
+  }
+}
+function oversized2(message) {
+  let text;
+  try {
+    text = JSON.stringify(message);
+  } catch {
+    return false;
+  }
+  if (text === undefined || text.length * 3 <= MAX_MESSAGE_BYTES2)
+    return false;
+  return text.length > MAX_MESSAGE_BYTES2 || new TextEncoder().encode(text).length > MAX_MESSAGE_BYTES2;
+}
+function surfaceIdOf(message) {
+  for (const v of Object.values(message))
+    if (isObject2(v) && typeof v.surfaceId === `string`)
+      return v.surfaceId;
+  return ``;
+}
+function normalizePath2(path) {
+  return path === undefined || path === `/` ? `` : path;
+}
+// packages/exponential-ui/src/host/runtime.ts
+class PackageError2 extends Error {
+  packageId;
+  issues;
+  constructor(packageId, issues) {
+    super(`exponential-ui: package ${packageId} is unusable: ${issues.map((i) => `${i.path || `/`} ${i.message}`).join(`; `)}`);
+    this.packageId = packageId;
+    this.issues = issues;
+    this.name = `PackageError`;
+  }
+}
+var MAX_ISSUES = 100;
+function resolveSurfaceTheme2(input) {
+  if (typeof input === `string`) {
+    if (!BUILTIN_THEME_IDS2.includes(input))
+      return { theme: null, issues: [`unknown built-in theme "${input}"; known: ${BUILTIN_THEME_IDS2.join(`|`)}`] };
+    return { theme: builtinTheme2(input), issues: [] };
+  }
+  const { theme, issues } = tryLoadTheme2(input, { themes: BUILTIN_THEMES2 });
+  return { theme, issues: issues.map((i) => i.path ? `${i.path}: ${i.message}` : i.message) };
+}
+
+class SurfaceStore2 {
+  extensions;
+  surfaceId;
+  catalogId;
+  packageId;
+  sendDataModel = false;
+  list = [];
+  shared = false;
+  positions = new Map;
+  data = {};
+  theme;
+  reduced = null;
+  listeners = new Set;
+  version = 0;
+  constructor(surfaceId, catalogId, extensions) {
+    this.extensions = extensions;
+    this.surfaceId = surfaceId;
+    this.catalogId = catalogId;
+  }
+  get components() {
+    this.shared = true;
+    return this.list;
+  }
+  component(id) {
+    const at = this.positions.get(id);
+    return at === undefined ? undefined : this.list[at];
+  }
+  get root() {
+    return this.reduce().root;
+  }
+  get issues() {
+    return this.reduce().issues;
+  }
+  get templates() {
+    return this.reduce().templates;
+  }
+  reduce() {
+    if (!this.reduced)
+      this.reduced = this.list.length ? reduceSurface2(this.list, { catalogId: this.catalogId, extensions: this.extensions() }) : { root: null, issues: [] };
+    return this.reduced;
+  }
+  setComponents(components) {
+    if (this.shared) {
+      this.list = this.list.slice();
+      this.shared = false;
+    }
+    for (const c of components) {
+      const at = this.positions.get(c.id);
+      if (at === undefined) {
+        this.positions.set(c.id, this.list.length);
+        this.list.push(c);
+      } else
+        this.list[at] = c;
+    }
+    this.reduced = null;
+    this.notify();
+  }
+  invalidate() {
+    this.reduced = null;
+    this.notify();
+  }
+  setData(pointer, value) {
+    const written = writePointer2(this.data, pointer, value);
+    if (written.error)
+      return written.error;
+    this.data = written.data;
+    this.notify();
+    return;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notify() {
+    this.version += 1;
+    for (const l of [...this.listeners])
+      l();
+  }
+}
+
+class ExponentialHost2 {
+  options;
+  router;
+  stores = new Map;
+  subscriptions = new Map;
+  paintErrors = new Map;
+  listeners = new Set;
+  functions;
+  sources;
+  extensions;
+  status = `closed`;
+  statusDetail;
+  unsupportedCatalog;
+  issues = [];
+  constructor(options = {}) {
+    this.options = options;
+    this.extensions = [...options.extensions ?? []];
+    this.router = new HostRouter2({ extensionIds: this.extensions.map((e) => e.id) });
+    this.functions = { ...options.functions ?? {} };
+    this.sources = { ...options.sources ?? {} };
+    for (const pkg of options.packages ?? []) {
+      const issues = this.installPackage(pkg);
+      if (issues.length)
+        throw new PackageError2(typeof pkg?.id === `string` && pkg.id ? pkg.id : `?`, issues);
+    }
+  }
+  get hasTransport() {
+    return this.options.transport !== undefined;
+  }
+  get supportedCatalogIds() {
+    return this.router.supportedCatalogIds;
+  }
+  clientCapabilities() {
+    return clientCapabilities2(this.extensions.map((e) => e.id));
+  }
+  get extensionDefs() {
+    return this.extensions;
+  }
+  registerExtension(ext) {
+    if (this.extensions.some((e) => e.id === ext.id))
+      return;
+    this.extensions.push(ext);
+    this.router.registerExtension(ext.id);
+    for (const store of this.stores.values())
+      store.invalidate();
+  }
+  registerFunction(name, fn) {
+    this.functions[name] = fn;
+  }
+  registerSource(scheme, resolver) {
+    this.sources[scheme.toLowerCase()] = resolver;
+  }
+  installPackage(pkg) {
+    const issues = this.router.installPackage(pkg);
+    const packageId = typeof pkg?.id === `string` ? pkg.id : undefined;
+    for (const i of issues)
+      this.report({ code: `PACKAGE_INVALID`, message: i.message, path: i.path, ...packageId ? { packageId } : {} });
+    return issues;
+  }
+  report(issue) {
+    const next = [...this.issues, issue];
+    this.issues = next.length > MAX_ISSUES ? next.slice(next.length - MAX_ISSUES) : next;
+    this.options.onIssue?.(issue);
+    this.notify();
+  }
+  surface(id) {
+    return this.stores.get(id);
+  }
+  surfaceIds() {
+    return [...this.stores.keys()];
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notify() {
+    for (const l of [...this.listeners])
+      l();
+  }
+  connect() {
+    const t = this.options.transport;
+    if (!t)
+      return;
+    t.start((m) => this.receive(m), (status, detail) => {
+      this.status = status;
+      this.statusDetail = detail;
+      this.notify();
+    });
+  }
+  close() {
+    this.options.transport?.close();
+    for (const id of this.surfaceIds())
+      this.perform({ op: `delete`, surfaceId: id });
+  }
+  receive(message) {
+    const ops = this.router.route(message);
+    for (const op of ops)
+      this.perform(op);
+    return ops;
+  }
+  send(message) {
+    this.options.transport?.send(message);
+    this.options.onSend?.(message);
+    if (`error` in message) {
+      const e = message.error;
+      this.report({ code: e.code, message: e.message, ...e.surfaceId ? { surfaceId: e.surfaceId } : {}, ...e.path !== undefined ? { path: e.path } : {} });
+    }
+  }
+  perform(op) {
+    this.options.onOp?.(op);
+    switch (op.op) {
+      case `create`: {
+        this.unbind(op.surfaceId);
+        this.forgetPaintErrors(op.surfaceId);
+        const store = new SurfaceStore2(op.surfaceId, op.catalogId, () => this.extensions);
+        store.sendDataModel = op.sendDataModel === true;
+        store.packageId = this.router.surface(op.surfaceId)?.packageId;
+        if (op.theme !== undefined && op.theme !== null) {
+          const { theme, issues } = resolveSurfaceTheme2(op.theme);
+          if (theme)
+            store.theme = theme;
+          else
+            this.send(errorMessage2(`VALIDATION_FAILED`, op.surfaceId, `createSurface.theme is unusable: ${issues.join(`; `)}`, `/createSurface/theme`));
+        }
+        this.stores.set(op.surfaceId, store);
+        this.notify();
+        return;
+      }
+      case `components`: {
+        const failed = this.paintErrors.get(op.surfaceId);
+        if (failed)
+          for (const c of op.components)
+            failed.delete(c.id);
+        this.stores.get(op.surfaceId)?.setComponents(op.components);
+        return;
+      }
+      case `data`: {
+        const error = this.stores.get(op.surfaceId)?.setData(op.path, op.value);
+        if (error)
+          this.send(errorMessage2(`VALIDATION_FAILED`, op.surfaceId, error, op.path || `/`));
+        return;
+      }
+      case `bind`: {
+        const store = this.stores.get(op.surfaceId);
+        const source = parseSource2(op.source);
+        const resolver = source ? this.sources[source.scheme] : undefined;
+        if (!store || !source)
+          return;
+        if (!resolver) {
+          this.send(errorMessage2(`VALIDATION_FAILED`, op.surfaceId, `no resolver for the source scheme ${source.scheme}`, op.path || `/`));
+          return;
+        }
+        const cancel = resolver(source, (value) => this.stores.get(op.surfaceId)?.setData(op.path, value));
+        if (cancel)
+          this.subscriptions.set(op.surfaceId, [...this.subscriptions.get(op.surfaceId) ?? [], cancel]);
+        return;
+      }
+      case `delete`:
+        this.unbind(op.surfaceId);
+        this.forgetPaintErrors(op.surfaceId);
+        this.stores.delete(op.surfaceId);
+        this.notify();
+        return;
+      case `send`: {
+        const err = `error` in op.message ? op.message.error : undefined;
+        if (err?.code === `UNSUPPORTED_CATALOG`) {
+          this.unsupportedCatalog = err.message.replace(/^catalog (\S+).*$/, `$1`);
+          this.notify();
+        }
+        this.send(op.message);
+        return;
+      }
+    }
+  }
+  unbind(surfaceId) {
+    for (const cancel of this.subscriptions.get(surfaceId) ?? [])
+      cancel();
+    this.subscriptions.delete(surfaceId);
+  }
+  action(event) {
+    const message = actionMessage2({
+      name: event.name,
+      surfaceId: event.surfaceId,
+      sourceComponentId: event.componentId,
+      timestamp: event.timestamp ?? new Date().toISOString(),
+      context: event.context ?? {},
+      payload: event.payload
+    });
+    this.send(message);
+    return message;
+  }
+  decide(surfaceId, name) {
+    const registered = Object.prototype.hasOwnProperty.call(this.functions, name);
+    let decision = decideFunction2(this.options.policy?.functions, name, registered);
+    const pkgId = this.stores.get(surfaceId)?.packageId;
+    const pkg = pkgId ? this.router.package(pkgId) : undefined;
+    if (pkg)
+      decision = combineDecisions2(decision, decideFunction2(packagePolicy2(pkg.functions), name, registered));
+    return decision;
+  }
+  async callFunction(call) {
+    if (call.name === `openUrl`) {
+      const url = typeof call.args.url === `string` ? call.args.url : ``;
+      return { decision: this.openUrl(url) ? `allow` : `deny` };
+    }
+    let decision = this.decide(call.surfaceId, call.name);
+    if (decision === `not_found`) {
+      this.send(errorMessage2(`FUNCTION_NOT_FOUND`, call.surfaceId, `no function ${call.name}`));
+      return { decision };
+    }
+    let consentError;
+    if (decision === `ask`) {
+      let ok = false;
+      try {
+        ok = await this.options.policy?.onFunctionCall?.(call) === true;
+      } catch (e) {
+        consentError = e instanceof Error ? e.message : String(e);
+      }
+      if (!ok)
+        decision = `deny`;
+    }
+    if (decision === `deny`) {
+      this.send(errorMessage2(`FUNCTION_DENIED`, call.surfaceId, consentError === undefined ? `${call.name} was not allowed` : `${call.name} was not allowed: the consent hook failed: ${consentError}`));
+      return consentError === undefined ? { decision } : { decision, error: consentError };
+    }
+    const fn = Object.prototype.hasOwnProperty.call(this.functions, call.name) ? this.functions[call.name] : undefined;
+    if (!fn)
+      return { decision: `allow` };
+    try {
+      return { decision: `allow`, result: await fn(call.args, call) };
+    } catch (e) {
+      return { decision: `allow`, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  urlPolicy() {
+    return { baseUrl: this.options.policy?.media?.baseUrl, ...this.options.policy?.urls };
+  }
+  openUrl(url) {
+    const d = decideUrl2(this.urlPolicy(), url);
+    if (!d.allowed || !d.url)
+      return false;
+    const open = this.options.policy?.openUrl ?? ((u) => globalThis.window?.open(u, `_blank`, `noopener`));
+    open(d.url);
+    return true;
+  }
+  paintError(error) {
+    const store = this.stores.get(error.surfaceId);
+    let owner = error.componentId;
+    while (store && !store.component(owner) && owner.includes(`.`))
+      owner = owner.slice(0, owner.lastIndexOf(`.`));
+    const current = store?.component(owner);
+    let failed = this.paintErrors.get(error.surfaceId);
+    if (!failed)
+      this.paintErrors.set(error.surfaceId, failed = new Map);
+    let entry = failed.get(owner);
+    if (!entry || entry.component !== current)
+      failed.set(owner, entry = { component: current, ids: new Set });
+    if (entry.ids.has(error.componentId))
+      return;
+    entry.ids.add(error.componentId);
+    this.send(errorMessage2(RENDER_FAILED2, error.surfaceId, error.message, `/components/${error.componentId}`));
+  }
+  forgetPaintErrors(surfaceId) {
+    this.paintErrors.delete(surfaceId);
+  }
+  mediaOptions() {
+    return this.options.policy?.media;
+  }
+  mediaRequest(url) {
+    return mediaRequest2(url, this.options.policy?.media);
+  }
+}
+// packages/exponential-ui/src/host/transports.ts
+class MemoryTransport2 {
+  sent = [];
+  receiveFn;
+  pending = [];
+  onSend;
+  start(receive, status) {
+    this.receiveFn = receive;
+    status(`open`);
+    const queued = this.pending;
+    this.pending = [];
+    queued.forEach(receive);
+  }
+  feed(...messages) {
+    if (!this.receiveFn)
+      this.pending.push(...messages);
+    else
+      messages.forEach(this.receiveFn);
+  }
+  feedJsonl(text) {
+    this.feed(...decodeJsonl2(text).messages);
+  }
+  send(message) {
+    this.sent.push(message);
+    this.onSend?.(message);
+  }
+  close() {
+    this.receiveFn = undefined;
+  }
+}
+
+class StreamTransport {
+  options;
+  controller;
+  generation = 0;
+  constructor(options) {
+    this.options = options;
+  }
+  start(receive, status) {
+    this.controller?.abort();
+    const gen = ++this.generation;
+    this.run(gen, receive, status);
+  }
+  async run(gen, receive, status) {
+    const f = this.options.fetch ?? fetch;
+    const live = () => gen === this.generation;
+    while (live()) {
+      const controller = new AbortController;
+      this.controller = controller;
+      status(`connecting`);
+      let wait = this.options.reconnectMs ?? 2000;
+      try {
+        const res = await f(this.options.url, { headers: { accept: this.accept(), ...this.options.headers }, signal: controller.signal });
+        if (!live())
+          return;
+        if (!res.ok || !res.body)
+          throw new Error(`HTTP ${res.status}`);
+        status(`open`);
+        const reader = res.body.getReader();
+        const text = new TextDecoder;
+        const dec = this.decoder();
+        for (;; ) {
+          const { done, value } = await reader.read();
+          if (!live())
+            return;
+          if (done)
+            break;
+          dec.push(text.decode(value, { stream: true })).messages.forEach(receive);
+        }
+        dec.end().messages.forEach(receive);
+        status(`closed`);
+        const resumable = this.options.resumable === true || dec.retryMs !== undefined;
+        if (!resumable) {
+          if (live())
+            this.generation += 1;
+          return;
+        }
+        if (dec.retryMs !== undefined && this.options.reconnectMs === undefined)
+          wait = dec.retryMs;
+      } catch (e) {
+        if (!live())
+          return;
+        status(`error`, e instanceof Error ? e.message : String(e));
+      }
+      if (!wait || !live())
+        return;
+      await new Promise((r) => setTimeout(r, wait));
+    }
+  }
+  async send(message) {
+    const f = this.options.fetch ?? fetch;
+    await f(this.options.postUrl ?? this.options.url, { method: `POST`, headers: { "content-type": `application/json`, ...this.options.headers }, body: JSON.stringify(message) });
+  }
+  close() {
+    this.generation += 1;
+    this.controller?.abort();
+  }
+}
+
+class JsonlStreamTransport2 extends StreamTransport {
+  decoder() {
+    return new JsonlDecoder2;
+  }
+  accept() {
+    return `application/jsonl, application/x-ndjson`;
+  }
+}
+
+class SseTransport2 extends StreamTransport {
+  decoder() {
+    return new SseDecoder2;
+  }
+  accept() {
+    return `text/event-stream`;
+  }
+}
+
+class WebSocketTransport2 {
+  options;
+  socket;
+  generation = 0;
+  constructor(options) {
+    this.options = options;
+  }
+  start(receive, status) {
+    const gen = ++this.generation;
+    const live = () => gen === this.generation;
+    const WS = this.options.WebSocket ?? WebSocket;
+    status(`connecting`);
+    const socket = new WS(this.options.url, this.options.protocols);
+    this.socket = socket;
+    socket.onopen = () => live() && status(`open`);
+    socket.onmessage = (ev) => {
+      if (live() && typeof ev.data === `string`)
+        decodeJsonl2(ev.data).messages.forEach(receive);
+    };
+    socket.onerror = () => live() && status(`error`, `websocket error`);
+    socket.onclose = () => {
+      if (!live())
+        return;
+      status(`closed`);
+      const wait = this.options.reconnectMs ?? 2000;
+      if (wait)
+        setTimeout(() => live() && this.start(receive, status), wait);
+    };
+  }
+  send(message) {
+    if (this.socket?.readyState === 1)
+      this.socket.send(JSON.stringify(message));
+  }
+  close() {
+    this.generation += 1;
+    this.socket?.close();
+  }
+}
+
+class McpTransport2 {
+  options;
+  id = 0;
+  receiveFn;
+  session;
+  constructor(options) {
+    this.options = options;
+  }
+  start(receive, status) {
+    this.receiveFn = receive;
+    status(`connecting`);
+    (async () => {
+      try {
+        await this.rpc(`initialize`, { protocolVersion: `2025-06-18`, capabilities: {}, clientInfo: { name: `exponential-ui`, version: `0.1.0` } });
+        const result = await this.rpc(`tools/call`, { name: this.options.tool, arguments: this.options.arguments ?? {} });
+        status(`open`);
+        messagesFromMcpResult2(result).messages.forEach(receive);
+      } catch (e) {
+        status(`error`, e instanceof Error ? e.message : String(e));
+      }
+    })();
+  }
+  async send(message) {
+    const call = mcpActionCall2(message, this.options.actionTool);
+    const result = await this.rpc(call.method, call.params);
+    if (this.receiveFn)
+      messagesFromMcpResult2(result).messages.forEach(this.receiveFn);
+  }
+  close() {
+    this.receiveFn = undefined;
+  }
+  async rpc(method, params) {
+    const f = this.options.fetch ?? fetch;
+    const id = ++this.id;
+    const res = await f(this.options.url, {
+      method: `POST`,
+      headers: { "content-type": `application/json`, accept: `application/json, text/event-stream`, ...this.session ? { "mcp-session-id": this.session } : {}, ...this.options.headers },
+      body: JSON.stringify({ jsonrpc: `2.0`, id, method, params })
+    });
+    const session = res.headers.get(`mcp-session-id`);
+    if (session)
+      this.session = session;
+    if (!res.ok)
+      throw new Error(`MCP HTTP ${res.status}`);
+    const type = res.headers.get(`content-type`) ?? ``;
+    const body = await res.text();
+    const replies = type.includes(`text/event-stream`) ? (() => {
+      const d = new SseDecoder2;
+      return [...d.push(body).messages, ...d.end().messages];
+    })() : [JSON.parse(body)];
+    const reply = replies.find((r) => r?.id === id);
+    if (!reply)
+      throw new Error(`MCP: no reply to ${method}`);
+    if (reply.error)
+      throw new Error(`MCP: ${reply.error.message ?? `error`}`);
+    return reply.result;
+  }
+}
+export { CATALOG_ID2, LITE_CATALOG_ID2, BASIC_CATALOG_ID2, BASIC_VERSION2, CATALOG_VERSION2, UNKNOWN_COMPONENT_NAME2, COMPONENT_NAMES2, NATIVE_COMPONENTS2, MACRO_COMPONENTS2, LITE_COMPONENTS2, COMPONENT_GROUPS2, SPECIMEN_IDS2, ENUMS2, TOKEN_NAMES2, STYLE_KEY_NAMES2, STYLE_STATE_NAMES2, ICON_NAMES2, FUNCTION_NAMES2, BASIC_COMPONENT_MAP2, BASIC_ICON_MAP2, BASIC_PLACEHOLDER_ICON2, DEFAULT_STRINGS2, STRING_IDS2, parseStringRef2, isStringRef2, stringTable2, formatString2, resolveString2, locale_default, displayString2, currencyDigits2, parseDateValue2, formatPattern2, ENGLISH_DATE_PATTERNS2, ENGLISH_TIME_PATTERN2, ENGLISH_DATE_TIME_JOIN2, fixedOffset2, intlZoneOffset2, relativeTimeUnit2, englishFormatter2, intlFormatter2, FORMAT_FUNCTION_NAMES2, formatFunctions2, ENGLISH_FORMAT_FUNCTIONS2, isBinding2, isCall2, isDynamic2, truthy2, valuesEqual2, clampNumber2, fillTemplate2, evalExpr2, evalConditionValue2, evalCondition2, evalValue2, percent2, filterItems2, CORE_FUNCTIONS2, CORE_FUNCTION_NAMES2, LIMITS2, MAX_COMPONENTS2, MAX_DEPTH2, MAX_MESSAGE_BYTES2, MAX_TEMPLATE_ITEMS2, MAX_POINTER_BYTES2, MAX_POINTER_SEGMENTS2, LIMIT_ISSUES2, absolutePath2, hasItem2, readPath2, readPointer2, writeTokens2, POINTER_ISSUES2, writePointer2, BIND_FUNCTIONS2, BIND_FUNCTION_NAMES2, resolveDynamic2, isVisible2, withOwnWrites2, submitClosesOverlay2, runAction2, isDataSchema2, resolveProp2, resolveNodeProps2, hasRowSlots2, rowScope2, bindRowSlot2, sectionScope2, bindSectionHeader2, bindTree2, treeGuides2, isRowRoot2, applyTreeGuides2, BREAKPOINTS2, isResponsiveValue2, responsiveAt2, propsAt2, expandMacros2, isCallableName2, validateNode2, validateProps2, basicMap2, mapBasicIcon2, mapBasicComponent2, BASIC_TRANSFORM_NAMES2, RESERVED_KEYS2, validVisible2, childTemplate2, reduceSurface2, slotAllowed2, reduceNested2, preorder2, BUILTIN_FUNCTIONS2, matchesPattern2, decideFunction2, combineDecisions2, packagePolicy2, isPrivateHost2, decideUrl2, mediaRequest2, safeHref2, sortKeys2, imageDimensions2, svgDimensions2, imageFrames2, mediaImageWithinLimits2, parseSource2, JsonlDecoder2, decodeJsonl2, SseDecoder2, messagesFromMcpResult2, mcpActionCall2, supportedCatalogIds2, clientCapabilities2, validatePackage2, sourceAllowed2, templateMessages2, mergeData2, HostRouter2, normalizePath2, PackageError2, resolveSurfaceTheme2, SurfaceStore2, ExponentialHost2, MemoryTransport2, JsonlStreamTransport2, SseTransport2, WebSocketTransport2, McpTransport2 };
+
+//# debugId=10AAE9080E35A11264756E2164756E21
+//# sourceMappingURL=index-98npjvsd.js.map