@qredence/fleet 0.5.1 → 0.5.5

package/dist/web/server/{chunk-2U7PWSJX.js → chunk-WZNZQNI4.js}

@@ -1,24 +1,38 @@
 import {
   UiErrorBoundary,
   encodeOpenPanelActionMessage
-} from "./chunk-HBZ6YKRB.js";
+} from "./chunk-WN77JNYY.js";
 import {
+  ACTION_STEPS,
+  BuiltinActionType,
   Card,
   CardContent,
   CardDescription,
   CardHeader,
   CardTitle,
+  ToolNotFoundError,
+  createLibrary,
+  createQueryManager,
+  createStore,
+  createStreamingParser,
+  defineComponent,
+  enrichErrors,
+  evaluate,
+  evaluateElementProps,
+  extractToolResult,
+  markReactive,
+  parseStructuredRules,
+  resolveStateField,
+  tagSchemaId,
+  validate,
   validateAndNormalizeOpenUIHtmlArtifact
-} from "./chunk-ZEVZFLIY.js";
+} from "./chunk-KOIPYBJF.js";
 import {
   OpenPanelActionSchema,
   RightPanelIdSchema,
   WorkspaceRelativePathSchema,
-  external_exports,
-  object,
-  registry,
-  toJSONSchema
-} from "./chunk-B2F6MLVZ.js";
+  external_exports
+} from "./chunk-XFVL5ITL.js";
 import {
   segmentOpenUIContent
 } from "./chunk-NFRJDPB3.js";
@@ -63,7 +77,7 @@ import {
   Separator,
   Switch,
   useRender
-} from "./chunk-FBOO3G67.js";
+} from "./chunk-AECEK3K7.js";
 import {
   Select,
   arrow$2,
@@ -76,34 +90,34 @@ import {
   shift,
   size,
   useFloating
-} from "./chunk-DO3TVNGA.js";
+} from "./chunk-TO3YPLNZ.js";
 import {
   ChevronDown
 } from "./chunk-QLY3L4A2.js";
 import {
   Input
-} from "./chunk-VHCAD46L.js";
+} from "./chunk-AWFOBHH4.js";
 import {
   Dialog,
   DialogContent,
   DialogHeader,
   DialogTitle
-} from "./chunk-FE4KN6T2.js";
+} from "./chunk-RX62LUDV.js";
 import {
   Button,
   cva,
   require_with_selector,
   visuallyHidden
-} from "./chunk-RPROZ2JC.js";
+} from "./chunk-5RQ6QAZX.js";
 import {
   useBaseUiId
-} from "./chunk-XYYNYFFD.js";
+} from "./chunk-LSIHVSUT.js";
 import {
   formatErrorMessage,
   mergeProps,
   useIsoLayoutEffect,
   useRenderElement
-} from "./chunk-X2TUFLTP.js";
+} from "./chunk-BLVCDQ7E.js";
 import {
   characterEntitiesLegacy
 } from "./chunk-ST5I2PLN.js";
@@ -134,7 +148,7 @@ import {
   __toESM
 } from "./chunk-L547YHC4.js";
 
-// web/app/dist/server/assets/openui-renderer-Cg4RSE9k.js
+// web/app/dist/server/assets/openui-renderer-c36_GYes.js
 import * as React$2 from "react";
 import React, { Children, Component as Component2, Fragment as Fragment2, PureComponent, cloneElement as cloneElement2, createContext as createContext2, createElement as createElement2, forwardRef as forwardRef2, isValidElement as isValidElement2, memo as memo2, useCallback as useCallback2, useContext as useContext2, useEffect as useEffect2, useId as useId2, useImperativeHandle, useInsertionEffect, useLayoutEffect as useLayoutEffect3, useMemo as useMemo2, useRef as useRef2, useState as useState2, useSyncExternalStore } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
@@ -18430,3422 +18444,6 @@ function useRegisteredLabelId(idProp, setLabelId) {
   }, [id, setLabelId]);
   return id;
 }
