@exponential-at/ui 0.0.0-stage → 0.1.0

package/dist/types/src/chart.d.ts

@@ -0,0 +1,46 @@
+export interface ChartSeries {
+    name: string;
+    values: readonly number[];
+    tone?: string;
+}
+/** The value range the y axis spans: `min` defaults to 0 (lower when a value
+ *  is negative), `max` to the largest value (at least 0) — for `stackedBar`
+ *  the largest category sum of the POSITIVE values, and `min` the lowest sum
+ *  of the NEGATIVE ones (positive and negative stacks grow apart from 0).
+ *  Sparkline spans its own min..max. Pie/donut use the same. Non-finite
+ *  values are skipped. Loops, never spreads: a 150k-point series is fine. */
+export declare function chartExtent(kind: string, series: readonly ChartSeries[], min?: number, max?: number): {
+    min: number;
+    max: number;
+};
+/** The numbers a Chart's accessible name fills `$string.chartSummary` with:
+ *  the series names (", "-joined) and the extent of the data (not the axis). */
+export declare function chartSummaryParams(series: readonly ChartSeries[]): {
+    series: string;
+    min: number;
+    max: number;
+};
+/** The numbers a sparkline's accessible name fills `$string.sparklineSummary`
+ *  with: first, last, min, max of the finite values (0 when there are none). */
+export declare function sparklineSummaryParams(values: readonly number[]): {
+    first: number;
+    last: number;
+    min: number;
+    max: number;
+};
+/** Axis ticks over [min, max]: a nice step (1, 2 or 5 × 10^n) giving about
+ *  `target` ticks, the range widened to whole steps, every tick rounded to
+ *  the step's decimals. */
+export declare function niceTicks(min: number, max: number, target?: number): {
+    min: number;
+    max: number;
+    step: number;
+    ticks: number[];
+};
+/** The colour token of series (or slice) i: its tone's colour when set,
+ *  else `$color.chart1..8` in order, wrapping. */
+export declare function seriesColor(index: number, tone?: string): string;
+/** The donut's hole as a share of its radius (pie = 0). */
+export declare const DONUT_HOLE = 0.6;
+/** Rows past which Table and List window their children (catalog/layout.json). */
+export { WINDOW_THRESHOLD } from "./layout.js";

package/dist/types/src/code.d.ts

@@ -0,0 +1,44 @@
+export interface CodeToken {
+    kind: string;
+    text: string;
+}
+interface LanguageSpec {
+    plain?: boolean;
+    ansi?: boolean;
+    lineKinds?: Record<string, string>;
+    lineComment?: string[];
+    blockComment?: [string, string][];
+    strings?: string[];
+    multiline?: string[];
+    keyStrings?: boolean;
+    markup?: boolean;
+    numbers?: boolean;
+    identExtra?: string;
+    keywords?: string[];
+    caseInsensitive?: boolean;
+    keyIdents?: boolean;
+    typeNames?: string[];
+    types?: string;
+    operators?: string;
+    punctuation?: string;
+}
+export declare const CODE_LANGUAGES: Record<string, LanguageSpec>;
+export declare const CODE_LANGUAGE_NAMES: readonly string[];
+/** EXP-1324 `ansi`: one run of the escape-free text, with the SGR colour
+ *  (a codeToken kind) it was printed in, or null. */
+export interface AnsiRun {
+    kind: string | null;
+    text: string;
+}
+/** The source with every ANSI CSI escape removed, split into runs by SGR
+ *  colour (catalog/code.json `$comment`, `ansi`). Adjacent runs of one
+ *  colour merge; an incomplete escape stays text. */
+export declare function ansiRuns(source: string): AnsiRun[];
+/** The text a CodeBlock shows and copies: the source with CRLF → LF and,
+ *  for `ansi`, every escape removed. */
+export declare function codeText(source: string, language: string): string;
+/** The source tokenized per LINE: each line's tokens concatenate to exactly
+ *  its text (no `\n`), adjacent tokens of one kind merged; an empty line is
+ *  an empty list. An unknown language tokenizes as `plain`. */
+export declare function tokenizeCode(source: string, language: string): CodeToken[][];
+export {};

package/dist/types/src/color.d.ts

