@satinhq/kit 0.0.0-stage → 0.1.0-beta.0

package/dist/docs/symbols.md

@@ -0,0 +1,293 @@
+# Available symbols
+
+Satin bundles 278 symbol names. Use these names in Symbol, Button,
+ToolbarItem and tab declarations. They are semantic aliases for redistributable
+Framework7 artwork, not Apple SF Symbols artwork.
+
+A name absent from this list renders the visible question-mark placeholder unless
+your SymbolProvider supplies an original or redistributable glyph. SymbolName
+accepts custom strings, so TypeScript does not check catalogue membership.
+Selected symbols use the corresponding .fill name when it exists.
+
+This page is generated from the shipped catalogue during each package build.
+
+| Name |
+| --- |
+| `airplane` |
+| `airplayaudio` |
+| `archivebox` |
+| `archivebox.fill` |
+| `arrow.2.squarepath` |
+| `arrow.clockwise` |
+| `arrow.counterclockwise` |
+| `arrow.down` |
+| `arrow.down.circle` |
+| `arrow.down.circle.fill` |
+| `arrow.left` |
+| `arrow.right` |
+| `arrow.up` |
+| `arrow.up.arrow.down` |
+| `arrow.up.right` |
+| `arrow.uturn.backward` |
+| `arrow.uturn.forward` |
+| `arrowshape.turn.up.left` |
+| `arrowshape.turn.up.left.fill` |
+| `arrowshape.turn.up.right` |
+| `arrowshape.turn.up.right.fill` |
+| `at` |
+| `backward` |
+| `backward.fill` |
+| `battery.100` |
+| `bed.double` |
+| `bed.double.fill` |
+| `bell` |
+| `bell.badge` |
+| `bell.badge.fill` |
+| `bell.fill` |
+| `bell.slash` |
+| `bell.slash.fill` |
+| `bicycle` |
+| `bolt` |
+| `bolt.fill` |
+| `book` |
+| `book.closed` |
+| `book.closed.fill` |
+| `book.fill` |
+| `bookmark` |
+| `bookmark.fill` |
+| `brain.head.profile` |
+| `briefcase` |
+| `briefcase.fill` |
+| `bubble.left.and.bubble.right` |
+| `bubble.left.and.bubble.right.fill` |
+| `calendar` |
+| `calendar.badge.clock` |
+| `camera` |
+| `camera.fill` |
+| `car` |
+| `cart` |
+| `cart.fill` |
+| `chart.bar` |
+| `chart.bar.fill` |
+| `chart.line.uptrend.xyaxis` |
+| `checklist` |
+| `checkmark` |
+| `checkmark.circle` |
+| `checkmark.circle.fill` |
+| `checkmark.seal` |
+| `checkmark.seal.fill` |
+| `checkmark.square` |
+| `checkmark.square.fill` |
+| `chevron.down` |
+| `chevron.left` |
+| `chevron.right` |
+| `chevron.up` |
+| `chevron.up.chevron.down` |
+| `circle` |
+| `circle.fill` |
+| `clock` |
+| `clock.arrow.circlepath` |
+| `clock.fill` |
+| `cross.case` |
+| `cross.case.fill` |
+| `cup.and.saucer` |
+| `cup.and.saucer.fill` |
+| `device.phone.portrait` |
+| `display` |
+| `doc` |
+| `doc.fill` |
+| `doc.on.doc` |
+| `doc.on.doc.fill` |
+| `doc.text` |
+| `doc.text.fill` |
+| `dollarsign.circle` |
+| `dollarsign.circle.fill` |
+| `dot.radiowaves.left.and.right` |
+| `dot.radiowaves.left.right` |
+| `drop` |
+| `drop.fill` |
+| `dumbbell` |
+| `dumbbell.fill` |
+| `ellipsis` |
+| `ellipsis.circle` |
+| `ellipsis.circle.fill` |
+| `envelope` |
+| `envelope.badge` |
+| `envelope.badge.fill` |
+| `envelope.fill` |
+| `envelope.open` |
+| `envelope.open.fill` |
+| `exclamationmark.2` |
+| `exclamationmark.triangle` |
+| `exclamationmark.triangle.fill` |
+| `eye` |
+| `eye.fill` |
+| `eye.slash` |
+| `eye.slash.fill` |
+| `face.smiling` |
+| `face.smiling.fill` |
+| `figure.run` |
+| `flag` |
+| `flag.fill` |
+| `flag.slash` |
+| `flag.slash.fill` |
+| `flame` |
+| `flame.fill` |
+| `folder` |
+| `folder.badge.plus` |
+| `folder.fill` |
+| `fork.knife` |
+| `forward` |
+| `forward.fill` |
+| `gear` |
+| `gearshape` |
+| `gearshape.fill` |
+| `gift` |
+| `gift.fill` |
+| `globe` |
+| `graduationcap` |
+| `graduationcap.fill` |
+| `hand.raised` |
+| `hand.raised.fill` |
+| `hand.thumbsdown` |
+| `hand.thumbsdown.fill` |
+| `hand.thumbsup` |
+| `hand.thumbsup.fill` |
+| `headphones` |
+| `heart` |
+| `heart.fill` |
+| `heart.slash` |
+| `heart.slash.fill` |
+| `hourglass` |
+| `house` |
+| `house.fill` |
+| `info.circle` |
+| `info.circle.fill` |
+| `key` |
+| `key.fill` |
+| `keyboard` |
+| `leaf` |
+| `leaf.fill` |
+| `line.3.horizontal` |
+| `line.3.horizontal.decrease` |
+| `line.3.horizontal.decrease.circle` |
+| `line.3.horizontal.decrease.circle.fill` |
+| `link` |
+| `list.bullet` |
+| `list.bullet.clipboard` |
+| `list.bullet.clipboard.fill` |
+| `list.number` |
+| `location` |
+| `location.fill` |
+| `lock` |
+| `lock.fill` |
+| `magnifyingglass` |
+| `mappin` |
+| `mappin.and.ellipse` |
+| `minus` |
+| `moon` |
+| `moon.fill` |
+| `music.house` |
+| `music.house.fill` |
+| `music.mic` |
+| `music.note` |
+| `music.note.list` |
+| `note.text` |
+| `note.text.fill` |
+| `paperplane` |
+| `paperplane.fill` |
+| `pause` |
+| `pause.circle` |
+| `pause.circle.fill` |
+| `pause.fill` |
+| `pawprint` |
+| `pencil` |
+| `person` |
+| `person.2` |
+| `person.2.fill` |
+| `person.badge.plus` |
+| `person.badge.plus.fill` |
+| `person.crop.circle` |
+| `person.crop.circle.fill` |
+| `person.fill` |
+| `photo` |
+| `photo.fill` |
+| `photo.on.rectangle` |
+| `pill` |
+| `pill.fill` |
+| `pin` |
+| `pin.fill` |
+| `pin.slash` |
+| `pin.slash.fill` |
+| `play` |
+| `play.circle` |
+| `play.circle.fill` |
+| `play.fill` |
+| `play.rectangle` |
+| `play.rectangle.fill` |
+| `plus` |
+| `plus.circle` |
+| `plus.circle.fill` |
+| `questionmark.circle` |
+| `questionmark.circle.fill` |
+| `questionmark.square` |
+| `questionmark.square.fill` |
+| `quote.bubble` |
+| `quote.bubble.fill` |
+| `receipt` |
+| `receipt.fill` |
+| `rectangle.stack` |
+| `rectangle.stack.fill` |
+| `repeat` |
+| `repeat.1` |
+| `scalemass` |
+| `scalemass.fill` |
+| `server.rack` |
+| `server.rack.fill` |
+| `shuffle` |
+| `sidebar.left` |
+| `slider.horizontal.3` |
+| `sparkles` |
+| `speaker` |
+| `speaker.fill` |
+| `speaker.wave.3` |
+| `speaker.wave.3.fill` |
+| `square.and.arrow.down` |
+| `square.and.arrow.down.fill` |
+| `square.and.arrow.up` |
+| `square.and.arrow.up.fill` |
+| `square.and.pencil` |
+| `square.and.pencil.fill` |
+| `square.grid.2x2` |
+| `square.grid.2x2.fill` |
+| `square.stack` |
+| `square.stack.fill` |
+| `star` |
+| `star.fill` |
+| `stop` |
+| `stop.fill` |
+| `stopwatch` |
+| `stopwatch.fill` |
+| `sun.max` |
+| `sun.max.fill` |
+| `tag` |
+| `tag.fill` |
+| `text.append` |
+| `text.badge.plus` |
+| `text.insert` |
+| `textformat` |
+| `timer` |
+| `timer.fill` |
+| `trash` |
+| `trash.fill` |
+| `tray` |
+| `tray.fill` |
+| `tray.full` |
+| `tray.full.fill` |
+| `tv.music.note` |
+| `tv.music.note.fill` |
+| `viewfinder` |
+| `waveform` |
+| `xmark` |
+| `xmark.circle` |
+| `xmark.circle.fill` |

