@exponential_app/eui 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,69 @@
+export * from "./types.js";
+export { CORE_CATALOG_ID, CORE_LITE_CATALOG_ID, A2UI_BASIC_CATALOG_ID, A2UI_VERSION, SUPPORTED_CATALOG_IDS, UNKNOWN_COMPONENT, TOKEN_GROUPS, coreCatalog, coreMacros, catalogView, sharedCatalogView, componentDef, componentNames, coreLite, isOffered, parseTokenRef, isKnownToken, } from "./catalog.js";
+export type { CatalogView } from "./catalog.js";
+export * from "./catalog.generated.js";
+export { STYLE_KEYS, STYLE_LAYOUT_KEYS, STYLE_VISUAL_KEYS, STYLE_LAYOUT_EFFECT_KEYS, STYLE_MEDIA, STYLE_STATES, STYLE_TRANSFORM, validateStyle, create, props, parseMediaCondition, mediaMatches, resolveConditions, activeBreakpoint, styleKeyEnum, styleKeyType, } from "./style.js";
+export type { Style, StyleProps, MediaKey, StateKey, StyleIssue, Gradient, ConditionContext, MediaCondition } from "./style.js";
+export { validateProps, validateNode, isCallableName, isDynamic } from "./validate.js";
+export type { PropIssue } from "./validate.js";
+export { evalValue, evalExpr, evalCondition, evalConditionValue, truthy, isBinding, isCall, percent, valuesEqual, clampNumber, fillTemplate, filterItems, CORE_FUNCTIONS, CORE_FUNCTION_NAMES } from "./expr.js";
+export type { ExprContext, Dynamic } from "./expr.js";
+export { expandMacros, isResponsiveValue, responsiveAt, propsAt, BREAKPOINTS } from "./macros.js";
+export { resolveDynamic, isVisible, runAction, withOwnWrites, submitClosesOverlay, bindTree, readPointer, writePointer, writeTokens, POINTER_ISSUES, absolutePath, readPath, hasItem, isDataSchema, resolveProp, resolveNodeProps, hasRowSlots, rowScope, bindRowSlot, sectionScope, bindSectionHeader, BIND_FUNCTIONS, BIND_FUNCTION_NAMES } from "./dynamic.js";
+export { displayString, englishFormatter, intlFormatter, formatFunctions, formatPattern, parseDateValue, relativeTimeUnit, currencyDigits, FORMAT_FUNCTION_NAMES, ENGLISH_FORMAT_FUNCTIONS, ENGLISH_DATE_PATTERNS, ENGLISH_TIME_PATTERN, ENGLISH_DATE_TIME_JOIN, fixedOffset, intlZoneOffset } from "./format.js";
+export type { Formatter, NumberOptions, DateOptions, DateStyle, PluralCategory, RelativeUnit, ZoneOffset } from "./format.js";
+export { templateItemKeys, tableRowKeys, templateInstances, itemExtents, itemOffsets, virtualWindow, scrollOffsetForIndex, scrollOffsetForItem, instanceSegment, listSections, sectionRows, stickyHeader, templateBudget, templateSiteKey, WINDOW_OVERSCAN } from "./list.js";
+export type { TemplateInstance, TemplateBudget, WindowRange, ScrollAlign, ListSection } from "./list.js";
+export { normalizeSizes, resizePanels, keyboardResize, panelExtents, dragDelta, RESIZE_STEP, PANEL_MIN, RESIZE_HANDLE_HIT } from "./resizable.js";
+export type { PanelLimits, ResizeKey } from "./resizable.js";
+export { nodeDirections, physicalTextAlign, nodeTextAlign } from "./direction.js";
+export type { Direction, PhysicalAlign } from "./direction.js";
+export { LIMITS, MAX_COMPONENTS, MAX_DEPTH, MAX_MESSAGE_BYTES, MAX_TEMPLATE_ITEMS, MAX_POINTER_BYTES, MAX_POINTER_SEGMENTS, LIMIT_ISSUES } from "./limits.js";
+export { LAYOUT_CONSTANTS, FIELD_INTRINSIC_WIDTH, MEDIA_INTRINSIC_WIDTH, MEDIA_ASPECT_RATIO, TREE_GUIDE_COLUMN, TREE_GUIDE_RADIUS, TREE_GUIDE_BRIDGE, PENDING_DELAY_MS, SKELETON_PULSE_MS, SKELETON_OPACITY_LOW, SKELETON_OPACITY_HIGH, SKELETON_REDUCED_OPACITY, SEARCH_LIST_FADE } from "./layout.js";
+export { treeGuides, applyTreeGuides, isRowRoot } from "./tree-guides.js";
+export type { TreeGuide } from "./tree-guides.js";
+export { ANIMATIONS, ANIMATION_NAMES, ANIMATION_PROPERTIES_CSS, animatesOpacity, animationTiming, animationFrame, cubicBezier, keyframesCss, animationCss, paintedOpacity } from "./animation.js";
+export type { AnimationDef, AnimationFrame, AnimationTiming, Keyframe } from "./animation.js";
+export type { DataScope, ResolveOptions, ActionOutcome, FunctionTable, PointerWrite } from "./dynamic.js";
+export { DEFAULT_STRINGS, STRING_IDS, parseStringRef, isStringRef, stringTable, formatString, resolveString } from "./strings.js";
+export { DEFAULT_LOCALE, parseLocale, localeRegion, weekStart, textDirection, RTL_MIRRORED_ICONS, mirrorsInRtl } from "./locale.js";
+export type { LocaleParts } from "./locale.js";
+export { tokenizeCode, codeText, ansiRuns, CODE_LANGUAGES, CODE_LANGUAGE_NAMES } from "./code.js";
+export type { AnsiRun } from "./code.js";
+export { textShimmer, TEXT_SHIMMER } from "./text-shimmer.js";
+export type { TextShimmer } from "./text-shimmer.js";
+export { voiceWave, voiceWavePath, voiceWavePhase, voiceWaveChildSize, voiceWaveChildBox, voiceWaveActivity, VOICE_WAVE, VOICE_WAVE_ACTIVITIES, VOICE_WAVE_RINGS } from "./voice-wave.js";
+export type { VoiceWave, VoiceWaveActivity, VoiceWaveChildBox, VoiceWaveInput, VoiceWaveRing, VoiceWaveRingName } from "./voice-wave.js";
+export { voiceWaveBars, voiceWaveBarsBox, voiceWaveVariant, VOICE_WAVE_BARS, VOICE_WAVE_SIZES, VOICE_WAVE_VARIANTS } from "./voice-wave.js";
+export type { VoiceWaveBar, VoiceWaveBars, VoiceWaveBarsInput, VoiceWaveSizeName, VoiceWaveVariant } from "./voice-wave.js";
+export { qrMatrix, qrLayout, qrLevel, qrVersion, QR_CODE, QR_LEVELS } from "./qr-code.js";
+export type { QrLevel, QrMatrix } from "./qr-code.js";
+export { A11Y_ROLES, A11Y_RULES, A11Y_COMMANDS, COMPONENT_A11Y, componentA11y, isA11yRole } from "./a11y.js";
+export { chartExtent, chartSummaryParams, sparklineSummaryParams, niceTicks, seriesColor, DONUT_HOLE, WINDOW_THRESHOLD } from "./chart.js";
+export type { ChartSeries } from "./chart.js";
+export type { ComponentA11y } from "./a11y.js";
+export type { CodeToken } from "./code.js";
+export { basicMap, mapBasicComponent, mapBasicIcon, BASIC_TRANSFORM_NAMES } from "./basic-map.js";
+export type { MappedComponent } from "./basic-map.js";
+export { reduceSurface, reduceNested, preorder, RESERVED_KEYS, validVisible, slotAllowed, childTemplate } from "./reducer.js";
+export type { ReduceOptions, ReduceResult } from "./reducer.js";
+export { defineExtension, validateExtension } from "./extension.js";
+export { defineSurface, flattenSurface, ui, el, bind, call, event, run } from "./define.js";
+export type { SurfaceNode, TemplateChildren, DefineOptions, DefinedSurface, Factory } from "./define.js";
+export * from "./theme-types.js";
+export { parseColor, toHex, toThemeHex, isThemeHex, luminance, contrast } from "./color.js";
+export type { Rgba } from "./color.js";
+export { RECIPE_STATES, RECIPE_KEYS, recipeParts, macroParts, nativeRecipeProps } from "./recipes.js";
+export type { PartSpec } from "./recipes.js";
+export { MODES, DENSITIES, THEME_SCHEMA_ID, resolveMode, applyDensity, applyContrast, resolveConditionKey, easingCss, ThemeError, validateTheme, tryLoadTheme, loadTheme, resolveToken, resolveStyleValues, recipeStyle, resolveRecipe, nodeRecipeQuery, resolveNodeStyle, shadowCss, } from "./theme.js";
+export type { ThemeOptions } from "./theme.js";
+export { BUILTIN_THEMES, BUILTIN_THEME_IDS, DEFAULT_THEME_ID, neutralTheme, exponentialTheme, playfulTheme, orangeTheme, builtinTheme, builtinThemes, themeOrDefault } from "./themes.js";
+export { styleToCss, styleAttribute, gradientCss } from "./css.js";
+export { SHADCN_COLOR_VARS, importShadcnCss, themeFromImport, diffTheme, exportThemeJson, parseThemeJson, parseShadow } from "./builder.js";
+export type { ThemeImport } from "./builder.js";
+export { CONTROL_PARTS, GEOMETRY_KEYS, controlGeometry, checkGeometry, verifyPainterGeometry } from "./geometry.js";
+export type { ControlGeometry, GeometryKey, MeasuredBox, PainterOverride, GeometryIssue } from "./geometry.js";
+export { OVERLAY_OFFSET, OVERLAY_PADDING, placeOverlay } from "./overlay.js";
+export type { OverlaySide, OverlayAlign, OverlayPlacement, Rect, Size } from "./overlay.js";
+export * from "./host/index.js";
+export * from "./connector/index.js";

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