@@ -0,0 +1,20 @@
+export interface Rgba {
+    r: number;
+    g: number;
+    b: number;
+    /** 0–1 */
+    a: number;
+}
+/** Any CSS colour a theme import may meet → `Rgba`, or null when it is not
+ *  one (a `var()`, a word we do not know). */
+export declare function parseColor(input: unknown): Rgba | null;
+/** `#rrggbb`, or `#rrggbbaa` when the alpha is below 1. Lowercase. */
+export declare function toHex(c: Rgba): `#${string}`;
+/** True for the ONE form a theme file accepts: `#rrggbb` / `#rrggbbaa`. */
+export declare function isThemeHex(value: unknown): value is `#${string}`;
+/** Any CSS colour → the theme form, or null. */
+export declare function toThemeHex(input: unknown): `#${string}` | null;
+/** Relative luminance (WCAG) of an opaque colour, 0–1. */
+export declare function luminance(c: Rgba): number;
+/** WCAG contrast ratio between two opaque colours. */
+export declare function contrast(a: Rgba, b: Rgba): number;

package/dist/types/src/conformance.d.ts

@@ -0,0 +1,39 @@
+/** 2 = round 2: the round-1 bind/style/code fixtures and the round-2
+ *  contract fixtures became suites (docs/round-2-contract.md §8). */
+export declare const CONFORMANCE_VERSION = 2;
+export interface ConformanceSuite {
+    id: string;
+    files: string[];
+    /** What a runner does with each case. */
+    check: string;
+    /** How a case is counted. */
+    unit: string;
+    cases: number;
+}
+export interface ConformanceManifest {
+    $comment: string;
+    version: number;
+    hostContractVersion: number;
+    suites: ConformanceSuite[];
+}
+/** The manifest over the bundled fixtures, or over `fixture(name)` (the
+ *  generator passes the files it is about to write). */
+export declare function conformanceManifest(fixture?: (name: string) => unknown): ConformanceManifest;
+/** What a runner writes (conformance/report.schema.json). */
+export interface ConformanceReport {
+    renderer: string;
+    platform: string;
+    version: string;
+    conformanceVersion: number;
+    suites: Record<string, {
+        cases: number;
+        passed: number;
+        failed: string[];
+        skipped?: string[];
+    }>;
+}
+export interface ReportVerdict {
+    conformant: boolean;
+    problems: string[];
+}
+export declare function checkReport(report: ConformanceReport, manifest?: ConformanceManifest): ReportVerdict;

package/dist/types/src/connector/app.d.ts

@@ -0,0 +1,14 @@
+import type { PackageIssue, AppPackage } from "../host/package.js";
+import { ExponentialHost } from "../host/runtime.js";
+import type { HostOptions } from "../host/runtime.js";
+export interface AppHostOptions extends HostOptions {
+    /** The package to run. */
+    package: AppPackage;
+}
+export interface AppHost {
+    host: ExponentialHost;
+    issues: PackageIssue[];
+    /** Apply a template of the package onto a surface (default: the first). */
+    open(surfaceId: string, templateId?: string, data?: unknown): void;
+}
+export declare function createAppHost(options: AppHostOptions): AppHost;

package/dist/types/src/connector/connector.d.ts