package/dist/docs/tokens.md

@@ -0,0 +1,60 @@
+# Geometry and appearance tokens
+
+Load `@satinhq/kit/styles.css` once. Satin supplies these properties inside its mounted root and may override geometry in adaptive pane descendants. Consume the nearest value; do not copy root measurements into a sidebar or detail pane. Unknown custom-property names do not produce a TypeScript error and can leave a CSS declaration invalid.
+
+| Property | Value | Use |
+| --- | --- | --- |
+| `--satin-inset-top` | CSS length in px | Interactive content's live top inset |
+| `--satin-inset-right` | CSS length in px | Right inset of the current surface |
+| `--satin-inset-bottom` | CSS length in px | Bottom inset of the current surface |
+| `--satin-inset-left` | CSS length in px | Left inset of the current surface |
+| `--satin-safe-frame-width` | CSS length in px | Current safe content width |
+| `--satin-safe-frame-height` | CSS length in px | Current safe content height |
+| `--satin-background` | CSS color | Framework-selected surface background |
+| `--satin-device-pixel` | CSS length in px | One physical pixel at the current device scale |
+| `--satin-layout-horizontal` | `compact` or `regular` | Diagnostic layout class, not a length |
+| `--satin-layout-vertical` | `compact` or `regular` | Diagnostic layout class, not a length |
+
+```css
+.custom-content {
+  padding-inline: var(--satin-inset-left) var(--satin-inset-right);
+  padding-bottom: var(--satin-inset-bottom);
+  background: var(--satin-background);
+  font: -apple-system-body;
+}
+```
+
+Let List/Form/ScrollView and framework chrome apply their own insets. Adding the same inset again inside those components causes double padding. Never use raw viewport-height units or `env(safe-area-inset-*)` to replace framework geometry. Do not fix html, body or the mount in app CSS.
+
+`useSafeAreaInsets()` returns numeric layout insets in CSS pixels. `useSafeAreaMetrics()` also exposes `layoutViewport`, `visualViewport`, `screen`, `safeFrame` and `physicalSafeFrame`, with numeric CSS-pixel dimensions. `physicalInsets` are comparison coordinates, not padding. React numeric padding values become px; CSS custom properties already contain their unit. Never append another `px` to a token.
+
+## Settings composition
+
+These settings tokens are also CSS lengths in px:
+
+| Property | Meaning |
+| --- | --- |
+| `--satin-settings-root-inline-inset` | Root settings horizontal content inset |
+| `--satin-settings-detail-inline-inset` | Detail settings horizontal content inset |
+| `--satin-settings-root-title-top` | Root title origin, including the top inset |
+| `--satin-settings-detail-content-top` | Detail content origin, including the top inset |
+| `--satin-settings-root-title-offset` | Root title offset without the top inset |
+| `--satin-settings-detail-content-offset` | Detail content offset without the top inset |
+| `--satin-settings-navigation-bar-height` | Settings navigation bar height |
+| `--satin-settings-root-row-height` | Root row baseline height |
+| `--satin-settings-detail-row-height` | Detail row baseline height |
+| `--satin-settings-group-radius` | Settings group corner radius |
+| `--satin-settings-group-spacing` | Inter-group spacing |
+| `--satin-settings-separator-hairline` | Separator thickness |
+
+The two origin tokens already include the live top inset: do not add it twice. Prefer framework List and Screen composition over reconstructing their geometry. Row height tokens describe baselines, not permission to clip large text.
+
+## Theme and ownership
+
+Set `appearance.tint`, `appearance.background` and `appearance.darkLaunch.background` through the app definition. Use `useColorScheme()` for application artwork or application-owned colors; it returns `light` or `dark` from the accepted framework appearance. Do not introduce a raw appearance media query. Use `semanticColor('label')`, `semanticColor('secondaryLabel')` and `semanticColor('tertiaryLabel')` for UIKit content roles. Fill tiers, system and grouped backgrounds, separators and tint are available through the same helper. These tokens live on the document and reach body portals. Semantic label tokens resolve colors directly; secondary and tertiary foreground treatments can instead composite opacity over their background.
+
+`systemColor` accepts red, orange, yellow, green, mint, teal, cyan, blue, indigo, purple, pink, brown, gray and gray2 through gray6. Values resolve by the accepted document appearance. Fixed RGB artwork remains app-owned. Automatic leading List `Label` symbols use app tint, or a local `ControlStyleProvider` tint, while titles retain primary/destructive roles and explicitly coloured Symbols retain their colour.
+
+For application-owned artwork variables use `:root[data-satin-appearance='dark']`. A `:where(html[...])` selector has zero specificity and loses against an authored `:root` declaration. Normal-contrast iOS 27 values are measured; increased contrast and Display P3 are outside this contract.
+
+The framework also owns glass, press-feedback and motion variables. Their presence in implementation CSS is not an application styling API. Do not override them to invent material, spring or gesture behavior. Keep decorative painted SVG content visible to the glass renderer with `role="presentation"` and `focusable="false"`; its enclosing control provides its accessible label.

