@exponential-at/ui 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,3213 @@
+import {
+  coreCatalog2,
+  CORE_CATALOG_ID2,
+  CORE_LITE_CATALOG_ID2,
+  A2UI_BASIC_CATALOG_ID2,
+  A2UI_VERSION2,
+  SUPPORTED_CATALOG_IDS2,
+  UNKNOWN_COMPONENT2,
+  coreMacros2,
+  TOKEN_GROUPS2,
+  parseTokenRef2,
+  isKnownToken2,
+  catalogView2,
+  sharedCatalogView2,
+  componentDef2,
+  isOffered2,
+  componentNames2,
+  coreLite2
+} from "./chunks/index-gwkt14w3.js";
+import {
+  STYLE_KEYS2,
+  STYLE_LAYOUT_KEYS2,
+  STYLE_VISUAL_KEYS2,
+  STYLE_LAYOUT_EFFECT_KEYS2,
+  STYLE_MEDIA2,
+  STYLE_TRANSFORM2,
+  STYLE_STATES2,
+  styleKeyEnum2,
+  styleKeyType2,
+  validateStyle2,
+  create2,
+  props2,
+  parseMediaCondition2,
+  mediaMatches2,
+  resolveConditions2,
+  activeBreakpoint2,
+  parseColor2,
+  toHex2,
+  isThemeHex2,
+  toThemeHex2,
+  luminance2,
+  contrast2,
+  RECIPE_STATES2,
+  RECIPE_KEYS2,
+  macroParts2,
+  recipeParts2,
+  nativeRecipeProps2,
+  MODES2,
+  DENSITIES2,
+  THEME_SCHEMA_ID2,
+  ThemeError2,
+  validateTheme2,
+  tryLoadTheme2,
+  loadTheme2,
+  resolveMode2,
+  applyDensity2,
+  applyContrast2,
+  resolveToken2,
+  resolveConditionKey2,
+  resolveStyleValues2,
+  recipeStyle2,
+  resolveRecipe2,
+  nodeRecipeQuery2,
+  resolveNodeStyle2,
+  shadowCss2,
+  easingCss2,
+  neutralTheme2,
+  exponentialTheme2,
+  playfulTheme2,
+  orangeTheme2,
+  BUILTIN_THEMES2,
+  BUILTIN_THEME_IDS2,
+  DEFAULT_THEME_ID2,
+  builtinTheme2,
+  themeOrDefault2,
+  builtinThemes2,
+  HOST_CONTRACT2,
+  HOST_CONTRACT_VERSION2,
+  A2UI_MESSAGE_KINDS2,
+  EXTENSION_MESSAGE_KINDS2,
+  MESSAGE_KINDS2,
+  HOST_ERROR_CODES2,
+  DEFAULT_URL_SCHEMES2,
+  DEFAULT_MEDIA_SCHEMES2,
+  MEDIA_LIMITS2,
+  PAINT_ERROR_HOOK2,
+  RENDER_FAILED2,
+  MCP_MIME_TYPES2,
+  MCP_ACTION_TOOL2,
+  SSE_EVENTS2,
+  SURFACE_SETTING_KEYS2,
+  FORMATTER_METHODS2,
+  SURFACE_COMMANDS2,
+  errorMessage2,
+  actionMessage2
+} from "./chunks/index-we7va6v6.js";
+import {
+  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
+} from "./chunks/index-98npjvsd.js";
+import {
+  style_default
+} from "./chunks/index-njt7yzzm.js";
+// packages/exponential-ui/catalog/layout.json
+var layout_default = {
+  $comment: "Round 2 (docs/round-2-contract.md §7): the layout NUMBERS every painter shares where no theme token decides (px unless noted). `windowThreshold` = items past which List and Table window; `windowOverscan` = items rendered beyond each viewport edge; `resizeStep` = percentage points per arrow key on a Resizable handle; `panelMin` = a panel's min (percent) when unset; `resizeHandleHit` = a handle's hit area across its hairline; `fieldIntrinsicWidth` = the max-content width of a text field (Input, Textarea, NumberField, ChipInput: never the browser's `size` default) — picker triggers (Select, DatePicker, DateRangePicker, TimePicker) size to their content; `mediaIntrinsicWidth` = the max-content width of an Image/Video without a width (its min-content is 0); `mediaAspectRatio` = width/height of an Image without `aspectRatio` or a height (Video: its `aspectRatio` default); `treeGuideColumn` = one TreeGuides gutter column (the recipe's `line` width is the STROKE; round 3: 14, the ×4 app indent, the elbow lands on the parent's lead glyph); `treeGuideRadius` = the elbow's corner radius; `treeGuideBridge` = how far the guide verticals overshoot the row's TOP edge (paint only) so a Section's hairline divider never breaks the line. EXP-1259 (packages/domain-contract/fixtures/feedback-states.json + search-list.json): `pendingDelayMs` = how long a `loading` Button waits before it shows the spinner and its `pendingLabel` (a fast action never flashes; presses are refused at once); `skeletonPulseMs` / `skeletonOpacityLow` / `skeletonOpacityHigh` = the placeholder's ONE opacity pulse (low → high → low, ease-in-out), `skeletonReducedOpacity` = its static opacity under reduce motion; `searchListFade` = the bottom fade over a SearchList (or a searchable submenu) while more rows sit below. Generated into every target; src/layout.ts reads it.",
+  windowThreshold: 50,
+  windowOverscan: 5,
+  resizeStep: 10,
+  panelMin: 10,
+  resizeHandleHit: 8,
+  fieldIntrinsicWidth: 160,
+  mediaIntrinsicWidth: 320,
+  mediaAspectRatio: 1.7777778,
+  treeGuideColumn: 14,
+  treeGuideRadius: 3,
+  treeGuideBridge: 1,
+  pendingDelayMs: 150,
+  skeletonPulseMs: 1600,
+  skeletonOpacityLow: 0.45,
+  skeletonOpacityHigh: 0.9,
+  skeletonReducedOpacity: 0.6,
+  searchListFade: 24
+};
+
+// packages/exponential-ui/src/layout.ts
+var LAYOUT_CONSTANTS = Object.fromEntries(Object.entries(layout_default).filter(([k]) => !k.startsWith(`$`)));
+var WINDOW_THRESHOLD = layout_default.windowThreshold;
+var WINDOW_OVERSCAN = layout_default.windowOverscan;
+var RESIZE_STEP = layout_default.resizeStep;
+var PANEL_MIN = layout_default.panelMin;
+var RESIZE_HANDLE_HIT = layout_default.resizeHandleHit;
+var FIELD_INTRINSIC_WIDTH = layout_default.fieldIntrinsicWidth;
+var MEDIA_INTRINSIC_WIDTH = layout_default.mediaIntrinsicWidth;
+var MEDIA_ASPECT_RATIO = layout_default.mediaAspectRatio;
+var TREE_GUIDE_COLUMN = layout_default.treeGuideColumn;
+var TREE_GUIDE_RADIUS = layout_default.treeGuideRadius;
+var TREE_GUIDE_BRIDGE = layout_default.treeGuideBridge;
+var PENDING_DELAY_MS = layout_default.pendingDelayMs;
+var SKELETON_PULSE_MS = layout_default.skeletonPulseMs;
+var SKELETON_OPACITY_LOW = layout_default.skeletonOpacityLow;
+var SKELETON_OPACITY_HIGH = layout_default.skeletonOpacityHigh;
+var SKELETON_REDUCED_OPACITY = layout_default.skeletonReducedOpacity;
+var SEARCH_LIST_FADE = layout_default.searchListFade;
+
+// packages/exponential-ui/src/list.ts
+function templateItemKeys(items, keyPointer) {
+  const seen = new Set;
+  return items.map((item, index) => {
+    let key = String(index);
+    if (keyPointer !== undefined) {
+      const v = readPointer2(item, keyPointer.startsWith(`/`) ? keyPointer : `/${keyPointer}`);
+      const own = v === undefined || v === null || v === `` ? null : typeof v === `object` ? JSON.stringify(v) : String(v);
+      key = own !== null && !seen.has(own) ? own : `#${index}`;
+      while (seen.has(key))
+        key = `#${key}`;
+    }
+    seen.add(key);
+    return key;
+  });
+}
+var escapeToken = (token) => token.replace(/~/g, `~0`).replace(/\//g, `~1`);
+function tableRowKeys(rows, rowKey = `id`) {
+  return templateItemKeys(rows, `/${escapeToken(rowKey)}`);
+}
+var instanceSegment = (key) => key.replace(/~/g, `~0`).replace(/\./g, `~1`);
+function templateInstances(data, template, scope = ``, instance = ``) {
+  const path = absolutePath2(template.path, { base: scope });
+  const list = readPointer2(data, path);
+  if (!Array.isArray(list))
+    return [];
+  const keys = templateItemKeys(list, template.key);
+  return list.slice(0, MAX_TEMPLATE_ITEMS2).map((_, index) => ({ key: keys[index], path: `${path}/${index}`, index, instance: `${instance}.${instanceSegment(keys[index])}` }));
+}
+var templateSiteKey = (nodeId, scope) => `${nodeId}\x00${scope}`;
+function staticSize(root) {
+  let n = 0;
+  const stack = [root];
+  while (stack.length) {
+    const node = stack.pop();
+    n++;
+    for (const slot of Object.values(node.slots ?? {}))
+      stack.push(slot);
+    for (const child of node.children)
+      stack.push(child);
+  }
+  return n;
+}
+function templateBudget(root, data, templateNode) {
+  const allowed = new Map;
+  const sizes = new Map;
+  const sizeOf = (tpl) => {
+    let n = sizes.get(tpl);
+    if (n === undefined)
+      sizes.set(tpl, n = staticSize(tpl));
+    return n;
+  };
+  let items = 0;
+  let nodes = staticSize(root);
+  let issue = null;
+  const stack = [{ node: root, scope: `` }];
+  while (stack.length) {
+    const entry = stack.pop();
+    if (`site` in entry) {
+      if (issue || entry.index >= entry.length)
+        continue;
+      if (items >= MAX_TEMPLATE_ITEMS2)
+        issue = { id: entry.component, message: LIMIT_ISSUES2.templateItems };
+      else if (nodes + entry.size > MAX_COMPONENTS2)
+        issue = { id: entry.component, message: LIMIT_ISSUES2.components };
+      if (issue)
+        continue;
+      items++;
+      nodes += entry.size;
+      allowed.set(entry.site, entry.index + 1);
+      stack.push({ ...entry, index: entry.index + 1 });
+      stack.push({ node: entry.tpl, scope: `${entry.path}/${entry.index}` });
+      continue;
+    }
+    const { node, scope } = entry;
+    const next = [];
+    for (const slot of Object.values(node.slots ?? {}))
+      next.push({ node: slot, scope });
+    for (const child of node.children)
+      next.push({ node: child, scope });
+    const template = node.template;
+    const tpl = template ? templateNode(template.component) : undefined;
+    if (template && tpl) {
+      const path = absolutePath2(template.path, { base: scope });
+      const list = readPointer2(data, path);
+      const windowed = Array.isArray(list) && node.component === `List` && node.children.length + list.length > WINDOW_THRESHOLD;
+      if (Array.isArray(list) && !windowed) {
+        const site = templateSiteKey(node.id, scope);
+        allowed.set(site, 0);
+        next.push({ site, component: template.component, tpl, path, size: sizeOf(tpl), index: 0, length: list.length });
+      }
+    }
+    for (let i = next.length - 1;i >= 0; i--)
+      stack.push(next[i]);
+  }
+  return { allowed, issue };
+}
+function itemOffsets(extents, gap = 0) {
+  const out = new Array(extents.length + 1);
+  let at = 0;
+  for (let i = 0;i < extents.length; i++) {
+    out[i] = at;
+    at += extents[i] + (i < extents.length - 1 ? gap : 0);
+  }
+  out[extents.length] = at;
+  return out;
+}
+function itemExtents(measured, row) {
+  let sum = 0;
+  let n = 0;
+  for (const m of measured) {
+    if (typeof m === `number`) {
+      sum += m;
+      n++;
+    }
+  }
+  const estimate = n ? sum / n : row;
+  return measured.map((m) => typeof m === `number` ? m : estimate);
+}
+function firstWhere(lo, hi, test) {
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (test(mid))
+      hi = mid;
+    else
+      lo = mid + 1;
+  }
+  return lo;
+}
+function virtualWindow(extents, gap, scroll, viewport, overscan = WINDOW_OVERSCAN, offsets) {
+  const count = extents.length;
+  const off = offsets ?? itemOffsets(extents, gap);
+  const total = off[count];
+  let start = firstWhere(0, count, (i) => off[i] + extents[i] >= scroll);
+  let end = firstWhere(start, count, (i) => off[i] >= scroll + viewport);
+  start = Math.max(0, start - overscan);
+  end = Math.min(count, end + overscan);
+  if (end <= start)
+    return { start, end: start, before: 0, after: total, total };
+  const before = off[start];
+  const after = total - (off[end - 1] + extents[end - 1]);
+  return { start, end, before, after, total };
+}
+function scrollOffsetForIndex(extents, gap, index, viewport, scroll, align = `nearest`, inset = 0, offsets) {
+  const off = offsets ?? itemOffsets(extents, gap);
+  const total = off[extents.length];
+  if (index < 0 || index >= extents.length)
+    return scroll;
+  const top = off[index];
+  const size = extents[index];
+  let next = scroll;
+  if (align === `start`)
+    next = top - inset;
+  else if (align === `end`)
+    next = top + size - viewport;
+  else if (align === `center`)
+    next = top + size / 2 - (viewport + inset) / 2;
+  else if (top - inset < scroll)
+    next = top - inset;
+  else if (top + size > scroll + viewport)
+    next = top + size - viewport;
+  return Math.max(0, Math.min(Math.max(0, total - viewport), next));
+}
+function listSections(items, sectionBy) {
+  const out = [];
+  const pointer = sectionBy.startsWith(`/`) ? sectionBy : `/${sectionBy}`;
+  items.forEach((item, index) => {
+    const v = readPointer2(item, pointer);
+    const value = v === undefined || v === null ? `` : typeof v === `object` ? JSON.stringify(v) : String(v);
+    const last = out[out.length - 1];
+    if (last && last.value === value)
+      last.count++;
+    else
+      out.push({ value, start: index, count: 1 });
+  });
+  return out;
+}
+function sectionRows(sections) {
+  const rows = [];
+  sections.forEach((s, i) => {
+    rows.push({ header: i });
+    for (let k = 0;k < s.count; k++)
+      rows.push({ item: s.start + k });
+  });
+  return rows;
+}
+function scrollOffsetForItem(rows, rowExtents, gap, dataIndex, viewport, scroll, align = `nearest`, stickyHeaders = false, offsets) {
+  const row = rows.findIndex((r) => (`item` in r) && r.item === dataIndex);
+  if (row < 0)
+    return scroll;
+  let header = row;
+  while (header >= 0 && !(`header` in rows[header]))
+    header--;
+  const inset = stickyHeaders && header >= 0 ? rowExtents[header] : 0;
+  return scrollOffsetForIndex(rowExtents, gap, row, viewport, scroll, align, inset, offsets);
+}
+function stickyHeader(rowOffsets, rowExtents, headerRows, scroll) {
+  const pinned = firstWhere(0, headerRows.length, (h) => rowOffsets[headerRows[h]] > scroll) - 1;
+  if (pinned < 0)
+    return null;
+  const row = headerRows[pinned];
+  const next = headerRows[pinned + 1];
+  const extent = rowExtents[row];
+  const offset = next === undefined ? scroll : Math.min(scroll, rowOffsets[next] - extent);
+  return { row, offset };
+}
+// packages/exponential-ui/src/resizable.ts
+var EPS = 0.000000001;
+var clampN = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+var tidy = (v) => {
+  const r = Math.round(v * 1e6) / 1e6;
+  return Object.is(r, -0) ? 0 : r;
+};
+function limitsOf(limits, i, count) {
+  const l = limits?.[i] ?? {};
+  const cap = 100 / Math.max(1, count);
+  const min = clampN(typeof l.min === `number` && Number.isFinite(l.min) ? l.min : PANEL_MIN, 0, cap);
+  const max = clampN(typeof l.max === `number` && Number.isFinite(l.max) ? l.max : 100, min, 100);
+  return { min, max, collapsible: l.collapsible === true };
+}
+function normalizeSizes(sizes, count, limits) {
+  if (count <= 0)
+    return [];
+  const given = Array.from({ length: count }, (_, i) => {
+    const v = sizes?.[i];
+    return typeof v === `number` && Number.isFinite(v) && v >= 0 ? v : null;
+  });
+  const missing = given.filter((v) => v === null).length;
+  let out;
+  if (missing === count)
+    out = given.map(() => 100 / count);
+  else {
+    const sum = given.reduce((s, v) => s + (v ?? 0), 0);
+    const rest = Math.max(0, 100 - sum);
+    out = given.map((v) => v ?? rest / missing);
+  }
+  const total = out.reduce((s, v) => s + v, 0);
+  out = total > EPS ? out.map((v) => v * 100 / total) : out.map(() => 100 / count);
+  const lim = out.map((_, i) => limitsOf(limits, i, count));
+  out = out.map((v, i) => lim[i].collapsible && v <= EPS ? 0 : clampN(v, lim[i].min, lim[i].max));
+  let diff = 100 - out.reduce((s, v) => s + v, 0);
+  for (let i = 0;i < count && Math.abs(diff) > EPS; i++) {
+    if (lim[i].collapsible && out[i] === 0)
+      continue;
+    const room = diff > 0 ? lim[i].max - out[i] : lim[i].min - out[i];
+    const take = diff > 0 ? Math.min(diff, room) : Math.max(diff, room);
+    out[i] += take;
+    diff -= take;
+  }
+  return out.map(tidy);
+}
+function resizePanels(sizes, handle, delta, limits) {
+  const out = [...sizes];
+  const a = handle;
+  const b = handle + 1;
+  if (a < 0 || b >= sizes.length || !Number.isFinite(delta))
+    return out.map(tidy);
+  const la = limitsOf(limits, a, sizes.length);
+  const lb = limitsOf(limits, b, sizes.length);
+  const lo = Math.max(la.min - sizes[a], sizes[b] - lb.max);
+  const hi = Math.min(la.max - sizes[a], sizes[b] - lb.min);
+  let d = clampN(delta, Math.min(lo, 0), Math.max(hi, 0));
+  if (la.collapsible && delta < 0 && sizes[a] > 0 && sizes[a] + delta < la.min / 2 && sizes[b] + sizes[a] <= lb.max + EPS)
+    d = -sizes[a];
+  else if (lb.collapsible && delta > 0 && sizes[b] > 0 && sizes[b] - delta < lb.min / 2 && sizes[a] + sizes[b] <= la.max + EPS)
+    d = sizes[b];
+  else if (la.collapsible && sizes[a] === 0)
+    d = delta >= la.min / 2 && hi >= la.min - EPS ? clampN(delta, la.min, hi) : 0;
+  else if (lb.collapsible && sizes[b] === 0)
+    d = -delta >= lb.min / 2 && -lo >= lb.min - EPS ? -clampN(-delta, lb.min, -lo) : 0;
+  out[a] = sizes[a] + d;
+  out[b] = sizes[b] - d;
+  return out.map(tidy);
+}
+function keyboardResize(sizes, handle, key, orientation, direction = `ltr`, limits) {
+  const a = handle;
+  const b = handle + 1;
+  if (a < 0 || b >= sizes.length)
+    return sizes.map(tidy);
+  const la = limitsOf(limits, a, sizes.length);
+  const lb = limitsOf(limits, b, sizes.length);
+  const flip = orientation === `horizontal` && direction === `rtl` ? -1 : 1;
+  const step = (sign) => resizePanels(sizes, handle, sign * RESIZE_STEP, limits);
+  switch (key) {
+    case `ArrowRight`:
+      return orientation === `horizontal` ? step(flip) : sizes.map(tidy);
+    case `ArrowLeft`:
+      return orientation === `horizontal` ? step(-flip) : sizes.map(tidy);
+    case `ArrowDown`:
+      return orientation === `vertical` ? step(1) : sizes.map(tidy);
+    case `ArrowUp`:
+      return orientation === `vertical` ? step(-1) : sizes.map(tidy);
+    case `Home`:
+      return resizePanels(sizes, handle, la.min - sizes[a], limits);
+    case `End`:
+      return resizePanels(sizes, handle, la.max - sizes[a], limits);
+    case `Enter`: {
+      const out = [...sizes];
+      if (la.collapsible) {
+        const d = sizes[a] > 0 ? -sizes[a] : Math.min(la.min, sizes[b] - lb.min);
+        if (sizes[b] - d > lb.max + EPS || d === 0)
+          return sizes.map(tidy);
+        out[a] += d;
+        out[b] -= d;
+      } else if (lb.collapsible) {
+        const d = sizes[b] > 0 ? sizes[b] : -Math.min(lb.min, sizes[a] - la.min);
+        if (sizes[a] + d > la.max + EPS || d === 0)
+          return sizes.map(tidy);
+        out[a] += d;
+        out[b] -= d;
+      }
+      return out.map(tidy);
+    }
+    default:
+      return sizes.map(tidy);
+  }
+}
+function panelExtents(sizes, container, handleExtent = 1) {
+  const avail = Math.max(0, container - Math.max(0, sizes.length - 1) * handleExtent);
+  return sizes.map((s) => tidy(avail * s / 100));
+}
+function dragDelta(px, container, panelCount, orientation, direction = `ltr`, handleExtent = 1) {
+  const avail = Math.max(1, container - Math.max(0, panelCount - 1) * handleExtent);
+  const flip = orientation === `horizontal` && direction === `rtl` ? -1 : 1;
+  return tidy(px * 100 / avail * flip);
+}
+// packages/exponential-ui/src/direction.ts
+function ownDirection(node, ctx) {
+  if (!node.style)
+    return;
+  const style = ctx ? resolveConditions2(node.style, ctx) : node.style;
+  const d = style.direction;
+  return d === `ltr` || d === `rtl` ? d : undefined;
+}
+function nodeDirections(root, surface, ctx) {
+  const out = {};
+  const walk = (n, inherited) => {
+    const dir = ownDirection(n, ctx) ?? inherited;
+    out[n.id] = dir;
+    for (const slot of Object.values(n.slots ?? {}))
+      walk(slot, dir);
+    for (const child of n.children)
+      walk(child, dir);
+  };
+  walk(root, surface);
+  return out;
+}
+function physicalTextAlign(align, direction) {
+  switch (align) {
+    case `left`:
+    case `right`:
+    case `center`:
+    case `justify`:
+      return align;
+    case `end`:
+      return direction === `rtl` ? `left` : `right`;
+    default:
+      return direction === `rtl` ? `right` : `left`;
+  }
+}
+function nodeTextAlign(node, direction, ctx) {
+  const style = node.style ? ctx ? resolveConditions2(node.style, ctx) : node.style : {};
+  return physicalTextAlign(style.textAlign ?? node.props.align, direction);
+}
+// packages/exponential-ui/src/animation.ts
+var ANIMATIONS = Object.fromEntries(Object.entries(style_default.animations).filter(([k]) => !k.startsWith(`$`)));
+var ANIMATION_NAMES = Object.keys(ANIMATIONS);
+var LINEAR = `linear`;
+function animationTiming(name, theme, durationToken) {
+  const def = ANIMATIONS[name];
+  if (!def)
+    return null;
+  const token = parseTokenRef2(durationToken ?? def.duration);
+  const base = token && token.group === `motion` ? theme.tokens.motion[token.name] : undefined;
+  const fallback = parseTokenRef2(def.duration);
+  const ms = (base ?? (fallback ? theme.tokens.motion[fallback.name] : 0) ?? 0) * def.factor;
+  const ease = parseTokenRef2(def.easing);
+  const easing = def.easing === LINEAR ? LINEAR : ease && ease.group === `ease` ? theme.tokens.ease[ease.name] ?? LINEAR : LINEAR;
+  return { durationMs: ms, easing, iterations: def.iterations };
+}
+function cubicBezier(curve, x) {
+  const [x1, y1, x2, y2] = curve;
+  if (x <= 0)
+    return 0;
+  if (x >= 1)
+    return 1;
+  const bx = (t) => 3 * x1 * t * (1 - t) ** 2 + 3 * x2 * t * t * (1 - t) + t ** 3;
+  const by = (t) => 3 * y1 * t * (1 - t) ** 2 + 3 * y2 * t * t * (1 - t) + t ** 3;
+  let lo = 0;
+  let hi = 1;
+  for (let i = 0;i < 60; i++) {
+    const mid = (lo + hi) / 2;
+    if (bx(mid) < x)
+      lo = mid;
+    else
+      hi = mid;
+  }
+  return by((lo + hi) / 2);
+}
+var CHANNELS = [`opacity`, `translateX`, `translateY`, `rotate`, `scale`];
+var REST = { opacity: 1, translateX: 0, translateY: 0, rotate: 0, scale: 1, band: null };
+var r4 = (v) => {
+  const r = Math.round(v * 1e4) / 1e4;
+  return Object.is(r, -0) ? 0 : r;
+};
+function frameAt(def, progress, easing) {
+  const ks = def.keyframes;
+  let k = 0;
+  while (k < ks.length - 2 && progress > ks[k + 1].offset)
+    k++;
+  const a = ks[k];
+  const b = ks[Math.min(k + 1, ks.length - 1)];
+  const span = b.offset - a.offset;
+  const local = span > 0 ? Math.max(0, Math.min(1, (progress - a.offset) / span)) : 1;
+  const t = easing === LINEAR ? local : cubicBezier(easing, local);
+  const out = { ...REST };
+  for (const ch of CHANNELS) {
+    const va = a[ch] ?? REST[ch];
+    const vb = b[ch] ?? REST[ch];
+    out[ch] = r4(va + (vb - va) * t);
+  }
+  if (a.band !== undefined && b.band !== undefined)
+    out.band = r4(a.band + (b.band - a.band) * t);
+  return out;
+}
+function animationFrame(name, elapsedMs, theme, options = {}) {
+  const def = ANIMATIONS[name];
+  const timing = animationTiming(name, theme, options.durationToken);
+  if (!def || !timing)
+    return null;
+  if (options.reducedMotion) {
+    const rest = frameAt(def, def.rest, LINEAR);
+    return { ...rest, band: null };
+  }
+  const d = timing.durationMs;
+  if (d <= 0)
+    return frameAt(def, 1, LINEAR);
+  const iterations = timing.iterations === `infinite` ? Infinity : timing.iterations;
+  const t = Math.max(0, elapsedMs);
+  if (t >= d * iterations)
+    return frameAt(def, 1, timing.easing);
+  return frameAt(def, t % d / d, timing.easing);
+}
+function paintedOpacity(own, frame) {
+  return r4((own ?? 1) * (frame?.opacity ?? 1));
+}
+var css = (n) => String(r4(n));
+var ANIMATION_PROPERTIES_CSS = `@property --xui-a-opacity{syntax:"<number>";inherits:false;initial-value:1}@property --xui-band{syntax:"<number>";inherits:true;initial-value:1}`;
+function animatesOpacity(name) {
+  return ANIMATIONS[name]?.keyframes.some((k) => k.opacity !== undefined) ?? false;
+}
+function keyframesCss(name) {
+  const def = ANIMATIONS[name];
+  if (!def)
+    return ``;
+  const steps = def.keyframes.map((k) => {
+    const decl = [];
+    if (k.opacity !== undefined)
+      decl.push(`--xui-a-opacity:${css(k.opacity)}`);
+    if (k.translateX !== undefined || k.translateY !== undefined)
+      decl.push(`translate:${css(k.translateX ?? 0)}px ${css(k.translateY ?? 0)}px`);
+    if (k.rotate !== undefined)
+      decl.push(`rotate:${css(k.rotate)}deg`);
+    if (k.scale !== undefined)
+      decl.push(`scale:${css(k.scale)}`);
+    if (k.band !== undefined)
+      decl.push(`--xui-band:${css(k.band)}`);
+    return `${css(k.offset * 100)}%{${decl.join(`;`)}}`;
+  });
+  return `@keyframes xui-${name}{${steps.join(``)}}`;
+}
+function animationCss(name, timing) {
+  const easing = timing.easing === LINEAR ? `linear` : `cubic-bezier(${timing.easing.join(`, `)})`;
+  const iterations = timing.iterations === `infinite` ? `infinite` : String(timing.iterations);
+  return `xui-${name} ${timing.durationMs}ms ${easing} ${iterations} both`;
+}
+// packages/exponential-ui/src/locale.ts
+var DEFAULT_LOCALE = locale_default.default;
+var ALIASES = locale_default.languageAliases;
+function parseLocale(locale) {
+  const tags = locale.replace(/_/g, `-`).split(`-`).filter(Boolean);
+  const raw = (tags[0] ?? ``).toLowerCase();
+  const language = ALIASES[raw] ?? raw;
+  const region = tags.slice(1).find((t) => /^[A-Za-z]{2}$|^\d{3}$/.test(t));
+  return { language, region: region ? region.toUpperCase() : null };
+}
+var WEEK_START_BY_REGION = (() => {
+  const out = {};
+  for (const [day, regions] of Object.entries(locale_default.weekStart.regions))
+    for (const r of regions)
+      out[r] = Number(day);
+  return out;
+})();
+function localeRegion(locale) {
+  const { language, region } = parseLocale(locale);
+  return region ?? locale_default.likelyRegion[language] ?? null;
+}
+function weekStart(locale) {
+  const r = localeRegion(locale);
+  return r !== null && r in WEEK_START_BY_REGION ? WEEK_START_BY_REGION[r] : locale_default.weekStart.default;
+}
+function textDirection(locale) {
+  return locale_default.rtl.includes(parseLocale(locale).language) ? `rtl` : `ltr`;
+}
+var RTL_MIRRORED_ICONS = locale_default.rtlMirroredIcons;
+function mirrorsInRtl(icon, direction) {
+  return direction === `rtl` && RTL_MIRRORED_ICONS.includes(icon);
+}
+// packages/exponential-ui/catalog/code.json
+var code_default = {
+  $comment: "Round 1 (docs/round-1-contract.md §3, CodeBlock): the BUILT-IN tokenizer every renderer mirrors so a CodeBlock colours the same on every platform (a host may still supply its own tokenizer; its kinds must be the `codeToken` enum). ONE scanner over the source (CRLF → LF), first rule that matches at the position wins: (1) `lineKinds` — at a line start (after spaces/tabs) a listed prefix makes the rest of the line that kind; (2) `lineComment` prefixes → comment to the end of the line; (3) `blockComment` [open, close] pairs → comment through close (or the end); (4) a quote in `strings` → string through the same unescaped quote (`\\` escapes the next char), stopping before a line break unless the quote is in `multiline`; with `keyStrings` a string followed by optional spaces and `:` is a `property`; (5) with `markup`, `<` followed by a letter, `/` or `!` opens a tag: `<`/`</` punctuation, the name `tag`, then whitespace plain, quotes string, `=` operator, names `attribute`, until `>`/`/>` punctuation (text outside tags is plain); (6) numbers (unless `numbers` is false): a digit, or `.` before a digit, then every [0-9A-Za-z_.]; (7) identifiers: [A-Za-z_$] plus `identExtra`, then the same plus digits: `keywords` (lower-cased first when `caseInsensitive`) → keyword; with `keyIdents` followed by spaces and a single `:` → property; followed by spaces and `(` → function; right after a `.` punctuation → property; in `typeNames` or (with `types: capitalized`) starting A–Z → type; else plain; (8) a run of spaces/tabs → plain; (9) a run of `operators` chars → operator; (10) one `punctuation` char → punctuation; (11) anything else, one char → plain. Then tokens split at line breaks into LINES and adjacent tokens of one kind merge; a line's tokens concatenate to exactly its text. src/code.ts is the reference, fixtures/code-tokens.json locks it. EXP-1324 `ansi` (the Terminal pattern: command output): BEFORE the scanner, every ANSI CSI escape (ESC `[` params 0x30-0x3F, intermediates 0x20-0x2F, one final 0x40-0x7E) is REMOVED from the source and the remaining text is split into runs by SGR (final `m`) colour: params 31/91 → `error`, 32/92 → `success`, 33/93 → `warning`, 2/90 → `comment`, 0/39/none → no colour, every other param leaves the colour as it was (params apply left to right). A run WITH a colour is that kind, verbatim (no rules). Runs without a colour go through the ordinary scanner with this language spec — which has only `lineKinds` (longest listed prefix wins), so an uncoloured line is either one lineKinds kind from its prefix on, or plain. Tokens then split into lines and merge as usual. The escapes never reach the text: a line's tokens concatenate to its text WITHOUT them (copy copies that text).",
+  defaults: { operators: "+-*/%=&|<>!?^~:@#", punctuation: "()[]{},.;" },
+  languages: {
+    plain: { plain: true },
+    json: { strings: ['"'], keywords: ["true", "false", "null"], keyStrings: true },
+    js: {
+      lineComment: ["//"],
+      blockComment: [["/*", "*/"]],
+      strings: ['"', "'", "`"],
+      multiline: ["`"],
+      types: "capitalized",
+      keywords: ["async", "await", "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do", "else", "export", "extends", "false", "finally", "for", "from", "function", "if", "import", "in", "instanceof", "let", "new", "null", "of", "return", "static", "super", "switch", "this", "throw", "true", "try", "typeof", "undefined", "var", "void", "while", "with", "yield"]
+    },
+    ts: {
+      lineComment: ["//"],
+      blockComment: [["/*", "*/"]],
+      strings: ['"', "'", "`"],
+      multiline: ["`"],
+      types: "capitalized",
+      typeNames: ["any", "bigint", "boolean", "never", "number", "object", "string", "symbol", "unknown"],
+      keywords: ["abstract", "as", "async", "await", "break", "case", "catch", "class", "const", "continue", "declare", "default", "delete", "do", "else", "enum", "export", "extends", "false", "finally", "for", "from", "function", "if", "implements", "import", "in", "infer", "instanceof", "interface", "is", "keyof", "let", "namespace", "new", "null", "of", "private", "protected", "public", "readonly", "return", "satisfies", "static", "super", "switch", "this", "throw", "true", "try", "type", "typeof", "undefined", "var", "void", "while", "yield"]
+    },
+    tsx: {
+      lineComment: ["//"],
+      blockComment: [["/*", "*/"]],
+      strings: ['"', "'", "`"],
+      multiline: ["`"],
+      types: "capitalized",
+      typeNames: ["any", "bigint", "boolean", "never", "number", "object", "string", "symbol", "unknown"],
+      keywords: ["abstract", "as", "async", "await", "break", "case", "catch", "class", "const", "continue", "declare", "default", "delete", "do", "else", "enum", "export", "extends", "false", "finally", "for", "from", "function", "if", "implements", "import", "in", "infer", "instanceof", "interface", "is", "keyof", "let", "namespace", "new", "null", "of", "private", "protected", "public", "readonly", "return", "satisfies", "static", "super", "switch", "this", "throw", "true", "try", "type", "typeof", "undefined", "var", "void", "while", "yield"]
+    },
+    rust: {
+      lineComment: ["//"],
+      blockComment: [["/*", "*/"]],
+      strings: ['"'],
+      multiline: ['"'],
+      types: "capitalized",
+      typeNames: ["bool", "char", "f32", "f64", "i8", "i16", "i32", "i64", "i128", "isize", "str", "u8", "u16", "u32", "u64", "u128", "usize"],
+      keywords: ["as", "async", "await", "break", "const", "continue", "crate", "dyn", "else", "enum", "extern", "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod", "move", "mut", "pub", "ref", "return", "self", "Self", "static", "struct", "super", "trait", "true", "type", "unsafe", "use", "where", "while"]
+    },
+    swift: {
+      lineComment: ["//"],
+      blockComment: [["/*", "*/"]],
+      strings: ['"'],
+      types: "capitalized",
+      keywords: ["any", "as", "associatedtype", "async", "await", "break", "case", "catch", "class", "continue", "default", "defer", "do", "else", "enum", "extension", "fallthrough", "false", "for", "func", "guard", "if", "import", "in", "init", "inout", "internal", "is", "let", "nil", "private", "protocol", "public", "repeat", "rethrows", "return", "self", "Self", "some", "static", "struct", "subscript", "super", "switch", "throw", "throws", "true", "try", "typealias", "var", "where", "while"]
+    },
+    kotlin: {
+      lineComment: ["//"],
+      blockComment: [["/*", "*/"]],
+      strings: ['"', "'"],
+      types: "capitalized",
+      keywords: ["as", "break", "by", "catch", "class", "companion", "constructor", "continue", "data", "do", "else", "enum", "false", "finally", "for", "fun", "if", "import", "in", "init", "interface", "internal", "is", "lateinit", "null", "object", "open", "override", "package", "private", "protected", "public", "return", "sealed", "super", "suspend", "this", "throw", "true", "try", "typealias", "val", "var", "when", "while"]
+    },
+    python: {
+      lineComment: ["#"],
+      strings: ['"', "'"],
+      types: "capitalized",
+      keywords: ["False", "None", "True", "and", "as", "assert", "async", "await", "break", "class", "continue", "def", "del", "elif", "else", "except", "finally", "for", "from", "global", "if", "import", "in", "is", "lambda", "nonlocal", "not", "or", "pass", "raise", "return", "self", "try", "while", "with", "yield"]
+    },
+    bash: {
+      lineComment: ["#"],
+      strings: ['"', "'"],
+      multiline: ['"', "'"],
+      keywords: ["case", "do", "done", "echo", "elif", "else", "esac", "exit", "export", "fi", "for", "function", "if", "in", "local", "readonly", "return", "then", "until", "while"]
+    },
+    html: { markup: true, blockComment: [["<!--", "-->"]], strings: ['"', "'"], numbers: false },
+    css: {
+      blockComment: [["/*", "*/"]],
+      strings: ['"', "'"],
+      identExtra: "-@",
+      keyIdents: true,
+      operators: "+*/%=&|<>!?^~:#",
+      keywords: ["@container", "@font-face", "@import", "@keyframes", "@layer", "@media", "@supports", "auto", "important", "inherit", "initial", "none", "unset"]
+    },
+    sql: {
+      lineComment: ["--"],
+      blockComment: [["/*", "*/"]],
+      strings: ["'", '"'],
+      caseInsensitive: true,
+      keywords: ["all", "alter", "and", "as", "asc", "between", "by", "case", "create", "default", "delete", "desc", "distinct", "drop", "else", "end", "exists", "foreign", "from", "group", "having", "in", "index", "inner", "insert", "into", "is", "join", "key", "left", "like", "limit", "not", "null", "offset", "on", "or", "order", "outer", "primary", "references", "returning", "right", "select", "set", "table", "then", "union", "update", "values", "when", "where", "with"]
+    },
+    yaml: { lineComment: ["#"], strings: ['"', "'"], keyIdents: true, identExtra: "-", keywords: ["true", "false", "null", "yes", "no"] },
+    markdown: { lineKinds: { "#": "keyword", ">": "comment" }, strings: ["`"], numbers: false, operators: "", punctuation: "" },
+    ansi: {
+      ansi: true,
+      numbers: false,
+      operators: "",
+      punctuation: "",
+      lineKinds: { "$ ": "comment", "> ": "comment", "BUILD SUCCESSFUL": "success", "BUILD FAILED": "error", "PASS ": "success", "FAIL ": "error", FAILED: "error", "(pass)": "success", "(fail)": "error", "test result: ok": "success", "test result: FAILED": "error", "error:": "error", "error[": "error", "Error:": "error", "warning:": "warning", "✓": "success", "✔": "success", "✗": "error", "✘": "error" }
+    }
+  }
+};
+
+// packages/exponential-ui/src/code.ts
+var CODE_LANGUAGES = code_default.languages;
+var CODE_LANGUAGE_NAMES = Object.keys(CODE_LANGUAGES);
+var isDigit = (c) => c !== undefined && c >= `0` && c <= `9`;
+var isAlpha = (c) => c !== undefined && (c >= `a` && c <= `z` || c >= `A` && c <= `Z`);
+var isSpace = (c) => c === ` ` || c === `	`;
+function nextNonSpace(code, j) {
+  let k = j;
+  while (isSpace(code[k]))
+    k++;
+  return code[k];
+}
+function scan(code, spec, lineStart = true) {
+  const out = [];
+  const n = code.length;
+  const operators = spec.operators ?? code_default.defaults.operators;
+  const punctuation = spec.punctuation ?? code_default.defaults.punctuation;
+  const extra = spec.identExtra ?? ``;
+  const identStart = (c) => isAlpha(c) || c === `_` || c === `$` || c !== undefined && extra.includes(c);
+  const identPart = (c) => identStart(c) || isDigit(c);
+  const keywords = new Set(spec.keywords ?? []);
+  const typeNames = new Set(spec.typeNames ?? []);
+  const push = (kind, text) => out.push({ kind, text });
+  const lastSignificant = () => {
+    for (let k = out.length - 1;k >= 0; k--)
+      if (out[k].text.trim() !== ``)
+        return out[k];
+    return;
+  };
+  if (spec.plain)
+    return code ? [{ kind: `plain`, text: code }] : [];
+  let i = 0;
+  let inTag = false;
+  while (i < n) {
+    const c = code[i];
+    if (c === `
+`) {
+      push(`plain`, c);
+      i++;
+      continue;
+    }
+    if (spec.lineKinds && (i === 0 ? lineStart : code[i - 1] === `
+` || isSpaceRunToLineStart(code, i, lineStart))) {
+      let prefix;
+      for (const p of Object.keys(spec.lineKinds))
+        if (code.startsWith(p, i) && (!prefix || p.length > prefix.length))
+          prefix = p;
+      if (prefix && !isSpace(c)) {
+        let j = i;
+        while (j < n && code[j] !== `
+`)
+          j++;
+        push(spec.lineKinds[prefix], code.slice(i, j));
+        i = j;
+        continue;
+      }
+    }
+    const line = !inTag ? (spec.lineComment ?? []).find((p) => code.startsWith(p, i)) : undefined;
+    if (line) {
+      let j = i;
+      while (j < n && code[j] !== `
+`)
+        j++;
+      push(`comment`, code.slice(i, j));
+      i = j;
+      continue;
+    }
+    const block = !inTag ? (spec.blockComment ?? []).find(([open]) => code.startsWith(open, i)) : undefined;
+    if (block) {
+      const end = code.indexOf(block[1], i + block[0].length);
+      const j = end < 0 ? n : end + block[1].length;
+      push(`comment`, code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if ((spec.strings ?? []).includes(c) && (!spec.markup || inTag)) {
+      const multi = (spec.multiline ?? []).includes(c);
+      let j = i + 1;
+      while (j < n) {
+        if (code[j] === `\\`) {
+          j += 2;
+          continue;
+        }
+        if (code[j] === c) {
+          j++;
+          break;
+        }
+        if (code[j] === `
+` && !multi)
+          break;
+        j++;
+      }
+      j = Math.min(j, n);
+      const kind = spec.keyStrings && nextNonSpace(code, j) === `:` ? `property` : `string`;
+      push(kind, code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (spec.markup) {
+      if (!inTag) {
+        if (c === `<` && (isAlpha(code[i + 1]) || code[i + 1] === `/` || code[i + 1] === `!`)) {
+          const open = code[i + 1] === `/` ? `</` : `<`;
+          push(`punctuation`, open);
+          let j = i + open.length;
+          const start = j;
+          while (j < n && (isAlpha(code[j]) || isDigit(code[j]) || code[j] === `-` || code[j] === `:` || code[j] === `!`))
+            j++;
+          if (j > start)
+            push(`tag`, code.slice(start, j));
+          inTag = true;
+          i = j;
+          continue;
+        }
+        let j = i;
+        while (j < n && code[j] !== `<` && code[j] !== `
+`)
+          j++;
+        if (j === i)
+          j = i + 1;
+        push(`plain`, code.slice(i, j));
+        i = j;
+        continue;
+      }
+      if (c === `>` || code.startsWith(`/>`, i)) {
+        const close = c === `>` ? `>` : `/>`;
+        push(`punctuation`, close);
+        inTag = false;
+        i += close.length;
+        continue;
+      }
+      if (c === `=`) {
+        push(`operator`, c);
+        i++;
+        continue;
+      }
+      if (isAlpha(c) || c === `_` || c === `:` || c === `@`) {
+        let j = i;
+        while (j < n && (isAlpha(code[j]) || isDigit(code[j]) || `_:@.-`.includes(code[j])))
+          j++;
+        push(`attribute`, code.slice(i, j));
+        i = j;
+        continue;
+      }
+      if (isSpace(c)) {
+        let j = i;
+        while (isSpace(code[j]))
+          j++;
+        push(`plain`, code.slice(i, j));
+        i = j;
+        continue;
+      }
+      push(`plain`, c);
+      i++;
+      continue;
+    }
+    if (spec.numbers !== false && (isDigit(c) || c === `.` && isDigit(code[i + 1]))) {
+      let j = i + 1;
+      while (j < n && (isDigit(code[j]) || isAlpha(code[j]) || code[j] === `_` || code[j] === `.`))
+        j++;
+      push(`number`, code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (identStart(c)) {
+      let j = i + 1;
+      while (j < n && identPart(code[j]))
+        j++;
+      const word = code.slice(i, j);
+      const key = spec.caseInsensitive ? word.toLowerCase() : word;
+      const next = nextNonSpace(code, j);
+      const after = (() => {
+        let k = j;
+        while (isSpace(code[k]))
+          k++;
+        return code[k + 1];
+      })();
+      const prev = lastSignificant();
+      let kind = `plain`;
+      if (keywords.has(key))
+        kind = `keyword`;
+      else if (spec.keyIdents && next === `:` && after !== `:`)
+        kind = `property`;
+      else if (next === `(`)
+        kind = `function`;
+      else if (prev && prev.kind === `punctuation` && prev.text.endsWith(`.`))
+        kind = `property`;
+      else if (typeNames.has(word) || spec.types === `capitalized` && word[0] >= `A` && word[0] <= `Z`)
+        kind = `type`;
+      push(kind, word);
+      i = j;
+      continue;
+    }
+    if (isSpace(c)) {
+      let j = i;
+      while (isSpace(code[j]))
+        j++;
+      push(`plain`, code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (operators.includes(c)) {
+      let j = i;
+      while (j < n && operators.includes(code[j]))
+        j++;
+      push(`operator`, code.slice(i, j));
+      i = j;
+      continue;
+    }
+    push(punctuation.includes(c) ? `punctuation` : `plain`, c);
+    i++;
+  }
+  return out;
+}
+function isSpaceRunToLineStart(code, i, lineStart = true) {
+  let k = i - 1;
+  while (k >= 0 && isSpace(code[k]))
+    k--;
+  return k < 0 ? lineStart : code[k] === `
+`;
+}
+var isCsiParam = (c) => c >= 48 && c <= 63;
+var isCsiIntermediate = (c) => c >= 32 && c <= 47;
+var isCsiFinal = (c) => c >= 64 && c <= 126;
+function sgrKind(params, kind) {
+  let out = kind;
+  for (const raw of params.split(`;`)) {
+    const p = raw === `` ? 0 : Number(raw);
+    if (p === 0 || p === 39)
+      out = null;
+    else if (p === 31 || p === 91)
+      out = `error`;
+    else if (p === 32 || p === 92)
+      out = `success`;
+    else if (p === 33 || p === 93)
+      out = `warning`;
+    else if (p === 2 || p === 90)
+      out = `comment`;
+  }
+  return out;
+}
+function ansiRuns(source) {
+  const runs = [];
+  let kind = null;
+  let text = ``;
+  const flush = () => {
+    if (text === ``)
+      return;
+    const last = runs[runs.length - 1];
+    if (last && last.kind === kind)
+      last.text += text;
+    else
+      runs.push({ kind, text });
+    text = ``;
+  };
+  let i = 0;
+  const n = source.length;
+  while (i < n) {
+    if (source.charCodeAt(i) === 27 && source[i + 1] === `[`) {
+      let j = i + 2;
+      while (j < n && isCsiParam(source.charCodeAt(j)))
+        j++;
+      const params = source.slice(i + 2, j);
+      while (j < n && isCsiIntermediate(source.charCodeAt(j)))
+        j++;
+      if (j < n && isCsiFinal(source.charCodeAt(j))) {
+        if (source[j] === `m`) {
+          const next = sgrKind(params, kind);
+          if (next !== kind) {
+            flush();
+            kind = next;
+          }
+        }
+        i = j + 1;
+        continue;
+      }
+    }
+    text += source[i];
+    i++;
+  }
+  flush();
+  return runs;
+}
+function scanAnsi(code, spec) {
+  const out = [];
+  let atLine = true;
+  for (const run of ansiRuns(code)) {
+    if (run.kind)
+      out.push({ kind: run.kind, text: run.text });
+    else
+      out.push(...scan(run.text, spec, atLine));
+    atLine = isSpaceRunToLineStart(run.text, run.text.length, atLine);
+  }
+  return out;
+}
+function codeText(source, language) {
+  const code = source.replace(/\r\n?/g, `
+`);
+  return CODE_LANGUAGES[language]?.ansi ? ansiRuns(code).map((r) => r.text).join(``) : code;
+}
+function tokenizeCode(source, language) {
+  const code = source.replace(/\r\n?/g, `
+`);
+  const spec = CODE_LANGUAGES[language] ?? CODE_LANGUAGES.plain;
+  const lines = [[]];
+  for (const token of spec.ansi ? scanAnsi(code, spec) : scan(code, spec)) {
+    const pieces = token.text.split(`
+`);
+    pieces.forEach((piece, index) => {
+      if (index > 0)
+        lines.push([]);
+      if (piece === ``)
+        return;
+      const line = lines[lines.length - 1];
+      const last = line[line.length - 1];
+      if (last && last.kind === token.kind)
+        last.text += piece;
+      else
+        line.push({ kind: token.kind, text: piece });
+    });
+  }
+  return lines;
+}
+// packages/exponential-ui/src/text-shimmer.ts
+var TEXT_SHIMMER = style_default.textShimmer;
+var toLinear = (c) => c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+var toGamma = (c) => {
+  const x = Math.max(0, Math.min(1, c));
+  return x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055;
+};
+function rgbToOklab(r, g, b) {
+  const [lr, lg, lb] = [toLinear(r / 255), toLinear(g / 255), toLinear(b / 255)];
+  const l = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
+  const m = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
+  const s = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
+  return [
+    0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
+  ];
+}
+function oklabToRgb([L, a, b]) {
+  const l = Math.pow(L + 0.3963377774 * a + 0.2158037573 * b, 3);
+  const m = Math.pow(L - 0.1055613458 * a - 0.0638541728 * b, 3);
+  const s = Math.pow(L - 0.0894841775 * a - 1.291485548 * b, 3);
+  return [
+    toGamma(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s) * 255,
+    toGamma(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s) * 255,
+    toGamma(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s) * 255
+  ];
+}
+var hex = (lab, alpha) => {
+  const [r, g, b] = oklabToRgb(lab);
+  return toHex2({ r, g, b, a: alpha });
+};
+function textShimmer(color, dark) {
+  const t = TEXT_SHIMMER;
+  const c = parseColor2(color) ?? { r: 0, g: 0, b: 0, a: 1 };
+  const base = rgbToOklab(c.r, c.g, c.b);
+  let high = base;
+  let highAlpha = c.a * t.lightAlphaFactor;
+  if (dark) {
+    high = [Math.min(1, Math.max(t.highlightLightnessMin, base[0] + t.highlightLightnessBoost)), base[1], base[2]];
+    highAlpha = Math.min(1, c.a + t.highlightAlphaBoost);
+  }
+  const sum = c.a + highAlpha;
+  const mid = sum > 0 ? [0, 1, 2].map((i) => (base[i] * c.a + high[i] * highAlpha) / sum) : base;
+  return {
+    base: toHex2(c),
+    highlight: hex(high, highAlpha),
+    mid: hex(mid, sum / 2),
+    durationMs: t.durationMs,
+    angleDeg: t.angleDeg,
+    spreadPx: t.spreadPx
+  };
+}
+// packages/exponential-ui/catalog/a11y.json
+var a11y_default = {
+  $comment: "Round 1 (docs/round-1-contract.md §6): the ACCESSIBILITY contract every renderer keeps. `roles` = the MACHINE-READABLE role vocabulary (ARIA names, plus `text` = static text and `hidden` = out of the accessibility tree; SwiftUI traits / Compose semantics / AccessKit roles map from them), used by every `role` here and by the expanded tree's `accessibility.role`. `components` = per component its `role` (one of `roles`: the role of the component's main accessible object), `notes` (prose: composite parts, states, which strings name it) and the KEYBOARD expectations, one line per key group (arrows flip in RTL; a roving tab stop = one Tab stop for the group, arrows move inside it). Every component is listed (round1.test.ts gates it). `commands` = what a HOST may ask of a surface at runtime. `rules` = what holds for every component. Round 2 (docs/round-2-contract.md): Resizable, `scrollToIndex`, sections, the per-node direction rule. Append-only; docs/components.generated.json carries each component's entry.",
+  roles: [
+    "alert",
+    "alertdialog",
+    "banner",
+    "button",
+    "checkbox",
+    "combobox",
+    "dialog",
+    "document",
+    "form",
+    "group",
+    "heading",
+    "hidden",
+    "img",
+    "link",
+    "list",
+    "listitem",
+    "main",
+    "menu",
+    "meter",
+    "navigation",
+    "none",
+    "progressbar",
+    "radio",
+    "radiogroup",
+    "region",
+    "separator",
+    "slider",
+    "spinbutton",
+    "status",
+    "switch",
+    "tablist",
+    "table",
+    "text",
+    "textbox",
+    "tooltip",
+    "tree",
+    "treeitem"
+  ],
+  rules: [
+    "Every interactive node is reachable by Tab in reading order (tree order; a node's resolved `direction` flips its rows) and shows a focus ring only for keyboard focus (`:focus-visible`, recipe state `focus`).",
+    "A field's label, description and every error are linked to it (aria-labelledby / aria-describedby, contentDescription, accessibilityLabel/Hint); an error has the id `<node id>.error`.",
+    "`visible: false` removes the node from the accessibility tree; `visibility: hidden` hides it too; `display: none` likewise.",
+    "Icon-only buttons and standalone Icons take their `label` (or `accessibility.label`) as the accessible name; decorative icons are hidden.",
+    "`accessibility.label`/`description` on any node override the computed name/description.",
+    "Animations honour reduced motion: with `prefers-reduced-motion: reduce` transitions run at 0 ms, the Spinner/Skeleton shimmer stops and every style `animation` shows its rest keyframe.",
+    "Text and accessible names follow the NODE's direction (an inner `direction` box included): reading order, `textAlign` start/end and the bidi paragraph direction."
+  ],
+  commands: {
+    focus: {
+      args: [
+        "id"
+      ],
+      description: "Moves keyboard focus to the node with this id (the first focusable descendant of a non-focusable node); ignored when it is not rendered."
+    },
+    announce: {
+      args: [
+        "text",
+        "live"
+      ],
+      description: "Speaks the text through the platform's live region (`polite` waits, `assertive` interrupts) without showing anything."
+    },
+    scrollIntoView: {
+      args: [
+        "id"
+      ],
+      description: "Scrolls the nearest scrolling ancestor (List, ScrollArea, the surface) so the node is visible."
+    },
+    scrollToIndex: {
+      args: [
+        "id",
+        "index",
+        "align"
+      ],
+      description: "Scrolls the List or Table `id` so its item (data index, before any local sort) is in view: `align` start | center | end | nearest (default), the pinned section header subtracted; a windowed list renders it first (src/list.ts scrollOffsetForIndex)."
+    }
+  },
+  components: {
+    Box: {
+      role: "none",
+      notes: "group (button when pressable). A pressable Box is a button.",
+      keys: [
+        "Enter, Space: press (pressable only)"
+      ]
+    },
+    Stack: {
+      role: "none",
+      notes: "none (layout only)",
+      keys: []
+    },
+    Grid: {
+      role: "none",
+      notes: "none (layout only)",
+      keys: []
+    },
+    Card: {
+      role: "group",
+      notes: "group labelled by its title",
+      keys: []
+    },
+    Separator: {
+      role: "separator",
+      notes: "separator",
+      keys: []
+    },
+    ScrollArea: {
+      role: "region",
+      notes: "region (scrollable, focusable when it overflows)",
+      keys: [
+        "Arrow keys, PageUp/PageDown, Home/End scroll while focused"
+      ]
+    },
+    Section: {
+      role: "group",
+      notes: "group; the header a heading (level 3) with the caption and count in its name, or a button with aria-expanded when collapsible; the rows a list (a tree when `tree`) of listitems",
+      keys: [
+        "Enter, Space: fold when collapsible"
+      ]
+    },
+    Group: {
+      role: "group",
+      notes: "group labelled by its title, described by its footer",
+      keys: []
+    },
+    Heading: {
+      role: "heading",
+      notes: "heading (level from h1–h4)",
+      keys: []
+    },
+    Kbd: {
+      role: "text",
+      notes: "text (the shortcut spelled out)",
+      keys: []
+    },
+    Label: {
+      role: "text",
+      notes: "label of the control named by `for`",
+      keys: [
+        "Pressing it focuses that control"
+      ]
+    },
+    Badge: {
+      role: "text",
+      notes: "text (status)",
+      keys: []
+    },
+    Alert: {
+      role: "alert",
+      notes: "alert for warning/error, status otherwise. alert for warning/error, status otherwise ($a11y).",
+      keys: []
+    },
+    EmptyState: {
+      role: "status",
+      notes: "status; the action = button",
+      keys: [
+        "Enter, Space on the action"
+      ]
+    },
+    Progress: {
+      role: "progressbar",
+      notes: "progressbar (valuenow/valuemax, labelled by its label)",
+      keys: []
+    },
+    Meter: {
+      role: "meter",
+      notes: "meter (value of max, labelled by its label)",
+      keys: []
+    },
+    Sparkline: {
+      role: "img",
+      notes: "img with a generated summary (first, last, min, max). The Chart painter names it with `sparklineSummary` (first, last, min, max).",
+      keys: []
+    },
+    List: {
+      role: "list",
+      notes: "list; each item a listitem with its position in the WHOLE list (aria-setsize/posinset, also when windowed); a section header is a heading (level 3) and stays first in reading order while pinned",
+      keys: [
+        "Tab moves through the rows' controls; the list itself is one scroll region"
+      ]
+    },
+    Resizable: {
+      role: "group",
+      notes: "group; each handle a focusable separator (aria-orientation = the line's, valuenow = the size of the panel before it, valuemin/max = its limits, controls = that panel), named `$string.resize`",
+      keys: [
+        "Arrow keys on a handle: move it on screen by 10 points (Left/Right horizontal, Up/Down vertical; rtl: ArrowRight shrinks the first panel)",
+        "Home / End: the panel before the handle to its min / max",
+        "Enter: collapse or reopen a collapsible panel"
+      ]
+    },
+    Text: {
+      role: "text",
+      notes: "text (a live region when `live` is not off)",
+      keys: []
+    },
+    Markdown: {
+      role: "document",
+      notes: "document fragment (headings, lists, links, tables keep their roles)",
+      keys: [
+        "Tab moves through the links"
+      ]
+    },
+    CodeBlock: {
+      role: "region",
+      notes: "region (code), copy = button",
+      keys: [
+        "Tab reaches the copy button; Enter, Space: copy and announce `copied`"
+      ]
+    },
+    Image: {
+      role: "img",
+      notes: "img (alt = name; decorative when alt is empty)",
+      keys: []
+    },
+    Icon: {
+      role: "img",
+      notes: "img when labelled, hidden otherwise",
+      keys: []
+    },
+    Video: {
+      role: "group",
+      notes: "video with the platform's controls",
+      keys: [
+        "Space: play/pause; ArrowLeft/ArrowRight: seek 5 s"
+      ]
+    },
+    AudioPlayer: {
+      role: "group",
+      notes: "audio with the platform's controls",
+      keys: [
+        "Space: play/pause; ArrowLeft/ArrowRight: seek 5 s"
+      ]
+    },
+    Avatar: {
+      role: "img",
+      notes: "img (name)",
+      keys: []
+    },
+    Carousel: {
+      role: "region",
+      notes: "region, roledescription carousel; each page a group `page i of n`",
+      keys: [
+        "ArrowLeft/ArrowRight: previous/next page while focus is inside",
+        "Home/End: first/last page"
+      ]
+    },
+    Tabs: {
+      role: "tablist",
+      notes: "tablist / tab / tabpanel",
+      keys: [
+        "Roving tab stop on the tabs",
+        "ArrowLeft/ArrowRight: previous/next tab, activating it (wraps)",
+        "Home/End: first/last tab",
+        "Tab: into the active panel",
+        "Each close glyph (labelled `closeTab`, revealed by keyboard focus too) is a button after its tab; the + button (labelled `newTab`) follows the last tab"
+      ]
+    },
+    Segmented: {
+      role: "radiogroup",
+      notes: "radiogroup (single) or toolbar of toggle buttons (multiple); `bar` = navigation of buttons, the selected one aria-current=page",
+      keys: [
+        "Roving tab stop",
+        "ArrowLeft/ArrowRight (ArrowUp/ArrowDown): move focus (wraps)",
+        "Home/End: first/last",
+        "Space, Enter: toggle the focused item"
+      ]
+    },
+    Accordion: {
+      role: "group",
+      notes: "headers = buttons with aria-expanded controlling regions",
+      keys: [
+        "Enter, Space: toggle the focused section",
+        "ArrowDown/ArrowUp: next/previous header",
+        "Home/End: first/last header"
+      ]
+    },
+    Dialog: {
+      role: "dialog",
+      notes: "dialog (modal)",
+      keys: [
+        "Opening moves focus to the first focusable child (else the dialog)",
+        "Tab cycles inside the dialog (focus trap)",
+        "Escape: close when dismissible",
+        "Closing returns focus to the trigger"
+      ]
+    },
+    Drawer: {
+      role: "dialog",
+      notes: "dialog (modal)",
+      keys: [
+        "As Dialog; a swipe toward the edge closes when dragToDismiss"
+      ]
+    },
+    DockCard: {
+      role: "button",
+      notes: "trigger = button named `label: title` ($a11y); the sheet is a Drawer (dialog, modal).",
+      keys: [
+        "Enter, Space: open the sheet",
+        "As Drawer once open"
+      ]
+    },
+    Popover: {
+      role: "dialog",
+      notes: "dialog (non-modal)",
+      keys: [
+        "Enter, Space on the trigger: open",
+        "Escape: close and return focus to the trigger",
+        "openOn hover also opens on trigger focus"
+      ]
+    },
+    Tooltip: {
+      role: "tooltip",
+      notes: "tooltip describing its anchor",
+      keys: [
+        "Shows on hover AND keyboard focus of the anchor (after the platform delay); Escape hides"
+      ]
+    },
+    Menu: {
+      role: "menu",
+      notes: "menu / menuitem / menuitemcheckbox / group / separator; `openOn: contextmenu` opens at the pointer",
+      keys: [
+        "Enter, Space, ArrowDown on the trigger: open on the first item; ArrowUp: open on the last",
+        "Shift+F10 or the Menu key on the focused child (contextmenu): open at the child",
+        "ArrowDown/ArrowUp: next/previous item (wraps, skips disabled)",
+        "Home/End: first/last item",
+        "Enter, Space: run the item (a checkbox item toggles and stays open)",
+        "ArrowRight on a submenu: open it; ArrowLeft or Escape inside: close it",
+        "A searchable submenu opens with its filter input focused: typing filters, ArrowDown/ArrowUp move the active row, Enter picks it, ArrowLeft with the caret at the start or Escape closes it",
+        "Escape: close and return focus to the trigger",
+        "Typing a letter: the next item starting with it"
+      ]
+    },
+    Toast: {
+      role: "status",
+      notes: "status (polite); alert (assertive) for type error",
+      keys: [
+        "Never takes focus on appear; Tab reaches its action and close",
+        "Escape on a focused toast: dismiss",
+        "Hover or focus pauses the duration timer"
+      ]
+    },
+    Ring: {
+      role: "progressbar",
+      notes: "progressbar (value 0..1 as percent)",
+      keys: []
+    },
+    Spinner: {
+      role: "progressbar",
+      notes: "progressbar (indeterminate) labelled `loading` by default",
+      keys: []
+    },
+    Skeleton: {
+      role: "hidden",
+      notes: "hidden (the parent announces busy)",
+      keys: []
+    },
+    Table: {
+      role: "table",
+      notes: "table (grid when selectable): columnheader with aria-sort, row with aria-selected",
+      keys: [
+        "Enter, Space on a sortable header: cycle the sort (asc, desc)",
+        "Space on a row checkbox: toggle the row; on the header checkbox: select all",
+        "Enter on a focused row: rowPress",
+        "Tab moves through headers, checkboxes and cell controls"
+      ]
+    },
+    Chart: {
+      role: "img",
+      notes: "img with a generated summary (kind, series, ranges); a data table fallback for screen readers. The painter names it with `chartSummary` (series, min, max) and offers a data table fallback.",
+      keys: [
+        "ArrowLeft/ArrowRight while focused: move the tooltip between categories"
+      ]
+    },
+    Button: {
+      role: "button",
+      notes: "button (aria-busy while loading)",
+      keys: [
+        "Enter, Space: press",
+        "A `submit` button submits the enclosing Form"
+      ]
+    },
+    Link: {
+      role: "link",
+      notes: "link",
+      keys: [
+        "Enter: open / press"
+      ]
+    },
+    Toggle: {
+      role: "button",
+      notes: "button with aria-pressed",
+      keys: [
+        "Enter, Space: toggle"
+      ]
+    },
+    Form: {
+      role: "form",
+      notes: "form",
+      keys: [
+        "Enter in a single-line field: submit",
+        "A failed submit focuses the first invalid field and announces `invalidFields`"
+      ]
+    },
+    Input: {
+      role: "textbox",
+      notes: "textbox",
+      keys: [
+        "Enter: submit (fires `submit`, submits the Form)"
+      ]
+    },
+    Textarea: {
+      role: "textbox",
+      notes: "textbox (multiline)",
+      keys: [
+        "Enter: newline"
+      ]
+    },
+    NumberField: {
+      role: "spinbutton",
+      notes: "spinbutton (valuemin/valuemax/valuenow)",
+      keys: [
+        "ArrowUp/ArrowDown: ± step (Shift: ×10)",
+        "PageUp/PageDown: ± 10 steps",
+        "Home/End: min/max",
+        "Enter or blur: commit and clamp"
+      ]
+    },
+    Checkbox: {
+      role: "checkbox",
+      notes: "checkbox",
+      keys: [
+        "Space: toggle"
+      ]
+    },
+    Radio: {
+      role: "radiogroup",
+      notes: "radiogroup / radio",
+      keys: [
+        "Roving tab stop on the checked option",
+        "ArrowDown/ArrowRight: next option, selecting it (wraps)",
+        "ArrowUp/ArrowLeft: previous option"
+      ]
+    },
+    ChoiceTiles: {
+      role: "radiogroup",
+      notes: "radiogroup of radio tiles (single) or a group of checkbox tiles (multiple); the picture is decorative, the label names the tile",
+      keys: [
+        "Roving tab stop on the picked tile (the first when none)",
+        "ArrowRight/ArrowLeft, ArrowDown/ArrowUp: move focus (wraps); single: picks",
+        "Space, Enter: toggle the focused tile"
+      ]
+    },
+    Switch: {
+      role: "switch",
+      notes: "switch; the label (and description) first, the switch at the end; the whole row toggles",
+      keys: [
+        "Space, Enter: toggle"
+      ]
+    },
+    Slider: {
+      role: "slider",
+      notes: "slider",
+      keys: [
+        "ArrowRight/ArrowUp: + step; ArrowLeft/ArrowDown: - step",
+        "PageUp/PageDown: ± 10 steps",
+        "Home/End: min/max"
+      ]
+    },
+    Select: {
+      role: "combobox",
+      notes: "combobox + listbox / option",
+      keys: [
+        "Enter, Space, ArrowDown: open on the selected option",
+        "ArrowDown/ArrowUp: move the active option; Home/End: first/last",
+        "Enter: choose (multiple: toggle and stay open)",
+        "Escape: close without change",
+        "Typing: jump to the next matching option; with `searchable`, typing filters, focus stays in the search field and arrows move the active option (aria-activedescendant)"
+      ]
+    },
+    SearchList: {
+      role: "combobox",
+      notes: "combobox (the input) controlling a listbox of options; the highlighted row = aria-activedescendant, the count a polite status",
+      keys: [
+        "Focus stays in the input",
+        "ArrowDown/ArrowUp: move the highlighted row (no wrap, no animation)",
+        "Enter or Tab: pick the highlighted row (fires `select`)",
+        "Typing: filters; the top row is highlighted again"
+      ]
+    },
+    ChipInput: {
+      role: "textbox",
+      notes: "textbox with a list of removable chips",
+      keys: [
+        "Enter or comma: add the typed entry",
+        "Backspace in an empty field: focus the last chip, again: remove it",
+        "ArrowLeft/ArrowRight: move between chips; Delete, Backspace: remove the focused chip",
+        "ArrowDown: open the suggestions (as Select)"
+      ]
+    },
+    DatePicker: {
+      role: "combobox",
+      notes: "combobox opening a dialog with a grid of days",
+      keys: [
+        "Enter, Space, ArrowDown: open on the selected (else today's) day",
+        "Arrow keys: ± 1 day / ± 1 week",
+        "PageUp/PageDown: previous/next month (Shift: year)",
+        "Home/End: start/end of the week (locale week start)",
+        "Enter, Space: choose; Escape: close"
+      ]
+    },
+    DateRangePicker: {
+      role: "combobox",
+      notes: "as DatePicker; the second choice ends the range",
+      keys: [
+        "As DatePicker; the first Enter sets the start, the second the end"
+      ]
+    },
+    TimePicker: {
+      role: "combobox",
+      notes: "combobox + listbox",
+      keys: [
+        "As Select; typing `HH:mm` into the field commits on Enter or blur"
+      ]
+    },
+    FileUpload: {
+      role: "button",
+      notes: "button (the drop zone) + a list of files with remove buttons",
+      keys: [
+        "Enter, Space on the drop zone: open the file picker",
+        "Tab reaches each file's remove button"
+      ]
+    },
+    Composer: {
+      role: "textbox",
+      notes: "textbox (multiline) + send button",
+      keys: [
+        "Enter: submit; Shift+Enter: newline",
+        "Escape while busy: stop"
+      ]
+    },
+    TreeGuides: {
+      role: "hidden",
+      notes: "hidden (decorative; a Row part)",
+      keys: []
+    },
+    Unknown: {
+      role: "group",
+      notes: "group labelled `unknownComponent`",
+      keys: []
+    },
+    Collapsible: {
+      role: "group",
+      notes: "trigger = button with aria-expanded. The trigger is a button with aria-expanded = open ($a11y).",
+      keys: [
+        "Enter, Space: toggle"
+      ]
+    },
+    Pagination: {
+      role: "navigation",
+      notes: "navigation of two buttons and a status. Labelled `pagination`; previous/next buttons and a status labelled `pageOf` ($a11y).",
+      keys: [
+        "Enter, Space on previous/next"
+      ]
+    },
+    Breadcrumb: {
+      role: "navigation",
+      notes: "navigation (breadcrumb); the last item aria-current=page. Labelled `breadcrumb`; the last item aria-current=page ($a11y).",
+      keys: [
+        "Tab through the links; Enter: select"
+      ]
+    },
+    Stepper: {
+      role: "list",
+      notes: "list; the current step aria-current=step. Each step a listitem labelled `stepDone`/`stepCurrent`/`stepUpcoming`; the current one aria-current=step ($a11y).",
+      keys: []
+    },
+    Rating: {
+      role: "group",
+      notes: 'A group of star buttons: each labelled `ratingStar` ("3 of 5"), the chosen one aria-pressed; read-only stars leave the tree and the group is an img labelled `ratingValue` ($a11y).',
+      keys: [
+        "Tab through the stars; Enter, Space: rate"
+      ]
+    },
+    AlertDialog: {
+      role: "alertdialog",
+      notes: "alertdialog. The cancel button takes focus on open (`autoFocus`, $a11y).",
+      keys: [
+        "Opening focuses the cancel button",
+        "Escape: cancel; clicks outside are ignored"
+      ]
+    },
+    Sidebar: {
+      role: "none",
+      notes: "navigation landmark (the sidebar slot) beside main. Layout only; its `sidebar` part is a navigation landmark, its `main` part the main landmark ($a11y).",
+      keys: []
+    },
+    AppBar: {
+      role: "banner",
+      notes: "banner (heading level 1 = the title). The title is heading level 1; the back button is labelled `back` ($a11y).",
+      keys: [
+        "Enter, Space on back"
+      ]
+    },
+    Row: {
+      role: "button",
+      notes: "button (aria-selected when selected) when pressable, a group of its texts otherwise ($a11y); the guides are decorative",
+      keys: [
+        "Enter, Space: press (pressable only)"
+      ]
+    },
+    Trace: {
+      role: "none",
+      notes: "Layout only: a column of TraceItem lines.",
+      keys: []
+    },
+    TraceItem: {
+      role: "group",
+      notes: "A collapsible line is a button with aria-expanded = open ($a11y); a plain line is text; the icon is decorative.",
+      keys: [
+        "Enter, Space: toggle (collapsible only)"
+      ]
+    },
+    Chip: {
+      role: "button",
+      notes: "button with aria-pressed (= selected) when pressable, text otherwise ($a11y); remove = button labelled `remove`",
+      keys: [
+        "Enter, Space: press; Delete, Backspace: remove when removable"
+      ]
+    },
+    Page: {
+      role: "none",
+      notes: "Layout only: its header is the AppBar (banner, the title heading level 1), its body the main landmark ($a11y).",
+      keys: [
+        "Enter, Space on back"
+      ]
+    },
+    Toolbar: {
+      role: "group",
+      notes: "group of controls in reading order; the trailing action last",
+      keys: []
+    },
+    SplitView: {
+      role: "none",
+      notes: "Layout only: the `list` part is a navigation landmark, the `detail` part the main landmark; the phone back button is labelled `back` ($a11y).",
+      keys: [
+        "Enter, Space on back"
+      ]
+    },
+    FieldGroup: {
+      role: "group",
+      notes: "group of fields; each field keeps its own label",
+      keys: []
+    },
+    FormActions: {
+      role: "group",
+      notes: "group: Cancel, then the submit (the last in focus order)",
+      keys: [
+        "Enter, Space on a button"
+      ]
+    },
+    StatTile: {
+      role: "group",
+      notes: "group labelled by its label; the sparkline is an img with the generated summary",
+      keys: []
+    }
+  }
+};
+
+// packages/exponential-ui/src/a11y.ts
+var A11Y_ROLES = a11y_default.roles;
+var A11Y_RULES = a11y_default.rules;
+var A11Y_COMMANDS = a11y_default.commands;
+var COMPONENT_A11Y = a11y_default.components;
+function componentA11y(name) {
+  return COMPONENT_A11Y[name];
+}
+function isA11yRole(value) {
+  return typeof value === `string` && A11Y_ROLES.includes(value);
+}
+// packages/exponential-ui/src/chart.ts
+function chartExtent(kind, series, min, max) {
+  let lo = Infinity;
+  let hi = -Infinity;
+  if (kind === `stackedBar`) {
+    let n = 0;
+    for (const s of series)
+      n = Math.max(n, s.values.length);
+    for (let i = 0;i < n; i++) {
+      let pos = 0;
+      let neg = 0;
+      for (const s of series) {
+        const v = s.values[i];
+        if (!Number.isFinite(v))
+          continue;
+        if (v > 0)
+          pos += v;
+        else
+          neg += v;
+      }
+      if (pos > hi)
+        hi = pos;
+      if (neg < lo)
+        lo = neg;
+    }
+  } else {
+    for (const s of series)
+      for (const v of s.values) {
+        if (!Number.isFinite(v))
+          continue;
+        if (v < lo)
+          lo = v;
+        if (v > hi)
+          hi = v;
+      }
+  }
+  if (kind !== `sparkline`) {
+    lo = Math.min(0, lo);
+    hi = Math.max(0, hi);
+  }
+  if (!Number.isFinite(lo))
+    lo = 0;
+  if (!Number.isFinite(hi))
+    hi = 0;
+  lo = min ?? lo;
+  hi = max ?? hi;
+  if (hi <= lo)
+    hi = lo + 1;
+  return { min: lo, max: hi };
+}
+function chartSummaryParams(series) {
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (const s of series)
+    for (const v of s.values) {
+      if (!Number.isFinite(v))
+        continue;
+      if (v < lo)
+        lo = v;
+      if (v > hi)
+        hi = v;
+    }
+  return { series: series.map((s) => s.name).filter(Boolean).join(`, `), min: Number.isFinite(lo) ? lo : 0, max: Number.isFinite(hi) ? hi : 0 };
+}
+function sparklineSummaryParams(values) {
+  const finite = values.filter((v) => Number.isFinite(v));
+  if (finite.length === 0)
+    return { first: 0, last: 0, min: 0, max: 0 };
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (const v of finite) {
+    if (v < lo)
+      lo = v;
+    if (v > hi)
+      hi = v;
+  }
+  return { first: finite[0], last: finite[finite.length - 1], min: lo, max: hi };
+}
+function niceNum(x, round) {
+  const exp = Math.floor(Math.log10(x));
+  const f = x / 10 ** exp;
+  const nf = round ? f < 1.5 ? 1 : f < 3 ? 2 : f < 7 ? 5 : 10 : f <= 1 ? 1 : f <= 2 ? 2 : f <= 5 ? 5 : 10;
+  return nf * 10 ** exp;
+}
+function niceTicks(min, max, target = 5) {
+  const lo = Math.min(min, max);
+  const hi = max === min ? min + 1 : Math.max(min, max);
+  const range = niceNum(hi - lo, false);
+  const step = niceNum(range / Math.max(1, target - 1), true);
+  const decimals = Math.max(0, -Math.floor(Math.log10(step)));
+  const fix = (v) => Number(v.toFixed(decimals));
+  const niceMin = fix(Math.floor(lo / step) * step);
+  const niceMax = fix(Math.ceil(hi / step) * step);
+  const ticks = [];
+  for (let v = niceMin, i = 0;v <= niceMax + step / 2 && i < 100; i++, v = niceMin + i * step)
+    ticks.push(fix(v));
+  return { min: niceMin, max: niceMax, step, ticks };
+}
+function seriesColor(index, tone) {
+  if (tone)
+    return tone === `danger` ? `$color.destructive` : tone === `neutral` ? `$color.mutedForeground` : `$color.${tone}`;
+  return `$color.chart${index % 8 + 1}`;
+}
+var DONUT_HOLE = 0.6;
+// packages/exponential-ui/src/extension.ts
+var CATALOG_ID = /^https?:\/\/[^\s]+$/;
+var NAME = /^[A-Z][A-Za-z0-9]*$/;
+function validateExtension(def) {
+  const errors = [];
+  if (!CATALOG_ID.test(def.id))
+    errors.push(`id must be a URL-shaped catalog id`);
+  if (def.extends !== CORE_CATALOG_ID2)
+    errors.push(`extends must be ${CORE_CATALOG_ID2}`);
+  if (!def.name)
+    errors.push(`name is required`);
+  const names = Object.keys(def.components);
+  if (names.length === 0)
+    errors.push(`an extension defines at least one component`);
+  for (const [name, component] of Object.entries(def.components)) {
+    if (!NAME.test(name))
+      errors.push(`${name}: component names are PascalCase`);
+    if (name in coreCatalog2.components)
+      errors.push(`${name}: shadows a core component`);
+    if (!component.description)
+      errors.push(`${name}: description is required`);
+    for (const [prop, schema] of Object.entries(component.props)) {
+      if (!schema.description)
+        errors.push(`${name}.${prop}: description is required`);
+      if (schema.type === `enum` && schema.enum && !(schema.enum in coreCatalog2.enums) && !(schema.enum in (def.enums ?? {})))
+        errors.push(`${name}.${prop}: enum ${schema.enum} is not defined`);
+      if (schema.type === `object` && schema.shape && !(schema.shape in coreCatalog2.defs) && !(schema.shape in (def.defs ?? {})))
+        errors.push(`${name}.${prop}: shape ${schema.shape} is not defined`);
+    }
+    if (component.kind === `macro` && !def.macros?.[name])
+      errors.push(`${name}: a macro needs a template in macros`);
+  }
+  for (const name of Object.keys(def.macros ?? {})) {
+    if (def.components[name]?.kind !== `macro`)
+      errors.push(`macros.${name}: no macro component of that name`);
+  }
+  for (const name of Object.keys(def.enums ?? {})) {
+    if (name in coreCatalog2.enums)
+      errors.push(`enums.${name}: shadows a core enum`);
+  }
+  return errors;
+}
+function defineExtension(def) {
+  const errors = validateExtension(def);
+  if (errors.length > 0)
+    throw new Error(`extension ${def.id}:
+${errors.join(`
+`)}`);
+  return def;
+}
+// packages/exponential-ui/src/define.ts
+var bind = (path) => ({ path });
+var call = (name, args) => ({ call: name, ...args ? { args } : {} });
+var event = (name, context) => ({ event: { name, ...context ? { context } : {} } });
+var run = (name, args) => ({ functionCall: call(name, args) });
+var ui = Object.fromEntries(COMPONENT_NAMES2.map((name) => [name, (props, children, extra) => ({ component: name, props, ...children ? { children } : {}, ...extra })]));
+function el(component, props, children, extra) {
+  return { component, props, ...children ? { children } : {}, ...extra };
+}
+function flattenSurface(tree, rootId = `root`) {
+  const out = [];
+  const taken = new Set;
+  const counters = new Map;
+  const nameOf = (n, isRoot) => {
+    if (n.id) {
+      if (taken.has(n.id))
+        throw new Error(`defineSurface: duplicate id "${n.id}"`);
+      taken.add(n.id);
+      return n.id;
+    }
+    if (isRoot && !taken.has(rootId)) {
+      taken.add(rootId);
+      return rootId;
+    }
+    const base = n.component.charAt(0).toLowerCase() + n.component.slice(1);
+    let id;
+    do {
+      const next = (counters.get(base) ?? 0) + 1;
+      counters.set(base, next);
+      id = `${base}-${next}`;
+    } while (taken.has(id));
+    taken.add(id);
+    return id;
+  };
+  const walk = (n, isRoot) => {
+    const id = nameOf(n, isRoot);
+    const flat = { id, component: n.component, ...n.props };
+    if (n.style)
+      flat.style = n.style;
+    if (n.on)
+      flat.on = n.on;
+    if (n.visible !== undefined)
+      flat.visible = n.visible;
+    if (n.accessibility)
+      flat.accessibility = n.accessibility;
+    out.push(flat);
+    if (Array.isArray(n.children))
+      flat.children = n.children.map((c) => walk(c, false));
+    else if (n.children) {
+      const t = walk(n.children.template, false);
+      flat.children = { componentId: t, path: n.children.path, ...n.children.key ? { key: n.children.key } : {} };
+    }
+    if (n.slots)
+      flat.slots = Object.fromEntries(Object.entries(n.slots).map(([slot, child]) => [slot, walk(child, false)]));
+    return id;
+  };
+  walk(tree, true);
+  return out;
+}
+function defineSurface(tree, options = {}) {
+  const surfaceId = options.surfaceId ?? `main`;
+  const catalogId = options.catalogId ?? CORE_CATALOG_ID2;
+  const components = flattenSurface(tree);
+  const { root, issues } = reduceSurface2(components, { catalogId, extensions: options.extensions });
+  const messages = [
+    { version: `v0.9`, createSurface: { surfaceId, catalogId } },
+    { version: `v0.9`, updateComponents: { surfaceId, components } },
+    ...Object.entries(options.data ?? {}).map(([path, value]) => ({ version: `v0.9`, updateDataModel: { surfaceId, path, value } }))
+  ];
+  return { surfaceId, catalogId, components, issues, root, messages, jsonl: messages.map((m) => JSON.stringify(m)).join(`
+`) };
+}
+// packages/exponential-ui/src/css.ts
+var UNITLESS = new Set([`flexGrow`, `flexShrink`, `opacity`, `fontWeight`, `aspectRatio`]);
+var SHORTHANDS = {
+  paddingHorizontal: [`padding-left`, `padding-right`],
+  paddingVertical: [`padding-top`, `padding-bottom`],
+  paddingInlineStart: [`padding-inline-start`],
+  paddingInlineEnd: [`padding-inline-end`],
+  marginHorizontal: [`margin-left`, `margin-right`],
+  marginVertical: [`margin-top`, `margin-bottom`],
+  marginInlineStart: [`margin-inline-start`],
+  marginInlineEnd: [`margin-inline-end`],
+  insetInlineStart: [`inset-inline-start`],
+  insetInlineEnd: [`inset-inline-end`],
+  insetBlockStart: [`inset-block-start`],
+  insetBlockEnd: [`inset-block-end`],
+  backgroundGradient: [`background-image`],
+  backdropBlur: [`backdrop-filter`]
+};
+var FOLDED = new Set([`transitionEasing`, `native`, `animationDuration`]);
+var kebab = (key) => key.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+function gradientCss(gradient) {
+  return `linear-gradient(${gradient.angle}deg, ${gradient.stops.map((s) => `${s.color} ${Math.round(s.offset * 1e4) / 100}%`).join(`, `)})`;
+}
+function cssString(text) {
+  return `"${text.replace(/\\/g, `\\\\`).replace(/"/g, `\\"`)}"`;
+}
+function fontStack(family, fonts) {
+  const fallback = fonts[family]?.fallback;
+  return fallback ? `${cssString(family)}, ${fallback}` : cssString(family);
+}
+function cssValue(key, value, fonts, style) {
+  if (key === `boxShadow`)
+    return Array.isArray(value) ? shadowCss2(value) : String(value);
+  if (key === `fontFamily`)
+    return fontStack(String(value), fonts);
+  if (key === `gridTemplateAreas` && Array.isArray(value))
+    return value.map((row) => `"${row}"`).join(` `);
+  if (key === `backgroundGradient`)
+    return typeof value === `object` && value !== null ? gradientCss(value) : null;
+  if (key === `backdropBlur`)
+    return typeof value === `number` ? `blur(${value}px)` : null;
+  if (key === `transition`) {
+    if (typeof value !== `number`)
+      return null;
+    const easing = style.transitionEasing;
+    return `all ${value}ms${Array.isArray(easing) ? ` ${easingCss2(easing)}` : ``}`;
+  }
+  if (typeof value === `number`)
+    return UNITLESS.has(key) ? String(value) : `${value}px`;
+  if (typeof value === `boolean`)
+    return null;
+  return String(value);
+}
+function styleToCss(style, fonts = {}, theme) {
+  const out = {};
+  for (const [key, value] of Object.entries(style)) {
+    if (value === undefined || FOLDED.has(key))
+      continue;
+    if (key === `animation`) {
+      const timing = theme && typeof value === `string` ? animationTiming(value, theme) : null;
+      if (!timing)
+        continue;
+      const duration = style.animationDuration;
+      const durationMs = typeof duration === `number` ? duration * (ANIMATIONS[value]?.factor ?? 1) : timing.durationMs;
+      out.animation = animationCss(value, { ...timing, durationMs });
+      continue;
+    }
+    if (key.startsWith(`@`) || key.startsWith(`:`))
+      continue;
+    if (typeof value === `object` && value !== null && !Array.isArray(value) && key !== `backgroundGradient`)
+      continue;
+    const css = cssValue(key, value, fonts, style);
+    if (css === null)
+      continue;
+    const targets = SHORTHANDS[key] ?? [kebab(key)];
+    for (const target of targets)
+      out[target] = css;
+  }
+  if (out.animation && animatesOpacity(String(style.animation)))
+    out.opacity = out.opacity ? `calc(${out.opacity} * var(--xui-a-opacity, 1))` : `var(--xui-a-opacity, 1)`;
+  if (out[`backdrop-filter`])
+    out[`-webkit-backdrop-filter`] = out[`backdrop-filter`];
+  const anyBorder = [`border-width`, `border-top-width`, `border-right-width`, `border-bottom-width`, `border-left-width`].some((k) => out[k] && out[k] !== `0px`);
+  if (anyBorder && !out[`border-style`])
+    out[`border-style`] = `solid`;
+  if (anyBorder && !out[`border-color`])
+    out[`border-color`] = `transparent`;
+  return out;
+}
+function styleAttribute(style, fonts = {}) {
+  return Object.entries(styleToCss(style, fonts)).map(([k, v]) => `${k}:${v}`).join(`;`);
+}
+// packages/exponential-ui/src/builder.ts
+var SHADCN_COLOR_VARS = {
+  background: `background`,
+  foreground: `foreground`,
+  card: `card`,
+  "card-foreground": `cardForeground`,
+  popover: `popover`,
+  "popover-foreground": `popoverForeground`,
+  primary: `primary`,
+  "primary-foreground": `primaryForeground`,
+  secondary: `secondary`,
+  "secondary-foreground": `secondaryForeground`,
+  muted: `muted`,
+  "muted-foreground": `mutedForeground`,
+  accent: `accent`,
+  "accent-foreground": `accentForeground`,
+  destructive: `destructive`,
+  "destructive-foreground": `destructiveForeground`,
+  success: `success`,
+  "success-foreground": `successForeground`,
+  warning: `warning`,
+  "warning-foreground": `warningForeground`,
+  info: `info`,
+  "info-foreground": `infoForeground`,
+  border: `border`,
+  input: `input`,
+  ring: `ring`,
+  "chart-1": `chart1`,
+  "chart-2": `chart2`,
+  "chart-3": `chart3`,
+  "chart-4": `chart4`,
+  "chart-5": `chart5`
+};
+var BLOCK = /([^{}]+)\{([^{}]*)\}/g;
+var DECL = /--([a-zA-Z0-9-]+)\s*:\s*([^;]+);?/g;
+function selectorMode(selector) {
+  const s = selector.trim();
+  if (/\.dark\b|\[data-theme=["']?dark|prefers-color-scheme:\s*dark/.test(s))
+    return `dark`;
+  if (/^(:root|:host|html|body)(\s*,\s*(:root|:host|html|body))*$/.test(s) || /\.light\b/.test(s))
+    return `light`;
+  return null;
+}
+function px(value) {
+  const v = value.trim();
+  if (v.endsWith(`rem`))
+    return Math.round(parseFloat(v) * 16 * 100) / 100;
+  if (v.endsWith(`px`))
+    return parseFloat(v);
+  if (v.endsWith(`em`))
+    return Math.round(parseFloat(v) * 16 * 100) / 100;
+  const n = parseFloat(v);
+  return Number.isFinite(n) && /^-?[\d.]+$/.test(v) ? n : null;
+}
+function parseShadow(value) {
+  const v = value.trim();
+  if (v === `none`)
+    return [];
+  const layers = [];
+  let depth = 0;
+  let start = 0;
+  const parts = [];
+  for (let i = 0;i < v.length; i++) {
+    if (v[i] === `(`)
+      depth++;
+    else if (v[i] === `)`)
+      depth--;
+    else if (v[i] === `,` && depth === 0) {
+      parts.push(v.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(v.slice(start));
+  for (const part of parts) {
+    const m = /^\s*(-?[\d.]+(?:px)?)\s+(-?[\d.]+(?:px)?)\s+(-?[\d.]+(?:px)?)(?:\s+(-?[\d.]+(?:px)?))?\s+(.+?)\s*$/.exec(part);
+    if (!m)
+      return null;
+    const color = toThemeHex2(m[5]);
+    if (!color)
+      return null;
+    layers.push({ x: parseFloat(m[1]), y: parseFloat(m[2]), blur: parseFloat(m[3]), spread: m[4] ? parseFloat(m[4]) : 0, color });
+  }
+  return layers;
+}
+function firstFamily(value) {
+  const parts = value.split(`,`).map((s) => s.trim().replace(/^["']|["']$/g, ``)).filter(Boolean);
+  return { family: parts[0] ?? value.trim(), fallback: parts.length > 1 ? parts.slice(1).join(`, `) : undefined };
+}
+function importShadcnCss(css) {
+  const out = { modes: {}, tokens: {}, fonts: {}, unmapped: [] };
+  const unmapped = new Set;
+  const text = css.replace(/\/\*[\s\S]*?\*\//g, ``);
+  const addFamily = (slot, value) => {
+    const { family, fallback } = firstFamily(value);
+    ((out.tokens.type ??= {}).family ??= {})[slot] = family;
+    out.fonts[family] = { ...fallback ? { fallback } : {}, source: `host` };
+  };
+  for (const block of text.matchAll(BLOCK)) {
+    const mode = selectorMode(block[1]);
+    for (const decl of block[2].matchAll(DECL)) {
+      const name = decl[1];
+      const value = decl[2].trim();
+      const colorName = SHADCN_COLOR_VARS[name];
+      if (colorName) {
+        const hex = toThemeHex2(value);
+        if (!hex || !mode) {
+          unmapped.add(`--${name}`);
+          continue;
+        }
+        (out.modes[mode] ??= { color: {} }).color[colorName] = hex;
+        continue;
+      }
+      if (name === `radius`) {
+        const base = px(value);
+        if (base === null) {
+          unmapped.add(`--${name}`);
+          continue;
+        }
+        out.tokens.radius = {
+          none: 0,
+          sm: Math.max(0, base - 4),
+          md: Math.max(0, base - 2),
+          lg: base,
+          xl: base + 4,
+          xl2: base + 8,
+          xl3: base + 12,
+          full: 9999
+        };
+        continue;
+      }
+      if (name === `font-sans` || name === `font-mono`) {
+        if (value.includes(`var(`))
+          unmapped.add(`--${name}`);
+        else
+          addFamily(name.slice(5), value);
+        continue;
+      }
+      const shadow = /^shadow-(sm|md|lg)$/.exec(name);
+      if (shadow && mode) {
+        const layers = parseShadow(value);
+        if (!layers) {
+          unmapped.add(`--${name}`);
+          continue;
+        }
+        const m = out.modes[mode] ??= { color: {} };
+        (m.shadow ??= {})[shadow[1]] = layers;
+        continue;
+      }
+      unmapped.add(`--${name}`);
+    }
+  }
+  out.unmapped = [...unmapped].sort();
+  return out;
+}
+function themeFromImport(imp, meta) {
+  const theme = { $schema: THEME_SCHEMA_ID2, id: meta.id, name: meta.name };
+  if (meta.extends)
+    theme.extends = meta.extends;
+  const modes = {};
+  for (const mode of MODES2) {
+    const m = imp.modes[mode];
+    if (!m)
+      continue;
+    modes[mode] = { color: m.color, ...m.shadow ? { shadow: m.shadow } : {} };
+    if (m.shadow && !m.shadow.none)
+      modes[mode].shadow = { none: [], ...m.shadow };
+  }
+  if (Object.keys(modes).length > 0)
+    theme.modes = modes;
+  const tokens = {};
+  if (imp.tokens.radius)
+    tokens.radius = imp.tokens.radius;
+  if (imp.tokens.type?.family)
+    tokens.type = { family: imp.tokens.type.family };
+  if (Object.keys(tokens).length > 0)
+    theme.tokens = tokens;
+  if (Object.keys(imp.fonts).length > 0)
+    theme.fonts = imp.fonts;
+  return theme;
+}
+var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function diffTheme(full, base, meta) {
+  const resolved = `chain` in full ? full : loadTheme2(full, { themes: [base] });
+  const out = { $schema: THEME_SCHEMA_ID2, id: meta?.id ?? resolved.id, name: meta?.name ?? resolved.name, extends: base.id };
+  const modes = {};
+  for (const mode of MODES2) {
+    const color = {};
+    const shadow = {};
+    for (const [k, v] of Object.entries(resolved.modes[mode].color))
+      if (base.modes[mode].color[k] !== v)
+        color[k] = v;
+    for (const [k, v] of Object.entries(resolved.modes[mode].shadow))
+      if (!same(base.modes[mode].shadow[k], v))
+        shadow[k] = v;
+    const m = {};
+    if (Object.keys(color).length > 0)
+      m.color = color;
+    if (Object.keys(shadow).length > 0)
+      m.shadow = shadow;
+    if (Object.keys(m).length > 0)
+      modes[mode] = m;
+  }
+  if (Object.keys(modes).length > 0)
+    out.modes = modes;
+  const contrast = {};
+  for (const mode of MODES2) {
+    const mine = resolved.contrast?.[mode] ?? { color: {}, shadow: {} };
+    const theirs = base.contrast?.[mode] ?? { color: {}, shadow: {} };
+    const color = {};
+    const shadow = {};
+    for (const [k, v] of Object.entries(mine.color))
+      if (theirs.color[k] !== v)
+        color[k] = v;
+    for (const [k, v] of Object.entries(mine.shadow))
+      if (!same(theirs.shadow[k], v))
+        shadow[k] = v;
+    const m = {};
+    if (Object.keys(color).length > 0)
+      m.color = color;
+    if (Object.keys(shadow).length > 0)
+      m.shadow = shadow;
+    if (Object.keys(m).length > 0)
+      contrast[mode] = m;
+  }
+  if (Object.keys(contrast).length > 0)
+    out.contrast = contrast;
+  const tokens = {};
+  for (const group of Object.keys(TOKEN_GROUPS2)) {
+    if (group === `color` || group === `shadow`)
+      continue;
+    const [top, sub] = group.split(`.`);
+    const mine = sub ? resolved.tokens.type[sub] : resolved.tokens[top];
+    const theirs = sub ? base.tokens.type[sub] : base.tokens[top];
+    const diff = {};
+    for (const [k, v] of Object.entries(mine ?? {}))
+      if (!same(theirs?.[k], v))
+        diff[k] = v;
+    if (Object.keys(diff).length === 0)
+      continue;
+    if (sub)
+      (tokens.type ??= {})[sub] = diff;
+    else
+      tokens[top] = diff;
+  }
+  if (Object.keys(tokens).length > 0)
+    out.tokens = tokens;
+  const fonts = {};
+  for (const [k, v] of Object.entries(resolved.fonts))
+    if (!same(base.fonts[k], v))
+      fonts[k] = v;
+  if (Object.keys(fonts).length > 0)
+    out.fonts = fonts;
+  if (`chain` in full) {
+    const recipes = {};
+    for (const [component, byPart] of Object.entries(resolved.recipes)) {
+      for (const [part, rules] of Object.entries(byPart)) {
+        const baseRules = base.recipes[component]?.[part] ?? [];
+        const tail = rules.slice(baseRules.length);
+        if (tail.length > 0)
+          (recipes[component] ??= {})[part] = tail;
+      }
+    }
+    if (Object.keys(recipes).length > 0)
+      out.recipes = recipes;
+  } else if (full.recipes && Object.keys(full.recipes).length > 0)
+    out.recipes = full.recipes;
+  return out;
+}
+function exportThemeJson(theme) {
+  const { $schema: _ignored, ...rest } = theme;
+  return `${JSON.stringify({ $schema: `https://ui.exponential.at/schemas/theme/v1.json`, ...rest }, null, 2)}
+`;
+}
+function parseThemeJson(text, themes) {
+  let source;
+  try {
+    source = JSON.parse(text);
+  } catch (error) {
+    return { theme: null, source: null, issues: [{ path: `theme`, message: `not JSON: ${error.message}` }] };
+  }
+  try {
+    return { theme: loadTheme2(source, { themes }), source, issues: [] };
+  } catch (error) {
+    const issues = error.issues ?? [{ path: `theme`, message: error.message }];
+    return { theme: null, source, issues };
+  }
+}
+// packages/exponential-ui/src/geometry.ts
+var CONTROL_PARTS = {
+  Button: `root`,
+  Toggle: `root`,
+  Segmented: `item`,
+  Input: `field`,
+  Textarea: `field`,
+  Select: `trigger`,
+  DatePicker: `trigger`,
+  Checkbox: `box`,
+  Radio: `item`,
+  Switch: `track`,
+  Slider: `thumb`,
+  Avatar: `root`,
+  Icon: `root`,
+  Spinner: `root`,
+  Ring: `root`,
+  Tabs: `tab`,
+  NumberField: `field`,
+  ChipInput: `field`,
+  TimePicker: `trigger`,
+  DateRangePicker: `trigger`
+};
+var GEOMETRY_KEYS = [`width`, `height`, `minWidth`, `minHeight`, `paddingHorizontal`, `paddingVertical`, `padding`, `gap`, `borderWidth`, `borderRadius`];
+function controlGeometry(theme, component, props = {}, states = []) {
+  const part = CONTROL_PARTS[component] ?? `root`;
+  const style = resolveRecipe2(theme, { component, part, props, states }, `light`);
+  const out = {};
+  for (const key of GEOMETRY_KEYS) {
+    const v = style[key];
+    if (typeof v === `number`)
+      out[key] = v;
+  }
+  return out;
+}
+function checkGeometry(expected, measured, tolerance = 0.5) {
+  const issues = [];
+  const probe = (key, actual) => {
+    const want = expected[key];
+    if (want === undefined)
+      return;
+    if (actual === undefined || Math.abs(actual - want) > tolerance)
+      issues.push({ key, expected: want, actual });
+  };
+  probe(`width`, measured.width);
+  if (expected.minHeight === undefined)
+    probe(`height`, measured.height);
+  probe(`paddingHorizontal`, measured.paddingHorizontal);
+  probe(`paddingVertical`, measured.paddingVertical);
+  probe(`borderWidth`, measured.borderWidth);
+  probe(`borderRadius`, measured.borderRadius);
+  if (expected.minHeight !== undefined && (measured.height === undefined || measured.height + tolerance < expected.minHeight))
+    issues.push({ key: `minHeight`, expected: expected.minHeight, actual: measured.height });
+  return issues;
+}
+function verifyPainterGeometry(override, theme, cases) {
+  return cases.map((c) => ({
+    name: Object.entries(c.props).map(([k, v]) => `${k}=${String(v)}`).join(`,`) || `default`,
+    issues: checkGeometry(controlGeometry(theme, override.component, c.props, c.states), override.measure(theme, c.props, c.states))
+  })).filter((r) => r.issues.length > 0);
+}
+// packages/exponential-ui/src/overlay.ts
+var OVERLAY_OFFSET = 4;
+var OVERLAY_PADDING = 8;
+var OPPOSITE = { top: `bottom`, bottom: `top`, left: `right`, right: `left` };
+function room(side, anchor, viewport, padding) {
+  switch (side) {
+    case `top`:
+      return anchor.y - padding;
+    case `bottom`:
+      return viewport.height - (anchor.y + anchor.height) - padding;
+    case `left`:
+      return anchor.x - padding;
+    case `right`:
+      return viewport.width - (anchor.x + anchor.width) - padding;
+  }
+}
+function placeOverlay(anchor, size, viewport, options = {}) {
+  const preferred = options.side ?? `bottom`;
+  const align = options.align ?? `center`;
+  const offset = options.offset ?? OVERLAY_OFFSET;
+  const padding = options.padding ?? OVERLAY_PADDING;
+  const vertical = preferred === `top` || preferred === `bottom`;
+  const needed = (vertical ? size.height : size.width) + offset;
+  let side = preferred;
+  let flipped = false;
+  if (room(preferred, anchor, viewport, padding) < needed && room(OPPOSITE[preferred], anchor, viewport, padding) > room(preferred, anchor, viewport, padding)) {
+    side = OPPOSITE[preferred];
+    flipped = true;
+  }
+  let x;
+  let y;
+  const alongX = () => align === `start` ? anchor.x : align === `end` ? anchor.x + anchor.width - size.width : anchor.x + anchor.width / 2 - size.width / 2;
+  const alongY = () => align === `start` ? anchor.y : align === `end` ? anchor.y + anchor.height - size.height : anchor.y + anchor.height / 2 - size.height / 2;
+  switch (side) {
+    case `top`:
+      x = alongX();
+      y = anchor.y - offset - size.height;
+      break;
+    case `bottom`:
+      x = alongX();
+      y = anchor.y + anchor.height + offset;
+      break;
+    case `left`:
+      x = anchor.x - offset - size.width;
+      y = alongY();
+      break;
+    case `right`:
+      x = anchor.x + anchor.width + offset;
+      y = alongY();
+      break;
+  }
+  if (vertical === (side === `top` || side === `bottom`)) {
+    if (side === `top` || side === `bottom`)
+      x = Math.min(Math.max(x, padding), Math.max(padding, viewport.width - padding - size.width));
+    else
+      y = Math.min(Math.max(y, padding), Math.max(padding, viewport.height - padding - size.height));
+  } else if (side === `top` || side === `bottom`)
+    x = Math.min(Math.max(x, padding), Math.max(padding, viewport.width - padding - size.width));
+  else
+    y = Math.min(Math.max(y, padding), Math.max(padding, viewport.height - padding - size.height));
+  return { x: round(x), y: round(y), side, flipped };
+}
+var round = (n) => Math.round(n * 1000) / 1000;
+// packages/exponential-ui/src/connector/connector.ts
+var b64url = (bytes) => btoa(String.fromCharCode(...bytes)).replace(/\+/g, `-`).replace(/\//g, `_`).replace(/=+$/, ``);
+async function pkcePair() {
+  const verifier = b64url(crypto.getRandomValues(new Uint8Array(32)));
+  const digest = new Uint8Array(await crypto.subtle.digest(`SHA-256`, new TextEncoder().encode(verifier)));
+  return { verifier, challenge: b64url(digest) };
+}
+
+class ExponentialConnector {
+  options;
+  metadata;
+  clientId;
+  tokens;
+  rpcId = 0;
+  constructor(options) {
+    this.options = options;
+    this.clientId = options.clientId;
+    this.tokens = options.tokens;
+  }
+  get fetch() {
+    return this.options.fetch ?? fetch;
+  }
+  url(path) {
+    return new URL(path, this.options.baseUrl).href;
+  }
+  async discover() {
+    if (this.metadata)
+      return this.metadata;
+    const res = await this.fetch(this.url(`/.well-known/oauth-authorization-server`));
+    if (!res.ok)
+      throw new Error(`discovery failed: HTTP ${res.status}`);
+    this.metadata = await res.json();
+    return this.metadata;
+  }
+  async register() {
+    if (this.clientId)
+      return this.clientId;
+    const meta = await this.discover();
+    if (!meta.registration_endpoint)
+      throw new Error(`the instance offers no dynamic client registration; pass clientId`);
+    const res = await this.fetch(meta.registration_endpoint, {
+      method: `POST`,
+      headers: { "content-type": `application/json` },
+      body: JSON.stringify({ client_name: this.options.clientName ?? `Exponential UI host`, redirect_uris: [this.options.redirectUri], grant_types: [`authorization_code`, `refresh_token`], response_types: [`code`], token_endpoint_auth_method: `none` })
+    });
+    if (!res.ok)
+      throw new Error(`registration failed: HTTP ${res.status}`);
+    this.clientId = (await res.json()).client_id;
+    return this.clientId;
+  }
+  async authorizeUrl() {
+    const meta = await this.discover();
+    const clientId = await this.register();
+    const { verifier, challenge } = await pkcePair();
+    const state = b64url(crypto.getRandomValues(new Uint8Array(16)));
+    const url = new URL(meta.authorization_endpoint);
+    url.search = new URLSearchParams({ response_type: `code`, client_id: clientId, redirect_uri: this.options.redirectUri, code_challenge: challenge, code_challenge_method: `S256`, state, scope: `openid profile email offline_access` }).toString();
+    return { url: url.href, verifier, state, clientId };
+  }
+  async token(body) {
+    const meta = await this.discover();
+    const res = await this.fetch(meta.token_endpoint, { method: `POST`, headers: { "content-type": `application/x-www-form-urlencoded` }, body: new URLSearchParams({ client_id: this.clientId ?? ``, ...body }).toString() });
+    if (!res.ok)
+      throw new Error(`token request failed: HTTP ${res.status}`);
+    const json = await res.json();
+    this.tokens = { accessToken: json.access_token, refreshToken: json.refresh_token ?? this.tokens?.refreshToken, expiresAt: json.expires_in ? Date.now() + json.expires_in * 1000 : undefined };
+    this.options.onTokens?.(this.tokens);
+    return this.tokens;
+  }
+  async exchange(code, verifier, clientId) {
+    if (clientId)
+      this.clientId = clientId;
+    if (!this.clientId)
+      throw new Error(`no client id for the token exchange; pass the clientId authorizeUrl returned`);
+    return this.token({ grant_type: `authorization_code`, code, code_verifier: verifier, redirect_uri: this.options.redirectUri });
+  }
+  async refresh() {
+    if (!this.tokens?.refreshToken)
+      throw new Error(`no refresh token; authorize again`);
+    return this.token({ grant_type: `refresh_token`, refresh_token: this.tokens.refreshToken });
+  }
+  async callTool(name, args = {}) {
+    if (!this.tokens)
+      throw new Error(`not connected; authorize first`);
+    if (this.tokens.expiresAt && this.tokens.expiresAt < Date.now() + 30000 && this.tokens.refreshToken)
+      await this.refresh();
+    const res = await this.fetch(this.url(`/api/mcp`), {
+      method: `POST`,
+      headers: { "content-type": `application/json`, accept: `application/json, text/event-stream`, authorization: `Bearer ${this.tokens.accessToken}` },
+      body: JSON.stringify({ jsonrpc: `2.0`, id: ++this.rpcId, method: `tools/call`, params: { name, arguments: args } })
+    });
+    if (!res.ok)
+      throw new Error(`MCP HTTP ${res.status}`);
+    const text = await res.text();
+    const line = text.trimStart().startsWith(`{`) ? text : text.split(`
+`).find((l) => l.startsWith(`data:`))?.slice(5) ?? `{}`;
+    const reply = JSON.parse(line);
+    if (reply.error)
+      throw new Error(reply.error.message ?? `MCP error`);
+    const result = reply.result ?? {};
+    const body = result.structuredContent ?? (result.content ?? []).filter((c) => c.type === `text`).map((c) => c.text ?? ``).join(``);
+    if (result.isError)
+      throw new Error(typeof body === `string` ? body : `tool error`);
+    if (typeof body !== `string`)
+      return body;
+    try {
+      return JSON.parse(body);
+    } catch {
+      return body;
+    }
+  }
+  sources() {
+    return { exp: (source, emit) => this.follow(source, emit) };
+  }
+  follow(source, emit) {
+    const p = source.params;
+    const read = async () => {
+      switch (source.name) {
+        case `issues`: {
+          const args = { limit: Number(p.limit ?? 50) };
+          if (p.board)
+            args.boardId = p.board;
+          if (p.team)
+            args.teamId = p.team;
+          if (p.search)
+            args.search = p.search;
+          return this.callTool(`exponential_issues_list`, args);
+        }
+        case `boards`:
+          return this.callTool(`exponential_boards_list`, p.team ? { teamId: p.team } : {});
+        case `teams`:
+          return this.callTool(`exponential_teams_list`, {});
+        case `members`:
+          return this.callTool(`exponential_members_list`, p.team ? { teamId: p.team } : {});
+        default:
+          return null;
+      }
+    };
+    let live = true;
+    let timer;
+    const seconds = Number(p.poll ?? this.options.pollSeconds ?? 30);
+    const tick = async () => {
+      try {
+        const value = await read();
+        if (!live)
+          return;
+        const rows = Array.isArray(value) ? value : value?.rows;
+        emit(rows ? { rows, count: rows.length } : value);
+      } catch (e) {
+        if (live)
+          emit({ rows: [], count: 0, error: e instanceof Error ? e.message : String(e) });
+      }
+      if (live && seconds > 0)
+        timer = setTimeout(tick, seconds * 1000);
+    };
+    tick();
+    return () => {
+      live = false;
+      if (timer)
+        clearTimeout(timer);
+    };
+  }
+  functions() {
+    return { "exponential.mcp": (args) => this.callTool(String(args.tool ?? ``), args.arguments ?? {}) };
+  }
+}
+// packages/exponential-ui/src/connector/app.ts
+function createAppHost(options) {
+  const { package: pkg, ...rest } = options;
+  const host = new ExponentialHost2(rest);
+  const issues = host.installPackage(pkg);
+  return {
+    host,
+    issues,
+    open(surfaceId, templateId = Object.keys(pkg.templates)[0], data) {
+      const message = { version: `v0.9`, applyTemplate: { surfaceId, templateId, packageId: pkg.id, ...data === undefined ? {} : { data } } };
+      host.receive(message);
+    }
+  };
+}
+export {
+  A11Y_COMMANDS,
+  A11Y_ROLES,
+  A11Y_RULES,
+  A2UI_BASIC_CATALOG_ID2 as A2UI_BASIC_CATALOG_ID,
+  A2UI_MESSAGE_KINDS2 as A2UI_MESSAGE_KINDS,
+  A2UI_VERSION2 as A2UI_VERSION,
+  ANIMATIONS,
+  ANIMATION_NAMES,
+  ANIMATION_PROPERTIES_CSS,
+  BASIC_CATALOG_ID2 as BASIC_CATALOG_ID,
+  BASIC_COMPONENT_MAP2 as BASIC_COMPONENT_MAP,
+  BASIC_ICON_MAP2 as BASIC_ICON_MAP,
+  BASIC_PLACEHOLDER_ICON2 as BASIC_PLACEHOLDER_ICON,
+  BASIC_TRANSFORM_NAMES2 as BASIC_TRANSFORM_NAMES,
+  BASIC_VERSION2 as BASIC_VERSION,
+  BIND_FUNCTIONS2 as BIND_FUNCTIONS,
+  BIND_FUNCTION_NAMES2 as BIND_FUNCTION_NAMES,
+  BREAKPOINTS2 as BREAKPOINTS,
+  BUILTIN_FUNCTIONS2 as BUILTIN_FUNCTIONS,
+  BUILTIN_THEMES2 as BUILTIN_THEMES,
+  BUILTIN_THEME_IDS2 as BUILTIN_THEME_IDS,
+  CATALOG_ID2 as CATALOG_ID,
+  CATALOG_VERSION2 as CATALOG_VERSION,
+  CODE_LANGUAGES,
+  CODE_LANGUAGE_NAMES,
+  COMPONENT_A11Y,
+  COMPONENT_GROUPS2 as COMPONENT_GROUPS,
+  COMPONENT_NAMES2 as COMPONENT_NAMES,
+  CONTROL_PARTS,
+  CORE_CATALOG_ID2 as CORE_CATALOG_ID,
+  CORE_FUNCTIONS2 as CORE_FUNCTIONS,
+  CORE_FUNCTION_NAMES2 as CORE_FUNCTION_NAMES,
+  CORE_LITE_CATALOG_ID2 as CORE_LITE_CATALOG_ID,
+  DEFAULT_LOCALE,
+  DEFAULT_MEDIA_SCHEMES2 as DEFAULT_MEDIA_SCHEMES,
+  DEFAULT_STRINGS2 as DEFAULT_STRINGS,
+  DEFAULT_THEME_ID2 as DEFAULT_THEME_ID,
+  DEFAULT_URL_SCHEMES2 as DEFAULT_URL_SCHEMES,
+  DENSITIES2 as DENSITIES,
+  DONUT_HOLE,
+  ENGLISH_DATE_PATTERNS2 as ENGLISH_DATE_PATTERNS,
+  ENGLISH_DATE_TIME_JOIN2 as ENGLISH_DATE_TIME_JOIN,
+  ENGLISH_FORMAT_FUNCTIONS2 as ENGLISH_FORMAT_FUNCTIONS,
+  ENGLISH_TIME_PATTERN2 as ENGLISH_TIME_PATTERN,
+  ENUMS2 as ENUMS,
+  EXTENSION_MESSAGE_KINDS2 as EXTENSION_MESSAGE_KINDS,
+  ExponentialConnector,
+  ExponentialHost2 as ExponentialHost,
+  FIELD_INTRINSIC_WIDTH,
+  FORMATTER_METHODS2 as FORMATTER_METHODS,
+  FORMAT_FUNCTION_NAMES2 as FORMAT_FUNCTION_NAMES,
+  FUNCTION_NAMES2 as FUNCTION_NAMES,
+  GEOMETRY_KEYS,
+  HOST_CONTRACT2 as HOST_CONTRACT,
+  HOST_CONTRACT_VERSION2 as HOST_CONTRACT_VERSION,
+  HOST_ERROR_CODES2 as HOST_ERROR_CODES,
+  HostRouter2 as HostRouter,
+  ICON_NAMES2 as ICON_NAMES,
+  JsonlDecoder2 as JsonlDecoder,
+  JsonlStreamTransport2 as JsonlStreamTransport,
+  LAYOUT_CONSTANTS,
+  LIMITS2 as LIMITS,
+  LIMIT_ISSUES2 as LIMIT_ISSUES,
+  LITE_CATALOG_ID2 as LITE_CATALOG_ID,
+  LITE_COMPONENTS2 as LITE_COMPONENTS,
+  MACRO_COMPONENTS2 as MACRO_COMPONENTS,
+  MAX_COMPONENTS2 as MAX_COMPONENTS,
+  MAX_DEPTH2 as MAX_DEPTH,
+  MAX_MESSAGE_BYTES2 as MAX_MESSAGE_BYTES,
+  MAX_POINTER_BYTES2 as MAX_POINTER_BYTES,
+  MAX_POINTER_SEGMENTS2 as MAX_POINTER_SEGMENTS,
+  MAX_TEMPLATE_ITEMS2 as MAX_TEMPLATE_ITEMS,
+  MCP_ACTION_TOOL2 as MCP_ACTION_TOOL,
+  MCP_MIME_TYPES2 as MCP_MIME_TYPES,
+  MEDIA_ASPECT_RATIO,
+  MEDIA_INTRINSIC_WIDTH,
+  MEDIA_LIMITS2 as MEDIA_LIMITS,
+  MESSAGE_KINDS2 as MESSAGE_KINDS,
+  MODES2 as MODES,
+  McpTransport2 as McpTransport,
+  MemoryTransport2 as MemoryTransport,
+  NATIVE_COMPONENTS2 as NATIVE_COMPONENTS,
+  OVERLAY_OFFSET,
+  OVERLAY_PADDING,
+  PAINT_ERROR_HOOK2 as PAINT_ERROR_HOOK,
+  PANEL_MIN,
+  PENDING_DELAY_MS,
+  POINTER_ISSUES2 as POINTER_ISSUES,
+  PackageError2 as PackageError,
+  RECIPE_KEYS2 as RECIPE_KEYS,
+  RECIPE_STATES2 as RECIPE_STATES,
+  RENDER_FAILED2 as RENDER_FAILED,
+  RESERVED_KEYS2 as RESERVED_KEYS,
+  RESIZE_HANDLE_HIT,
+  RESIZE_STEP,
+  RTL_MIRRORED_ICONS,
+  SEARCH_LIST_FADE,
+  SHADCN_COLOR_VARS,
+  SKELETON_OPACITY_HIGH,
+  SKELETON_OPACITY_LOW,
+  SKELETON_PULSE_MS,
+  SKELETON_REDUCED_OPACITY,
+  SPECIMEN_IDS2 as SPECIMEN_IDS,
+  SSE_EVENTS2 as SSE_EVENTS,
+  STRING_IDS2 as STRING_IDS,
+  STYLE_KEYS2 as STYLE_KEYS,
+  STYLE_KEY_NAMES2 as STYLE_KEY_NAMES,
+  STYLE_LAYOUT_EFFECT_KEYS2 as STYLE_LAYOUT_EFFECT_KEYS,
+  STYLE_LAYOUT_KEYS2 as STYLE_LAYOUT_KEYS,
+  STYLE_MEDIA2 as STYLE_MEDIA,
+  STYLE_STATES2 as STYLE_STATES,
+  STYLE_STATE_NAMES2 as STYLE_STATE_NAMES,
+  STYLE_TRANSFORM2 as STYLE_TRANSFORM,
+  STYLE_VISUAL_KEYS2 as STYLE_VISUAL_KEYS,
+  SUPPORTED_CATALOG_IDS2 as SUPPORTED_CATALOG_IDS,
+  SURFACE_COMMANDS2 as SURFACE_COMMANDS,
+  SURFACE_SETTING_KEYS2 as SURFACE_SETTING_KEYS,
+  SseDecoder2 as SseDecoder,
+  SseTransport2 as SseTransport,
+  SurfaceStore2 as SurfaceStore,
+  TEXT_SHIMMER,
+  THEME_SCHEMA_ID2 as THEME_SCHEMA_ID,
+  TOKEN_GROUPS2 as TOKEN_GROUPS,
+  TOKEN_NAMES2 as TOKEN_NAMES,
+  TREE_GUIDE_BRIDGE,
+  TREE_GUIDE_COLUMN,
+  TREE_GUIDE_RADIUS,
+  ThemeError2 as ThemeError,
+  UNKNOWN_COMPONENT2 as UNKNOWN_COMPONENT,
+  UNKNOWN_COMPONENT_NAME2 as UNKNOWN_COMPONENT_NAME,
+  WINDOW_OVERSCAN,
+  WINDOW_THRESHOLD,
+  WebSocketTransport2 as WebSocketTransport,
+  absolutePath2 as absolutePath,
+  actionMessage2 as actionMessage,
+  activeBreakpoint2 as activeBreakpoint,
+  animatesOpacity,
+  animationCss,
+  animationFrame,
+  animationTiming,
+  ansiRuns,
+  applyContrast2 as applyContrast,
+  applyDensity2 as applyDensity,
+  applyTreeGuides2 as applyTreeGuides,
+  basicMap2 as basicMap,
+  bind,
+  bindRowSlot2 as bindRowSlot,
+  bindSectionHeader2 as bindSectionHeader,
+  bindTree2 as bindTree,
+  builtinTheme2 as builtinTheme,
+  builtinThemes2 as builtinThemes,
+  call,
+  catalogView2 as catalogView,
+  chartExtent,
+  chartSummaryParams,
+  checkGeometry,
+  childTemplate2 as childTemplate,
+  clampNumber2 as clampNumber,
+  clientCapabilities2 as clientCapabilities,
+  codeText,
+  combineDecisions2 as combineDecisions,
+  componentA11y,
+  componentDef2 as componentDef,
+  componentNames2 as componentNames,
+  contrast2 as contrast,
+  controlGeometry,
+  coreCatalog2 as coreCatalog,
+  coreLite2 as coreLite,
+  coreMacros2 as coreMacros,
+  create2 as create,
+  createAppHost,
+  cubicBezier,
+  currencyDigits2 as currencyDigits,
+  decideFunction2 as decideFunction,
+  decideUrl2 as decideUrl,
+  decodeJsonl2 as decodeJsonl,
+  defineExtension,
+  defineSurface,
+  diffTheme,
+  displayString2 as displayString,
+  dragDelta,
+  easingCss2 as easingCss,
+  el,
+  englishFormatter2 as englishFormatter,
+  errorMessage2 as errorMessage,
+  evalCondition2 as evalCondition,
+  evalConditionValue2 as evalConditionValue,
+  evalExpr2 as evalExpr,
+  evalValue2 as evalValue,
+  event,
+  expandMacros2 as expandMacros,
+  exponentialTheme2 as exponentialTheme,
+  exportThemeJson,
+  fillTemplate2 as fillTemplate,
+  filterItems2 as filterItems,
+  fixedOffset2 as fixedOffset,
+  flattenSurface,
+  formatFunctions2 as formatFunctions,
+  formatPattern2 as formatPattern,
+  formatString2 as formatString,
+  gradientCss,
+  hasItem2 as hasItem,
+  hasRowSlots2 as hasRowSlots,
+  imageDimensions2 as imageDimensions,
+  imageFrames2 as imageFrames,
+  importShadcnCss,
+  instanceSegment,
+  intlFormatter2 as intlFormatter,
+  intlZoneOffset2 as intlZoneOffset,
+  isA11yRole,
+  isBinding2 as isBinding,
+  isCall2 as isCall,
+  isCallableName2 as isCallableName,
+  isDataSchema2 as isDataSchema,
+  isDynamic2 as isDynamic,
+  isKnownToken2 as isKnownToken,
+  isOffered2 as isOffered,
+  isPrivateHost2 as isPrivateHost,
+  isResponsiveValue2 as isResponsiveValue,
+  isRowRoot2 as isRowRoot,
+  isStringRef2 as isStringRef,
+  isThemeHex2 as isThemeHex,
+  isVisible2 as isVisible,
+  itemExtents,
+  itemOffsets,
+  keyboardResize,
+  keyframesCss,
+  listSections,
+  loadTheme2 as loadTheme,
+  localeRegion,
+  luminance2 as luminance,
+  macroParts2 as macroParts,
+  mapBasicComponent2 as mapBasicComponent,
+  mapBasicIcon2 as mapBasicIcon,
+  matchesPattern2 as matchesPattern,
+  mcpActionCall2 as mcpActionCall,
+  mediaImageWithinLimits2 as mediaImageWithinLimits,
+  mediaMatches2 as mediaMatches,
+  mediaRequest2 as mediaRequest,
+  mergeData2 as mergeData,
+  messagesFromMcpResult2 as messagesFromMcpResult,
+  mirrorsInRtl,
+  nativeRecipeProps2 as nativeRecipeProps,
+  neutralTheme2 as neutralTheme,
+  niceTicks,
+  nodeDirections,
+  nodeRecipeQuery2 as nodeRecipeQuery,
+  nodeTextAlign,
+  normalizePath2 as normalizePath,
+  normalizeSizes,
+  orangeTheme2 as orangeTheme,
+  packagePolicy2 as packagePolicy,
+  paintedOpacity,
+  panelExtents,
+  parseColor2 as parseColor,
+  parseDateValue2 as parseDateValue,
+  parseLocale,
+  parseMediaCondition2 as parseMediaCondition,
+  parseShadow,
+  parseSource2 as parseSource,
+  parseStringRef2 as parseStringRef,
+  parseThemeJson,
+  parseTokenRef2 as parseTokenRef,
+  percent2 as percent,
+  physicalTextAlign,
+  pkcePair,
+  placeOverlay,
+  playfulTheme2 as playfulTheme,
+  preorder2 as preorder,
+  props2 as props,
+  propsAt2 as propsAt,
+  readPath2 as readPath,
+  readPointer2 as readPointer,
+  recipeParts2 as recipeParts,
+  recipeStyle2 as recipeStyle,
+  reduceNested2 as reduceNested,
+  reduceSurface2 as reduceSurface,
+  relativeTimeUnit2 as relativeTimeUnit,
+  resizePanels,
+  resolveConditionKey2 as resolveConditionKey,
+  resolveConditions2 as resolveConditions,
+  resolveDynamic2 as resolveDynamic,
+  resolveMode2 as resolveMode,
+  resolveNodeProps2 as resolveNodeProps,
+  resolveNodeStyle2 as resolveNodeStyle,
+  resolveProp2 as resolveProp,
+  resolveRecipe2 as resolveRecipe,
+  resolveString2 as resolveString,
+  resolveStyleValues2 as resolveStyleValues,
+  resolveSurfaceTheme2 as resolveSurfaceTheme,
+  resolveToken2 as resolveToken,
+  responsiveAt2 as responsiveAt,
+  rowScope2 as rowScope,
+  run,
+  runAction2 as runAction,
+  safeHref2 as safeHref,
+  scrollOffsetForIndex,
+  scrollOffsetForItem,
+  sectionRows,
+  sectionScope2 as sectionScope,
+  seriesColor,
+  shadowCss2 as shadowCss,
+  sharedCatalogView2 as sharedCatalogView,
+  slotAllowed2 as slotAllowed,
+  sortKeys2 as sortKeys,
+  sourceAllowed2 as sourceAllowed,
+  sparklineSummaryParams,
+  stickyHeader,
+  stringTable2 as stringTable,
+  styleAttribute,
+  styleKeyEnum2 as styleKeyEnum,
+  styleKeyType2 as styleKeyType,
+  styleToCss,
+  submitClosesOverlay2 as submitClosesOverlay,
+  supportedCatalogIds2 as supportedCatalogIds,
+  svgDimensions2 as svgDimensions,
+  tableRowKeys,
+  templateBudget,
+  templateInstances,
+  templateItemKeys,
+  templateMessages2 as templateMessages,
+  templateSiteKey,
+  textDirection,
+  textShimmer,
+  themeFromImport,
+  themeOrDefault2 as themeOrDefault,
+  toHex2 as toHex,
+  toThemeHex2 as toThemeHex,
+  tokenizeCode,
+  treeGuides2 as treeGuides,
+  truthy2 as truthy,
+  tryLoadTheme2 as tryLoadTheme,
+  ui,
+  validVisible2 as validVisible,
+  validateExtension,
+  validateNode2 as validateNode,
+  validatePackage2 as validatePackage,
+  validateProps2 as validateProps,
+  validateStyle2 as validateStyle,
+  validateTheme2 as validateTheme,
+  valuesEqual2 as valuesEqual,
+  verifyPainterGeometry,
+  virtualWindow,
+  weekStart,
+  withOwnWrites2 as withOwnWrites,
+  writePointer2 as writePointer,
+  writeTokens2 as writeTokens
+};
+
+//# debugId=B7BF51E65B713F9764756E2164756E21
+//# sourceMappingURL=index.js.map