@@ -0,0 +1,77 @@
+import type { HostFunction } from "../host/runtime.js";
+import type { SourceResolvers } from "../host/sources.js";
+export interface AuthServerMetadata {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    registration_endpoint?: string;
+}
+export interface ConnectorTokens {
+    accessToken: string;
+    refreshToken?: string;
+    /** Epoch ms. */
+    expiresAt?: number;
+}
+export interface ConnectorOptions {
+    /** The Exponential instance, e.g. `https://app.exponential.at`. */
+    baseUrl: string;
+    /** Where the instance sends the person back with `?code=&state=`. */
+    redirectUri: string;
+    clientName?: string;
+    /** A client id registered earlier (skips dynamic registration). */
+    clientId?: string;
+    tokens?: ConnectorTokens;
+    /** Called whenever tokens change (persist them). */
+    onTokens?: (tokens: ConnectorTokens) => void;
+    fetch?: typeof fetch;
+    /** Seconds between re-reads of a bound source (MCP has no live feed). */
+    pollSeconds?: number;
+}
+/** A PKCE verifier and its S256 challenge. */
+export declare function pkcePair(): Promise<{
+    verifier: string;
+    challenge: string;
+}>;
+export declare class ExponentialConnector {
+    private options;
+    private metadata?;
+    private clientId?;
+    tokens?: ConnectorTokens;
+    private rpcId;
+    constructor(options: ConnectorOptions);
+    private get fetch();
+    private url;
+    discover(): Promise<AuthServerMetadata>;
+    /** Dynamic client registration (a public client: PKCE, no secret). */
+    register(): Promise<string>;
+    /** Where to send the person. Keep `verifier`, `state` AND `clientId`
+     *  for the callback: a connector rebuilt after the redirect needs the
+     *  dynamically registered client id (pass it to `exchange`, or as
+     *  `ConnectorOptions.clientId`), or the code was issued to a client the
+     *  token request does not name. */
+    authorizeUrl(): Promise<{
+        url: string;
+        verifier: string;
+        state: string;
+        clientId: string;
+    }>;
+    private token;
+    /** The callback: trade the code for tokens. `clientId` = the one
+     *  `authorizeUrl` returned (required unless this connector registered it
+     *  or got it in its options): the exchange never registers a new client,
+     *  whose id the code was not issued to. */
+    exchange(code: string, verifier: string, clientId?: string): Promise<ConnectorTokens>;
+    refresh(): Promise<ConnectorTokens>;
+    /** One MCP tool call on the instance, as the person who consented.
+     *  Returns the tool's JSON payload (its text content parsed). */
+    callTool(name: string, args?: Record<string, unknown>): Promise<unknown>;
+    /** The `exp:` scheme over MCP: `exp:issues?board=<id>&team=<id>&limit=<n>&search=<q>`,
+     *  `exp:boards?team=<id>`, `exp:teams`, `exp:members?team=<id>`. Each
+     *  emits `{rows, count}` and re-reads every `pollSeconds` (default 30, the
+     *  `poll` param overrides; 0 = once). Unknown names emit `null`. */
+    sources(): SourceResolvers;
+    private follow;
+    /** `exponential.mcp({tool, arguments})` for an ExponentialHost (gate it
+     *  with an `ask` policy: it acts as the person). */
+    functions(): Record<string, HostFunction>;
+}

package/dist/types/src/connector/index.d.ts

@@ -0,0 +1,4 @@
+export { ExponentialConnector, pkcePair } from "./connector.js";
+export type { AuthServerMetadata, ConnectorOptions, ConnectorTokens } from "./connector.js";
+export { createAppHost } from "./app.js";
+export type { AppHost, AppHostOptions } from "./app.js";

package/dist/types/src/css.d.ts

@@ -0,0 +1,29 @@
+import type { FontSpec, ResolvedStyle, ResolvedTheme } from "./theme-types.js";
+interface GradientValue {
+    angle: number;
+    stops: {
+        color: string;
+        offset: number;
+    }[];
+}
+export declare function gradientCss(gradient: GradientValue): string;
+/** A CSS string literal: backslashes and quotes escaped, so a family name
+ *  can never end the string early (`validateTheme` also refuses them). */
+export declare function cssString(text: string): string;
+/** `font-family` for a theme family: the quoted name, then its `fonts`
+ *  fallback list. Shared by the web layer's `web/theme-css.ts`. */
+export declare function fontStack(family: string, fonts: Record<string, FontSpec>): string;
+/** Flat declarations for one resolved style (condition blocks are the
+ *  caller's: resolve them against the surface first). `native` is not CSS
+ *  and is dropped; `transitionEasing` folds into `transition`; round 2:
+ *  `backdropBlur` (px) → `backdrop-filter` (+ the -webkit- twin);
+ *  `animation` (+ `animationDuration`, ms once resolved) → the `animation`
+ *  shorthand over `@keyframes xui-<name>` (src/animation.ts keyframesCss)
+ *  when `theme` is given (its motion tokens time it), else nothing; a set
+ *  that animates opacity makes `opacity` = own × `var(--xui-a-opacity, 1)`
+ *  (register it: ANIMATION_PROPERTIES_CSS). The caller drops `animation`
+ *  under reduced motion. */
+export declare function styleToCss(style: ResolvedStyle | Record<string, unknown>, fonts?: Record<string, FontSpec>, theme?: ResolvedTheme): Record<string, string>;
+/** The same as one `style=""` attribute string. */
+export declare function styleAttribute(style: ResolvedStyle | Record<string, unknown>, fonts?: Record<string, FontSpec>): string;
+export {};

package/dist/types/src/define.d.ts

