@prestack/thread-ui 0.0.1

package/dist/ui/variants/var_skeleton-block.js

@@ -0,0 +1,11 @@
+import { variant } from "../variant.js";
+export const SKELETON_BLOCK = variant({
+    id: 'skeleton-block',
+    sets: [
+        { property: 'background', is: 'colour-sunken' },
+        { property: 'borderRadius', is: 'radius-sm' },
+        { property: 'minHeight', is: 'control-sm' },
+        { property: 'animation', is: 'animation-waiting' },
+    ],
+    reacts: [],
+});

package/dist/ui/variants/var_spinner-turning.d.ts

@@ -0,0 +1,17 @@
+export declare const SPINNER_TURNING: {
+    readonly id: "spinner-turning";
+    readonly sets: readonly [{
+        readonly property: "width";
+        readonly is: "icon-md";
+    }, {
+        readonly property: "height";
+        readonly is: "icon-md";
+    }, {
+        readonly property: "color";
+        readonly is: "colour-accent";
+    }, {
+        readonly property: "animation";
+        readonly is: "animation-working";
+    }];
+    readonly reacts: readonly [];
+};

package/dist/ui/variants/var_spinner-turning.js

@@ -0,0 +1,11 @@
+import { variant } from "../variant.js";
+export const SPINNER_TURNING = variant({
+    id: 'spinner-turning',
+    sets: [
+        { property: 'width', is: 'icon-md' },
+        { property: 'height', is: 'icon-md' },
+        { property: 'color', is: 'colour-accent' },
+        { property: 'animation', is: 'animation-working' },
+    ],
+    reacts: [],
+});

package/dist/ui/variants/var_stat-tile.d.ts

@@ -0,0 +1,18 @@
+export declare const STAT_TILE: {
+    readonly id: "stat-tile";
+    readonly material: "flat";
+    readonly sets: readonly [{
+        readonly property: "color";
+        readonly is: "colour-ink";
+    }, {
+        readonly property: "borderRadius";
+        readonly is: "radius-md";
+    }, {
+        readonly property: "padding";
+        readonly is: "space-4";
+    }, {
+        readonly property: "gap";
+        readonly is: "space-2";
+    }];
+    readonly reacts: readonly ["focus", "hover"];
+};

package/dist/ui/variants/var_stat-tile.js

@@ -0,0 +1,12 @@
+import { variant } from "../variant.js";
+export const STAT_TILE = variant({
+    id: 'stat-tile',
+    material: 'flat',
+    sets: [
+        { property: 'color', is: 'colour-ink' },
+        { property: 'borderRadius', is: 'radius-md' },
+        { property: 'padding', is: 'space-4' },
+        { property: 'gap', is: 'space-2' },
+    ],
+    reacts: ['focus', 'hover'],
+});

package/dist/ui/variants/var_tab-bar.d.ts

@@ -0,0 +1,24 @@
+export declare const TAB_BAR: {
+    readonly id: "tab-bar";
+    readonly material: "flat";
+    readonly sets: readonly [{
+        readonly property: "color";
+        readonly is: "colour-ink";
+    }, {
+        readonly property: "borderRadius";
+        readonly is: "radius-lg";
+    }, {
+        readonly property: "minHeight";
+        readonly is: "control-md";
+    }, {
+        readonly property: "padding";
+        readonly is: "space-1";
+    }, {
+        readonly property: "gap";
+        readonly is: "space-1";
+    }, {
+        readonly property: "transition";
+        readonly is: "motion-quick ease-out";
+    }];
+    readonly reacts: readonly ["focus", "hover"];
+};

package/dist/ui/variants/var_tab-bar.js

@@ -0,0 +1,14 @@
+import { variant } from "../variant.js";
+export const TAB_BAR = variant({
+    id: 'tab-bar',
+    material: 'flat',
+    sets: [
+        { property: 'color', is: 'colour-ink' },
+        { property: 'borderRadius', is: 'radius-lg' },
+        { property: 'minHeight', is: 'control-md' },
+        { property: 'padding', is: 'space-1' },
+        { property: 'gap', is: 'space-1' },
+        { property: 'transition', is: 'motion-quick ease-out' },
+    ],
+    reacts: ['focus', 'hover'],
+});