package/dist/fidelity/devAssertions.d.ts

@@ -0,0 +1,21 @@
+export type FidelityInvariant = 'document-scroll' | 'history-growth' | 'input-font-size' | 'navigator-history-change' | 'popstate' | 'undeclared-scroll-surface';
+export type FidelityViolation = {
+    invariant: FidelityInvariant;
+    message: string;
+    offender: Element;
+};
+type StyleReader = (element: Element) => CSSStyleDeclaration;
+export declare function describeElement(element: Element): string;
+export declare function findDocumentScrollViolation(documentObject: Document, viewport?: {
+    width: number;
+    height: number;
+}): FidelityViolation | undefined;
+export declare function findHistoryGrowthViolation(initialLength: number, currentLength: number, documentElement: Element): FidelityViolation | undefined;
+export declare function findPopstateViolation(documentElement: Element): FidelityViolation;
+export declare function reportNavigatorHistoryChange(operation: string, initialLength: number, currentLength: number, navigatorState: unknown): boolean;
+export declare function isTextControl(element: Element): boolean;
+export declare function findInputFontSizeViolation(element: Element, readStyle?: StyleReader): FidelityViolation | undefined;
+export declare function findUndeclaredScrollViolations(root: ParentNode, readStyle?: StyleReader): FidelityViolation[];
+export declare function formatFidelityViolation(violation: FidelityViolation): string;
+export declare function startDevFidelityAssertions(initialHistoryLength?: number): () => void;
+export {};

