@adecore/intelligent-ui 0.0.0-stage → 0.21.0

package/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 - present Bas Milius
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,72 @@
-# Temporary Holding Version
+# @adecore/intelligent-ui
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A streaming compiler and bounded expression interpreter for UI blocks in agent replies. The catalog defines props once with Zod. Renderers consume evaluated props and input bindings; they do not evaluate model text.
+
+Chat wire integration and scheduling are provided by `@adecore/agents`; React renderers are provided by `@adecore/agents-react`. Hosts supply actions, query authorization and platform renderers. The compiler and interpreter do not authorize a query or an action.
+
+```ts
+import { compileUi, evaluateUiBlock, UiState } from '@adecore/intelligent-ui';
+
+const blocks = compileUi(reply, { id: assistantItemId, final: true });
+for (const block of blocks) {
+    const state = new UiState(block);
+    const view = evaluateUiBlock(block, state);
+    render(view.nodes);
+}
+```
+
+## Compilation
+
+`compileUi(text, options)` finds blocks marked with `UI_FENCE_LANGUAGE` among Markdown, including unfinished fences. It ignores UI fences nested inside another code fence. Each `UiBlock` has its own ID, text range, catalog version, declarations, nodes, diagnostics and Markdown fallback. `compileUiBlock(source, options)` compiles one fence's contents.
+
+`UiCompileOptions.id` identifies the assistant item or block. Supply the same ID on each recompile. Node IDs include the start of their tag, so appending text preserves them. `final` reports unfinished syntax when the authoritative response arrives. `latestAttachment` resolves `Image generated="latest"` to an attachment. `limits` overrides the work budget; `now` supplies a clock for deterministic tests.
+
+The parser recovers at the next tag or line after malformed input. Open tags remain incomplete. A streamed quoted prop exposes the text already received. CodeBlock contents are literal, including angle brackets and braces. Unknown components retain their own fallback; unknown props produce `refused_prop` and are dropped. A budget failure replaces the whole compiled block with a bounded fallback and one diagnosis.
+
+`UiNode` keeps static `props` separate from `expressions` and local-variable `bindings`. Its `type` is a string so an unfamiliar component can fall back without rejecting neighboring content. `UiNodeSchema`, `UiBlockSchema`, `UiBlocksSchema` and `UiDiagnosticSchema` describe the wire envelope. Component names, props and expressions stay open, so a future catalog can be retained and shown as fallback. The optional assistant field and daemon integration still await the package's first publication setup.
+
+`parseUiSyntax` exposes the intermediate `UiSyntax` and `UiSyntaxNode` for compiler tooling. `UiDiagnostic` carries a code, message, source range and optional node ID. `uiDiagnostic` turns a caught failure into that shape.
+
+## Catalog
+
+`UI_CATALOG` contains each component's schema, description, group and applicable parent, child or binding rule. `UI_GROUPS` contains the instructions shared by each group. `isUiComponent` recognizes a catalog name; `uiCatalogText` lists names, props and descriptions for tooling. `uiCompactCatalog` derives the short prop list from those schemas, `uiSessionNote` adds explicit tag syntax and a fenced example checked by the compiler, and `uiReferenceText` combines full descriptions with group rules. `uiFallbackText` replaces UI fences with their compiled fallback while retaining surrounding prose.
+
+`UiComponentName` is the key union. `UiProps<Name>` is inferred from that component's schema. `UiToneSchema` and `UiTone` provide neutral, info, success, warning and danger. `UI_CATALOG_VERSION` identifies this catalog.
+
+| Group | Components |
+| --- | --- |
+| Status | Summary, Callout, Tag, Progress, Steps / Step |
+| Data | Stats / Stat, EntityList / Entry, Table / Column, Chart |
+| Structure | Tabs / Tab, Sections / Section |
+| Content | CodeBlock, Image, Sources / Source |
+| Host links | File, Diff, Commit, Node |
+| Local inputs | Checklist / Item, Switch, Slider, Segmented / Option, Show, Each |
+| Choices | Choices / Choice |
+
+Image accepts exactly one of `attachment` and `generated="latest"`, plus an optional alt and caption. It never takes a URL or a filesystem path. Charts use rows with a label and numeric series; their renderer will validate usable series before drawing. A Column names a field and optionally its title, unit and presentation.
+
+## Expressions and state
+
+`parseUiExpression(source, budget?)` returns a `UiExpression` AST. `evaluateUiExpression(ast, variables?, budget?)` returns a finite JSON `UiValue`. It supports scalar, array and object literals, variables, own field/index reads, arithmetic, strict comparisons, boolean operators and these helpers:
+
+| Helper | Arguments |
+| --- | --- |
+| `@Count` | list or string |
+| `@Filter` | list, local name, boolean predicate, e.g. `@Filter($rows, row, row.failed)` |
+| `@Sum` | numeric list, or record list and a field name |
+| `@Join` | scalar list and optional separator |
+| `@Round` | number and optional precision from zero to six |
+
+There is no JavaScript execution, general function call, assignment, network access or inherited field access. `__proto__`, `constructor` and `prototype` are refused. `copyUiValue` validates and copies JSON input without invoking accessors; class instances, nonfinite numbers, sparse arrays and cycles are refused.
+
+`UiState` belongs to one chat/item/block identity. `sync(block)` preserves edits when a declaration's default is unchanged, resets changed defaults, removes disappeared variables and clears changed query data. A reload creates a new state from defaults. `scope()` returns a safe copy. `set(name, value)` changes a declared local variable without changing its type. `run(ast)` accepts only `@Set($name, expression)`, `@Reset($name)` and `@Reset()`. `snapshot()` and `subscribe(listener)` let a renderer observe input edits.
+
+`evaluateUiBlock(block, state?, limits?)` returns `UiEvaluation`, including `UiViewNode` objects and per-element diagnostics. View nodes contain validated evaluated props, children and `UiBinding` callbacks. A binding changes state only after its input node is complete and the new prop passes its schema. Show and Each are resolved before rendering. Repetition reserves iterations before allocating children. Unknown catalog versions and invalid elements retain their fallback.
+
+`$name = @Query("source", {literalArgs})` requires a matching schema in `UiCompileOptions.querySchemas`. It yields a read-only `UiQuery`; ordinary value evaluation never performs a query. The authorized host may supply data with `state.setQuery(name, value, block)`. Results for replaced query definitions are refused. Transport, quotas, rights, fixed versus variable arguments and visible-only refresh still belong to the upcoming host integration.
+
+## Budgets and acceptance
+
+`UI_LIMITS` bounds characters, nesting, nodes, diagnoses, steps, iterations, string length and elapsed time. `UiLimits` describes overrides. `UiBudget` counts work inside helpers as well as ordinary evaluation. `UiFailure` carries a machine-readable refusal code; `safeKey` applies the forbidden-field rule.
+
+The tests compile ten hand-written examples and every character prefix, then exercise malformed syntax, prototype/accessor attacks, helper budgets, output expansion, query replacement and state reset. Recorded Claude/Codex responses, daemon event-loop/log measurements and iPhone JavaScriptCore parity remain acceptance work. The package does not yet render replies in an application.