@@ -0,0 +1,20 @@
+export declare const LAYOUT_CONSTANTS: Readonly<Record<string, number>>;
+export declare const WINDOW_THRESHOLD: number;
+export declare const WINDOW_OVERSCAN: number;
+export declare const RESIZE_STEP: number;
+export declare const PANEL_MIN: number;
+export declare const RESIZE_HANDLE_HIT: number;
+export declare const FIELD_INTRINSIC_WIDTH: number;
+export declare const MEDIA_INTRINSIC_WIDTH: number;
+export declare const MEDIA_ASPECT_RATIO: number;
+export declare const TREE_GUIDE_COLUMN: number;
+/** Round 3: the elbow's corner radius and how far the guide verticals overshoot a row's top edge (paint only). */
+export declare const TREE_GUIDE_RADIUS: number;
+export declare const TREE_GUIDE_BRIDGE: number;
+/** EXP-1259: the pending Button's delay, the Skeleton's pulse and the SearchList's bottom fade (feedback-states.json, search-list.json). */
+export declare const PENDING_DELAY_MS: number;
+export declare const SKELETON_PULSE_MS: number;
+export declare const SKELETON_OPACITY_LOW: number;
+export declare const SKELETON_OPACITY_HIGH: number;
+export declare const SKELETON_REDUCED_OPACITY: number;
+export declare const SEARCH_LIST_FADE: number;

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