package/dist/ui/variants/var_tap-target.d.ts

@@ -0,0 +1,33 @@
+export declare const TAP_TARGET: {
+    readonly id: "tap-target";
+    readonly sets: readonly [{
+        readonly property: "borderRadius";
+        readonly is: "radius-md";
+    }];
+    readonly states: readonly [{
+        readonly when: readonly ["tapped"];
+        readonly sets: readonly [{
+            readonly property: "animation";
+            readonly is: "animation-flash";
+        }];
+    }, {
+        readonly when: readonly ["pressing"];
+        readonly sets: readonly [{
+            readonly property: "animation";
+            readonly is: "animation-press";
+        }];
+    }, {
+        readonly when: readonly ["carrying", "pressing"];
+        readonly sets: readonly [{
+            readonly property: "animation";
+            readonly is: "animation-hover-lift";
+        }];
+    }, {
+        readonly when: readonly ["carrying"];
+        readonly sets: readonly [{
+            readonly property: "animation";
+            readonly is: "animation-hover-lift";
+        }];
+    }];
+    readonly reacts: readonly ["tapped", "pressing", "carrying"];
+};

package/dist/ui/variants/var_tap-target.js

@@ -0,0 +1,24 @@
+import { variant } from "../variant.js";
+export const TAP_TARGET = variant({
+    id: 'tap-target',
+    sets: [{ property: 'borderRadius', is: 'radius-md' }],
+    states: [
+        {
+            when: ['tapped'],
+            sets: [{ property: 'animation', is: 'animation-flash' }],
+        },
+        {
+            when: ['pressing'],
+            sets: [{ property: 'animation', is: 'animation-press' }],
+        },
+        {
+            when: ['carrying', 'pressing'],
+            sets: [{ property: 'animation', is: 'animation-hover-lift' }],
+        },
+        {
+            when: ['carrying'],
+            sets: [{ property: 'animation', is: 'animation-hover-lift' }],
+        },
+    ],
+    reacts: ['tapped', 'pressing', 'carrying'],
+});

package/dist/ui/variants.d.ts

