@appilots/sdk 0.11.3 → 0.13.0

package/dist/index.d.ts

@@ -1,9 +1,891 @@
-import { P as PartialThemeTokens, A as AppilotsThemeTokens, a as AppilotsLocale, b as AgentAction, I as InteractionElementEntry, C as ComponentRegistry, c as AgentPermissions, S as ScreenSnapshot, F as FieldEntry, d as AppilotsEvent } from './index-BR-33WMN.js';
-export { e as AgentActionType, f as AgentMessage, g as AppilotsClient, h as AppilotsClientOptions, i as AppilotsConfig, j as AppilotsEventHandler, k as AppilotsEventType, l as AppilotsProvider, m as AppilotsProviderProps, n as AppilotsTraceEntry, o as AppilotsUser, B as BreadcrumbItem, p as BreadcrumbState, q as ButtonSnapshot, r as ChatMessage, s as ChoiceGroupSnapshot, t as ChoiceOptionSnapshot, u as ComponentEntry, v as ComponentKind, E as EscalationState, w as FormFillPayload, x as InputSnapshot, y as InteractionElementListContext, z as InteractionElementSnapshot, L as ListItemSnapshot, D as ListSnapshot, M as MessageRole, N as NavigationPayload, R as RateLimitedError, G as RemotePersonalization, H as SliderEntry, J as SuggestedPrompt, T as TargetEntry, K as ToggleEntry, O as ToggleSnapshot, U as UIInteractionPayload, Q as UseAppilotsFieldOptions, V as UseAppilotsSliderOptions, W as UseAppilotsTargetOptions, X as UseAppilotsToggleOptions, Y as UseSuggestedPromptsOptions, Z as UseSuggestedPromptsReturn, _ as clearAppilotsDebugTraces, $ as componentRegistry, a0 as createComponentRegistry, a1 as defaultDarkTheme, a2 as defaultLightTheme, a3 as describeAction, a4 as getAppilotsDebugTraces, a5 as humanizeError, a6 as mergeThemeTokens, a7 as recordAppilotsDebugTrace, a8 as subscribeAppilotsDebugTraces, a9 as useAppilots, aa as useAppilotsActions, ab as useAppilotsChat, ac as useAppilotsContext, ad as useAppilotsField, ae as useAppilotsNavigation, af as useAppilotsSlider, ag as useAppilotsTarget, ah as useAppilotsToggle, ai as useSuggestedPrompts } from './index-BR-33WMN.js';
+import { A as AppilotsTraceEntry, a as AgentAction, b as AppilotsLocale, P as PartialThemeTokens, c as AppilotsThemeTokens, C as ComponentRegistry, d as AppilotsSessionStorage, e as AgentPermissions, F as FieldEntry, f as AppilotsEvent } from './index-CI4jmSoP.js';
+export { g as AgentActionType, h as AgentMessage, i as AppilotsClient, j as AppilotsClientOptions, k as AppilotsConfig, l as AppilotsElementProps, m as AppilotsEventHandler, n as AppilotsEventType, o as AppilotsProvider, p as AppilotsProviderProps, q as AppilotsUser, r as ChatMessage, s as ComponentEntry, t as ComponentKind, E as EscalationState, u as FormFillPayload, M as MessageRole, N as NavigationPayload, R as RateLimitedError, v as RemotePersonalization, S as SliderEntry, w as SuggestedPrompt, T as TargetEntry, x as ToggleEntry, U as UIInteractionPayload, y as UseAppilotsFieldOptions, z as UseAppilotsSliderOptions, B as UseAppilotsTargetOptions, D as UseAppilotsToggleOptions, G as UseSuggestedPromptsOptions, H as UseSuggestedPromptsReturn, I as componentRegistry, J as createComponentRegistry, K as defaultDarkTheme, L as defaultLightTheme, O as mergeThemeTokens, Q as useAppilots, V as useAppilotsActions, W as useAppilotsChat, X as useAppilotsContext, Y as useAppilotsField, Z as useAppilotsNavigation, _ as useAppilotsSlider, $ as useAppilotsTarget, a0 as useAppilotsToggle, a1 as useSuggestedPrompts } from './index-CI4jmSoP.js';
 import * as React$1 from 'react';
 import React__default from 'react';
 export { AppilotsNavigationContainer, NavigationConfig, ScreenMetadata, registerScreen, setCurrentScreen } from './navigation/index.js';
 
