@exponential_app/eui-react 0.0.0-stage → 0.2.1

package/dist/types/form.d.ts

@@ -0,0 +1,65 @@
+import { type ReactNode } from "react";
+import { joinIds } from "@exponential_app/eui/web";
+import type { NativeProps } from "./node-view.js";
+import { type PartFn } from "./natives/shared.js";
+export interface FieldHandle {
+    name: string;
+    domId: string;
+    value: () => unknown;
+    errors: () => string[];
+    focus: () => void;
+    element: () => HTMLElement | null;
+}
+export interface FormContextValue {
+    register: (field: FieldHandle) => () => void;
+    /** Run the checks and fire `submit` or `invalid`. */
+    submit: () => void;
+    /** A field's value changed (Form `change {name, value}`). */
+    changed: (name: string, value: unknown) => void;
+    disabled: boolean;
+    busy: boolean;
+    /** Bumps on every refused submit: every field shows its errors. */
+    attempts: number;
+}
+export declare const FormContext: import("react").Context<FormContextValue | null>;
+/** Round 4 (VAPP-103, `submitClosesOverlay`): the NEAREST overlay around a
+ *  Form decides — a dismissible Dialog or Drawer provides its close, every
+ *  other overlay (a Popover, a non-dismissible Dialog = AlertDialog)
+ *  provides null; a valid Form submit beneath calls it right after
+ *  `submit` (the author never resets the bound `open` flag). */
+export declare const CloseOnSubmitContext: import("react").Context<(() => void) | null>;
+export declare function useForm(): FormContextValue | null;
+export declare function FormNative({ node, props, rootProps, emit, children }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export interface FieldOptions {
+    node: NativeProps[`node`];
+    domId: string;
+    props: Record<string, unknown>;
+    /** The field's current (local) value. */
+    value: unknown;
+    /** The element focus moves to when the field is the first invalid one. */
+    focusRef: {
+        readonly current: HTMLElement | null;
+    };
+}
+export interface FieldState {
+    /** The messages to SHOW now (all failing checks once validation shows). */
+    errors: string[];
+    invalid: boolean;
+    /** `<field id>.error` — put it in the control's aria-describedby. */
+    errorId: string;
+    describedBy: string | undefined;
+    /** Report a blur / a change / an Enter submit. */
+    touch: () => void;
+    change: (value: unknown) => void;
+    submit: () => void;
+    form: FormContextValue | null;
+}
+/** A named control's validation + its registration with the nearest Form. */
+export declare function useField({ node, domId, props, value, focusRef }: FieldOptions): FieldState;
+/** Every failing message under a field, linked by `errorId`. */
+export declare function FieldErrors({ part, field }: {
+    part: PartFn;
+    field: FieldState;
+}): import("react/jsx-runtime").JSX.Element | null;
+export { joinIds };
+export type { ReactNode };

package/dist/types/host-surface.d.ts

@@ -0,0 +1,32 @@
+import type { ExponentialHost, TransportStatus } from "@exponential_app/eui";
+import type { HostPlugin } from "./host.js";
+import type { SurfaceState } from "./use-surface.js";
+import { type ExponentialSurfaceProps } from "./surface.js";
+/** The renderer callbacks that route through the host: actions become A2UI
+ *  client messages on its transport, host functions pass its policy gate,
+ *  every href its URL policy, every src its media policy + loader, paint
+ *  failures become `RENDER_FAILED` errors. `base` adds the rest (icons,
+ *  markdown, onInput…) and may observe actions first. */
+export declare function hostPlugin(host: ExponentialHost, base?: HostPlugin): HostPlugin;
+/** The ids of the host's surfaces, re-rendered as surfaces come and go. */
+export declare function useHostSurfaceIds(host: ExponentialHost): string[];
+/** The host's transport state (`host_offline` when not `open`) and the
+ *  catalog it could not render (the catalog-update banner). */
+export declare function useHostStatus(host: ExponentialHost): {
+    status: TransportStatus;
+    detail?: string;
+    unsupportedCatalog?: string;
+};
+/** One host surface as the `SurfaceState` `<ExponentialSurface>` paints. */
+export declare function useHostSurface(host: ExponentialHost, surfaceId: string): SurfaceState | null;
+export interface HostSurfaceProps extends Omit<ExponentialSurfaceProps, `surface` | `root` | `data` | `host`> {
+    host: ExponentialHost;
+    surfaceId: string;
+    /** Icons, markdown, input observers… (actions, functions, urls and media
+     *  route through the host). */
+    plugin?: HostPlugin;
+    /** Shown while the host has no surface with this id. */
+    fallback?: React.ReactNode;
+}
+/** A surface the host's transport feeds. */
+export declare function HostSurface({ host, surfaceId, plugin, fallback, ...rest }: HostSurfaceProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/host.d.ts

@@ -0,0 +1,37 @@
+import type { ComponentType, SVGProps } from "react";
+import type { UiNode, ResolvedTheme, ModeName } from "@exponential_app/eui";
+import type { HostPlugin as WebHostPlugin, IconMap as WebIconMap } from "@exponential_app/eui/web";
+export type { SurfaceActionEvent, SurfaceInputEvent, PaintError, SourceOption } from "@exponential_app/eui/web";
+/** An icon component the host maps a registry name to (`lucide-react`'s
+ *  `LucideIcon` shape fits). */
+export type IconComponent = ComponentType<SVGProps<SVGSVGElement> & {
+    size?: number | string;
+    className?: string;
+}>;
+export type IconMap = WebIconMap<IconComponent>;
+/** The host plugin on React: icons are React components, `Markdown` a
+ *  React component taking `{text, className}`. */
+export type HostPlugin = WebHostPlugin<IconComponent, ComponentType<{
+    text: string;
+    className?: string;
+}>>;
+/** What an extension component receives: the node, its props resolved, the
+ *  theme and mode, the rendered children, and an emitter for its events. */
+export interface ExtensionComponentProps {
+    node: UiNode;
+    props: Record<string, unknown>;
+    theme: ResolvedTheme;
+    mode: ModeName;
+    tokens: ResolvedTheme[`tokens`];
+    /** The node's children, already rendered. */
+    children?: React.ReactNode;
+    /** Rendered slots by name. */
+    slots: Record<string, React.ReactNode>;
+    /** Fire one of the node's `on` handlers. `own` = what the component
+     *  just WROTE, by prop (`{value: "ship"}`): the action resolves against
+     *  the data with it applied (round 4 own write), never inferred from the
+     *  payload. */
+    emit: (event: string, payload?: Record<string, unknown>, own?: Record<string, unknown>) => void;
+    /** The element attributes the renderer wants on the root (classes, data). */
+    rootProps: Record<string, unknown>;
+}

package/dist/types/icons.d.ts

@@ -0,0 +1,31 @@
+import type { SVGProps } from "react";
+import type { IconComponent, IconMap } from "./host.js";
+/** The renderer's own chrome glyphs that are NOT catalog part glyphs (the
+ *  busy spinner, media play, the field and picker adornments). */
+export declare const CHROME: {
+    readonly check: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly chevronDown: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly chevronUp: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly chevronLeft: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly chevronRight: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly close: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly search: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly calendar: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly send: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly stop: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly play: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly attach: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly spinner: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly placeholder: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+};
+/** icons.json concept / registry names → the Lucide glyph icons.json gives
+ *  them (`semantic`), for every name the catalog's `builtinIcons` and the
+ *  core macros draw. */
+export declare const FALLBACK_ICONS: Record<string, IconComponent>;
+export declare function resolveIcon(icons: IconMap | undefined, name: string): IconComponent | undefined;
+export declare function IconGlyph({ icons, name, size, className, ...rest }: {
+    icons?: IconMap;
+    name: string;
+    size?: number;
+    className?: string;
+} & SVGProps<SVGSVGElement>): import("react/jsx-runtime").JSX.Element;

package/dist/types/index.d.ts

@@ -0,0 +1,37 @@
+export { ExponentialSurface, resolveThemeInput, surfaceTheme } from "./surface.js";
+export type { ExponentialSurfaceProps, ThemeInput, SurfaceHandle } from "./surface.js";
+export { useSurface } from "./use-surface.js";
+export type { A2uiMessage, SurfaceState, UseSurfaceOptions } from "./use-surface.js";
+export { registerExtension, defineReactExtension, registeredExtensions, extensionCatalogs } from "./extensions.js";
+export type { ReactExtension, ExtensionComponent, RegisterExtensionOptions } from "./extensions.js";
+export type { HostPlugin, IconComponent, IconMap, PaintError, SurfaceActionEvent, SurfaceInputEvent, ExtensionComponentProps, SourceOption } from "./host.js";
+export { compileTheme, compiledTheme, themeScope, partClass, propAttribute, tokenVar, tokenVarName, cssValue, declarations, ruleSelectors, STATE_SELECTORS, LAYERS } from "@exponential_app/eui/web";
+export type { CompiledTheme } from "@exponential_app/eui/web";
+export { nodeSheet, compileNodeSheet, dynamicStyleEntries, queryToken, nodeClass, surfaceClass, walkNodes } from "@exponential_app/eui/web";
+export type { NodeSheet, DynamicStyleEntry } from "@exponential_app/eui/web";
+export { BASE_CSS } from "@exponential_app/eui/web";
+export { getPointer, setPointer, absolutePath, resolveValue, resolveProps, resolveNodeProps, resolveVisible, bindTree, boundPath, isBinding, isCall, hasDynamic, memoFormatter, CLIENT_FUNCTIONS } from "@exponential_app/eui/web";
+export type { DataModel, DataBinding, FunctionCall, ClientFunction, ResolveContext } from "@exponential_app/eui/web";
+export { useHostOwnedValue, DEBOUNCE_MS } from "./inputs.js";
+export type { HostOwnedOptions, HostOwnedValue } from "./inputs.js";
+export { WindowedList } from "./list.js";
+export type { WindowedListProps, WindowedListHandle } from "./list.js";
+export { NodeView, useRootProps, useEmitter, runNodeAction, templateItems, itemInstance, mergeStyle } from "./node-view.js";
+export type { NativeProps, TemplateItem } from "./node-view.js";
+export { NATIVES, NATIVE_NAMES } from "./natives/index.js";
+export { useSurfaceContext, SurfaceContext, ScopeContext, InstanceContext } from "./context.js";
+export type { SurfaceContextValue } from "./context.js";
+export { IconGlyph, resolveIcon, FALLBACK_ICONS } from "./icons.js";
+export { BuiltinMarkdown, renderMarkdown } from "./markdown.js";
+export { useParts, str, num, bool, arr, BuiltinIcon, builtinIconName, failingChecks } from "./natives/shared.js";
+export { FormContext, useForm, useField } from "./form.js";
+export type { FieldHandle, FormContextValue, FieldState } from "./form.js";
+export { useMediaQuery, useElementSize } from "./platform.js";
+export { sortRows } from "./natives/table.js";
+export { parseLocaleNumber } from "./natives/inputs.js";
+export { acceptsFile } from "./natives/chips.js";
+export { monthGrid } from "./natives/dates.js";
+export { HostSurface, hostPlugin, useHostSurface, useHostSurfaceIds, useHostStatus } from "./host-surface.js";
+export type { HostSurfaceProps } from "./host-surface.js";
+export { useMediaSource, useMediaSrc, clearMediaCache, mediaCacheStats, fetchLimited, MEDIA_CACHE_IDLE_MAX } from "./media.js";
+export { linkHref, mediaRequestOf, urlPolicyOf } from "@exponential_app/eui/web";

package/dist/types/inputs.d.ts

@@ -0,0 +1,25 @@
+import { DEBOUNCE_MS } from "@exponential_app/eui/web";
+export { DEBOUNCE_MS };
+export interface HostOwnedOptions<T> {
+    /** The value the host currently holds (resolved prop or data model). */
+    external: T;
+    /** Sends an edit; a returned promise acknowledges the revision on settle. */
+    send: (value: T, revision: number, kind: `change` | `commit`) => void | Promise<void>;
+    /** Optional local write-through (the bound data model path). */
+    writeLocal?: (value: T) => void;
+    debounceMs?: number;
+}
+export interface HostOwnedValue<T> {
+    value: T;
+    revision: number;
+    /** True while a revision the host has not acknowledged exists. */
+    pending: boolean;
+    focused: boolean;
+    onFocus: () => void;
+    onBlur: () => void;
+    /** A local edit. */
+    edit: (next: T) => void;
+    /** Flush the debounce and send a `commit`. */
+    commit: () => void;
+}
+export declare function useHostOwnedValue<T>({ external, send, writeLocal, debounceMs }: HostOwnedOptions<T>): HostOwnedValue<T>;

package/dist/types/list.d.ts

@@ -0,0 +1,31 @@
+import { type ReactNode } from "react";
+import { type ScrollAlign } from "@exponential_app/eui";
+import { scrollParent, type ListAxis } from "@exponential_app/eui/web";
+export type { ListAxis };
+export interface WindowedListProps {
+    count: number;
+    itemKey: (index: number) => string;
+    renderItem: (index: number) => ReactNode;
+    /** The extent (px on the axis) of a row before it is measured. */
+    estimatedItemHeight?: number | ((index: number) => number);
+    overscan?: number;
+    className?: string;
+    axis?: ListAxis;
+    /** Inline direction (a horizontal list starts at the right in rtl). */
+    direction?: `ltr` | `rtl`;
+    /** Space between rows on the axis (px; a divided list adds the hairline). */
+    gap?: number;
+    /** A divider drawn centred in the gap BEFORE row `index` (null = none). */
+    divider?: (index: number) => ReactNode | null;
+    /** Flat indices of the header rows that pin (ascending). */
+    stickyRows?: readonly number[];
+    /** Extra attributes of row `index`'s wrapper (role, aria-setsize…). */
+    itemProps?: (index: number) => Record<string, unknown>;
+}
+export interface WindowedListHandle {
+    /** Scroll row `index` into view (`start` | `center` | `end` | `nearest`,
+     *  default nearest), the pinned header's extent subtracted. */
+    scrollToIndex: (index: number, align?: ScrollAlign) => void;
+}
+export { scrollParent };
+export declare const WindowedList: import("react").ForwardRefExoticComponent<WindowedListProps & import("react").RefAttributes<WindowedListHandle>>;

package/dist/types/live.d.ts

@@ -0,0 +1,18 @@
+import type { ExtensionDef, UiNode } from "@exponential_app/eui";
+import type { SurfaceContextValue } from "./context.js";
+export interface NodeDeps {
+    paths: string[];
+    /** `paths` as pointer tokens (read on every change of every node). */
+    tokens: string[][];
+    /** Re-render on any data change. */
+    all: boolean;
+    breakpoint: boolean;
+    xq: boolean;
+    mode: boolean;
+}
+/** The props of a component marked `responsive: true` in the catalog. */
+export declare function responsiveProps(component: string, extensions: readonly ExtensionDef[]): string[];
+export declare function nodeDeps(node: UiNode, scope: string, ctx: SurfaceContextValue): NodeDeps;
+/** The live values a node reads, as one array that keeps its identity
+ *  until one of them changes (the node's re-render key). */
+export declare function useLive(ctx: SurfaceContextValue, node: UiNode, scope: string): readonly unknown[];

package/dist/types/markdown.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from "react";
+import type { HostPlugin } from "./host.js";
+export { MAX_LINK_NESTING, MAX_LINK_DEST, MAX_BLOCK_NESTING, linkAt, wholeImage, parseList } from "@exponential_app/eui/web";
+export declare function renderMarkdown(text: string, host?: HostPlugin): ReactNode[];
+export declare function BuiltinMarkdown({ text, className, host }: {
+    text: string;
+    className?: string;
+    host?: HostPlugin;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/media.d.ts

@@ -0,0 +1,15 @@
+import { type MediaKind } from "@exponential_app/eui/web";
+import type { HostPlugin } from "./host.js";
+export { clearMediaCache, fetchLimited, fetchStream, mediaCacheStats, MEDIA_CACHE_IDLE_MAX } from "@exponential_app/eui/web";
+export type { MediaKind } from "@exponential_app/eui/web";
+/** A media source's state: the url to use (undefined while a fetched one
+ *  loads or after it failed) and whether the fetch failed (so an Image can
+ *  show its fallback; an <img> never sees a failed fetch). A src the media
+ *  policy denies has no url and `error`. */
+export declare function useMediaSource(host: HostPlugin, src: string, kind?: MediaKind): {
+    url: string | undefined;
+    error: boolean;
+};
+/** The src an element should use, or undefined while a fetched one loads
+ *  (or after it failed). */
+export declare function useMediaSrc(host: HostPlugin, src: string, kind?: MediaKind): string | undefined;

package/dist/types/natives/actions.d.ts

@@ -0,0 +1,10 @@
+import type { NativeProps } from "../node-view.js";
+export declare function usePending(): {
+    pending: boolean;
+    track: (result: void | Promise<void>) => void;
+};
+export declare function ButtonNative({ node, props, rootProps, emit, children }: NativeProps): import("react/jsx-runtime").JSX.Element;
+/** `loading` held for `PENDING_DELAY_MS` (false again at once when it ends). */
+export declare function usePendingShown(loading: boolean): boolean;
+export declare function LinkNative({ props, rootProps, emit }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function ToggleNative({ node, props, rootProps, emit, scope }: NativeProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/natives/bound.d.ts

@@ -0,0 +1,2 @@
+import type { NativeProps } from "../node-view.js";
+export declare function useBoundState<T>(node: NativeProps[`node`], scope: string, prop: string, external: T, key?: (v: T) => string): [T, (next: T, written?: unknown) => void, string | undefined];

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

@@ -0,0 +1,2 @@
+import type { NativeProps } from "../node-view.js";
+export declare function ChartNative({ node, props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/natives/chips.d.ts

@@ -0,0 +1,5 @@
+import type { NativeProps } from "../node-view.js";
+import { acceptsFile } from "@exponential_app/eui/web";
+export { acceptsFile };
+export declare function ChipInputNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function FileUploadNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/natives/choice-tiles.d.ts

@@ -0,0 +1,2 @@
+import type { NativeProps } from "../node-view.js";
+export declare function ChoiceTilesNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+import type { NativeProps } from "../node-view.js";
+export declare function CodeBlockNative({ node, props, rootProps, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/natives/dates.d.ts

@@ -0,0 +1,29 @@
+import type { Formatter } from "@exponential_app/eui";
+import type { NativeProps } from "../node-view.js";
+import { type PartFn } from "./shared.js";
+import { calendarStop, isoDate, monthGrid, parseIsoDate } from "@exponential_app/eui/web";
+export { calendarStop, isoDate, monthGrid, parseIsoDate };
+interface CalendarProps {
+    part: PartFn;
+    dayPart: `day`;
+    locale: string;
+    /** The surface Formatter: month and weekday names, day labels (round 2 §3). */
+    formatter: Formatter;
+    firstDay: number;
+    min: Date | null;
+    max: Date | null;
+    /** Days drawn selected. */
+    isSelected: (d: Date) => boolean;
+    /** Days drawn inside a range (DateRangePicker). */
+    inRange?: (d: Date) => boolean;
+    initial: Date;
+    onPick: (d: Date) => void;
+    t: (id: string) => string;
+    /** The SURFACE direction (never the document's): ArrowLeft/Right mirror in
+     *  RTL, like the grid. */
+    direction?: `ltr` | `rtl`;
+}
+export declare function CalendarGrid({ part, dayPart, formatter, firstDay, min, max, isSelected, inRange, initial, onPick, t, direction }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+export declare function DatePickerNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function DateRangePickerNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function TimePickerNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/natives/feedback.d.ts

@@ -0,0 +1,29 @@
+import type { NativeProps } from "../node-view.js";
+export declare function RingNative({ node, props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function SpinnerNative({ props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;
+/** Skeleton: one pulsing block, or (EXP-1259, feedback-states.json
+ *  `placeholder`) `rows` placeholder rows in the row geometry: each a `dot`
+ *  (unless `dot: false`) and two `bar`s, hairline-divided; the root paints
+ *  nothing itself, the pieces pulse (base CSS). */
+export declare function SkeletonNative({ node, props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;
+/** TreeGuides (round 3, a Row's `guides` part the CORE fills: `elbowAt`,
+ *  `tee`, `passThrough` arrive computed): `depth` columns of
+ *  `TREE_GUIDE_COLUMN` (14) px; column i's line sits at its centre
+ *  (x = i·14 + 7). The elbow = ONE element whose left + bottom borders are
+ *  the vertical (from `TREE_GUIDE_BRIDGE` px above the row's top to its
+ *  centre) and the stub (to the column's right edge), the corner rounded by
+ *  `TREE_GUIDE_RADIUS`; `tee` and pass-through columns = full-height
+ *  verticals from the same bridge (paint only: the overshoot covers a
+ *  Section's hairline divider, never layout). Stroke width + colour = the
+ *  `TreeGuides/line` recipe. Physical x (the gutter is not mirrored). */
+export declare function TreeGuidesNative({ node, props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;
+/** NEW-77: VoiceWave (catalog/style.json `voiceWave`): one SVG of three
+ *  closed waves, the core's `voiceWave` per frame, each ring filled and
+ *  stroked in its part's recipe colour at the ring's alphas; the root
+ *  recipe sizes the box and sets the opacity (CSS); the ONE child sits
+ *  centred at its own size, drawn scaled about the centre by
+ *  `voiceWaveChildBox` (never up; at `sm` kept but unpainted). While
+ *  listening, thinking or speaking (and not under reduced motion) the
+ *  frames write the paths' `d` directly, never a re-render; the elapsed
+ *  seconds count from the moment the wave started moving. */
+export declare function VoiceWaveNative(p: NativeProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,4 @@
+import type { ComponentType } from "react";
+import type { NativeProps } from "../node-view.js";
+export declare const NATIVES: Record<string, ComponentType<NativeProps>>;
+export declare const NATIVE_NAMES: readonly string[];

package/dist/types/natives/inputs.d.ts

@@ -0,0 +1,19 @@
+import { CHROME } from "../icons.js";
+import type { NativeProps } from "../node-view.js";
+import { mergeStyle } from "../node-view.js";
+import { parseLocaleNumber } from "@exponential_app/eui/web";
+export declare function useInputSender(node: NativeProps[`node`], scope: string, prop: string, domId?: string): {
+    send: (value: unknown, revision: number, kind: `change` | `commit`) => void | Promise<void> | undefined;
+    writeLocal: ((value: unknown) => void) | undefined;
+    path: string | undefined;
+    name: string;
+};
+export declare function InputNative(p: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function TextareaNative(p: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function NumberFieldNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function CheckboxNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function SwitchNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function RadioNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function SliderNative({ node, props, rootProps, emit, scope }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function ComposerNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export { CHROME, mergeStyle, parseLocaleNumber };

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

@@ -0,0 +1,15 @@
+import type { NativeProps } from "../node-view.js";
+export declare function BoxNative({ node, props, rootProps, emit, children }: NativeProps): import("react/jsx-runtime").JSX.Element;
+/** Past this many items a List windows (fewer render flat, so fixtures
+ *  snapshot every row). The catalog's number (`layout.json`). */
+export declare const WINDOW_THRESHOLD: number;
+/** List (round 2 §5): children then the data template's items; `sectionBy`
+ *  groups consecutive template items under a `section` header (the slot,
+ *  bound once per section with the literal scope `{value, count, index}`,
+ *  else the value); past `WINDOW_THRESHOLD` items, or with `stickyHeaders`,
+ *  the list WINDOWS on its axis (vertical or horizontal) against its own
+ *  scroll, the nearest scroller or the viewport. Every item is a listitem
+ *  with its position in the whole list; `scrollToIndex` (the host command)
+ *  takes the data index. */
+export declare function ListNative({ node, props, rootProps, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function UnknownNative({ node, props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/natives/listbox.d.ts

@@ -0,0 +1,15 @@
+import { type KeyboardEvent } from "react";
+export interface ListNavOptions {
+    count: number;
+    isDisabled?: (index: number) => boolean;
+    labelOf?: (index: number) => string;
+    onPick: (index: number) => void;
+    /** Type-ahead (off when a search field owns the keys). */
+    typeahead?: boolean;
+    initial?: number;
+}
+export declare function useListNavigation({ count, isDisabled, labelOf, onPick, typeahead, initial }: ListNavOptions): {
+    active: number;
+    setActive: import("react").Dispatch<import("react").SetStateAction<number>>;
+    onKeyDown: (e: KeyboardEvent) => void;
+};

package/dist/types/natives/media.d.ts

@@ -0,0 +1,13 @@
+import type { NativeProps } from "../node-view.js";
+/** Image (contract §3): `loading` lazy|eager, `focalX/focalY` (0..1, the
+ *  point kept when the picture is cropped → `object-position`), and the
+ *  `fallback` icon (default `builtinIcons["Image.fallback"]`) on error or
+ *  without a src; `data-state` = loading | loaded | error | empty. */
+export declare function ImageNative({ node, props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function VideoNative({ node, props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function AudioPlayerNative({ node, props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;
+/** A stable hue for a seed (the app's avatar palette is host-side; the SDK
+ *  tints with one hue so two avatars of one person always match). */
+export declare function seedHue(seed: string): number;
+export declare function AvatarNative({ node, props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function CarouselNative({ node, props, rootProps, emit, scope }: NativeProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/natives/nav.d.ts

@@ -0,0 +1,17 @@
+import type { NativeProps } from "../node-view.js";
+export declare function TabsNative({ node, props, rootProps, emit, scope }: NativeProps): import("react/jsx-runtime").JSX.Element;
+/** Segmented (round 3): ONE row of segments.
+ *  `segmented` (default, the pill track) / `toggles` (bare) / `outline`
+ *  (joined) = a Radix ToggleGroup (radiogroup single, toolbar of toggle
+ *  buttons multiple; roving tab stop, arrows wrap, Home/End). `bar` = the
+ *  full-width bottom destinations: role navigation, each item a column
+ *  button (icon above a caption label), the selected one
+ *  `aria-current="page"`, the same roving keys. Parts: root, item, icon,
+ *  label (the selected state rides every part of the selected item).
+ *  VAPP-162 (round-5 contract §3): `orientation: vertical` stacks every
+ *  variant top to bottom (ArrowUp/ArrowDown move focus); a vertical `bar`
+ *  is THE navigation rail (72 px items). A `bar` item's `count` paints the
+ *  `badge` at its icon's top-end corner (`99+` above 99, none at 0) and
+ *  reads after the label (`Chats, 3`). */
+export declare function SegmentedNative({ node, props, rootProps, emit, scope }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function AccordionNative({ node, props, rootProps, emit, scope }: NativeProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/natives/overlays.d.ts

@@ -0,0 +1,17 @@
+import type { NativeProps } from "../node-view.js";
+export declare function DialogNative(p: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function DrawerNative(p: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function PopoverNative({ node, props, rootProps, emit, children, slots, scope }: NativeProps): import("react/jsx-runtime").JSX.Element;
+/** Tooltip: shows on hover AND keyboard focus (a11y.json), Escape hides. */
+export declare function TooltipNative({ node, props, rootProps, children }: NativeProps): import("react/jsx-runtime").JSX.Element;
+/** Menu: `openOn: press` (default) = a Radix DropdownMenu, its ONE child the
+ *  trigger (no child = the default outline Button from label/icon, no
+ *  chevron), anchored bottom-start; `openOn: contextmenu` = a Radix
+ *  ContextMenu over the child (right-click / long-press / Shift+F10 / the
+ *  Menu key), opened at the pointer (the child's corner from the keyboard). */
+export declare function MenuNative(p: NativeProps): import("react/jsx-runtime").JSX.Element;
+/** Toast (contract §3): in the TOAST layer, newest nearest the edge, at most
+ *  3 visible (base CSS). The renderer runs `duration` (0 = sticky), PAUSED
+ *  while hovered or focused, then writes `open: false` and fires `dismiss`
+ *  + `change`. `error` is assertive, the rest polite; never takes focus. */
+export declare function ToastNative({ node, props, rootProps, emit, scope }: NativeProps): import("react").ReactPortal | null;

package/dist/types/natives/qr.d.ts

@@ -0,0 +1,3 @@
+import type { NativeProps } from "../node-view.js";
+export declare function QrCodeNative({ node, props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function QrScannerNative({ node, props, rootProps, emit }: NativeProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+import type { NativeProps } from "../node-view.js";
+export declare function ResizableNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/natives/search.d.ts

@@ -0,0 +1,46 @@
+import { type ReactNode } from "react";
+import type { NativeProps } from "../node-view.js";
+import { type PartFn } from "./shared.js";
+export interface SearchItem {
+    label: string;
+    value: string;
+    icon?: string;
+    identifier?: string;
+    disabled?: boolean;
+}
+/** Does a row match the query (case-insensitive, label or identifier)?
+ *  The core's `search_matches`. */
+export declare function searchMatches(item: Pick<SearchItem, `label` | `identifier`>, query: string): boolean;
+export interface SearchBodyProps {
+    part: PartFn;
+    /** Whose body this is (a SearchList, or a Menu's searchable submenu). */
+    owner: `SearchList` | `Menu`;
+    /** `""` for a SearchList, `.<i>` for submenu `i` (the core's suffix). */
+    suffix: string;
+    /** The rows ALREADY filtered, each with its index in the full list. */
+    rows: {
+        index: number;
+        item: SearchItem;
+    }[];
+    query: string;
+    onQuery: (query: string) => void;
+    placeholder: string;
+    emptyText: string;
+    maxRows: number;
+    showCount: boolean;
+    picked?: string;
+    onPick: (item: SearchItem) => void;
+    autoFocus?: boolean;
+    /** ← with the caret at the start leaves the field's key to the menu (a
+     *  searchable submenu closes back to its row). */
+    leaveBubbles?: boolean;
+    /** The rows' recipe part (`item`) and the row id prefix. */
+    rowPart?: (item: SearchItem, index: number, active: boolean) => Record<string, string>;
+    renderRow?: (item: SearchItem, index: number) => ReactNode;
+}
+export declare function SearchBody({ part, owner, suffix, rows, query, onQuery, placeholder, emptyText, maxRows, showCount, picked, onPick, autoFocus, leaveBubbles, rowPart, renderRow }: SearchBodyProps): import("react/jsx-runtime").JSX.Element;
+/** SearchList: the field filters the rows locally (label or identifier)
+ *  unless the host searches itself (`on.search`, its rows arrive through
+ *  the bound `items`); `search {query}` fires 150 ms after the last
+ *  keystroke; a pick writes the bound `value` and fires `select {value}`. */
+export declare function SearchListNative({ node, props, rootProps, emit, scope }: NativeProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/natives/select.d.ts

@@ -0,0 +1,8 @@
+import type { NativeProps } from "../node-view.js";
+export interface SelectOption {
+    label: string;
+    value: string;
+    icon?: string;
+    disabled?: boolean;
+}
+export declare function SelectNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;