@@ -0,0 +1,21 @@
+export declare const LIMITS: Readonly<Record<string, number>>;
+/** Nodes the reducer places in one surface's tree (template nodes included). */
+export declare const MAX_COMPONENTS: number;
+/** Component nesting levels (the root = 1). */
+export declare const MAX_DEPTH: number;
+/** One server message as UTF-8 JSON. */
+export declare const MAX_MESSAGE_BYTES: number;
+/** Template items one surface instantiates. */
+export declare const MAX_TEMPLATE_ITEMS: number;
+/** A data pointer's length in UTF-8 bytes. */
+export declare const MAX_POINTER_BYTES: number;
+/** A data pointer's token count. */
+export declare const MAX_POINTER_SEGMENTS: number;
+/** The issue messages, byte-identical in every core. */
+export declare const LIMIT_ISSUES: {
+    readonly usedTwice: "id used twice; only its first place renders";
+    readonly depth: `nesting deeper than ${number} levels`;
+    readonly components: `surface: more than ${number} components; the rest is dropped`;
+    readonly templateItems: `template: more than ${number} items; the rest is not rendered`;
+    readonly messageBytes: `message larger than ${number} bytes`;
+};

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

@@ -0,0 +1,133 @@
+import type { ChildTemplate, ReduceIssue, UiNode } from "./types.js";
+export { WINDOW_THRESHOLD, WINDOW_OVERSCAN } from "./layout.js";
+/** The instance key of every item: the value at `keyPointer` (relative to
+ *  the item; objects as their JSON) — `#<index>` when that value is missing,
+ *  null, `` or a DUPLICATE of an earlier item's key (more `#`s until unique);
+ *  without a pointer, the index. */
+export declare function templateItemKeys(items: readonly unknown[], keyPointer?: string): string[];
+/** Table row keys: the `rowKey` FIELD (default `id`) under the same rules
+ *  (`#<index>` for missing, empty or duplicate). */
+export declare function tableRowKeys(rows: readonly unknown[], rowKey?: string): string[];
+/** A key as one instance-suffix segment: `~` → `~0`, `.` → `~1` (as JSON
+ *  pointer escapes `/`), so dotted keys never collide across nesting levels
+ *  (`a.b` + `c` vs `a` + `b.c`). */
+export declare const instanceSegment: (key: string) => string;
+export interface TemplateInstance {
+    /** The item's key (see `templateItemKeys`). */
+    key: string;
+    /** The item's data pointer: its scope (`/posts/3`). */
+    path: string;
+    index: number;
+    /** The suffix every node of the item wears: the enclosing instance's
+     *  suffix + `.<key>`, the key escaped by `instanceSegment` (`.a` for an
+     *  outer item, `.a.0` inside it, `.a~1b` for key `a.b`). A node's painted
+     *  id = its id + the suffix. */
+    instance: string;
+}
+/** The items a node's `template` renders in a data scope: one per array
+ *  item at `template.path` (relative to `scope`), keyed by `template.key`.
+ *  `instance` = the suffix of the item the template sits in (`` at the top). */
+export declare function templateInstances(data: unknown, template: ChildTemplate, scope?: string, instance?: string): TemplateInstance[];
+/** A template site's key in a `TemplateBudget`: the node holding the
+ *  template + the data scope it sits in. */
+export declare const templateSiteKey: (nodeId: string, scope: string) => string;
+export interface TemplateBudget {
+    /** Items each visited template site builds (absent = a site the walk
+     *  never reached: it sits in an item that is not built). */
+    allowed: Map<string, number>;
+    /** ONE issue per build: the template component whose next item did not
+     *  fit (`LIMIT_ISSUES.templateItems` or `LIMIT_ISSUES.components`); null =
+     *  everything fits. */
+    issue: ReduceIssue | null;
+}
+/** VAPP-103: the template items ONE surface builds, in the Rust layout
+ *  build's order (depth-first: a node's slots and static children, then its
+ *  template items, each item's own subtree, nested items included, before
+ *  the next item). The build holds `maxComponents` nodes: it starts at the
+ *  reduced root tree's own nodes (children + slots; template definitions
+ *  aside), and every item costs 1 against `maxTemplateItems` AND its
+ *  template subtree's nodes. The first item that does not fit either budget
+ *  and every later one is not built, with ONE issue on that template
+ *  component. A windowed List (more than `WINDOW_THRESHOLD` rows) mounts
+ *  its rows on demand: its items are not counted up front. Iterative. */
+export declare function templateBudget(root: UiNode, data: unknown, templateNode: (componentId: string) => UiNode | undefined): TemplateBudget;
+/** Start offsets of items laid end to end on one axis with `gap` between
+ *  them (a `divided` list adds `$control.hairline` to the gap; the divider
+ *  is centred in it): `offsets[i]` = where item i starts, `offsets[count]` =
+ *  the content length. */
+export declare function itemOffsets(extents: readonly number[], gap?: number): number[];
+/** Every item's extent on the list's axis: a measured item keeps its
+ *  extent; an unmeasured one (`null`) takes the MEAN of the measured
+ *  extents once any item is measured (the content length stays stable while
+ *  rows measure in, so a fling lands on the real end), else `row` (the
+ *  theme's `$control.row`). */
+export declare function itemExtents(measured: readonly (number | null | undefined)[], row: number): number[];
+export interface WindowRange {
+    /** First rendered item. */
+    start: number;
+    /** One past the last rendered item. */
+    end: number;
+    /** Space before `start` / after `end - 1` (the spacers). */
+    before: number;
+    after: number;
+    /** The content length. */
+    total: number;
+}
+/** The items to render for a viewport `[scroll, scroll + viewport)` on the
+ *  list's axis (both relative to the list's content start; a list without a
+ *  bounded size windows against its nearest scrolling ancestor or the host
+ *  viewport, translated into this frame): every item that intersects it
+ *  (an item ending exactly at the viewport start still counts) plus
+ *  `overscan` items on each side. Unmeasured items take `itemExtents`'s
+ *  estimate (the caller's extents). `offsets` = `itemOffsets(extents, gap)` when the
+ *  caller caches it (recompute only when an extent changes): the window is
+ *  then two binary searches, O(log n) per scroll frame. */
+export declare function virtualWindow(extents: readonly number[], gap: number, scroll: number, viewport: number, overscan?: number, offsets?: readonly number[]): WindowRange;
+export type ScrollAlign = `start` | `center` | `end` | `nearest`;
+/** The scroll offset that brings item `index` into a viewport of length
+ *  `viewport` currently at `scroll` (the `scrollToIndex` command): `start` =
+ *  its start at the viewport start (after `inset`, the pinned header's
+ *  extent), `end` = its end at the viewport end, `center` = centred,
+ *  `nearest` (default) = the smallest move that shows it whole (none when it
+ *  already is). Clamped to `[0, max(0, total - viewport)]`. `offsets` = the
+ *  cached `itemOffsets`, as for `virtualWindow`. */
+export declare function scrollOffsetForIndex(extents: readonly number[], gap: number, index: number, viewport: number, scroll: number, align?: ScrollAlign, inset?: number, offsets?: readonly number[]): number;
+export interface ListSection {
+    /** The `sectionBy` value its items share (as `displayString`; `` for
+     *  missing). */
+    value: string;
+    /** Index of the section's first item in the data. */
+    start: number;
+    count: number;
+}
+/** Consecutive template items with the same `sectionBy` value (a pointer
+ *  relative to each item) form a section; the data order is kept (sort the
+ *  data to group it). */
+export declare function listSections(items: readonly unknown[], sectionBy: string): ListSection[];
+/** The flat ROW list a sectioned list windows: a header row before each
+ *  section's items (`{header: sectionIndex}` / `{item: dataIndex}`). */
+export declare function sectionRows(sections: readonly ListSection[]): ({
+    header: number;
+} | {
+    item: number;
+})[];
+/** `scrollToIndex` on a SECTIONED list: the DATA index → its flat row
+ *  (`sectionRows`; -1 = absent → no move), then `scrollOffsetForIndex` over
+ *  the rows' extents with `inset` = the extent of the item's own section
+ *  header when headers are sticky (it pins over the item), else 0. */
+export declare function scrollOffsetForItem(rows: readonly ({
+    header: number;
+} | {
+    item: number;
+})[], rowExtents: readonly number[], gap: number, dataIndex: number, viewport: number, scroll: number, align?: ScrollAlign, stickyHeaders?: boolean, offsets?: readonly number[]): number;
+/** The sticky header at a scroll offset: the LAST header row starting at or
+ *  before `scroll` is pinned at the viewport start — pushed back by the next
+ *  header as it arrives (its offset = min(scroll, nextHeaderStart −
+ *  extent)). `rowOffsets` = itemOffsets of the flat rows; `headerRows` = the
+ *  flat indices of the header rows, ascending. Null before the first header
+ *  reaches the viewport start. Binary search: O(log headers). The pinned header is rendered even when the
+ *  window does not contain it. */
+export declare function stickyHeader(rowOffsets: readonly number[], rowExtents: readonly number[], headerRows: readonly number[], scroll: number): {
+    row: number;
+    offset: number;
+} | null;

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