package/dist/budget.d.ts

@@ -0,0 +1,30 @@
+export interface UiLimits {
+    characters: number;
+    depth: number;
+    nodes: number;
+    diagnostics: number;
+    steps: number;
+    iterations: number;
+    stringLength: number;
+    milliseconds: number;
+}
+export declare const UI_LIMITS: Readonly<UiLimits>;
+export declare class UiFailure extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class UiBudget {
+    readonly limits: Readonly<UiLimits>;
+    private steps;
+    private iterations;
+    private nodes;
+    private readonly started;
+    private readonly now;
+    constructor(limits?: Partial<UiLimits>, now?: () => number);
+    step(count?: number): void;
+    iteration(count?: number): void;
+    node(): void;
+    depth(depth: number): void;
+    string(value: string): string;
+}
+export declare function safeKey(key: string): string;

package/dist/budget.js

@@ -0,0 +1,75 @@
+export const UI_LIMITS = {
+    characters: 65536,
+    depth: 32,
+    nodes: 512,
+    diagnostics: 20,
+    steps: 20000,
+    iterations: 2000,
+    stringLength: 16384,
+    milliseconds: 30
+};
+export class UiFailure extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'UiFailure';
+    }
+}
+export class UiBudget {
+    limits;
+    steps = 0;
+    iterations = 0;
+    nodes = 0;
+    started;
+    now;
+    constructor(limits = {}, now = Date.now) {
+        this.now = now;
+        this.limits = { ...UI_LIMITS, ...limits };
+        for (const value of Object.values(this.limits)) {
+            if (!Number.isSafeInteger(value) || value <= 0) {
+                throw new UiFailure('invalid_limits', 'Budgets must be positive safe integers.');
+            }
+        }
+        this.started = now();
+    }
+    step(count = 1) {
+        this.steps += count;
+        if (this.steps > this.limits.steps || this.now() - this.started > this.limits.milliseconds) {
+            throw new UiFailure('budget_exceeded', 'The operation exceeded its work budget.');
+        }
+    }
+    iteration(count = 1) {
+        this.iterations += count;
+        this.step(count);
+        if (this.iterations > this.limits.iterations) {
+            throw new UiFailure('budget_exceeded', 'The operation exceeded its iteration budget.');
+        }
+    }
+    node() {
+        this.nodes += 1;
+        this.step();
+        if (this.nodes > this.limits.nodes) {
+            throw new UiFailure('budget_exceeded', 'The operation exceeded its node budget.');
+        }
+    }
+    depth(depth) {
+        this.step();
+        if (depth > this.limits.depth) {
+            throw new UiFailure('budget_exceeded', 'The operation exceeded its nesting budget.');
+        }
+    }
+    string(value) {
+        this.step(value.length);
+        if (value.length > this.limits.stringLength) {
+            throw new UiFailure('budget_exceeded', 'The operation exceeded its string budget.');
+        }
+        return value;
+    }
+}
+export function safeKey(key) {
+    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+        throw new UiFailure('refused_access', `Access to ${key} is refused.`);
+    }
+    return key;
+}