+/** Source facts, not an executable locator or proof of a business outcome. */
+interface ControlEvidence {
+    version: 1;
+    siteId: string;
+    component: string;
+    icons: string[];
+    handler?: string;
+    calls: string[];
+    argumentBindings: string[];
+    conditions: string[];
+    nativeConfirmation?: {
+        title?: string;
+        destructiveOption: boolean;
+    };
+}
+
+type ActionPresentationState = 'pending' | 'running' | 'success' | 'failed';
+
+/**
+ * Snapshot types — the platform-agnostic "view model" of what the user
+ * is currently seeing on screen, sent to the AI agent so it has
+ * accurate visible state.
+ *
+ * Every platform walker (React Native fiber walk, web DOM walk, ...)
+ * produces this same shape; the wire contract it feeds is
+ * `agentSnapshotSchema` in `@appilots/shared`.
+ */
+/**
+ * How much the walker actually knows about an element's identifier.
+ *
+ * The observation used to say nothing here, so `btn-3` — an ordinal the
+ * walker invented — read to the model exactly like `testID="submit-order"`,
+ * which a developer wrote down on purpose. That is how a confident press on
+ * the wrong control happens.
+ *
+ * - `declared`   the app named it: `testID` / `data-testid` /
+ *                `accessibilityLabel` / `aria-label`. Stable across renders
+ *                and across releases; safe to copy into a tool call.
+ * - `derived`    folded from what the user can see — the button's own text,
+ *                a `label` or `placeholder` prop. Stable as long as the copy
+ *                does not change, and it changes with the app's language.
+ * - `positional` nothing but an ordinal in the current snapshot. Valid for
+ *                this observation only: a re-render, a scroll or an inserted
+ *                sibling moves it.
+ *
+ * ABSENT means unknown, NOT `declared` — clients published before this field
+ * existed send no provenance at all, and a missing value must never be read
+ * as the most trustworthy one.
+ */
+type IdentityProvenance = 'declared' | 'derived' | 'positional';
+interface InputSnapshot {
+    /** Best identifier — testID/data-testid, accessibilityLabel/aria-label, or placeholder */
+    id?: string;
+    /** How `id` was obtained. See {@link IdentityProvenance}. */
+    provenance?: IdentityProvenance;
+    /**
+     * False when the control is mounted but currently outside the window —
+     * below the fold of a ScrollView, scrolled off the top, pushed sideways
+     * by a carousel.
+     *
+     * ABSENT MEANS UNKNOWN. The old React Native architecture cannot report a
+     * synchronous window-relative rect, and no SDK published before this
+     * field existed reports one at all; reading absence as `false` would make
+     * the agent refuse to press a control the user is looking at.
+     */
+    onScreen?: boolean;
+    /** Human-readable label inferred from accessibility metadata or sibling text */
+    label?: string;
+    /** Current value (only present for controlled inputs) */
+    value?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether the input is editable */
+    editable?: boolean;
+    /** Whether the input is secure (password field) */
+    secure?: boolean;
+    /**
+     * Tipo do campo.
+     *
+     * Os cinco primeiros vêm da metadata de input da plataforma. Os quatro
+     * últimos vêm do registry: um select, um date picker, um toggle ou um
+     * controle custom registrado por `useAppilotsField` não é `TextInput`,
+     * então o walker não o coleta — e sem eles a observação não dizia o que
+     * estava preenchido num formulário que os exige. O schema de wire já
+     * aceitava (`type` é string livre lá); só o tipo local era estrito.
+     */
+    type?: 'text' | 'email' | 'number' | 'phone' | 'password' | 'select' | 'date' | 'toggle' | 'custom';
+    /**
+     * True when pressing return on this field submits — RN's
+     * `onSubmitEditing`, the web's implicit form submit.
+     *
+     * On a search box, a one-field login or a chat composer this IS the
+     * submit; the screen has no button and never will. Absent means the
+     * field declares no such handler, so the form needs a button.
+     */
+    submitsOnReturn?: boolean;
+    /**
+     * The app is asking for this field before the form can be submitted.
+     *
+     * ABSENT MEANS UNKNOWN, not optional: most apps never declare it, and
+     * reading absence as "not required" would let the agent submit a form
+     * it could have known was incomplete.
+     */
+    required?: boolean;
+    /**
+     * The app is currently rejecting this field's value.
+     *
+     * This is the fact the agent used to recover by READING — the error
+     * copy next to the input ("Campo obrigatório", "Formato inválido").
+     * Carrying the fact as a boolean is what lets a redacted observation
+     * still support recovery, and it is cheaper than the sentence even
+     * when nothing is redacted.
+     *
+     * Absent means the app declares no validity state — never that the
+     * field is valid.
+     */
+    invalid?: boolean;
+    /**
+     * Whether the field currently holds anything.
+     *
+     * Deliberately its own field rather than an inference over `value`.
+     * The value belongs to the user and is the first thing a privacy
+     * policy withholds; the EXISTENCE of a value belongs to the agent and
+     * is what stops it from filling the same field twice on a later hop.
+     * Separating them is what lets the second survive without the first.
+     */
+    filled?: boolean;
+    /**
+     * This input has keyboard focus right now.
+     *
+     * Tells apart "empty because nobody typed" from "empty because the
+     * user is typing in it at this moment" — the difference between
+     * completing a form and interrupting someone mid-sentence.
+     */
+    focused?: boolean;
+    /**
+     * True when this input lives inside a currently-visible modal. When a
+     * modal is open, only inModal elements can actually receive input —
+     * everything else is behind the overlay.
+     */
+    inModal?: boolean;
+}
+interface ButtonSnapshot {
+    controlEvidence?: ControlEvidence;
+    /** Best identifier — testID/data-testid, accessibilityLabel/aria-label, or inferred from child text */
+    id?: string;
+    /** How `id` was obtained. See {@link IdentityProvenance}. */
+    provenance?: IdentityProvenance;
+    /** False when the client can observe this button but cannot bind its id to an exact control. */
+    dispatchable?: boolean;
+    /**
+     * False when the control is mounted but currently outside the window —
+     * below the fold of a ScrollView, scrolled off the top, pushed sideways
+     * by a carousel.
+     *
+     * ABSENT MEANS UNKNOWN. The old React Native architecture cannot report a
+     * synchronous window-relative rect, and no SDK published before this
+     * field existed reports one at all; reading absence as `false` would make
+     * the agent refuse to press a control the user is looking at.
+     */
+    onScreen?: boolean;
+    /** Human-readable label — usually the visible text inside the button */
+    label?: string;
+    /** Whether the button is disabled */
+    disabled?: boolean;
+    /**
+     * Whether this control is currently in its ON state.
+     *
+     * Covers both accessibility states that mean it, because the agent
+     * needs the same thing from either: `accessibilityState.selected`
+     * (grouped, mutually-exclusive controls — segmented controls, radio
+     * groups, each option its own pressable target) and
+     * `accessibilityState.checked` (an independent checkbox).
+     *
+     * Absent means "not on OR not observable" — the walker cannot tell a
+     * custom checkbox that declares no a11y state from an ordinary button,
+     * so absence is never proof that a box is unticked.
+     */
+    selected?: boolean;
+    /** True when this button lives inside a currently-visible modal. */
+    inModal?: boolean;
+}
+interface ToggleSnapshot {
+    /** Best identifier */
+    id?: string;
+    /** How `id` was obtained. See {@link IdentityProvenance}. */
+    provenance?: IdentityProvenance;
+    /**
+     * False when the control is mounted but currently outside the window —
+     * below the fold of a ScrollView, scrolled off the top, pushed sideways
+     * by a carousel.
+     *
+     * ABSENT MEANS UNKNOWN. The old React Native architecture cannot report a
+     * synchronous window-relative rect, and no SDK published before this
+     * field existed reports one at all; reading absence as `false` would make
+     * the agent refuse to press a control the user is looking at.
+     */
+    onScreen?: boolean;
+    /** Human-readable label */
+    label?: string;
+    /** Current on/off state */
+    value?: boolean;
+    /** True when this toggle lives inside a currently-visible modal. */
+    inModal?: boolean;
+}
+interface SliderSnapshot {
+    /** Registry id — the executable handle. */
+    id?: string;
+    /** How `id` was obtained. See {@link IdentityProvenance}. */
+    provenance?: IdentityProvenance;
+    /**
+     * False when the control is mounted but currently outside the window —
+     * below the fold of a ScrollView, scrolled off the top, pushed sideways
+     * by a carousel.
+     *
+     * ABSENT MEANS UNKNOWN. The old React Native architecture cannot report a
+     * synchronous window-relative rect, and no SDK published before this
+     * field existed reports one at all; reading absence as `false` would make
+     * the agent refuse to press a control the user is looking at.
+     */
+    onScreen?: boolean;
+    /** Human-readable label */
+    label?: string;
+    /** Current numeric value */
+    value?: number;
+    /** Lower bound the executor clamps to */
+    min?: number;
+    /** Upper bound the executor clamps to */
+    max?: number;
+    /** Step the executor snaps to (omitted = continuous) */
+    step?: number;
+    /** Whether the slider is currently disabled */
+    disabled?: boolean;
+    /** True when this slider lives inside a currently-visible modal. */
+    inModal?: boolean;
+}
+interface ListItemSnapshot {
+    /** Whether this row intersects the list viewport, when geometry is available. */
+    onScreen?: boolean;
+    /** 1-indexed position within the parent list (matches "selecione o terceiro"). */
+    index: number;
+    /**
+     * 0-based index of this row in the list's backing DATA, when known.
+     * For scrolled/virtualized lists this differs from `index`.
+     */
+    dataIndex?: number;
+    /** Framework key of the row, if present (typically the item's domain id). */
+    reactKey?: string;
+    /** Runtime key supplied by list tracking, if available. */
+    itemKey?: string;
+    /** Texts captured from this item's subtree, preserving row association. */
+    texts: string[];
+    /** Buttons inside this item — e.g. an inline "Edit" button on a row. */
+    buttons: ButtonSnapshot[];
+    /** Inputs inside this item — rare but possible (inline edit row). */
+    inputs: InputSnapshot[];
+    /** Toggles inside this item. */
+    toggles: ToggleSnapshot[];
+    /**
+     * Synthetic id assigned by the walker. Stable within a single
+     * snapshot; format `list-<L>-item-<I>` (0-indexed L, 1-indexed I).
+     * Used by tap-by-ordinal resolution in the executor.
+     */
+    syntheticId: string;
+}
+interface ListSnapshot {
+    /** Measured rows intersecting the list viewport; absent means unmeasurable. */
+    viewportItemCount?: number;
+    /** Mission-local exploration metadata; positions are 0-based, never action targets. */
+    exploration?: {
+        revision: number;
+        observedItemCount: number;
+        observedRanges: Array<{
+            start: number;
+            end: number;
+        }>;
+        rangesTruncated: boolean;
+        coverage: 'partial' | 'all-loaded';
+        pagination: 'possible' | 'not-declared';
+        scrollSteps: number;
+        remainingScrollSteps: number;
+        consecutiveNoProgress: number;
+        lastScroll?: 'moved' | 'no-progress' | 'boundary' | 'unverified';
+    };
+    /** 0-indexed list ordinal — multiple lists on one screen get 0, 1, 2... */
+    index: number;
+    /** Runtime list id when tracking or explicit props provide one. */
+    id?: string;
+    /** The container component/tag name as observed by the walker. */
+    containerType: string;
+    /**
+     * Source that identified this list. `'fiber'`/`'auto-tracked'` are
+     * the walker's own discovery tags (a DOM walker reports
+     * `'auto-tracked'` for app-annotated lists and omits the field for
+     * heuristically-detected ones); `'registry'` means the list came
+     * from the SDK's list registry rather than the tree walk.
+     */
+    source?: 'fiber' | 'auto-tracked' | 'registry';
+    /**
+     * How many items the list renders FROM — its `data.length`, which for
+     * a paginated list is the page and not the collection.
+     */
+    itemCount?: number;
+    /**
+     * Size of the whole collection when the app declared it.
+     *
+     * The three counts answer three different questions and a list that
+     * pages needs all three: `visibleItemCount` is what is mounted,
+     * `itemCount` is what is loaded, `totalItemCount` is what exists.
+     * Undefined means unknown — it is never a copy of `itemCount`.
+     */
+    totalItemCount?: number;
+    /** Number of row items captured in this snapshot. */
+    visibleItemCount?: number;
+    /** True when the list reports a refresh/loading state. */
+    refreshing?: boolean;
+    /** True when total item count is known and zero. */
+    empty?: boolean;
+    /** Human-readable label if the app supplied one. */
+    label?: string;
+    /** Items in visible order. */
+    items: ListItemSnapshot[];
+    /**
+     * Lightweight text projection of the list's FULL data set (capped),
+     * so the agent can see/search rows that virtualization keeps
+     * unmounted. Each entry: 0-based data index, stable key, short text.
+     */
+    dataPreview?: ListDataPreviewEntry$1[];
+    /** Current vertical scroll offset in px, when readable. */
+    scrollOffsetY?: number;
+    /** True when there is scrollable content above the viewport. */
+    canScrollUp?: boolean;
+    /** True when there is scrollable content below the viewport. */
+    canScrollDown?: boolean;
+}
+interface ListDataPreviewEntry$1 {
+    /** 0-based index in the list's backing data. */
+    index: number;
+    /** Stable key from the item's domain id when available. */
+    key?: string;
+    /** Short human-readable projection of the item (capped length). */
+    text: string;
+}
+/**
+ * A scrollable surface that is NOT a collection — a long form, a detail
+ * page, a settings screen inside a `ScrollView`.
+ *
+ * It exists as its own concept, and not as a `ListSnapshot` with zero
+ * rows, because everything the agent knows how to do with a list
+ * (ordinals, totals, "select the third one") is meaningless here. The
+ * only affordance is paging toward content below the fold — and without
+ * it, a screen taller than the viewport ends at the fold.
+ */
+interface ScrollableSnapshot {
+    /** Runtime id — the handle `scroll_list` addresses. */
+    id: string;
+    /** The container component as observed: ScrollView, ... */
+    containerType: string;
+    /** Human-readable label if the app supplied one. */
+    label?: string;
+    /** Current scroll offset in px. */
+    scrollOffsetY?: number;
+    /** True when there is content above the viewport. */
+    canScrollUp?: boolean;
+    /** True when there is content below the viewport. */
+    canScrollDown?: boolean;
+    /** True when the surface scrolls sideways rather than vertically. */
+    horizontal?: boolean;
+}
+/**
+ * A platform dialog covering the screen — React Native's `Alert.alert`,
+ * an action sheet, an OS permission prompt.
+ *
+ * It renders outside React, so no amount of tree walking finds it. It
+ * has to be reported separately or the agent keeps operating the app
+ * underneath a dialog that blocks every real finger.
+ */
+interface NativeDialogSnapshot {
+    /** Stable for as long as this dialog is open. */
+    id: string;
+    title?: string;
+    message?: string;
+    /** The buttons the user can press. Never empty. */
+    buttons: Array<{
+        label: string;
+        style?: 'default' | 'cancel' | 'destructive';
+    }>;
+}
+interface ChoiceOptionSnapshot {
+    /** 1-indexed option position within this group. */
+    index: number;
+    /** Stable-enough id for the current snapshot/action turn. */
+    syntheticId: string;
+    /** Best target id if this option is backed by a pressable component. */
+    targetId?: string;
+    /** Human-readable option label. */
+    label?: string;
+    /** Text segments that belong to this option. */
+    texts: string[];
+    /** Whether this option appears selected. */
+    selected?: boolean;
+    /** Whether this option appears disabled. */
+    disabled?: boolean;
+}
+interface ChoiceGroupSnapshot {
+    /** 0-indexed group ordinal on the current screen. */
+    index: number;
+    /** Runtime id when known, usually inherited from a list/collection. */
+    id?: string;
+    /** Human-readable label when known. */
+    label?: string;
+    /** Source that produced this choice group. */
+    source?: 'list' | 'buttons' | 'heuristic';
+    /** Visible options in order. */
+    options: ChoiceOptionSnapshot[];
+}
+interface InteractionElementListContext {
+    listIndex?: number;
+    listId?: string;
+    listLabel?: string;
+    itemIndex?: number;
+    itemKey?: string;
+    reactKey?: string;
+    syntheticId?: string;
+}
+interface InteractionElementSnapshot {
+    /** False means observation-only; absence preserves legacy client behavior. */
+    dispatchable?: boolean;
+    /** Stable id for the current screen/content, preferred for tool calls. */
+    id: string;
+    /** Semantic UI role. */
+    role: 'option' | 'button' | 'input' | 'toggle' | 'slider' | 'listItem';
+    /** Human-readable label. */
+    label?: string;
+    /** Text segments associated with this element. */
+    texts: string[];
+    /** Actions supported by this element. */
+    actions: Array<'press' | 'focus' | 'toggle' | 'setValue'>;
+    /** Whether the element is currently disabled. */
+    disabled?: boolean;
+    /** Whether the element appears selected. */
+    selected?: boolean;
+    /** Source that produced the element. */
+    source?: 'list' | 'button' | 'input' | 'toggle' | 'slider' | 'choice';
+    /**
+     * How the underlying control's identifier was obtained. Carried up from
+     * the snapshot entry this element was derived from, so a consumer that
+     * only reads `elements` still knows what it is trusting. See
+     * {@link IdentityProvenance}.
+     */
+    provenance?: IdentityProvenance;
+    /**
+     * False when the control is mounted but currently outside the window —
+     * below the fold of a ScrollView, scrolled off the top, pushed sideways
+     * by a carousel.
+     *
+     * ABSENT MEANS UNKNOWN. The old React Native architecture cannot report a
+     * synchronous window-relative rect, and no SDK published before this
+     * field existed reports one at all; reading absence as `false` would make
+     * the agent refuse to press a control the user is looking at.
+     */
+    onScreen?: boolean;
+    /** Legacy/fallback target id, if any. */
+    targetId?: string;
+    /** Context for row/list options. */
+    listContext?: InteractionElementListContext;
+    /**
+     * True when the underlying component lives inside a currently-visible
+     * modal — the only targets actually touchable while the overlay is up.
+     */
+    inModal?: boolean;
+}
+/** Window-relative box, in the coordinate space the platform reports. */
+interface ElementRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * What the CLIENT keeps about an element, which is strictly more than what
+ * the model is told about it.
+ *
+ * The wire shape (`InteractionElementSnapshot`) is sized for a language
+ * model: names, roles, state, everything it needs to decide. This one adds
+ * what only the executor needs — coordinates it will never read aloud —
+ * and it exists because that data was being measured and then discarded
+ * for want of somewhere to put it that wasn't the wire.
+ *
+ * The split is the point. Anything added here is free: it never reaches
+ * `agentSnapshotSchema`, never crosses the network, and never costs a
+ * token. Anything added to the wire type is paid for on every observation
+ * of every session, so it has to earn the model's attention.
+ */
+interface InteractionElementEntry extends InteractionElementSnapshot {
+    /**
+     * Where the control was on screen when the snapshot was taken. Absent
+     * when the platform cannot measure synchronously (React Native's old
+     * architecture) or when the element came from a source with no fiber
+     * behind it.
+     */
+    rect?: ElementRect;
+}
+/**
+ * What changed between the previous observation and this one.
+ *
+ * The client holds both snapshots; the server only ever sees one. So the
+ * question the agent loop asks most often — "did the action I just took
+ * do anything?" — is one the client can answer as a FACT and the server
+ * can only guess at. Today it guesses: `effect: 'none'` on the turn trail
+ * is derived server-side from heuristics over a single snapshot.
+ *
+ * Everything here is shape, never content: counts, booleans, and field
+ * ids that the app declared itself. That is not an accident of design —
+ * it is what lets this survive a redacted or content-free observation
+ * intact, and it is why the most useful signal in the observation is also
+ * the cheapest one to send.
+ *
+ * ABSENT vs `unchanged: true` is the load-bearing distinction, and it is
+ * the same one `truncated` exists to make. Absent means there was no
+ * previous observation to compare against (the first capture of a
+ * mission). `unchanged: true` means we DID compare and nothing moved —
+ * which is the strongest evidence there is that an action did nothing.
+ */
+interface SnapshotDelta {
+    /** The active route is not the one the previous observation reported. */
+    routeChanged?: boolean;
+    /** A modal or native dialog is up now and was not before. */
+    modalOpened?: boolean;
+    /** A modal or native dialog was up before and is gone now. */
+    modalClosed?: boolean;
+    /** A loading indicator appeared. */
+    loadingStarted?: boolean;
+    /** A loading indicator that was showing is gone. */
+    loadingFinished?: boolean;
+    /** How many distinct visible texts are present now that were not before. */
+    textsAdded?: number;
+    /** How many distinct visible texts are gone. */
+    textsRemoved?: number;
+    /** Zero-based indexes of newly visible buttons in this snapshot, capped at 12.
+     * No derived ids or copy travel in the delta; render only from current buttons.
+     */
+    buttonsAddedIndices?: number[];
+    /** Number of previously visible button identities no longer visible. */
+    buttonsRemoved?: number;
+    /** Net change in mounted list rows, summed across every list. */
+    visibleRowsDelta?: number;
+    /**
+     * Net change in the lists' reported DATA totals, summed. This is the
+     * one that answers "did the record actually get created", because it
+     * moves even when virtualization keeps the new row unmounted.
+     */
+    totalRowsDelta?: number;
+    /**
+     * Fields that went from empty to filled. Declared ids only — a
+     * `derived` id is folded from visible copy, so publishing it here
+     * would smuggle content through a field that claims to carry none.
+     */
+    fieldsNewlyFilled?: string[];
+    /** Fields that went from filled to empty. Declared ids only. */
+    fieldsCleared?: string[];
+    /** Some field is reporting invalid that was not reporting it before. */
+    invalidAppeared?: boolean;
+    /**
+     * Nothing above fired: we compared two observations and the screen is
+     * structurally identical. Present only when every other field is
+     * absent, so a reader never has to check all of them to know.
+     */
+    unchanged?: boolean;
+}
+interface ScreenSnapshot {
+    /** The currently active route name, if known */
+    route: string | null;
+    /** All visible static text */
+    texts: string[];
+    /** All text inputs currently rendered (and visible) */
+    inputs: InputSnapshot[];
+    /** All button-like components */
+    buttons: ButtonSnapshot[];
+    /** All toggle components */
+    toggles: ToggleSnapshot[];
+    /** Sliders / adjustable numeric controls. */
+    sliders: SliderSnapshot[];
+    /** Whether a loading indicator is visible */
+    loading: boolean;
+    /** Whether a modal is currently open */
+    modalOpen: boolean;
+    /**
+     * A native dialog covering the screen, when the SDK could observe one.
+     *
+     * Its presence also forces `modalOpen`, because for every purpose the
+     * agent cares about it IS a modal — nothing behind it is touchable.
+     * Absence is not proof there is no dialog: an OS permission prompt or
+     * a share sheet cannot be instrumented at all.
+     */
+    nativeDialog?: NativeDialogSnapshot;
+    /**
+     * Lists detected in the visible tree. Each list's items have their
+     * own per-item texts/buttons/inputs/toggles, NOT duplicated in the
+     * flat top-level arrays — preserving the row association the flat
+     * shape destroys.
+     */
+    lists: ListSnapshot[];
+    /**
+     * Choice groups detected from visible cards/rows/chips/buttons, used
+     * for select-like flows where no text input exists.
+     */
+    choiceGroups: ChoiceGroupSnapshot[];
+    /**
+     * Scrollable surfaces that carry no rows. Absent/empty means either
+     * the screen does not scroll or the SDK could not observe that it
+     * does — never that the visible content is all the content.
+     */
+    scrollables?: ScrollableSnapshot[];
+    /**
+     * Interaction graph: visible actionable elements with stable ids,
+     * semantic roles, labels, and execution fallbacks. Agents should
+     * prefer these ids over synthetic ordinal handles.
+     */
+    elements: InteractionElementSnapshot[];
+    /**
+     * Set when the walker's output exceeded the wire contract and
+     * `clampSnapshotToWireLimits` dropped part of it (see
+     * `introspection/wireLimits.ts`). Absent means the observation is
+     * complete.
+     *
+     * The server surfaces this to the model: a screen whose text was cut
+     * at 500 entries must not be read as a screen with only 500 things on
+     * it. Without the flag a truncated observation is indistinguishable
+     * from a short one.
+     */
+    truncated?: boolean;
+    /**
+     * What moved since the previous observation. See {@link SnapshotDelta}
+     * — absent means there was nothing to compare against, which is a
+     * different statement from "nothing changed".
+     *
+     * Attached by the platform adapter rather than by the walker: the
+     * baseline has to be the last snapshot that was actually SENT, and
+     * `captureSnapshot` is also called for internal probes that never
+     * leave the device.
+     */
+    delta?: SnapshotDelta;
+    /** Diagnostic counts for debugging */
+    stats?: {
+        visitedFibers: number;
+        skippedHidden: number;
+        /**
+         * How many controls the walker could name, and how well.
+         *
+         * `WalkDetectorCounts` counts RECOGNITIONS, not emissions, so a screen
+         * whose controls were all silently dropped still reported healthy
+         * detector numbers. This is the emission side: `positional` climbing is
+         * the signal that an app needs annotating, and comparing it between a
+         * debug and a release build is the first real measurement of what
+         * minification costs the agent.
+         */
+        identity?: {
+            declared: number;
+            derived: number;
+            positional: number;
+        };
+    };
+}
+
+type TraceListener = (entries: AppilotsTraceEntry[]) => void;
+declare function recordAppilotsDebugTrace(entry: Omit<AppilotsTraceEntry, 'id'> & {
+    id?: string;
+}): void;
+declare function getAppilotsDebugTraces(): AppilotsTraceEntry[];
+declare function clearAppilotsDebugTraces(): void;
+declare function subscribeAppilotsDebugTraces(listener: TraceListener): () => void;
+
+/** Customer action labels. Raw payloads remain in the action/debug records. */
+
+type BreadcrumbState = ActionPresentationState;
+interface BreadcrumbItem {
+    label: string;
+    state: BreadcrumbState;
+}
+declare function describeAction(action: AgentAction, locale?: AppilotsLocale): BreadcrumbItem;
+/**
+ * Convert the executor's raw error string into a short, user-facing
+ * reason that fits inside parentheses on the breadcrumb line. Returns
+ * `undefined` when there's no useful information to show — caller can
+ * then drop the parenthetical entirely.
+ *
+ * Heuristics:
+ *   - Apply known-pattern rewrites (rejected, not found, network, etc.)
+ *   - If the result looks technical (stack frame, HTTP status, JSON
+ *     dump) or is suspiciously long, fall back to "algo deu errado".
+ *   - Trim and lowercase the first letter so it reads naturally inside
+ *     the parens after the action verb.
+ */
+declare function humanizeError(raw: string | undefined, _action?: AgentAction): string | undefined;
+
+/**
+ * Shared position type.
+ *
+ * Extracted from AppilotsChat so `AgentPill` can accept it without
+ * importing the 1400-line chat module — which would pull the whole
+ * chat (and its hooks, and the client) into any test that renders just
+ * the pill.
+ */
+type AppilotsChatPosition = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+
+/**
+ * The speech seam.
+ *
+ * The SDK ships no speech engine and never will. Every usable one on
+ * React Native is a native module — `@react-native-voice/voice`,
+ * `expo-speech-recognition`, a vendor SDK — and a dependency here would
+ * force native linking on every integrator, including the majority who
+ * will never turn voice on. Worse, it would pick their engine for them:
+ * the right one depends on the locale they need, whether recognition
+ * may leave the device, and what their app store review already covers.
+ *
+ * So this is an interface and nothing else, injected the same way
+ * `GeometryHost` and the `Alert` in `confirmedDestructiveAlert` are.
+ * Pass an adapter and the mic button appears; pass nothing and
+ * `resolveExperience` reports `input: 'voice'` as an unmet request
+ * rather than rendering a button that does nothing.
+ *
+ * Everything here is transcription only. Playing audio back is not
+ * modelled, because nothing in the loop produces audio.
+ */
+/** What the SDK needs to run a hold-to-talk button. */
+interface SpeechHost {
+    /**
+     * Begin listening. Resolve once capture is actually running, so the
+     * UI can wait before telling the user to speak.
+     *
+     * Implementations own permissions: if the OS prompt has not been
+     * accepted, request it here and reject when refused.
+     */
+    start(options: SpeechStartOptions): Promise<void>;
+    /**
+     * Stop listening and resolve with the final transcript.
+     *
+     * Resolving with an empty string is the normal outcome for "the user
+     * pressed and said nothing" — it must not reject for that.
+     */
+    stop(): Promise<string>;
+    /** Abandon the capture. No transcript, no error. */
+    cancel(): Promise<void>;
+    /**
+     * Partial results while the user is still talking, if the engine has
+     * them. Return a disposer. Optional — a host without interim results
+     * simply shows the placeholder until `stop` resolves.
+     */
+    onPartial?(listener: (text: string) => void): () => void;
+}
+interface SpeechStartOptions {
+    /**
+     * BCP-47 tag resolved from the chat's locale, so a pt-BR chat does
+     * not transcribe against a US English model. Hosts that only support
+     * one locale may ignore it.
+     */
+    locale: string;
+}
+
+/**
+ * Pure resolution for the chat's *experience* config — the knobs that
+ * decide what the user sees WHILE the agent drives the app, and how a
+ * turn gets started.
+ *
+ * Same pattern as `personalization.ts`: no `react-native` import, no
+ * side effects, so the precedence and coherence rules are unit-testable
+ * without rendering a tree.
+ *
+ * ## Why this is a resolver and not five booleans
+ *
+ * These knobs are layers, not independent switches. A spotlight ring
+ * drawn while the sheet is up lands BEHIND a full-screen scrim; shared
+ * control behind a native `Modal` cannot exist at all, because the
+ * modal swallows every touch before the app sees it. Exposed as raw
+ * booleans, most of the combination space renders something broken, and
+ * the only way to find out is to run it.
+ *
+ * So the config is *requested*, not applied. Everything here narrows a
+ * request down to a combination that is coherent by construction, and
+ * reports what it had to change. The render code downstream never has
+ * to ask "is this combination possible" — by the time it sees a
+ * `ResolvedExperience`, it is.
+ *
+ * Downgrades are returned rather than logged so the caller decides the
+ * channel (dev warning, telemetry, both) — the same reason
+ * `probeNameMangling` returns its findings instead of printing them.
+ */
+/**
+ * What the user sees while the agent is executing actions.
+ *  - `sheet`  — today's behavior: the chat stays up, app covered.
+ *  - `pill`   — the sheet collapses to a status line; app visible and
+ *               interactive.
+ *  - `hidden` — nothing but the app. The turn reports back when it ends
+ *               or when it needs an answer.
+ */
+type AppilotsPresence = 'sheet' | 'pill' | 'hidden';
+/**
+ * Whether the element being acted on is marked on the app itself.
+ *  - `off`    — no overlay.
+ *  - `ring`   — outline the target; skip it when it is off-screen.
+ *  - `guided` — scroll the target into view first, then outline it.
+ */
+type AppilotsSpotlight = 'off' | 'ring' | 'guided';
+/**
+ * Who may operate the app during a turn.
+ *  - `agent`  — the agent alone; a user touch is not treated specially.
+ *  - `shared` — a user touch pauses the queue and invalidates the
+ *               snapshot the model reasoned about.
+ */
+type AppilotsControl = 'agent' | 'shared';
+/**
+ * Ways a turn can be started that the SDK installs by itself.
+ *
+ * `commandBar` is deliberately NOT here: it is a component the host
+ * places in its own header, so a flag could not mount it. It ships as
+ * an ordinary export instead.
+ */
+type AppilotsEntryPoint = 'fab' | 'longPress' | 'contextual';
+/** Composer input modalities. `voice` needs an injected `SpeechHost`. */
+type AppilotsInputMode = 'text' | 'voice';
+interface AppilotsExperience {
+    presence?: AppilotsPresence;
+    spotlight?: AppilotsSpotlight;
+    control?: AppilotsControl;
+    entry?: AppilotsEntryPoint[];
+    input?: AppilotsInputMode[];
+}
+interface ResolvedExperience {
+    presence: AppilotsPresence;
+    spotlight: AppilotsSpotlight;
+    control: AppilotsControl;
+    entry: AppilotsEntryPoint[];
+    input: AppilotsInputMode[];
+}
+/**
+ * Runtime facts the resolver cannot read for itself — injected for the
+ * same reason `GeometryHost` is: this file must stay importable in a
+ * plain unit test with no React Native under it.
+ */
+interface ExperienceCapabilities {
+    /**
+     * Fabric geometry is readable. Window-relative rects are the only
+     * thing that can place a ring over a real control, and the old
+     * architecture cannot report them at all — see `introspection/geometry.ts`.
+     */
+    geometry: boolean;
+    /** A `SpeechHost` was injected. Without one the mic button is inert. */
+    speech: boolean;
+}
+interface ExperienceDowngrade {
+    field: keyof ResolvedExperience;
+    from: string;
+    to: string;
+    /** Developer-facing, English, no i18n — this never reaches an end user. */
+    reason: string;
+}
+interface ExperienceResolution {
+    experience: ResolvedExperience;
+    /** Empty when the request was already coherent. */
+    downgrades: ExperienceDowngrade[];
+}
+/**
+ * Today's shipped behavior, exactly. The new presences are opt-in for
+ * now so no existing integration changes when it upgrades the SDK.
+ */
+declare const DEFAULT_EXPERIENCE: ResolvedExperience;
+/**
+ * Narrow a requested experience to one that can actually render.
+ *
+ * Rules are applied in dependency order: a knob that gets switched off
+ * for lack of a capability must not go on to force a change in another
+ * knob. Concretely — spotlight loses to missing geometry BEFORE it gets
+ * the chance to pull `presence` off the sheet, so an old-architecture
+ * app that asked for a spotlight keeps the sheet it already had rather
+ * than being moved to a pill it never requested.
+ */
+declare function resolveExperience(requested: AppilotsExperience | undefined, caps: ExperienceCapabilities): ExperienceResolution;
+/** One-line-per-downgrade text, for a dev-mode console warning. */
+declare function formatDowngrades(downgrades: readonly ExperienceDowngrade[]): string[];
+
 interface AppilotsThemeProviderProps {
     /**
      * Partial token overrides — merged on top of the resolved base
@@ -153,6 +1035,24 @@ interface AppilotsStrings {
     escalationPendingBanner: string;
     /** Thin banner under the header while connected to an operator. */
     escalationActiveBanner: string;
+    /** Pill label while the turn is running but no action has started yet. */
+    pillWorking: string;
+    /** A11y label for the pill as a whole — tapping it opens the sheet. */
+    pillExpandA11y: string;
+    /** A11y label for the pill's stop button. */
+    pillStopA11y: string;
+    missionPause: string;
+    missionResume: string;
+    missionCancel: string;
+    missionPaused: string;
+    /** Pill label after the turn ends, before the user opens the sheet. */
+    pillDone: string;
+    /** A11y label for the hold-to-talk mic button at rest. */
+    micStartA11y: string;
+    /** A11y label while a capture is running. */
+    micStopA11y: string;
+    /** Placeholder shown in the composer while listening. */
+    micListening: string;
 }
 type AppilotsStringKey = keyof AppilotsStrings;
 