-function resolveField(obj, path2) {
-  if (!path2 || obj == null) return void 0;
-  if (!path2.includes(".")) return obj[path2];
-  let cur = obj;
-  for (const p of path2.split(".")) {
-    if (cur == null) return void 0;
-    cur = cur[p];
-  }
-  return cur;
-}
-function toNumber$2(val) {
-  if (typeof val === "number") return val;
-  if (typeof val === "string") {
-    const n = Number(val);
-    return isNaN(n) ? 0 : n;
-  }
-  if (typeof val === "boolean") return val ? 1 : 0;
-  return 0;
-}
-var BUILTINS = {
-  Count: {
-    name: "Count",
-    signature: "Count(array) \u2192 number",
-    description: "Returns array length",
-    fn: (arr) => Array.isArray(arr) ? arr.length : 0
-  },
-  First: {
-    name: "First",
-    signature: "First(array) \u2192 element",
-    description: "Returns first element of array",
-    fn: (arr) => Array.isArray(arr) ? arr[0] ?? null : null
-  },
-  Last: {
-    name: "Last",
-    signature: "Last(array) \u2192 element",
-    description: "Returns last element of array",
-    fn: (arr) => Array.isArray(arr) ? arr[arr.length - 1] ?? null : null
-  },
-  Sum: {
-    name: "Sum",
-    signature: "Sum(numbers[]) \u2192 number",
-    description: "Sum of numeric array",
-    fn: (arr) => Array.isArray(arr) ? arr.reduce((a2, b) => a2 + toNumber$2(b), 0) : 0
-  },
-  Avg: {
-    name: "Avg",
-    signature: "Avg(numbers[]) \u2192 number",
-    description: "Average of numeric array",
-    fn: (arr) => Array.isArray(arr) && arr.length ? arr.reduce((a2, b) => a2 + toNumber$2(b), 0) / arr.length : 0
-  },
-  Min: {
-    name: "Min",
-    signature: "Min(numbers[]) \u2192 number",
-    description: "Minimum value in array",
-    fn: (arr) => Array.isArray(arr) && arr.length ? arr.reduce((acc, b) => Math.min(acc, toNumber$2(b)), toNumber$2(arr[0])) : 0
-  },
-  Max: {
-    name: "Max",
-    signature: "Max(numbers[]) \u2192 number",
-    description: "Maximum value in array",
-    fn: (arr) => Array.isArray(arr) && arr.length ? arr.reduce((acc, b) => Math.max(acc, toNumber$2(b)), toNumber$2(arr[0])) : 0
-  },
-  Sort: {
-    name: "Sort",
-    signature: "Sort(array, field, direction?) \u2192 sorted array",
-    description: 'Sort array by field. Direction: "asc" (default) or "desc"',
-    fn: (arr, field, dir) => {
-      if (!Array.isArray(arr)) return arr;
-      const f = String(field ?? "");
-      const desc = String(dir ?? "asc") === "desc";
-      return [...arr].sort((a2, b) => {
-        const av = f ? resolveField(a2, f) : a2;
-        const bv = f ? resolveField(b, f) : b;
-        const aIsNumeric = typeof av === "number" || typeof av === "string" && !isNaN(Number(av)) && av !== "";
-        const bIsNumeric = typeof bv === "number" || typeof bv === "string" && !isNaN(Number(bv)) && bv !== "";
-        if (aIsNumeric && bIsNumeric) {
-          const diff2 = toNumber$2(av) - toNumber$2(bv);
-          return desc ? -diff2 : diff2;
-        }
-        const cmp = String(av ?? "").localeCompare(String(bv ?? ""));
-        return desc ? -cmp : cmp;
-      });
-    }
-  },
-  Filter: {
-    name: "Filter",
-    signature: 'Filter(array, field, operator: "==" | "!=" | ">" | "<" | ">=" | "<=" | "contains", value) \u2192 filtered array',
-    description: "Filter array by field value",
-    fn: (arr, field, op, value) => {
-      if (!Array.isArray(arr)) return [];
-      const f = String(field ?? "");
-      const o = String(op ?? "==");
-      return arr.filter((item) => {
-        const v2 = f ? resolveField(item, f) : item;
-        switch (o) {
-          case "==":
-            return v2 == value;
-          case "!=":
-            return v2 != value;
-          case ">":
-            return toNumber$2(v2) > toNumber$2(value);
-          case "<":
-            return toNumber$2(v2) < toNumber$2(value);
-          case ">=":
-            return toNumber$2(v2) >= toNumber$2(value);
-          case "<=":
-            return toNumber$2(v2) <= toNumber$2(value);
-          case "contains":
-            return String(v2 ?? "").includes(String(value ?? ""));
-          default:
-            return false;
-        }
-      });
-    }
-  },
-  Round: {
-    name: "Round",
-    signature: "Round(number, decimals?) \u2192 number",
-    description: "Round to N decimal places (default 0)",
-    fn: (n, decimals) => {
-      const num = toNumber$2(n);
-      const d2 = decimals != null ? toNumber$2(decimals) : 0;
-      const factor2 = Math.pow(10, d2);
-      return Math.round(num * factor2) / factor2;
-    }
-  },
-  Abs: {
-    name: "Abs",
-    signature: "Abs(number) \u2192 number",
-    description: "Absolute value",
-    fn: (n) => Math.abs(toNumber$2(n))
-  },
-  Floor: {
-    name: "Floor",
-    signature: "Floor(number) \u2192 number",
-    description: "Round down to nearest integer",
-    fn: (n) => Math.floor(toNumber$2(n))
-  },
-  Ceil: {
-    name: "Ceil",
-    signature: "Ceil(number) \u2192 number",
-    description: "Round up to nearest integer",
-    fn: (n) => Math.ceil(toNumber$2(n))
-  }
-};
-var LAZY_BUILTINS = /* @__PURE__ */ new Set(["Each"]);
-var LAZY_BUILTIN_DEFS = { Each: {
-  signature: "Each(array, varName, template)",
-  description: "Evaluate template for each element. varName is the loop variable \u2014 use it ONLY inside the template expression (inline). Do NOT create a separate statement for the template."
-} };
-var ACTION_STEPS = {
-  Run: "run",
-  ToAssistant: "continue_conversation",
-  OpenUrl: "open_url",
-  Set: "set",
-  Reset: "reset"
-};
-var ACTION_NAMES = /* @__PURE__ */ new Set(["Action", ...Object.keys(ACTION_STEPS)]);
-var BUILTIN_NAMES = /* @__PURE__ */ new Set([
-  ...Object.keys(BUILTINS),
-  ...LAZY_BUILTINS,
-  ...ACTION_NAMES
-]);
-function isBuiltin(name) {
-  return BUILTIN_NAMES.has(name);
-}
-var RESERVED_CALLS = {
-  Query: "Query",
-  Mutation: "Mutation"
-};
-function isReservedCall(name) {
-  return name in RESERVED_CALLS;
-}
-function jsonSchemaTypeStr(schema) {
-  const type = schema.type;
-  if (type === "string") {
-    const enumVals = schema.enum;
-    if (enumVals) return enumVals.map((v2) => `"${v2}"`).join(" | ");
-    return "string";
-  }
-  if (type === "number" || type === "integer") return "number";
-  if (type === "boolean") return "boolean";
-  if (type === "array") {
-    const items = schema.items;
-    if (items) return `${jsonSchemaTypeStr(items)}[]`;
-    return "any[]";
-  }
-  if (type === "object") {
-    const props = schema.properties;
-    if (props && Object.keys(props).length > 0) {
-      const required = schema.required ?? [];
-      return `{${Object.entries(props).map(([k2, v2]) => {
-        return `${k2}${required.includes(k2) ? "" : "?"}: ${jsonSchemaTypeStr(v2)}`;
-      }).join(", ")}}`;
-    }
-    return "object";
-  }
-  return "any";
-}
-function defaultForSchema(schema) {
-  const type = schema.type;
-  if (type === "string") return "";
-  if (type === "number" || type === "integer") return 0;
-  if (type === "boolean") return false;
-  if (type === "array") return [];
-  if (type === "object") {
-    const props = schema.properties;
-    if (props && Object.keys(props).length > 0) {
-      const result = {};
-      for (const [k2, v2] of Object.entries(props)) result[k2] = defaultForSchema(v2);
-      return result;
-    }
-    return {};
-  }
-  return null;
-}
-var PREAMBLE = `You are an AI assistant that responds using openui-lang, a declarative UI language. Your ENTIRE response must be valid openui-lang code \u2014 no markdown, no explanations, just openui-lang.`;
-function syntaxRules(rootName, flags) {
-  const lines = [
-    "## Syntax Rules",
-    "",
-    "1. Each statement is on its own line: `identifier = Expression`",
-    `2. \`root\` is the entry point \u2014 every program must define \`root = ${rootName}(...)\``,
-    '3. Expressions are: strings ("..."), numbers, booleans (true/false), null, arrays ([...]), objects ({...}), or component calls TypeName(arg1, arg2, ...)',
-    "4. Use references for readability: define `name = ...` on one line, then use `name` later",
-    "5. EVERY variable (except root) MUST be referenced by at least one other variable. Unreferenced variables are silently dropped and will NOT render. Always include defined variables in their parent's children/items array.",
-    '6. Arguments are POSITIONAL (order matters, not names). Write `Stack([children], "row", "l")` NOT `Stack([children], direction: "row", gap: "l")` \u2014 colon syntax is NOT supported and silently breaks',
-    "7. Optional arguments can be omitted from the end"
-  ];
-  let ruleNum = 8;
-  if (flags.bindings) lines.push(`${ruleNum++}. Declare mutable state with \`$varName = defaultValue\`. Components marked with \`$binding\` can read/write these. Undeclared $variables are auto-created with null default.`);
-  if (flags.supportsExpressions) lines.push(`${ruleNum++}. String concatenation: \`"text" + $var + "more"\``, `${ruleNum++}. Dot member access: \`query.field\` reads a field; on arrays it extracts that field from every element`, `${ruleNum++}. Index access: \`arr[0]\`, \`data[index]\``, `${ruleNum++}. Arithmetic operators: +, -, *, /, % (work on numbers; + is string concat when either side is a string)`, `${ruleNum++}. Comparison: ==, !=, >, <, >=, <=`, `${ruleNum++}. Logical: &&, ||, ! (prefix)`, `${ruleNum++}. Ternary: \`condition ? valueIfTrue : valueIfFalse\``, `${ruleNum++}. Parentheses for grouping: \`(a + b) * c\``);
-  lines.push("- Strings use double quotes with backslash escaping");
-  return lines.join("\n");
-}
-function builtinFunctionsSection() {
-  const builtinLines = Object.values(BUILTINS).map((b) => `@${b.signature} \u2014 ${b.description}`);
-  const lazyLines = Object.values(LAZY_BUILTIN_DEFS).map((b) => `@${b.signature} \u2014 ${b.description}`);
-  return `## Built-in Functions
-
-Data functions prefixed with \`@\` to distinguish from components. These are the ONLY functions available \u2014 do NOT invent new ones.
-Use @-prefixed built-in functions (@Count, @Sum, @Avg, @Min, @Max, @Round) on Query results \u2014 do NOT hardcode computed values.
-
-${[...builtinLines, ...lazyLines].join("\n")}
-
-Builtins compose \u2014 output of one is input to the next:
-\`@Count(@Filter(data.rows, "field", "==", "val"))\` for KPIs/chart values, \`@Round(@Avg(data.rows.score), 1)\`, \`@Each(data.rows, "item", Comp(item.field))\` for per-item rendering.
-Array pluck: \`data.rows.field\` extracts a field from every row \u2192 use with @Sum, @Avg, charts, tables.
-
-IMPORTANT @Each rule: The loop variable (e.g. "item") is ONLY available inside the @Each template expression. Always inline the template \u2014 do NOT extract it to a separate statement.
-CORRECT: \`Col("Actions", @Each(rows, "t", Button("Edit", Action([@Set($id, t.id)]))))\`
-WRONG: \`myBtn = Button("Edit", Action([@Set($id, t.id)]))\` then \`Col("Actions", @Each(rows, "t", myBtn))\` \u2014 t is undefined in myBtn.`;
-}
-function querySection() {
-  return `## Query \u2014 Live Data Fetching
-
-Fetch data from available tools. Returns defaults instantly, swaps in real data when it arrives.
-
-\`\`\`
-metrics = Query("tool_name", {arg1: value, arg2: $binding}, {defaultField: 0, defaultData: []}, refreshInterval?)
-\`\`\`
-
-- First arg: tool name (string)
-- Second arg: arguments object (may reference $bindings \u2014 re-fetches automatically on change)
-- Third arg: default data (rendered immediately before fetch resolves)
-- Fourth arg (optional): refresh interval in seconds (e.g. 30 for auto-refresh every 30s)
-- Use dot access on results: metrics.totalEvents, metrics.data.day (array pluck)
-- Query results must use regular identifiers: \`metrics = Query(...)\`, NOT \`$metrics = Query(...)\`
-- Manual refresh: \`Button("Refresh", Action([@Run(query1), @Run(query2)]), "secondary")\` \u2014 re-fetches the listed queries
-- Refresh all queries: create Action with @Run for each query`;
-}
-function mutationSection() {
-  return `## Mutation \u2014 Write Operations
-
-Execute state-changing tool calls (create, update, delete). Unlike Query (auto-fetches on render), Mutation fires only on button click via Action.
-
-\`\`\`
-result = Mutation("tool_name", {arg1: $binding, arg2: "value"})
-\`\`\`
-
-- First arg: tool name (string)
-- Second arg: arguments object (evaluated with current $binding values at click time)
-- result.status: "idle" | "loading" | "success" | "error"
-- result.data: tool response on success
-- result.error: error message on failure
-- Mutation results use regular identifiers: \`result = Mutation(...)\`, NOT \`$result\`
-- Show loading state: \`result.status == "loading" ? TextContent("Saving...") : null\``;
-}
-function actionSection(flags) {
-  const steps = ['- @ToAssistant("message") \u2014 Send a message to the assistant (for conversational buttons like "Tell me more", "Explain this")', '- @OpenUrl("https://...") \u2014 Navigate to a URL'];
-  if (flags.bindings) steps.push("- @Set($variable, value) \u2014 Set a $variable to a specific value", '- @Reset($var1, $var2, ...) \u2014 Reset $variables to their declared defaults (e.g. @Reset($title, $priority) restores $title="" and $priority="medium")');
-  if (flags.toolCalls) steps.unshift("- @Run(queryOrMutationRef) \u2014 Execute a Mutation or re-fetch a Query (ref must be a declared Query/Mutation)");
-  const examples = [];
-  if (flags.toolCalls) examples.push(`Example \u2014 mutation + refresh + reset (PREFERRED pattern):
-\`\`\`
-$binding = "default"
-result = Mutation("tool_name", {field: $binding})
-data = Query("tool_name", {}, {rows: []})
-onSubmit = Action([@Run(result), @Run(data), @Reset($binding)])
-\`\`\``);
-  examples.push(`Example \u2014 simple nav:
-\`\`\`
-viewBtn = Button("View", Action([@OpenUrl("https://example.com")]))
-\`\`\``);
-  const rules = ['- Action can be assigned to a variable or inlined: Button("Go", onSubmit) and Button("Go", Action([...])) both work'];
-  if (flags.toolCalls) rules.push("- If a @Run(mutation) step fails, remaining steps are skipped (halt on failure)", "- @Run(queryRef) re-fetches the query (fire-and-forget, cannot fail)");
-  return `## Action \u2014 Button Behavior
-
-Action([@steps...]) wires button clicks to operations. Steps are @-prefixed built-in actions. Steps execute in order.
-Buttons without an explicit Action prop automatically send their label to the assistant (equivalent to Action([@ToAssistant(label)])).
-
-Available steps:
-${steps.join("\n")}
-
-${examples.join("\n\n")}
-
-${rules.join("\n")}`;
-}
-function interactiveFiltersSection() {
-  return `## Interactive Filters
-
-To let the user filter data with a dropdown:
-1. Declare a $variable with a default: \`$dateRange = "14"\`
-2. Create a Select with name, items, and binding: \`Select("dateRange", [SelectItem("7", "Last 7 days"), ...], null, null, $dateRange)\`
-3. Wrap in FormControl for a label: \`FormControl("Date Range", Select(...))\`
-4. Pass $dateRange in Query args: \`Query("tool", {dateRange: $dateRange}, {defaults})\`
-5. When the user changes the Select, $dateRange updates and the Query automatically re-fetches
-
-FILTER WIRING RULE: If a $binding filter is visible in the UI, EVERY relevant Query MUST reference that $binding in its args. Never show a filter dropdown while hardcoding the query args.
-
-Rules for $variables:
-- $variables hold simple values (strings or numbers), NOT arrays or objects
-- $variables must be bound to a Select/Input component via the value argument (last positional arg) to be interactive
-- Queries must use regular identifiers (NOT $variables): \`metrics = Query(...)\` not \`$metrics = Query(...)\`
-- **Auto-declare**: You do NOT need to explicitly declare $variables. If you use \`$foo\` without declaring it, the parser auto-creates \`$foo = null\`. You can still declare explicitly to set a default: \`$days = "14"\`
-
-## Forms
-
-Simple form \u2014 no $bindings needed. Field values are managed internally by the Form via the name prop:
-\`\`\`
-contactForm = Form("contact", submitBtn, [nameField, emailField])
-nameField = FormControl("Name", Input("name", "Your name", "text", {required: true}))
-emailField = FormControl("Email", Input("email", "your@email.com", "email", {required: true, email: true}))
-submitBtn = Button("Submit")
-\`\`\`
-
-Use $bindings when you need to read field values elsewhere (in Action context, Query args, or conditionals). They are auto-declared:
-\`\`\`
-$role = "engineer"
-contactForm = Form("contact", submitBtn, [nameField, emailField, roleField])
-nameField = FormControl("Name", Input("name", "Enter your name", "text", {required: true}, $name))
-emailField = FormControl("Email", Input("email", "Enter your email", "email", {required: true, email: true}, $email))
-roleField = FormControl("Role", Select("role", [SelectItem("engineer", "Engineer"), SelectItem("designer", "Designer"), SelectItem("pm", "PM")], null, {required: true}, $role))
-submitBtn = Button("Submit")
-\`\`\`
-
-For form + mutation patterns (create, refresh, reset), see the Action section example above.
-
-IMPORTANT: Always add validation rules to form fields used with Mutations. Use OBJECT syntax: {required: true, email: true, minLength: 8}. The renderer shows error messages automatically and blocks submit when validation fails.`;
-}
-function editModeSection() {
-  return `## Edit Mode
-
-The runtime merges by statement name: same name = replace, new name = append.
-Output ONLY statements that changed or are new. Everything else is kept automatically.
-
-### Delete
-To remove a component, update the parent to exclude it from its children array. Orphaned statements are automatically garbage-collected.
-Example \u2014 remove chart: \`root = Stack([header, kpiRow, table])\` \u2014 chart is no longer in the children list, so it and any statements only it referenced are auto-deleted.
-
-### Patch size guide
-- Changing a title or label: 1 statement
-- Adding a component: 2-3 statements (the new component + parent update)
-- Removing a component: 1 statement (re-declare parent without the removed child)
-- Adding a filter + wiring to query: 3-5 statements
-- Restructuring into tabs: 5-10 statements
-
-### Rules
-- Reuse existing statement names exactly \u2014 do not rename
-- Do NOT re-emit unchanged statements \u2014 the runtime keeps them
-- A typical edit patch is 1-10 statements, not 20+
-- If the existing code already satisfies the request, output only the root statement
-- NEVER output the entire program as a patch. Only output what actually changes
-- If you are about to output more than 10 statements, reconsider \u2014 most edits need fewer`;
-}
-function streamingRules(rootName, flags) {
-  const steps = [`1. \`root = ${rootName}(...)\` \u2014 UI shell appears immediately`];
-  if (flags.supportsExpressions) {
-    steps.push("2. $variable declarations \u2014 state ready for bindings");
-    steps.push("3. Query statements \u2014 defaults resolve immediately so components render with data");
-    steps.push("4. Component definitions \u2014 fill in with data already available");
-    steps.push("5. Data values \u2014 leaf content last");
-  } else {
-    steps.push("2. Component definitions \u2014 fill in as they stream");
-    steps.push("3. Data values \u2014 leaf content last");
-  }
-  return `## Hoisting & Streaming (CRITICAL)
-
-openui-lang supports hoisting: a reference can be used BEFORE it is defined. The parser resolves all references after the full input is parsed.
-
-During streaming, the output is re-parsed on every chunk. Undefined references are temporarily unresolved and appear once their definitions stream in. This creates a progressive top-down reveal \u2014 structure first, then data fills in.
-
-**Recommended statement order for optimal streaming:**
-${steps.join("\n")}
-
-Always write the root = ${rootName}(...) statement first so the UI shell appears immediately, even before child data has streamed in.`;
-}
-function inlineModeSection() {
-  return `## Inline Mode
-
-You are in inline mode. You can respond in two ways:
-
-### 1. Code response (when the user wants to CREATE or CHANGE the UI)
-Wrap openui-lang code in triple-backtick fences. You can include explanatory text before/after:
-
-Here's your dashboard:
-
-\`\`\`openui-lang
-root = RootComp([header, content])
-header = SomeHeader("Title")
-content = SomeContent("Hello world")
-\`\`\`
-
-I created a simple layout with a header.
-
-### 2. Text-only response (when the user asks a QUESTION)
-If the user asks "what is this?", "explain the chart", "how does this work", etc. \u2014 respond with plain text. Do NOT output any openui-lang code. The existing dashboard stays unchanged.
-
-### Rules
-- When the user asks for changes, output ONLY the changed/new statements in a fenced block
-- When the user asks a question, respond with text only \u2014 NO code. The dashboard stays unchanged.
-- The parser extracts code from fences automatically. Text outside fences is shown as chat.`;
-}
-function toolWorkflowSection() {
-  return `## Data Workflow
-
-When tools are available, follow this workflow:
-1. FIRST: Call the most relevant tool to inspect the real data shape before generating code
-2. Use Query() for READ operations (data that should stay live) \u2014 NEVER hardcode tool results as literal arrays or objects
-3. Use Mutation() for WRITE operations (create, update, delete) \u2014 triggered by button clicks via Action([@Run(mutationRef)])
-4. Use the real data from step 1 as condensed Query defaults (3-5 rows) so the UI renders immediately
-5. Use @-prefixed builtins (@Count, @Filter, @Sort, @Sum) on Query results for KPIs and aggregations \u2014 the runtime evaluates these live on every refresh
-6. Hardcoded arrays are ONLY for static display data (labels, options) where no tool exists
-
-WRONG \u2014 you called a tool and got data back, but you inlined the results:
-\`\`\`
-openCount = 2
-item1 = SomeComp("first item title")
-item2 = SomeComp("second item title")
-list = Stack([item1, item2])
-chart = SomeChart(["A", "B"], [12, 8])
-\`\`\`
-This is static \u2014 it shows stale data and won't update. Creating item1, item2, item3... manually is ALWAYS wrong when a tool exists.
-
-RIGHT \u2014 use Query() for live data, Mutation() for writes, @builtins to derive values:
-\`\`\`
-data = Query("tool_name", {}, {rows: []})
-openCount = @Count(@Filter(data.rows, "field", "==", "value"))
-list = @Each(data.rows, "item", SomeComp(item.title, item.field))
-createResult = Mutation("create_tool", {title: $title})
-submitBtn = Button("Create", Action([@Run(createResult), @Run(data), @Reset($title)]))
-\`\`\`
-Everything derives from the Query \u2014 when data refreshes, the entire dashboard updates automatically.`;
-}
-function importantRules(rootName, flags) {
-  const verifyLines = [`1. root = ${rootName}(...) is the FIRST line (for optimal streaming).`, "2. Every referenced name is defined. Every defined name (other than root) is reachable from root."];
-  if (flags.toolCalls) verifyLines.push("3. Every Query result is referenced by at least one component.");
-  if (flags.bindings) verifyLines.push(`${flags.toolCalls ? "4" : "3"}. Every $binding appears in at least one component or expression.`);
-  if (flags.toolCalls && flags.bindings) verifyLines.push("5. Every visible filter $binding appears in at least one Query args object.");
-  return `## Important Rules
-- When asked about data, generate realistic/plausible data
-- Choose components that best represent the content (tables for comparisons, charts for trends, forms for input, etc.)
-
-## Final Verification
-Before finishing, walk your output and verify:
-${verifyLines.join("\n")}`;
-}
-function renderToolSignature(tool) {
-  let args = "";
-  if (tool.inputSchema) {
-    const props = tool.inputSchema.properties;
-    const required = tool.inputSchema.required ?? [];
-    if (props && Object.keys(props).length > 0) args = Object.entries(props).map(([k2, v2]) => {
-      return `${k2}${required.includes(k2) ? "" : "?"}: ${jsonSchemaTypeStr(v2)}`;
-    }).join(", ");
-  }
-  let returnType = "";
-  if (tool.outputSchema) returnType = ` \u2192 ${jsonSchemaTypeStr(tool.outputSchema)}`;
-  let line = `- ${tool.name}(${args})${returnType}`;
-  if (tool.description) line += `
-  ${tool.description}`;
-  return line;
-}
-function renderToolsSection(tools) {
-  const lines = [];
-  const stringTools = [];
-  const specTools = [];
-  for (const tool of tools) if (typeof tool === "string") stringTools.push(tool);
-  else specTools.push(tool);
-  lines.push("## Available Tools");
-  lines.push("");
-  lines.push("Use these with Query() for read operations or Mutation() for write operations. The LLM decides which is appropriate based on the tool's purpose.");
-  lines.push("");
-  for (const t of stringTools) lines.push(`- ${t}`);
-  for (const t of specTools) lines.push(renderToolSignature(t));
-  const toolsWithOutput = specTools.filter((t) => t.outputSchema);
-  if (toolsWithOutput.length > 0) {
-    lines.push("");
-    lines.push("### Default values for Query results");
-    lines.push("");
-    lines.push("Use these shapes as minimal Query defaults:");
-    for (const t of toolsWithOutput) {
-      const defaults2 = defaultForSchema(t.outputSchema);
-      lines.push(`- ${t.name}: \`${JSON.stringify(defaults2)}\``);
-    }
-  }
-  lines.push("");
-  lines.push("CRITICAL: Use ONLY the tools listed above in Query() and Mutation() calls. Do NOT invent or guess tool names. If the user asks for functionality that doesn't match any available tool, use realistic mock data instead of fabricating a tool call.");
-  return lines.join("\n");
-}
-function generateComponentSignatures(spec, flags) {
-  const lines = [
-    "## Component Signatures",
-    "",
-    "Arguments marked with ? are optional. Sub-components can be inline or referenced; prefer references for better streaming."
-  ];
-  if (flags.usesActionExpression) {
-    const allSteps = [
-      flags.toolCalls ? "@Run" : "",
-      "@ToAssistant",
-      "@OpenUrl",
-      flags.bindings ? "@Set" : "",
-      flags.bindings ? "@Reset" : ""
-    ].filter(Boolean);
-    lines.push(`Props typed \`ActionExpression\` accept an Action([@steps...]) expression. See the Action section for available steps (${allSteps.join(", ")}).`);
-  }
-  if (flags.bindings || Object.values(spec.components).some((c2) => c2.signature?.includes("$binding"))) lines.push("Props marked `$binding<type>` accept a `$variable` reference for two-way binding.");
-  const formatSig = (comp) => comp.description ? `${comp.signature} \u2014 ${comp.description}` : comp.signature;
-  if (spec.componentGroups?.length) {
-    const grouped = /* @__PURE__ */ new Set();
-    for (const group of spec.componentGroups) {
-      lines.push("", `### ${group.name}`);
-      for (const name of group.components) {
-        if (grouped.has(name)) continue;
-        const comp = spec.components[name];
-        if (!comp) continue;
-        grouped.add(name);
-        lines.push(formatSig(comp));
-      }
-      if (group.notes?.length) for (const note of group.notes) lines.push(note);
-    }
-    const ungrouped = Object.keys(spec.components).filter((n) => !grouped.has(n));
-    if (ungrouped.length) {
-      lines.push("", "### Other");
-      for (const name of ungrouped) {
-        const comp = spec.components[name];
-        lines.push(formatSig(comp));
-      }
-    }
-  } else {
-    lines.push("");
-    for (const [, comp] of Object.entries(spec.components)) lines.push(formatSig(comp));
-  }
-  return lines.join("\n");
-}
-function generatePrompt(spec) {
-  const rootName = spec.root ?? "Root";
-  const hasTools = !!spec.tools?.length;
-  const toolCalls = spec.toolCalls ?? hasTools;
-  const bindings = spec.bindings ?? toolCalls;
-  const supportsExpressions = toolCalls || bindings;
-  const usesActionExpression = Object.values(spec.components).some((c2) => c2.signature?.includes("ActionExpression"));
-  const parts = [];
-  parts.push(spec.preamble ?? PREAMBLE);
-  parts.push("");
-  parts.push(syntaxRules(rootName, {
-    supportsExpressions,
-    bindings
-  }));
-  parts.push("");
-  parts.push(generateComponentSignatures(spec, {
-    toolCalls,
-    bindings,
-    usesActionExpression
-  }));
-  if (supportsExpressions) {
-    parts.push("");
-    parts.push(builtinFunctionsSection());
-  }
-  if (toolCalls) {
-    parts.push("");
-    parts.push(querySection());
-    parts.push("");
-    parts.push(mutationSection());
-  }
-  if (usesActionExpression) {
-    parts.push("");
-    parts.push(actionSection({
-      toolCalls,
-      bindings
-    }));
-  }
-  if (toolCalls && bindings) {
-    parts.push("");
-    parts.push(interactiveFiltersSection());
-  }
-  if (toolCalls) {
-    parts.push("");
-    parts.push(toolWorkflowSection());
-  }
-  if (spec.tools?.length) {
-    parts.push("");
-    parts.push(renderToolsSection(spec.tools));
-  }
-  parts.push("");
-  parts.push(streamingRules(rootName, { supportsExpressions }));
-  const allExamples = [...spec.examples ?? [], ...spec.toolExamples ?? []];
-  if (allExamples.length) {
-    parts.push("");
-    parts.push("## Examples");
-    parts.push("");
-    for (const ex of allExamples) {
-      parts.push(ex);
-      parts.push("");
-    }
-  }
-  if (spec.editMode) {
-    parts.push("");
-    parts.push(editModeSection());
-  }
-  if (spec.inlineMode) {
-    parts.push("");
-    parts.push(inlineModeSection());
-  }
-  parts.push(importantRules(rootName, {
-    toolCalls,
-    bindings
-  }));
-  if (spec.additionalRules?.length) {
-    parts.push("");
-    for (const rule of spec.additionalRules) parts.push(`- ${rule}`);
-  }
-  return parts.join("\n");
-}
-var reactiveSchemas = /* @__PURE__ */ new WeakSet();
-function markReactive(schema) {
-  reactiveSchemas.add(schema);
-}
-function isReactiveSchema(schema) {
-  return typeof schema === "object" && schema !== null && reactiveSchemas.has(schema);
-}
-var schemaIdTags = /* @__PURE__ */ new WeakMap();
-function tagSchemaId(schema, id) {
-  schemaIdTags.set(schema, id);
-}
-function assertV4Schema(schema, componentName) {
-  if (schema != null && typeof schema === "object" && "_def" in schema && !("_zod" in schema)) throw new Error(`[OpenUI] Component "${componentName}" was defined with a Zod 3 schema. OpenUI requires Zod 4 schemas. If you're on zod@3.25+, import from "zod/v4" instead of "zod". See: https://zod.dev/v4/versioning`);
-}
-function defineComponent(config2) {
-  assertV4Schema(config2.props, config2.name);
-  schemaIdTags.set(config2.props, config2.name);
-  return {
-    ...config2,
-    ref: config2.props
-  };
-}
-function getZodDef(schema) {
-  return schema?._zod?.def;
-}
-function getZodType(schema) {
-  return getZodDef(schema)?.type;
-}
-function isOptionalType(schema) {
-  const type = getZodType(schema);
-  return type === "optional" || type === "default" || type === "nullable";
-}
-function unwrap$1(schema) {
-  let s2 = schema;
-  let def = getZodDef(s2);
-  while (def?.type === "optional" || def?.type === "default" || def?.type === "nullable") {
-    s2 = def.innerType;
-    def = getZodDef(s2);
-  }
-  return s2;
-}
-function isArrayType(schema) {
-  return getZodType(unwrap$1(schema)) === "array";
-}
-function getArrayInnerType(schema) {
-  const def = getZodDef(unwrap$1(schema));
-  if (def?.type === "array") return def.element ?? def.innerType;
-}
-function getEnumValues(schema) {
-  const def = getZodDef(unwrap$1(schema));
-  if (def?.type !== "enum") return void 0;
-  if (Array.isArray(def.values)) return def.values;
-  if (def.entries && typeof def.entries === "object") return Object.keys(def.entries);
-}
-function getSchemaId(schema, reg) {
-  try {
-    const meta = reg.get(schema);
-    if (meta?.id) return meta.id;
-  } catch {
-  }
-  if (typeof schema === "object" && schema !== null) return schemaIdTags.get(schema);
-}
-function getUnionOptions(schema) {
-  const def = getZodDef(schema);
-  if (def?.type === "union" && Array.isArray(def.options)) return def.options;
-}
-function getObjectShape(schema) {
-  const def = getZodDef(schema);
-  if (def?.type === "object" && def.shape && typeof def.shape === "object") return def.shape;
-}
-function resolveTypeAnnotation(schema, reg) {
-  const isReactive = isReactiveSchema(schema);
-  const baseType = resolveBaseType(unwrap$1(schema), reg);
-  if (!baseType) return void 0;
-  return isReactive ? `$binding<${baseType}>` : baseType;
-}
-function resolveBaseType(inner, reg) {
-  const directId = getSchemaId(inner, reg);
-  if (directId) return directId;
-  const unionOpts = getUnionOptions(inner);
-  if (unionOpts) {
-    const names = unionOpts.map((o) => resolveTypeAnnotation(o, reg)).filter(Boolean);
-    if (names.length > 0) return names.join(" | ");
-  }
-  if (isArrayType(inner)) {
-    const arrayInner = getArrayInnerType(inner);
-    if (!arrayInner) return void 0;
-    const innerType = resolveTypeAnnotation(arrayInner, reg);
-    if (innerType) return getUnionOptions(unwrap$1(arrayInner)) !== void 0 ? `(${innerType})[]` : `${innerType}[]`;
-    return;
-  }
-  const zodType = getZodType(inner);
-  if (zodType === "string") return "string";
-  if (zodType === "number") return "number";
-  if (zodType === "boolean") return "boolean";
-  if (zodType === "any") return "any";
-  if (zodType === "record") {
-    const def = getZodDef(inner);
-    return `Record<${resolveTypeAnnotation(def?.keyType, reg) ?? "string"}, ${resolveTypeAnnotation(def?.valueType, reg) ?? "any"}>`;
-  }
-  const enumVals = getEnumValues(inner);
-  if (enumVals) return enumVals.map((v2) => `"${v2}"`).join(" | ");
-  if (zodType === "literal") {
-    const vals = getZodDef(inner)?.values;
-    if (Array.isArray(vals) && vals.length === 1) {
-      const v2 = vals[0];
-      return typeof v2 === "string" ? `"${v2}"` : String(v2);
-    }
-  }
-  const shape = getObjectShape(inner);
-  if (shape) return `{${Object.entries(shape).map(([name, fieldSchema]) => {
-    const opt = isOptionalType(fieldSchema) ? "?" : "";
-    const fieldType = resolveTypeAnnotation(fieldSchema, reg);
-    return fieldType ? `${name}${opt}: ${fieldType}` : `${name}${opt}`;
-  }).join(", ")}}`;
-  return "any";
-}
-function analyzeFields(shape, reg) {
-  return Object.entries(shape).map(([name, schema]) => ({
-    name,
-    isOptional: isOptionalType(schema),
-    isArray: isArrayType(schema),
-    typeAnnotation: resolveTypeAnnotation(schema, reg)
-  }));
-}
-function buildSignature(componentName, fields) {
-  return `${componentName}(${fields.map((f) => {
-    if (f.typeAnnotation) return f.isOptional ? `${f.name}?: ${f.typeAnnotation}` : `${f.name}: ${f.typeAnnotation}`;
-    if (f.isArray) return f.isOptional ? `[${f.name}]?` : `[${f.name}]`;
-    return f.isOptional ? `${f.name}?` : f.name;
-  }).join(", ")})`;
-}
-function buildComponentSpecs(components, reg) {
-  const specs = {};
-  for (const [name, def] of Object.entries(components)) specs[name] = {
-    signature: buildSignature(name, analyzeFields(def.props.shape, reg)),
-    description: def.description
-  };
-  return specs;
-}
-var fallbackLibraryId = 0;
-function createLibraryId() {
-  if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
-  fallbackLibraryId += 1;
-  return `openui-lib-${Date.now().toString(36)}-${fallbackLibraryId.toString(36)}`;
-}
-function createLibrary(input) {
-  const componentsRecord = {};
-  const reg = registry();
-  const __libraryId = createLibraryId();
-  for (const comp of input.components) {
-    reg.add(comp.props, { id: comp.name });
-    componentsRecord[comp.name] = comp;
-  }
-  if (input.root && !componentsRecord[input.root]) {
-    const available = Object.keys(componentsRecord).join(", ");
-    throw new Error(`[createLibrary] Root component "${input.root}" was not found in components. Available components: ${available}`);
-  }
-  const library = {
-    components: componentsRecord,
-    componentGroups: input.componentGroups,
-    root: input.root,
-    id: input.id,
-    __libraryId,
-    prompt(options) {
-      return generatePrompt({
-        root: input.root,
-        components: buildComponentSpecs(componentsRecord, reg),
-        componentGroups: input.componentGroups,
-        ...options
-      });
-    },
-    toSpec() {
-      return {
-        root: input.root,
-        components: buildComponentSpecs(componentsRecord, reg),
-        componentGroups: input.componentGroups,
-        schema: buildJSONSchema(),
-        ...input.id !== void 0 ? { id: input.id } : {}
-      };
-    },
-    toJSONSchema() {
-      return buildJSONSchema();
-    }
-  };
-  function buildJSONSchema() {
-    const combinedSchema = object(Object.fromEntries(Object.entries(componentsRecord).map(([k2, v2]) => [k2, v2.props])));
-    const schema = toJSONSchema(combinedSchema, { metadata: reg });
-    for (const [name, comp] of Object.entries(componentsRecord)) {
-      const def = schema.$defs?.[name];
-      if (def && comp.description) def.description = comp.description;
-    }
-    return schema;
-  }
-  return library;
-}
-function isElementNode(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const node = value;
-  return node.type === "element" && typeof node.typeName === "string" && typeof node.props === "object" && node.props !== null && typeof node.partial === "boolean";
-}
-var BuiltinActionType = /* @__PURE__ */ (function(BuiltinActionType2) {
-  BuiltinActionType2["ContinueConversation"] = "continue_conversation";
-  BuiltinActionType2["OpenUrl"] = "open_url";
-  return BuiltinActionType2;
-})({});
-function isRuntimeExpr(node) {
-  switch (node.k) {
-    case "StateRef":
-    case "RuntimeRef":
-    case "BinOp":
-    case "UnaryOp":
-    case "Ternary":
-    case "Member":
-    case "Index":
-    case "Assign":
-      return true;
-    default:
-      return false;
-  }
-}
-var AST_KINDS = /* @__PURE__ */ new Set([
-  "Comp",
-  "Ref",
-  "StateRef",
-  "RuntimeRef",
-  "BinOp",
-  "UnaryOp",
-  "Ternary",
-  "Member",
-  "Index",
-  "Assign",
-  "Str",
-  "Num",
-  "Bool",
-  "Null",
-  "Arr",
-  "Obj",
-  "Ph"
-]);
-function isASTNode(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  return AST_KINDS.has(value.k);
-}
-function walkAST(node, visit2) {
-  const walk = (current2) => {
-    visit2(current2);
-    switch (current2.k) {
-      case "Comp":
-        current2.args.forEach(walk);
-        Object.values(current2.mappedProps ?? {}).forEach(walk);
-        break;
-      case "Arr":
-        current2.els.forEach(walk);
-        break;
-      case "Obj":
-        current2.entries.forEach(([, value]) => walk(value));
-        break;
-      case "BinOp":
-        walk(current2.left);
-        walk(current2.right);
-        break;
-      case "UnaryOp":
-        walk(current2.operand);
-        break;
-      case "Ternary":
-        walk(current2.cond);
-        walk(current2.then);
-        walk(current2.else);
-        break;
-      case "Member":
-        walk(current2.obj);
-        break;
-      case "Index":
-        walk(current2.obj);
-        walk(current2.index);
-        break;
-      case "Assign":
-        walk(current2.value);
-    }
-  };
-  walk(node);
-}
-var PREC_TERNARY = 1;
-var PREC_OR = 2;
-var PREC_AND = 3;
-var PREC_EQ = 4;
-var PREC_CMP = 5;
-var PREC_ADD = 6;
-var PREC_MUL = 7;
-var PREC_UNARY = 8;
-var PREC_MEMBER = 9;
-function parseExpression(tokens) {
-  let pos = 0;
-  const cur = () => tokens[pos] ?? { t: 13 };
-  const adv = () => {
-    const tok = cur();
-    pos++;
-    return tok;
-  };
-  const eat = (kind) => {
-    if (cur().t === kind) pos++;
-  };
-  function getInfixPrec(tok) {
-    switch (tok.t) {
-      case 34:
-        return PREC_TERNARY;
-      case 32:
-        return PREC_OR;
-      case 31:
-        return PREC_AND;
-      case 25:
-      case 26:
-        return PREC_EQ;
-      case 27:
-      case 28:
-      case 29:
-      case 30:
-        return PREC_CMP;
-      case 20:
-      case 21:
-        return PREC_ADD;
-      case 22:
-      case 23:
-      case 24:
-        return PREC_MUL;
-      case 19:
-      case 3:
-        return PREC_MEMBER;
-      default:
-        return 0;
-    }
-  }
-  function parseExpr(minPrec = 0) {
-    let left = parsePrefix();
-    while (getInfixPrec(cur()) > minPrec) left = parseInfix(left);
-    return left;
-  }
-  function parsePrefix() {
-    const tok = cur();
-    if (tok.t === 14) {
-      adv();
-      return {
-        k: "Str",
-        v: tok.v
-      };
-    }
-    if (tok.t === 15) {
-      adv();
-      return {
-        k: "Num",
-        v: tok.v
-      };
-    }
-    if (tok.t === 10) {
-      adv();
-      return {
-        k: "Bool",
-        v: true
-      };
-    }
-    if (tok.t === 11) {
-      adv();
-      return {
-        k: "Bool",
-        v: false
-      };
-    }
-    if (tok.t === 12) {
-      adv();
-      return { k: "Null" };
-    }
-    if (tok.t === 3) return parseArr();
-    if (tok.t === 5) return parseObj();
-    if (tok.t === 18) {
-      const name = tok.v;
-      adv();
-      if (cur().t === 9) {
-        adv();
-        return {
-          k: "Assign",
-          target: name,
-          value: parseExpr(0)
-        };
-      }
-      return {
-        k: "StateRef",
-        n: name
-      };
-    }
-    if (tok.t === 17) {
-      const name = tok.v;
-      if (tokens[pos + 1]?.t === 1 && (!isBuiltin(name) || name === "Action")) return parseComp();
-      adv();
-      return {
-        k: "Ref",
-        n: name
-      };
-    }
-    if (tok.t === 35) {
-      if (tokens[pos + 1]?.t === 1) return parseComp();
-      adv();
-      return {
-        k: "Ref",
-        n: tok.v
-      };
-    }
-    if (tok.t === 16) {
-      adv();
-      return {
-        k: "Ref",
-        n: tok.v
-      };
-    }
-    if (tok.t === 33) {
-      adv();
-      return {
-        k: "UnaryOp",
-        op: "!",
-        operand: parseExpr(PREC_UNARY)
-      };
-    }
-    if (tok.t === 21) {
-      adv();
-      return {
-        k: "UnaryOp",
-        op: "-",
-        operand: parseExpr(PREC_UNARY)
-      };
-    }
-    if (tok.t === 1) {
-      adv();
-      const inner = parseExpr(0);
-      eat(2);
-      return inner;
-    }
-    adv();
-    return { k: "Null" };
-  }
-  function parseInfix(left) {
-    const tok = cur();
-    if (tok.t === 20) {
-      adv();
-      return {
-        k: "BinOp",
-        op: "+",
-        left,
-        right: parseExpr(PREC_ADD)
-      };
-    }
-    if (tok.t === 21) {
-      adv();
-      return {
-        k: "BinOp",
-        op: "-",
-        left,
-        right: parseExpr(PREC_ADD)
-      };
-    }
-    if (tok.t === 22) {
-      adv();
-      return {
-        k: "BinOp",
-        op: "*",
-        left,
-        right: parseExpr(PREC_MUL)
-      };
-    }
-    if (tok.t === 23) {
-      adv();
-      return {
-        k: "BinOp",
-        op: "/",
-        left,
-        right: parseExpr(PREC_MUL)
-      };
-    }
-    if (tok.t === 24) {
-      adv();
-      return {
-        k: "BinOp",
-        op: "%",
-        left,
-        right: parseExpr(PREC_MUL)
-      };
-    }
-    if (tok.t === 25) {
-      adv();
-      return {
-        k: "BinOp",
-        op: "==",
-        left,
-        right: parseExpr(PREC_EQ)
-      };
-    }
-    if (tok.t === 26) {
-      adv();
-      return {
-        k: "BinOp",
-        op: "!=",
-        left,
-        right: parseExpr(PREC_EQ)
-      };
-    }
-    if (tok.t === 27) {
-      adv();
-      return {
-        k: "BinOp",
-        op: ">",
-        left,
-        right: parseExpr(PREC_CMP)
-      };
-    }
-    if (tok.t === 28) {
-      adv();
-      return {
-        k: "BinOp",
-        op: "<",
-        left,
-        right: parseExpr(PREC_CMP)
-      };
-    }
-    if (tok.t === 29) {
-      adv();
-      return {
-        k: "BinOp",
-        op: ">=",
-        left,
-        right: parseExpr(PREC_CMP)
-      };
-    }
-    if (tok.t === 30) {
-      adv();
-      return {
-        k: "BinOp",
-        op: "<=",
-        left,
-        right: parseExpr(PREC_CMP)
-      };
-    }
-    if (tok.t === 31) {
-      adv();
-      return {
-        k: "BinOp",
-        op: "&&",
-        left,
-        right: parseExpr(PREC_AND)
-      };
-    }
-    if (tok.t === 32) {
-      adv();
-      return {
-        k: "BinOp",
-        op: "||",
-        left,
-        right: parseExpr(PREC_OR)
-      };
-    }
-    if (tok.t === 34) {
-      adv();
-      const then = parseExpr(0);
-      eat(8);
-      return {
-        k: "Ternary",
-        cond: left,
-        then,
-        else: parseExpr(0)
-      };
-    }
-    if (tok.t === 19) {
-      adv();
-      const fieldTok = cur();
-      return {
-        k: "Member",
-        obj: left,
-        field: fieldTok.t === 16 || fieldTok.t === 17 || fieldTok.t === 14 || fieldTok.t === 15 ? (adv(), String(fieldTok.v)) : fieldTok.t === 18 ? (adv(), fieldTok.v.replace(/^\$/, "")) : (adv(), "?")
-      };
-    }
-    if (tok.t === 3) {
-      adv();
-      const index = parseExpr(0);
-      eat(4);
-      return {
-        k: "Index",
-        obj: left,
-        index
-      };
-    }
-    return left;
-  }
-  function parseComp() {
-    const name = cur().v;
-    adv();
-    eat(1);
-    const args = [];
-    while (cur().t !== 2 && cur().t !== 13) {
-      args.push(parseExpr(0));
-      if (cur().t === 7) adv();
-    }
-    eat(2);
-    return {
-      k: "Comp",
-      name,
-      args
-    };
-  }
-  function parseArr() {
-    adv();
-    const els = [];
-    while (cur().t !== 4 && cur().t !== 13) {
-      els.push(parseExpr(0));
-      if (cur().t === 7) adv();
-    }
-    eat(4);
-    return {
-      k: "Arr",
-      els
-    };
-  }
-  function parseObj() {
-    adv();
-    const entries = [];
-    while (cur().t !== 6 && cur().t !== 13) {
-      const kt = cur();
-      const key = kt.t === 16 || kt.t === 14 || kt.t === 17 || kt.t === 15 ? (adv(), String(kt.v)) : kt.t === 18 ? (adv(), kt.v.replace(/^\$/, "")) : (adv(), "?");
-      eat(8);
-      entries.push([key, parseExpr(0)]);
-      if (cur().t === 7) adv();
-    }
-    eat(6);
-    return {
-      k: "Obj",
-      entries
-    };
-  }
-  return parseExpr(0);
-}
-function tokenize(src) {
-  const tokens = [];
-  let i = 0;
-  const n = src.length;
-  while (i < n) {
-    while (i < n && (src[i] === " " || src[i] === "	" || src[i] === "\r")) i++;
-    if (i >= n) break;
-    const c2 = src[i];
-    if (c2 === "\n") {
-      tokens.push({ t: 0 });
-      i++;
-      continue;
-    }
-    if (c2 === "(") {
-      tokens.push({ t: 1 });
-      i++;
-      continue;
-    }
-    if (c2 === ")") {
-      tokens.push({ t: 2 });
-      i++;
-      continue;
-    }
-    if (c2 === "[") {
-      tokens.push({ t: 3 });
-      i++;
-      continue;
-    }
-    if (c2 === "]") {
-      tokens.push({ t: 4 });
-      i++;
-      continue;
-    }
-    if (c2 === "{") {
-      tokens.push({ t: 5 });
-      i++;
-      continue;
-    }
-    if (c2 === "}") {
-      tokens.push({ t: 6 });
-      i++;
-      continue;
-    }
-    if (c2 === ",") {
-      tokens.push({ t: 7 });
-      i++;
-      continue;
-    }
-    if (c2 === ":") {
-      tokens.push({ t: 8 });
-      i++;
-      continue;
-    }
-    if (c2 === "=") {
-      if (i + 1 < n && src[i + 1] === "=") {
-        tokens.push({ t: 25 });
-        i += 2;
-      } else {
-        tokens.push({ t: 9 });
-        i++;
-      }
-      continue;
-    }
-    if (c2 === "!") {
-      if (i + 1 < n && src[i + 1] === "=") {
-        tokens.push({ t: 26 });
-        i += 2;
-      } else {
-        tokens.push({ t: 33 });
-        i++;
-      }
-      continue;
-    }
-    if (c2 === ">") {
-      if (i + 1 < n && src[i + 1] === "=") {
-        tokens.push({ t: 29 });
-        i += 2;
-      } else {
-        tokens.push({ t: 27 });
-        i++;
-      }
-      continue;
-    }
-    if (c2 === "<") {
-      if (i + 1 < n && src[i + 1] === "=") {
-        tokens.push({ t: 30 });
-        i += 2;
-      } else {
-        tokens.push({ t: 28 });
-        i++;
-      }
-      continue;
-    }
-    if (c2 === "&") {
-      if (i + 1 < n && src[i + 1] === "&") {
-        tokens.push({ t: 31 });
-        i += 2;
-      } else {
-        tokens.push({ t: 31 });
-        i++;
-      }
-      continue;
-    }
-    if (c2 === "|") {
-      if (i + 1 < n && src[i + 1] === "|") {
-        tokens.push({ t: 32 });
-        i += 2;
-      } else {
-        tokens.push({ t: 32 });
-        i++;
-      }
-      continue;
-    }
-    if (c2 === ".") {
-      tokens.push({ t: 19 });
-      i++;
-      continue;
-    }
-    if (c2 === "?") {
-      tokens.push({ t: 34 });
-      i++;
-      continue;
-    }
-    if (c2 === "+") {
-      tokens.push({ t: 20 });
-      i++;
-      continue;
-    }
-    if (c2 === "*") {
-      tokens.push({ t: 22 });
-      i++;
-      continue;
-    }
-    if (c2 === "/") {
-      tokens.push({ t: 23 });
-      i++;
-      continue;
-    }
-    if (c2 === "%") {
-      tokens.push({ t: 24 });
-      i++;
-      continue;
-    }
-    if (c2 === '"') {
-      const start = i;
-      i++;
-      let isClosed = false;
-      while (i < n) if (src[i] === "\\") i += 2;
-      else if (src[i] === '"') {
-        i++;
-        isClosed = true;
-        break;
-      } else i++;
-      const rawString = src.slice(start, i);
-      try {
-        const validJsonString = isClosed ? rawString : rawString + '"';
-        tokens.push({
-          t: 14,
-          v: JSON.parse(validJsonString)
-        });
-      } catch {
-        const stripped = rawString.replace(/^"|"$/g, "");
-        tokens.push({
-          t: 14,
-          v: stripped
-        });
-      }
-      continue;
-    }
-    if (c2 === "'") {
-      i++;
-      let result = "";
-      while (i < n) if (src[i] === "\\") {
-        i++;
-        if (i < n) {
-          const esc = src[i];
-          if (esc === "'") result += "'";
-          else if (esc === "\\") result += "\\";
-          else if (esc === "n") result += "\n";
-          else if (esc === "t") result += "	";
-          else result += esc;
-          i++;
-        }
-      } else if (src[i] === "'") {
-        i++;
-        break;
-      } else {
-        result += src[i];
-        i++;
-      }
-      tokens.push({
-        t: 14,
-        v: result
-      });
-      continue;
-    }
-    if (c2 === "-") {
-      const prev = tokens.length > 0 ? tokens[tokens.length - 1] : null;
-      if (!(prev != null && (prev.t === 15 || prev.t === 14 || prev.t === 16 || prev.t === 17 || prev.t === 2 || prev.t === 4 || prev.t === 10 || prev.t === 11 || prev.t === 12 || prev.t === 18 || prev.t === 35)) && i + 1 < n && src[i + 1] >= "0" && src[i + 1] <= "9") {
-      } else {
-        tokens.push({ t: 21 });
-        i++;
-        continue;
-      }
-    }
-    const isDigit = c2 >= "0" && c2 <= "9";
-    const isNegDigit = c2 === "-" && i + 1 < n && src[i + 1] >= "0" && src[i + 1] <= "9";
-    if (isDigit || isNegDigit) {
-      const start = i;
-      if (src[i] === "-") i++;
-      while (i < n && src[i] >= "0" && src[i] <= "9") i++;
-      if (i < n && src[i] === "." && i + 1 < n && src[i + 1] >= "0" && src[i + 1] <= "9") {
-        i++;
-        while (i < n && src[i] >= "0" && src[i] <= "9") i++;
-      }
-      if (i < n && (src[i] === "e" || src[i] === "E")) {
-        i++;
-        if (i < n && (src[i] === "+" || src[i] === "-")) i++;
-        while (i < n && src[i] >= "0" && src[i] <= "9") i++;
-      }
-      tokens.push({
-        t: 15,
-        v: +src.slice(start, i)
-      });
-      continue;
-    }
-    if (c2 === "$" && i + 1 < n && (src[i + 1] >= "a" && src[i + 1] <= "z" || src[i + 1] >= "A" && src[i + 1] <= "Z" || src[i + 1] === "_")) {
-      const start = i;
-      i++;
-      while (i < n && (src[i] >= "a" && src[i] <= "z" || src[i] >= "A" && src[i] <= "Z" || src[i] >= "0" && src[i] <= "9" || src[i] === "_")) i++;
-      tokens.push({
-        t: 18,
-        v: src.slice(start, i)
-      });
-      continue;
-    }
-    if (c2 >= "a" && c2 <= "z" || c2 >= "A" && c2 <= "Z" || c2 === "_") {
-      const start = i;
-      while (i < n && (src[i] >= "a" && src[i] <= "z" || src[i] >= "A" && src[i] <= "Z" || src[i] >= "0" && src[i] <= "9" || src[i] === "_")) i++;
-      const word = src.slice(start, i);
-      if (word === "true") {
-        tokens.push({ t: 10 });
-        continue;
-      }
-      if (word === "false") {
-        tokens.push({ t: 11 });
-        continue;
-      }
-      if (word === "null") {
-        tokens.push({ t: 12 });
-        continue;
-      }
-      const kind = c2 >= "A" && c2 <= "Z" ? 17 : 16;
-      tokens.push({
-        t: kind,
-        v: word
-      });
-      continue;
-    }
-    if (c2 === "@" && i + 1 < n && (src[i + 1] >= "a" && src[i + 1] <= "z" || src[i + 1] >= "A" && src[i + 1] <= "Z" || src[i + 1] === "_")) {
-      i++;
-      const start = i;
-      while (i < n && (src[i] >= "a" && src[i] <= "z" || src[i] >= "A" && src[i] <= "Z" || src[i] >= "0" && src[i] <= "9" || src[i] === "_")) i++;
-      tokens.push({
-        t: 35,
-        v: src.slice(start, i)
-      });
-      continue;
-    }
-    i++;
-  }
-  tokens.push({ t: 13 });
-  return tokens;
-}
-var SCALAR_TYPEOFS = [
-  "string",
-  "number",
-  "boolean"
-];
-var NO_PROPS = {};
-var NO_REQUIRED = [];
-function jsType(value) {
-  return Array.isArray(value) ? "array" : typeof value;
-}
-function isCompositeSchema(s2) {
-  return "$ref" in s2 || "anyOf" in s2 || "oneOf" in s2 || "allOf" in s2;
-}
-function getScalarTypeInfo(s2) {
-  if (Array.isArray(s2["enum"])) return { enumValues: s2["enum"] };
-  if ("const" in s2) return { enumValues: [s2["const"]] };
-  switch (s2["type"]) {
-    case "string":
-      return { expectedType: "string" };
-    case "number":
-    case "integer":
-      return { expectedType: "number" };
-    case "boolean":
-      return { expectedType: "boolean" };
-    default:
-      return {};
-  }
-}
-function getSchemaDefaultValue(property2) {
-  if (!property2 || typeof property2 !== "object" || Array.isArray(property2)) return;
-  return property2.default;
-}
-function getTypeFromSchema(property2) {
-  if (!property2 || typeof property2 !== "object" || Array.isArray(property2)) return;
-  const p = property2;
-  if (typeof p.$ref === "string") return p.$ref.split("/").pop();
-  const leaf = getScalarTypeInfo(p);
-  if (leaf.enumValues) return leaf.enumValues.map((v2) => JSON.stringify(v2)).join("|");
-  if (leaf.expectedType) return leaf.expectedType;
-  return typeof p.type === "string" ? p.type : void 0;
-}
-function buildParamsSignature(component, params) {
-  return `${component}(${params.map((p) => {
-    const type = getTypeFromSchema(p.schema);
-    const marked = p.required ? `${p.name}*` : p.name;
-    return type ? `${marked}: ${type}` : marked;
-  }).join(", ")})`;
-}
-function checkTypeMismatch(value, info) {
-  const actual = typeof value;
-  if (info.enumValues) {
-    if (!SCALAR_TYPEOFS.includes(actual)) return null;
-    if (info.enumValues.includes(value)) return null;
-    return {
-      expected: `one of [${info.enumValues.map((v2) => JSON.stringify(v2)).join(", ")}]`,
-      actual: JSON.stringify(value)
-    };
-  }
-  if (info.expectedType && info.expectedType !== actual) return {
-    expected: info.expectedType,
-    actual: jsType(value)
-  };
-  return null;
-}
-function validationMessage$1(component, path2, issue) {
-  switch (issue.code) {
-    case "type-mismatch":
-      return `field "${path2}" expects ${issue.expected} but got ${issue.actual}`;
-    case "missing-required":
-      return `missing required field "${path2}"${issue.signature ? ` \u2014 signature: ${issue.signature}` : ""}`;
-    case "null-required":
-      return `required field "${path2}" cannot be null${issue.signature ? ` \u2014 signature: ${issue.signature}` : ""}`;
-    case "unknown-component":
-      return `Unknown component "${component}" \u2014 not found in catalog or builtins${issue.available?.length ? `. Available components: ${issue.available.join(", ")}` : ""}`;
-    case "inline-reserved":
-      return `${component}() must be declared as a top-level statement, not used inline as a value`;
-    case "excess-args":
-      return `${component} takes ${issue.declared} arg(s), got ${issue.got} (${issue.got - issue.declared} excess dropped)`;
-  }
-}
-function pushValidationIssue(ctx, component, path2, issue) {
-  ctx.errors.push({
-    code: issue.code,
-    component,
-    path: path2,
-    message: validationMessage$1(component, path2, issue),
-    statementId: ctx.currentStatementId
-  });
-}
-function resolveInvalidValue(container, key, required, defaultValue) {
-  if (defaultValue !== void 0) {
-    container[key] = defaultValue;
-    return false;
-  }
-  if (required) return true;
-  delete container[key];
-  return false;
-}
-function validateElementPosition(element, s2, component, path2, ctx) {
-  if (isCompositeSchema(s2)) return false;
-  if (typeof s2["type"] === "string" || Array.isArray(s2["enum"]) || "const" in s2) {
-    pushValidationIssue(ctx, component, path2, {
-      code: "type-mismatch",
-      expected: typeof s2["type"] === "string" ? s2["type"] : "a literal value",
-      actual: `component "${element.typeName}"`
-    });
-    return true;
-  }
-  return false;
-}
-function validateObjectValue(value, s2, component, path2, ctx) {
-  if (typeof value !== "object" || Array.isArray(value)) {
-    pushValidationIssue(ctx, component, path2, {
-      code: "type-mismatch",
-      expected: "object",
-      actual: jsType(value)
-    });
-    return true;
-  }
-  const obj = value;
-  const props = s2["properties"] && typeof s2["properties"] === "object" ? s2["properties"] : NO_PROPS;
-  const required = Array.isArray(s2["required"]) ? s2["required"] : NO_REQUIRED;
-  let invalid = false;
-  if (!ctx.partial) for (const key of required) {
-    const present = key in obj;
-    if (!present || obj[key] == null) {
-      const fallback = getSchemaDefaultValue(props[key]);
-      if (fallback !== void 0) {
-        obj[key] = fallback;
-        continue;
-      }
-      pushValidationIssue(ctx, component, `${path2}/${key}`, { code: present ? "null-required" : "missing-required" });
-      invalid = true;
-    }
-  }
-  for (const key of Object.keys(props)) if (key in obj) {
-    const sub = props[key];
-    if (validateSchemaValue(obj[key], sub, component, `${path2}/${key}`, ctx)) {
-      if (resolveInvalidValue(obj, key, required.includes(key), getSchemaDefaultValue(sub))) invalid = true;
-    }
-  }
-  return invalid;
-}
-function validateArrayValue(value, s2, component, path2, ctx) {
-  if (!Array.isArray(value)) {
-    pushValidationIssue(ctx, component, path2, {
-      code: "type-mismatch",
-      expected: "array",
-      actual: jsType(value)
-    });
-    return true;
-  }
-  const items = s2["items"];
-  if (!items || typeof items !== "object" || Array.isArray(items)) return false;
-  let invalid;
-  for (let i = 0; i < value.length; i++) if (validateSchemaValue(value[i], items, component, `${path2}/${i}`, ctx)) (invalid ??= []).push(i);
-  if (invalid) for (let i = invalid.length - 1; i >= 0; i--) value.splice(invalid[i], 1);
-  return false;
-}
-function validateLeafValue(value, s2, component, path2, ctx) {
-  const leaf = getScalarTypeInfo(s2);
-  if (leaf.expectedType == null && leaf.enumValues == null) return false;
-  if (leaf.enumValues && ctx.partial) return false;
-  const mismatch = checkTypeMismatch(value, leaf);
-  if (mismatch) {
-    pushValidationIssue(ctx, component, path2, {
-      code: "type-mismatch",
-      ...mismatch
-    });
-    return true;
-  }
-  return false;
-}
-function validateSchemaValue(value, schema, component, path2, ctx) {
-  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return false;
-  const s2 = schema;
-  if (value == null) return false;
-  if (isASTNode(value)) return false;
-  if (isElementNode(value)) return validateElementPosition(value, s2, component, path2, ctx);
-  if (isCompositeSchema(s2)) return false;
-  const type = s2["type"];
-  if (type === "object") return validateObjectValue(value, s2, component, path2, ctx);
-  if (type === "array") return validateArrayValue(value, s2, component, path2, ctx);
-  return validateLeafValue(value, s2, component, path2, ctx);
-}
-function containsDynamicValue(v2) {
-  if (v2 == null || typeof v2 !== "object") return false;
-  if (isASTNode(v2)) return true;
-  if (Array.isArray(v2)) return v2.some(containsDynamicValue);
-  if (isElementNode(v2)) return Object.values(v2.props).some(containsDynamicValue);
-  return Object.values(v2).some(containsDynamicValue);
-}
-function resolveRef(name, ctx, mode) {
-  if (ctx.visited.has(name)) {
-    ctx.unres.push(name);
-    return mode === "expr" ? {
-      k: "Ph",
-      n: name
-    } : null;
-  }
-  if (!ctx.syms.has(name)) {
-    ctx.unres.push(name);
-    return mode === "expr" ? {
-      k: "Ph",
-      n: name
-    } : null;
-  }
-  const target = ctx.syms.get(name);
-  ctx.unreached?.delete(name);
-  if (target.k === "Comp" && isReservedCall(target.name)) return {
-    k: "RuntimeRef",
-    n: name,
-    refType: target.name === RESERVED_CALLS.Mutation ? "mutation" : "query"
-  };
-  ctx.visited.add(name);
-  const prevStatementId = ctx.currentStatementId;
-  ctx.currentStatementId = name;
-  try {
-    const result = mode === "value" ? materializeValue(target, ctx) : materializeExpr(target, ctx);
-    if (mode === "value" && isElementNode(result)) result.statementId = name;
-    return result;
-  } finally {
-    ctx.currentStatementId = prevStatementId;
-    ctx.visited.delete(name);
-  }
-}
-function materializeLazyBuiltin(node, ctx, scopedRefs) {
-  if (!LAZY_BUILTINS.has(node.name) || node.args.length < 3) return null;
-  const varArg = node.args[1];
-  const varName = varArg.k === "Ref" ? varArg.n : varArg.k === "Str" ? varArg.v : null;
-  if (!varName) return null;
-  const nextScopedRefs = new Set(scopedRefs);
-  nextScopedRefs.add(varName);
-  const recursedArgs = node.args.map((a2, i) => i === 1 ? a2 : materializeExprInternal(a2, ctx, nextScopedRefs));
-  return {
-    ...node,
-    args: recursedArgs
-  };
-}
-function materializeExprInternal(node, ctx, scopedRefs) {
-  switch (node.k) {
-    case "Ref":
-      return scopedRefs.has(node.n) ? node : resolveRef(node.n, ctx, "expr");
-    case "Ph":
-      return node;
-    case "Comp": {
-      const lazy = materializeLazyBuiltin(node, ctx, scopedRefs);
-      if (lazy) return lazy;
-      const recursedArgs = node.args.map((a2) => materializeExprInternal(a2, ctx, scopedRefs));
-      if (isBuiltin(node.name) || isReservedCall(node.name)) return {
-        ...node,
-        args: recursedArgs
-      };
-      const def = ctx.cat?.get(node.name);
-      if (def) {
-        const mappedProps = {};
-        for (let i = 0; i < def.params.length && i < recursedArgs.length; i++) mappedProps[def.params[i].name] = recursedArgs[i];
-        return {
-          ...node,
-          args: recursedArgs,
-          mappedProps
-        };
-      }
-      pushValidationIssue(ctx, node.name, "", {
-        code: "unknown-component",
-        available: ctx.cat && [...ctx.cat.keys()]
-      });
-      return {
-        ...node,
-        args: recursedArgs
-      };
-    }
-    case "Arr":
-      return {
-        ...node,
-        els: node.els.map((e) => materializeExprInternal(e, ctx, scopedRefs))
-      };
-    case "Obj":
-      return {
-        ...node,
-        entries: node.entries.map(([k2, v2]) => [k2, materializeExprInternal(v2, ctx, scopedRefs)])
-      };
-    case "BinOp":
-      return {
-        ...node,
-        left: materializeExprInternal(node.left, ctx, scopedRefs),
-        right: materializeExprInternal(node.right, ctx, scopedRefs)
-      };
-    case "UnaryOp":
-      return {
-        ...node,
-        operand: materializeExprInternal(node.operand, ctx, scopedRefs)
-      };
-    case "Ternary":
-      return {
-        ...node,
-        cond: materializeExprInternal(node.cond, ctx, scopedRefs),
-        then: materializeExprInternal(node.then, ctx, scopedRefs),
-        else: materializeExprInternal(node.else, ctx, scopedRefs)
-      };
-    case "Member":
-      return {
-        ...node,
-        obj: materializeExprInternal(node.obj, ctx, scopedRefs)
-      };
-    case "Index":
-      return {
-        ...node,
-        obj: materializeExprInternal(node.obj, ctx, scopedRefs),
-        index: materializeExprInternal(node.index, ctx, scopedRefs)
-      };
-    case "Assign":
-      return {
-        ...node,
-        value: materializeExprInternal(node.value, ctx, scopedRefs)
-      };
-    default:
-      return node;
-  }
-}
-function materializeExpr(node, ctx) {
-  return materializeExprInternal(node, ctx, /* @__PURE__ */ new Set());
-}
-function materializeValue(node, ctx) {
-  switch (node.k) {
-    case "Ref":
-      return resolveRef(node.n, ctx, "value");
-    case "Str":
-      return node.v;
-    case "Num":
-      return node.v;
-    case "Bool":
-      return node.v;
-    case "Null":
-      return null;
-    case "Ph":
-      return null;
-    case "Arr": {
-      const items = [];
-      for (const e of node.els) {
-        if (e.k === "Ph") continue;
-        const value = materializeValue(e, ctx);
-        if (value === null && (e.k === "Comp" || e.k === "Ref")) continue;
-        items.push(value);
-      }
-      return items;
-    }
-    case "Obj": {
-      const o = {};
-      for (const [k2, v2] of node.entries) o[k2] = materializeValue(v2, ctx);
-      return o;
-    }
-    case "Comp": {
-      const { name, args } = node;
-      if (isBuiltin(name)) {
-        const lazy = materializeLazyBuiltin(node, ctx, /* @__PURE__ */ new Set());
-        if (lazy) return lazy;
-        return {
-          ...node,
-          args: args.map((a2) => materializeExpr(a2, ctx))
-        };
-      }
-      if (isReservedCall(name)) {
-        pushValidationIssue(ctx, name, "", { code: "inline-reserved" });
-        return null;
-      }
-      const def = ctx.cat?.get(name);
-      const props = {};
-      if (def) {
-        let dropComponent = false;
-        for (let i = 0; i < def.params.length && i < args.length; i++) {
-          const param = def.params[i];
-          const value = materializeValue(args[i], ctx);
-          props[param.name] = value;
-          if (param.schema !== void 0 && validateSchemaValue(value, param.schema, name, `/${param.name}`, ctx)) {
-            if (resolveInvalidValue(props, param.name, param.required, param.defaultValue)) dropComponent = true;
-          }
-        }
-        if (args.length > def.params.length) pushValidationIssue(ctx, name, "", {
-          code: "excess-args",
-          declared: def.params.length,
-          got: args.length
-        });
-        const missingRequired = def.params.filter((p) => p.required && (!(p.name in props) || props[p.name] === null));
-        if (missingRequired.length) {
-          const stillInvalid = missingRequired.filter((p) => {
-            if (p.defaultValue !== void 0) {
-              props[p.name] = p.defaultValue;
-              return false;
-            }
-            return true;
-          });
-          if (stillInvalid.length) {
-            for (const p of stillInvalid) pushValidationIssue(ctx, name, `/${p.name}`, {
-              code: p.name in props ? "null-required" : "missing-required",
-              signature: buildParamsSignature(name, def.params)
-            });
-            return null;
-          }
-        }
-        if (dropComponent) return null;
-      } else if (!isBuiltin(name) && !isReservedCall(name)) {
-        pushValidationIssue(ctx, name, "", {
-          code: "unknown-component",
-          available: ctx.cat && [...ctx.cat.keys()]
-        });
-        return null;
-      }
-      const hasDynamicProps = Object.values(props).some((v2) => containsDynamicValue(v2));
-      return {
-        type: "element",
-        typeName: name,
-        props,
-        partial: ctx.partial,
-        hasDynamicProps
-      };
-    }
-    default:
-      if (isRuntimeExpr(node)) return materializeExpr(node, ctx);
-      return node;
-  }
-}
-function autoClose(input) {
-  const stack = [];
-  let inStr = false;
-  let esc = false;
-  for (let i = 0; i < input.length; i++) {
-    const c2 = input[i];
-    if (esc) {
-      esc = false;
-      continue;
-    }
-    if (c2 === "\\" && inStr) {
-      esc = true;
-      continue;
-    }
-    if (inStr) {
-      if (c2 === inStr) inStr = false;
-      continue;
-    }
-    if (c2 === '"' || c2 === "'") {
-      inStr = c2;
-      continue;
-    }
-    if (c2 === "(" || c2 === "[" || c2 === "{") stack.push(c2);
-    else if (c2 === ")" && stack[stack.length - 1] === "(") stack.pop();
-    else if (c2 === "]" && stack[stack.length - 1] === "[") stack.pop();
-    else if (c2 === "}" && stack[stack.length - 1] === "{") stack.pop();
-  }
-  if (!(!!inStr || stack.length > 0)) return {
-    text: input,
-    wasIncomplete: false
-  };
-  let out = input;
-  if (inStr) {
-    if (esc) out += "\\";
-    out += inStr;
-  }
-  for (let j2 = stack.length - 1; j2 >= 0; j2--) out += stack[j2] === "(" ? ")" : stack[j2] === "[" ? "]" : "}";
-  return {
-    text: out,
-    wasIncomplete: true
-  };
-}
-function split(tokens) {
-  const stmts = [];
-  let pos = 0;
-  while (pos < tokens.length) {
-    while (pos < tokens.length && tokens[pos].t === 0) pos++;
-    if (pos >= tokens.length || tokens[pos].t === 13) break;
-    const tok = tokens[pos];
-    if (tok.t !== 16 && tok.t !== 17 && tok.t !== 18) {
-      while (pos < tokens.length && tokens[pos].t !== 0 && tokens[pos].t !== 13) pos++;
-      continue;
-    }
-    const id = tok.v;
-    const idTokenType = tok.t;
-    pos++;
-    if (pos >= tokens.length || tokens[pos].t !== 9) {
-      while (pos < tokens.length && tokens[pos].t !== 0 && tokens[pos].t !== 13) pos++;
-      continue;
-    }
-    pos++;
-    const expr = [];
-    let depth = 0;
-    let ternaryDepth = 0;
-    while (pos < tokens.length && tokens[pos].t !== 13) {
-      const tt = tokens[pos].t;
-      if (tt === 0 && depth <= 0 && ternaryDepth <= 0) {
-        let peek2 = pos + 1;
-        while (peek2 < tokens.length && tokens[peek2].t === 0) peek2++;
-        const nextT = peek2 < tokens.length ? tokens[peek2].t : 13;
-        if (nextT === 34 || nextT === 8 && ternaryDepth > 0) {
-          pos++;
-          continue;
-        }
-        break;
-      }
-      if (tt === 0) {
-        pos++;
-        continue;
-      }
-      if (tt === 1 || tt === 3 || tt === 5) depth++;
-      else if ((tt === 2 || tt === 4 || tt === 6) && depth > 0) depth--;
-      else if (tt === 34 && depth === 0) ternaryDepth++;
-      else if (tt === 8 && depth === 0 && ternaryDepth > 0) ternaryDepth--;
-      expr.push(tokens[pos++]);
-    }
-    if (expr.length) stmts.push({
-      id,
-      idTokenType,
-      tokens: expr
-    });
-  }
-  return stmts;
-}
-function emptyResult(incomplete = true) {
-  return {
-    root: null,
-    meta: {
-      incomplete,
-      unresolved: [],
-      orphaned: [],
-      statementCount: 0,
-      errors: []
-    },
-    stateDeclarations: {},
-    queryStatements: [],
-    mutationStatements: []
-  };
-}
-function collectQueryDeps(node) {
-  if (!isASTNode(node)) return [];
-  const refs = /* @__PURE__ */ new Set();
-  walkAST(node, (current2) => {
-    if (current2.k === "StateRef") refs.add(current2.n);
-  });
-  return [...refs];
-}
-function classifyStatement(raw, expr) {
-  if (expr.k === "Comp" && expr.name === RESERVED_CALLS.Query) {
-    const deps = collectQueryDeps(expr.args[1]);
-    return {
-      kind: "query",
-      id: raw.id,
-      call: {
-        callee: RESERVED_CALLS.Query,
-        args: expr.args
-      },
-      expr,
-      deps: deps.length > 0 ? deps : void 0
-    };
-  }
-  if (expr.k === "Comp" && expr.name === RESERVED_CALLS.Mutation) return {
-    kind: "mutation",
-    id: raw.id,
-    call: {
-      callee: RESERVED_CALLS.Mutation,
-      args: expr.args
-    },
-    expr
-  };
-  if (raw.idTokenType === 18) return {
-    kind: "state",
-    id: raw.id,
-    init: expr
-  };
-  return {
-    kind: "value",
-    id: raw.id,
-    expr
-  };
-}
-function extractStatements(stmts, ctx) {
-  const stateDeclarations = {};
-  const queryStatements = [];
-  const mutationStatements = [];
-  for (const stmt of stmts) switch (stmt.kind) {
-    case "state":
-      stateDeclarations[stmt.id] = materializeValue(stmt.init, ctx);
-      break;
-    case "query":
-      queryStatements.push({
-        statementId: stmt.id,
-        toolAST: stmt.call.args[0] ?? null,
-        argsAST: stmt.call.args[1] ?? null,
-        defaultsAST: stmt.call.args[2] ?? null,
-        refreshAST: stmt.call.args[3] ?? null,
-        deps: stmt.deps,
-        complete: true
-      });
-      break;
-    case "mutation":
-      mutationStatements.push({
-        statementId: stmt.id,
-        toolAST: stmt.call.args[0] ?? null,
-        argsAST: stmt.call.args[1] ?? null
-      });
-      break;
-  }
-  for (const stmt of stmts) {
-    const nodes = stmt.kind === "state" ? [stmt.init] : stmt.kind === "value" ? [stmt.expr] : stmt.kind === "query" || stmt.kind === "mutation" ? stmt.call.args : [];
-    for (const node of nodes) for (const dep of collectQueryDeps(node)) if (!(dep in stateDeclarations)) stateDeclarations[dep] = null;
-  }
-  return {
-    stateDeclarations,
-    queryStatements,
-    mutationStatements
-  };
-}
-var DEFAULT_ROOT_STATEMENT_ID = "root";
-function isComponentStatement(stmt) {
-  return stmt.kind === "value" && stmt.expr.k === "Comp" && !isBuiltin(stmt.expr.name) && stmt.expr.name !== RESERVED_CALLS.Query && stmt.expr.name !== RESERVED_CALLS.Mutation;
-}
-function pickEntryId(stmtMap, typedStmts, firstId, rootName) {
-  if (stmtMap.has(DEFAULT_ROOT_STATEMENT_ID)) return DEFAULT_ROOT_STATEMENT_ID;
-  if (rootName && stmtMap.has(rootName)) return rootName;
-  const preferredComponent = rootName ? typedStmts.find((stmt) => isComponentStatement(stmt) && stmt.expr.name === rootName) : void 0;
-  if (preferredComponent) return preferredComponent.id;
-  return typedStmts.find(isComponentStatement)?.id ?? firstId;
-}
-function buildResult(stmtMap, typedStmts, firstId, wasIncomplete, stmtCount, cat, rootName) {
-  const entryId = pickEntryId(stmtMap, typedStmts, firstId, rootName);
-  if (!stmtMap.has(entryId)) return emptyResult(wasIncomplete);
-  const syms = /* @__PURE__ */ new Map();
-  for (const [id, stmt] of stmtMap) syms.set(id, stmt.kind === "state" ? stmt.init : stmt.expr);
-  const unres = [];
-  const errors = [];
-  const unreached = /* @__PURE__ */ new Set();
-  for (const [id, stmt] of stmtMap) {
-    if (id === entryId) continue;
-    if (stmt.kind === "state" || stmt.kind === "query" || stmt.kind === "mutation") continue;
-    unreached.add(id);
-  }
-  const ctx = {
-    syms,
-    cat,
-    errors,
-    unres,
-    visited: /* @__PURE__ */ new Set(),
-    partial: wasIncomplete,
-    currentStatementId: entryId,
-    unreached
-  };
-  const materialized = materializeValue(syms.get(entryId), ctx);
-  const root2 = isElementNode(materialized) ? materialized : null;
-  if (root2) root2.statementId = entryId;
-  const { stateDeclarations, queryStatements, mutationStatements } = extractStatements(typedStmts, ctx);
-  return {
-    root: root2,
-    meta: {
-      incomplete: wasIncomplete,
-      unresolved: unres,
-      orphaned: [...unreached],
-      statementCount: stmtCount,
-      errors
-    },
-    stateDeclarations,
-    queryStatements,
-    mutationStatements
-  };
-}
-function skipString(input, start) {
-  if (input[start] !== '"') return start;
-  let i = start + 1;
-  while (i < input.length) {
-    const c2 = input[i];
-    if (c2 === "\\") i += 2;
-    else if (c2 === '"') return i + 1;
-    else i++;
-  }
-  return i;
-}
-function stripFences(input) {
-  const blocks = [];
-  let i = 0;
-  while (i < input.length) {
-    let fenceStart = -1;
-    while (i < input.length) {
-      const nextI = skipString(input, i);
-      if (nextI > i) {
-        i = nextI;
-        continue;
-      }
-      if (input[i] === "`" && i + 1 < input.length && input[i + 1] === "`" && i + 2 < input.length && input[i + 2] === "`") {
-        fenceStart = i;
-        break;
-      }
-      i++;
-    }
-    if (fenceStart === -1) break;
-    let j2 = fenceStart + 3;
-    while (j2 < input.length && input[j2] !== "\n") j2++;
-    if (j2 >= input.length) {
-      blocks.push(input.slice(fenceStart + 3).replace(/^[^\n]*\n?/, ""));
-      i = input.length;
-      break;
-    }
-    j2++;
-    let closePos = -1;
-    let k2 = j2;
-    while (k2 < input.length) {
-      const nextK = skipString(input, k2);
-      if (nextK > k2) {
-        k2 = nextK;
-        continue;
-      }
-      if (input[k2] === "`" && k2 + 1 < input.length && input[k2 + 1] === "`" && k2 + 2 < input.length && input[k2 + 2] === "`") {
-        closePos = k2;
-        break;
-      }
-      k2++;
-    }
-    if (closePos !== -1) {
-      blocks.push(input.slice(j2, closePos));
-      i = closePos + 3;
-    } else {
-      blocks.push(input.slice(j2));
-      i = input.length;
-    }
-  }
-  if (blocks.length > 0) return blocks.join("\n");
-  if (input.startsWith("```")) {
-    let j2 = 3;
-    while (j2 < input.length && input[j2] !== "\n") j2++;
-    const start = j2 < input.length ? j2 + 1 : 3;
-    const body = input.slice(start);
-    const trailingFence = body.lastIndexOf("```");
-    if (trailingFence !== -1) return body.slice(0, trailingFence);
-    return body;
-  }
-  return input;
-}
-function stripComments(input) {
-  let inStr = false;
-  return input.split("\n").map((line) => {
-    for (let i = 0; i < line.length; i++) {
-      const c2 = line[i];
-      if (inStr) {
-        if (c2 === "\\" && i + 1 < line.length) {
-          i++;
-          continue;
-        }
-        if (c2 === inStr) inStr = false;
-        continue;
-      }
-      if (c2 === '"' || c2 === "'") {
-        inStr = c2;
-        continue;
-      }
-      if (c2 === "/" && line[i + 1] === "/") return line.substring(0, i).trimEnd();
-      if (c2 === "#") return line.substring(0, i).trimEnd();
-    }
-    return line;
-  }).join("\n");
-}
-function preprocess(input) {
-  return stripComments(stripFences(input.trim())).trim();
-}
-function createStreamParser(cat, rootName) {
-  let buf = "";
-  let cleaned = "";
-  let completedEnd = 0;
-  const completedStmtMap = /* @__PURE__ */ new Map();
-  let completedCount = 0;
-  let firstId = "";
-  function addStmt(text) {
-    const t = text.trim();
-    if (!t) return;
-    for (const s2 of split(tokenize(t))) {
-      const stmt = classifyStatement(s2, parseExpression(s2.tokens));
-      completedStmtMap.set(s2.id, stmt);
-      completedCount++;
-      if (!firstId) firstId = s2.id;
-    }
-  }
-  function refreshCleaned() {
-    const next = preprocess(buf);
-    if (!next.startsWith(cleaned.slice(0, completedEnd))) {
-      completedEnd = 0;
-      completedStmtMap.clear();
-      completedCount = 0;
-      firstId = "";
-    }
-    cleaned = next;
-  }
-  function scanNewCompleted() {
-    let depth = 0, ternaryDepth = 0, inStr = false, esc = false;
-    let stmtStart = completedEnd;
-    for (let i = completedEnd; i < cleaned.length; i++) {
-      const c2 = cleaned[i];
-      if (esc) {
-        esc = false;
-        continue;
-      }
-      if (c2 === "\\" && inStr) {
-        esc = true;
-        continue;
-      }
-      if (inStr) {
-        if (c2 === inStr) inStr = false;
-        continue;
-      }
-      if (c2 === '"' || c2 === "'") {
-        inStr = c2;
-        continue;
-      }
-      if (c2 === "(" || c2 === "[" || c2 === "{") depth++;
-      else if (c2 === ")" || c2 === "]" || c2 === "}") depth = Math.max(0, depth - 1);
-      else if (c2 === "?" && depth === 0) ternaryDepth++;
-      else if (c2 === ":" && depth === 0 && ternaryDepth > 0) ternaryDepth--;
-      else if (c2 === "\n" && depth <= 0 && ternaryDepth <= 0) {
-        let peek2 = i + 1;
-        while (peek2 < cleaned.length && (cleaned[peek2] === " " || cleaned[peek2] === "	" || cleaned[peek2] === "\r" || cleaned[peek2] === "\n")) peek2++;
-        if (peek2 < cleaned.length && (cleaned[peek2] === "?" || cleaned[peek2] === ":" && ternaryDepth > 0)) continue;
-        const t = cleaned.slice(stmtStart, i).trim();
-        if (t) addStmt(t);
-        stmtStart = i + 1;
-        completedEnd = i + 1;
-      }
-    }
-    return stmtStart;
-  }
-  function currentResult() {
-    refreshCleaned();
-    const pendingStart = scanNewCompleted();
-    const pendingText = cleaned.slice(pendingStart).trim();
-    if (!pendingText) {
-      if (completedCount === 0) return emptyResult();
-      return buildResult(completedStmtMap, [...completedStmtMap.values()], firstId, false, completedCount, cat, rootName);
-    }
-    const { text: closed, wasIncomplete } = autoClose(pendingText);
-    const stmts = split(tokenize(closed));
-    if (!stmts.length) {
-      if (completedCount === 0) return emptyResult(wasIncomplete);
-      return buildResult(completedStmtMap, [...completedStmtMap.values()], firstId, wasIncomplete, completedCount, cat, rootName);
-    }
-    const allStmtMap = new Map(completedStmtMap);
-    for (const s2 of stmts) {
-      if (completedStmtMap.has(s2.id)) continue;
-      const stmt = classifyStatement(s2, parseExpression(s2.tokens));
-      allStmtMap.set(s2.id, stmt);
-    }
-    return buildResult(allStmtMap, [...allStmtMap.values()], firstId || stmts[0].id, wasIncomplete, completedCount + stmts.length, cat, rootName);
-  }
-  function reset() {
-    buf = "";
-    cleaned = "";
-    completedEnd = 0;
-    completedStmtMap.clear();
-    completedCount = 0;
-    firstId = "";
-  }
-  return {
-    push(chunk) {
-      buf += chunk;
-      return currentResult();
-    },
-    set(fullText) {
-      if (fullText.length < buf.length || !fullText.startsWith(buf)) reset();
-      const delta = fullText.slice(buf.length);
-      if (delta) buf += delta;
-      return currentResult();
-    },
-    getResult: currentResult
-  };
-}
-function compileSchema(schema) {
-  const map2 = /* @__PURE__ */ new Map();
-  const defs = schema.$defs ?? {};
-  for (const [name, def] of Object.entries(defs)) {
-    const properties2 = def.properties ?? {};
-    const required = def.required ?? [];
-    const params = Object.keys(properties2).map((key) => ({
-      name: key,
-      required: required.includes(key),
-      defaultValue: getSchemaDefaultValue(properties2[key]),
-      schema: properties2[key]
-    }));
-    map2.set(name, { params });
-  }
-  return map2;
-}
-function createStreamingParser(schema, rootName) {
-  return createStreamParser(compileSchema(schema), rootName);
-}
-function buildSignatureHint(componentName, schema) {
-  if (!schema?.properties) return void 0;
-  const required = new Set(schema.required ?? []);
-  return `Signature: ${componentName}(${Object.keys(schema.properties).map((k2) => required.has(k2) ? `${k2}*` : k2).join(", ")}) \u2014 * marks required`;
-}
-function enrichErrors(validationErrors, schema, componentNames) {
-  return validationErrors.map((ve) => {
-    const error = {
-      source: "parser",
-      code: ve.code,
-      message: ve.message,
-      component: ve.component,
-      path: ve.path || void 0,
-      statementId: ve.statementId
-    };
-    if (ve.code === "unknown-component" && componentNames.length) error.hint = `Available components: ${componentNames.join(", ")}`;
-    else if (ve.code === "missing-required" || ve.code === "null-required") error.hint = buildSignatureHint(ve.component, schema.$defs?.[ve.component]);
-    else if (ve.code === "inline-reserved") error.hint = `Declare as a top-level statement: myVar = ${ve.component}(...)`;
-    return error;
-  });
-}
-function isReactiveAssign(value) {
-  return typeof value === "object" && value !== null && value.__reactive === "assign";
-}
-function evaluate(node, context, schemaCtx) {
-  switch (node.k) {
-    case "Str":
-      return node.v;
-    case "Num":
-      return node.v;
-    case "Bool":
-      return node.v;
-    case "Null":
-      return null;
-    case "Ph":
-      return null;
-    case "StateRef":
-      return context.extraScope?.[node.n] ?? context.getState(node.n);
-    case "Ref":
-    case "RuntimeRef":
-      return context.resolveRef(node.n);
-    case "Arr":
-      return node.els.map((el) => evaluate(el, context));
-    case "Obj":
-      return Object.fromEntries(node.entries.map(([k2, v2]) => [k2, evaluate(v2, context)]));
-    case "Comp": {
-      if (LAZY_BUILTINS.has(node.name)) return evaluateLazyBuiltin(node.name, node.args, context, schemaCtx);
-      const builtin = BUILTINS[node.name];
-      if (builtin) {
-        const args = node.args.map((a2) => evaluate(a2, context));
-        return builtin.fn(...args);
-      }
-      if (ACTION_NAMES.has(node.name)) return evaluateActionCall(node.name, node.args, context);
-      if (node.mappedProps) {
-        const def = schemaCtx?.library.components[node.name];
-        const props = {};
-        for (const [key, val] of Object.entries(node.mappedProps)) {
-          const propSchema = def?.props?.shape?.[key];
-          if (val.k === "StateRef" && propSchema && isReactiveSchema(propSchema)) props[key] = {
-            __reactive: "assign",
-            target: val.n,
-            expr: {
-              k: "StateRef",
-              n: "$value"
-            }
-          };
-          else if (val.k === "StateRef") props[key] = schemaCtx ? context.getState(val.n) : val;
-          else props[key] = evaluate(val, context, schemaCtx);
-        }
-        const result = {
-          type: "element",
-          typeName: node.name,
-          props,
-          partial: false,
-          hasDynamicProps: true
-        };
-        if (schemaCtx) {
-          for (const [key, val] of Object.entries(props)) if (isElementNode(val)) props[key] = evaluateElementInline(val, context, schemaCtx);
-          else if (Array.isArray(val)) props[key] = val.map((item) => isElementNode(item) ? evaluateElementInline(item, context, schemaCtx) : item);
-        }
-        return result;
-      }
-      console.warn(`[openui] Unexpected unmapped Comp node: ${node.name}`);
-      return null;
-    }
-    case "BinOp": {
-      if (node.op === "&&") {
-        const left2 = evaluate(node.left, context);
-        return left2 ? evaluate(node.right, context) : left2;
-      }
-      if (node.op === "||") {
-        const left2 = evaluate(node.left, context);
-        return left2 ? left2 : evaluate(node.right, context);
-      }
-      const left = evaluate(node.left, context);
-      const right = evaluate(node.right, context);
-      switch (node.op) {
-        case "+":
-          if (typeof left === "string" || typeof right === "string") return String(left ?? "") + String(right ?? "");
-          return toNumber$2(left) + toNumber$2(right);
-        case "-":
-          return toNumber$2(left) - toNumber$2(right);
-        case "*":
-          return toNumber$2(left) * toNumber$2(right);
-        case "/":
-          return toNumber$2(right) === 0 ? 0 : toNumber$2(left) / toNumber$2(right);
-        case "%":
-          return toNumber$2(right) === 0 ? 0 : toNumber$2(left) % toNumber$2(right);
-        case "==":
-          return left == right;
-        case "!=":
-          return left != right;
-        case ">":
-          return toNumber$2(left) > toNumber$2(right);
-        case "<":
-          return toNumber$2(left) < toNumber$2(right);
-        case ">=":
-          return toNumber$2(left) >= toNumber$2(right);
-        case "<=":
-          return toNumber$2(left) <= toNumber$2(right);
-        default:
-          return null;
-      }
-    }
-    case "UnaryOp":
-      if (node.op === "!") return !evaluate(node.operand, context);
-      if (node.op === "-") return -toNumber$2(evaluate(node.operand, context));
-      return null;
-    case "Ternary":
-      return evaluate(node.cond, context) ? evaluate(node.then, context) : evaluate(node.else, context);
-    case "Member": {
-      const obj = evaluate(node.obj, context);
-      if (obj == null) return null;
-      if (Array.isArray(obj)) {
-        if (node.field === "length") return obj.length;
-        return obj.map((item) => item?.[node.field] ?? null);
-      }
-      return obj[node.field];
-    }
-    case "Index": {
-      const obj = evaluate(node.obj, context);
-      const idx = evaluate(node.index, context);
-      if (obj == null || idx == null) return null;
-      if (Array.isArray(obj)) return obj[toNumber$2(idx)];
-      return obj[String(idx)];
-    }
-    case "Assign":
-      return {
-        __reactive: "assign",
-        target: node.target,
-        expr: node.value
-      };
-  }
-}
-function evaluateElementInline(el, context, schemaCtx) {
-  if (el.hasDynamicProps === false) return el;
-  const def = schemaCtx.library.components[el.typeName];
-  const evaluated = {};
-  for (const [key, value] of Object.entries(el.props)) {
-    const propSchema = def?.props?.shape?.[key];
-    evaluated[key] = evaluatePropInline(value, context, schemaCtx, propSchema);
-  }
-  return {
-    ...el,
-    props: evaluated
-  };
-}
-function evaluatePropInline(value, context, schemaCtx, reactiveSchema) {
-  return evaluatePropCore(value, context, schemaCtx, reactiveSchema, {
-    recurseElement: (el) => evaluateElementInline(el, context, schemaCtx),
-    recurse: (v2, rs) => evaluatePropInline(v2, context, schemaCtx, rs)
-  });
-}
-function toLiteralAST(value) {
-  if (value === null || value === void 0) return { k: "Null" };
-  if (typeof value === "string") return {
-    k: "Str",
-    v: value
-  };
-  if (typeof value === "number") return {
-    k: "Num",
-    v: value
-  };
-  if (typeof value === "boolean") return {
-    k: "Bool",
-    v: value
-  };
-  if (Array.isArray(value)) return {
-    k: "Arr",
-    els: value.map(toLiteralAST)
-  };
-  if (typeof value === "object") return {
-    k: "Obj",
-    entries: Object.entries(value).map(([k2, v2]) => [k2, toLiteralAST(v2)])
-  };
-  return { k: "Null" };
-}
-function evaluateActionCall(name, args, context) {
-  switch (name) {
-    case "Action": {
-      const stepsArg = args.length > 0 ? evaluate(args[0], context) : [];
-      return { steps: (Array.isArray(stepsArg) ? stepsArg : []).filter((s2) => s2 != null && typeof s2 === "object" && "type" in s2) };
-    }
-    case "Run": {
-      if (args.length === 0) return null;
-      const refNode = args[0];
-      if (refNode.k === "RuntimeRef") return {
-        type: ACTION_STEPS.Run,
-        statementId: refNode.n,
-        refType: refNode.refType
-      };
-      return null;
-    }
-    case "ToAssistant": {
-      const message2 = args.length > 0 ? String(evaluate(args[0], context) ?? "") : "";
-      const ctx = args.length > 1 ? String(evaluate(args[1], context) ?? "") : void 0;
-      return {
-        type: ACTION_STEPS.ToAssistant,
-        message: message2,
-        context: ctx
-      };
-    }
-    case "OpenUrl": {
-      const url = args.length > 0 ? String(evaluate(args[0], context) ?? "") : "";
-      return {
-        type: ACTION_STEPS.OpenUrl,
-        url
-      };
-    }
-    case "Set": {
-      if (args.length < 2) return null;
-      const targetNode = args[0];
-      if (targetNode.k !== "StateRef") return null;
-      return {
-        type: ACTION_STEPS.Set,
-        target: targetNode.n,
-        valueAST: args[1]
-      };
-    }
-    case "Reset": {
-      const targets = args.filter((a2) => a2.k === "StateRef").map((a2) => a2.n);
-      if (targets.length === 0) return null;
-      return {
-        type: ACTION_STEPS.Reset,
-        targets
-      };
-    }
-    default:
-      return null;
-  }
-}
-function substituteRef(node, varName, value) {
-  switch (node.k) {
-    case "Ref":
-      return node.n === varName ? toLiteralAST(value) : node;
-    case "Member":
-      if (isASTNode(node.obj)) {
-        const subObj = substituteRef(node.obj, varName, value);
-        if (subObj.k === "Obj") {
-          const entry = subObj.entries.find(([k2]) => k2 === node.field);
-          if (entry) return entry[1];
-        }
-        return {
-          ...node,
-          obj: subObj
-        };
-      }
-      return node;
-    case "Index":
-      return {
-        ...node,
-        obj: isASTNode(node.obj) ? substituteRef(node.obj, varName, value) : node.obj,
-        index: isASTNode(node.index) ? substituteRef(node.index, varName, value) : node.index
-      };
-    case "BinOp":
-      return {
-        ...node,
-        left: substituteRef(node.left, varName, value),
-        right: substituteRef(node.right, varName, value)
-      };
-    case "UnaryOp":
-      return {
-        ...node,
-        operand: substituteRef(node.operand, varName, value)
-      };
-    case "Ternary":
-      return {
-        ...node,
-        cond: substituteRef(node.cond, varName, value),
-        then: substituteRef(node.then, varName, value),
-        else: substituteRef(node.else, varName, value)
-      };
-    case "Arr":
-      return {
-        ...node,
-        els: node.els.map((e) => substituteRef(e, varName, value))
-      };
-    case "Obj":
-      return {
-        ...node,
-        entries: node.entries.map(([k2, v2]) => [k2, substituteRef(v2, varName, value)])
-      };
-    case "Comp": {
-      const result = {
-        ...node,
-        args: node.args.map((a2) => substituteRef(a2, varName, value))
-      };
-      if (node.mappedProps) {
-        const subProps = {};
-        for (const [k2, v2] of Object.entries(node.mappedProps)) subProps[k2] = substituteRef(v2, varName, value);
-        result.mappedProps = subProps;
-      }
-      return result;
-    }
-    case "Assign":
-      return {
-        ...node,
-        value: substituteRef(node.value, varName, value)
-      };
-    default:
-      return node;
-  }
-}
-function evaluateLazyBuiltin(name, args, context, schemaCtx) {
-  if (name === "Each") {
-    if (args.length < 3) return [];
-    const arr = evaluate(args[0], context);
-    if (!Array.isArray(arr)) return [];
-    const varName = args[1].k === "Ref" ? args[1].n : args[1].k === "Str" ? args[1].v : null;
-    if (!varName) return [];
-    const template = args[2];
-    return arr.map((item, _idx) => {
-      const substituted = substituteRef(template, varName, item);
-      const childCtx = {
-        ...context,
-        resolveRef: (refName) => {
-          if (refName === varName) return item;
-          return context.resolveRef(refName);
-        }
-      };
-      const result = evaluate(substituted, childCtx, schemaCtx);
-      if (schemaCtx && isElementNode(result)) return evaluateElementInline(result, childCtx, schemaCtx);
-      return result;
-    });
-  }
-  return null;
-}
-function evaluatePropCore(value, context, schemaCtx, reactiveSchema, callbacks) {
-  if (value == null) return value;
-  if (typeof value !== "object") return value;
-  if (isASTNode(value)) {
-    if (value.k === "StateRef" && reactiveSchema && isReactiveSchema(reactiveSchema)) return {
-      __reactive: "assign",
-      target: value.n,
-      expr: {
-        k: "StateRef",
-        n: "$value"
-      }
-    };
-    const result = evaluate(value, context, schemaCtx);
-    if (isElementNode(result)) return callbacks.recurseElement(result);
-    if (Array.isArray(result)) return result.map((item) => isElementNode(item) ? callbacks.recurseElement(item) : item);
-    if (isReactiveAssign(result) && !(reactiveSchema && isReactiveSchema(reactiveSchema))) return context.getState(result.target) ?? null;
-    return result;
-  }
-  if (typeof value === "string" && reactiveSchema && isReactiveSchema(reactiveSchema)) return value;
-  if (Array.isArray(value)) return value.map((v2) => callbacks.recurse(v2, reactiveSchema));
-  if (isElementNode(value)) return callbacks.recurseElement(value);
-  const obj = value;
-  if ("steps" in obj && Array.isArray(obj.steps)) return value;
-  if ("type" in obj && "valueAST" in obj) return value;
-  let needsEval = false;
-  for (const val of Object.values(obj)) if (typeof val === "object" && val !== null) {
-    needsEval = true;
-    break;
-  }
-  if (needsEval) {
-    const result = {};
-    for (const [k2, v2] of Object.entries(obj)) result[k2] = callbacks.recurse(v2, reactiveSchema);
-    return result;
-  }
-  return value;
-}
-function evaluateElementProps(el, evalCtx) {
-  if (el.hasDynamicProps === false) return el;
-  const schemaCtx = { library: evalCtx.library };
-  const def = evalCtx.library.components[el.typeName];
-  const evaluated = {};
-  for (const [key, value] of Object.entries(el.props)) {
-    const propSchema = def?.props?.shape?.[key];
-    try {
-      evaluated[key] = evaluatePropValue(value, evalCtx, schemaCtx, propSchema);
-    } catch (e) {
-      evaluated[key] = value;
-      const msg = e instanceof Error ? e.message : String(e);
-      evalCtx.errors?.push({
-        source: "runtime",
-        code: "runtime-error",
-        component: el.typeName,
-        statementId: el.statementId,
-        message: `Evaluating prop "${key}" on ${el.typeName} failed: ${msg}`,
-        hint: `Check the expression used for prop "${key}"`
-      });
-    }
-  }
-  return {
-    ...el,
-    props: evaluated
-  };
-}
-function evaluatePropValue(value, evalCtx, schemaCtx, reactiveSchema) {
-  return evaluatePropCore(value, evalCtx.ctx, schemaCtx, reactiveSchema, {
-    recurseElement: (el) => evaluateElementProps(el, evalCtx),
-    recurse: (v2, rs) => evaluatePropValue(v2, evalCtx, schemaCtx, rs)
-  });
-}
-var McpToolError = class extends Error {
-  toolErrorText;
-  constructor(errorText) {
-    super(`MCP tool error: ${errorText || "Unknown error"}`);
-    this.name = "McpToolError";
-    this.toolErrorText = errorText;
-  }
-};
-function extractToolResult(result) {
-  if (result.isError) {
-    const errorText = result.content?.filter((c2) => c2.type === "text").map((c2) => c2.text).join("\n");
-    throw new McpToolError(errorText || "Unknown error");
-  }
-  if (result.structuredContent != null) return result.structuredContent;
-  const textParts = result.content?.filter((c2) => c2.type === "text").map((c2) => c2.text ?? "");
-  if (textParts?.length) {
-    const text = textParts.join("");
-    try {
-      return JSON.parse(text);
-    } catch {
-      return text;
-    }
-  }
-  return null;
-}
-var ToolNotFoundError = class extends Error {
-  toolName;
-  availableTools;
-  constructor(toolName, availableTools = []) {
-    super(`[openui] No handler for tool "${toolName}". Available: ${availableTools.join(", ") || "(none)"}`);
-    this.name = "ToolNotFoundError";
-    this.toolName = toolName;
-    this.availableTools = availableTools;
-  }
-};
-function stableStringify(value) {
-  return JSON.stringify(value, (_key, val) => {
-    if (val && typeof val === "object" && !Array.isArray(val)) {
-      const sorted = {};
-      for (const k2 of Object.keys(val).sort()) sorted[k2] = val[k2];
-      return sorted;
-    }
-    if (val === void 0) return "__undefined__";
-    if (typeof val === "number") {
-      if (Number.isNaN(val)) return "__NaN__";
-      if (val === Infinity) return "__Inf__";
-      if (val === -Infinity) return "__-Inf__";
-    }
-    return val;
-  });
-}
-function buildCacheKey(toolName, args, deps) {
-  const depsKey = deps != null ? "::" + stableStringify(deps) : "";
-  return toolName + "::" + stableStringify(args) + depsKey;
-}
-function createQueryManager(toolProvider) {
-  const queries = /* @__PURE__ */ new Map();
-  const mutations = /* @__PURE__ */ new Map();
-  const cache2 = /* @__PURE__ */ new Map();
-  const listeners = /* @__PURE__ */ new Set();
-  let snapshot = {
-    __openui_loading: [],
-    __openui_refetching: [],
-    __openui_errors: []
-  };
-  let snapshotJson = JSON.stringify(snapshot);
-  let disposed = false;
-  let generation = 0;
-  function rebuildSnapshot() {
-    const out = {
-      __openui_loading: [],
-      __openui_refetching: [],
-      __openui_errors: []
-    };
-    for (const [sid, q2] of queries) {
-      const entry = cache2.get(q2.cacheKey);
-      if (entry && entry.data !== void 0) out[sid] = entry.data;
-      else if (q2.prevCacheKey) {
-        const prev = cache2.get(q2.prevCacheKey);
-        if (prev && prev.data !== void 0) out[sid] = prev.data;
-        else out[sid] = q2.defaults;
-      } else out[sid] = q2.defaults;
-      if (q2.loading) {
-        out.__openui_loading.push(sid);
-        if (q2.everFetched) out.__openui_refetching.push(sid);
-      }
-      if (q2.error) out.__openui_errors.push(q2.error);
-    }
-    for (const [sid, m] of mutations) {
-      out[sid] = m.result;
-      if (m.error) out.__openui_errors.push(m.error);
-    }
-    try {
-      const outJson = JSON.stringify(out);
-      if (outJson === snapshotJson) return false;
-      snapshot = out;
-      snapshotJson = outJson;
-    } catch {
-      snapshot = out;
-      snapshotJson = "";
-    }
-    return true;
-  }
-  function notify() {
-    for (const listener2 of [...listeners]) listener2();
-  }
-  async function executeFetch(cacheKey, statementId) {
-    if (!toolProvider) return;
-    const q2 = queries.get(statementId);
-    if (!q2) return;
-    const fetchKey = cacheKey;
-    const toolName = q2.toolName;
-    const args = q2.args;
-    let entry = cache2.get(fetchKey);
-    if (!entry) {
-      entry = {
-        data: void 0,
-        inFlight: true
-      };
-      cache2.set(fetchKey, entry);
-    } else entry.inFlight = true;
-    q2.loading = true;
-    rebuildSnapshot();
-    notify();
-    try {
-      const data = await toolProvider.callTool(toolName, args ?? {});
-      if (disposed) return;
-      const current2 = queries.get(statementId);
-      if (!current2 || current2.cacheKey !== fetchKey) {
-        entry.inFlight = false;
-        return;
-      }
-      entry.data = data ?? null;
-      current2.everFetched = true;
-      current2.error = void 0;
-      if (current2.prevCacheKey && current2.prevCacheKey !== fetchKey) {
-        const prevKey = current2.prevCacheKey;
-        current2.prevCacheKey = void 0;
-        cleanupCacheEntry(prevKey);
-      }
-    } catch (err) {
-      const current2 = queries.get(statementId);
-      if (current2 && current2.cacheKey === fetchKey) if (err instanceof ToolNotFoundError) current2.error = {
-        source: "query",
-        code: "tool-not-found",
-        message: `Query tool "${toolName}" not found`,
-        statementId,
-        component: "Query",
-        toolName,
-        hint: err.availableTools.length ? `Available tools: ${err.availableTools.join(", ")}` : void 0
-      };
-      else if (err instanceof McpToolError) current2.error = {
-        source: "query",
-        code: "mcp-error",
-        message: `Query "${toolName}" returned an error: ${err.toolErrorText}`,
-        statementId,
-        component: "Query",
-        toolName
-      };
-      else current2.error = {
-        source: "query",
-        code: "tool-error",
-        message: `Query "${toolName}" failed: ${err instanceof Error ? err.message : String(err)}`,
-        statementId,
-        component: "Query",
-        toolName
-      };
-      console.error(`Query "${toolName}" failed:`, err);
-    } finally {
-      entry.inFlight = false;
-      const current2 = queries.get(statementId);
-      if (current2 && current2.cacheKey === fetchKey) {
-        current2.loading = false;
-        if (rebuildSnapshot()) notify();
-        if (current2.needsRefetch) {
-          current2.needsRefetch = false;
-          executeFetch(current2.cacheKey, statementId);
-        }
-      } else if (rebuildSnapshot()) notify();
-    }
-  }
-  function cleanupCacheEntry(cacheKey) {
-    for (const q2 of queries.values()) if (q2.cacheKey === cacheKey || q2.prevCacheKey === cacheKey) return;
-    cache2.delete(cacheKey);
-  }
-  function evaluateQueries(queryNodes) {
-    if (disposed) return;
-    const activeIds = new Set(queryNodes.map((n) => n.statementId));
-    for (const [sid, q2] of queries) if (!activeIds.has(sid)) {
-      if (q2.timer) clearInterval(q2.timer);
-      queries.delete(sid);
-      cleanupCacheEntry(q2.cacheKey);
-      if (q2.prevCacheKey) cleanupCacheEntry(q2.prevCacheKey);
-    }
-    for (const node of queryNodes) {
-      if (!node.complete) continue;
-      const cacheKey = buildCacheKey(node.toolName, node.args, node.deps);
-      const existing = queries.get(node.statementId);
-      if (existing) {
-        if (existing.cacheKey !== cacheKey) existing.prevCacheKey = existing.cacheKey;
-        existing.toolName = node.toolName;
-        existing.args = node.args;
-        existing.defaults = node.defaults;
-        existing.cacheKey = cacheKey;
-      } else queries.set(node.statementId, {
-        toolName: node.toolName,
-        args: node.args,
-        defaults: node.defaults,
-        cacheKey,
-        loading: false,
-        everFetched: false,
-        refreshInterval: 0,
-        needsRefetch: false
-      });
-      const q2 = queries.get(node.statementId);
-      const entry = cache2.get(cacheKey);
-      const hasSettledData = entry && entry.data !== void 0 && !entry.inFlight;
-      if (toolProvider && !hasSettledData && !entry?.inFlight) executeFetch(cacheKey, node.statementId);
-      const newInterval = node.refreshInterval ?? 0;
-      if (newInterval !== q2.refreshInterval) {
-        if (q2.timer) {
-          clearInterval(q2.timer);
-          q2.timer = void 0;
-        }
-        if (newInterval > 0) q2.timer = setInterval(() => {
-          if (disposed || !toolProvider) return;
-          if (!cache2.get(q2.cacheKey)?.inFlight) executeFetch(q2.cacheKey, node.statementId);
-        }, newInterval * 1e3);
-        q2.refreshInterval = newInterval;
-      }
-    }
-    if (rebuildSnapshot()) notify();
-  }
-  function getResult(statementId) {
-    const q2 = queries.get(statementId);
-    if (!q2) return null;
-    const entry = cache2.get(q2.cacheKey);
-    if (entry && entry.data !== void 0) return entry.data;
-    if (q2.prevCacheKey) {
-      const prev = cache2.get(q2.prevCacheKey);
-      if (prev && prev.data !== void 0) return prev.data;
-    }
-    return q2.defaults;
-  }
-  function isLoading(statementId) {
-    return queries.get(statementId)?.loading ?? false;
-  }
-  function isAnyLoading() {
-    for (const q2 of queries.values()) if (q2.loading) return true;
-    return false;
-  }
-  function invalidate(statementIds) {
-    if (disposed || !toolProvider) return;
-    const targets = statementIds?.length ? statementIds.filter((sid) => queries.has(sid)) : [...queries.keys()];
-    for (const sid of targets) {
-      const q2 = queries.get(sid);
-      if (!q2) continue;
-      if (cache2.get(q2.cacheKey)?.inFlight) q2.needsRefetch = true;
-      else executeFetch(q2.cacheKey, sid);
-    }
-  }
-  function registerMutations(nodes) {
-    const activeIds = new Set(nodes.map((n) => n.statementId));
-    for (const sid of mutations.keys()) if (!activeIds.has(sid)) mutations.delete(sid);
-    for (const node of nodes) {
-      const existing = mutations.get(node.statementId);
-      if (existing) {
-        if (existing.toolName !== node.toolName) {
-          existing.toolName = node.toolName;
-          existing.result = {
-            status: "idle",
-            data: null,
-            error: null
-          };
-          existing.error = void 0;
-        }
-      } else mutations.set(node.statementId, {
-        toolName: node.toolName,
-        result: { status: "idle" }
-      });
-    }
-    if (rebuildSnapshot()) notify();
-  }
-  async function fireMutation(statementId, evaluatedArgs, refreshQueryIds) {
-    if (disposed || !toolProvider) return false;
-    const m = mutations.get(statementId);
-    if (!m) return false;
-    if (m.result.status === "loading") return false;
-    const gen = generation;
-    m.result = { status: "loading" };
-    rebuildSnapshot();
-    notify();
-    let success = false;
-    try {
-      const data = await toolProvider.callTool(m.toolName, evaluatedArgs);
-      if (disposed || gen !== generation) return false;
-      m.result = {
-        status: "success",
-        data
-      };
-      m.error = void 0;
-      success = true;
-    } catch (err) {
-      if (disposed || gen !== generation) return false;
-      const msg = err instanceof Error ? err.message : String(err);
-      m.result = {
-        status: "error",
-        error: msg
-      };
-      if (err instanceof ToolNotFoundError) m.error = {
-        source: "mutation",
-        code: "tool-not-found",
-        message: `Mutation tool "${m.toolName}" not found`,
-        statementId,
-        component: "Mutation",
-        toolName: m.toolName,
-        hint: err.availableTools.length ? `Available tools: ${err.availableTools.join(", ")}` : void 0
-      };
-      else if (err instanceof McpToolError) m.error = {
-        source: "mutation",
-        code: "mcp-error",
-        message: `Mutation "${m.toolName}" returned an error: ${err.toolErrorText}`,
-        statementId,
-        component: "Mutation",
-        toolName: m.toolName
-      };
-      else m.error = {
-        source: "mutation",
-        code: "tool-error",
-        message: `Mutation "${m.toolName}" failed: ${msg}`,
-        statementId,
-        component: "Mutation",
-        toolName: m.toolName
-      };
-    }
-    rebuildSnapshot();
-    notify();
-    if (success && refreshQueryIds?.length) invalidate(refreshQueryIds);
-    return success;
-  }
-  function getMutationResult(statementId) {
-    return mutations.get(statementId)?.result ?? null;
-  }
-  function subscribe2(listener2) {
-    listeners.add(listener2);
-    return () => listeners.delete(listener2);
-  }
-  function getSnapshot() {
-    return snapshot;
-  }
-  function activate() {
-    disposed = false;
-  }
-  function dispose() {
-    disposed = true;
-    generation++;
-    listeners.clear();
-    for (const q2 of queries.values()) {
-      if (q2.timer) {
-        clearInterval(q2.timer);
-        q2.timer = void 0;
-      }
-      q2.refreshInterval = 0;
-      q2.loading = false;
-      q2.needsRefetch = false;
-    }
-    mutations.clear();
-  }
-  return {
-    evaluateQueries,
-    getResult,
-    isLoading,
-    isAnyLoading,
-    invalidate,
-    registerMutations,
-    fireMutation,
-    getMutationResult,
-    subscribe: subscribe2,
-    getSnapshot,
-    activate,
-    dispose
-  };
-}
-function resolveStateField(name, bindingValue, store2, evaluationContext, fieldGetter, fieldSetter) {
-  if (isReactiveAssign(bindingValue) && store2 && evaluationContext) {
-    const { target, expr } = bindingValue;
-    return {
-      name,
-      value: store2.get(target),
-      setValue: (value) => {
-        const extraScope = { $value: value };
-        const nextValue = evaluate(expr, {
-          ...evaluationContext,
-          extraScope
-        });
-        store2.set(target, nextValue);
-      },
-      isReactive: true
-    };
-  }
-  return {
-    name,
-    value: fieldGetter(name) ?? bindingValue,
-    setValue: (value) => fieldSetter(name, value),
-    isReactive: false
-  };
-}
-function createStore$2() {
-  const state = /* @__PURE__ */ new Map();
-  const listeners = /* @__PURE__ */ new Set();
-  let snapshot = {};
-  function notify() {
-    const currentListeners = [...listeners];
-    for (const listener2 of currentListeners) listener2();
-  }
-  function rebuildSnapshot() {
-    snapshot = Object.fromEntries(state);
-  }
-  function get2(name) {
-    return state.get(name);
-  }
-  function set3(name, value) {
-    const existing = state.get(name);
-    if (Object.is(existing, value)) return;
-    if (value && existing && typeof value === "object" && typeof existing === "object" && !Array.isArray(value) && !Array.isArray(existing)) {
-      const nk = Object.keys(value);
-      const ok = Object.keys(existing);
-      if (nk.length === ok.length && nk.every((k2) => Object.is(value[k2], existing[k2]))) return;
-    }
-    state.set(name, value);
-    rebuildSnapshot();
-    notify();
-  }
-  function subscribe2(listener2) {
-    listeners.add(listener2);
-    return () => {
-      listeners.delete(listener2);
-    };
-  }
-  function getSnapshot() {
-    return snapshot;
-  }
-  function initialize(defaults2, persisted) {
-    for (const key of Object.keys(persisted)) state.set(key, persisted[key]);
-    for (const key of Object.keys(defaults2)) if (!state.has(key)) state.set(key, defaults2[key]);
-    rebuildSnapshot();
-    notify();
-  }
-  function dispose() {
-    state.clear();
-    listeners.clear();
-    snapshot = {};
-  }
-  return {
-    get: get2,
-    set: set3,
-    subscribe: subscribe2,
-    getSnapshot,
-    initialize,
-    dispose
-  };
-}
-function isEmpty(value) {
-  if (value === null || value === void 0 || value === "") return true;
-  if (Array.isArray(value) && value.length === 0) return true;
-  if (value && typeof value === "object" && !Array.isArray(value) && "value" in value) return isEmpty(value.value);
-  if (typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0) return true;
-  return false;
-}
-var builtInValidators = {
-  required: (value) => {
-    if (isEmpty(value)) return "This field is required";
-    if (typeof value === "object" && !Array.isArray(value) && value !== null) {
-      const vals = Object.values(value);
-      if (vals.length > 0 && vals.every((v2) => typeof v2 === "boolean") && !vals.some(Boolean)) return "At least one option is required";
-    }
-  },
-  email: (value) => {
-    if (isEmpty(value)) return void 0;
-    if (typeof value !== "string") return "Please enter a valid email";
-    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) ? void 0 : "Please enter a valid email";
-  },
-  url: (value) => {
-    if (isEmpty(value)) return void 0;
-    if (typeof value !== "string") return "Please enter a valid URL";
-    try {
-      new URL(value);
-      return;
-    } catch {
-      return "Please enter a valid URL";
-    }
-  },
-  numeric: (value) => {
-    if (isEmpty(value)) return void 0;
-    if (typeof value === "number" && !isNaN(value)) return void 0;
-    if (typeof value === "string" && !isNaN(parseFloat(value)) && value.trim() !== "") return void 0;
-    return "Must be a number";
-  },
-  min: (value, arg) => {
-    if (isEmpty(value)) return void 0;
-    const n = typeof value === "number" ? value : parseFloat(String(value));
-    if (isNaN(n)) return void 0;
-    const min = Number(arg);
-    return n >= min ? void 0 : `Must be at least ${min}`;
-  },
-  max: (value, arg) => {
-    if (isEmpty(value)) return void 0;
-    const n = typeof value === "number" ? value : parseFloat(String(value));
-    if (isNaN(n)) return void 0;
-    const max = Number(arg);
-    return n <= max ? void 0 : `Must be no more than ${max}`;
-  },
-  minLength: (value, arg) => {
-    if (isEmpty(value)) return void 0;
-    if (typeof value !== "string") return void 0;
-    const min = Number(arg);
-    return value.length >= min ? void 0 : `Must be at least ${min} characters`;
-  },
-  maxLength: (value, arg) => {
-    if (isEmpty(value)) return void 0;
-    if (typeof value !== "string") return void 0;
-    const max = Number(arg);
-    return value.length <= max ? void 0 : `Must be no more than ${max} characters`;
-  },
-  pattern: (value, arg) => {
-    if (isEmpty(value)) return void 0;
-    if (typeof value !== "string" || typeof arg !== "string") return void 0;
-    try {
-      return new RegExp(arg).test(value) ? void 0 : "Invalid format";
-    } catch {
-      return;
-    }
-  }
-};
-function validate(value, rules, customValidators) {
-  for (const rule of rules) {
-    const validator = customValidators?.[rule.type] ?? builtInValidators[rule.type];
-    if (!validator) {
-      console.warn(`[openui] Unknown validation rule type: "${rule.type}"`);
-      continue;
-    }
-    const error = validator(value, rule.arg);
-    if (error) return error;
-  }
-}
-function parseStructuredRules(rules) {
-  if (!rules || typeof rules !== "object" || Array.isArray(rules)) return [];
-  const obj = rules;
-  const result = [];
-  for (const [key, val] of Object.entries(obj)) {
-    if (val === false || val === void 0 || val === null) continue;
-    if (val === true) result.push({ type: key });
-    else result.push({
-      type: key,
-      arg: val
-    });
-  }
-  return result;
-}
 var ALL_KEY = "all";
 function createObservability() {
   const listeners = /* @__PURE__ */ new Map();
@@ -22105,7 +18703,7 @@ function useOpenUIState({ response, library, isStreaming, onAction, onStateUpdat
       return null;
     }
   }, [sp, response]);