@@ -0,0 +1,66 @@
+import { type ComponentName, type ComponentProps } from "./catalog.generated.js";
+import type { Action, AuthoredAccessibility, DataBinding, ExtensionDef, FlatComponent, FunctionCall, ReduceIssue, UiNode, Visible } from "./types.js";
+/** A node of the typed tree: `component` picks the props type. */
+export interface SurfaceNode<C extends ComponentName = ComponentName> {
+    /** Explicit id; `defineSurface` assigns `root` to the top node and `<component>-<n>` to the rest. */
+    id?: string;
+    component: C;
+    props: ComponentProps[C];
+    style?: Record<string, unknown>;
+    on?: Record<string, Action>;
+    visible?: Visible;
+    accessibility?: AuthoredAccessibility;
+    /** Static children, or one template rendered per item of `path`. */
+    children?: SurfaceNode[] | TemplateChildren;
+    slots?: Record<string, SurfaceNode>;
+}
+export interface TemplateChildren {
+    template: SurfaceNode;
+    /** The JSON pointer of the array. */
+    path: string;
+    /** The item field that identifies it. */
+    key?: string;
+}
+export interface DefineOptions {
+    surfaceId?: string;
+    catalogId?: string;
+    extensions?: readonly ExtensionDef[];
+    /** Initial data model writes: pointer → value (one updateDataModel each). */
+    data?: Record<string, unknown>;
+}
+export interface DefinedSurface {
+    surfaceId: string;
+    catalogId: string;
+    components: FlatComponent[];
+    issues: ReduceIssue[];
+    /** The normalized tree (macros expanded), for a host that paints directly. */
+    root: UiNode;
+    messages: Record<string, unknown>[];
+    jsonl: string;
+}
+/** A data binding: `{ path }`. A pointer relative to the item inside a template. */
+export declare const bind: (path: string) => DataBinding;
+/** A client function call: `{ call, args }`. */
+export declare const call: (name: string, args?: Record<string, unknown>) => FunctionCall;
+/** An action that sends an event to the agent / server. */
+export declare const event: (name: string, context?: Record<string, unknown>) => Action;
+/** An action that runs a client function (`set`, `openUrl`, `app.toast`…). */
+export declare const run: (name: string, args?: Record<string, unknown>) => Action;
+type Extra<C extends ComponentName> = Omit<SurfaceNode<C>, `component` | `props` | `children`>;
+/** The typed factory per component: `ui.Stack(props, children?, extra?)`. */
+export type Factory<C extends ComponentName> = (props: ComponentProps[C], children?: SurfaceNode[] | TemplateChildren, extra?: Extra<C>) => SurfaceNode<C>;
+/** `ui.Card({ title: "…" }, [ui.Text({ text: "…" })])`: one factory per
+ *  catalog component, typed by name. Props only: style, on, visible,
+ *  slots and an explicit id go in the third argument. */
+export declare const ui: {
+    [C in ComponentName]: Factory<C>;
+};
+/** A typed node from a name (for a component picked at runtime). */
+export declare function el<C extends ComponentName>(component: C, props: ComponentProps[C], children?: SurfaceNode[] | TemplateChildren, extra?: Extra<C>): SurfaceNode<C>;
+/** The tree → the flat list, ids assigned (the top node is `root`; an
+ *  unnamed node is `<component lower-case>-<n>`, unique within the tree). */
+export declare function flattenSurface(tree: SurfaceNode, rootId?: string): FlatComponent[];
+/** The typed tree → everything a host or an agent transport needs. Never
+ *  throws on a bad surface: read `issues`. */
+export declare function defineSurface(tree: SurfaceNode, options?: DefineOptions): DefinedSurface;
+export {};

package/dist/types/src/direction.d.ts

@@ -0,0 +1,16 @@
+import { type ConditionContext } from "./style.js";
+import type { UiNode } from "./types.js";
+export type Direction = `ltr` | `rtl`;
+export type PhysicalAlign = `left` | `right` | `center` | `justify`;
+/** Every node's direction: its own style `direction` (resolved against
+ *  `ctx` when given), else its parent's; the root's parent is the surface
+ *  (catalog/locale.json `textDirection(locale)`). Slots inherit from their
+ *  owner. A template's items take the direction of the node that renders
+ *  them (call again with that direction for the template node). */
+export declare function nodeDirections(root: UiNode, surface: Direction, ctx?: ConditionContext): Record<string, Direction>;
+/** `start`/`end` (and an absent value = `start`) as the physical side for
+ *  a direction; `left`, `right`, `center` and `justify` stay. */
+export declare function physicalTextAlign(align: unknown, direction: Direction): PhysicalAlign;
+/** A node's text alignment: its style `textAlign`, else a Text's `align`
+ *  prop, else `start` — resolved against the node's direction. */
+export declare function nodeTextAlign(node: UiNode, direction: Direction, ctx?: ConditionContext): PhysicalAlign;