@@ -0,0 +1,22 @@
+export declare const DEFAULT_LOCALE: string;
+export interface LocaleParts {
+    language: string;
+    region: string | null;
+}
+/** `pt-BR` → {pt, BR}; `zh-Hant-TW` → {zh, TW}; `de` → {de, null}. The
+ *  region = the first 2-letter or 3-digit subtag after the language; a
+ *  deprecated language code is normalised (`iw` → `he`, `ji` → `yi`, `in` →
+ *  `id`: `languageAliases`). */
+export declare function parseLocale(locale: string): LocaleParts;
+/** The region a locale's data comes from: its own, else the language's
+ *  likely region (CLDR likelySubtags), else null. */
+export declare function localeRegion(locale: string): string | null;
+/** The first day of the week, 0 = Sunday … 6 = Saturday. */
+export declare function weekStart(locale: string): number;
+/** `rtl` for the right-to-left languages, else `ltr`. */
+export declare function textDirection(locale: string): `ltr` | `rtl`;
+/** The directional glyphs (icons.json names) a painter mirrors under rtl. */
+export declare const RTL_MIRRORED_ICONS: readonly string[];
+/** True when `icon` is drawn mirrored (scaleX(-1), outermost) in this
+ *  direction. */
+export declare function mirrorsInRtl(icon: string, direction: `ltr` | `rtl`): boolean;

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