package/dist/catalog.d.ts

@@ -0,0 +1,368 @@
+import { z } from 'zod';
+export declare const UI_CATALOG_VERSION = 1;
+export declare const UiToneSchema: z.ZodEnum<{
+    danger: "danger";
+    info: "info";
+    neutral: "neutral";
+    success: "success";
+    warning: "warning";
+}>;
+export type UiTone = z.infer<typeof UiToneSchema>;
+export declare const UI_GROUPS: {
+    readonly status: {
+        readonly description: 'Summarize a result or show progress.';
+        readonly rules: 'Use one leading Summary. Children are inline prose, not headings or tables.';
+    };
+    readonly data: {
+        readonly description: 'Compare values and records.';
+        readonly rules: 'Give numbers as numbers. Tone expresses meaning, never infer it from an increase.';
+    };
+    readonly structure: {
+        readonly description: 'Organize distinct topics.';
+        readonly rules: 'Use Tabs for alternatives and Sections for independent topics.';
+    };
+    readonly content: {
+        readonly description: 'Include code, attachments and sources.';
+        readonly rules: 'Image accepts a chat attachment or generated="latest", never a URL or a local path.';
+    };
+    readonly links: {
+        readonly description: 'Refer to a host-owned resource.';
+        readonly rules: 'Targets are checked by the host. No arbitrary navigation or file reads.';
+    };
+    readonly inputs: {
+        readonly description: 'Change local block state.';
+        readonly rules: 'Bind value={$name}. State stays local until a Choice sends visible context.';
+    };
+    readonly choices: {
+        readonly description: 'Ask the person to pick a next step.';
+        readonly rules: 'Give a short label and precise visible context. A Choice sends once after streaming ends.';
+    };
+};
+export declare const UI_CATALOG: {
+    readonly Summary: {
+        readonly group: 'status';
+        readonly description: 'The result in one sentence.';
+        readonly schema: z.ZodObject<{
+            tone: z.ZodOptional<z.ZodEnum<{
+                danger: "danger";
+                info: "info";
+                neutral: "neutral";
+                success: "success";
+                warning: "warning";
+            }>>;
+            badge: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    };
+    readonly Callout: {
+        readonly group: 'status';
+        readonly description: 'A note that needs attention.';
+        readonly schema: z.ZodObject<{
+            tone: z.ZodEnum<{
+                danger: "danger";
+                info: "info";
+                neutral: "neutral";
+                success: "success";
+                warning: "warning";
+            }>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    };
+    readonly Tag: {
+        readonly group: 'status';
+        readonly description: 'A short status label.';
+        readonly schema: z.ZodObject<{
+            tone: z.ZodOptional<z.ZodEnum<{
+                danger: "danger";
+                info: "info";
+                neutral: "neutral";
+                success: "success";
+                warning: "warning";
+            }>>;
+        }, z.core.$strict>;
+    };
+    readonly Progress: {
+        readonly group: 'status';
+        readonly description: 'Progress with a label; omit value for indeterminate progress.';
+        readonly schema: z.ZodObject<{
+            value: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+    };
+    readonly Steps: {
+        readonly group: 'status';
+        readonly description: 'An ordered sequence of steps.';
+        readonly schema: z.ZodObject<{}, z.core.$strict>;
+        readonly children: readonly ['Step'];
+    };
+    readonly Step: {
+        readonly group: 'status';
+        readonly description: 'One step in a sequence.';
+        readonly schema: z.ZodObject<{
+            state: z.ZodEnum<{
+                done: "done";
+                failed: "failed";
+                pending: "pending";
+                running: "running";
+                skipped: "skipped";
+            }>;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly parent: 'Steps';
+    };
+    readonly Stats: {
+        readonly group: 'data';
+        readonly description: 'A small set of key numbers.';
+        readonly schema: z.ZodObject<{}, z.core.$strict>;
+        readonly children: readonly ['Stat'];
+    };
+    readonly Stat: {
+        readonly group: 'data';
+        readonly description: 'A labeled value and optional previous value.';
+        readonly schema: z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodNumber;
+            previous: z.ZodOptional<z.ZodNumber>;
+            unit: z.ZodOptional<z.ZodString>;
+            tone: z.ZodOptional<z.ZodEnum<{
+                danger: "danger";
+                info: "info";
+                neutral: "neutral";
+                success: "success";
+                warning: "warning";
+            }>>;
+        }, z.core.$strict>;
+        readonly parent: 'Stats';
+    };
+    readonly EntityList: {
+        readonly group: 'data';
+        readonly description: 'Labeled facts about an entity.';
+        readonly schema: z.ZodObject<{}, z.core.$strict>;
+        readonly children: readonly ['Entry'];
+    };
+    readonly Entry: {
+        readonly group: 'data';
+        readonly description: 'One labeled fact.';
+        readonly schema: z.ZodObject<{
+            label: z.ZodString;
+        }, z.core.$strict>;
+        readonly parent: 'EntityList';
+    };
+    readonly Table: {
+        readonly group: 'data';
+        readonly description: 'Rows with named columns.';
+        readonly schema: z.ZodObject<{
+            rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>;
+        readonly children: readonly ['Column'];
+    };
+    readonly Column: {
+        readonly group: 'data';
+        readonly description: 'A field of each table row.';
+        readonly schema: z.ZodObject<{
+            key: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            unit: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodEnum<{
+                bytes: "bytes";
+                date: "date";
+                duration: "duration";
+                file: "file";
+                number: "number";
+                tag: "tag";
+                text: "text";
+            }>>;
+        }, z.core.$strict>;
+        readonly parent: 'Table';
+    };
+    readonly Chart: {
+        readonly group: 'data';
+        readonly description: 'Compare labeled numeric series. Data rows have label and up to six numeric series.';
+        readonly schema: z.ZodObject<{
+            kind: z.ZodEnum<{
+                bar: "bar";
+                hbar: "hbar";
+                line: "line";
+                stacked: "stacked";
+            }>;
+            data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+            unit: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    };
+    readonly Tabs: {
+        readonly group: 'structure';
+        readonly description: 'Switch between alternative topics.';
+        readonly schema: z.ZodObject<{}, z.core.$strict>;
+        readonly children: readonly ['Tab'];
+    };
+    readonly Tab: {
+        readonly group: 'structure';
+        readonly description: 'A named tab.';
+        readonly schema: z.ZodObject<{
+            title: z.ZodString;
+        }, z.core.$strict>;
+        readonly parent: 'Tabs';
+    };
+    readonly Sections: {
+        readonly group: 'structure';
+        readonly description: 'Independent collapsible topics.';
+        readonly schema: z.ZodObject<{}, z.core.$strict>;
+        readonly children: readonly ['Section'];
+    };
+    readonly Section: {
+        readonly group: 'structure';
+        readonly description: 'A named section.';
+        readonly schema: z.ZodObject<{
+            title: z.ZodString;
+        }, z.core.$strict>;
+        readonly parent: 'Sections';
+    };
+    readonly CodeBlock: {
+        readonly group: 'content';
+        readonly description: 'Code as text, without execution.';
+        readonly schema: z.ZodObject<{
+            language: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    };
+    readonly Image: {
+        readonly group: 'content';
+        readonly description: 'A chat attachment with an optional caption.';
+        readonly schema: z.ZodObject<{
+            attachment: z.ZodOptional<z.ZodString>;
+            generated: z.ZodOptional<z.ZodLiteral<"latest">>;
+            alt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    };
+    readonly Sources: {
+        readonly group: 'content';
+        readonly description: 'Numbered sources without preloading.';
+        readonly schema: z.ZodObject<{}, z.core.$strict>;
+        readonly children: readonly ['Source'];
+    };
+    readonly Source: {
+        readonly group: 'content';
+        readonly description: 'An HTTP or HTTPS source.';
+        readonly schema: z.ZodObject<{
+            title: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strict>;
+        readonly parent: 'Sources';
+    };
+    readonly File: {
+        readonly group: 'links';
+        readonly description: 'A file in the project or a worktree.';
+        readonly schema: z.ZodObject<{
+            path: z.ZodString;
+            line: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        }, z.core.$strict>;
+    };
+    readonly Diff: {
+        readonly group: 'links';
+        readonly description: 'A changed project file.';
+        readonly schema: z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strict>;
+    };
+    readonly Commit: {
+        readonly group: 'links';
+        readonly description: 'A repository commit.';
+        readonly schema: z.ZodObject<{
+            sha: z.ZodString;
+        }, z.core.$strict>;
+    };
+    readonly Node: {
+        readonly group: 'links';
+        readonly description: 'A host node.';
+        readonly schema: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>;
+    };
+    readonly Checklist: {
+        readonly group: 'inputs';
+        readonly description: 'Select values in a local list.';
+        readonly schema: z.ZodObject<{
+            value: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        }, z.core.$strict>;
+        readonly children: readonly ['Item'];
+        readonly binding: 'value';
+    };
+    readonly Item: {
+        readonly group: 'inputs';
+        readonly description: 'One selectable value.';
+        readonly schema: z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+        }, z.core.$strict>;
+        readonly parent: 'Checklist';
+    };
+    readonly Switch: {
+        readonly group: 'inputs';
+        readonly description: 'A local boolean.';
+        readonly schema: z.ZodObject<{
+            value: z.ZodBoolean;
+        }, z.core.$strict>;
+        readonly binding: 'value';
+    };
+    readonly Slider: {
+        readonly group: 'inputs';
+        readonly description: 'A local number in a range.';
+        readonly schema: z.ZodObject<{
+            value: z.ZodNumber;
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+            step: z.ZodOptional<z.ZodNumber>;
+            unit: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly binding: 'value';
+    };
+    readonly Segmented: {
+        readonly group: 'inputs';
+        readonly description: 'Choose one local value.';
+        readonly schema: z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+        }, z.core.$strict>;
+        readonly children: readonly ['Option'];
+        readonly binding: 'value';
+    };
+    readonly Option: {
+        readonly group: 'inputs';
+        readonly description: 'One local alternative.';
+        readonly schema: z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+        }, z.core.$strict>;
+        readonly parent: 'Segmented';
+    };
+    readonly Show: {
+        readonly group: 'inputs';
+        readonly description: 'Show children when the condition is true.';
+        readonly schema: z.ZodObject<{
+            when: z.ZodBoolean;
+        }, z.core.$strict>;
+    };
+    readonly Each: {
+        readonly group: 'inputs';
+        readonly description: 'Repeat children over local data.';
+        readonly schema: z.ZodObject<{
+            items: z.ZodArray<z.ZodUnknown>;
+            as: z.ZodString;
+        }, z.core.$strict>;
+    };
+    readonly Choices: {
+        readonly group: 'choices';
+        readonly description: 'Visible next steps.';
+        readonly schema: z.ZodObject<{}, z.core.$strict>;
+        readonly children: readonly ['Choice'];
+    };
+    readonly Choice: {
+        readonly group: 'choices';
+        readonly description: 'Send its label and visible context once.';
+        readonly schema: z.ZodObject<{
+            context: z.ZodOptional<z.ZodString>;
+            primary: z.ZodOptional<z.ZodBoolean>;
+            disabled: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        readonly parent: 'Choices';
+    };
+};
+export type UiComponentName = keyof typeof UI_CATALOG;
+export type UiProps<Name extends UiComponentName> = z.infer<(typeof UI_CATALOG)[Name]['schema']>;
+export declare function isUiComponent(name: string): name is UiComponentName;
+export declare function uiCatalogText(): string;