package/dist/types/src/dynamic.d.ts

@@ -0,0 +1,159 @@
+import { type Formatter } from "./format.js";
+import type { Action, ComponentDef, ExtensionDef, PropSchema, UiNode } from "./types.js";
+/** Where relative paths resolve: the pointer of the current template item
+ *  (`/rows/3`), or the root; `item` (when the key is present) = a LITERAL
+ *  item that is not in the data model (a Table row of literal `rows`):
+ *  relative paths then read inside it, absolute ones still the data. */
+export interface DataScope {
+    base?: string;
+    item?: unknown;
+}
+export declare function absolutePath(path: string, scope?: DataScope): string;
+/** True when relative paths of this scope read a literal item. */
+export declare function hasItem(scope: DataScope | undefined): boolean;
+/** The value a binding path names in a scope: inside the literal item for a
+ *  relative path under an item scope, else at its absolute pointer. */
+export declare function readPath(data: unknown, path: string, scope?: DataScope): unknown;
+/** The value at an absolute pointer; undefined when any step is missing.
+ *  `` and `/` = the whole model (as `writeTokens` writes it); only OWN
+ *  keys and real indices are read (`/constructor` names nothing). */
+export declare function readPointer(data: unknown, pointer: string): unknown;
+/** A pointer write: the new data model, or `error` (data unchanged). */
+export interface PointerWrite {
+    data: unknown;
+    error?: string;
+}
+/** A pointer's tokens (`` and `/` = the whole model), or the limit it breaks. */
+export declare function writeTokens(pointer: string): string[] | string;
+/** VAPP-103: the pointer-write refusals, byte-identical in every core. */
+export declare const POINTER_ISSUES: {
+    readonly bytes: `data: pointer longer than ${number} bytes`;
+    readonly segments: `data: pointer has more than ${number} segments`;
+    readonly notIndex: (token: string) => string;
+    readonly pastEnd: (token: string, length: number) => string;
+};
+/** A copy of `data` with `value` written at the absolute pointer
+ *  (`undefined` removes). Missing containers are OBJECTS; an array takes an
+ *  index up to its length (`length` and `-` append). Refused (data
+ *  unchanged, `error` set): a pointer past `maxPointerBytes` /
+ *  `maxPointerSegments`, a non-index token or an index past the end of an
+ *  array. Iterative: any depth, no recursion. */
+export declare function writePointer(data: unknown, pointer: string, value: unknown): PointerWrite;
+export type FunctionTable = Record<string, (args: Record<string, unknown>) => unknown>;
+/** The reference function table: the core functions + and/or/not/required
+ *  + (round 2) the format functions through the English fallback Formatter
+ *  (`formatNumber`, `formatCurrency`, `formatPercent`, `formatDate`,
+ *  `formatRelativeTime`, `pluralize`; ResolveOptions.formatter replaces it).
+ *  `set` is an action, never a value. The expander EMITS `not`/`and`/`or`
+ *  too, so a renderer must implement this whole table (generated as
+ *  `bindFunctionNames`), not just the core names. */
+export declare const BIND_FUNCTIONS: FunctionTable;
+export declare const BIND_FUNCTION_NAMES: readonly string[];
+export interface ResolveOptions {
+    scope?: DataScope;
+    /** Extra functions (the host's own, the locale formatters). */
+    functions?: FunctionTable;
+    /** The surface's built-in string table (`stringTable(overrides)`): a
+     *  `$string.<id>` value resolves through it. Absent = left as written. */
+    strings?: Readonly<Record<string, string>>;
+    /** The surface's extensions: their components' prop schemas decide which
+     *  props are DATA (bindTree). */
+    extensions?: readonly ExtensionDef[];
+    /** Round 2: the surface's Formatter (SurfaceSettings.locale + timeZone);
+     *  the format functions run through it. Absent = the English fallback. */
+    formatter?: Formatter;
+    /** The clock `formatRelativeTime` reads without a `now` argument. */
+    now?: () => number;
+}
+/** A prop or style value with every binding and call resolved, at any
+ *  depth. An unknown function resolves to undefined. */
+export declare function resolveDynamic(value: unknown, data: unknown, options?: ResolveOptions): unknown;
+/** A node's `visible`: absent = shown; else its resolved truthiness. */
+export declare function isVisible(visible: unknown, data: unknown, options?: ResolveOptions): boolean;
+export interface ActionOutcome {
+    /** The data model after the action's `set` (unchanged without one). */
+    data: unknown;
+    /** VAPP-103: the `set` was refused (writePointer's reason). */
+    error?: string;
+    /** The event to dispatch, its context resolved BEFORE the write. */
+    event?: {
+        name: string;
+        context?: Record<string, unknown>;
+    };
+    /** A function other than `set` the host must run (openUrl…), args resolved. */
+    call?: {
+        call: string;
+        args: Record<string, unknown>;
+    };
+}
+/** Round 4 (VAPP-103): the data an interaction's action resolves against =
+ *  the data model WITH the source component's OWN write applied first.
+ *  `own` = EXACTLY what the component wrote, by prop (an Input's `value`,
+ *  a Checkbox's `checked`, an overlay's `open`, a FileUpload's MERGED
+ *  `files`), never inferred from the event payload (an `upload` payload's
+ *  `added` is the new batch, the write is the whole list): each prop that
+ *  is a `{path}` binding is written at that path, so a `context.query`
+ *  bound to the path the Input writes reads the text just typed. Renderers
+ *  apply it before `runAction` (Rust: every write lands before
+ *  `Surface::fire`). */
+export declare function withOwnWrites(data: unknown, props: Record<string, unknown>, own: Record<string, unknown> | undefined, scope?: DataScope): unknown;
+/** The overlay components (catalog group `overlay`; AlertDialog expands to
+ *  a non-dismissible Dialog). */
+export declare const OVERLAY_COMPONENTS: readonly string[];
+/** Round 4 (VAPP-103): a successful Form submit CLOSES the overlay around
+ *  the form (the author never resets the bound `open` flag). The NEAREST
+ *  enclosing overlay of ANY kind decides: it closes only when it is a
+ *  Dialog or Drawer that is dismissible (`dismissible: false` — an
+ *  AlertDialog — never auto-closes); a nearest Popover, Menu, Tooltip or
+ *  Toast closes nothing, nor does anything around it. The id of that
+ *  overlay in the EXPANDED tree, null when nothing closes. Renderers close
+ *  it like a dismiss (`open` false written through, `change {open:
+ *  false}`) right after the form's `submit`. */
+export declare function submitClosesOverlay(root: UiNode, formId: string): string | null;
+/** What a press does: resolve the function args and the event context
+ *  against the data AS IT IS (after `withOwnWrites`), then apply `set`, then
+ *  hand back the event. */
+export declare function runAction(action: Action, data: unknown, options?: ResolveOptions): ActionOutcome;
+/** A DATA schema: a shape-less `object` (any object) or an array of them —
+ *  Table `rows` in the core catalog. A literal value there is the author's
+ *  data, copied verbatim: no binding, call or `$string.<id>` inside it is
+ *  interpreted (a row `{path: "/etc/hosts"}` is a row). A dynamic value AT
+ *  the position still resolves (and its result is never descended). */
+export declare function isDataSchema(schema: PropSchema | undefined): boolean;
+/** One prop value resolved along its schema: dynamic → resolved, DATA
+ *  literal → verbatim, arrays and shaped objects → per item / property,
+ *  anything else → `resolveDynamic` (any depth). */
+export declare function resolveProp(value: unknown, schema: PropSchema | undefined, data: unknown, options?: ResolveOptions, defs?: Record<string, {
+    properties: Record<string, PropSchema>;
+}>): unknown;
+/** A node's props resolved along its component's schema (an unknown
+ *  component's props resolve at any depth). */
+export declare function resolveNodeProps(def: ComponentDef | undefined, props: Record<string, unknown>, data: unknown, options?: ResolveOptions, defs?: Record<string, {
+    properties: Record<string, PropSchema>;
+}>): Record<string, unknown>;
+/** True when the component's slots are ROW-SCOPED (catalog `slotScope:
+ *  "row"`, Table): each slot is a cell template the painter binds once per
+ *  row (`bindRowSlot`), never against the surface. */
+export declare function hasRowSlots(def: ComponentDef | undefined): boolean;
+/** The scope row `index` of a row-scoped component binds its slot cells in.
+ *  `rowsProp` = the UNBOUND `rows` value: a binding → `{base: <its pointer>/
+ *  <index>}` (relative paths read the row in the data model and `set` writes
+ *  into it); a literal or a call → `{item: rows[index]}` (relative paths read
+ *  inside the row; a relative `set` writes nothing). `index` = the row's index
+ *  in `rows` as given, before any local sort. */
+export declare function rowScope(rowsProp: unknown, rows: readonly unknown[], index: number, scope?: DataScope): DataScope;
+/** A row-scoped slot cell bound for row `index` (see `rowScope`). */
+export declare function bindRowSlot(slot: UiNode, rowsProp: unknown, rows: readonly unknown[], index: number, data: unknown, options?: ResolveOptions): UiNode | null;
+/** Round 2 (docs/round-2-contract.md §4): the scope a List's `section`
+ *  header binds in — a LITERAL item `{value, count, index}` (relative paths
+ *  read it: `{path: "value"}`; absolute ones the surface data). */
+export declare function sectionScope(section: {
+    value: string;
+    count: number;
+}, index: number, scope?: DataScope): DataScope;
+/** A List `section` header bound for section `index` (see `sectionScope`). */
+export declare function bindSectionHeader(slot: UiNode, section: {
+    value: string;
+    count: number;
+}, index: number, data: unknown, options?: ResolveOptions): UiNode | null;
+export declare function bindTree(node: UiNode, data: unknown, options?: ResolveOptions): UiNode | null;