package/dist/fidelity/devAssertions.js

@@ -0,0 +1,199 @@
+const TEXT_INPUT_TYPES = new Set([
+    '',
+    'date',
+    'datetime-local',
+    'email',
+    'month',
+    'number',
+    'password',
+    'search',
+    'tel',
+    'text',
+    'time',
+    'url',
+    'week',
+]);
+function hasScrollableOverflow(value) {
+    return value === 'auto' || value === 'scroll';
+}
+export function describeElement(element) {
+    const tag = element.tagName.toLowerCase();
+    const id = element.id ? `#${element.id}` : '';
+    const classes = Array.from(element.classList)
+        .slice(0, 2)
+        .map(name => `.${name}`)
+        .join('');
+    const role = element.getAttribute('data-satin-role');
+    const roleLabel = role ? `[data-satin-role="${role}"]` : '';
+    return `<${tag}${id}${classes}${roleLabel}>`;
+}
+function likelyDocumentOverflowOffender(documentObject, viewportWidth, viewportHeight) {
+    let likely = documentObject.scrollingElement ?? documentObject.documentElement;
+    let largestOverflow = 0;
+    for (const element of documentObject.body?.querySelectorAll('*') ?? []) {
+        const bounds = element.getBoundingClientRect();
+        const overflow = Math.max(0, bounds.right - viewportWidth, bounds.bottom - viewportHeight, -bounds.left, -bounds.top);
+        if (overflow > largestOverflow) {
+            likely = element;
+            largestOverflow = overflow;
+        }
+    }
+    return likely;
+}
+export function findDocumentScrollViolation(documentObject, viewport = {
+    width: window.innerWidth,
+    height: window.innerHeight,
+}) {
+    const scrollingElement = documentObject.scrollingElement ?? documentObject.documentElement;
+    const verticalOverflow = scrollingElement.scrollHeight - viewport.height;
+    const horizontalOverflow = scrollingElement.scrollWidth - viewport.width;
+    if (verticalOverflow <= 1 && horizontalOverflow <= 1)
+        return;
+    return {
+        invariant: 'document-scroll',
+        message: `The document is scrollable (${scrollingElement.scrollWidth}x${scrollingElement.scrollHeight}) ` +
+            `outside the ${viewport.width}x${viewport.height} layout viewport. ` +
+            'Keep the document fixed and move intentional scrolling into data-satin-scroll.',
+        offender: likelyDocumentOverflowOffender(documentObject, viewport.width, viewport.height),
+    };
+}
+export function findHistoryGrowthViolation(initialLength, currentLength, documentElement) {
+    if (currentLength <= initialLength)
+        return;
+    return {
+        invariant: 'history-growth',
+        message: `Browser history grew from ${initialLength} to ${currentLength} after SatinRoot mounted. ` +
+            "Internal navigation must use Satin's in-memory stack, never a browser-history router.",
+        offender: documentElement,
+    };
+}
+export function findPopstateViolation(documentElement) {
+    return {
+        invariant: 'popstate',
+        message: 'A popstate event fired. Browser session history must not drive Satin navigation. ' +
+            'Inspect the logged event state and the current history length.',
+        offender: documentElement,
+    };
+}
+export function reportNavigatorHistoryChange(operation, initialLength, currentLength, navigatorState) {
+    if (currentLength === initialLength)
+        return false;
+    console.error('[Satin fidelity: navigator-history-change] ' +
+        `Browser history changed from ${initialLength} to ${currentLength} during ${operation}. ` +
+        'Satin navigator operations must only update the in-memory screen stack.', { navigatorState, operation });
+    return true;
+}
+export function isTextControl(element) {
+    if (element instanceof HTMLTextAreaElement)
+        return true;
+    if (element instanceof HTMLInputElement)
+        return TEXT_INPUT_TYPES.has(element.type);
+    return element instanceof HTMLElement && element.isContentEditable;
+}
+export function findInputFontSizeViolation(element, readStyle = target => getComputedStyle(target)) {
+    if (!isTextControl(element))
+        return;
+    const fontSize = Number.parseFloat(readStyle(element).fontSize);
+    if (!Number.isFinite(fontSize) || fontSize >= 16)
+        return;
+    return {
+        invariant: 'input-font-size',
+        message: `Focused text control computes to ${fontSize}px. iOS may zoom the page below 16px. ` +
+            'Set the control itself to at least 16 CSS pixels and adjust visual density through layout.',
+        offender: element,
+    };
+}
+export function findUndeclaredScrollViolations(root, readStyle = target => getComputedStyle(target)) {
+    const violations = [];
+    for (const element of root.querySelectorAll('*')) {
+        if (element.hasAttribute('data-satin-scroll'))
+            continue;
+        if (element.tagName === 'TEXTAREA' &&
+            element.hasAttribute('data-satin-text-editor') &&
+            element.closest('[data-satin-scroll-axis="vertical"]'))
+            continue;
+        const style = readStyle(element);
+        const overflowX = style.overflowX || style.overflow;
+        const overflowY = style.overflowY || style.overflow;
+        const scrollsHorizontally = hasScrollableOverflow(overflowX) && element.scrollWidth > element.clientWidth + 1;
+        const scrollsVertically = hasScrollableOverflow(overflowY) && element.scrollHeight > element.clientHeight + 1;
+        if (!scrollsHorizontally && !scrollsVertically)
+            continue;
+        violations.push({
+            invariant: 'undeclared-scroll-surface',
+            message: `An undeclared element scrolls with overflow-x:${overflowX} and overflow-y:${overflowY}. ` +
+                'Render scrolling content through Satin ScrollSurface; raw overflow containers are not declared runtime surfaces.',
+            offender: element,
+        });
+    }
+    return violations;
+}
+function violationKey(violation) {
+    return `${violation.invariant}:${describeElement(violation.offender)}`;
+}
+export function formatFidelityViolation(violation) {
+    return (`[Satin fidelity: ${violation.invariant}] ${violation.message} ` +
+        `Likely offender: ${describeElement(violation.offender)}`);
+}
+function reportViolation(violation, reported) {
+    const key = violationKey(violation);
+    if (reported.has(key))
+        return;
+    reported.add(key);
+    console.error(formatFidelityViolation(violation), violation.offender);
+}
+export function startDevFidelityAssertions(initialHistoryLength = window.history.length) {
+    const reported = new Set();
+    const report = (violation) => {
+        if (violation)
+            reportViolation(violation, reported);
+    };
+    const scan = () => {
+        report(findDocumentScrollViolation(document));
+        report(findHistoryGrowthViolation(initialHistoryLength, window.history.length, document.documentElement));
+        for (const violation of findUndeclaredScrollViolations(document.body)) {
+            report(violation);
+        }
+    };
+    const onFocusIn = (event) => {
+        if (event.target instanceof Element) {
+            report(findInputFontSizeViolation(event.target));
+        }
+    };
+    const onDocumentScroll = (event) => {
+        const scrollingElement = document.scrollingElement ?? document.documentElement;
+        if (event.target !== document &&
+            event.target !== document.documentElement &&
+            event.target !== document.body &&
+            event.target !== scrollingElement) {
+            return;
+        }
+        report({
+            invariant: 'document-scroll',
+            message: 'A document-level scroll event fired. The Satin document must stay inert; inspect layout overflow and undeclared scroll containers.',
+            offender: scrollingElement,
+        });
+    };
+    const onPopstate = (event) => {
+        const violation = findPopstateViolation(document.documentElement);
+        console.error(formatFidelityViolation(violation), {
+            eventState: event.state,
+            historyLength: window.history.length,
+        });
+        scan();
+    };
+    const initialScan = window.setTimeout(scan, 0);
+    const periodicScan = window.setInterval(scan, 1_000);
+    document.addEventListener('focusin', onFocusIn, true);
+    document.addEventListener('scroll', onDocumentScroll, true);
+    window.addEventListener('scroll', onDocumentScroll, { passive: true });
+    window.addEventListener('popstate', onPopstate);
+    return () => {
+        window.clearTimeout(initialScan);
+        window.clearInterval(periodicScan);
+        document.removeEventListener('focusin', onFocusIn, true);
+        document.removeEventListener('scroll', onDocumentScroll, true);
+        window.removeEventListener('scroll', onDocumentScroll);
+        window.removeEventListener('popstate', onPopstate);
+    };
+}