@@ -0,0 +1,29 @@
+import { isDynamic, truthy } from "./expr.js";
+import type { ExtensionDef, MacroChild, ReduceIssue, UiNode } from "./types.js";
+/** The breakpoint names in ascending order (tokens.json). */
+export declare const BREAKPOINTS: readonly string[];
+/** `{base, sm?, md?, lg?, xl?}`: an object with `base` and only breakpoint
+ *  keys besides. */
+export declare function isResponsiveValue(value: unknown): value is Record<string, unknown> & {
+    base: unknown;
+};
+/** The value a responsive prop takes at a breakpoint: the nearest defined
+ *  key at or below it, `base` under the first one. `null` = the base. */
+export declare function responsiveAt(value: Record<string, unknown> & {
+    base: unknown;
+}, breakpoint: string | null): unknown;
+/** The author's props with every responsive object replaced by its value at
+ *  `breakpoint`. */
+export declare function propsAt(props: Record<string, unknown>, breakpoint: string | null): Record<string, unknown>;
+/** The normalized tree with every macro (core + extensions) expanded into
+ *  natives, recipes attached. Pure: the input is not mutated; expansion
+ *  problems (an author function that replaces a `$set` write) are pushed to
+ *  `options.issues` when given. */
+export declare function expandMacros(root: UiNode, options?: {
+    extensions?: readonly ExtensionDef[];
+    issues?: ReduceIssue[];
+}): UiNode;
+/** True for a value the expander would keep (see expr.ts). */
+export declare const keeps: typeof truthy;
+export { isDynamic };
+export type { MacroChild };

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