package/dist/types/src/entries/prompt.d.ts

@@ -0,0 +1,11 @@
+import { describeCatalog } from "../catalog.described.js";
+import { CHARS_PER_TOKEN, COMMON_PROPS, DEFAULT_SECTIONS, PROMPT_RULES, PROMPT_SECTIONS, catalogIndex as bareCatalogIndex, componentPrompt as bareComponentPrompt, estimateTokens } from "../prompt.js";
+import type { PromptOptions, PromptSection } from "../prompt.js";
+export { CHARS_PER_TOKEN, COMMON_PROPS, DEFAULT_SECTIONS, PROMPT_RULES, PROMPT_SECTIONS, describeCatalog, estimateTokens };
+export type { PromptOptions, PromptSection };
+/** The catalog prompt (src/prompt.ts `catalogPrompt`) over the described catalog. */
+export declare function catalogPrompt(options?: PromptOptions): string;
+/** One component's prompt section (VAPP-108, the on-demand per-component prompt) over the described catalog. */
+export declare function componentPrompt(name: string, options?: Parameters<typeof bareComponentPrompt>[1]): string;
+/** The one-line-per-component index (VAPP-108) over the described catalog. */
+export declare function catalogIndex(options?: Parameters<typeof bareCatalogIndex>[0]): string[];