-  const store2 = useMemo2(() => createStore$2(), []);
+  const store2 = useMemo2(() => createStore(), []);
   const queryManager = useMemo2(() => createQueryManager(toolProvider ?? null), [toolProvider]);
   useEffect2(() => {
     queryManager.activate();
@@ -24115,37 +20713,37 @@ function toPath(deepKey) {
   if (key) result.push(key);
   return result;
 }
-function get$7(object2, path2, defaultValue) {
-  if (object2 == null) return defaultValue;
+function get$7(object, path2, defaultValue) {
+  if (object == null) return defaultValue;
   switch (typeof path2) {
     case "string": {
       if (isUnsafeProperty(path2)) return defaultValue;
-      const result = object2[path2];
-      if (result === void 0) if (isDeepKey(path2) && !Object.hasOwn(object2, path2)) return get$7(object2, toPath(path2), defaultValue);
+      const result = object[path2];
+      if (result === void 0) if (isDeepKey(path2) && !Object.hasOwn(object, path2)) return get$7(object, toPath(path2), defaultValue);
       else return defaultValue;
       return result;
     }
     case "number":
     case "symbol": {
       if (typeof path2 === "number") path2 = toKey(path2);
-      const result = object2[path2];
+      const result = object[path2];
       if (result === void 0) return defaultValue;
       return result;
     }
     default: {
-      if (Array.isArray(path2)) return getWithPath(object2, path2, defaultValue);
+      if (Array.isArray(path2)) return getWithPath(object, path2, defaultValue);
       if (Object.is(path2?.valueOf(), -0)) path2 = "-0";
       else path2 = String(path2);
       if (isUnsafeProperty(path2)) return defaultValue;
-      const result = object2[path2];
+      const result = object[path2];
       if (result === void 0) return defaultValue;
       return result;
     }
   }
 }
-function getWithPath(object2, path2, defaultValue) {
+function getWithPath(object, path2, defaultValue) {
   if (path2.length === 0) return defaultValue;
-  let current2 = object2;
+  let current2 = object;
   for (let index = 0; index < path2.length; index++) {
     if (current2 == null) return defaultValue;
     if (isUnsafeProperty(path2[index])) return defaultValue;
@@ -24641,8 +21239,8 @@ function isArrayLike(value) {
   return value != null && typeof value !== "function" && isLength(value.length);
 }
 function property(path2) {
-  return function(object2) {
-    return get$7(object2, path2);
+  return function(object) {
+    return get$7(object, path2);
   };
 }
 function isPrimitive(value) {
@@ -24651,8 +21249,8 @@ function isPrimitive(value) {
 function isTypedArray(x2) {
   return ArrayBuffer.isView(x2) && !(x2 instanceof DataView);
 }
-function getSymbols(object2) {
-  return Object.getOwnPropertySymbols(object2).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object2, symbol));
+function getSymbols(object) {
+  return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
 }
 function getTag(value) {
   if (value == null) return value === void 0 ? "[object Undefined]" : "[object Null]";
@@ -24791,8 +21389,8 @@ function copyProperties(target, source, objectToClone = target, stack, cloneValu
     if (descriptor == null || descriptor.writable) target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
   }
 }
-function isCloneableObject(object2) {
-  switch (getTag(object2)) {
+function isCloneableObject(object) {
+  switch (getTag(object)) {
     case argumentsTag:
     case arrayTag:
     case arrayBufferTag:
@@ -24831,8 +21429,8 @@ function isObject$6(value) {
 }
 function isMatchWith(target, source, compare) {
   if (typeof compare !== "function") return isMatchWith(target, source, () => void 0);
-  return isMatchWithInternal(target, source, function doesMatch(objValue, srcValue, key, object2, source2, stack) {
-    const isEqual = compare(objValue, srcValue, key, object2, source2, stack);
+  return isMatchWithInternal(target, source, function doesMatch(objValue, srcValue, key, object, source2, stack) {
+    const isEqual = compare(objValue, srcValue, key, object, source2, stack);
     if (isEqual !== void 0) return Boolean(isEqual);
     return isMatchWithInternal(objValue, srcValue, doesMatch, stack, false);
   }, /* @__PURE__ */ new Map(), true);
@@ -24926,14 +21524,14 @@ function matches(source) {
   };
 }
 function cloneDeepWith(obj, customizer) {
-  return cloneDeepWith$1(obj, (value, key, object2, stack) => {
-    const cloned = customizer?.(value, key, object2, stack);
+  return cloneDeepWith$1(obj, (value, key, object, stack) => {
+    const cloned = customizer?.(value, key, object, stack);
     if (cloned !== void 0) return cloned;
     if (typeof obj !== "object") return;
     if (getTag(obj) === "[object Object]" && typeof obj.constructor !== "function") {
       const result = {};
       stack.set(obj, result);
-      copyProperties(result, obj, object2, stack);
+      copyProperties(result, obj, object, stack);
       return result;
     }
     switch (Object.prototype.toString.call(obj)) {
@@ -24973,13 +21571,13 @@ function isIndex(value, length = Number.MAX_SAFE_INTEGER) {
 function isArguments(value) {
   return value !== null && typeof value === "object" && getTag(value) === "[object Arguments]";
 }
-function has$2(object2, path2) {
+function has$2(object, path2) {
   let resolvedPath;
   if (Array.isArray(path2)) resolvedPath = path2;
-  else if (typeof path2 === "string" && isDeepKey(path2) && !(path2 in Object(object2))) resolvedPath = toPath(path2);
+  else if (typeof path2 === "string" && isDeepKey(path2) && !(path2 in Object(object))) resolvedPath = toPath(path2);
   else resolvedPath = [path2];
   if (resolvedPath.length === 0) return false;
-  let current2 = object2;
+  let current2 = object;
   for (let i = 0; i < resolvedPath.length; i++) {
     const key = resolvedPath[i];
     if (current2 == null || !Object.hasOwn(current2, key)) {
@@ -25222,9 +21820,9 @@ function flatten(arr, depth = 1) {
   recursive(arr, 0);
   return result;
 }
-function isIterateeCall(value, index, object2) {
-  if (!isObject$6(object2)) return false;
-  if (typeof index === "number" && isArrayLike(object2) && isIndex(index) && index < object2.length || typeof index === "string" && index in object2) return eq(object2[index], value);
+function isIterateeCall(value, index, object) {
+  if (!isObject$6(object)) return false;
+  if (typeof index === "number" && isArrayLike(object) && isIndex(index) && index < object.length || typeof index === "string" && index in object) return eq(object[index], value);
   return false;
 }
 function getPriority(a2) {
@@ -25251,10 +21849,10 @@ function isSymbol$1(value) {
 }
 var regexIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
 var regexIsPlainProp = /^\w*$/;
-function isKey(value, object2) {
+function isKey(value, object) {
   if (Array.isArray(value)) return false;
   if (typeof value === "number" || typeof value === "boolean" || value == null || isSymbol$1(value)) return true;
-  return typeof value === "string" && (regexIsPlainProp.test(value) || !regexIsDeepProp.test(value)) || object2 != null && Object.hasOwn(object2, value);
+  return typeof value === "string" && (regexIsPlainProp.test(value) || !regexIsDeepProp.test(value)) || object != null && Object.hasOwn(object, value);
 }
 function orderBy(collection, criteria, orders, guard) {
   if (collection == null) return [];
@@ -25264,22 +21862,22 @@ function orderBy(collection, criteria, orders, guard) {
   if (criteria.length === 0) criteria = [null];
   if (!Array.isArray(orders)) orders = orders == null ? [] : [orders];
   orders = orders.map((order) => String(order));
-  const getValueByNestedPath = (object2, path2) => {
-    let target = object2;
+  const getValueByNestedPath = (object, path2) => {
+    let target = object;
     let index = 0;
     for (; index < path2.length && target != null; ++index) target = target[path2[index]];
     return index > 0 && index === path2.length ? target : void 0;
   };
-  const getValueByCriterion = (criterion, object2) => {
-    if (criterion == null) return object2;
-    if (object2 == null) return;
+  const getValueByCriterion = (criterion, object) => {
+    if (criterion == null) return object;
+    if (object == null) return;
     if (typeof criterion === "object" && "key" in criterion) {
-      if (Object.hasOwn(object2, criterion.key)) return object2[criterion.key];
-      return getValueByNestedPath(object2, criterion.path);
+      if (Object.hasOwn(object, criterion.key)) return object[criterion.key];
+      return getValueByNestedPath(object, criterion.path);
     }
-    if (typeof criterion === "function") return criterion(object2);
-    if (Array.isArray(criterion)) return getValueByNestedPath(object2, criterion);
-    return object2[criterion];
+    if (typeof criterion === "function") return criterion(object);
+    if (Array.isArray(criterion)) return getValueByNestedPath(object, criterion);
+    return object[criterion];
   };
   const preparedCriteria = criteria.map((criterion) => {
     if (Array.isArray(criterion) && criterion.length === 1) criterion = criterion[0];
@@ -25572,8 +22170,8 @@ function compose$1(...funcs) {
   return funcs.reduce((a2, b) => (...args) => a2(b(...args)));
 }
 function applyMiddleware(...middlewares) {
-  return (createStore2) => (reducer, preloadedState) => {
-    const store2 = createStore2(reducer, preloadedState);
+  return (createStore22) => (reducer, preloadedState) => {
+    const store2 = createStore22(reducer, preloadedState);
     let dispatch = () => {
       throw new Error(formatProdErrorMessage$1(15));
     };
@@ -39703,28 +36301,28 @@ var require_react_is_production = /* @__PURE__ */ __commonJSMin(((exports) => {
   var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
   var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
   var REACT_VIEW_TRANSITION_TYPE = /* @__PURE__ */ Symbol.for("react.view_transition");
-  function typeOf(object2) {
-    if ("object" === typeof object2 && null !== object2) {
-      var $$typeof = object2.$$typeof;
+  function typeOf(object) {
+    if ("object" === typeof object && null !== object) {
+      var $$typeof = object.$$typeof;
       switch ($$typeof) {
         case REACT_ELEMENT_TYPE:
-          switch (object2 = object2.type, object2) {
+          switch (object = object.type, object) {
             case REACT_FRAGMENT_TYPE:
             case REACT_PROFILER_TYPE:
             case REACT_STRICT_MODE_TYPE:
             case REACT_SUSPENSE_TYPE:
             case REACT_SUSPENSE_LIST_TYPE:
             case REACT_VIEW_TRANSITION_TYPE:
-              return object2;
+              return object;
             default:
-              switch (object2 = object2 && object2.$$typeof, object2) {
+              switch (object = object && object.$$typeof, object) {
                 case REACT_CONTEXT_TYPE:
                 case REACT_FORWARD_REF_TYPE:
                 case REACT_LAZY_TYPE:
                 case REACT_MEMO_TYPE:
-                  return object2;
+                  return object;
                 case REACT_CONSUMER_TYPE:
-                  return object2;
+                  return object;
                 default:
                   return $$typeof;
               }
@@ -39734,8 +36332,8 @@ var require_react_is_production = /* @__PURE__ */ __commonJSMin(((exports) => {
       }
     }
   }
-  exports.isFragment = function(object2) {
-    return typeOf(object2) === REACT_FRAGMENT_TYPE;
+  exports.isFragment = function(object) {
+    return typeOf(object) === REACT_FRAGMENT_TYPE;
   };
 }));
 var import_react_is$1 = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -48853,7 +45451,7 @@ var createStoreImpl = (createState) => {
   const initialState2 = state = createState(setState, getState2, api);
   return api;
 };
-var createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+var createStore2 = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
 var { useDebugValue } = React;
 var { useSyncExternalStoreWithSelector } = import_with_selector$1.default;
 var identity$2 = (arg) => arg;
@@ -48863,7 +45461,7 @@ function useStore(api, selector = identity$2, equalityFn) {
   return slice;
 }
 var createImpl = (createState) => {
-  const api = typeof createState === "function" ? createStore(createState) : createState;
+  const api = typeof createState === "function" ? createStore2(createState) : createState;
   const useBoundStore = (selector, equalityFn) => useStore(api, selector, equalityFn);
   Object.assign(useBoundStore, api);
   return useBoundStore;
@@ -49459,20 +46057,20 @@ function buildArtifactRendererRegistry(configs) {
     byType
   };
 }
-function lookupArtifactRenderer(registry2, toolName) {
-  return registry2.byToolName.get(toolName) ?? null;
+function lookupArtifactRenderer(registry, toolName) {
+  return registry.byToolName.get(toolName) ?? null;
 }
-function lookupArtifactRendererByType(registry2, type) {
-  return registry2.byType.get(type) ?? null;
+function lookupArtifactRendererByType(registry, type) {
+  return registry.byType.get(type) ?? null;
 }
 var ArtifactRenderersContext = createContext2(null);
 var useArtifactRendererRegistry = () => {
   return useContext2(ArtifactRenderersContext);
 };
 function useArtifactRenderer(toolName) {
-  const registry2 = useArtifactRendererRegistry();
-  if (!registry2) return null;
-  return lookupArtifactRenderer(registry2, toolName);
+  const registry = useArtifactRendererRegistry();
+  if (!registry) return null;
+  return lookupArtifactRenderer(registry, toolName);
 }
 function useDetailedView(viewId) {
   const store2 = useDetailedViewStore();
@@ -50019,7 +46617,7 @@ var mergeThreadList = (existing, incoming) => Array.from(new Map([...existing, .
 var createChatStore = (configRef) => {
   const { storage } = configRef.current;
   const { thread: threadStorage } = storage;
-  return createStore()(subscribeWithSelector((set3, get2) => ({
+  return createStore2()(subscribeWithSelector((set3, get2) => ({
     threads: [],
     isLoadingThreads: false,
     threadListError: null,
@@ -50218,7 +46816,7 @@ var createChatStore = (configRef) => {
   })));
 };
 var createDetailedViewStore = () => {
-  return createStore()(subscribeWithSelector((set3, get2) => ({
+  return createStore2()(subscribeWithSelector((set3, get2) => ({
     activeDetailedViewId: null,
     setActiveDetailedView: (id) => {
       set3({ activeDetailedViewId: id });
@@ -50233,16 +46831,16 @@ var createDetailedViewStore = () => {
   })));
 };
 var entriesEqual = (a2, b) => a2.heading === b.heading && a2.type === b.type;
-var upsertVersion = (registry2, entry) => {
-  const existing = registry2[entry.id] ?? [];
+var upsertVersion = (registry, entry) => {
+  const existing = registry[entry.id] ?? [];
   const sameVersionIdx = existing.findIndex((e) => e.version === entry.version);
   if (sameVersionIdx !== -1) {
     const current2 = existing[sameVersionIdx];
-    if (entriesEqual(current2, entry)) return registry2;
+    if (entriesEqual(current2, entry)) return registry;
     const next2 = existing.slice();
     next2[sameVersionIdx] = entry;
     return {
-      ...registry2,
+      ...registry,
       [entry.id]: next2
     };
   }
@@ -50253,28 +46851,28 @@ var upsertVersion = (registry2, entry) => {
     ...existing.slice(insertIdx)
   ];
   return {
-    ...registry2,
+    ...registry,
     [entry.id]: next
   };
 };
-var removeVersion = (registry2, id, version) => {
-  const existing = registry2[id];
-  if (!existing) return registry2;
+var removeVersion = (registry, id, version) => {
+  const existing = registry[id];
+  if (!existing) return registry;
   const idx = existing.findIndex((e) => e.version === version);
-  if (idx === -1) return registry2;
+  if (idx === -1) return registry;
   if (existing.length === 1) {
-    const { [id]: _removed, ...rest2 } = registry2;
+    const { [id]: _removed, ...rest2 } = registry;
     return rest2;
   }
   const next = existing.slice();
   next.splice(idx, 1);
   return {
-    ...registry2,
+    ...registry,
     [id]: next
   };
 };
 var createThreadContextStore = () => {
-  return createStore()(subscribeWithSelector((set3) => ({
+  return createStore2()(subscribeWithSelector((set3) => ({
     artifacts: {},
     registerArtifact: (entry) => {
       set3((s2) => ({ artifacts: upsertVersion(s2.artifacts, entry) }));
@@ -60131,8 +56729,8 @@ function buildMatchFn(args) {
     };
   };
 }
-function findKey(object2, predicate) {
-  for (const key in object2) if (Object.prototype.hasOwnProperty.call(object2, key) && predicate(object2[key])) return key;
+function findKey(object, predicate) {
+  for (const key in object) if (Object.prototype.hasOwnProperty.call(object, key) && predicate(object[key])) return key;
 }
 function findIndex(array, predicate) {
   for (let key = 0; key < array.length; key++) if (predicate(array[key])) return key;
@@ -64215,11 +60813,11 @@ var require__isKey = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var isSymbol2 = require_isSymbol();
   var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
   var reIsPlainProp = /^\w*$/;
-  function isKey2(value, object2) {
+  function isKey2(value, object) {
     if (isArray2(value)) return false;
     var type = typeof value;
     if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol2(value)) return true;
-    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object2 != null && value in Object(object2);
+    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
   }
   module.exports = isKey2;
 }));
@@ -64294,16 +60892,16 @@ var require__baseIsNative = /* @__PURE__ */ __commonJSMin(((exports, module) =>
   module.exports = baseIsNative;
 }));
 var require__getValue = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-  function getValue(object2, key) {
-    return object2 == null ? void 0 : object2[key];
+  function getValue(object, key) {
+    return object == null ? void 0 : object[key];
   }
   module.exports = getValue;
 }));
 var require__getNative = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var baseIsNative = require__baseIsNative();
   var getValue = require__getValue();
-  function getNative(object2, key) {
-    var value = getValue(object2, key);
+  function getNative(object, key) {
+    var value = getValue(object, key);
     return baseIsNative(value) ? value : void 0;
   }
   module.exports = getNative;
@@ -64632,9 +61230,9 @@ var require__castPath = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var isKey2 = require__isKey();
   var stringToPath = require__stringToPath();
   var toString2 = require_toString();
-  function castPath(value, object2) {
+  function castPath(value, object) {
     if (isArray2(value)) return value;
-    return isKey2(value, object2) ? [value] : stringToPath(toString2(value));
+    return isKey2(value, object) ? [value] : stringToPath(toString2(value));
   }
   module.exports = castPath;
 }));
@@ -64651,18 +61249,18 @@ var require__toKey = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require__baseGet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var castPath = require__castPath();
   var toKey2 = require__toKey();
-  function baseGet(object2, path2) {
-    path2 = castPath(path2, object2);
+  function baseGet(object, path2) {
+    path2 = castPath(path2, object);
     var index = 0, length = path2.length;
-    while (object2 != null && index < length) object2 = object2[toKey2(path2[index++])];
-    return index && index == length ? object2 : void 0;
+    while (object != null && index < length) object = object[toKey2(path2[index++])];
+    return index && index == length ? object : void 0;
   }
   module.exports = baseGet;
 }));
 var require_get = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var baseGet = require__baseGet();
-  function get2(object2, path2, defaultValue) {
-    var result = object2 == null ? void 0 : baseGet(object2, path2);
+  function get2(object, path2, defaultValue) {
+    var result = object == null ? void 0 : baseGet(object, path2);
     return result === void 0 ? defaultValue : result;
   }
   module.exports = get2;
@@ -66424,39 +63022,39 @@ var require__equalByTag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var dataViewTag2 = "[object DataView]";
   var symbolProto2 = Symbol2 ? Symbol2.prototype : void 0;
   var symbolValueOf = symbolProto2 ? symbolProto2.valueOf : void 0;
-  function equalByTag(object2, other, tag, bitmask, customizer, equalFunc, stack) {
+  function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
     switch (tag) {
       case dataViewTag2:
-        if (object2.byteLength != other.byteLength || object2.byteOffset != other.byteOffset) return false;
-        object2 = object2.buffer;
+        if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) return false;
+        object = object.buffer;
         other = other.buffer;
       case arrayBufferTag2:
-        if (object2.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object2), new Uint8Array2(other))) return false;
+        if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) return false;
         return true;
       case boolTag:
       case dateTag2:
       case numberTag2:
-        return eq2(+object2, +other);
+        return eq2(+object, +other);
       case errorTag:
-        return object2.name == other.name && object2.message == other.message;
+        return object.name == other.name && object.message == other.message;
       case regexpTag2:
       case stringTag2:
-        return object2 == other + "";
+        return object == other + "";
       case mapTag2:
         var convert = mapToArray;
       case setTag2:
         var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
         convert || (convert = setToArray);
-        if (object2.size != other.size && !isPartial) return false;
-        var stacked = stack.get(object2);
+        if (object.size != other.size && !isPartial) return false;
+        var stacked = stack.get(object);
         if (stacked) return stacked == other;
         bitmask |= COMPARE_UNORDERED_FLAG;
-        stack.set(object2, other);
-        var result = equalArrays(convert(object2), convert(other), bitmask, customizer, equalFunc, stack);
-        stack["delete"](object2);
+        stack.set(object, other);
+        var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+        stack["delete"](object);
         return result;
       case symbolTag2:
-        if (symbolValueOf) return symbolValueOf.call(object2) == symbolValueOf.call(other);
+        if (symbolValueOf) return symbolValueOf.call(object) == symbolValueOf.call(other);
     }
     return false;
   }
@@ -66473,9 +63071,9 @@ var require__arrayPush = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require__baseGetAllKeys = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var arrayPush = require__arrayPush();
   var isArray2 = require_isArray();
-  function baseGetAllKeys(object2, keysFunc, symbolsFunc) {
-    var result = keysFunc(object2);
-    return isArray2(object2) ? result : arrayPush(result, symbolsFunc(object2));
+  function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+    var result = keysFunc(object);
+    return isArray2(object) ? result : arrayPush(result, symbolsFunc(object));
   }
   module.exports = baseGetAllKeys;
 }));
@@ -66501,11 +63099,11 @@ var require__getSymbols = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var stubArray = require_stubArray();
   var propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
   var nativeGetSymbols = Object.getOwnPropertySymbols;
-  module.exports = !nativeGetSymbols ? stubArray : function(object2) {
-    if (object2 == null) return [];
-    object2 = Object(object2);
-    return arrayFilter(nativeGetSymbols(object2), function(symbol) {
-      return propertyIsEnumerable.call(object2, symbol);
+  module.exports = !nativeGetSymbols ? stubArray : function(object) {
+    if (object == null) return [];
+    object = Object(object);
+    return arrayFilter(nativeGetSymbols(object), function(symbol) {
+      return propertyIsEnumerable.call(object, symbol);
     });
   };
 }));
@@ -66672,10 +63270,10 @@ var require__baseKeys = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var isPrototype = require__isPrototype();
   var nativeKeys = require__nativeKeys();
   var hasOwnProperty2 = Object.prototype.hasOwnProperty;
-  function baseKeys(object2) {
-    if (!isPrototype(object2)) return nativeKeys(object2);
+  function baseKeys(object) {
+    if (!isPrototype(object)) return nativeKeys(object);
     var result = [];
-    for (var key in Object(object2)) if (hasOwnProperty2.call(object2, key) && key != "constructor") result.push(key);
+    for (var key in Object(object)) if (hasOwnProperty2.call(object, key) && key != "constructor") result.push(key);
     return result;
   }
   module.exports = baseKeys;
@@ -66692,8 +63290,8 @@ var require_keys = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var arrayLikeKeys = require__arrayLikeKeys();
   var baseKeys = require__baseKeys();
   var isArrayLike2 = require_isArrayLike();
-  function keys2(object2) {
-    return isArrayLike2(object2) ? arrayLikeKeys(object2) : baseKeys(object2);
+  function keys2(object) {
+    return isArrayLike2(object) ? arrayLikeKeys(object) : baseKeys(object);
   }
   module.exports = keys2;
 }));
@@ -66701,8 +63299,8 @@ var require__getAllKeys = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var baseGetAllKeys = require__baseGetAllKeys();
   var getSymbols2 = require__getSymbols();
   var keys2 = require_keys();
-  function getAllKeys(object2) {
-    return baseGetAllKeys(object2, keys2, getSymbols2);
+  function getAllKeys(object) {
+    return baseGetAllKeys(object, keys2, getSymbols2);
   }
   module.exports = getAllKeys;
 }));
@@ -66710,25 +63308,25 @@ var require__equalObjects = /* @__PURE__ */ __commonJSMin(((exports, module) =>
   var getAllKeys = require__getAllKeys();
   var COMPARE_PARTIAL_FLAG = 1;
   var hasOwnProperty2 = Object.prototype.hasOwnProperty;
-  function equalObjects(object2, other, bitmask, customizer, equalFunc, stack) {
-    var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object2), objLength = objProps.length;
+  function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length;
     if (objLength != getAllKeys(other).length && !isPartial) return false;
     var index = objLength;
     while (index--) {
       var key = objProps[index];
       if (!(isPartial ? key in other : hasOwnProperty2.call(other, key))) return false;
     }
-    var objStacked = stack.get(object2);
+    var objStacked = stack.get(object);
     var othStacked = stack.get(other);
-    if (objStacked && othStacked) return objStacked == other && othStacked == object2;
+    if (objStacked && othStacked) return objStacked == other && othStacked == object;
     var result = true;
-    stack.set(object2, other);
-    stack.set(other, object2);
+    stack.set(object, other);
+    stack.set(other, object);
     var skipCtor = isPartial;
     while (++index < objLength) {
       key = objProps[index];
-      var objValue = object2[key], othValue = other[key];
-      if (customizer) var compared = isPartial ? customizer(othValue, objValue, key, other, object2, stack) : customizer(objValue, othValue, key, object2, other, stack);
+      var objValue = object[key], othValue = other[key];
+      if (customizer) var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
       if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
         result = false;
         break;
@@ -66736,10 +63334,10 @@ var require__equalObjects = /* @__PURE__ */ __commonJSMin(((exports, module) =>
       skipCtor || (skipCtor = key == "constructor");
     }
     if (result && !skipCtor) {
-      var objCtor = object2.constructor, othCtor = other.constructor;
-      if (objCtor != othCtor && "constructor" in object2 && "constructor" in other && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) result = false;
+      var objCtor = object.constructor, othCtor = other.constructor;
+      if (objCtor != othCtor && "constructor" in object && "constructor" in other && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) result = false;
     }
-    stack["delete"](object2);
+    stack["delete"](object);
     stack["delete"](other);
     return result;
   }
@@ -66809,31 +63407,31 @@ var require__baseIsEqualDeep = /* @__PURE__ */ __commonJSMin(((exports, module)
   var arrayTag2 = "[object Array]";
   var objectTag2 = "[object Object]";
   var hasOwnProperty2 = Object.prototype.hasOwnProperty;
-  function baseIsEqualDeep(object2, other, bitmask, customizer, equalFunc, stack) {
-    var objIsArr = isArray2(object2), othIsArr = isArray2(other), objTag = objIsArr ? arrayTag2 : getTag2(object2), othTag = othIsArr ? arrayTag2 : getTag2(other);
+  function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+    var objIsArr = isArray2(object), othIsArr = isArray2(other), objTag = objIsArr ? arrayTag2 : getTag2(object), othTag = othIsArr ? arrayTag2 : getTag2(other);
     objTag = objTag == argsTag ? objectTag2 : objTag;
     othTag = othTag == argsTag ? objectTag2 : othTag;
     var objIsObj = objTag == objectTag2, othIsObj = othTag == objectTag2, isSameTag = objTag == othTag;
-    if (isSameTag && isBuffer2(object2)) {
+    if (isSameTag && isBuffer2(object)) {
       if (!isBuffer2(other)) return false;
       objIsArr = true;
       objIsObj = false;
     }
     if (isSameTag && !objIsObj) {
       stack || (stack = new Stack2());
-      return objIsArr || isTypedArray2(object2) ? equalArrays(object2, other, bitmask, customizer, equalFunc, stack) : equalByTag(object2, other, objTag, bitmask, customizer, equalFunc, stack);
+      return objIsArr || isTypedArray2(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
     }
     if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
-      var objIsWrapped = objIsObj && hasOwnProperty2.call(object2, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty2.call(other, "__wrapped__");
+      var objIsWrapped = objIsObj && hasOwnProperty2.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty2.call(other, "__wrapped__");
       if (objIsWrapped || othIsWrapped) {
-        var objUnwrapped = objIsWrapped ? object2.value() : object2, othUnwrapped = othIsWrapped ? other.value() : other;
+        var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
         stack || (stack = new Stack2());
         return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
       }
     }
     if (!isSameTag) return false;
     stack || (stack = new Stack2());
-    return equalObjects(object2, other, bitmask, customizer, equalFunc, stack);
+    return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
   }
   module.exports = baseIsEqualDeep;
 }));
@@ -66852,22 +63450,22 @@ var require__baseIsMatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var baseIsEqual = require__baseIsEqual();
   var COMPARE_PARTIAL_FLAG = 1;
   var COMPARE_UNORDERED_FLAG = 2;
-  function baseIsMatch(object2, source, matchData, customizer) {
+  function baseIsMatch(object, source, matchData, customizer) {
     var index = matchData.length, length = index, noCustomizer = !customizer;
-    if (object2 == null) return !length;
-    object2 = Object(object2);
+    if (object == null) return !length;
+    object = Object(object);
     while (index--) {
       var data = matchData[index];
-      if (noCustomizer && data[2] ? data[1] !== object2[data[0]] : !(data[0] in object2)) return false;
+      if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) return false;
     }
     while (++index < length) {
       data = matchData[index];
-      var key = data[0], objValue = object2[key], srcValue = data[1];
+      var key = data[0], objValue = object[key], srcValue = data[1];
       if (noCustomizer && data[2]) {
-        if (objValue === void 0 && !(key in object2)) return false;
+        if (objValue === void 0 && !(key in object)) return false;
       } else {
         var stack = new Stack2();
-        if (customizer) var result = customizer(objValue, srcValue, key, object2, source, stack);
+        if (customizer) var result = customizer(objValue, srcValue, key, object, source, stack);
         if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result)) return false;
       }
     }
@@ -66885,10 +63483,10 @@ var require__isStrictComparable = /* @__PURE__ */ __commonJSMin(((exports, modul
 var require__getMatchData = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var isStrictComparable = require__isStrictComparable();
   var keys2 = require_keys();
-  function getMatchData(object2) {
-    var result = keys2(object2), length = result.length;
+  function getMatchData(object) {
+    var result = keys2(object), length = result.length;
     while (length--) {
-      var key = result[length], value = object2[key];
+      var key = result[length], value = object[key];
       result[length] = [
         key,
         value,
@@ -66901,9 +63499,9 @@ var require__getMatchData = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 }));
 var require__matchesStrictComparable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   function matchesStrictComparable(key, srcValue) {
-    return function(object2) {
-      if (object2 == null) return false;
-      return object2[key] === srcValue && (srcValue !== void 0 || key in Object(object2));
+    return function(object) {
+      if (object == null) return false;
+      return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
     };
   }
   module.exports = matchesStrictComparable;
@@ -66915,15 +63513,15 @@ var require__baseMatches = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   function baseMatches(source) {
     var matchData = getMatchData(source);
     if (matchData.length == 1 && matchData[0][2]) return matchesStrictComparable(matchData[0][0], matchData[0][1]);
-    return function(object2) {
-      return object2 === source || baseIsMatch(object2, source, matchData);
+    return function(object) {
+      return object === source || baseIsMatch(object, source, matchData);
     };
   }
   module.exports = baseMatches;
 }));
 var require__baseHasIn = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-  function baseHasIn(object2, key) {
-    return object2 != null && key in Object(object2);
+  function baseHasIn(object, key) {
+    return object != null && key in Object(object);
   }
   module.exports = baseHasIn;
 }));
@@ -66934,25 +63532,25 @@ var require__hasPath = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var isIndex2 = require__isIndex();
   var isLength2 = require_isLength();
   var toKey2 = require__toKey();
-  function hasPath(object2, path2, hasFunc) {
-    path2 = castPath(path2, object2);
+  function hasPath(object, path2, hasFunc) {
+    path2 = castPath(path2, object);
     var index = -1, length = path2.length, result = false;
     while (++index < length) {
       var key = toKey2(path2[index]);
-      if (!(result = object2 != null && hasFunc(object2, key))) break;
-      object2 = object2[key];
+      if (!(result = object != null && hasFunc(object, key))) break;
+      object = object[key];
     }
     if (result || ++index != length) return result;
-    length = object2 == null ? 0 : object2.length;
-    return !!length && isLength2(length) && isIndex2(key, length) && (isArray2(object2) || isArguments2(object2));
+    length = object == null ? 0 : object.length;
+    return !!length && isLength2(length) && isIndex2(key, length) && (isArray2(object) || isArguments2(object));
   }
   module.exports = hasPath;
 }));
 var require_hasIn = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var baseHasIn = require__baseHasIn();
   var hasPath = require__hasPath();
-  function hasIn(object2, path2) {
-    return object2 != null && hasPath(object2, path2, baseHasIn);
+  function hasIn(object, path2) {
+    return object != null && hasPath(object, path2, baseHasIn);
   }
   module.exports = hasIn;
 }));
@@ -66968,9 +63566,9 @@ var require__baseMatchesProperty = /* @__PURE__ */ __commonJSMin(((exports, modu
   var COMPARE_UNORDERED_FLAG = 2;
   function baseMatchesProperty(path2, srcValue) {
     if (isKey2(path2) && isStrictComparable(srcValue)) return matchesStrictComparable(toKey2(path2), srcValue);
-    return function(object2) {
-      var objValue = get2(object2, path2);
-      return objValue === void 0 && objValue === srcValue ? hasIn(object2, path2) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+    return function(object) {
+      var objValue = get2(object, path2);
+      return objValue === void 0 && objValue === srcValue ? hasIn(object, path2) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
     };
   }
   module.exports = baseMatchesProperty;
@@ -66983,8 +63581,8 @@ var require_identity = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 var require__baseProperty = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   function baseProperty(key) {
-    return function(object2) {
-      return object2 == null ? void 0 : object2[key];
+    return function(object) {
+      return object == null ? void 0 : object[key];
     };
   }
   module.exports = baseProperty;
@@ -66992,8 +63590,8 @@ var require__baseProperty = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 var require__basePropertyDeep = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var baseGet = require__baseGet();
   function basePropertyDeep(path2) {
-    return function(object2) {
-      return baseGet(object2, path2);
+    return function(object) {
+      return baseGet(object, path2);
     };
   }
   module.exports = basePropertyDeep;
@@ -67436,13 +64034,13 @@ var require__baseFlatten = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 var require__createBaseFor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   function createBaseFor(fromRight) {
-    return function(object2, iteratee2, keysFunc) {
-      var index = -1, iterable = Object(object2), props = keysFunc(object2), length = props.length;
+    return function(object, iteratee2, keysFunc) {
+      var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
       while (length--) {
         var key = props[fromRight ? length : ++index];
         if (iteratee2(iterable[key], key, iterable) === false) break;
       }
-      return object2;
+      return object;
     };
   }
   module.exports = createBaseFor;
@@ -67453,8 +64051,8 @@ var require__baseFor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require__baseForOwn = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var baseFor = require__baseFor();
   var keys2 = require_keys();
-  function baseForOwn(object2, iteratee2) {
-    return object2 && baseFor(object2, iteratee2, keys2);
+  function baseForOwn(object, iteratee2) {
+    return object && baseFor(object, iteratee2, keys2);
   }
   module.exports = baseForOwn;
 }));
@@ -67511,8 +64109,8 @@ var require__compareAscending = /* @__PURE__ */ __commonJSMin(((exports, module)
 }));
 var require__compareMultiple = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var compareAscending = require__compareAscending();
-  function compareMultiple(object2, other, orders) {
-    var index = -1, objCriteria = object2.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
+  function compareMultiple(object, other, orders) {
+    var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
     while (++index < length) {
       var result = compareAscending(objCriteria[index], othCriteria[index]);
       if (result) {
@@ -67520,7 +64118,7 @@ var require__compareMultiple = /* @__PURE__ */ __commonJSMin(((exports, module)
         return result * (orders[index] == "desc" ? -1 : 1);
       }
     }
-    return object2.index - other.index;
+    return object.index - other.index;
   }
   module.exports = compareMultiple;
 }));
@@ -67552,8 +64150,8 @@ var require__baseOrderBy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
         "index": ++index,
         "value": value
       };
-    }), function(object2, other) {
-      return compareMultiple(object2, other, orders);
+    }), function(object, other) {
+      return compareMultiple(object, other, orders);
     });
   }
   module.exports = baseOrderBy;
@@ -67658,10 +64256,10 @@ var require__isIterateeCall = /* @__PURE__ */ __commonJSMin(((exports, module) =
   var isArrayLike2 = require_isArrayLike();
   var isIndex2 = require__isIndex();
   var isObject2 = require_isObject();
-  function isIterateeCall2(value, index, object2) {
-    if (!isObject2(object2)) return false;
+  function isIterateeCall2(value, index, object) {
+    if (!isObject2(object)) return false;
     var type = typeof index;
-    if (type == "number" ? isArrayLike2(object2) && isIndex2(index, object2.length) : type == "string" && index in object2) return eq2(object2[index], value);
+    if (type == "number" ? isArrayLike2(object) && isIndex2(index, object.length) : type == "string" && index in object) return eq2(object[index], value);
     return false;
   }
   module.exports = isIterateeCall2;
@@ -72016,10 +68614,10 @@ function createIsCircular(areItemsEqual) {
 function getShortTag(value) {
   return value != null ? value[Symbol.toStringTag] : void 0;
 }
-function getStrictProperties(object2) {
-  return getOwnPropertyNames(object2).concat(getOwnPropertySymbols(object2));
+function getStrictProperties(object) {
+  return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
 }
-var hasOwn = Object.hasOwn || ((object2, property2) => hasOwnProperty.call(object2, property2));
+var hasOwn = Object.hasOwn || ((object, property2) => hasOwnProperty.call(object, property2));
 function sameValueZeroEqual(a2, b) {
   return a2 === b || !a2 && !b && a2 !== a2 && b !== b;
 }
@@ -77046,14 +73644,14 @@ var ifOverflowMatches = function ifOverflowMatches2(props, value) {
 };
 var require__baseAssignValue = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var defineProperty = require__defineProperty();
-  function baseAssignValue(object2, key, value) {
-    if (key == "__proto__" && defineProperty) defineProperty(object2, key, {
+  function baseAssignValue(object, key, value) {
+    if (key == "__proto__" && defineProperty) defineProperty(object, key, {
       "configurable": true,
       "enumerable": true,
       "value": value,
       "writable": true
     });
-    else object2[key] = value;
+    else object[key] = value;
   }
   module.exports = baseAssignValue;
 }));
@@ -77061,11 +73659,11 @@ var require_mapValues = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   var baseAssignValue = require__baseAssignValue();
   var baseForOwn = require__baseForOwn();
   var baseIteratee = require__baseIteratee();
-  function mapValues(object2, iteratee2) {
+  function mapValues(object, iteratee2) {
     var result = {};
     iteratee2 = baseIteratee(iteratee2, 3);
-    baseForOwn(object2, function(value, key, object3) {
-      baseAssignValue(result, key, iteratee2(value, key, object3));
+    baseForOwn(object, function(value, key, object2) {
+      baseAssignValue(result, key, iteratee2(value, key, object2));
     });
     return result;
   }
@@ -85266,8 +81864,8 @@ function getLastAssistantMessageId(messages2) {
   }
   return null;
 }
-function getMatchedRendererActivities(registry2, activities) {
-  return activities.filter((a2) => !!(registry2 && lookupArtifactRenderer(registry2, a2.toolName)));
+function getMatchedRendererActivities(registry, activities) {
+  return activities.filter((a2) => !!(registry && lookupArtifactRenderer(registry, a2.toolName)));
 }
 var OPENUI_INLINE_SENTINEL = "]]>openui:";
 var CONTENT_MARKER = `${OPENUI_INLINE_SENTINEL}content`;
@@ -86653,12 +83251,12 @@ var formatArtifactUpdatedAt = (updatedAt) => {
   return new Intl.DateTimeFormat(void 0, { dateStyle: "medium" }).format(date2);
 };
 var useArtifactIcon = (type) => {
-  const registry2 = useArtifactRendererRegistry();
-  return (registry2 ? lookupArtifactRendererByType(registry2, type)?.icon : void 0) ?? /* @__PURE__ */ jsx(Boxes, { size: "1em" });
+  const registry = useArtifactRendererRegistry();
+  return (registry ? lookupArtifactRendererByType(registry, type)?.icon : void 0) ?? /* @__PURE__ */ jsx(Boxes, { size: "1em" });
 };
 var useArtifactTypeLabel = (type) => {
-  const registry2 = useArtifactRendererRegistry();
-  return (registry2 ? lookupArtifactRendererByType(registry2, type)?.label : void 0) ?? prettifyType(type);
+  const registry = useArtifactRendererRegistry();
+  return (registry ? lookupArtifactRendererByType(registry, type)?.label : void 0) ?? prettifyType(type);
 };
 var ArtifactBrowserCard = ({ artifact, updatedAt, onClick }) => {
   const icon2 = useArtifactIcon(artifact.type);
@@ -87123,7 +83721,7 @@ var ArtifactNav = ({ className, icon: icon2 }) => {
 };
 var ArtifactViewPage = ({ artifactId, categoryName }) => {
   const storage = useArtifactStorage();
-  const registry2 = useArtifactRendererRegistry();
+  const registry = useArtifactRendererRegistry();
   const { navigate } = useNav();
   const selectThread = useThreadList((s2) => s2.selectThread);
   const [artifact, setArtifact] = useState2(null);
@@ -87149,9 +83747,9 @@ var ArtifactViewPage = ({ artifactId, categoryName }) => {
     navigate(void 0);
   };
   const renderer = useMemo2(() => {
-    if (!artifact || !registry2) return null;
-    return lookupArtifactRendererByType(registry2, artifact.type);
-  }, [artifact, registry2]);
+    if (!artifact || !registry) return null;
+    return lookupArtifactRendererByType(registry, artifact.type);
+  }, [artifact, registry]);
   const parsed = useMemo2(() => {
     if (!artifact || !renderer) return null;
     return renderer.parser({
@@ -90224,8 +86822,8 @@ var WorkspaceItem = ({ entry }) => {
     })]
   }) });
 };
-function latestPerId(registry2) {
-  return Object.values(registry2).map((versions) => versions[versions.length - 1]).filter((entry) => entry !== void 0);
+function latestPerId(registry) {
+  return Object.values(registry).map((versions) => versions[versions.length - 1]).filter((entry) => entry !== void 0);
 }
 function entryMatchesCategory(entry, category) {
   return category.filter.type.includes(entry.type);