@@ -0,0 +1,27 @@
+export declare const OVERLAY_OFFSET = 4;
+export declare const OVERLAY_PADDING = 8;
+export type OverlaySide = `top` | `right` | `bottom` | `left`;
+export type OverlayAlign = `start` | `center` | `end`;
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface Size {
+    width: number;
+    height: number;
+}
+export interface OverlayPlacement {
+    x: number;
+    y: number;
+    side: OverlaySide;
+    /** True when the preferred side was swapped for its opposite. */
+    flipped: boolean;
+}
+export declare function placeOverlay(anchor: Rect, size: Size, viewport: Size, options?: {
+    side?: OverlaySide;
+    align?: OverlayAlign;
+    offset?: number;
+    padding?: number;
+}): OverlayPlacement;

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

@@ -0,0 +1,44 @@
+import type { ComponentDef, ExtensionDef } from "./types.js";
+/** The sections of the prompt, in print order (VAPP-108): an agent (or the
+ *  host serving it) asks for the ones it needs. `index` = one line per
+ *  component (name, group, description) instead of the full `components`
+ *  blocks: the agent reads the index, then asks for `componentPrompt(name)`
+ *  of the ones it will use. */
+export type PromptSection = `rules` | `components` | `index` | `shapes` | `functions` | `style` | `extensions`;
+export declare const PROMPT_SECTIONS: readonly PromptSection[];
+/** What `catalogPrompt()` prints without `sections`. */
+export declare const DEFAULT_SECTIONS: readonly PromptSection[];
+export interface PromptOptions {
+    extensions?: readonly ExtensionDef[];
+    /** The core-lite subset (the app-shaped vocabulary: no overlays, media, Chart, data tables or the rarer controls). */
+    lite?: boolean;
+    /** Omit the per-prop lines (names + types only). */
+    terse?: boolean;
+    /** VAPP-108: which sections to print (default `DEFAULT_SECTIONS`, in that order whatever the order given). */
+    sections?: readonly PromptSection[];
+    /** VAPP-108: print only these components (full blocks) and the shapes they reach; `index` still lists every one. */
+    only?: readonly string[];
+}
+/** The rules every surface author (a model) must follow, shared by the core
+ *  and the basic catalog. Kept to a few lines on purpose. */
+export declare const PROMPT_RULES: readonly string[];
+/** Props whose meaning is the same everywhere: described ONCE in the full
+ *  prompt (the per-prop line then carries only name, marks and type). The
+ *  catalog keeps every per-component description for the docs. */
+export declare const COMMON_PROPS: Readonly<Record<string, string>>;
+export declare function componentBlock(name: string, def: ComponentDef, enums: Record<string, readonly string[]>, terse: boolean): string;
+/** Every catalog function as `name(arg:type,…)→returns` (round 4: the
+ *  model sees the argument names, not just the function names). */
+export declare function functionSignatures(): string[];
+/** VAPP-108: one component's full block on demand (the per-component
+ *  section an agent requests after reading the index), with the shapes its
+ *  props reach. Unknown or hidden names give an empty string. */
+export declare function componentPrompt(name: string, options?: Pick<PromptOptions, `extensions` | `terse`>): string;
+/** VAPP-108: the index — every offered component on one line (name, group, kind, its sentence), grouped. */
+export declare function catalogIndex(options?: Pick<PromptOptions, `extensions` | `lite`>): string[];
+/** The system prompt for a surface author. */
+export declare function catalogPrompt(options?: PromptOptions): string;
+/** Characters per token the budget assumes (the same rule as the context
+ *  layout's `charsPerToken`): an estimate, not a tokenizer. */
+export declare const CHARS_PER_TOKEN = 4;
+export declare function estimateTokens(text: string): number;

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

