peachsim 0.1.1644 → 0.1.1653

package/dist-types/packages/peach-globals/src/index.d.ts

@@ -0,0 +1,3311 @@
+import type { FrameBreakdownCapture } from './frameBreakdownContract.d.ts';
+import type { PointerSourceEvent } from './pointerSourceEventContract.d.ts';
+import type { ProfileFile, SootSimProfilerBridge } from './profilerContract.d.ts';
+export type { PointerSourceEvent } from './pointerSourceEventContract.d.ts';
+export type PreviewCaptureKind = 'recording' | 'run';
+export type NativeScreenCaptureState = 'active' | 'inactive' | 'unspecified';
+export declare function isPreviewCaptureKind(value: unknown): value is PreviewCaptureKind;
+export type PeachRecordingMode = 'scene' | 'video' | 'live' | 'combined';
+export type PeachRecordingStartOptions = {
+    liveBundle?: boolean;
+    video?: boolean;
+    skipEntitlement?: boolean;
+    capture?: PreviewCaptureKind;
+};
+type Listener<T> = (value: T) => void;
+export type Emitter<T> = {
+    value: T;
+    emit: (value: T) => void;
+    listen: (fn: Listener<T>) => () => void;
+    nextValue: () => Promise<T>;
+};
+export type NativeViewMeasureMode = 'undefined' | 'exactly' | 'at-most';
+export type NativeViewMeasure = (width: number, widthMode: NativeViewMeasureMode, height: number, heightMode: NativeViewMeasureMode) => {
+    width: number;
+    height: number;
+};
+export type PeachNativeWorkletEventDispatcher = (viewTag: number, event: {
+    eventName?: string;
+} & Record<string, unknown>, options?: {
+    deferFlush?: boolean;
+    timestamp?: number;
+    localOnly?: boolean;
+}) => void;
+export interface SootsimBridgeStatusDetail {
+    id?: string | null;
+    isPrimary?: boolean;
+    url?: string;
+    title?: string;
+    attachedCliCount?: number;
+    activeAgentCommandCount?: number;
+    recentActions?: ReadonlyArray<unknown>;
+    lockedBy?: string | null;
+    lockedByKind?: string | null;
+    lockExpiresAt?: number;
+    userFocused?: boolean;
+    userVisible?: boolean | null;
+    visibilityState?: string | null;
+    documentFocused?: boolean | null;
+    hasClientActivity?: boolean;
+}
+export interface SootsimActiveAppChangeDetail {
+    activeAppId: string | null;
+    activeAppName: string | null;
+    isAppOpen: boolean;
+}
+export type SootsimSettingsPage = 'root' | 'accessibility' | 'display-and-text-size' | 'larger-text' | 'notifications' | 'apps' | 'privacy' | 'apple-account';
+export type SootsimSettingsRoute = {
+    kind: 'app';
+    appId: string;
+} | {
+    kind: 'system';
+    page: SootsimSettingsPage;
+};
+export interface SootsimNavigateAppDetail {
+    appId?: string;
+    settingsPage?: SootsimSettingsPage;
+    route?: {
+        kind: 'rn';
+        id: string;
+    };
+    replace?: boolean;
+}
+export interface SootsimNavigateHomeDetail {
+    replace?: boolean;
+}
+export interface SootsimEmbedVisibilityDetail {
+    visible: boolean;
+}
+export type SootsimEmbedInteraction = {
+    kind: 'press';
+    target: {
+        kind: 'id' | 'text';
+        value: string;
+    };
+} | {
+    kind: 'drag';
+    from: {
+        x: number;
+        y: number;
+    };
+    to: {
+        x: number;
+        y: number;
+    };
+    durationMs: number;
+};
+export interface SootsimEngineFailureDetail {
+    reason: string;
+    detail?: string;
+}
+export type SootsimBootStage = 'engine' | 'tenant' | 'shell-booted' | 'shell-modules' | 'shell-mounted' | 'painted';
+export declare const SOOTSIM_BOOT_STAGE_ORDER: Record<SootsimBootStage, number>;
+export declare const SOOTSIM_TENANT_READY_MARK = "sootsim:tenant-ready";
+export type SootsimBootMarkName = 'wasm-body' | 'worker-ready' | 'compositor-ready' | 'tenant-commit' | 'app-paint' | 'canvaskit-init' | 'corpus-loaded' | 'home-tree' | 'home-paint';
+export interface SootsimBootMark {
+    name: SootsimBootMarkName;
+    atEpochMs: number;
+}
+export declare const SOOTSIM_BOOT_MARKS_GLOBAL = "__sootsimBootMarks";
+export interface SootsimHostKeyDetail {
+    key: string;
+    code?: string;
+    phase?: 'press' | 'release';
+    repeat?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+    ctrl?: boolean;
+}
+export interface SootsimHapticActivityDetail {
+    strength: number;
+    source?: string;
+}
+export type SootsimColorScheme = 'light' | 'dark' | 'auto';
+export type SootsimTopOverlayKind = 'none' | 'notification-center' | 'control-center';
+export interface SootsimEventMap {
+    'peach:device-frame-layout': void;
+    'sootsim:goHome': null;
+    'sootsim:appSwitcher': null;
+    'sootsim:toggleLock': null;
+    'sootsim:shake': null;
+    'sootsim:screenshotTaken': null;
+    'peach:screenCaptureState': NativeScreenCaptureState;
+    'sootsim:openNotificationCenter': null;
+    'sootsim:closeNotificationCenter': null;
+    'sootsim:openControlCenter': null;
+    'sootsim:closeControlCenter': null;
+    'sootsim:setTopOverlay': {
+        overlay: SootsimTopOverlayKind;
+    };
+    'sootsim:inspectModeChange': {
+        active: boolean;
+    };
+    'sootsim:ringHint': null;
+    'sootsim:ringModeChange': {
+        mode: 'ring' | 'silent';
+    };
+    'sootsim:homeIntro': null;
+    'sootsim:hoverPosition': {
+        x: number;
+        y: number;
+    };
+    'sootsim:hoverLeave': null;
+    'sootsim:inspectSelectPosition': {
+        x: number;
+        y: number;
+    };
+    'sootsim:prewarmApp': {
+        appId: string;
+        iconPosition?: {
+            x: number;
+            y: number;
+        };
+    };
+    'sootsim:cancelPrewarmApp': null;
+    'sootsim:colorSchemeChange': {
+        scheme: SootsimColorScheme;
+    };
+    'sootsim:activeAppChange': SootsimActiveAppChangeDetail;
+    'sootsim:navigateApp': SootsimNavigateAppDetail;
+    'sootsim:navigateHome': SootsimNavigateHomeDetail;
+    'sootsim:demoBundleModeChange': {
+        mode: 'development' | 'production';
+    };
+    'sootsim:urlstatechange': null;
+    'sootsim:externalAppReady': null;
+    'sootsim:externalAppError': null;
+    'sootsim:previewReloadRequest': null;
+    'sootsim:externalAppReloadStart': {
+        entryPath: string;
+    };
+    'sootsim:bridgeStatusChange': SootsimBridgeStatusDetail;
+    'sootsim:hostFocusChange': {
+        focused: boolean;
+    };
+    'sootsim:embed-visibility-change': SootsimEmbedVisibilityDetail;
+    'sootsim:hostKey': SootsimHostKeyDetail;
+    'sootsim:bundleProgress': {
+        percent: number;
+    };
+    'sootsim:bootStage': {
+        stage: SootsimBootStage;
+    };
+    'sootsim:engineFailure': SootsimEngineFailureDetail;
+    'sootsim:uploadActivity': {
+        phase: 'uploading' | 'copied' | 'failed' | 'done';
+        immediate?: boolean;
+    };
+    'sootsim:hapticActivity': SootsimHapticActivityDetail;
+    'sootsim:statusBarOverride': {
+        time?: string | null;
+    };
+    'sootsim:previewReplayClock': {
+        nowMs: number;
+        advancing?: boolean;
+    };
+    'sootsim:menuAnimOverride': {
+        value: number | null;
+        highlightMoveDuration?: number | null;
+        liquidGlass?: {
+            light?: Record<string, unknown>;
+            dark?: Record<string, unknown>;
+        } | null;
+    };
+    'sootsim:agentAction': SootSimAgentActionDetail;
+    'sootsim:hardwareKeyboardInput': SootSimHardwareKeyboardInputDetail;
+    'sootsim:bootClients': null;
+    'sootsim:plugin-bridge-ready': {
+        plugin: string;
+    };
+    'sootsim:agent-bridge-change': {
+        available: boolean;
+    };
+    'contrast-preview-reload': {
+        target?: 'web' | 'ios' | 'android';
+    } | null;
+    'sootsim:bootMark': SootsimBootMark;
+}
+export type SootsimEventName = keyof SootsimEventMap;
+export declare function dispatchSootsimEvent<K extends SootsimEventName>(name: K, detail: SootsimEventMap[K], target?: EventTarget): void;
+export declare function listenSootsimEvent<K extends SootsimEventName>(name: K, handler: (detail: SootsimEventMap[K]) => void, target?: EventTarget): () => void;
+export interface SootSimChrome {
+    shell: boolean;
+    headless: boolean;
+    electron: boolean;
+    engineBase: string | null;
+    engineTenantBase: string | null;
+    demo: boolean;
+    demoGatewayOrigin: string | null;
+    preview: boolean;
+}
+type MaybeAsync<T> = T | Promise<T>;
+export interface SootSimTestQueryFilter {
+    type?: string;
+    hasText?: string;
+    hasId?: string;
+    idPattern?: string | {
+        source: string;
+        flags: string;
+        matchLastSegment?: boolean;
+    };
+    hasRole?: string;
+    hasLabel?: string;
+    hasHint?: string;
+    hasState?: Partial<SootSimAccessibilityState>;
+    pruneHidden?: boolean;
+}
+export interface SootSimTextCandidatesOptions {
+    query: string;
+    exact?: boolean;
+    role?: string;
+}
+export interface SootSimTextCandidate {
+    info: SootSimNodeInfo;
+    ancestorTestIDs: string[];
+    ancestorPickerColumnIndices: number[];
+}
+export interface SootSimTextCandidatesResult {
+    total: number;
+    candidates: SootSimTextCandidate[];
+}
+export interface SootSimDumpTreeOptions {
+    describe?: boolean;
+    verbose?: boolean;
+    filter?: string;
+    testIdLike?: string;
+    onlyGlob?: string;
+    subtreeRoot?: string;
+    compact?: boolean;
+    hideXy?: boolean;
+    fullText?: boolean;
+    includeOccluded?: boolean;
+    format?: 'boxes';
+}
+export interface SootSimInspectPointOptions {
+    excludeTestId?: string;
+    excludeTestIds?: string[];
+}
+export interface SootSimListInspectableOptions {
+    excludeTestIds?: string[];
+}
+export type SootSimInspectNeighborDirection = 'parent' | 'firstChild' | 'prevSibling' | 'nextSibling';
+export type SootSimGestureCallback = 'onBegin' | 'onStart' | 'onUpdate' | 'onEnd' | 'onFinalize';
+export interface SootSimTapPathEntry {
+    nodeId?: number;
+    type: string;
+    testID?: string;
+    text?: string;
+}
+export interface SootSimTapRefusal {
+    hit: false;
+    requestedTargetMatched: false;
+    reason: 'target-covered' | 'target-not-found';
+    requestedTarget: SootSimReplayTarget;
+    coordinateTarget: SootSimReplayTarget | null;
+}
+export interface SootSimTapTargetMatch {
+    requestedTargetMatched: true;
+    requestedTarget: SootSimReplayTarget;
+    coordinateTarget: SootSimReplayTarget;
+}
+export type SootSimTapTargetVerification = SootSimTapTargetMatch | SootSimTapRefusal;
+export interface SootSimTapResult extends Partial<Omit<SootSimTapRefusal, 'hit'>> {
+    hit: boolean;
+    type?: string;
+    testID?: string;
+    isTextInput?: boolean;
+    keyboardOpened?: boolean;
+    text?: string;
+    responderTestID?: string;
+    responderType?: string;
+    path?: SootSimTapPathEntry[];
+    directTapHandled?: boolean;
+    pointerTapHandled?: boolean;
+}
+export type SootSimTapTargetStrategy = 'matched-node' | 'actionable-ancestor' | 'actionable-descendant';
+export interface SootSimTapTargetInfo {
+    match: SootSimNodeInfo;
+    target: SootSimNodeInfo;
+    cx: number;
+    cy: number;
+    strategy: SootSimTapTargetStrategy;
+    viewport: {
+        width: number;
+        height: number;
+    };
+}
+export interface SootSimRouteInfo {
+    routeNames: string[];
+    currentPath: string | null;
+    coveringPath: string | null;
+    canGoBack: boolean;
+    rootState: unknown;
+}
+export interface SootSimUndeclaredScreen {
+    navigator: string;
+    screen: string;
+    declared: string[];
+    settledMs: number;
+}
+export interface SootSimScrollToResult {
+    ok: boolean;
+    via?: string;
+    reason?: string;
+}
+export interface SootSimCursorState {
+    nodeId: number;
+    position: number;
+    opacity: number;
+    visible: boolean;
+    captureActive: boolean;
+    rect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+}
+export interface SootSimLoupeState {
+    x: number;
+    y: number;
+    active: boolean;
+}
+export interface SootSimEditMenuRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface SootSimEditMenuItem {
+    action: string;
+    label: string;
+}
+export interface SootSimEditMenuState {
+    items: SootSimEditMenuItem[];
+    anchor: SootSimEditMenuRect;
+    barRect: SootSimEditMenuRect | null;
+    itemRects: Array<SootSimEditMenuRect & {
+        action: string;
+    }>;
+}
+export interface SootSimTextSelection {
+    start: number | null;
+    end: number | null;
+}
+export interface SootSimTextSelectionHandles {
+    start: {
+        x: number;
+        y: number;
+    } | null;
+    end: {
+        x: number;
+        y: number;
+    } | null;
+}
+export interface SootSimRequestEntry {
+    kind: 'fetch';
+    runtime: 'window' | 'worker';
+    method: string;
+    url: string;
+    displayUrl: string;
+    timestamp: number;
+    ok: boolean;
+    status: number | null;
+    statusText: string | null;
+    error: string | null;
+    responseBody: string | null;
+    requestBody?: string | null;
+}
+export interface SootSimRequestCounts {
+    total: number;
+    failed: number;
+    inFlight: number;
+}
+export type SootSimAnimationSource = 'value' | 'engine' | 'native' | 'reanimated';
+export interface SootSimAnimationInfo {
+    id: number;
+    kind: 'timing' | 'spring' | 'linearLoop' | 'program' | 'formSheetSettle' | 'timed' | 'interpolate' | 'native' | 'reanimated';
+    source: SootSimAnimationSource;
+    realm: 'tenant' | 'shell';
+    from?: number;
+    to?: number;
+    current: number | null;
+    animatedValue: number | null;
+    startedAt?: number;
+    elapsedMs: number;
+    progress?: number;
+    duration?: number;
+    easing?: string;
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    velocity?: number;
+    loop?: boolean;
+    layoutBound?: boolean;
+    listenerCount: number;
+    graphBacked?: boolean;
+    remoteDriven?: boolean;
+    priority?: string;
+    visible?: boolean;
+}
+export interface SootSimAnimationTraceSample {
+    t: number;
+    value: number;
+    velocity: number;
+}
+export interface SootSimAnimationTraceStatus {
+    id: number;
+    count: number;
+    limit: number;
+}
+export interface SootSimRuntimeState {
+    url: string;
+    hidden: boolean;
+    nodeCount: number;
+    animations: {
+        active: number;
+        byKind: {
+            timing: number;
+            spring: number;
+        };
+    };
+    keyboard: {
+        visible: boolean;
+        mode: string | null;
+    };
+    diagnostics: {
+        errors: number;
+        warnings: number;
+        failedRequests: number;
+        totalRequests: number;
+    };
+    shell?: Record<string, unknown> | null;
+}
+export interface SootSimScreenTransitionWaitOptions {
+    timeoutMs?: number;
+    settleMs?: number;
+    startWindowMs?: number;
+}
+export interface SootSimScreenTransitionWaitResult {
+    started: boolean;
+    settled: boolean;
+    timedOut: boolean;
+    activeCount: number;
+    peakActiveCount: number;
+    waitedMs: number;
+    restedMs: number;
+}
+export interface SootSimInspectDeviceInfo {
+    platform: 'ios' | 'android';
+    model: string;
+    name: string;
+    width: number;
+    height: number;
+    scale: number;
+    statusBarHeight?: number;
+    cornerRadius?: number;
+    dynamicIsland?: {
+        width: number;
+        height: number;
+        top: number;
+    } | null;
+    osVersion: string;
+    iosVersion: string;
+    androidApiLevel?: number | null;
+}
+export interface SootSimInspectAncestor {
+    nodeId?: number;
+    type: string;
+    text?: string;
+    componentName?: string;
+    id?: string;
+    testID?: string;
+    testId?: string;
+    role?: string;
+    label?: string;
+    accessibilityLabel?: string;
+    screenId?: string;
+    srcloc?: string;
+    sourceFile?: string;
+}
+export interface SootSimInspectBoxModel {
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    border: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    padding: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    content: {
+        width: number;
+        height: number;
+    };
+}
+export interface SootSimInspectImageSource {
+    kind: 'uri' | 'metro-asset' | 'module-default';
+    assetId?: number;
+    uri?: string;
+    assetPath?: string;
+    assetFile?: string;
+    modulePath?: string;
+    width?: number;
+    height?: number;
+    scale?: number;
+}
+export type SootSimInspectHookKind = 'state' | 'reducer' | 'effect' | 'layoutEffect' | 'insertionEffect' | 'memo' | 'callback' | 'ref' | 'context' | 'other';
+export interface SootSimInspectHookSummary {
+    total: number;
+    counts: Partial<Record<SootSimInspectHookKind, number>>;
+}
+export type SootSimInspectCommitCause = 'mount' | 'props' | 'state' | 'context' | 'parent';
+export interface SootSimInspectLastCommit {
+    ageMs: number;
+    causes: SootSimInspectCommitCause[];
+    propDiffs?: string[];
+    stateChanged?: boolean;
+    actualDurationMs?: number;
+}
+export interface SootSimInspectReactInfo {
+    component?: string;
+    owners?: string[];
+    source?: string;
+    key?: string;
+    hasRef?: boolean;
+    hooks?: SootSimInspectHookSummary;
+    contexts?: string[];
+    lastCommit?: SootSimInspectLastCommit;
+}
+export interface SootSimInspectNavigationInfo {
+    appId?: string;
+    appName?: string;
+    screenId?: string;
+    routeName?: string;
+    routePath?: string;
+    params?: Record<string, unknown>;
+    stackDepth?: number;
+    stackTrail?: string[];
+    presentation?: string;
+}
+export interface SootSimInspectTimelineEntry {
+    ageMs: number;
+    kind: string;
+    context: 'host' | 'shell' | 'tenant';
+    label?: string;
+}
+export interface SootSimInspectTreeNode {
+    nodeId: number;
+    parentId: number | null;
+    type: string;
+    components?: string[];
+    testID?: string;
+    label?: string;
+    text?: string;
+    width: number;
+    height: number;
+    pressable?: boolean;
+    hidden?: boolean;
+}
+export interface SootSimInspectInfo {
+    nodeId: number;
+    sessionId?: string;
+    type: string;
+    componentName?: string;
+    componentStack?: string[];
+    id?: string;
+    testID?: string;
+    testId?: string;
+    role?: string;
+    label?: string;
+    accessibilityLabel?: string;
+    accessibilityHidden?: true;
+    readsFirst?: true;
+    accessibilityContainer?: true;
+    accessibilityFrame?: SootSimInspectInfo['absolute'];
+    screenId?: string;
+    hint?: string;
+    text?: string;
+    layout: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    absolute: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    backgroundPlayback?: true;
+    visibleFrame?: SootSimVisibleFrame | null;
+    handlers: string[];
+    style: Record<string, unknown>;
+    authoredStyle: Record<string, unknown>;
+    computedStyle: Record<string, unknown>;
+    boxModel: SootSimInspectBoxModel;
+    parentId?: number;
+    prevSiblingId?: number;
+    nextSiblingId?: number;
+    firstChildId?: number;
+    ancestors: SootSimInspectAncestor[];
+    appName?: string;
+    appearanceScheme?: string;
+    device?: SootSimInspectDeviceInfo;
+    srcloc?: string;
+    sourceFile?: string;
+    sourceChain?: string[];
+    imageSource?: SootSimInspectImageSource;
+    react?: SootSimInspectReactInfo;
+    navigation?: SootSimInspectNavigationInfo;
+    timeline?: SootSimInspectTimelineEntry[];
+}
+export type PeachSemanticInspectInfo = Pick<SootSimInspectInfo, 'nodeId' | 'type' | 'testID' | 'testId' | 'id' | 'text' | 'role' | 'accessibilityLabel' | 'label' | 'handlers' | 'accessibilityHidden' | 'absolute' | 'parentId' | 'readsFirst'> & {
+    ancestors: Array<Pick<SootSimInspectAncestor, 'nodeId'>>;
+};
+export interface PointerDispatchOptions {
+    sourceEvent?: PointerSourceEvent;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    pointerType?: string;
+    stylusData?: {
+        tiltX: number;
+        tiltY: number;
+        altitudeAngle: number;
+        azimuthAngle: number;
+        pressure: number;
+    };
+    timestamp?: number;
+    nativeWindowRoot?: number;
+}
+export interface PeachAccessibilityNode {
+    platform: SootSimInspectDeviceInfo['platform'];
+    elementId: string;
+    nodeId: number;
+    type: string;
+    testID: string | null;
+    label: string | null;
+    hint: string | null;
+    inputLabels?: string[] | null;
+    traits?: string[];
+    value: string | null;
+    placeholder: string | null;
+    role: string;
+    isAccessibilityElement: boolean;
+    enabled: boolean;
+    selected: boolean;
+    checked: boolean;
+    clickable: boolean;
+    isTextInput: boolean;
+    state: SootSimAccessibilityState | null;
+    accessibilityValue: SootSimAccessibilityValue | null;
+    hasFocus?: boolean;
+    frame: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    children: PeachAccessibilityNode[];
+}
+export type PeachSwiftUiAccessibility = Pick<PeachAccessibilityNode, 'testID' | 'role'> & Required<Pick<PeachAccessibilityNode, 'inputLabels' | 'traits'>>;
+export type PeachDebugSnapshotOperation = 'snapshot' | 'snapshots' | 'diff' | 'clearSnapshots';
+export interface SootSimTargetMatcher {
+    type: 'id' | 'text' | 'label' | 'type' | 'role';
+    value: string;
+    regexFlags?: string;
+    index?: number;
+}
+export interface SootSimTargetObservation extends SootSimNodeInfo {
+    tapPoint: {
+        x: number;
+        y: number;
+    } | null;
+    sampledAt: number;
+}
+export interface PeachPeerStatsProgress {
+    tenant: 'pending' | 'replied' | 'null' | 'rejected';
+    shell: 'pending' | 'replied' | 'null' | 'rejected' | 'absent';
+}
+export interface PeachPeerStats {
+    replayedFrameCallbacks: number;
+    nativeFrameFirstTimestampMs: number | null;
+    writeRequests: number;
+    batchesSent: number;
+    pendingRunWorklets?: number;
+    runWorkletsIdleMs: number | null;
+    runWorkletsSent?: number;
+    runWorkletsDone?: number;
+    runWorkletsFailed?: number;
+    closureCacheHits?: number;
+    closureCacheMisses?: number;
+}
+export interface SootSimTestBridge {
+    resolveViewTags?(tags: readonly number[]): MaybeAsync<Record<number, {
+        component: string | null;
+        sourceChain?: string[];
+    }>>;
+    dispatchTextInputText?(text: string, nodeId: number): MaybeAsync<GuardedTextInputResult>;
+    captureAccessibilityTree(): MaybeAsync<PeachAccessibilityNode[]>;
+    startScrollPerformanceTrace(limit?: number): MaybeAsync<void>;
+    stopScrollPerformanceTrace(): MaybeAsync<SootSimScrollOffsetSample[]>;
+    setShellReanimatedTraceEnabled?(enabled: boolean, reset?: boolean, limit?: number): MaybeAsync<boolean>;
+    getShellReanimatedTrace?(reset?: boolean): MaybeAsync<unknown[]>;
+    findById(id: string): MaybeAsync<SootSimNodeInfo | null>;
+    findByTestId(testId: string): MaybeAsync<SootSimNodeInfo | null>;
+    ancestorChainById(id: string): MaybeAsync<SootSimNodeInfo[] | null>;
+    ancestorChainByTestId(testId: string): MaybeAsync<SootSimNodeInfo[] | null>;
+    findByText(text: string): MaybeAsync<SootSimNodeInfo | null>;
+    findByTextOrLabel(text: string): MaybeAsync<SootSimNodeInfo | null>;
+    queryMatchingNodes(matcher: SootSimTargetMatcher): MaybeAsync<SootSimNodeInfo[]>;
+    observeTapTarget(matcher: SootSimTargetMatcher): MaybeAsync<SootSimTargetObservation | null>;
+    resolveTapTarget(nodeId: number): MaybeAsync<SootSimTapTargetInfo | null>;
+    verifyTapTargetAt(x: number, y: number, target: SootSimReplayTarget, nativeWindowRoot?: number): MaybeAsync<SootSimTapTargetVerification>;
+    debugByText(text: string): MaybeAsync<SootSimDebugNodeInfo[] | null>;
+    debugByTestId(testId: string): MaybeAsync<SootSimDebugNodeInfo[] | null>;
+    findByLabel(label: string): MaybeAsync<SootSimNodeInfo | null>;
+    findByRole(role: string): MaybeAsync<SootSimNodeInfo | null>;
+    findAllByRole(role: string): MaybeAsync<SootSimNodeInfo[]>;
+    findByA11yState(state: Partial<SootSimAccessibilityState>): MaybeAsync<SootSimNodeInfo | null>;
+    findAllByA11yState(state: Partial<SootSimAccessibilityState>): MaybeAsync<SootSimNodeInfo[]>;
+    findByHint(hint: string): MaybeAsync<SootSimNodeInfo | null>;
+    inspectAt(x: number, y: number, opts?: SootSimInspectPointOptions): MaybeAsync<SootSimInspectInfo | null>;
+    inspectHoverAt(x: number, y: number, opts?: SootSimInspectPointOptions): MaybeAsync<SootSimInspectInfo | null>;
+    inspectByNodeId(nodeId: number): MaybeAsync<SootSimInspectInfo | null>;
+    inspectLastTap(): MaybeAsync<SootSimInspectInfo | null>;
+    inspectNeighbor(nodeId: number, direction: SootSimInspectNeighborDirection): MaybeAsync<SootSimInspectInfo | null>;
+    inspectSetStyleOverride(nodeId: number, key: string, value: unknown): MaybeAsync<boolean>;
+    inspectSetHandlerLogging(nodeId: number, handlerName: string, enabled: boolean): MaybeAsync<boolean>;
+    listInspectable(opts?: SootSimListInspectableOptions): MaybeAsync<SootSimInspectInfo[]>;
+    listSemanticInspectable(opts?: SootSimListInspectableOptions): MaybeAsync<PeachSemanticInspectInfo[]>;
+    inspectTree(): MaybeAsync<SootSimInspectTreeNode[] | null>;
+    captureRenderTree?(): MaybeAsync<SootSimRenderTreeSnapshot>;
+    beginCaptureTransaction?(): MaybeAsync<SootSimCaptureTransactionReceipt>;
+    endCaptureTransaction?(token: number): MaybeAsync<SootSimCaptureTransactionReceipt>;
+    captureBoundLongPress?(token: number, x: number, y: number, durationMs?: number, nativeWindowRoot?: number): MaybeAsync<SootSimCaptureBoundLongPressReceipt>;
+    captureBoundTap?(token: number, x: number, y: number, nativeWindowRoot?: number): MaybeAsync<SootSimCaptureBoundTapReceipt>;
+    debugHitAt(x: number, y: number): MaybeAsync<SootSimDebugNodeInfo[] | null>;
+    debugGestureAt(x: number, y: number): MaybeAsync<Record<string, unknown> | null>;
+    invokeGestureAt(x: number, y: number, gestureType: string, callback: SootSimGestureCallback): MaybeAsync<boolean>;
+    findPressable(): MaybeAsync<SootSimNodeInfo[]>;
+    getStyle(id: string): MaybeAsync<Record<string, unknown> | null>;
+    getLayout(id: string): MaybeAsync<SootSimLayout | null>;
+    getAbsolutePosition(id: string): MaybeAsync<{
+        x: number;
+        y: number;
+    } | null>;
+    isVisible(id: string): MaybeAsync<boolean>;
+    blurFocusedTextInput(): MaybeAsync<boolean>;
+    isTextInputFocused(): MaybeAsync<boolean>;
+    getFocusedNode(): MaybeAsync<SootSimFocusedNodeInfo | null>;
+    getNodeCount(): MaybeAsync<number>;
+    getWindowNodeCount(): MaybeAsync<number>;
+    getTreeQuietMs(): MaybeAsync<number>;
+    getGeometryRevision(): MaybeAsync<string | null>;
+    getCullStats?(reset?: boolean): MaybeAsync<{
+        examined: number;
+        kept: number;
+        skipped: number;
+    }>;
+    getImageLoaderStats?(reset?: boolean): MaybeAsync<Record<string, unknown>>;
+    getFontDebug?(family?: string, fontWeight?: unknown): MaybeAsync<Record<string, unknown>>;
+    getIncrementalYogaVerifier?(): MaybeAsync<{
+        enabled: boolean;
+        runs: number;
+        comparedNodes: number;
+        diverged: number;
+        lastRootId: number | null;
+        lastComparedNodes: number;
+        lastDivergences: number;
+        lastDiffs: string[];
+    }>;
+    getPeerStats?(reset?: boolean): PeachPeerStats | null | (Promise<PeachPeerStats | null> & {
+        peachPeerProgress?: PeachPeerStatsProgress;
+    });
+    getWorkletSlotStats?(): MaybeAsync<{
+        role: 'tenant' | 'shell' | 'host';
+        capacity: number;
+        nextId: number;
+        freeSlots: number;
+        freedSlots: number;
+        nextObjectId: number;
+        freeObjectSlots: number;
+        freedObjectSlots: number;
+        primitiveAllocs: number;
+        objectAllocs: number;
+        reusedAllocs: number;
+        frees: number;
+        listenerSlots: number;
+        objectListenerSlots: number;
+        objectSlots: number;
+        pendingPrimitiveUpdates: number;
+        pendingObjectUpdates: number;
+        runJSCallbackSent: number;
+        runJSCallbackReceived: number;
+        runJSCallbackMissing: number;
+        eventHandlers: number;
+        hasPeer: boolean;
+        eventHandlerNames: Array<[string, number]>;
+        remoteEventHandlers: number;
+        keyboardHandlers: number;
+    } | null>;
+    queryAll(filter: SootSimTestQueryFilter): MaybeAsync<SootSimNodeInfo[]>;
+    queryTextCandidates(opts: SootSimTextCandidatesOptions): MaybeAsync<SootSimTextCandidatesResult>;
+    dumpTree(maxDepth?: number, opts?: SootSimDumpTreeOptions): MaybeAsync<string>;
+    dumpAccessibilityTree(maxDepth?: number): MaybeAsync<string>;
+    debugFind(target: 'sheets' | 'portals' | 'boundaries'): MaybeAsync<unknown>;
+    debugSnapshot(operation: PeachDebugSnapshotOperation, labels: string[], target: 'tenant' | 'shell'): MaybeAsync<unknown>;
+    waitForTree(): Promise<void>;
+    waitForScreenTransitions?(opts?: SootSimScreenTransitionWaitOptions): Promise<SootSimScreenTransitionWaitResult>;
+    activatePressAt(x: number, y: number, nodeId?: number): MaybeAsync<Record<string, unknown> | null>;
+    activatePressByText(text: string): MaybeAsync<Record<string, unknown> | null>;
+    activatePressById(id: string): MaybeAsync<Record<string, unknown> | null>;
+    getRequests(limit?: number): MaybeAsync<SootSimRequestEntry[]>;
+    getFailedRequests(limit?: number): MaybeAsync<SootSimRequestEntry[]>;
+    getRequestCounts(): MaybeAsync<SootSimRequestCounts>;
+    clearRequests(): MaybeAsync<void>;
+    listAnimations(): MaybeAsync<SootSimAnimationInfo[]>;
+    getAnimation(id: number): MaybeAsync<SootSimAnimationInfo | null>;
+    stopAnimation(target: number | 'all'): MaybeAsync<number>;
+    enableAnimationTrace(target: number | 'all', limit?: number): MaybeAsync<void>;
+    disableAnimationTrace(target: number | 'all'): MaybeAsync<void>;
+    getAnimationTrace(id: number, limit?: number): MaybeAsync<SootSimAnimationTraceSample[]>;
+    listAnimationTraces(): MaybeAsync<SootSimAnimationTraceStatus[]>;
+    getRuntimeState(): MaybeAsync<SootSimRuntimeState>;
+    getExternalAppState?(): MaybeAsync<Record<string, unknown> | null>;
+    scrollToTop(x: number): MaybeAsync<boolean>;
+    getScrollState(id: string): MaybeAsync<Record<string, unknown> | null>;
+    getScrollStateAt(x: number, y: number): MaybeAsync<Record<string, unknown> | null>;
+    getCursorState(): MaybeAsync<SootSimCursorState | null>;
+    setCursorCaptureActive(active: boolean): MaybeAsync<void>;
+    getLoupeState(): MaybeAsync<SootSimLoupeState>;
+    getEditMenuState(): MaybeAsync<SootSimEditMenuState | null>;
+    getTextSelection(id: string): MaybeAsync<SootSimTextSelection | null>;
+    getTextSelectionHandles(id: string): MaybeAsync<SootSimTextSelectionHandles | null>;
+    getTextInputDisplayText(id: string): MaybeAsync<string | null>;
+    getTextInputValue(id: string): MaybeAsync<string | null>;
+    getTextInputDisplayColor(id: string): MaybeAsync<string | null>;
+    getImageState(nodeId: number): MaybeAsync<Record<string, unknown> | null>;
+    scrollTo(target: string | number | {
+        id?: string;
+        nodeId?: number;
+    }, x: number, y: number, animated?: boolean): MaybeAsync<SootSimScrollToResult>;
+    workerDebugState(): MaybeAsync<Record<string, unknown>>;
+    screenshot(): Promise<string>;
+    tap?(x: number, y: number, target?: SootSimReplayTarget): MaybeAsync<SootSimTapResult>;
+    longPress?(x: number, y: number, durationMs?: number, nativeWindowRoot?: number): MaybeAsync<boolean>;
+    captureBoundLongPress?(token: number, x: number, y: number, durationMs?: number, nativeWindowRoot?: number): MaybeAsync<SootSimCaptureBoundLongPressReceipt>;
+    captureBoundTap?(token: number, x: number, y: number, nativeWindowRoot?: number): MaybeAsync<SootSimCaptureBoundTapReceipt>;
+    drag?(fromX: number, fromY: number, toX: number, toY: number, steps?: number, stepMs?: number): MaybeAsync<boolean>;
+    pinch?(fromX1: number, fromY1: number, fromX2: number, fromY2: number, toX1: number, toY1: number, toX2: number, toY2: number, steps?: number, stepMs?: number): MaybeAsync<boolean>;
+    longPress?(x: number, y: number, durationMs?: number, nativeWindowRoot?: number): MaybeAsync<boolean>;
+    touchDown?(x: number, y: number, pointerId?: number, nativeWindowRoot?: number, timestamp?: number): MaybeAsync<boolean>;
+    touchMove?(x: number, y: number, pointerId?: number, nativeWindowRoot?: number, timestamp?: number): MaybeAsync<boolean>;
+    touchUp?(x: number, y: number, pointerId?: number, nativeWindowRoot?: number, timestamp?: number): MaybeAsync<boolean>;
+    touchCancel?(pointerId?: number, timestamp?: number): MaybeAsync<boolean>;
+    settleInteractionRelease?(): MaybeAsync<void>;
+    openDeepLink(url: string): MaybeAsync<{
+        ok: boolean;
+        error?: string;
+    }>;
+    getRouteInfo?(): MaybeAsync<SootSimRouteInfo>;
+    undeclaredScreen?(href: string): MaybeAsync<SootSimUndeclaredScreen | null>;
+    pushRoute?(href: string): MaybeAsync<boolean>;
+    replaceRoute?(href: string): MaybeAsync<boolean>;
+    goBackRoute?(): MaybeAsync<boolean>;
+    getFocusKeyboardSnapshot?(): MaybeAsync<Record<string, unknown> | null>;
+    getScrollSnapshots?(): MaybeAsync<Array<Record<string, unknown>>>;
+    getNavigationSnapshot?(): MaybeAsync<Record<string, unknown> | null>;
+    isNavigationIdle?(): MaybeAsync<boolean>;
+    getSurfaceMetricsSnapshot?(): MaybeAsync<Record<string, unknown> | null>;
+    permissionListApps?(): MaybeAsync<readonly SystemPermissionApp[]>;
+    permissionGuestAppId?(): MaybeAsync<string>;
+    permissionGetAppSettings?(appId: string): MaybeAsync<AppSettingsSnapshot>;
+    permissionSetAppPermission?(appId: string, kind: SystemPermissionKind, mutation: SystemPermissionMutation): MaybeAsync<AppSettingsSnapshot>;
+    permissionResetApp?(appId: string): MaybeAsync<void>;
+    clearKeychain?(): MaybeAsync<void>;
+    evalInTenant?(code: string): MaybeAsync<{
+        ok: boolean;
+        value?: unknown;
+        error?: string;
+    }>;
+    armNodeY(nodeId: number, frames?: number): MaybeAsync<void>;
+    recordNodeY(): MaybeAsync<void>;
+    takeNodeY(): MaybeAsync<number[] | null>;
+}
+type BridgeMethodKeys<T> = {
+    [K in keyof T]-?: NonNullable<T[K]> extends (...args: any[]) => unknown ? K : never;
+}[keyof T];
+export type SootSimTestBridgeMethod = Extract<BridgeMethodKeys<SootSimTestBridge>, string>;
+export type SootSimTestBridgeArgs<M extends SootSimTestBridgeMethod> = NonNullable<SootSimTestBridge[M]> extends (...args: infer A) => unknown ? A : never;
+export type SootSimTestBridgeResult<M extends SootSimTestBridgeMethod> = NonNullable<SootSimTestBridge[M]> extends (...args: any[]) => infer R ? Awaited<R> : never;
+export interface SootSimInteractBridge {
+    tap(x: number, y: number, target?: SootSimReplayTarget): MaybeAsync<SootSimTapResult>;
+    doubleTap?(x: number, y: number, gapMs?: number): MaybeAsync<boolean>;
+    drag(fromX: number, fromY: number, toX: number, toY: number, steps?: number, stepMs?: number): MaybeAsync<boolean>;
+    pinch(fromX1: number, fromY1: number, fromX2: number, fromY2: number, toX1: number, toY1: number, toX2: number, toY2: number, steps?: number, stepMs?: number): MaybeAsync<boolean>;
+    longPress?(x: number, y: number, durationMs?: number, nativeWindowRoot?: number): MaybeAsync<boolean>;
+    captureBoundLongPress?(token: number, x: number, y: number, durationMs?: number, nativeWindowRoot?: number): MaybeAsync<SootSimCaptureBoundLongPressReceipt>;
+    captureBoundTap?(token: number, x: number, y: number, nativeWindowRoot?: number): MaybeAsync<SootSimCaptureBoundTapReceipt>;
+    touchDown?(x: number, y: number, pointerId?: number, timestamp?: number): MaybeAsync<boolean>;
+    touchMove?(x: number, y: number, pointerId?: number, timestamp?: number): MaybeAsync<boolean>;
+    touchUp?(x: number, y: number, pointerId?: number, timestamp?: number): MaybeAsync<boolean>;
+    touchCancel?(pointerId?: number, timestamp?: number): MaybeAsync<boolean>;
+}
+export interface GuardedTextInputResult {
+    handled: boolean;
+    secureTextEntry: boolean;
+}
+export interface TextInputEditRange {
+    start: number;
+    end: number;
+}
+export type TextInputEditCommand = {
+    kind: 'compositionStart';
+    range: TextInputEditRange;
+} | {
+    kind: 'replace';
+    range: TextInputEditRange;
+    text: string;
+    composition: 'none' | 'update' | 'commit';
+    key?: string;
+};
+export declare function isTextInputEditCommand(value: unknown): value is TextInputEditCommand;
+export interface SootSimKeyboardBridge {
+    [key: string]: unknown;
+    type?(text: string): MaybeAsync<void>;
+    typeInto?(text: string, nodeId: number): MaybeAsync<GuardedTextInputResult>;
+    press?(key: string): MaybeAsync<void>;
+    dispatchKey?(key: string): MaybeAsync<void>;
+    edit?(command: TextInputEditCommand): MaybeAsync<boolean>;
+    show?(): MaybeAsync<void>;
+    dismiss?(): MaybeAsync<boolean>;
+    isVisible?(): MaybeAsync<boolean>;
+    hasHostedEditorFocus?(): MaybeAsync<boolean>;
+    getMode?(): MaybeAsync<string>;
+    getLayout?(): {
+        spec: {
+            secureTextEntry: boolean;
+        } | null;
+    };
+    getKeyRect?(label: string): MaybeAsync<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+}
+export interface SootSimDetectedBarcode {
+    format: string;
+    rawValue: string;
+    boundingBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    cornerPoints: Array<{
+        x: number;
+        y: number;
+    }>;
+}
+export interface PeachCameraPhotoOptions {
+    mimeType?: string;
+    quality?: number;
+    isMirrored?: boolean;
+}
+export interface PeachCameraPhotoResult {
+    dataUri: string;
+    width: number;
+    height: number;
+    timestamp: number;
+}
+export interface PeachCameraRecordingOptions {
+    recordingId?: string;
+    persistent?: PeachCameraSourceConfiguration;
+    mimeType: string;
+    containerFormat?: 'mp4' | 'mov';
+    audio: boolean;
+    videoBitsPerSecond?: number;
+    maxDuration?: number;
+    maxFileSize?: number;
+}
+export type PeachCameraRecordingCommand = 'stop' | 'pause' | 'resume' | 'cancel' | 'bind' | 'unbind';
+export type PeachCameraRecordingEvent = {
+    type: 'started' | 'paused' | 'resumed';
+} | {
+    type: 'progress';
+    duration: number;
+    fileSize: number;
+} | {
+    type: 'finished';
+    blob: Blob;
+    duration: number;
+    width: number;
+    height: number;
+    reason: 'stopped' | 'max-duration-reached' | 'max-file-size-reached';
+} | {
+    type: 'cancelled';
+} | {
+    type: 'error';
+    message: string;
+};
+export interface PeachCameraSourceInfo {
+    settings: MediaTrackSettings;
+    capabilities: MediaTrackCapabilities;
+}
+export interface PeachCameraSourceConfiguration {
+    width: number;
+    height: number;
+    frameRate?: number;
+}
+export interface PeachCameraFrameResult {
+    codedWidth: number;
+    codedHeight: number;
+    visibleX: number;
+    visibleY: number;
+    producerGeneration: bigint;
+    format: VideoPixelFormat;
+    width: number;
+    height: number;
+    timestamp: number;
+    layout: PlaneLayout[];
+    colorSpace: VideoColorSpaceInit;
+    pixels: ArrayBuffer;
+}
+export interface SootSimCameraBridge {
+    configureSource(configuration: PeachCameraSourceConfiguration): Promise<void>;
+    captureFrame(format: 'source' | 'BGRA'): Promise<PeachCameraFrameResult>;
+    getSourceInfo(facing: 'user' | 'environment'): Promise<PeachCameraSourceInfo>;
+    startCamera(facing: 'user' | 'environment', onFrame: (bitmap: ImageBitmap, width: number, height: number) => void, configuration?: PeachCameraSourceConfiguration): Promise<{
+        width: number;
+        height: number;
+    }>;
+    capturePhoto(options?: PeachCameraPhotoOptions): Promise<PeachCameraPhotoResult | null>;
+    stopCamera(): Promise<void>;
+    startRecording(options: PeachCameraRecordingOptions, onEvent: (event: PeachCameraRecordingEvent) => void): Promise<void>;
+    commandRecording(command: PeachCameraRecordingCommand, recordingId?: string): Promise<void>;
+    isCameraActive?(): boolean;
+    startBarcodeScan(formats: string[], onResults: (barcodes: SootSimDetectedBarcode[], videoWidth: number, videoHeight: number) => void): Promise<void>;
+    stopBarcodeScan(): Promise<void>;
+}
+export type SootSimVideoSource = {
+    uri?: string;
+    headers?: Record<string, string>;
+};
+export type SootSimVideoStatus = 'idle' | 'loading' | 'readyToPlay' | 'error';
+export type SootSimVideoEvent = {
+    name: 'statusChange';
+    payload: {
+        status: SootSimVideoStatus;
+        oldStatus?: SootSimVideoStatus;
+        error?: {
+            message: string;
+        };
+    };
+} | {
+    name: 'playingChange';
+    payload: {
+        isPlaying: boolean;
+        oldIsPlaying?: boolean;
+    };
+} | {
+    name: 'playbackRateChange';
+    payload: {
+        playbackRate: number;
+        oldPlaybackRate?: number;
+    };
+} | {
+    name: 'volumeChange';
+    payload: {
+        volume: number;
+        oldVolume?: number;
+    };
+} | {
+    name: 'mutedChange';
+    payload: {
+        muted: boolean;
+        oldMuted?: boolean;
+    };
+} | {
+    name: 'playToEnd';
+    payload: undefined;
+} | {
+    name: 'timeUpdate';
+    payload: {
+        currentTime: number;
+        currentLiveTimestamp: null;
+        currentOffsetFromLive: null;
+        bufferedPosition: number;
+    };
+} | {
+    name: 'sourceChange';
+    payload: {
+        source: SootSimVideoSource | null;
+        oldSource?: SootSimVideoSource | null;
+    };
+} | {
+    name: 'sourceLoad';
+    payload: {
+        videoSource: SootSimVideoSource | null;
+        duration: number;
+        availableVideoTracks: [];
+        availableSubtitleTracks: [];
+        availableAudioTracks: [];
+        naturalSize: {
+            width: number;
+            height: number;
+        };
+    };
+} | {
+    name: 'seeked';
+    payload: {
+        currentTime: number;
+    };
+};
+export interface SootSimVideoBridge {
+    createPlayer(instanceId: number, source: SootSimVideoSource | null, onEvent: (event: SootSimVideoEvent) => void, onFrame: (bitmap: ImageBitmap, width: number, height: number) => void): void;
+    command(instanceId: number, command: 'play' | 'pause' | 'replay' | 'seekBy' | 'replace', value?: number | SootSimVideoSource | null): void;
+    setProperty(instanceId: number, property: 'currentTime' | 'loop' | 'muted' | 'playbackRate' | 'preservesPitch' | 'timeUpdateEventInterval' | 'timeUpdatesWhilePaused' | 'volume', value: number | boolean): void;
+    releasePlayer(instanceId: number): void;
+}
+export type SootSimSpeechSynthesisUtterance = {
+    text: string;
+    lang: string;
+    rate: number;
+    pitch: number;
+    volume: number;
+};
+export type SootSimSpeechSynthesisEvent = {
+    type: 'start';
+} | {
+    type: 'boundary';
+    charIndex: number;
+    charLength: number;
+} | {
+    type: 'end';
+} | {
+    type: 'error';
+    error: string;
+};
+export interface SootSimSpeechSynthesisBridge {
+    speak(utterance: SootSimSpeechSynthesisUtterance, onEvent: (event: SootSimSpeechSynthesisEvent) => void): void;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+}
+export interface SootSimAudioRecorderOptions {
+    isMeteringEnabled?: boolean;
+    bitRate?: number;
+    bitsPerSecond?: number;
+    mimeType?: string;
+    extension?: string;
+    sampleRate?: number;
+    numberOfChannels?: number;
+    deviceId?: string;
+}
+export type SootSimAudioRecorderCommand = 'inputs' | 'prepare' | 'record' | 'pause' | 'status' | 'stop';
+export interface SootSimAudioRecorderSnapshot {
+    state: 'inactive' | 'recording' | 'paused' | 'stopped';
+    durationMs: number;
+    inputs: Array<{
+        uid: string;
+        name: string;
+        type: string;
+    }>;
+    inputId?: string;
+    metering?: number;
+    blob?: Blob;
+}
+export interface SootSimAudioRecorderBridge {
+    subscribe(id: string, listener: (snapshot: SootSimAudioRecorderSnapshot) => void): () => void;
+    request(id: string, command: SootSimAudioRecorderCommand, options?: SootSimAudioRecorderOptions): Promise<SootSimAudioRecorderSnapshot>;
+    release(id: string): void;
+}
+export interface SootSimMediaSessionBridge {
+    readonly session: Pick<MediaSession, 'metadata' | 'playbackState' | 'setActionHandler' | 'setPositionState'>;
+    readonly MediaMetadata: new (init?: MediaMetadataInit) => MediaMetadata;
+    reset(): void;
+}
+export interface SootSimClipboardImage {
+    bytes: ArrayBuffer;
+    mimeType: string;
+    width: number;
+    height: number;
+    scale: number;
+}
+export interface SootSimClipboardChange {
+    changeCount: number;
+    types: string[];
+    contentTypes: string[];
+}
+export interface SootSimClipboardBridge {
+    readText(): Promise<string>;
+    writeText(text: string): Promise<void>;
+    readImage(): Promise<SootSimClipboardImage | null>;
+    writeImage(image: {
+        bytes: ArrayBuffer;
+        mimeType: string;
+        kind: 'bitmap' | 'file';
+        scale?: number;
+        types?: string[];
+    }): Promise<void>;
+    subscribe(listener: (change: SootSimClipboardChange) => void): () => void;
+}
+export interface SootSimHostStorageBridge {
+    snapshotLocalStorageEntries(scopeUrl: string): Promise<Array<[string, string]>>;
+}
+export interface SootSimImagePickerAsset {
+    uri: string;
+    width: number;
+    height: number;
+    fileName?: string;
+    mimeType?: string;
+    fileSize?: number;
+    mediaType?: 'image' | 'video';
+    duration?: number;
+}
+export interface SootSimImagePickerResult {
+    continuing?: boolean;
+    error?: string;
+    canceled: boolean;
+    assets: SootSimImagePickerAsset[] | null;
+}
+export interface SootSimImagePickerOptions {
+    continuous?: boolean;
+    preferredItemEncoding?: 'automatic' | 'current' | 'compatible';
+    mediaTypes?: 'images' | 'videos' | 'all';
+    allowsMultiple?: boolean;
+    selectionLimit?: number;
+    ordered?: boolean;
+}
+export interface ShellNativeEvaluationOwner {
+    readonly kind: 'shell';
+    readonly appId: string;
+    readonly surfaceId: 'app:one' | 'app:two';
+    readonly generation: number;
+}
+export interface SootSimImagePickerBridge {
+    readonly cameraAvailable: boolean;
+    captureFromCamera(signal?: AbortSignal, owner?: ShellNativeEvaluationOwner): Promise<SootSimImagePickerResult>;
+    pickFromLibrary(options?: SootSimImagePickerOptions, signal?: AbortSignal, owner?: ShellNativeEvaluationOwner, onSelection?: (result: SootSimImagePickerResult) => void): Promise<SootSimImagePickerResult>;
+}
+export interface SootSimImageCropperSpec {
+    previewUri: string;
+    imageWidth: number;
+    imageHeight: number;
+    aspectRatio: number;
+    shape: 'rectangle' | 'circle';
+}
+export interface SootSimImageCropperBridge {
+    present(spec: SootSimImageCropperSpec): Promise<{
+        done: boolean;
+    }>;
+}
+export interface SootSimAndroidPickerDay {
+    year: number;
+    month: number;
+    day: number;
+}
+export interface SootSimAndroidPickerButton {
+    label?: string;
+    textColor?: number;
+}
+export interface SootSimAndroidDateTimePickerSpec extends SootSimAndroidPickerDay {
+    dialog: 'date' | 'time';
+    display: 'default' | 'spinner';
+    hour: number;
+    minute: number;
+    is24Hour: boolean;
+    minimumDay?: SootSimAndroidPickerDay;
+    maximumDay?: SootSimAndroidPickerDay;
+    minuteInterval?: number;
+    firstDayOfWeek?: number;
+    startOnYearSelection?: boolean;
+    buttons: {
+        positive?: SootSimAndroidPickerButton;
+        negative?: SootSimAndroidPickerButton;
+        neutral?: SootSimAndroidPickerButton;
+    };
+}
+export type SootSimAndroidDateTimePickerResult = ({
+    action: 'set';
+    hour: number;
+    minute: number;
+} & SootSimAndroidPickerDay) | {
+    action: 'neutral';
+} | {
+    action: 'dismissed';
+};
+export interface SootSimAndroidDateTimePickerBridge {
+    present(spec: SootSimAndroidDateTimePickerSpec, signal: AbortSignal): {
+        result: Promise<SootSimAndroidDateTimePickerResult>;
+        update: (spec: SootSimAndroidDateTimePickerSpec) => void;
+    };
+}
+export type SystemPermissionKind = 'app-tracking-transparency' | 'bluetooth' | 'calendars' | 'camera' | 'contacts' | 'face-id' | 'local-network' | 'location-always' | 'location-when-in-use' | 'media-library' | 'microphone' | 'motion' | 'notifications' | 'photo-library' | 'photo-library-add-only' | 'reminders' | 'siri' | 'speech-recognition';
+export type SystemPermissionStatus = 'not-determined' | 'restricted' | 'denied' | 'authorized' | 'limited' | 'provisional' | 'ephemeral' | 'unavailable';
+export type SystemPermissionLocationAccuracy = 'full' | 'reduced';
+export type SystemPermissionPlatform = 'ios' | 'android';
+export type AppPreferenceValue = string | number | boolean;
+export type AppSettingsSpecifier = {
+    type: 'group';
+    title?: string;
+    footer?: string;
+} | {
+    type: 'toggle';
+    key: string;
+    title: string;
+    defaultValue: boolean;
+    currentValue: boolean;
+} | {
+    type: 'text';
+    key: string;
+    title: string;
+    defaultValue: string;
+    currentValue: string;
+    placeholder?: string;
+    secure?: boolean;
+    keyboardType?: 'alphabet' | 'numbers-and-punctuation' | 'number-pad' | 'url' | 'email-address' | 'name-phone-pad' | 'ascii-capable';
+    autocapitalization?: 'none' | 'sentences' | 'words' | 'all-characters';
+    autocorrection?: boolean;
+} | {
+    type: 'multi-value';
+    key: string;
+    title: string;
+    defaultValue: AppPreferenceValue;
+    currentValue: AppPreferenceValue;
+    values: readonly AppPreferenceValue[];
+    titles: readonly string[];
+} | {
+    type: 'title-value';
+    key: string;
+    title: string;
+    defaultValue: AppPreferenceValue;
+    currentValue: AppPreferenceValue;
+} | {
+    type: 'slider';
+    key: string;
+    title?: string;
+    defaultValue: number;
+    currentValue: number;
+    minimumValue: number;
+    maximumValue: number;
+    minimumValueImage?: string;
+    maximumValueImage?: string;
+} | {
+    type: 'child-pane';
+    title: string;
+    file?: string;
+    specifiers: readonly AppSettingsSpecifier[];
+};
+export interface SystemNotificationSettings {
+    authorizationStatus: SystemPermissionStatus;
+    alerts: boolean;
+    sounds: boolean;
+    badges: boolean;
+    lockScreen: boolean;
+    notificationCenter: boolean;
+    banners: boolean;
+    bannerStyle: 'temporary' | 'persistent';
+    previews: 'always' | 'whenUnlocked' | 'never';
+    grouping: 'automatic' | 'byApp' | 'off';
+    criticalAlerts: boolean;
+    announcements: boolean;
+    scheduledDelivery: boolean;
+    timeSensitive: boolean;
+}
+export interface SystemPermissionState {
+    kind: SystemPermissionKind;
+    status: SystemPermissionStatus;
+    canAskAgain: boolean;
+    requested: boolean;
+    authorizationScope?: 'persistent' | 'once';
+    locationAccuracy?: SystemPermissionLocationAccuracy;
+    limitedResourceIds?: readonly string[];
+    notifications?: SystemNotificationSettings;
+}
+export interface SystemPermissionDescriptor {
+    kind: SystemPermissionKind;
+    purpose?: string;
+    notificationOptions?: readonly ('alert' | 'badge' | 'sound' | 'carPlay' | 'criticalAlert' | 'provisional' | 'providesAppSettings')[];
+}
+export interface SystemPermissionApp {
+    appId: string;
+    bundleIdentifier?: string;
+    displayName: string;
+    version?: string;
+    icon?: string;
+    settingsBundle?: readonly AppSettingsSpecifier[];
+    settingsStorageScopeUrl?: string;
+}
+export interface SystemPermissionRecord extends SystemPermissionState {
+    appId: string;
+    platform: SystemPermissionPlatform;
+    updatedAt: number;
+}
+export interface AppPermissionSetting {
+    kind: SystemPermissionKind;
+    status: SystemPermissionStatus;
+    mutable: boolean;
+    locationAccuracy?: SystemPermissionLocationAccuracy;
+}
+export interface AppSettingsSnapshot {
+    appId: string;
+    platform: SystemPermissionPlatform;
+    permissions: readonly AppPermissionSetting[];
+    notifications?: SystemNotificationSettings;
+    declaredSettings?: {
+        specifiers: readonly AppSettingsSpecifier[];
+        values: Readonly<Record<string, AppPreferenceValue>>;
+    };
+}
+export type SystemPermissionMutation = {
+    status: 'not-determined';
+} | {
+    status: 'restricted';
+} | {
+    status: 'denied';
+    canAskAgain?: boolean;
+} | {
+    status: 'authorized';
+    locationAccuracy?: SystemPermissionLocationAccuracy;
+    authorizationScope?: 'persistent' | 'once';
+} | {
+    status: 'limited';
+    limitedResourceIds?: readonly string[];
+} | {
+    status: 'provisional';
+} | {
+    status: 'ephemeral';
+} | {
+    status: 'unavailable';
+};
+export interface SystemPermissionRequestContext extends SystemPermissionApp {
+    presentationAppId?: string;
+    platform: SystemPermissionPlatform;
+}
+export interface SootSimPermissionsBridge {
+    listApps(): MaybeAsync<readonly SystemPermissionApp[]>;
+    getAppSettingsSnapshot(appId: string): MaybeAsync<AppSettingsSnapshot>;
+    setAppPermission(appId: string, kind: SystemPermissionKind, mutation: SystemPermissionMutation): MaybeAsync<AppSettingsSnapshot>;
+    patchNotificationSettings(appId: string, patch: Partial<SystemNotificationSettings>): MaybeAsync<AppSettingsSnapshot>;
+    setAppDeclaredSetting(appId: string, key: string, value: AppPreferenceValue): MaybeAsync<AppSettingsSnapshot>;
+    resetPermission(appId: string, kind: SystemPermissionKind): MaybeAsync<void>;
+    resetAppPermissions(appId: string): MaybeAsync<void>;
+}
+export interface SootSimShareSheetOptions {
+    title?: string;
+    message?: string;
+    url?: string;
+    subject?: string;
+    excludedActivityTypes?: string[];
+}
+export interface SootSimShareSheetResult {
+    completed: boolean;
+    activityType: string | null;
+}
+export interface SootSimShareSheetBridge {
+    share(options: SootSimShareSheetOptions): Promise<SootSimShareSheetResult>;
+}
+export interface SootSimPhotoLibraryAsset {
+    id: string;
+    uri: string;
+    width: number;
+    height: number;
+    fileName?: string;
+    mediaType: 'photo' | 'video';
+    timestamp: number;
+    fileSize?: number;
+    durationMs?: number;
+    isFavorite: boolean;
+    mimeType?: string;
+}
+export interface SootSimPhotoLibraryPage {
+    assets: SootSimPhotoLibraryAsset[];
+    hasNextPage: boolean;
+    endCursor: string | null;
+    totalCount: number;
+}
+export interface SootSimPhotoLibraryQueryOptions {
+    first: number;
+    after?: string;
+    assetType?: 'All' | 'Photos' | 'Videos';
+    readFiles?: boolean;
+}
+export interface SootSimPhotoLibraryCreateOptions {
+    uri: string;
+    width?: number;
+    height?: number;
+    fileName?: string;
+    mediaType?: 'photo' | 'video';
+}
+export interface SootSimPhotoLibraryBridge {
+    getPhotos(options: SootSimPhotoLibraryQueryOptions): Promise<SootSimPhotoLibraryPage>;
+    createAsset(options: SootSimPhotoLibraryCreateOptions): Promise<SootSimPhotoLibraryAsset>;
+}
+export interface SootSimNavigationRoutesPayload {
+    prefixes: string[];
+    screens: unknown;
+    filter?: unknown;
+}
+export interface SootSimNavigationRoutesBridge {
+    publish(payload: SootSimNavigationRoutesPayload | null): void;
+}
+export interface SootSimLinkingDispatcherBridge {
+    dispatch(url: string): void;
+}
+export interface PeachWebViewDocumentData {
+    bytesBase64: string;
+    mimeType: string;
+    characterEncodingName: string;
+}
+export interface SootSimWebViewSource {
+    uri?: string;
+    html?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    method?: string;
+    bodyBase64?: string;
+    documentData?: PeachWebViewDocumentData;
+}
+export type SootSimWebViewHostRequest = {
+    kind: 'navigationDecision';
+    instanceId: string;
+    requestId: number;
+    allow: boolean;
+} | {
+    kind: 'attach';
+    instanceId: string;
+    frameName: string;
+    url: string;
+    headers: Record<string, string>;
+    method?: string;
+    bodyBase64?: string;
+    documentData?: PeachWebViewDocumentData;
+    config: string;
+    beforeKey: string;
+    beforeContent: string;
+    afterContent: string;
+    incognito: boolean;
+} | {
+    kind: 'detach';
+    instanceId: string;
+} | {
+    kind: 'cookies';
+    instanceId: string;
+    cookies: string;
+} | {
+    kind: 'evaluate';
+    instanceId: string;
+    js: string;
+    userAgent?: string;
+} | {
+    kind: 'tap';
+    instanceId: string;
+    x: number;
+    y: number;
+} | {
+    kind: 'fileResponse';
+    instanceId: string;
+    requestId: number;
+    file: {
+        mimeType: string;
+        bytesBase64: string;
+    } | null;
+} | {
+    kind: 'snapshot';
+    instanceId: string;
+    requestId: number;
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    scale: number;
+};
+export type { SootSimCornerRadii, NativeSurfaceShadow, NativeSurfaceShadowCast, NativeSurfaceLayout, NativeSurfacePresentation, NativeSurfaceIdentity, NativeSurfacePresented, NativeSurfaceRegistration, } from './nativeSurfaceContract.d.ts';
+import type { SootSimCornerRadii, NativeSurfacePresentation } from './nativeSurfaceContract.d.ts';
+export declare function uncutCornerRadii(radii: SootSimCornerRadii, rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, clipped: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): SootSimCornerRadii | undefined;
+export interface SootSimWebKitConfiguration {
+    navigation: number;
+    navigationType: -1 | 2 | 3;
+    userScripts: Array<{
+        source: string;
+        time: 0 | 1;
+    }>;
+    messageHandlers: string[];
+    userAgent?: string;
+}
+export type SootSimWebKitValue = {
+    type: 'null';
+} | {
+    type: 'string';
+    value: string;
+} | {
+    type: 'number';
+    value: number;
+} | {
+    type: 'boolean';
+    value: boolean;
+} | {
+    type: 'date';
+    value: number;
+} | {
+    type: 'array';
+    value: SootSimWebKitValue[];
+} | {
+    type: 'object';
+    value: {
+        [key: string]: SootSimWebKitValue;
+    };
+};
+export type SootSimWebKitEvent = {
+    event: 'themeColor';
+    navigation: number;
+    color: [number, number, number, number] | null;
+} | {
+    event: 'start' | 'finish';
+    navigation: number;
+    url: string;
+    title?: string;
+} | {
+    event: 'title';
+    url: string;
+    title: string;
+} | {
+    event: 'policy';
+    shouldPerformDownload: boolean;
+    headers?: Record<string, string>;
+    method?: string;
+    bodyBase64?: string;
+    navigation: number;
+    navigationType: number;
+    targetURL: string;
+    lock: number;
+} | {
+    event: 'response';
+    navigation: number;
+    targetURL: string;
+    status: number;
+    mime: string;
+    length?: number;
+    lock: number;
+} | {
+    event: 'file';
+    navigation: number;
+    requestId: number;
+    url: string;
+} | {
+    event: 'snapshot';
+    requestId: number;
+    pngBase64: string | null;
+} | {
+    event: 'redirect';
+    navigation: number;
+    url: string;
+} | {
+    event: 'fail';
+    navigation: number;
+    url: string;
+    domain: string;
+    code: number;
+    description: string;
+    provisional: boolean;
+} | {
+    event: 'cookie';
+    url: string;
+    value: string;
+} | {
+    event: 'responseCookies';
+    url: string;
+    headers: string[];
+} | {
+    event: 'message';
+    securityOrigin: string;
+    name: string;
+    body: SootSimWebKitValue;
+    requestId: number;
+} | {
+    event: 'commit';
+    securityOrigin: string;
+    navigation: number;
+    url: string;
+    canGoBack?: boolean;
+    canGoForward?: boolean;
+} | {
+    event: 'evaluate';
+    requestId: number;
+    result: {
+        value?: SootSimWebKitValue;
+        title?: string;
+        undefined?: true;
+        errorCode?: number;
+        errorInfo?: Record<string, string | number>;
+    };
+};
+export interface SootSimWebViewCookieStore {
+    cookies: string;
+    policy: 0 | 1;
+}
+export interface SootSimWebViewSpec extends Partial<NativeSurfacePresentation> {
+    cookieStore?: SootSimWebViewCookieStore;
+    captureOwner?: {
+        surfaceId: string;
+        generation: number;
+    };
+    webKit?: SootSimWebKitConfiguration;
+    source?: SootSimWebViewSource;
+    injectedJavaScript?: string;
+    injectedJavaScriptBeforeContentLoaded?: string;
+    injectedJavaScriptObject?: string;
+    hasOnOpenWindowEvent?: boolean;
+    hasOnShouldStartLoadWithRequest?: boolean;
+    incognito?: boolean;
+    javaScriptEnabled?: boolean;
+    scrollEnabled?: boolean;
+    startInLoadingState?: boolean;
+    testID?: string;
+}
+export type SootSimWebViewEvent = {
+    kind: 'webKit';
+    instanceId: string;
+    payload: SootSimWebKitEvent;
+} | {
+    kind: 'message';
+    instanceId: string;
+    data: string;
+    url: string;
+    loading: boolean;
+    title: string;
+    canGoBack: boolean;
+    canGoForward: boolean;
+    lockIdentifier: number;
+} | {
+    kind: 'presentation';
+    instanceId: string;
+    live: boolean;
+    closable: boolean;
+} | {
+    kind: 'loadStart';
+    instanceId: string;
+    url: string;
+    loading: boolean;
+    navigationType: SootSimWebViewNavigationType;
+} | {
+    kind: 'load';
+    instanceId: string;
+    url: string;
+} | {
+    kind: 'loadEnd';
+    instanceId: string;
+    url: string;
+} | {
+    kind: 'openWindow';
+    instanceId: string;
+    targetUrl: string;
+} | {
+    kind: 'navigationStateChange';
+    instanceId: string;
+    url: string;
+    title: string;
+    loading: boolean;
+    canGoBack: boolean;
+    canGoForward: boolean;
+} | {
+    kind: 'shouldStartLoadWithRequest';
+    instanceId: string;
+    url: string;
+    mainDocumentURL: string;
+    navigationType: SootSimWebViewNavigationType;
+    isTopFrame: boolean;
+    hasTargetFrame: boolean;
+    lockIdentifier: number;
+    loading: boolean;
+} | {
+    kind: 'loadingError';
+    instanceId: string;
+    url: string;
+    domain: string;
+    code: number;
+    description: string;
+    didFailProvisionalNavigation: boolean;
+} | {
+    kind: 'httpError';
+    instanceId: string;
+    url: string;
+    statusCode: number;
+};
+export type SootSimWebViewNavigationType = 'click' | 'formsubmit' | 'backforward' | 'reload' | 'formresubmit' | 'other';
+export type SootSimWebKitReply = {
+    json: string;
+} | {
+    undefined: true;
+} | {
+    error: string;
+};
+export interface SootSimWebViewBridge {
+    setMessageHandlers(instanceId: string, names: string[]): void;
+    replyScriptMessage(instanceId: string, requestId: number, reply: SootSimWebKitReply): void;
+    evaluateJavaScript(instanceId: string, requestId: number, js: string, userAgent?: string): void;
+    updateWebKitCookies(instanceId: string, requestId: number, cookies: string, policy: number): void;
+    mount(instanceId: string, spec: SootSimWebViewSpec): void;
+    update(instanceId: string, spec: SootSimWebViewSpec): void;
+    unmount(instanceId: string): void;
+    activate(instanceId: string, point?: {
+        x: number;
+        y: number;
+    }): void;
+    deactivate(instanceId: string): void;
+    injectJavaScript(instanceId: string, js: string): void;
+    postMessage(instanceId: string, data: string): void;
+    goBack(instanceId: string): void;
+    goForward(instanceId: string): void;
+    reload(instanceId: string): void;
+    stopLoading(instanceId: string, navigation?: number): void;
+    shouldStartLoadWithLockIdentifier(lockIdentifier: number, shouldStart: boolean): void;
+    fileResponse(instanceId: string, requestId: number, file: {
+        mimeType: string;
+        bytesBase64: string;
+    } | null): void;
+    snapshot(instanceId: string, requestId: number, rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, scale: number): void;
+    subscribe(listener: (event: SootSimWebViewEvent) => void): () => void;
+}
+export interface SootSimA11yBridge {
+    [key: string]: unknown;
+    setMode?(mode: string): void;
+    getMode?(): string;
+    enable?(): void;
+    disable?(): void;
+    inspect?(on?: boolean): MaybeAsync<boolean>;
+    profile?(): MaybeAsync<Record<string, unknown> | undefined>;
+    resetProfile?(): MaybeAsync<void>;
+}
+export interface SootSimPerfBridge {
+    [key: string]: unknown;
+    enableFrameStats?(reset?: boolean): unknown;
+    disableFrameStats?(): void;
+    getVsyncStats?(): unknown;
+    resetVsyncStats?(): void;
+    getLiveRenderLoad(): SootSimLiveRenderLoad;
+}
+export interface SootSimLiveRenderLoad {
+    liveFrames: number;
+    softwareAdapter: boolean | null;
+}
+export interface SootSimDebugBridge {
+    frameBreakdown: {
+        start(): void;
+        stop(): Promise<FrameBreakdownCapture>;
+    };
+    enable(...channels: string[]): readonly string[];
+    disable(...channels: string[]): readonly string[];
+    toggle(channel: string): boolean;
+    status(): readonly string[];
+    channels(): readonly string[];
+    flags(): Readonly<Record<string, boolean>>;
+    snapshot(label?: string): unknown;
+    diff(a: string, b: string): unknown;
+    snapshots(): string[];
+    clearSnapshots(label?: string): void;
+    findSheets(): unknown[];
+    findPortals(): unknown[];
+    record(on?: boolean): boolean;
+    recent(channel?: string, limit?: number): unknown[];
+    clearEvents(): void;
+    cullStats?(reset?: boolean): {
+        examined: number;
+        kept: number;
+        skipped: number;
+    };
+}
+export interface SootSimRecorderBridge {
+    renderScene(): Promise<{
+        durationMs: number;
+        frameCount: number;
+        renderTimeMs: number;
+    }>;
+    start(opts?: {
+        format?: 'webm' | 'mp4';
+        fps?: number;
+        layers?: 'full' | 'tenant' | 'shell';
+    }): Promise<{
+        ok: boolean;
+        error?: string;
+        format?: string;
+        startedAtMs?: number;
+    }>;
+    stop(): Promise<{
+        ok: boolean;
+        error?: string;
+        size?: number;
+        mime?: string;
+        durationMs?: number;
+        frameCount?: number;
+        profile?: ProfileFile | null;
+    }>;
+    state(): 'idle' | 'starting' | 'recording' | 'processing' | 'ready';
+    getStartedAtMs(): number | null;
+    getDurationMs(): number | null;
+    getBlob(): Blob | null;
+    getBlobBase64(opts?: {
+        chunk?: number;
+        offset?: number;
+    }): Promise<{
+        data: string;
+        size: number;
+        offset: number;
+        done: boolean;
+        mime: string;
+    } | null>;
+    captureFrames(count: number, durationMs: number): Promise<SootSimCapturedFrame[]>;
+    startFrameCapture(opts: {
+        count: number;
+        durationMs: number;
+        maxWidth?: number;
+        observation?: 'presented';
+        surfaceId?: string;
+    }): Promise<{
+        ok: boolean;
+        requestId?: number;
+        error?: string;
+    }>;
+    getFrameCaptureResult(requestId: number, page?: {
+        offset: number;
+        limit: number;
+    }): Promise<{
+        ok: boolean;
+        done: boolean;
+        capturedCount: number;
+        totalFrames?: number;
+        frames?: SootSimCapturedFrame[];
+        error?: string;
+    } | null>;
+    getFrameCaptureProgress(requestId: number, opts?: {
+        latestFrames?: number;
+        presentedBeforeEpochMs?: number;
+    }): Promise<{
+        done: boolean;
+        capturedCount: number;
+        latestFrames?: SootSimCapturedFrame[];
+    } | null>;
+    stopFrameCapture(requestId: number): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    flushFrameCapture(requestId: number): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    captureGif(opts: {
+        frames: number;
+        durationMs: number;
+        maxWidth?: number;
+    }): Promise<{
+        data: string;
+        size: number;
+    } | null>;
+    forceRelease(): Promise<boolean>;
+    cancel?(): void;
+}
+export interface SootSimCapturedFrame {
+    data: string;
+    size: number;
+    capturedAtEpochMs: number;
+    frameToken?: number;
+    surfacePresentations?: SootSimCapturedSurfacePresentation[];
+}
+export interface SootSimCapturedSurfacePresentation {
+    surfaceId: string;
+    display: string;
+    opacity: number;
+    scale: number;
+    animations: number;
+}
+export interface SootSimEventRecorderBridge {
+    [key: string]: unknown;
+    start?(videoStartedAtMs?: number | null): Promise<boolean>;
+    startPrelude?(): boolean;
+    markVisibleStart?(videoStartedAtMs?: number | null): Promise<boolean>;
+    stop?(): SootSimReplayEvent[];
+    clear?(): void;
+    getEvents?(): SootSimReplayEvent[];
+    isRecording?(): boolean;
+}
+export interface SootSimPreviewRecorder {
+    flush(): Promise<void>;
+    list(bundleOrigin: string): unknown[];
+    clear(): void;
+    [key: string]: unknown;
+}
+export interface SootSimPortalManager {
+    [key: string]: unknown;
+    ensureHost?(name: string): unknown;
+    releaseHost?(name: string): void;
+    getHostNode?(name: string): unknown;
+    register?(name: string, node: unknown): () => void;
+    get?(name: string): unknown;
+    list?(): string[];
+}
+export interface SootSimWindowScaleBridge {
+    get(): 'physical' | 'point' | 'pixel' | 'fit';
+    set(mode: 'physical' | 'point' | 'pixel' | 'fit'): void;
+    subscribe(fn: () => void): () => void;
+}
+export interface SootSimElectronBridge {
+    personalHomeApps?: PeachHomeApp[];
+    homeAppStorage?(bundleUrl: string): Promise<PeachHomeStorageValue[]>;
+    captureScreen(full?: boolean): Promise<string | null>;
+    captureVideo(): Promise<unknown>;
+    presentationMode?: 'window' | 'grid';
+    getPlatform?(): string;
+    shouldOfferCliInstall?(): Promise<boolean>;
+    installCli?(): Promise<{
+        persistentDaemon: boolean;
+    }>;
+    onCliInstallOffer?(callback: () => void): () => void;
+    openExternal?(url: string): MaybeAsync<void>;
+    setDevice?(model: string): void;
+    setDevicePosture?(posture: string, foldActive: boolean): void;
+    setDeviceOrientation?(orientation: string): void;
+    [key: string]: unknown;
+}
+export interface PeachHomeApp {
+    id: string;
+    name: string;
+    icon: string;
+    source: {
+        bundleUrl?: string;
+        devUrl?: string;
+    };
+}
+export interface PeachHomeStorageValue {
+    key: string;
+    value: string;
+    store: 'localStorage' | 'secureStore';
+    service?: string;
+}
+export interface PeachHomeStorageBinding {
+    key: string;
+    store: 'localStorage' | 'secureStore';
+    service?: string;
+    value?: string;
+    credential?: {
+        file: string;
+        field: string[];
+        encoding?: 'json' | 'text';
+    };
+}
+export interface PeachHomeScreenConfig {
+    apps: Array<PeachHomeApp & {
+        storage?: PeachHomeStorageBinding[];
+    }>;
+}
+export interface SootSimConsoleBuffer {
+    [key: string]: unknown;
+    getErrors?(limit?: number): unknown[];
+    getWarnings?(limit?: number): unknown[];
+    getAll?(limit?: number): unknown[];
+    clear?(): void;
+    count?(): {
+        errors: number;
+        warnings: number;
+        total: number;
+    };
+}
+export interface SootSimShellCommands {
+    [key: string]: unknown;
+    launchApp?(appId: string): MaybeAsync<unknown>;
+    goHome?(): MaybeAsync<unknown>;
+    openSwitcher?(): MaybeAsync<unknown>;
+    openSwitcherCard?(appId: string): MaybeAsync<unknown>;
+    dispatch?(cmd: {
+        type: string;
+        [key: string]: unknown;
+    }): void;
+}
+export interface SootSimMainShellBridge {
+    [key: string]: unknown;
+    launchApp?(appId: string): MaybeAsync<unknown>;
+    goBack?(): MaybeAsync<unknown>;
+    goHome?(): MaybeAsync<unknown>;
+    openSwitcher?(): MaybeAsync<unknown>;
+    openSwitcherCard?(appId: string): MaybeAsync<unknown>;
+    toggleLock?(): MaybeAsync<unknown>;
+    setTopOverlay?(overlay: 'none' | 'notification-center' | 'control-center'): MaybeAsync<unknown>;
+    getState?(): MaybeAsync<Record<string, unknown> | null>;
+    postNativeUIRequest?(request: unknown): MaybeAsync<unknown>;
+    onNativeUIEvent?(cb: (event: unknown) => void): () => void;
+}
+export interface SootSimDemoShareLeaseOptions {
+    ownerToken?: string | null;
+    bundleMode?: 'development' | 'production';
+}
+export interface SootSimDemoShareBridge {
+    activateDemoShare?(name: string, options?: SootSimDemoShareLeaseOptions): MaybeAsync<unknown>;
+    releaseCurrentShare?(options?: SootSimDemoShareLeaseOptions): MaybeAsync<unknown>;
+}
+export interface SootSimRenderActivityState {
+    busy: boolean;
+    frameToken: number;
+}
+export interface SootSimShellSceneFanoutStats {
+    fastVersion: number;
+    fastFanouts: number;
+    slowFanouts: number;
+    listenerFanouts: number;
+}
+export interface SootSimAuxCompositorStats {
+    trajectoryPosts: number;
+    trajectoryCancels: number;
+    sceneSyncs: number;
+    auxStylePasses: number;
+    browserCompositeFrames: number;
+    shellScene: SootSimShellSceneFanoutStats | null;
+}
+export interface SootSimLiveCompositeBridge {
+    getCanvas(): HTMLCanvasElement | null;
+    getFrameToken(): number;
+    captureFresh(): Promise<{
+        canvas: HTMLCanvasElement | null;
+        frameToken: number;
+    }>;
+    subscribe(listener: () => void, opts?: {
+        maxWidth?: number;
+    }): () => void;
+    setSourceScale(scale: number): void;
+    markDirty(): void;
+}
+export interface PeachAnimatedExecution {
+    id: number;
+    kind: 'delay' | 'timing' | 'spring' | 'decay';
+    phase: 'unknown' | 'waiting' | 'running' | 'finished' | 'stopped';
+    delayStartedAtMs: number | null;
+    delayMs: number | null;
+    startedAtMs: number | null;
+    lastCallbackMs: number | null;
+    callbacks: number;
+    sampleValue: number | null;
+    appliedValue: number | null;
+    applications: number;
+    endCallback: 'absent' | 'invoking' | 'returned' | null;
+}
+export interface PeachLockstepTenantFrame {
+    frameNowMs: number | null;
+    guestNowMs: number;
+    guestClockFrozen: boolean;
+    animationFramesFrozen: boolean;
+    animationFrameCallbacks: number;
+    animatedExecution: {
+        records: PeachAnimatedExecution[];
+        evicted: number;
+    } | null;
+    animatedRenderTriggers: number;
+    rendered: boolean;
+}
+export interface SootSimLockstepFrameReceipt {
+    frameIndex: number;
+    virtualTimestampMs: number;
+    tenantFrame: PeachLockstepTenantFrame | null;
+}
+export type LockstepInputReceipt = {
+    phase: 'down' | 'move' | 'up';
+    x: number;
+    y: number;
+    pointerId: number;
+    eventTimestampMs: number;
+    frameIndex: number;
+    virtualTimestampMs: number;
+};
+export type LockstepScheduledInput = {
+    afterMs: number;
+    eventAfterMs?: number;
+    phase: LockstepInputReceipt['phase'];
+    x: number;
+    y: number;
+    pointerId: number;
+    deliver: (timestampMs: number) => Promise<void>;
+};
+export interface SootSimLockstepCaptureController {
+    readonly initialFrame: SootSimLockstepFrameReceipt;
+    readonly inputReceipts: LockstepInputReceipt[];
+    scheduleInput(events: LockstepScheduledInput[]): Promise<void>;
+    stepFrame(elapsedMs?: number, options?: {
+        awaitPageShown?: boolean;
+    }): Promise<SootSimLockstepFrameReceipt>;
+    flushFrame(options?: {
+        awaitPageShown?: boolean;
+    }): Promise<SootSimLockstepFrameReceipt>;
+    framesForOffset(offsetMs: number): number;
+    stageTouchOffsetMs(touches: ReadonlyArray<{
+        scheduledMs: number;
+        landedMs: number;
+    }>, offsetMs: number): number;
+    stepToOffset(anchor: SootSimLockstepFrameReceipt, offsetMs: number): Promise<SootSimLockstepFrameReceipt>;
+    endWorkletFrameReceipt(): void;
+    end(): void;
+}
+export interface SootSimLockstepCaptureBridge {
+    begin(fps: number, options?: {
+        baseline?: boolean;
+        holdGpuScenes?: boolean;
+        workletFrameTimestampsSeconds?: number[];
+    }): Promise<SootSimLockstepCaptureController>;
+    end(): boolean;
+}
+export type PointerDeliveryTarget = 'tenant' | 'shell';
+export interface PointerDeliveryPendingDrop {
+    ackRequestId: number;
+    target: PointerDeliveryTarget;
+    surfaceId: string;
+    phase: string;
+    elapsedMs: number;
+    timestamp: number;
+}
+export interface PointerDeliveryStats {
+    sent: number;
+    acked: number;
+    droppedTimeouts: number;
+    pending: number;
+    lastAckLatencyMs: number | null;
+    maxAckLatencyMs: number;
+    recentDrops: PointerDeliveryPendingDrop[];
+}
+export interface SootSimShellHostBridge {
+    getPointerDeliveryStats(): PointerDeliveryStats;
+    getHeartbeatCount(): number;
+    getLastHeartbeatAt(): number;
+    getRenderActivity(): SootSimRenderActivityState;
+    subscribeRenderActivity(listener: () => void): () => void;
+    getSceneFanoutStats(): SootSimShellSceneFanoutStats;
+    triggerSnapshotRequest(): void;
+}
+export type SootSimLaunchArguments = Record<string, unknown>;
+export interface SootSimExternalAppLifecycleOptions {
+    launchArguments?: SootSimLaunchArguments | null;
+    initialUrl?: string | null;
+    relaunch?: boolean;
+}
+export type SootSimStorageResetStrategy = 'data' | 'full';
+export interface SootSimExternalAppResetOptions extends SootSimExternalAppLifecycleOptions {
+    strategy: SootSimStorageResetStrategy;
+}
+export interface SootSimExternalAppResetResult {
+    cleared: string[];
+    failures: string[];
+    relaunched: boolean;
+    workerReloaded: boolean;
+}
+export interface SootSimHotRemountBridge {
+    hotRemount(reason?: string): MaybeAsync<void>;
+    reloadExternalApp(options?: SootSimExternalAppLifecycleOptions): MaybeAsync<void>;
+    resetExternalApp?(options: SootSimExternalAppResetOptions): MaybeAsync<SootSimExternalAppResetResult>;
+}
+export interface SootSimSettingsBridge {
+    get(): unknown;
+    set(key: string, value: unknown): boolean;
+    apply(settings: Record<string, unknown>): unknown;
+    applyRuntime(settings: Record<string, unknown>): unknown;
+    subscribe(listener: () => void): () => void;
+}
+export interface SootSimCaptureFilter {
+    hideTestIds?: string[];
+    soloTestId?: string;
+    soloNodeId?: number;
+    soloOwnPaint?: boolean;
+    fitToOutput?: {
+        width: number;
+        height: number;
+        frame?: SootSimLayout;
+    };
+}
+export interface SootSimCaptureOptions {
+    layers?: 'full' | 'tenant' | 'shell';
+    usePresentedFrame?: boolean;
+    outputWidth?: number;
+    outputHeight?: number;
+    crop?: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    suppressText?: boolean;
+    captureFilter?: SootSimCaptureFilter;
+    format?: 'webp' | 'png';
+    quality?: number;
+}
+export declare const SOOTSIM_CAPTURE_IMAGE_QUALITY = 0.8;
+export declare function sootsimCaptureIsFlat(canvas: {
+    width: number;
+    height: number;
+    getContext(id: '2d', opts?: {
+        willReadFrequently?: boolean;
+    }): unknown;
+}): boolean;
+export declare const SOOTSIM_TIMELINE_KINDS: readonly ['console', 'fetch', 'app-launch', 'shell', 'route', 'screen', 'flow-step', 'keyboard', 'alert', 'actionsheet', 'picker', 'notification', 'toast', 'scroll', 'gesture', 'text-input', 'react-commit', 'layout', 'animation', 'console-log', 'frame', 'profile', 'animation-samples', 'memory'];
+export type SootSimTimelineKind = (typeof SOOTSIM_TIMELINE_KINDS)[number];
+export declare function isTimelineKind(value: unknown): value is SootSimTimelineKind;
+export declare function isTimelineEvent(value: unknown): value is SootSimTimelineEvent;
+export type SootSimTimelineContext = 'host' | 'shell' | 'tenant';
+export interface SootSimTimelineEvent {
+    schemaVersion: 1;
+    t: number;
+    seq: number;
+    context: SootSimTimelineContext;
+    kind: SootSimTimelineKind;
+    id?: string;
+    data: unknown;
+}
+export interface SootSimTimelineQuery {
+    kinds?: SootSimTimelineKind | SootSimTimelineKind[];
+    since?: number;
+    sinceCursor?: string;
+    until?: number;
+    limit?: number;
+}
+export interface SootSimTimelineQueryResult {
+    events: SootSimTimelineEvent[];
+    watermark: number;
+}
+export interface SootSimTimelineCountsByKind {
+    [kind: string]: number;
+}
+export interface SootSimTimelineSummary {
+    total: number;
+    byKind: SootSimTimelineCountsByKind;
+    firstAt: number | null;
+    lastAt: number | null;
+}
+export interface SootSimTimelineStatus {
+    enabled: SootSimTimelineKind[];
+    all: SootSimTimelineKind[];
+    ringSizes: {
+        host: number;
+        shell: number;
+        tenant: number;
+    };
+}
+export interface SootSimTimelineBridge {
+    record(kind: SootSimTimelineKind, data: unknown, opts?: {
+        id?: string;
+        t?: number;
+    }): void;
+    recent(query?: SootSimTimelineQuery): SootSimTimelineQueryResult;
+    summary(query?: SootSimTimelineQuery): SootSimTimelineSummary;
+    cursorAdvance(key: string, watermark: number): void;
+    cursorAt(key: string): number;
+    cursorClear(key: string): void;
+    enable(...kinds: (SootSimTimelineKind | 'all')[]): void;
+    disable(...kinds: (SootSimTimelineKind | 'all')[]): void;
+    clear(): void;
+    status(): SootSimTimelineStatus;
+}
+export interface SootSimReactProfileBridge {
+    start(opts?: {
+        includeProps?: boolean;
+        maxCommits?: number;
+    }): MaybeAsync<unknown>;
+    stop(): MaybeAsync<unknown>;
+    slow(opts?: {
+        limit?: number;
+    }): MaybeAsync<unknown>;
+    rerenders(opts?: {
+        limit?: number;
+    }): MaybeAsync<unknown>;
+    tree(opts?: {
+        depth?: number;
+        find?: string;
+    }): MaybeAsync<unknown>;
+    why(fiberId: number): MaybeAsync<unknown>;
+}
+export interface SootSimShellPerfBridge {
+    start(): MaybeAsync<unknown>;
+    stop(): MaybeAsync<unknown>;
+}
+export type SootSimScrollTraceLayer = 'tenant' | 'shell' | 'compositor';
+export interface SootSimScrollOffsetSample {
+    layer: SootSimScrollTraceLayer;
+    t: number;
+    seq: number;
+    surfaceId: string;
+    nodeId: number;
+    generation?: number;
+    frameToken?: number;
+    surfaceEpoch?: number;
+    textureEpoch?: number;
+    drag?: boolean;
+    momentum?: boolean;
+    offsetX: number;
+    offsetY: number;
+    slotX?: number;
+    slotY?: number;
+    phase?: 'idle' | 'drag' | 'momentum' | 'active';
+    paint?: number;
+    contentWidth?: number;
+    contentHeight?: number;
+    viewportWidth?: number;
+    viewportHeight?: number;
+}
+export interface SootSimTransitionProgressSample {
+    t: number;
+    surfaceId: string;
+    stackId: number;
+    progress: number;
+    targetApplies: number;
+    targetChanges: number;
+    targetMisses: number;
+    paintCount: number;
+}
+export interface SootSimPressPerformanceSample {
+    inputSurfaceId: string;
+    surfaceId: string;
+    targetWasMounted: boolean;
+    pointerT: number;
+    treeT: number;
+    paintT: number;
+}
+export interface SootSimScrollPerformanceTrace {
+    startedAt: number;
+    stoppedAt: number;
+    paired: false;
+    layers: {
+        tenant: SootSimScrollOffsetSample[];
+        shell: SootSimScrollOffsetSample[];
+        compositor: SootSimScrollOffsetSample[];
+    };
+    transitions: SootSimTransitionProgressSample[];
+    presses: SootSimPressPerformanceSample[];
+}
+export interface SootSimScrollPerfBridge {
+    start(limit?: number, pressTestID?: string): MaybeAsync<void>;
+    stop(): MaybeAsync<SootSimScrollPerformanceTrace>;
+}
+export interface SootSimReactDevtoolsConnection {
+    send(frame: unknown): void;
+    disconnect(): void;
+}
+export interface SootSimReactDevtoolsBridge {
+    connect(onFrame: (frame: unknown) => void): SootSimReactDevtoolsConnection;
+}
+export type SootSimSceneStreamCommand = {
+    action: 'recordStart';
+} | {
+    action: 'recordStop';
+} | {
+    action: 'play';
+} | {
+    action: 'pause';
+} | {
+    action: 'seek';
+    timeMs: number;
+} | {
+    action: 'step';
+    timeMs: number;
+} | {
+    action: 'state';
+};
+export interface SootSimSceneReplayState {
+    timeMs: number;
+    durationMs: number;
+    playing: boolean;
+    ended: boolean;
+    recordedAtEpochMs: number | null;
+}
+export type SootSimSceneStreamResult = {
+    action: 'recordStart';
+} | {
+    action: 'recordStop';
+    bytes: Uint8Array;
+    durationMs: number;
+    frameCount: number;
+} | ({
+    action: 'play' | 'pause' | 'seek' | 'step' | 'state';
+} & SootSimSceneReplayState);
+export interface SootSimSceneStreamBridge {
+    run(command: SootSimSceneStreamCommand): Promise<SootSimSceneStreamResult>;
+}
+export interface SootSimBridges {
+    test: SootSimTestBridge | null;
+    interact: SootSimInteractBridge | null;
+    keyboard: SootSimKeyboardBridge | null;
+    camera: SootSimCameraBridge | null;
+    video: SootSimVideoBridge | null;
+    speechSynthesis: SootSimSpeechSynthesisBridge | null;
+    audioRecorder: SootSimAudioRecorderBridge | null;
+    mediaSession: SootSimMediaSessionBridge | null;
+    clipboard: SootSimClipboardBridge | null;
+    hostStorage: SootSimHostStorageBridge | null;
+    demoShare: SootSimDemoShareBridge | null;
+    imagePicker: SootSimImagePickerBridge | null;
+    imageCropper: SootSimImageCropperBridge | null;
+    androidDateTimePicker: SootSimAndroidDateTimePickerBridge | null;
+    shareSheet: SootSimShareSheetBridge | null;
+    photoLibrary: SootSimPhotoLibraryBridge | null;
+    permissions: SootSimPermissionsBridge | null;
+    navigationRoutes: SootSimNavigationRoutesBridge | null;
+    linkingDispatcher: SootSimLinkingDispatcherBridge | null;
+    webview: SootSimWebViewBridge | null;
+    a11y: SootSimA11yBridge | null;
+    perf: SootSimPerfBridge | null;
+    shellPerf: SootSimShellPerfBridge | null;
+    scrollPerf: SootSimScrollPerfBridge | null;
+    debug: SootSimDebugBridge | null;
+    timeline: SootSimTimelineBridge | null;
+    profiler: SootSimProfilerBridge | null;
+    reactProfile: SootSimReactProfileBridge | null;
+    reactDevtools: SootSimReactDevtoolsBridge | null;
+    recorder: SootSimRecorderBridge | null;
+    eventRecorder: SootSimEventRecorderBridge | null;
+    previewRecorder: SootSimPreviewRecorder | null;
+    portalManager: SootSimPortalManager | null;
+    settings: SootSimSettingsBridge | null;
+    windowScale: SootSimWindowScaleBridge | null;
+    electron: SootSimElectronBridge | null;
+    shellHost: SootSimShellHostBridge | null;
+    shellCommands: SootSimShellCommands | null;
+    mainShell: SootSimMainShellBridge | null;
+    hotRemount: SootSimHotRemountBridge | null;
+    liveComposite: SootSimLiveCompositeBridge | null;
+    sceneStream: SootSimSceneStreamBridge | null;
+    lockstepCapture: SootSimLockstepCaptureBridge | null;
+    exitApp: (() => void) | null;
+    forceRender: (() => void) | null;
+    scrollToTop: (() => void) | null;
+    screenshot: ((opts?: SootSimCaptureOptions) => Promise<string>) | null;
+    getWindowSnapshot: (() => unknown) | null;
+    appSnapshot: ((appId: string) => unknown) | null;
+    captureBundle: (() => unknown) | null;
+    readTransformedBundleSlice: ((offset: number, end: number) => Promise<string | null>) | null;
+    createPortal: ((children: unknown, rootNode: unknown, key?: string | null) => unknown) | null;
+    toggleRecording: (() => void) | null;
+    isRecording: (() => boolean) | null;
+    getRecordingState: (() => unknown) | null;
+    getRecordingStartError: (() => string | null) | null;
+    startRecording: ((mode?: PeachRecordingMode, layers?: 'full' | 'tenant' | 'shell', options?: PeachRecordingStartOptions) => Promise<boolean>) | null;
+    startRecordingPrelude: (() => boolean | Promise<boolean>) | null;
+    stopRecording: (() => Promise<boolean | 'pending'>) | null;
+    cancelRecording: (() => void) | null;
+    setSession: ((snapshot: {
+        token: string | null;
+        user: {
+            id: string;
+            name?: string;
+            email?: string;
+            image?: string;
+        } | null;
+    }) => void) | null;
+    workerPerfStats: (() => Promise<unknown>) | null;
+    workerPerfStart: (() => unknown) | null;
+    workerPerfStop: (() => Promise<unknown>) | null;
+    workerCpuProfileStart: ((opts?: {
+        sampleInterval?: number;
+        maxBufferSize?: number;
+    }) => unknown) | null;
+    workerCpuProfileStop: (() => Promise<unknown>) | null;
+}
+export interface SootSimAccessibilityState {
+    disabled: boolean;
+    selected: boolean;
+    checked: boolean | 'mixed';
+    busy: boolean;
+    expanded: boolean;
+}
+export interface SootSimAccessibilityValue {
+    min?: number;
+    max?: number;
+    now?: number;
+    text?: string;
+}
+export type SootSimAccessibilityLiveRegion = 'none' | 'polite' | 'assertive';
+export interface SootSimFocusedNodeInfo extends SootSimNodeInfo {
+    ancestorNodeIds: number[];
+}
+export interface SootSimAccessibilityInput {
+    nodeId: number;
+    rootId: number;
+    activate: boolean;
+    escape: boolean;
+    adjust: boolean;
+}
+export interface SootSimNodeInfo {
+    nativeTag?: number;
+    accessibilityFrame?: SootSimLayout;
+    nativeType?: string | null;
+    nodeId: number;
+    type: string;
+    id: string | null;
+    testID: string | null;
+    text: string | null;
+    style: Record<string, unknown>;
+    layout: SootSimLayout;
+    frame: SootSimLayout | null;
+    absolutePosition: {
+        x: number;
+        y: number;
+        width?: number;
+        height?: number;
+    };
+    visibleFrame: SootSimVisibleFrame | null;
+    childCount: number;
+    pressed: boolean;
+    pressable: boolean;
+    isTextInput: boolean;
+    textSelection: {
+        start: number | null;
+        end: number | null;
+    } | null;
+    secureTextEntry: boolean;
+    placeholder: string | null;
+    scrollOffsetX: number;
+    scrollOffsetY: number;
+    zoomScale: number | null;
+    nativePinchEnabled: boolean;
+    contentOffsetProp: {
+        x?: number;
+        y?: number;
+    } | null;
+    decelerationRateProp: unknown;
+    strokeDashoffsetProp: number | null;
+    accessible: boolean;
+    accessibilityLabel: string | null;
+    accessibilityRole: string | null;
+    accessibilityHint: string | null;
+    accessibilityIdentifier?: string | null;
+    accessibilityUserInputLabels?: string[] | null;
+    accessibilityTraits?: string[];
+    accessibilityLiveRegion: SootSimAccessibilityLiveRegion | null;
+    accessibilityState: SootSimAccessibilityState | null;
+    accessibilityValue: SootSimAccessibilityValue | null;
+    accessibilityInput?: SootSimAccessibilityInput;
+}
+export interface SootSimStyleTokenBinding {
+    token: string;
+    theme: string;
+}
+export interface SootSimCapturedTextSegment {
+    text: string;
+    color?: string | number;
+    fontFamily?: string;
+    fontSize?: number;
+    fontStyle?: string;
+    fontWeight?: string | number;
+    letterSpacing?: number;
+    textDecorationLine?: string;
+}
+export interface SootSimCapturedTextLine {
+    text: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    baseline: number;
+    segments?: SootSimCapturedTextSegment[];
+}
+export interface SootSimRenderTreeNode extends SootSimNodeInfo {
+    nativeSurfaceId?: string;
+    parentNodeId: number | null;
+    childNodeIds: number[];
+    paintIndex: number;
+    props: Record<string, unknown>;
+    inspect: SootSimInspectInfo;
+    styleTokenBindings: Record<string, SootSimStyleTokenBinding>;
+    textLines?: SootSimCapturedTextLine[];
+}
+export interface SootSimRenderTreeSnapshot {
+    width: number;
+    height: number;
+    rootNodeId: number;
+    nodes: SootSimRenderTreeNode[];
+    commitRevision?: number;
+}
+export interface SootSimCaptureTransactionReceipt {
+    token: number;
+    commitRevision: number;
+}
+export interface SootSimCaptureBoundLongPressReceipt {
+    handled: boolean;
+    transaction: SootSimCaptureTransactionReceipt;
+}
+export interface SootSimCaptureBoundTapReceipt {
+    handled: SootSimTapResult;
+    transaction: SootSimCaptureTransactionReceipt;
+    transition: SootSimScreenTransitionWaitResult | null;
+}
+export interface SootSimDebugNodeInfo {
+    nodeId: number;
+    parentNodeId: number | null;
+    childNodeIds: number[];
+    type: string;
+    text: string | null;
+    testID: string | null;
+    accessibilityRole: string | null;
+    pointerEvents: string | null;
+    layout: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    style: Record<string, unknown>;
+    runtime: {
+        hasFocusImpl: boolean;
+        hasBlurImpl: boolean;
+        hasClearImpl: boolean;
+        hasIsFocusedImpl: boolean;
+        isFocused: boolean | null;
+        hasTextInputState: boolean;
+        controlledTextInput: boolean | null;
+    };
+    propKeys: string[];
+    handlers: Record<string, boolean>;
+}
+export interface SootSimVisibleFrame extends SootSimLayout {
+    area?: number;
+    hidden?: SootSimVisibleFrameHidden;
+}
+export interface SootSimVisibilityNodeRef {
+    nodeId: number;
+    type: string;
+    testID: string | null;
+}
+export type SootSimVisibleFrameHidden = {
+    cached?: true;
+} & ({
+    path: 'unpainted';
+    by: SootSimVisibilityNodeRef;
+    style: 'hidden' | 'opacity' | 'display-none';
+} | {
+    path: 'clipped';
+    paint: SootSimLayout;
+    clip: SootSimLayout | null;
+    viewport: SootSimLayout | null;
+    by: (SootSimVisibilityNodeRef | 'viewport')[];
+} | {
+    path: 'occluded';
+    clipped: SootSimLayout;
+    by: SootSimVisibilityNodeRef;
+    rect: SootSimLayout;
+} | {
+    path: 'unknown';
+});
+export interface SootSimLayout {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface SootSimDeviceSpec {
+    platform?: 'ios' | 'android';
+    width: number;
+    height: number;
+    scale: number;
+    statusBarHeight?: number;
+    homeIndicatorHeight?: number;
+    navigationBarHeight?: number;
+    osVersion?: string;
+    iosVersion?: string;
+    androidApiLevel?: number | null;
+}
+export interface SootSimEngineSnapshot {
+    recording: {
+        state: 'idle' | 'recording' | 'processing';
+        mode: PeachRecordingMode | null;
+        duration: number;
+    };
+    inspectActive: boolean;
+    selectedInspect: SootSimInspectInfo | null;
+    devtoolsOpen: boolean;
+    devtoolsPosition: 'right' | 'bottom';
+    devtoolsTab: 'network' | 'performance' | 'logs' | 'agent' | 'test' | 'react' | 'report' | 'onboard' | 'recordings' | 'inspect';
+    devtoolsFilterLogLevel: 'log' | 'info' | 'warn' | 'error' | 'debug' | null;
+    a11yMode: 'off' | 'delayed' | 'active' | 'default' | 'always' | 'agent';
+    ringMode: 'ring' | 'silent';
+    browserNav: {
+        canGoBack: boolean;
+        isAppOpen: boolean;
+    } | null;
+    activeApp: {
+        appId: string | null;
+        appName: string | null;
+        isAppOpen: boolean;
+    };
+    windowState: {
+        deviceModel: string;
+        deviceSpec: SootSimDeviceSpec;
+        orientation: 'portrait' | 'landscape';
+        scaleMode: 'physical' | 'point' | 'pixel' | 'fit';
+        agentProvider: 'codex' | 'claude';
+        showFrame: boolean;
+        showMenuBar: boolean;
+        showRail: boolean;
+        solidWindow: boolean;
+        ambientGlow: 'off' | 'soft' | 'full';
+        stageBackground: 'system' | 'light' | 'dark' | 'gray';
+        stageChecker: boolean;
+        screenshotMode: boolean;
+        threeMode: boolean;
+        threeRecordingEditor: boolean;
+        screenshotCanvas: string;
+        screenshotBackground: string;
+        screenshotText: string;
+        screenshotPose: string;
+        screenshotDynamicSize: boolean;
+    } | null;
+    menuDefs: unknown;
+}
+export type SootSimReplayCursorMode = 'live' | 'replay';
+export interface SootSimReplayCursorPose {
+    x: number;
+    y: number;
+    scale: number;
+    pressed: boolean;
+    opacity: number;
+    transitionMs: number;
+}
+export interface SootSimReplayCursorState {
+    visible: boolean;
+    mode: SootSimReplayCursorMode;
+    tone: 'blue' | 'gray';
+    home: {
+        x: number;
+        y: number;
+    };
+    primary: SootSimReplayCursorPose;
+    secondary: SootSimReplayCursorPose | null;
+    hasReplayMoved: boolean;
+}
+export interface SootSimAgentActionDetail {
+    type: 'tap' | 'longPress' | 'drag' | 'pinch' | 'scroll' | 'type' | 'screenshot' | 'move';
+    x?: number;
+    y?: number;
+    toX?: number;
+    toY?: number;
+    x2?: number;
+    y2?: number;
+    toX2?: number;
+    toY2?: number;
+    durationMs?: number;
+    moveMs?: number;
+    text?: string;
+    keyboardAction?: 'type' | 'press' | 'dispatchKey' | 'dismiss' | 'edit';
+    edit?: TextInputEditCommand;
+    target?: SootSimReplayTarget;
+}
+export type SootSimHardwareKeyboardInputDetail = {
+    keyboardAction: 'type' | 'dispatchKey';
+    text: string;
+} | {
+    keyboardAction: 'edit';
+    edit: TextInputEditCommand;
+};
+export interface SootSimReplayTarget {
+    nodeId?: number | null;
+    id?: string | null;
+    testID?: string | null;
+    text?: string | null;
+    type?: string | null;
+}
+export declare function createSootSimReplayScreenIdentity(nodes: readonly PeachAccessibilityNode[]): string;
+export interface SootSimReplayEvent {
+    startScreen?: string;
+    t: number;
+    sourceT?: number;
+    type: Exclude<SootSimAgentActionDetail['type'], 'screenshot'>;
+    x?: number;
+    y?: number;
+    toX?: number;
+    toY?: number;
+    x2?: number;
+    y2?: number;
+    toX2?: number;
+    toY2?: number;
+    durationMs?: number;
+    moveMs?: number;
+    text?: string;
+    keyboardAction?: 'type' | 'press' | 'dispatchKey' | 'dismiss' | 'edit';
+    edit?: TextInputEditCommand;
+    target?: SootSimReplayTarget;
+    path?: SootSimReplayPathPoint[];
+}
+export interface SootSimReplayPathPoint {
+    x: number;
+    y: number;
+    dt: number;
+}
+export interface SootSimReplayPreviewState {
+    flowVideoUrl: string | null;
+    flowVideoDurationMs: number | null;
+    bootSnapshotUrl: string | null;
+    bootLoading: boolean;
+    flowVideoLoaded: boolean;
+    sceneLoaded: boolean;
+    recordingStartedAtMs: number | null;
+    surface: 'video' | 'live';
+    interaction: 'replay' | 'paused' | 'live';
+}
+export interface SootSimReplayState {
+    status: 'idle' | 'loading' | 'ready' | 'error';
+    previewId: string | null;
+    error: string | null;
+    events: SootSimReplayEvent[];
+    playback: {
+        playing: boolean;
+        scrubbing: boolean;
+        currentTimeMs: number;
+        durationMs: number;
+        currentEventIndex: number;
+        rate: number;
+    };
+    restore: {
+        phase: 'idle' | 'reloading' | 'restoring';
+        targetTimeMs: number | null;
+        progress: number;
+    };
+    cursor: SootSimReplayCursorState;
+    preview: SootSimReplayPreviewState;
+}
+export type SootSimRenderMode = 'main' | 'worker';
+export type SootSimTransformedBundle = {
+    url: string;
+    blob: Blob;
+    byteLength: number;
+    timestamp: number;
+    nativeAppIdentityHeader?: string | null;
+};
+export type SootSimConnection = 'idle' | 'connecting' | 'connected' | 'disconnected';
+export type SootSimShellPathRoute = {
+    kind: 'home';
+} | {
+    kind: 'connect-rn';
+} | {
+    kind: 'app';
+    slug: string;
+} | {
+    kind: 'rn';
+    id: string;
+} | {
+    kind: 'dock';
+    id: string;
+};
+export interface SootSimShellRouteSnapshot {
+    pathname: string;
+    search: string;
+    hash: string;
+    shellRoute: SootSimShellPathRoute;
+}
+export interface SootSimRouter {
+    getSnapshot?: () => SootSimShellRouteSnapshot;
+    subscribe?: (listener: () => void) => () => void;
+    push?: (route: SootSimShellPathRoute) => void;
+    replace?: (route: SootSimShellPathRoute) => void;
+    parsePath?: (pathname: string) => SootSimShellPathRoute;
+    buildUrl?: (currentHref: string, route: SootSimShellPathRoute) => string;
+    isManagedPath?: (pathname: string) => boolean;
+    assignAppRouteSlugs?: <T extends {
+        id: string;
+        name: string;
+    }>(entries: T[]) => Array<T & {
+        routeSlug: string;
+    }>;
+    assignRNRouteIds?: <T extends {
+        port: number;
+        projectName?: string;
+    }>(entries: T[]) => Array<T & {
+        routeId: string;
+    }>;
+}
+export interface SootSimState {
+    root: unknown;
+    renderHost: unknown;
+    engineSnapshot: SootSimEngineSnapshot | null;
+    simId: string | null;
+    stats: {
+        [key: string]: unknown;
+        getSnapshot?: () => Record<string, unknown>;
+        getAnimationDebugInfo?: () => unknown;
+    } | null;
+    lastTransformedBundle: SootSimTransformedBundle | null;
+    launchMetadata: {
+        reference: string;
+        metadata: URLSearchParams;
+    } | null;
+    console: SootSimConsoleBuffer | null;
+    connection: SootSimConnection;
+    renderMode: SootSimRenderMode;
+    verboseLogs: boolean;
+    capturedComponent: unknown;
+    capturedKey: string | null;
+    rolldownStubs: Record<string, unknown> | null;
+    requestAnimationFrame: ((cb: FrameRequestCallback) => number) | null;
+    shellEventsInstalled: boolean;
+}
+export interface SootSimDebugChannels {
+    portals: boolean;
+    sheets: boolean;
+    layout: boolean;
+    onlayout: boolean;
+    animated: boolean;
+    render: boolean;
+    touch: boolean;
+    yoga: boolean;
+    [key: string]: boolean;
+}
+export interface SootSimDebugEvent {
+    channel: string;
+    ts: number;
+    payload: unknown;
+}
+export interface SootSimDebugState {
+    channels: SootSimDebugChannels;
+    snapshots: Map<string, unknown>;
+    events: SootSimDebugEvent[];
+    recording: boolean;
+}
+export interface SootSimGlobals {
+    chrome: SootSimChrome;
+    router: SootSimRouter;
+    bridges: SootSimBridges;
+    state: SootSimState;
+    debug: SootSimDebugState;
+    replayStore: Emitter<SootSimReplayState>;
+}
+export declare function inferCursorMoveMs(prevPoint: {
+    x: number;
+    y: number;
+} | null | undefined, nextPoint: {
+    x: number;
+    y: number;
+} | null | undefined, gapMs?: number): number;
+export declare function createSootSimReplayCursorState(mode?: SootSimReplayCursorMode, home?: {
+    x: number;
+    y: number;
+}): SootSimReplayCursorState;
+export declare function createSootSimReplayState(): SootSimReplayState;
+export interface SootSimLegacyGlobals {
+    __sootsimRoot: SootSimState['root'];
+    __sootsimRenderHost: SootSimState['renderHost'];
+    __sootsimSimId: string | null;
+    __sootsimVerboseLogs: boolean;
+    __sootsimEngineState: SootSimEngineSnapshot | null;
+    __sootsimBridgeInstalled: boolean;
+    __sootsimLastTransformedBundle: SootSimState['lastTransformedBundle'];
+    __sootsimConsole: SootSimConsoleBuffer | null;
+    __sootsimStats: SootSimState['stats'];
+    __sootsim_rolldown_stubs: Record<string, unknown> | null;
+    __sootsim_captured_component: SootSimState['capturedComponent'];
+    __sootsim_captured_key: string | null;
+    __sootsimRequestAnimationFrame: SootSimState['requestAnimationFrame'];
+    __sootsim_demo_gateway_origin: string | null;
+    __sootsimTest: SootSimTestBridge | null;
+    __sootsimInteract: SootSimInteractBridge | null;
+    __sootsimKeyboard: SootSimKeyboardBridge | null;
+    __sootsimA11y: SootSimA11yBridge | null;
+    __sootsimDebug: SootSimDebugBridge | null;
+    __sootsimTimeline: SootSimTimelineBridge | null;
+    __sootsimPerf: SootSimPerfBridge | null;
+    __sootsimShellPerf: SootSimShellPerfBridge | null;
+    __sootsimRecorder: SootSimRecorderBridge | null;
+    __sootsimEventRecorder: SootSimEventRecorderBridge | null;
+    __sootsimPreviewRecorder: SootSimPreviewRecorder | null;
+    __sootsimPortalManager: SootSimPortalManager | null;
+    __sootsimCreatePortal: SootSimBridges['createPortal'];
+    __sootsimSettings: SootSimSettingsBridge | null;
+    __sootsimWindowScale: SootSimWindowScaleBridge | null;
+    __sootsimShell: SootSimShellHostBridge | null;
+    __sootsimShellCommands: SootSimShellCommands | null;
+    __sootsimForceRender: SootSimBridges['forceRender'];
+    __sootsimScrollToTop: SootSimBridges['scrollToTop'];
+    __sootsimScreenshot: SootSimBridges['screenshot'];
+    __sootsimGetWindowSnapshot: SootSimBridges['getWindowSnapshot'];
+    __sootsimSnapshot: SootSimBridges['appSnapshot'];
+    __sootsimCaptureBundle: SootSimBridges['captureBundle'];
+    __sootsimToggleRecording: SootSimBridges['toggleRecording'];
+    __sootsimIsRecording: SootSimBridges['isRecording'];
+    __sootsimGetRecordingState: SootSimBridges['getRecordingState'];
+    __sootsimPerfStats: SootSimBridges['workerPerfStats'];
+    __sootsimPerfStart: SootSimBridges['workerPerfStart'];
+    __sootsimPerfStop: SootSimBridges['workerPerfStop'];
+}
+export interface SootSimMetroAssetRecord {
+    httpServerLocation?: string;
+    name?: string;
+    type?: string;
+    scales?: number[];
+    width?: number;
+    height?: number;
+}
+export interface SootSimMetroRequire {
+    (moduleId: number | string): unknown;
+    getModules?: () => Map<number | string, unknown> | Record<string, unknown>;
+}
+export interface SootSimTenantLocation {
+    href: string;
+    origin: string;
+    protocol: string;
+    host: string;
+    hostname: string;
+    port: string;
+    pathname: string;
+    search: string;
+    hash: string;
+    assign(next: string): void;
+    replace(next: string): void;
+    reload(): void;
+    toString(): string;
+}
+export interface SootSimTenantNavigator {
+    product: 'ReactNative';
+    userAgent: string;
+    platform: string;
+    language: string;
+    languages: string[];
+    onLine: boolean;
+    maxTouchPoints: number;
+    clipboard: {
+        readText(): Promise<string>;
+        writeText(text: string): Promise<void>;
+    };
+    canShare(data?: unknown): boolean;
+    vibrate(pattern?: number | number[]): boolean;
+    mediaDevices: {
+        getUserMedia(constraints?: unknown): Promise<MediaStream>;
+        enumerateDevices?(): Promise<MediaDeviceInfo[]>;
+    };
+    geolocation?: Geolocation;
+    credentials?: CredentialsContainer;
+    permissions?: Permissions;
+    storage?: StorageManager;
+}
+export interface SootSimTenantScreen {
+    width: number;
+    height: number;
+    availWidth: number;
+    availHeight: number;
+    orientation: {
+        angle: number;
+        type: string;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
+    };
+}
+export interface SootSimWorkerTextInputBridge<Node = unknown> {
+    focus?(node: Node): boolean;
+    focusCommand?(node: Node): boolean;
+    blur?(node: Node): boolean;
+    isFocused?(node: Node): boolean;
+    blurFocused?(): boolean;
+    isAnyFocused?(): boolean;
+    getFocused?(): Node | null;
+    focusAdjacent?(direction: 1 | -1): boolean;
+    focusCurrent?(): boolean;
+}
+export declare const SOOTSIM_KEYBOARD_TOOLBAR_GROUP_PROP: '__sootsimKeyboardToolbarGroup';
+export interface SootSimWorkerTextInputBridgeGlobal<Node = unknown> {
+    readonly Object: ObjectConstructor;
+    __sootsimWorkerTextInputBridge?: SootSimWorkerTextInputBridge<Node>;
+}
+export type PeachPageServingAuthority = 'published' | 'contributor';
+export interface SootSimTenantEnvironment {
+    localStorage: Storage;
+    sessionStorage: Storage;
+    matchMedia(query: string): MediaQueryList;
+    location: SootSimTenantLocation;
+    navigator: SootSimTenantNavigator;
+    open(url?: string, target?: string, features?: string): WindowProxy | null;
+    devicePixelRatio: number;
+    innerWidth: number;
+    innerHeight: number;
+    outerWidth: number;
+    outerHeight: number;
+    screen: SootSimTenantScreen;
+}
+export type SootSimMetroDefine = (factory: (globalObj: typeof globalThis, require: (id: number) => unknown, metroImportDefault: (id: number) => unknown, metroImportAll: (id: number) => unknown, module: {
+    exports: unknown;
+}, exports: unknown, dependencyMap: unknown) => void, moduleId: number, dependencyMap: unknown, moduleName?: string, inverseDependencies?: Record<number, number[]>) => void;
+export interface SootSimDirectGlobals {
+    __peachPageServingAuthority: PeachPageServingAuthority | null;
+    __peachWebViewHost: (request: SootSimWebViewHostRequest) => Promise<void>;
+    __sootsimAuxCompositorStats: () => SootSimAuxCompositorStats;
+    __sootsimDeviceSpec: SootSimDeviceSpec;
+    __sootsimDeviceSpecListeners: Set<() => void>;
+    __sootsimTenantEnvironment: SootSimTenantEnvironment;
+    __sootsim_launch_arguments: string | Record<string, unknown>;
+    __sootsim_react_native_keys_json: string | {
+        secure?: Record<string, string>;
+        public?: Record<string, unknown>;
+    };
+    __sootsimEmitBackPress: () => boolean;
+    __sootsimFindInteractiveCanvas: () => HTMLCanvasElement | null;
+    __r: SootSimMetroRequire;
+    __d: SootSimMetroDefine;
+    __metro_assets: Array<SootSimMetroAssetRecord | undefined>;
+    __sootsim_bundle_origin: string;
+    __sootsimMetroAssetRegistryModuleId: number | string;
+    __sootsimOneNativeContentSnapshot: (appId: string) => unknown;
+    __sootsimStatusBarResetListenerInstalled: boolean;
+    __sootsimDebugWedgeTenant: (ms: number) => void;
+    __contrastModules: {
+        require: (name: string) => unknown;
+        [k: string]: unknown;
+    };
+    __sootsimRuntimeVersion: string;
+    __sootsimCliVersion: string;
+    __peachDesktopHostInstalled: boolean;
+    __peachWorkerHost: {
+        pullSurface?: (source: HTMLCanvasElement, kx?: number, ky?: number) => Promise<void>;
+    };
+}
+
+export declare function createDefaultSootSim(): SootSimGlobals;
+export declare function ensureSootSim(): SootSimGlobals;
+export declare function getSootSim(): SootSimGlobals | undefined;
+export declare const SOOTSIM_NATIVE_PUBLIC_INSTANCE: unique symbol;
+export interface SootSimNativePublicInstance {
+    readonly [SOOTSIM_NATIVE_PUBLIC_INSTANCE]: true;
+    readonly __nativeTag: number | undefined;
+    readonly _nativeTag: number | undefined;
+    readonly __viewTag: number | undefined;
+}
+export declare function isSootSimNativePublicInstance(value: unknown): value is SootSimNativePublicInstance;
+export declare function withSootSimNativePublicInstanceTags<T extends object>(handle: Omit<T, keyof SootSimNativePublicInstance>, viewTag: () => number | undefined): T & SootSimNativePublicInstance;
+export type BoxViewingMode = 'remote' | 'local';
+export interface BoxViewingMessage {
+    type: 'sootsim:boxViewing';
+    mode: BoxViewingMode;
+}
+export declare function isBoxViewingMessage(value: unknown): value is BoxViewingMessage;
+export interface NumericTextPaintRequest {
+    value: number;
+    countsDown?: boolean;
+    animated: boolean;
+    speed: number;
+    delay: number;
+}