package/dist/focus/focusIntentMachine.d.ts

@@ -0,0 +1,106 @@
+export type FocusReadiness = 'lazy' | 'ready';
+export type FocusScopeDefinition = Readonly<{
+    initialTarget: string;
+    key: string;
+    readiness: FocusReadiness;
+    title: string;
+}>;
+export type FocusLocation = Readonly<{
+    scopeKey: string;
+    target: string;
+}>;
+export type FocusReason = 'dismiss' | 'error' | 'pop' | 'present' | 'push' | 'transition-cancel';
+export type FocusCommand = Readonly<{
+    location: FocusLocation;
+    type: 'capture';
+}> | Readonly<{
+    fallback: FocusLocation;
+    location: FocusLocation;
+    reason: FocusReason;
+    type: 'restore';
+}> | Readonly<{
+    location: FocusLocation;
+    reason: FocusReason;
+    type: 'move-to';
+}> | Readonly<{
+    message: string;
+    politeness: 'assertive';
+    scopeKey: string;
+    type: 'announce';
+}>;
+type FocusScopeState = FocusScopeDefinition & Readonly<{
+    failed: boolean;
+    focusTarget: string;
+    ready: boolean;
+}>;
+export type FocusRouteState = FocusScopeState & Readonly<{
+    phase: 'entering' | 'exiting' | 'settled';
+    transitionId?: string;
+}>;
+export type FocusPresentationState = FocusScopeState;
+export type FocusTransitionState = Readonly<{
+    id: string;
+    kind: 'pop' | 'push';
+}>;
+type PendingFocusIntent = Readonly<{
+    kind: 'initial' | 'restore';
+    reason: FocusReason;
+    scopeKey: string;
+}>;
+export type FocusIntentState = Readonly<{
+    pending?: PendingFocusIntent;
+    presentations: readonly FocusPresentationState[];
+    routes: readonly FocusRouteState[];
+    snapshots: ReadonlyMap<string, string>;
+    transitions: readonly FocusTransitionState[];
+}>;
+export type FocusIntentEvent = Readonly<{
+    activeFocus?: FocusLocation;
+    fromKey: string;
+    to: FocusScopeDefinition;
+    transitionId: string;
+    type: 'push-begin';
+}> | Readonly<{
+    outcome: 'cancelled' | 'completed';
+    transitionId: string;
+    type: 'push-settle';
+}> | Readonly<{
+    activeFocus?: FocusLocation;
+    toKey: string;
+    transitionId: string;
+    type: 'pop-begin';
+}> | Readonly<{
+    outcome: 'cancelled' | 'completed';
+    transitionId: string;
+    type: 'pop-settle';
+}> | Readonly<{
+    activeFocus?: FocusLocation;
+    presentation: FocusScopeDefinition;
+    type: 'present';
+}> | Readonly<{
+    presentationKey: string;
+    type: 'dismiss';
+}> | Readonly<{
+    scopeKey: string;
+    target?: string;
+    type: 'lazy-ready';
+}> | Readonly<{
+    kind: 'screen';
+    message: string;
+    scopeKey: string;
+    target: string;
+    type: 'error';
+}> | Readonly<{
+    kind: 'status';
+    message: string;
+    scopeKey: string;
+    type: 'error';
+}>;
+export type FocusIntentResult = Readonly<{
+    commands: readonly FocusCommand[];
+    state: FocusIntentState;
+}>;
+export declare function activeFocusScopeKey(state: FocusIntentState): string | undefined;
+export declare function createFocusIntentState(initial: FocusScopeDefinition): FocusIntentState;
+export declare function reduceFocusIntent(state: FocusIntentState, event: FocusIntentEvent): FocusIntentResult;
+export {};