@@ -188,7 +1088,7 @@ interface AppilotsI18nProviderProps {
     overrides?: Partial<AppilotsStrings> | null;
     children: React__default.ReactNode;
 }
-declare function AppilotsI18nProvider({ locale, overrides, children, }: AppilotsI18nProviderProps): React__default.JSX.Element;
+declare function AppilotsI18nProvider({ locale, overrides, children }: AppilotsI18nProviderProps): React__default.JSX.Element;
 /**
  * Read the locale + strings from context. Falls back to the default
  * locale bundle if no provider is mounted, so components don't need a
@@ -204,7 +1104,7 @@ declare function useAppilotsI18n(): I18nContextValue;
  *  - `inline`     — render inline where it's mounted, no modal at all
  */
 type AppilotsChatMode = 'bubble' | 'fullscreen' | 'sidebar' | 'inline';
-type AppilotsChatPosition = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+
 interface AppilotsChatProps {
     /** Controlled visibility — when set, the FAB is hidden. */
     visible?: boolean;
@@ -273,6 +1173,28 @@ interface AppilotsChatProps {
      * Ignored when `triggerIcon` is set.
      */
     triggerButtonImage?: string | number;
+    /**
+     * What the user sees WHILE the agent drives the app, and how a turn
+     * can be started.
+     *
+     * Omit it and nothing changes: the default is `presence: 'sheet'`,
+     * which is the behavior every version of this component has had —
+     * the chat stays up and the app is covered while actions run.
+     *
+     * The knobs are layers rather than independent switches, so the
+     * request is normalised by `resolveExperience` before anything
+     * renders; an impossible combination is narrowed to the nearest
+     * possible one and reported via a dev-mode warning instead of
+     * rendering something broken. See `components/experience.ts`.
+     */
+    experience?: AppilotsExperience;
+    /**
+     * Speech-to-text adapter. Required for `experience.input: ['voice']` —
+     * the SDK ships no engine of its own, on purpose (see
+     * `components/speech.ts`). Without one, a voice request is reported as
+     * unmet instead of rendering a mic button that cannot listen.
+     */
+    speech?: SpeechHost;
     /** Force a locale. Falls through to device detection when omitted. */
     locale?: AppilotsLocale;
 }
@@ -365,26 +1287,429 @@ interface ConfirmDialogProps {
 declare function ConfirmDialog(_props?: ConfirmDialogProps): React__default.ReactElement | null;
 
 /**
- * Pure presentation logic for ActionBreadcrumb, extracted from the RN
- * component (same pattern as `humanizeAction.ts` / `chatTimeline.ts`)
- * so it can be unit tested without a renderer:
- *   - lifecycle state → tone (colors) and icon glyph;
- *   - destructive detection (payload flag or action-level flag);
- *   - confirm-card copy + colors derivation (title / message / button
- *     labels / accent color / surface / border) with the
- *     destructive-aware defaults.
+ * AgentPill — the collapsed surface for `presence: 'pill' | 'hidden'`.
+ *
+ * One line saying what the agent is doing right now, floating over the
+ * host app instead of covering it. This is the piece that makes the
+ * rest of the experience layer possible: while it is up, the app is
+ * fully visible AND fully touchable, because — unlike the sheet — the
+ * pill is NOT inside a native `Modal`. It renders as an absolutely
+ * positioned sibling, the same layer the FAB has always used.
+ *
+ * That placement is the whole design, so it is worth stating why it
+ * cannot be otherwise: a React Native `Modal` is a real platform modal.
+ * It takes every touch before the app below sees one, and no
+ * `pointerEvents` setting on our side changes that. Anything that wants
+ * the user to keep using their app has to live outside it.
+ *
+ * Presentational on purpose — it decides nothing about WHEN it shows
+ * (that is `presence.ts`) and nothing about what the label says (that
+ * is `describeAction` in client-core, the same source the breadcrumb
+ * uses, so the pill and the expanded transcript can never disagree).
+ */
+
+interface AgentPillStrings {
+    expandA11y: string;
+    stopA11y: string;
+}
+interface AgentPillProps {
+    /** What to say. Already humanised and localised by the caller. */
+    label: string;
+    /** Drives the leading glyph: spinner while running, check when done. */
+    state: BreadcrumbState;
+    /** Tap anywhere on the pill — raises the full sheet. */
+    onExpand: () => void;
+    /**
+     * Stop button. Omit to hide it — there is nothing to cancel once the
+     * turn has ended, and a dead button on a one-line surface is worse
+     * than no button.
+     */
+    onStop?: () => void;
+    /** Only the vertical half is read; the pill always spans the width. */
+    position: AppilotsChatPosition;
+    /** Safe-area insets, so the pill clears the notch and the home bar. */
+    insets: {
+        top: number;
+        bottom: number;
+    };
+    colors: {
+        surface: string;
+        text: string;
+        textSecondary: string;
+        primary: string;
+        border: string;
+        success: string;
+        error: string;
+    };
+    fontFamily?: string;
+    strings: AgentPillStrings;
+}
+declare function AgentPill({ label, state, onExpand, onStop, position, insets, colors, fontFamily, strings, }: AgentPillProps): React__default.JSX.Element;
+
+/**
+ * Is this control actually on the screen right now?
+ *
+ * Nothing answered that until now. `shouldSkipSubtree` prunes what React
+ * has HIDDEN — `display: 'none'`, a closed Modal, an inactive tab — but a
+ * button sitting below the fold of a `ScrollView` is mounted, visible to the
+ * walker, and reported as an ordinary pressable target. The agent presses
+ * it, the press lands on a view the user cannot see, and the reply says the
+ * work is done. `scrollables` tells the model the screen CAN scroll; it
+ * never says which controls are currently off it.
+ *
+ * ## Why this is Fabric-only, and why that is not a cop-out
+ *
+ * Position in a comparable space is the whole problem. `onLayout` reports
+ * coordinates relative to the PARENT, so composing them means measuring
+ * every ancestor too — and ancestors are plain Views nobody tracks.
+ * `measure`/`measureInWindow` are callback-based, and the introspection
+ * layer is synchronous end to end (`captureSnapshot` returns a value;
+ * making it async would change the signature of every caller).
+ *
+ * Fabric's `getBoundingClientRect(node, includeTransform)` is neither: it is
+ * a synchronous JSI call returning `[x, y, width, height]` in WINDOW
+ * coordinates, and React Native exposes it on host instances as
+ * `unstable_getBoundingClientRect()`. That is the one API that fits, so the
+ * old architecture gets no geometry and says so rather than guessing.
+ *
+ * ## The seam
+ *
+ * The reader is injected, not imported — the same reason
+ * `confirmedDestructiveAlert` takes its Alert and `probeNameMangling` takes
+ * its components. It also happens to be the only way this is testable at
+ * all: the render tests drive `react-test-renderer`, which builds a genuine
+ * fiber tree with NO host platform, so `stateNode` there is a test instance
+ * with no rect to read. Everything below is policy over injected numbers;
+ * the real-device half is what the Detox release lane is for.
+ */
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+type GeometryAvailability = 
+/** A host is installed and returning rects. */
+'available'
+/** No host installed — old architecture, or the provider never wired it. */
+ | 'unavailable'
+/** A host is installed but every instance refused to measure. */
+ | 'silent';
+
+/**
+ * The ring drawn over the control the agent is acting on.
+ *
+ * This is the piece that makes the app the canvas instead of the chat:
+ * with `presence: 'pill'` the user can see their app, and with a ring on
+ * it they can see WHICH part of it the agent just touched — which is the
+ * difference between watching a screen change and understanding why.
+ *
+ * ## Absolutely positioned Views, not SVG
+ *
+ * A stroked rounded rect is one `<Rect>` in `react-native-svg` and four
+ * borders in plain RN. The SVG version would be marginally cleaner and
+ * would put a peer dependency on every integrator who turns the
+ * spotlight on, including the ones who have no other use for it. The SDK
+ * has no runtime dependency beyond React Native today and this feature
+ * is not worth being the first.
+ *
+ * ## Never interactive
+ *
+ * `pointerEvents="none"` throughout. The ring marks a control the user
+ * can still press themselves — swallowing that press to draw decoration
+ * over it would defeat the point of leaving the app touchable.
+ */
+
+interface SpotlightOverlayProps {
+    rect: Rect;
+    /** Changes on every publish, including a repeat of the same rect. */
+    seq: number;
+    /** Optional one-line caption. Omitted when there is no room above/below. */
+    label?: string;
+    color: string;
+    /** Caption text/background. Unused when `label` is absent. */
+    captionBackground: string;
+    captionColor: string;
+    fontFamily?: string;
+    /** Window size, to keep the caption on screen. */
+    window: {
+        width: number;
+        height: number;
+    };
+}
+declare function SpotlightOverlay({ rect, seq, label, color, captionBackground, captionColor, fontFamily, window: win, }: SpotlightOverlayProps): React__default.JSX.Element | null;
+
+/**
+ * Where the agent is about to act — published by the executor, read by
+ * whatever wants to draw on it.
+ *
+ * A tiny store rather than a prop or an event payload, because the two
+ * ends are far apart and neither should learn about the other: the
+ * executor resolves controls and knows nothing about rendering, and the
+ * chat renders and knows nothing about how a target was resolved. Same
+ * shape as `navigationState`, and for the same reason.
+ *
+ * ## Why the rect is measured by the publisher, not the subscriber
+ *
+ * By the time a React subscriber re-renders, the press has already
+ * happened and the control may have moved, unmounted, or navigated away.
+ * The only moment the rect is true is immediately before dispatch, so
+ * the executor measures there and publishes a value. Subscribers get a
+ * snapshot of a moment, not a live handle to a fiber.
+ *
+ * ## Why it clears itself
+ *
+ * A highlight with no expiry is a highlight that survives the action it
+ * describes: press "Delete", navigate away, and the ring is still
+ * sitting over whatever now occupies those coordinates. Every publish
+ * therefore carries its own deadline and the store forgets on its own.
+ */
+
+interface SpotlightTarget {
+    rect: Rect;
+    /** Humanised description of the action, for an optional caption. */
+    label?: string;
+    /** Monotonic id so a subscriber can tell a re-publish from a re-render. */
+    seq: number;
+}
+type Listener$2 = (target: SpotlightTarget | null) => void;
+/**
+ * How long a ring stays up after the action it marks.
+ *
+ * Long enough to be seen — under ~400ms a highlight reads as a flicker —
+ * and short enough that a fast queue does not stack rings from three
+ * actions ago on top of the current one.
+ */
+declare const SPOTLIGHT_TTL_MS = 1200;
+type SpotlightMode = 'off' | 'ring' | 'guided';
+declare function setSpotlightMode(next: SpotlightMode): void;
+declare function getSpotlightMode(): SpotlightMode;
+/**
+ * Publish the control the agent is acting on.
+ *
+ * `null` clears immediately — used when an action resolves to nothing
+ * measurable, so the previous ring does not linger over an unrelated
+ * control and imply the agent is aiming at it.
+ */
+declare function setSpotlightTarget(rect: Rect | null, label?: string): void;
+declare function getSpotlightTarget(): SpotlightTarget | null;
+/** Subscribe. Returns the unsubscribe. Does NOT fire on subscribe. */
+declare function subscribeSpotlight(listener: Listener$2): () => void;
+
+/**
+ * React binding over the spotlight store.
+ *
+ * `useSyncExternalStore` rather than a `useState` + `useEffect` pair:
+ * the store is written from the executor, which runs OUTSIDE React's
+ * dispatch — a press handler called directly on a fiber. Without the
+ * external-store contract a publish landing mid-render can be missed
+ * entirely, which for a highlight means an action nobody saw marked.
+ */
+
+/**
+ * @param enabled When false the hook subscribes to nothing and always
+ * returns null. Passing `false` rather than not calling the hook keeps
+ * the call unconditional (hooks rules) while still costing nothing:
+ * a disabled spotlight must not re-render the chat on every agent action.
+ */
+declare function useSpotlight(enabled: boolean): SpotlightTarget | null;
+
+/**
+ * Bring a control into view before the agent presses it.
+ *
+ * The problem, restated: the executor dispatches on the fiber, so a
+ * control below the fold is just as pressable as one in front of the
+ * user. The app reacts, the screen changes, and nothing on screen ever
+ * showed what was touched. `spotlight: 'guided'` is the setting that
+ * says "do not do that" — scroll first, then act.
+ *
+ * The arithmetic lives in `scrollIntoView.ts`; this file is the part
+ * that has to talk to registries and instances, and it is deliberately
+ * conservative about when it will act at all.
+ */
+
+interface RevealResult {
+    /** Where the control will be once the scroll lands. */
+    rect: Rect;
+    /** True when a scroll was actually issued. */
+    scrolled: boolean;
+}
+/**
+ * Scroll so `rect` is visible, and return where it will end up.
+ *
+ * Returns the rect UNCHANGED when nothing was or could be done, so the
+ * caller always has something to publish and never has to branch on
+ * "did this work".
+ *
+ * ## Why the returned rect is predicted rather than re-measured
+ *
+ * A scroll does not land within the synchronous call that starts it,
+ * and the dispatch path is synchronous end to end (`captureSnapshot`
+ * returns a value; making this async would change the signature of
+ * every handler above it). Re-measuring here would read the position
+ * BEFORE the scroll — worse than not measuring. The prediction is
+ * exact, though: the offset delta is known, and a scroll translates its
+ * content by exactly that.
+ */
+declare function revealTarget(rect: Rect): RevealResult;
+
+/**
+ * How far to scroll so a control the agent is about to press is
+ * actually on screen.
+ *
+ * ## Why this exists at all
+ *
+ * The executor dispatches at the fiber level: it calls `onPress` on the
+ * component directly, which works whether or not the control is
+ * visible. A button below the fold is mounted, reachable, and pressable
+ * — so the agent presses it, the app reacts, and the user sees a screen
+ * change with no visible cause. `geometry.ts` was written to detect
+ * that; this is the half that fixes it.
+ *
+ * Pure on purpose. It takes numbers and returns a number, so every case
+ * that matters — target above, below, partially cut off, a list that
+ * cannot scroll far enough — is a table entry rather than a device.
+ */
+
+interface ScrollMetrics {
+    /** Current offset, px. */
+    offset: number;
+    /** Viewport length, px. */
+    visibleLength: number;
+    /** Total content length, px. */
+    contentLength: number;
+}
+/**
+ * Breathing room left between the control and the viewport edge.
+ *
+ * A control flush against the edge is technically visible and reads as
+ * cut off, and on a phone the edge is where the notch, the home
+ * indicator and any sticky header actually live.
+ */
+declare const REVEAL_MARGIN = 24;
+interface RevealInput {
+    /** Target, in the same coordinate space as the viewport below. */
+    rect: Rect;
+    /**
+     * The scrollable's viewport in WINDOW coordinates.
+     *
+     * Not the window itself: a list occupying the middle of the screen
+     * under a header and above a tab bar has a viewport that starts below
+     * zero-y, and scrolling a target to "y = 24" would put it under the
+     * header.
+     */
+    viewport: {
+        top: number;
+        height: number;
+    };
+    metrics: ScrollMetrics;
+}
+/**
+ * The offset to scroll to, or null when nothing needs to move.
+ *
+ * Null covers two different situations on purpose — already visible,
+ * and no scroll that would help — because the caller does the same
+ * thing in both: dispatch anyway and let the geometry policy report
+ * what it can see. The distinction is the caller's to log, not ours to
+ * encode in a magic number.
+ */
+declare function offsetToReveal({ rect, viewport, metrics }: RevealInput): number | null;
+
+/**
+ * What the chat surface shows, given the experience config and where
+ * the current turn is.
+ *
+ * Split out of AppilotsChat for the same reason as `chatTimeline.ts`:
+ * the interesting part is a handful of precedence rules, and rules are
+ * far cheaper to get right against a table of cases than against a
+ * rendered tree.
+ *
+ * The one rule worth stating out loud is the safety rule in
+ * `resolveSurface`: a question that blocks the turn is never hidden,
+ * whatever the config asks for. Every other knob here trades visibility
+ * for a better view of the app; that one would trade it for a turn that
+ * hangs forever with nothing on screen explaining why.
+ */
+
+/** What the chat renders right now. */
+type SurfaceState = 
+/** Full sheet / modal — the app is covered. */
+'sheet'
+/** Collapsed status line — the app is visible and interactive. */
+ | 'pill'
+/** Nothing but the trigger (if the entry config renders one). */
+ | 'none';
+interface TurnActivity {
+    /** Waiting on the model, or draining the action queue. */
+    busy: boolean;
+    /** An app action has started in this request, including continuation waits. */
+    acting?: boolean;
+    /**
+     * An action is parked waiting for a human answer — a confirm gate, or
+     * any pending action under `autoExecute: false`.
+     */
+    awaitingUser: boolean;
+    /** The user wants the sheet up (tapped the trigger, or `visible` is set). */
+    open: boolean;
+    /** Host app still owns an open modal/sheet; defer automatic presentation. */
+    hostModalOpen?: boolean;
+    /** An explicit tap may expand the reply; automatic turn-end expansion may not. */
+    explicitlyOpened?: boolean;
+    /**
+     * A turn has finished and nobody has looked at the result yet.
+     *
+     * Only `presence: 'hidden'` can reach this: it drops the sheet for
+     * real when a turn starts, so without a resting pill the turn would
+     * end with nothing on screen and the answer buried behind the
+     * trigger. `pill` reopens instead, and `sheet` never left.
+     */
+    unread?: boolean;
+}
+/**
+ * Resolve the surface for one render.
+ *
+ * `presence: 'sheet'` is deliberately the first branch and returns
+ * before any other rule runs — it must reproduce the pre-experience
+ * behavior byte for byte, so an app that never sets `experience` cannot
+ * observe that this module was introduced at all.
+ */
+declare function resolveSurface(presence: AppilotsPresence, activity: TurnActivity): SurfaceState;
+/**
+ * Should the sheet come back by itself when the turn finishes?
+ *
+ * `pill` is the "watch it work, then read the answer" loop: the sheet
+ * steps aside for the execution and returns with the reply. `hidden`
+ * means the user asked not to be interrupted, so the reply waits behind
+ * the pill until they ask for it.
+ */
+declare function shouldReopenOnTurnEnd(presence: AppilotsPresence): boolean;
+/**
+ * Does this presence ever collapse a live turn onto the pill?
+ *
+ * Callers use it to decide whether to pay for the pill's subscription
+ * and animation at all — under `sheet` none of it can ever render.
+ */
+declare function usesPill(presence: AppilotsPresence): boolean;
+
+interface PillStatus {
+    label: string;
+    state: BreadcrumbState;
+}
+interface PillStatusStrings {
+    /** Turn is live but no action has been dispatched yet. */
+    working: string;
+    locale?: AppilotsLocale;
+    /** Turn is over and the result has not been read. */
+    done: string;
+}
+/**
+ * Pick the line for this frame.
  *
- * BACKLOG 4.2 — theming: this module used to hardcode every color
- * (`#FFFFFF` card background, `#DC2626` destructive red, etc.), which is
- * why the theme's `secondary`/`success`/`warning`/`error` tokens had no
- * effect on the chat at all — nothing consumed them. Every color now
- * comes from a `BreadcrumbPalette` the caller passes in (ultimately
- * `useAppilotsTheme()` in AppilotsChat). `DEFAULT_BREADCRUMB_PALETTE` is
- * built from the SDK's bundled `defaultLightTheme`, and `tokens.ts` picks
- * its `success`/`warning`/`error` defaults to exactly reproduce the OLD
- * hardcoded hex values below — so a caller on the default theme renders
- * pixel-identical to before.
+ * `actions` is the whole turn in emission order — the same array the
+ * breadcrumb renders, unfiltered, so callers don't have to keep a
+ * second one in sync.
  */
+declare function resolvePillStatus(actions: readonly AgentAction[], busy: boolean, strings: PillStatusStrings): PillStatus;
 
 /**
  * The subset of theme tokens the breadcrumb (rows + confirm card)
@@ -425,26 +1750,6 @@ interface ConfirmCardStrings {
     confirmThisAction: string;
 }
 
-/**
- * ActionBreadcrumb — compact, line-per-action progress UI.
- *
- * Replaces the per-action "card" UI with something closer to a CI build
- * log: each action is one line, stamped with an icon that reflects its
- * lifecycle state. Spinners on running actions, checks on success, ✗
- * on failure. Failures show a humanised reason in parens.
- *
- * Why a separate component (instead of leaving render code inline in
- * AppilotsChat.tsx): the lifecycle state animation is non-trivial and
- * the same UI is now also rendered in three places (Mailing the spec
- * — empty state, between message bubbles, and inline footer). Keeping
- * it in one file makes the styling consistent.
- *
- * The component does NOT decide approve/reject visibility on its own —
- * the caller passes `requireApprovalFor(action)` so this component stays
- * presentational and the policy lives where the rest of the auto-execute
- * config does (AppilotsChat).
- */
-
 interface ActionBreadcrumbProps {
     /** Actions to render, ordered by emission. Caller dedupes / groups. */
     actions: AgentAction[];
@@ -466,6 +1771,7 @@ interface ActionBreadcrumbProps {
      * the pt-BR literals it always shipped (#402). AppilotsChat passes it.
      */
     confirmStrings?: ConfirmCardStrings;
+    locale?: AppilotsLocale;
     /**
      * Approve/reject inline buttons appear when this returns true for an
      * action in `pending` state. `confirm`-type actions are normally
@@ -476,7 +1782,7 @@ interface ActionBreadcrumbProps {
     onApprove?: (actionId: string) => void;
     onReject?: (actionId: string) => void;
 }
-declare function ActionBreadcrumb({ actions, primaryColor, textColor, fontFamily, palette, confirmStrings, requireApprovalFor, onApprove, onReject, }: ActionBreadcrumbProps): React__default.JSX.Element | null;
+declare function ActionBreadcrumb({ actions, primaryColor, textColor, fontFamily, palette, confirmStrings, locale, requireApprovalFor, onApprove, onReject, }: ActionBreadcrumbProps): React__default.JSX.Element | null;
 
 interface ChatIconProps {
     /** Outer width/height in points. Default 24. */
@@ -514,6 +1820,16 @@ interface HeadsetIconProps {
  */
 declare function HeadsetIcon({ size, color }: HeadsetIconProps): React$1.JSX.Element;
 
+type Observation = NonNullable<ListSnapshot['exploration']>;
+/** Local, bounded metadata only. No text, records, callbacks or historical action targets. */
+declare function createListExploration(): {
+    reset: () => void;
+    update(nextKeys: Array<string | undefined>, nextCount: number | undefined, nextSource: unknown, nextScope: unknown, mayPaginate: boolean): void;
+    observe(items: ListSnapshot["items"]): void;
+    recordScroll(outcome: NonNullable<Observation["lastScroll"]>): void;
+    snapshot(): Observation;
+};
+
 /**
  * ListRegistry — runtime metadata for list/collection components.
  *
@@ -553,12 +1869,43 @@ interface ListEntry {
      * container that has no third anything.
      */
     kind: 'list' | 'scroll';
+    /** Runtime-only mission memory. Never serialize this object. */
+    exploration?: ReturnType<typeof createListExploration>;
     /** Stable runtime id assigned from testID/accessibilityLabel or generated. */
     id: string;
     /** Component name: FlatList, SectionList, VirtualizedList, FlashList, etc. */
     component: string;
-    /** Total items in the backing data set when the component exposes it. */
+    /**
+     * How many items the list is CURRENTLY RENDERING FROM — `data.length`,
+     * not the size of the collection it is a window onto.
+     *
+     * The distinction is the whole point and the old wording ("total items
+     * in the backing data set") got it wrong. For a list that holds all its
+     * data the two coincide, so nothing downstream noticed. For a PAGINATED
+     * list they never coincide: a screen showing page 1 of 36 vehicles has
+     * `itemCount === 20`, and every consumer that read this as the total
+     * told the agent the list had twenty items in it.
+     *
+     * The agent then answers "you have 20 vehicles" — not a hedge, not a
+     * partial reading, a wrong count stated plainly — and it has no way to
+     * know better, because nothing in the observation distinguishes "this
+     * is all of them" from "this is the first page". Where the app knows
+     * the real total, `totalItemCount` below carries it.
+     */
     itemCount?: number;
+    /**
+     * Size of the full collection, when the APP knows it and the list
+     * cannot: a server-reported total behind pagination, a filtered count,
+     * an infinite feed's header figure.
+     *
+     * Only the app can supply this — it lives in the response the screen
+     * fetched, never in the RN component, which by construction sees only
+     * the page it was handed. Left undefined it means exactly "unknown",
+     * which is honest and different from "equal to itemCount": a consumer
+     * must not fill it in from `itemCount`, because that is precisely the
+     * conflation this field exists to break.
+     */
+    totalItemCount?: number;
     /** Human-readable label if the app supplied one. */
     label?: string;
     /** Screen where this list is registered, when available. */
@@ -579,6 +1926,22 @@ interface ListEntry {
     scrollToOffset?: (offset: number) => boolean;
     /** Read live scroll metrics off the component instance, when possible. */
     getScrollMetrics?: () => ListScrollMetrics | undefined;
+    /**
+     * The scrollable's own rect in WINDOW coordinates, when geometry is
+     * available.
+     *
+     * Needed because the viewport is not the window: a list sitting under
+     * a header and above a tab bar has a usable band that starts well
+     * below y=0, and scrolling a control to the top of the SCREEN would
+     * park it under that header — visible to geometry, invisible to the
+     * person watching.
+     */
+    measureViewport?: () => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
 }
 type Listener$1 = (id: string, entry: ListEntry | null) => void;
 type ListRegistry = ListRegistryImpl;
@@ -651,33 +2014,41 @@ declare function AppilotsRegistryProvider({ value, children, }: {
 declare function useResolvedRegistry(): ComponentRegistry;
 
 /**
- * initAppilots — SDK initialisation & auto-config resolution.
- *
- * The preferred setup is fully automatic:
- *
- * 1. Add `withAppilots()` to your metro.config.js (one-time):
- * ```js
- * const { withAppilots } = require('@appilots/sdk/metro');
- * module.exports = withAppilots(mergeConfig(defaultConfig, config));
- * ```
- *
- * 2. Create a `.appilotsrc` JSON file at the project root.
+ * Declare the size of the collection a list is a WINDOW onto.
  *
- * 3. Use AppilotsProvider with zero props — config is loaded automatically:
  * ```tsx
- * <AppilotsProvider>
- *   <App />
- *   <AppilotsChat />
- * </AppilotsProvider>
+ * <FlatList data={page} {...appilotsListTotal(total)} … />
  * ```
  *
- * You can also call initAppilots() manually if you prefer explicit control:
- * ```tsx
- * initAppilots({ projectId: 'my-app', apiKey: 'ak_...' });
- * ```
+ * A list that pages cannot be asked this: its `data` is the page, so
+ * every count derived from the component describes the window and not
+ * what the window looks onto. The app is the only party holding the
+ * number — it arrived in the same response as the page — so the SDK
+ * takes it as a declaration and never infers it.
+ *
+ * Pass `undefined` when the total is genuinely unknown (still loading,
+ * an endless feed). Undefined is a different fact from "the same as what
+ * is loaded", and the SDK keeps them apart: a list with no declared
+ * total reports only what it has, which is exactly what is known.
+ *
+ * ── Why a helper and not just the prop ────────────────────────
+ *
+ * `FlatListProps` is React Native's type, not ours. Augmenting it
+ * globally would add an Appilots prop to every list in every consumer's
+ * app, including apps that never integrated — a package reaching into
+ * another package's public types. A JSX spread carries the extra key
+ * without an excess-property error, so this stays narrow, explicit, and
+ * greppable: someone reading the screen sees where the number came from.
  */
+declare function appilotsListTotal(total: number | undefined): {
+    appilotsTotalItemCount: number | undefined;
+};
 
 interface AppilotsRC {
+    /** Restore a session handle using the host's storage; no UI snapshots are stored. */
+    sessionStorage?: AppilotsSessionStorage;
+    /** Metro reuses installed AsyncStorage by default. Set false to keep sessions in memory. */
+    sessionPersistence?: boolean;
     /** Project ID from the Appilots dashboard */
     projectId: string;
     /** SDK API key (ak_...) */
@@ -903,14 +2274,6 @@ interface NameManglingProbe {
     observed: Record<string, string | null>;
 }
 
-type GeometryAvailability = 
-/** A host is installed and returning rects. */
-'available'
-/** No host installed — old architecture, or the provider never wired it. */
- | 'unavailable'
-/** A host is installed but every instance refused to measure. */
- | 'silent';
-
 /**
  * walkFiber — Depth-first traversal of a React fiber tree.
  *
@@ -1261,8 +2624,16 @@ interface ActionResult {
 interface ExecutorContext {
     /** React Navigation ref for navigate actions */
     navigationRef: React.MutableRefObject<any>;
-    /** SDK permissions from AppilotsConfig */
-    permissions: AgentPermissions;
+    /**
+     * SDK permissions from AppilotsConfig.
+     *
+     * PARTIAL on purpose: `.appilotsrc` is JSON and nothing on the way
+     * here types it, so a config naming three of the four flags is the
+     * everyday case. Every flag it omits takes the default —
+     * `resolveAgentPermissions` is what guarantees that, and the reason
+     * it has to is in its own header.
+     */
+    permissions?: Partial<AgentPermissions>;
     /** Event emitter from AppilotsProvider */
     emit: (event: AppilotsEvent) => void;
     /**
@@ -1284,6 +2655,6 @@ declare function executeAction(action: AgentAction, context: ExecutorContext): P
  * (`X-Appilots-Sdk-Version`). Kept identical to package.json by the
  * release flow; `version.test.ts` fails if the two ever disagree.
  */
-declare const SDK_VERSION = "0.11.3";
+declare const SDK_VERSION = "0.13.0";
 
-export { ActionBreadcrumb, type ActionBreadcrumbProps, type ActionResult, AgentAction, AgentPermissions, type AppilotsButtonProps, AppilotsChat, type AppilotsChatMode, type AppilotsChatPosition, type AppilotsChatProps, type AppilotsChatTheme, AppilotsEvent, AppilotsI18nProvider, type AppilotsI18nProviderProps, type AppilotsInputProps, AppilotsLocale, type AppilotsRC, AppilotsRegistryProvider, type AppilotsSelfCheckReport, type AppilotsStringKey, type AppilotsStrings, type AppilotsSwitchProps, AppilotsThemeProvider, type AppilotsThemeProviderProps, AppilotsThemeTokens, type AutoTrackingState, ChatIcon, type ChatIconProps, ComponentRegistry, ConfirmDialog, type ConfirmDialogProps, type ElementRegistry, type ExecutorContext, FieldEntry, HeadsetIcon, type HeadsetIconProps, InteractionElementEntry, type IntrospectionDiagnostics, type IntrospectionFailureReason, type ListEntry, type ListRegistry, type NameManglingProbe, PartialThemeTokens, SDK_VERSION, ScreenSnapshot, type SelfCheckRegistry, type SelfCheckWalk, type TailwindResolvedConfig, type WalkDetectorCounts, _patchJsxRuntimes, appilotsSelfCheck, appilotsTheme, appilotsThemeFromTailwind, captureSnapshot, createAppilotsButton, createAppilotsInput, createAppilotsSwitch, createElementRegistry, createListRegistry, detectDeviceLocale, elementRegistry, enableAppilotsAutoTracking, executeAction, getAutoTrackingState, getGlobalConfig, getIntrospectionDiagnostics, initAppilots, isAutoTrackingEnabled, listRegistry, resolveLocale, useAppilotsI18n, useAppilotsTheme, useResolvedRegistry };
+export { ActionBreadcrumb, type ActionBreadcrumbProps, type ActionResult, AgentAction, AgentPermissions, AgentPill, type AgentPillProps, type AgentPillStrings, type AppilotsButtonProps, AppilotsChat, type AppilotsChatMode, type AppilotsChatPosition, type AppilotsChatProps, type AppilotsChatTheme, type AppilotsControl, type AppilotsEntryPoint, AppilotsEvent, type AppilotsExperience, AppilotsI18nProvider, type AppilotsI18nProviderProps, type AppilotsInputMode, type AppilotsInputProps, AppilotsLocale, type AppilotsPresence, type AppilotsRC, AppilotsRegistryProvider, type AppilotsSelfCheckReport, type AppilotsSpotlight, type AppilotsStringKey, type AppilotsStrings, type AppilotsSwitchProps, AppilotsThemeProvider, type AppilotsThemeProviderProps, AppilotsThemeTokens, AppilotsTraceEntry, type AutoTrackingState, type BreadcrumbItem, type BreadcrumbState, type ButtonSnapshot, ChatIcon, type ChatIconProps, type ChoiceGroupSnapshot, type ChoiceOptionSnapshot, ComponentRegistry, ConfirmDialog, type ConfirmDialogProps, DEFAULT_EXPERIENCE, type ElementRegistry, type ExecutorContext, type ExperienceCapabilities, type ExperienceDowngrade, type ExperienceResolution, FieldEntry, HeadsetIcon, type HeadsetIconProps, type InputSnapshot, type InteractionElementEntry, type InteractionElementListContext, type InteractionElementSnapshot, type IntrospectionDiagnostics, type IntrospectionFailureReason, type ListEntry, type ListItemSnapshot, type ListRegistry, type ListSnapshot, type NameManglingProbe, PartialThemeTokens, type PillStatus, type PillStatusStrings, REVEAL_MARGIN, type ResolvedExperience, type RevealInput, type RevealResult, SDK_VERSION, SPOTLIGHT_TTL_MS, type ScreenSnapshot, type ScrollMetrics, type SelfCheckRegistry, type SelfCheckWalk, type SpotlightMode, SpotlightOverlay, type SpotlightOverlayProps, type SpotlightTarget, type SurfaceState, type TailwindResolvedConfig, type ToggleSnapshot, type TurnActivity, type WalkDetectorCounts, _patchJsxRuntimes, appilotsListTotal, appilotsSelfCheck, appilotsTheme, appilotsThemeFromTailwind, captureSnapshot, clearAppilotsDebugTraces, createAppilotsButton, createAppilotsInput, createAppilotsSwitch, createElementRegistry, createListRegistry, describeAction, detectDeviceLocale, elementRegistry, enableAppilotsAutoTracking, executeAction, formatDowngrades, getAppilotsDebugTraces, getAutoTrackingState, getGlobalConfig, getIntrospectionDiagnostics, getSpotlightMode, getSpotlightTarget, humanizeError, initAppilots, isAutoTrackingEnabled, listRegistry, offsetToReveal, recordAppilotsDebugTrace, resolveExperience, resolveLocale, resolvePillStatus, resolveSurface, revealTarget, setSpotlightMode, setSpotlightTarget, shouldReopenOnTurnEnd, subscribeAppilotsDebugTraces, subscribeSpotlight, useAppilotsI18n, useAppilotsTheme, useResolvedRegistry, useSpotlight, usesPill };