@@ -0,0 +1,174 @@
+export declare const VARIANTS: {
+    readonly id: "variant";
+    readonly at: "thread/ui/variants.ts";
+    readonly files: "ui/var_*.ts";
+    readonly describes: "How a thing looks: a material plus the style guide values it names directly, never raw ones, and how that look changes under a state. It says nothing about type, because typography belongs to the role the wording states; what is left here is the look of the box and the colour of what sits in it. Each row names a file prefixed `var_`, and that file is the variant: what it looks like, what it looks like under a state, and which states it reacts to. The row states which elements accept it, and it is worn as the tag, so a variant `button-fill` is written `<Button.buttonFill>` and an element nothing declares is refused. A state is the set of signals holding at once, and two states that can both hold and both set one property must have their combination declared, or which one wins is an accident of file order. An app adds its own to this same list, and a row that goes missing breaks the build, because what the framework offers is not an app’s to withdraw.";
+    readonly version: 1;
+    readonly cites: readonly [{
+        readonly on: "2026-08-24";
+        readonly said: "Variants define lots of things. Including how they look in different states. Including how they look in multiple states at once. (hover, pressed) is one variant that covers both hover and pressed, so they look the same when they are simultaneous. (hover) (pressed) (hover, pressed) however have different states for the three situations.";
+    }, {
+        readonly on: "2026-08-25";
+        readonly said: "Variants basically say: This is how I look. These are the elements that accept me. These are my behaviours under different states. These are the states I can react to.";
+    }, {
+        readonly on: "2026-08-28";
+        readonly said: "fonts.ts as SSOT for everything related to fonts and easy to change fonts throughout the app like tokens, like....the exact same reason for existing that tokens+styleguide have is the same reason we have fonts.ts";
+    }];
+    readonly declares: readonly [{
+        readonly id: "card";
+        readonly section: "surface";
+        readonly at: string;
+        readonly wears: readonly ["Accordion", "Bars", "Box", "Donut", "Empty", "Funnel", "Heatmap", "LineChart", "Media", "Menu", "Scatter", "Sparkline", "Surface", "Table", "Tooltip"];
+        readonly describes: "A surface holding other content, and the shape every unregistered variant falls back to.";
+    }, {
+        readonly id: "list-row";
+        readonly section: "surface";
+        readonly at: string;
+        readonly wears: readonly ["Box"];
+        readonly describes: "One row of a list — square, quiet, and separated by its neighbours rather than by a shadow.";
+    }, {
+        readonly id: "framed";
+        readonly section: "surface";
+        readonly at: string;
+        readonly wears: readonly ["Image", "Media", "AspectRatio"];
+        readonly describes: "A picture given the same corners as a panel, on a sunken ground so the gap before it loads is not a white hole.";
+    }, {
+        readonly id: "bubble-them";
+        readonly section: "surface";
+        readonly at: string;
+        readonly wears: readonly ["Box"];
+        readonly describes: "A message somebody else sent. The plain half of a conversation.";
+    }, {
+        readonly id: "bubble-me";
+        readonly section: "surface";
+        readonly at: string;
+        readonly wears: readonly ["Box"];
+        readonly describes: "A message the current person sent. Takes the accent, which is how a conversation reads as two voices without a second colour role.";
+    }, {
+        readonly id: "button-fill";
+        readonly section: "button";
+        readonly at: string;
+        readonly wears: readonly ["Button"];
+        readonly describes: "The one action a screen is asking for. The accent behind it, and the only button on a screen that should carry it.";
+    }, {
+        readonly id: "button-normal";
+        readonly section: "button";
+        readonly at: string;
+        readonly wears: readonly ["Button"];
+        readonly describes: "The ordinary button. A surface with a hairline round it — pressable, and asking for nothing in particular.";
+    }, {
+        readonly id: "button-ghost";
+        readonly section: "button";
+        readonly at: string;
+        readonly wears: readonly ["Button"];
+        readonly describes: "Wording that acts. No ground and no line until a pointer is over it, which is what keeps a row of them from reading as a wall of boxes.";
+    }, {
+        readonly id: "button-border";
+        readonly section: "button";
+        readonly at: string;
+        readonly wears: readonly ["Button"];
+        readonly describes: "An action offered beside a filled one. The accent as an edge rather than a ground, so the shape says pressable and the colour says not this one.";
+    }, {
+        readonly id: "button-destructive";
+        readonly section: "button";
+        readonly at: string;
+        readonly wears: readonly ["Button"];
+        readonly describes: "Something that cannot be undone. The same shape as the asking button, in the colour reserved for consequence.";
+    }, {
+        readonly id: "button-destructive-ghost";
+        readonly section: "button";
+        readonly at: string;
+        readonly wears: readonly ["Button"];
+        readonly describes: "A destructive action that is not the point of the screen — delete, sitting quietly at the end of a menu. Carries the negative as ink and gains a ground only under a pointer.";
+    }, {
+        readonly id: "button-cta";
+        readonly section: "button";
+        readonly at: string;
+        readonly wears: readonly ["Button"];
+        readonly describes: "The one thing a landing screen exists to get pressed. Taller than every other button and set in running type rather than label type, which is what makes it read from across the page.";
+    }, {
+        readonly id: "button-quiet";
+        readonly section: "button";
+        readonly at: string;
+        readonly wears: readonly ["Button"];
+        readonly describes: "An action that is available and is not being suggested — cancel, skip, dismiss. Ink that supports rather than states, and a smaller symbol beside it.";
+    }, {
+        readonly id: "button-glass";
+        readonly section: "button";
+        readonly at: string;
+        readonly wears: readonly ["Button"];
+        readonly describes: "A button over a picture or a video, where a solid fill would hide what it is sitting on. What is behind shows through, softened.";
+    }, {
+        readonly id: "input";
+        readonly section: "entry";
+        readonly at: string;
+        readonly wears: readonly ["Field", "Select", "Slider", "Textarea", "Toggle"];
+        readonly describes: "Anything a person types into. Tighter vertical room than a surface, so the text baseline sits where a label expects it.";
+    }, {
+        readonly id: "choice";
+        readonly section: "entry";
+        readonly at: string;
+        readonly wears: readonly ["RadioGroup"];
+        readonly describes: "A set of options laid out to be chosen between. A group is not a control — it cannot be focused or invalid itself, only the radios inside it can — so it takes arrangement and a ground and states nothing it cannot be in.";
+    }, {
+        readonly id: "tab-bar";
+        readonly section: "navigation";
+        readonly at: string;
+        readonly wears: readonly ["Breadcrumb", "Pagination", "Tabs"];
+        readonly describes: "The strip of destinations along one edge. Rounder and less padded than a surface, because it holds pressable things rather than content.";
+    }, {
+        readonly id: "link-inline";
+        readonly section: "navigation";
+        readonly at: string;
+        readonly wears: readonly ["Link"];
+        readonly describes: "Wording that takes you somewhere. Carries the accent so it reads as reachable without an underline, and draws a real ring when a keyboard reaches it.";
+    }, {
+        readonly id: "chip";
+        readonly section: "marker";
+        readonly at: string;
+        readonly wears: readonly ["Badge"];
+        readonly describes: "A small token standing for a value. The tightest room in the set, and pill-shaped like the buttons.";
+    }, {
+        readonly id: "glyph-plain";
+        readonly section: "marker";
+        readonly at: string;
+        readonly wears: readonly ["Glyph"];
+        readonly describes: "A pictogram at the size most controls use, drawn in the ink of whatever it sits beside.";
+    }, {
+        readonly id: "avatar-round";
+        readonly section: "marker";
+        readonly at: string;
+        readonly wears: readonly ["Avatar"];
+        readonly describes: "A person, standing for themselves. Fully round, sunken so it reads as a well rather than a card, and sized to be recognised at a glance.";
+    }, {
+        readonly id: "rule";
+        readonly section: "marker";
+        readonly at: string;
+        readonly wears: readonly ["Separator"];
+        readonly describes: "The line between two things. The thinnest a screen can draw, in the colour that separates without asking to be seen.";
+    }, {
+        readonly id: "skeleton-block";
+        readonly section: "marker";
+        readonly at: string;
+        readonly wears: readonly ["Skeleton"];
+        readonly describes: "The shape of something that has not arrived. Sunken and breathing, which is what says waiting rather than empty.";
+    }, {
+        readonly id: "spinner-turning";
+        readonly section: "marker";
+        readonly at: string;
+        readonly wears: readonly ["Spinner"];
+        readonly describes: "Work with no measurable end. Turns without stopping, in the accent, so it reads as the app doing something rather than the app stuck.";
+    }, {
+        readonly id: "stat-tile";
+        readonly section: "figure";
+        readonly at: string;
+        readonly wears: readonly ["Gauge", "Progress", "Stat"];
+        readonly describes: "A single figure given room to be read at a glance, so its type role is the display one rather than body.";
+    }, {
+        readonly id: "tap-target";
+        readonly section: "gesture";
+        readonly at: string;
+        readonly wears: readonly ["HitBox"];
+        readonly describes: "Anything a finger acts on directly rather than through a control — the one variant a hit box wears. It is where a tap, a press and a carry are answered, because a hit box is the only thing that raises those and nothing accepted it before.";
+    }];
+};