package/dist/types/src/entries/schema.d.ts

@@ -0,0 +1,8 @@
+import { describeCatalog } from "../catalog.described.js";
+import { coreSchema as bareCoreSchema, extensionSchema as bareExtensionSchema } from "../schema.js";
+import type { ExtensionDef } from "../types.js";
+export { describeCatalog };
+/** The core catalog as JSON Schema (src/schema.ts `coreSchema`), descriptions included. */
+export declare function coreSchema(iconNames: readonly string[]): ReturnType<typeof bareCoreSchema>;
+/** An extension's schema (src/schema.ts `extensionSchema`), descriptions included. */
+export declare function extensionSchema(ext: ExtensionDef, iconNames: readonly string[]): ReturnType<typeof bareExtensionSchema>;

package/dist/types/src/expr.d.ts

@@ -0,0 +1,71 @@
+export interface ExprContext {
+    id: string;
+    props: Record<string, unknown>;
+    vars: Record<string, unknown>;
+}
+/** An A2UI data binding: an object with exactly one key, `path`. */
+export interface DataBinding {
+    path: string;
+}
+/** An A2UI function call. */
+export interface FunctionCall {
+    call: string;
+    args?: Record<string, unknown>;
+    returnType?: string;
+}
+export type Dynamic = DataBinding | FunctionCall;
+export declare function isBinding(value: unknown): value is DataBinding;
+export declare function isCall(value: unknown): value is FunctionCall;
+/** A value the expander cannot evaluate: the renderer will. */
+export declare function isDynamic(value: unknown): value is Dynamic;
+/** `undefined`, `null`, `false` and `""` are false; 0 is TRUE (a count of
+ *  zero still shows). */
+export declare function truthy(value: unknown): boolean;
+/** `eq` (and `$eq`): strict equality, except that a NUMBER and a string
+ *  spelling that number are equal (`5` vs `"5"`: form and URL state arrive as
+ *  strings). Nothing else coerces (`0` vs `""`, `1` vs `true` differ). */
+export declare function valuesEqual(a: unknown, b: unknown): boolean;
+/** `clamp`: the value as a number held inside [min, max]; a missing bound
+ *  (undefined or null) does not clamp; `min` wins when max < min. */
+export declare function clampNumber(value: unknown, min: unknown, max: unknown): number;
+/** `fill`: the template (already resolved through the string table) with its
+ *  `{name}` placeholders filled from params (strings.ts formatString). */
+export declare function fillTemplate(template: unknown, params: unknown): string;
+/** The most indexes `range(n)` yields (R8 F51): a Rating's `max` of 1e8 or
+ *  1e300 would otherwise allocate that many items before the component
+ *  budget could refuse them. Equals `maxTemplateItems`; a larger `n` is
+ *  silently clamped (the reducer's `maxComponents` reports the overflow).
+ *  Mirrors `MAX_RANGE_ITEMS` in the Rust core's `expr.rs`. */
+export declare const MAX_RANGE_ITEMS = 10000;
+/** One expression: `len(path)`, `range(n)`, `path|fallback`, `!path`, `path`.
+ *  The function forms wrap the whole expression and are tried first, so a
+ *  fallback inside their parentheses stays theirs. */
+export declare function evalExpr(expr: string, ctx: ExprContext): unknown;
+/** A condition: a string expression or a value object ($eq …). `true` or
+ *  `false` when it can be decided now; the dynamic value when it cannot. */
+export declare function evalConditionValue(cond: unknown, ctx: ExprContext): boolean | Dynamic;
+/** A condition decided NOW: a dynamic condition counts as true (the part
+ *  exists; `visible` carries the bound test, see macros.ts). */
+export declare function evalCondition(cond: unknown, ctx: ExprContext): boolean;
+/** Any template value: strings interpolate, arrays and objects recurse, the
+ *  `$`-objects compute (or emit a call when an input is dynamic). `undefined`
+ *  results are dropped by the caller. */
+export declare function evalValue(value: unknown, ctx: ExprContext): unknown;
+/** `$percent`'s arithmetic, shared with the core `percent` function: the
+ *  share of `max` as "N%", clamped to 0..100, two decimals. */
+export declare function percent(value: unknown, max: unknown): string;
+/** Round 4 (VAPP-103) `filter`: the items of an array that match, in order,
+ *  so a List or Table binds to a filtered view without an agent round trip.
+ *  `where` = field → value, every entry must hold (`eq` equality); an entry
+ *  whose value is missing, null or "" does NOT constrain (a bound "all"
+ *  choice). `query` = a case-insensitive substring of ANY of `fields` (the
+ *  item's own string and number values when `fields` is absent; a string or
+ *  number item matches itself); a missing, null or blank query does not
+ *  constrain. Not an array → []. */
+export declare function filterItems(items: unknown, query: unknown, fields: unknown, where: unknown): unknown[];
+/** The core value functions (core.catalog.json `functions.core`; `set` is
+ *  an action, src/dynamic.ts runAction) as the renderer
+ *  evaluates them once the arguments are resolved: the reference every
+ *  client function table mirrors. `undefined` = no value. */
+export declare const CORE_FUNCTIONS: Record<string, (args: Record<string, unknown>) => unknown>;
+export declare const CORE_FUNCTION_NAMES: readonly string[];

package/dist/types/src/extension.d.ts

@@ -0,0 +1,4 @@
+import type { ExtensionDef } from "./types.js";
+export declare function validateExtension(def: ExtensionDef): string[];
+/** The definition, checked; throws with every problem listed. */
+export declare function defineExtension(def: ExtensionDef): ExtensionDef;