@@ -0,0 +1,30 @@
+export declare const QR_CODE: {
+    $comment: string;
+    quietZone: number;
+    labelGap: number;
+    maxValueBytes: number;
+};
+export declare const QR_LEVELS: readonly ["L", "M", "Q", "H"];
+export type QrLevel = (typeof QR_LEVELS)[number];
+export interface QrMatrix {
+    /** Modules per side (21 + 4 × (version − 1)). */
+    size: number;
+    version: number;
+    /** The mask pattern chosen (0..7). */
+    mask: number;
+    /** `size` rows of `size` characters: '1' = dark, '0' = light; no quiet zone. */
+    rows: string[];
+}
+/** The level as the catalog names it; anything else is `M` (the default). */
+export declare function qrLevel(value: unknown): QrLevel;
+/** The smallest version whose data capacity holds `bytes` at `level`, or null. */
+export declare function qrVersion(byteLength: number, level: QrLevel): number | null;
+/** The QR matrix of `value` (UTF-8, byte mode) at `level`; null for an empty
+ *  value or one too long for version 40 at that level. */
+export declare function qrMatrix(value: string, rawLevel?: unknown): QrMatrix | null;
+/** The painted geometry of a QrCode of edge `size` px (style.json `qrCode`):
+ *  the module edge and the quiet zone's inset, both in px. */
+export declare function qrLayout(size: number, modules: number): {
+    module: number;
+    inset: number;
+};

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

@@ -0,0 +1,17 @@
+import type { ExtensionDef, MacroDef } from "./types.js";
+export declare const RECIPE_STATES: readonly string[];
+export declare const RECIPE_KEYS: readonly string[];
+export interface PartSpec {
+    parts: string[];
+    /** The prop names a `when` may use (besides `state`). */
+    props: string[];
+}
+/** A macro's parts and recipe props, read off its template. */
+export declare function macroParts(def: MacroDef): PartSpec;
+/** Every component (core + the given extensions) → its parts and `when`
+ *  props. An extension's natives declare `recipe: {parts, props}` on their
+ *  component def; without it a native gets `root` and its enum/boolean props. */
+export declare function recipeParts(extensions?: readonly ExtensionDef[]): Record<string, PartSpec>;
+/** The recipe query a NATIVE node answers to: its `when` props with the
+ *  catalog defaults filled in (a macro part carries its own `recipe`). */
+export declare function nativeRecipeProps(component: string, props: Record<string, unknown>, extensions?: readonly ExtensionDef[]): Record<string, unknown>;

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

@@ -0,0 +1,41 @@
+import type { ChildTemplate, ExtensionDef, FlatComponent, NestedNode, ReduceIssue, UiNode, Visible, WireChildTemplate } from "./types.js";
+/** The keys of a flat component that are not props (round 1 adds `visible`). */
+export declare const RESERVED_KEYS: readonly string[];
+export interface ReduceOptions {
+    /** The surface's catalog: the core, the lite subset, the basic catalog or an extension's id. */
+    catalogId: string;
+    extensions?: readonly ExtensionDef[];
+    /** The root component id (A2UI: `root`). */
+    rootId?: string;
+    /** Expand macros (default true); false keeps the pre-expansion tree. */
+    expand?: boolean;
+    /** Record prop validation issues (default true). */
+    validate?: boolean;
+}
+export interface ReduceResult {
+    root: UiNode;
+    issues: ReduceIssue[];
+    /** Round 2 (docs/round-2-contract.md §4): the nodes a data `template`
+     *  renders per item, by component id, LIFTED out of the tree (a template
+     *  node listed as a child too never renders in place), validated and
+     *  expanded like the root; in discovery order. Absent without templates. */
+    templates?: Record<string, UiNode>;
+}
+/** A `visible` value is a boolean or a dynamic value (a binding or a call). */
+export declare function validVisible(value: unknown): value is Visible;
+export declare function childTemplate(value: WireChildTemplate): ChildTemplate;
+/** Reduce a flat component list. Children are resolved from the root down, so
+ *  components nothing references (a basic Button's consumed Text child) do
+ *  not appear. A missing or cyclic reference becomes an Unknown placeholder
+ *  plus an issue. VAPP-103: an id placed a second time (two parents, or one
+ *  parent twice) renders at its first place only (`id used twice`), a node
+ *  deeper than `maxDepth` is an Unknown placeholder, and past
+ *  `maxComponents` nodes the rest is dropped (catalog/limits.json). */
+export declare function reduceSurface(components: readonly FlatComponent[], options: ReduceOptions): ReduceResult;
+/** A component's slot list admits a name when it lists it or lists `*`. */
+export declare function slotAllowed(slots: readonly string[] | undefined, name: string): boolean;
+/** The nested authoring form → a normalized tree (same validation and
+ *  expansion as reduceSurface). */
+export declare function reduceNested(tree: NestedNode, options: Omit<ReduceOptions, `rootId`>): ReduceResult;
+/** Pre-order ids of a tree, the painters' accessibility order. */
+export declare function preorder(root: UiNode): string[];

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