package/dist/ui/variants.js

@@ -0,0 +1,50 @@
+const at = (id) => `thread/ui/variants/var_${id}.ts`;
+export const VARIANTS = {
+    id: 'variant',
+    at: 'thread/ui/variants.ts',
+    files: 'ui/var_*.ts',
+    describes: 'How a thing looks: a material plus the style guide values it names directly, never raw ones, and how that look changes under a state. It says nothing about type, because typography belongs to the role the wording states; what is left here is the look of the box and the colour of what sits in it. Each row names a file prefixed `var_`, and that file is the variant: what it looks like, what it looks like under a state, and which states it reacts to. The row states which elements accept it, and it is worn as the tag, so a variant `button-fill` is written `<Button.buttonFill>` and an element nothing declares is refused. A state is the set of signals holding at once, and two states that can both hold and both set one property must have their combination declared, or which one wins is an accident of file order. An app adds its own to this same list, and a row that goes missing breaks the build, because what the framework offers is not an app’s to withdraw.',
+    version: 1,
+    cites: [
+        {
+            on: '2026-08-24',
+            said: 'Variants define lots of things. Including how they look in different states. Including how they look in multiple states at once. (hover, pressed) is one variant that covers both hover and pressed, so they look the same when they are simultaneous. (hover) (pressed) (hover, pressed) however have different states for the three situations.',
+        },
+        {
+            on: '2026-08-25',
+            said: 'Variants basically say: This is how I look. These are the elements that accept me. These are my behaviours under different states. These are the states I can react to.',
+        },
+        {
+            on: '2026-08-28',
+            said: 'fonts.ts as SSOT for everything related to fonts and easy to change fonts throughout the app like tokens, like....the exact same reason for existing that tokens+styleguide have is the same reason we have fonts.ts',
+        },
+    ],
+    declares: [
+        { id: 'card', section: 'surface', at: at('card'), wears: ['Accordion', 'Bars', 'Box', 'Donut', 'Empty', 'Funnel', 'Heatmap', 'LineChart', 'Media', 'Menu', 'Scatter', 'Sparkline', 'Surface', 'Table', 'Tooltip'], describes: 'A surface holding other content, and the shape every unregistered variant falls back to.' },
+        { id: 'list-row', section: 'surface', at: at('list-row'), wears: ['Box'], describes: 'One row of a list — square, quiet, and separated by its neighbours rather than by a shadow.' },
+        { id: 'framed', section: 'surface', at: at('framed'), wears: ['Image', 'Media', 'AspectRatio'], describes: 'A picture given the same corners as a panel, on a sunken ground so the gap before it loads is not a white hole.' },
+        { id: 'bubble-them', section: 'surface', at: at('bubble-them'), wears: ['Box'], describes: 'A message somebody else sent. The plain half of a conversation.' },
+        { id: 'bubble-me', section: 'surface', at: at('bubble-me'), wears: ['Box'], describes: 'A message the current person sent. Takes the accent, which is how a conversation reads as two voices without a second colour role.' },
+        { id: 'button-fill', section: 'button', at: at('button-fill'), wears: ['Button'], describes: 'The one action a screen is asking for. The accent behind it, and the only button on a screen that should carry it.' },
+        { id: 'button-normal', section: 'button', at: at('button-normal'), wears: ['Button'], describes: 'The ordinary button. A surface with a hairline round it — pressable, and asking for nothing in particular.' },
+        { id: 'button-ghost', section: 'button', at: at('button-ghost'), wears: ['Button'], describes: 'Wording that acts. No ground and no line until a pointer is over it, which is what keeps a row of them from reading as a wall of boxes.' },
+        { id: 'button-border', section: 'button', at: at('button-border'), wears: ['Button'], describes: 'An action offered beside a filled one. The accent as an edge rather than a ground, so the shape says pressable and the colour says not this one.' },
+        { id: 'button-destructive', section: 'button', at: at('button-destructive'), wears: ['Button'], describes: 'Something that cannot be undone. The same shape as the asking button, in the colour reserved for consequence.' },
+        { id: 'button-destructive-ghost', section: 'button', at: at('button-destructive-ghost'), wears: ['Button'], describes: 'A destructive action that is not the point of the screen — delete, sitting quietly at the end of a menu. Carries the negative as ink and gains a ground only under a pointer.' },
+        { id: 'button-cta', section: 'button', at: at('button-cta'), wears: ['Button'], describes: 'The one thing a landing screen exists to get pressed. Taller than every other button and set in running type rather than label type, which is what makes it read from across the page.' },
+        { id: 'button-quiet', section: 'button', at: at('button-quiet'), wears: ['Button'], describes: 'An action that is available and is not being suggested — cancel, skip, dismiss. Ink that supports rather than states, and a smaller symbol beside it.' },
+        { id: 'button-glass', section: 'button', at: at('button-glass'), wears: ['Button'], describes: 'A button over a picture or a video, where a solid fill would hide what it is sitting on. What is behind shows through, softened.' },
+        { id: 'input', section: 'entry', at: at('input'), wears: ['Field', 'Select', 'Slider', 'Textarea', 'Toggle'], describes: 'Anything a person types into. Tighter vertical room than a surface, so the text baseline sits where a label expects it.' },
+        { id: 'choice', section: 'entry', at: at('choice'), wears: ['RadioGroup'], describes: 'A set of options laid out to be chosen between. A group is not a control — it cannot be focused or invalid itself, only the radios inside it can — so it takes arrangement and a ground and states nothing it cannot be in.' },
+        { id: 'tab-bar', section: 'navigation', at: at('tab-bar'), wears: ['Breadcrumb', 'Pagination', 'Tabs'], describes: 'The strip of destinations along one edge. Rounder and less padded than a surface, because it holds pressable things rather than content.' },
+        { id: 'link-inline', section: 'navigation', at: at('link-inline'), wears: ['Link'], describes: 'Wording that takes you somewhere. Carries the accent so it reads as reachable without an underline, and draws a real ring when a keyboard reaches it.' },
+        { id: 'chip', section: 'marker', at: at('chip'), wears: ['Badge'], describes: 'A small token standing for a value. The tightest room in the set, and pill-shaped like the buttons.' },
+        { id: 'glyph-plain', section: 'marker', at: at('glyph-plain'), wears: ['Glyph'], describes: 'A pictogram at the size most controls use, drawn in the ink of whatever it sits beside.' },
+        { id: 'avatar-round', section: 'marker', at: at('avatar-round'), wears: ['Avatar'], describes: 'A person, standing for themselves. Fully round, sunken so it reads as a well rather than a card, and sized to be recognised at a glance.' },
+        { id: 'rule', section: 'marker', at: at('rule'), wears: ['Separator'], describes: 'The line between two things. The thinnest a screen can draw, in the colour that separates without asking to be seen.' },
+        { id: 'skeleton-block', section: 'marker', at: at('skeleton-block'), wears: ['Skeleton'], describes: 'The shape of something that has not arrived. Sunken and breathing, which is what says waiting rather than empty.' },
+        { id: 'spinner-turning', section: 'marker', at: at('spinner-turning'), wears: ['Spinner'], describes: 'Work with no measurable end. Turns without stopping, in the accent, so it reads as the app doing something rather than the app stuck.' },
+        { id: 'stat-tile', section: 'figure', at: at('stat-tile'), wears: ['Gauge', 'Progress', 'Stat'], describes: 'A single figure given room to be read at a glance, so its type role is the display one rather than body.' },
+        { id: 'tap-target', section: 'gesture', at: at('tap-target'), wears: ['HitBox'], describes: 'Anything a finger acts on directly rather than through a control — the one variant a hit box wears. It is where a tap, a press and a carry are answered, because a hit box is the only thing that raises those and nothing accepted it before.' },
+    ],
+};

package/dist/ui/wrappers.d.ts

@@ -0,0 +1,128 @@
+import { type ReactNode } from 'react';
+import type { Collector } from './collector.ts';
+import type { ArrangementElement, VariantsFor, Wearing } from './checked.ts';
+import { PRESENTATION_BEHAVIOUR, type Clock, type Presentation, type Surface, type Ticker } from './door.ts';
+import { holds as declared } from './signals.ts';
+declare module 'react' {
+    interface HTMLAttributes<T> {
+        readonly at?: string;
+    }
+    interface SVGAttributes<T> {
+        readonly at?: string;
+    }
+}
+export interface Appearance {
+    readonly mode: 'light' | 'dark';
+    readonly reduceMotion: boolean;
+}
+export interface UiConfig {
+    readonly palette: {
+        readonly accent: string;
+        readonly surface: string;
+    };
+    readonly translate: (key: string, params?: Readonly<Record<string, unknown>>) => string;
+    readonly appearance: Appearance;
+    readonly clock: Clock;
+    readonly ticker?: Ticker;
+    readonly now?: () => number;
+    readonly edgeScroll?: {
+        readonly band?: number;
+        readonly speed?: number;
+    };
+    readonly collector?: Collector;
+    readonly platform?: string;
+    readonly dispatch?: (name: string, input?: Readonly<Record<string, unknown>>) => Promise<unknown>;
+    readonly navigateTo?: (screen: string) => void;
+    readonly actor?: {
+        readonly id: string | null;
+        readonly roles: readonly string[];
+        readonly entitlements: readonly string[];
+    };
+    readonly asking?: readonly {
+        readonly id: string;
+        readonly selector: string;
+    }[];
+}
+export declare const UiContext: import("react").Context<UiConfig | null>;
+export declare function UiProvider({ config, children }: {
+    config: UiConfig;
+    children: ReactNode;
+}): ReactNode;
+export declare function useUi(): UiConfig;
+export interface SurfaceRequest {
+    readonly className?: string;
+    readonly invokes?: {
+        readonly dispatch?: string;
+        readonly input?: Readonly<Record<string, unknown>>;
+        readonly on?: 'press' | 'shown';
+    };
+    readonly holds?: readonly ((typeof declared)[number]['id'] | (string & {}))[];
+    readonly animates?: boolean;
+    readonly measures?: Readonly<Record<string, string | number>>;
+}
+export declare function useSurface(request?: SurfaceRequest): Surface;
+export type Press = {
+    readonly dispatch: string;
+    readonly input?: Readonly<Record<string, unknown>>;
+    readonly navigateTo?: never;
+    readonly onPress?: never;
+} | {
+    readonly navigateTo: string;
+    readonly dispatch?: never;
+    readonly input?: never;
+    readonly onPress?: never;
+} | {
+    readonly onPress: () => void;
+    readonly dispatch?: never;
+    readonly navigateTo?: never;
+    readonly input?: never;
+} | {
+    readonly dispatch?: never;
+    readonly navigateTo?: never;
+    readonly input?: never;
+    readonly onPress?: never;
+};
+export declare function pressOf(props: {
+    readonly dispatch?: string;
+    readonly input?: Readonly<Record<string, unknown>>;
+    readonly navigateTo?: string;
+    readonly onPress?: () => void;
+}): Press;
+export interface PressOrigin {
+    readonly element: string;
+    readonly name?: string;
+}
+export declare function usePress(press: Press, origin?: PressOrigin): (() => void) | undefined;
+export declare function useVisibility(active: boolean): (node: HTMLElement | null) => void;
+export interface ScreenOptions {
+    readonly as?: Presentation;
+    readonly views?: readonly string[];
+    readonly unreachable?: boolean;
+}
+type Component<P> = (props: P) => ReactNode;
+export type ElementBody<P> = (props: P, className?: string) => ReactNode;
+type Members<N extends string, P> = {
+    readonly [K in VariantsFor<N> | {
+        [W in keyof Wearing]: N extends Wearing[W] ? W : never;
+    }[keyof Wearing]]: Component<P & {
+        readonly at?: string;
+    }>;
+};
+export type Element<N extends string, P> = [keyof Members<N, P>] extends [never] ? Component<P & {
+    readonly at?: string;
+}> : N extends ArrangementElement ? Component<P & {
+    readonly at?: string;
+}> & Members<N, P> : Members<N, P>;
+export declare function element<N extends string, P>(name: N, fn: ElementBody<P>, own?: string): Element<N, P>;
+export declare function composition<P>(own: string, fn: (props: P) => ReactNode): Component<P & {
+    readonly at?: string;
+    readonly className?: string;
+}>;
+export interface ScreenControls {
+    readonly open?: boolean;
+    readonly onDismiss?: () => void;
+    readonly at?: string;
+}
+export declare function screen<P>(own: string, options: ScreenOptions, fn: Component<P>): Component<P & ScreenControls>;
+export declare function behaviourOf(presentation: Presentation): (typeof PRESENTATION_BEHAVIOUR)[Presentation];
+export {};