@@ -0,0 +1,38 @@
+/** One panel's limits (Resizable `panels[i]`), percent. */
+export interface PanelLimits {
+    min?: number;
+    max?: number;
+    /** Dragging below half its `min` collapses it to 0; Enter toggles. */
+    collapsible?: boolean;
+}
+export { PANEL_MIN, RESIZE_HANDLE_HIT, RESIZE_STEP } from "./layout.js";
+/** The sizes a group of `count` panels starts with: the valid given sizes
+ *  (finite, ≥ 0), the missing ones sharing what is left of 100 (equal split
+ *  when nothing is given), scaled to sum 100, then each clamped into its
+ *  [min, max] (a collapsible panel may stay at 0) with the difference handed
+ *  to the panels that still have room, in order. A `min` above 100 / count
+ *  is lowered to it. */
+export declare function normalizeSizes(sizes: readonly unknown[] | undefined, count: number, limits?: readonly PanelLimits[]): number[];
+/** Move handle `handle` (between panels `handle` and `handle + 1`) by
+ *  `delta` percentage points (positive = the first panel grows). Always
+ *  computed from the sizes at the START of a drag (no drift). The move is
+ *  clamped so both panels stay in their [min, max]; a collapsible panel
+ *  dragged below half its min collapses to 0 (the other takes its space, if
+ *  it can), and a collapsed one dragged past half its min reopens: at its
+ *  min, or where the pointer is when that is further (clamped as above).
+ *  Other panels never change. */
+export declare function resizePanels(sizes: readonly number[], handle: number, delta: number, limits?: readonly PanelLimits[]): number[];
+export type ResizeKey = `ArrowLeft` | `ArrowRight` | `ArrowUp` | `ArrowDown` | `Home` | `End` | `Enter`;
+/** A key on a focused handle. Arrows move the HANDLE on screen by
+ *  RESIZE_STEP (horizontal group: Left/Right — in rtl the first panel sits
+ *  on the right, so ArrowRight shrinks it; vertical group: Up/Down); Home /
+ *  End take the first panel to its min / max (as far as the second allows);
+ *  Enter collapses the first panel when collapsible (else the second),
+ *  reopening a collapsed one at its min. Other keys change nothing. */
+export declare function keyboardResize(sizes: readonly number[], handle: number, key: ResizeKey | string, orientation: `horizontal` | `vertical`, direction?: `ltr` | `rtl`, limits?: readonly PanelLimits[]): number[];
+/** Panel lengths in px on the main axis: the container minus every handle
+ *  (`handleExtent` each, `$control.hairline`), shared by the sizes. */
+export declare function panelExtents(sizes: readonly number[], container: number, handleExtent?: number): number[];
+/** A pointer movement (px on the main axis, screen direction) as the
+ *  percentage delta `resizePanels` takes (rtl horizontal groups flip it). */
+export declare function dragDelta(px: number, container: number, panelCount: number, orientation: `horizontal` | `vertical`, direction?: `ltr` | `rtl`, handleExtent?: number): number;

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

@@ -0,0 +1,7 @@
+import type { ExtensionDef } from "./types.js";
+type Json = Record<string, unknown>;
+/** The core catalog's JSON Schema. */
+export declare function coreSchema(iconNames: readonly string[]): Json;
+/** An extension's JSON Schema: its own id, `extends` the core, its components. */
+export declare function extensionSchema(ext: ExtensionDef, iconNames: readonly string[]): Json;
+export {};

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

@@ -0,0 +1,13 @@
+export declare const DEFAULT_STRINGS: Readonly<Record<string, string>>;
+export declare const STRING_IDS: readonly string[];
+/** `$string.choose` → `choose`; null for any other value. */
+export declare function parseStringRef(value: unknown): string | null;
+/** True for a well-formed reference to a KNOWN id. */
+export declare function isStringRef(value: unknown): boolean;
+/** The host's overrides merged over the defaults. */
+export declare function stringTable(overrides?: Readonly<Record<string, string>>): Record<string, string>;
+/** `{name}` placeholders filled from `params`; unknown ones stay. */
+export declare function formatString(template: string, params?: Record<string, unknown>): string;
+/** A prop value with any `$string.<id>` reference replaced by the table's
+ *  text (an unknown id resolves to the id itself); other values pass. */
+export declare function resolveString(value: unknown, table?: Readonly<Record<string, string>>): unknown;