peachsim 0.1.1641 → 0.1.1653

package/dist-types/packages/peach-engine/src/render-worker/worklet-sab.d.ts

@@ -0,0 +1,24 @@
+import { type SynchronizableArenas } from './native-dynamic-synchronizable.d.ts';
+export declare const SAB_MAGIC = 1347328513;
+export declare const SAB_HEADER_FLOATS = 6;
+export declare const SAB_DEMAND_EPOCH_INT32_INDEX = 4;
+export declare const SAB_COMPOSITOR_TASK_PENDING_INT32_INDEX = 5;
+export declare const SAB_TENANT_LIVE_FRAMES_INT32_INDEX = 6;
+export declare const SAB_UI_FRAME_DEMAND_INT32_INDEX = 7;
+export declare const SAB_UI_FRAME_TIME_FLOAT64_INDEX = 4;
+export declare const SAB_UI_FRAME_OFFERED_INT32_INDEX = 10;
+export declare const SAB_UI_FRAME_DONE_INT32_INDEX = 11;
+export declare const DEFAULT_CAPACITY = 262144;
+declare const WORKLET_PEER_EPOCH_BRAND: unique symbol;
+export type WorkletPeerEpoch = number & {
+    readonly [WORKLET_PEER_EPOCH_BRAND]: true;
+};
+export declare function createWorkletPeerEpoch(value: number): WorkletPeerEpoch;
+export declare function createSharedValueSAB(capacity?: number): SharedArrayBuffer;
+export declare function allocateWorkletPeerEpoch(): WorkletPeerEpoch;
+export declare function getOrCreateWorkletSAB(): SharedArrayBuffer | null;
+export declare function getOrCreateSynchronizableArenas(): SynchronizableArenas | null;
+export declare function getUiFrameClockSAB(): SharedArrayBuffer | null;
+export declare function getOrCreateLayoutSAB(): SharedArrayBuffer | null;
+export declare function __resetWorkletSAB(): void;
+export {};

package/dist-types/packages/peach-engine/src/rolldown-bundle-inventory.d.ts

@@ -0,0 +1,84 @@
+interface RolldownFactory {
+    start: number;
+    end: number;
+    functionStart: number;
+    functionEnd: number;
+    kind: '__commonJSMin' | '__esmMin';
+}
+export interface RolldownModuleRegistration {
+    modulePath: string;
+    start: number;
+    end: number;
+    calleeStart: number;
+    calleeEnd: number;
+    exportHolder: string[] | 'missing' | 'invalid';
+    factory: RolldownFactory | null;
+}
+export interface RolldownNamespaceExport {
+    key: string;
+    target: string;
+    properties: string[];
+}
+export interface RolldownNamespace {
+    start: number;
+    end: number;
+    exports: RolldownNamespaceExport[] | 'unsupported-binding' | 'unsupported-re-export';
+}
+export interface RolldownFactoryBinding {
+    binding: string;
+    factory: RolldownFactory;
+    dependencies: string[];
+    namespaces: string[];
+    exportDeclarations: Array<{
+        start: number;
+        end: number;
+    }>;
+    moduleStart: number;
+    exportedBindings: Array<{
+        name: string;
+        binding: string;
+    }>;
+}
+export interface RolldownExternalImport {
+    start: number;
+    end: number;
+    specifier: string;
+    defaults: string[];
+    namespaces: string[];
+    named: Array<{
+        imported: string | null;
+        local: string;
+    }>;
+}
+export interface RolldownBundleInventory {
+    hasGraph: boolean;
+    platform: 'ios' | 'android' | null;
+    registrations: RolldownModuleRegistration[];
+    namespaces: Map<string, RolldownNamespace>;
+    externalImports: RolldownExternalImport[];
+    factoryBindings: RolldownFactoryBinding[];
+    callsByBinding: Map<string, number[]>;
+    runtimeGlobalAccesses: Array<{
+        offset: number;
+        name: string;
+    }>;
+    nativePrivateSlots: Map<string, string>;
+    nativePrivateCalls: Array<{
+        offset: number;
+        key: string;
+        method: string;
+    }>;
+    localNames: LocalNameOffsets;
+}
+export interface LocalNameOffsets {
+    starts: Int32Array;
+    ends: Int32Array;
+    shorthand: Uint8Array;
+}
+export interface RolldownInventoryReceipt {
+    key: string;
+    inventory: RolldownBundleInventory;
+}
+export declare function carryRolldownBundleInventory(receipt: RolldownInventoryReceipt | null, report: (receipt: RolldownInventoryReceipt) => void): void;
+export declare function readRolldownBundleInventory(source: string): Promise<RolldownBundleInventory>;
+export {};

package/dist-types/packages/peach-engine/src/rolldown-production-fingerprint.d.ts

@@ -0,0 +1,31 @@
+import type { RolldownFactoryBinding } from './rolldown-bundle-inventory.d.ts';
+declare function fingerprintInput(source: string): Promise<{
+    contentHash: string;
+    factories: Array<{
+        binding: RolldownFactoryBinding;
+        fingerprint: string;
+    }>;
+}>;
+export declare function fingerprintRolldownProductionInput(source: string): ReturnType<typeof fingerprintInput>;
+export interface RolldownProductionFingerprintRegistry {
+    modules: Record<string, string[]>;
+}
+export declare function recognizeRolldownProductionInput(source: string, registry: RolldownProductionFingerprintRegistry): Promise<{
+    contentHash: string;
+    modules: Array<{
+        modulePath: string;
+        binding: RolldownFactoryBinding;
+    }>;
+}>;
+export declare function readRolldownProductionInput(source: string): Promise<{
+    contentHash: string;
+    modules: Array<{
+        modulePath: string;
+        binding: RolldownFactoryBinding;
+    }>;
+    nativeInterfaces: {
+        globalName: string;
+        methods: string[];
+    }[];
+}>;
+export {};

package/dist-types/packages/peach-engine/src/screenshots/timeline-assets.d.ts

@@ -0,0 +1,10 @@
+export type TimelineAssetRef = {
+    src: string;
+    recording: boolean;
+};
+export declare function timelineAssetFieldsOf(value: Record<string, unknown>, inWallpaper: boolean): {
+    field: string;
+    recording: boolean;
+}[];
+export declare function isWallpaperChild(key: string, inWallpaper: boolean): boolean;
+export declare function collectTimelineAssetRefs(value: unknown): TimelineAssetRef[];

package/dist-types/packages/peach-engine/src/screenshots/tokens.d.ts

@@ -0,0 +1,9 @@
+import { type ScreenshotBackgroundStyles } from '../../../../../src/screenshots/screenshotContract.ts';
+import type { DeviceSpec } from '../../../../../src/device-catalog.ts';
+export declare function resolveScreenshotDeviceFrameGeometry(device: Pick<DeviceSpec, 'cornerRadius' | 'frameInsets' | 'height' | 'width'>): {
+    outerAspect: number;
+    outerCornerRadius: import("../../../../../src/device-catalog.ts").CornerRadii;
+    outerHeight: number;
+    outerWidth: number;
+};
+export declare function resolveScreenshotBackground(bgTop: string, bgBottom: string, titleColor?: string, titleUnderlay?: 'black' | 'white'): ScreenshotBackgroundStyles;

package/dist-types/packages/peach-engine/src/settings/devices.d.ts

@@ -0,0 +1,70 @@
+import { type RuntimePlatform, type FrameInsets, type DevicePosture, type PhysicalCutoutRect, type CornerRadii, type DeviceSpec, type DeviceModel, type InterfacePose, type DisplayHold, type SizeClass, type InterfaceOrientation, type LandscapeSide, type RotateDirection, type SceneVerticalBar } from '../../../../../src/device-catalog.ts';
+export declare function scaleCornerRadii(radii: CornerRadii, factor: number): CornerRadii;
+export declare function formatCornerRadii(radii: CornerRadii, unit?: (value: number) => string): string;
+export declare function physicalCameraRect(device: DeviceSpec): PhysicalCutoutRect | null;
+export declare function landscapePhysicalCutouts(device: DeviceSpec): {
+    island: PhysicalCutoutRect | null;
+    camera: PhysicalCutoutRect | null;
+};
+export declare function erodeCornerRadii(radii: CornerRadii, by: FrameInsets): CornerRadii;
+export declare function resolveDeviceFrameCorners(device: Pick<DeviceSpec, 'frameInsets' | 'cornerRadius'> & Partial<Pick<DeviceSpec, 'frameCornerRadius'>>): {
+    frameRadius: CornerRadii;
+    frameRadiusApproximationError: number;
+    screenRadius: CornerRadii;
+};
+export declare function resolveDeviceFrameGeometry(device: Pick<DeviceSpec, 'cornerRadius' | 'frameCornerRadius' | 'frameInsets' | 'height' | 'width' | 'housing'>): {
+    frameRadius: CornerRadii;
+    frameRadiusApproximationError: number;
+    screenRadius: CornerRadii;
+    housing: {
+        rail: FrameInsets;
+        hingeBarrel: import("../../../../../src/device-catalog.ts").DeviceHingeBarrel | null;
+        glassRadius: CornerRadii;
+    } | null;
+    bodyLeft: number;
+    frameHeight: number;
+    frameWidth: number;
+    screenBottomInset: number;
+    screenLeft: number;
+    screenRightInset: number;
+    screenTop: number;
+};
+export declare function isDevicePosture(value: string): value is DevicePosture;
+export declare function resolveDevicePosture(model: DeviceModel, posture?: DevicePosture): DevicePosture;
+export declare function deviceDefaultOrientation(model: DeviceModel, posture?: DevicePosture): InterfaceOrientation;
+export declare function orientationAfterPostureChange(model: DeviceModel, current: InterfaceOrientation, nextPosture: DevicePosture): InterfaceOrientation;
+export declare function orderedPoses(poses: Iterable<InterfacePose>): readonly InterfacePose[];
+export declare function samePoses(a: readonly InterfacePose[], b: readonly InterfacePose[]): boolean;
+export declare function interfacePose(spec: DeviceSpec): InterfacePose;
+export declare function sceneHoldsInterface(model: DeviceModel, posture?: DevicePosture): boolean;
+export declare function displayHold(display: DeviceSpec, body: DeviceSpec): DisplayHold;
+export declare function poseHold(display: InterfacePose, body: InterfacePose): DisplayHold;
+export declare function supportsOrientationChange(model: DeviceModel, posture?: DevicePosture): boolean;
+export declare function usesLandscapePhoneKeyboard(device: Pick<DeviceSpec, 'model' | 'platform' | 'homeIndicatorHeight'>): boolean;
+export declare function defaultLandscapeSide(model: DeviceModel, posture?: DevicePosture): LandscapeSide;
+export declare function deviceTurnDirection(from: DeviceSpec, to: DeviceSpec): -1 | 1;
+export declare function resolveRotateDirectionTarget(direction: RotateDirection, current: DeviceSpec): {
+    orientation: InterfaceOrientation;
+    landscapeSide?: LandscapeSide;
+};
+export declare function isPadIdiom(spec: Pick<DeviceSpec, 'model'>): boolean;
+export declare function isPhoneIdiom(spec: DeviceSpec): boolean;
+export declare function deviceSizeClasses(model: DeviceModel, orientation: InterfaceOrientation, posture?: DevicePosture): {
+    horizontal: SizeClass;
+    vertical: SizeClass;
+};
+export declare function withSceneVerticalBar(spec: DeviceSpec, bar: SceneVerticalBar): DeviceSpec;
+export declare function withOsVersionOverride(spec: DeviceSpec, osVersion: string): DeviceSpec;
+export declare function getDevice(model: DeviceModel, posture?: DevicePosture, orientation?: InterfaceOrientation, landscapeSide?: LandscapeSide): DeviceSpec;
+export declare function resolveDeviceFitBox(model: DeviceModel, showBezels: boolean, orientation?: InterfaceOrientation, currentPosture?: DevicePosture): {
+    width: number;
+    height: number;
+};
+export declare function resolveTopChromeHeight(device: Pick<DeviceSpec, 'statusBarHeight' | 'safeAreaInsets'>): number;
+export declare function isDeviceResolvableById(model: string): boolean;
+export declare function getRuntimePlatform(model: DeviceModel): RuntimePlatform;
+export declare function listDeviceModelsByPlatform(platform: RuntimePlatform): DeviceModel[];
+export declare function nearestPhoneModel(screen: {
+    width: number;
+    height: number;
+}): DeviceModel;

package/dist-types/packages/peach-engine/src/settings/duo-fold-bus.d.ts

@@ -0,0 +1,87 @@
+import type { InterfaceOrientation, LandscapeSide } from '../../../../../src/device-catalog.ts';
+export type DuoFoldPosture = 'closed' | 'half-opened' | 'open';
+export type DuoFoldRest = 'closed' | 'book' | 'open' | 'laptop' | 'tent';
+export declare const DUO_REST_PROGRESS: Record<DuoFoldRest, number>;
+type Quaternion = readonly [number, number, number, number];
+export declare function duoFoldStance(from: DuoFoldRest | null, to: DuoFoldRest, travel: number, angles: {
+    from: number;
+    to: number;
+}): Quaternion;
+export declare function duoBodyAngle(rest: DuoFoldRest | null, posture: 'closed' | 'open', orientation: InterfaceOrientation, side: LandscapeSide): number;
+export declare function duoSweepFromAngle(sweep: {
+    from: DuoFoldRest;
+    fromTurned: boolean;
+    fromSide: LandscapeSide;
+}): number;
+export declare function duoRestTurnsBody(rest: DuoFoldRest): boolean;
+export declare function duoRestPosture(rest: DuoFoldRest): 'closed' | 'open';
+export declare function duoRestTurned(rest: DuoFoldRest, arrivedTurned: boolean): boolean;
+export declare function duoRestOrientation(rest: DuoFoldRest, arrivedTurned: boolean): InterfaceOrientation;
+export declare function duoSweepTiming(sweep: {
+    from: number;
+    leaving: DuoFoldRest;
+    to: DuoFoldRest;
+    stanceChanges: boolean;
+}): {
+    durationMs: number;
+    ease: (t: number) => number;
+};
+export declare function duoViewerLeg(leaving: DuoFoldRest, to: DuoFoldRest): boolean;
+export declare function duoSweepHinge(leaving: DuoFoldRest, to: DuoFoldRest, travel: number): number;
+export declare function duoRestLandscapeSide(rest: DuoFoldRest): LandscapeSide | undefined;
+export type DuoFoldPage = {
+    origin: 'closed' | 'open';
+    image: HTMLCanvasElement;
+    back: HTMLCanvasElement | null;
+    keepsLayout: boolean;
+    side: LandscapeSide;
+} | null;
+export type DuoFoldLook = {
+    settleAt: number | null;
+    leans: boolean;
+    blurs: boolean;
+};
+type DuoFoldState = {
+    progress: number;
+    active: boolean;
+    ready: boolean;
+    page: DuoFoldPage;
+    pose: number;
+    rest: DuoFoldRest | null;
+    from: DuoFoldRest | null;
+    fromTurned: boolean;
+    fromSide: LandscapeSide;
+    travel: number;
+    sweptAt: number;
+    clock: (() => number) | null;
+    look: DuoFoldLook | null;
+};
+export type DuoFoldWireState = Pick<DuoFoldState, 'progress' | 'active' | 'ready' | 'rest'>;
+export declare function getDuoFoldProgress(): number;
+export type DeviceHingeStatus = 'closed' | 'partiallyOpen' | 'fullyOpen';
+export declare function readDeviceHinge(): {
+    progress: number;
+    status: DeviceHingeStatus;
+} | null;
+export declare function isDuoFoldActive(): boolean;
+export declare function isDuoFoldReady(): boolean;
+export declare function getDuoFoldPage(): DuoFoldPage;
+export declare function getDuoFoldSweep(): {
+    from: DuoFoldRest | null;
+    fromTurned: boolean;
+    fromSide: LandscapeSide;
+    travel: number;
+};
+export declare function getDuoFoldLookNow(): number;
+export declare function getDuoFoldLook(): DuoFoldLook | null;
+export declare function duoFoldAwaitingBackFace(): boolean;
+export declare function getDuoFoldPose(): number;
+export declare function getDuoFoldRest(): DuoFoldRest | null;
+export declare function subscribeDuoFoldProgress(fn: () => void): () => void;
+export declare function publishDuoFold(patch: Partial<DuoFoldState>): void;
+export declare function duoFoldAngle(progress?: number): number;
+export declare function duoFoldPosture(progress?: number): DuoFoldPosture;
+export declare function duoFrameSampleDifference(first: ArrayLike<number>, second: ArrayLike<number>): number;
+export declare function duoFrameSampleCovered(sample: ArrayLike<number>): boolean;
+export declare function snapshotDuoFoldState(): DuoFoldWireState;
+export {};

package/dist-types/packages/peach-engine/src/settings/interface-rotation.d.ts

@@ -0,0 +1,30 @@
+import type { CornerRadii } from '../../../../../src/device-catalog.ts';
+import type { DuoFoldLook } from './duo-fold-bus.d.ts';
+export declare const INTERFACE_ROTATION_MS = 290;
+export declare function interfaceRotationProgress(t: number): number;
+export type InterfaceRotation = {
+    turn: 90 | 180;
+    direction: -1 | 1;
+    from: {
+        width: number;
+        height: number;
+    };
+    to: {
+        width: number;
+        height: number;
+    };
+};
+export declare function interfaceRotationFrame(rotation: InterfaceRotation, progress: number): {
+    width: number;
+    height: number;
+    angle: number;
+};
+export declare function drawInterfaceRotation(target: HTMLCanvasElement, rotation: InterfaceRotation & {
+    image: CanvasImageSource;
+    back: CanvasImageSource | null;
+    radii: {
+        from: CornerRadii;
+        to: CornerRadii;
+    };
+}, progress: number): void;
+export declare function duoSweepInterfaceRotation(look: DuoFoldLook | null, now: number): number;

package/dist-types/packages/peach-engine/src/settings/react-native-configuration.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNativeConfigurationKey, ReactNativeConfigurationSnapshot } from '../../../../../src/reactNativeConfigurationContract.ts';
+export { type ReactNativeConfigurationKey, type ReactNativeConfigurationSnapshot, } from '../../../../../src/reactNativeConfigurationContract.ts';
+import type { SettingsValues } from '../../../../../src/settingsContract.ts';
+declare const MUTABLE_KEYS: readonly ['fontSize', 'boldText', 'reduceMotion', 'largerAccessibilitySizes', 'glassTintAmount', 'reduceTransparency', 'increaseContrast', 'showBorders', 'onOffLabels', 'differentiateWithoutColor', 'smartInvert', 'preferCrossFadeTransitions'];
+type MutableKey = (typeof MUTABLE_KEYS)[number];
+export type ReactNativeConfigurationMutation = Partial<Pick<SettingsValues, MutableKey>>;
+export declare function snapshotReactNativeConfiguration(): ReactNativeConfigurationSnapshot;
+export declare function changesLayout(changed: readonly ReactNativeConfigurationKey[]): boolean;
+export declare function applyReactNativeConfiguration(snapshot: ReactNativeConfigurationSnapshot): ReactNativeConfigurationKey[];
+export declare function applyReactNativeConfigurationMutation(mutation: ReactNativeConfigurationMutation): void;
+export declare function requestReactNativeConfigurationMutation(mutation: ReactNativeConfigurationMutation): void;
+export declare function reactNativeConfigurationsEqual(left: ReactNativeConfigurationSnapshot, right: ReactNativeConfigurationSnapshot): boolean;

package/dist-types/packages/peach-engine/src/settings/scene-geometryContract.d.ts

@@ -0,0 +1,40 @@
+import type { ShellNativeEvaluationOwner } from '../../../peach-globals/src/index.d.ts';
+export type SceneOrientation = 'portrait' | 'portrait-upside-down' | 'landscape-left' | 'landscape-right';
+export type SceneGeometryRejection = {
+    kind: 'scene';
+} | {
+    kind: 'platform';
+} | {
+    kind: 'unavailable';
+} | {
+    kind: 'unsupported';
+    requested: readonly SceneOrientation[];
+    supported: readonly SceneOrientation[];
+} | {
+    kind: 'aborted';
+};
+export type SceneGeometryOperation = {
+    kind: 'request';
+    orientations: readonly SceneOrientation[];
+} | {
+    kind: 'read';
+} | {
+    kind: 'watch';
+};
+export interface SceneGeometryEntry {
+    id: string;
+    owner: ShellNativeEvaluationOwner;
+    evaluationId: string;
+    operation: SceneGeometryOperation;
+}
+export type SceneGeometryResult = {
+    kind: 'observed';
+    orientation: SceneOrientation;
+} | {
+    kind: 'rejected';
+    rejection: SceneGeometryRejection;
+};
+export declare class SceneGeometryRejectedError extends Error {
+    readonly rejection: SceneGeometryRejection;
+    constructor(rejection: SceneGeometryRejection);
+}

package/dist-types/packages/peach-engine/src/settings/store.d.ts

@@ -0,0 +1,37 @@
+import { type InterfacePose, type DeviceSpec, type SceneVerticalBar } from '../../../../../src/device-catalog.ts';
+import { type SettingsValues, type SettingKey } from '../../../../../src/settingsContract.ts';
+type Listener = () => void;
+export interface SettingsPersistence {
+    readonly keys: readonly SettingKey[];
+    load(): Partial<SettingsValues>;
+    save(state: SettingsValues, preserved: Readonly<Record<string, unknown>>): void;
+    saveAndWait(state: SettingsValues, preserved: Readonly<Record<string, unknown>>): Promise<void>;
+    subscribe(listener: (snapshot: Partial<SettingsValues>) => void): void;
+}
+export declare function attachSettingsPersistence(persistence: SettingsPersistence): void;
+export declare const settingsStore: {
+    get<K extends SettingKey>(key: K): SettingsValues[K];
+    set<K extends SettingKey>(key: K, value: SettingsValues[K]): void;
+    setRuntime<K extends SettingKey>(key: K, value: SettingsValues[K]): void;
+    isRuntimeControlled(key: SettingKey): boolean;
+    getAll(): SettingsValues;
+    apply(overrides: Partial<SettingsValues>): void;
+    applyRuntime(overrides: Partial<SettingsValues>): void;
+    reset(): void;
+    resetDeviceContent(): Promise<void>;
+    subscribe(fn: Listener): () => void;
+    getDeviceSpec(): DeviceSpec;
+    getBodySpec(): DeviceSpec;
+    getScenePoses(): readonly InterfacePose[];
+    interfacePoseFor(poses: readonly InterfacePose[]): InterfacePose;
+    setScenePoses(poses: readonly InterfacePose[]): void;
+    requestInterfacePose(pose: InterfacePose): void;
+    getSceneVerticalBar(): SceneVerticalBar;
+    setSceneVerticalBar(bar: SceneVerticalBar): void;
+    getA11yMode(): import("../ios/constants.d.ts").A11yMode;
+    setA11yMode(mode: SettingsValues['a11yMode']): void;
+    getInspectMode(): boolean;
+    setInspectMode(on: boolean): void;
+};
+export declare function getPreferredLocaleTag(): string;
+export {};

package/dist-types/packages/peach-engine/src/shell-events.d.ts

@@ -0,0 +1,203 @@
+import type { DevicePosture, DeviceSpec, InterfaceOrientation, LandscapeSide } from '../../../../src/device-catalog.ts';
+import type { AgentProvider, AmbientGlowLevel, StageBackground } from '../../../../src/settingsContract.ts';
+import type { LogLevel } from './observability/types.d.ts';
+import type { DuoFoldRest } from './settings/duo-fold-bus.d.ts';
+import type { PeachRecordingMode, PeachRecordingStartOptions, SootSimInspectInfo } from '../../peach-globals/src/index.d.ts';
+export type DevtoolsDockPosition = 'right' | 'bottom';
+export type DevtoolsTab = 'network' | 'performance' | 'logs' | 'agent' | 'test' | 'react' | 'report' | 'recordings' | 'inspect';
+export type EngineEventRoute = {
+    type: 'route-change';
+    pathname: string;
+    appId: string | null;
+};
+export type EngineEventInspect = {
+    type: 'inspect-mode-change';
+    active: boolean;
+};
+export type EngineEventInspectSelection = {
+    type: 'inspect-selection-change';
+    selected: SootSimInspectInfo | null;
+};
+export type EngineEventInspectHover = {
+    type: 'inspect-hover-change';
+    nodeId: number | null;
+};
+export type EngineEventInspectTree = {
+    type: 'inspect-tree-change';
+};
+export type EngineEventRingMode = {
+    type: 'ring-mode-change';
+    mode: 'ring' | 'silent';
+};
+export type EngineEventRecording = {
+    type: 'recording-state-change';
+    state: 'idle' | 'recording' | 'processing';
+    mode: PeachRecordingMode | null;
+    duration: number;
+};
+export type EngineEventA11y = {
+    type: 'a11y-mode-change';
+    mode: 'off' | 'delayed' | 'active';
+};
+export type EngineEventSimId = {
+    type: 'sim-id';
+    id: string;
+};
+export type EngineEventActiveApp = {
+    type: 'active-app-change';
+    appId: string | null;
+    appName: string | null;
+    isAppOpen: boolean;
+};
+export type EngineEventUpload = {
+    type: 'upload-activity';
+    phase: 'uploading' | 'copied' | 'failed' | 'done';
+};
+export type EngineEventBrowserNav = {
+    type: 'browser-nav-change';
+    canGoBack: boolean;
+    isAppOpen: boolean;
+};
+export type EngineWindowState = {
+    deviceModel: string;
+    deviceSpec: DeviceSpec;
+    bodySpec: DeviceSpec;
+    orientation: InterfaceOrientation;
+    scaleMode: 'physical' | 'point' | 'pixel' | 'fit';
+    agentProvider: AgentProvider;
+    showFrame: boolean;
+    showMenuBar: boolean;
+    showRail: boolean;
+    agentIndicator: boolean;
+    solidWindow: boolean;
+    ambientGlow: AmbientGlowLevel;
+    stageBackground: StageBackground;
+    stageChecker: boolean;
+    screenshotMode: boolean;
+    threeMode: boolean;
+    threeRecordingEditor: boolean;
+    screenshotCanvas: string;
+    screenshotBackground: string;
+    screenshotText: string;
+    screenshotPose: string;
+    screenshotDynamicSize: boolean;
+    sendToBoxCarryAuth: boolean;
+};
+declare const WINDOW_STATE_EVENT_BRAND: unique symbol;
+export type EngineEventWindowState = EngineWindowState & {
+    type: 'window-state-change';
+    readonly [WINDOW_STATE_EVENT_BRAND]: true;
+};
+export type EngineEventMenuDefs = {
+    type: 'menu-defs-change';
+    defs: unknown;
+};
+export type EngineEventRecordDialogOpen = {
+    type: 'record-dialog-open';
+};
+export type EngineEventPreviewWindowOpen = {
+    type: 'preview-window-open';
+    previewUrl: string;
+    title: string;
+};
+export type EngineEventDevtools = {
+    type: 'devtools-open-change';
+    open: boolean;
+    position: DevtoolsDockPosition;
+    tab: DevtoolsTab;
+    filterLogLevel?: LogLevel | null;
+};
+export type EngineEvent = EngineEventRoute | EngineEventInspect | EngineEventInspectSelection | EngineEventInspectHover | EngineEventInspectTree | EngineEventRingMode | EngineEventRecording | EngineEventA11y | EngineEventSimId | EngineEventActiveApp | EngineEventUpload | EngineEventBrowserNav | EngineEventMenuDefs | EngineEventWindowState | EngineEventRecordDialogOpen | EngineEventPreviewWindowOpen | EngineEventDevtools;
+export type ShellCommand = {
+    type: 'go-home';
+} | {
+    type: 'go-back';
+} | {
+    type: 'lock';
+    locked?: boolean;
+} | {
+    type: 'open-app-switcher';
+} | {
+    type: 'set-ring-mode';
+    mode: 'ring' | 'silent';
+} | {
+    type: 'inspect-toggle';
+    active?: boolean;
+} | {
+    type: 'inspect-hover-node';
+    nodeId: number | null;
+} | {
+    type: 'inspect-select-node';
+    nodeId: number | null;
+} | {
+    type: 'request-record';
+    mode?: PeachRecordingMode;
+    options?: PeachRecordingStartOptions;
+} | {
+    type: 'stop-record';
+} | {
+    type: 'screenshot';
+} | {
+    type: 'set-device-posture';
+    posture: DevicePosture;
+} | {
+    type: 'set-device-orientation';
+    orientation: InterfaceOrientation;
+    landscapeSide?: LandscapeSide;
+} | {
+    type: 'set-fold-progress';
+    progress: number;
+} | {
+    type: 'commit-fold-progress';
+} | {
+    type: 'fold-to-progress';
+    progress: number;
+} | {
+    type: 'fold-to-rest';
+    rest: DuoFoldRest;
+} | {
+    type: 'set-fold-sweep';
+    from: DuoFoldRest;
+    to: DuoFoldRest;
+    travel: number;
+    elapsedMs: number;
+    settled?: boolean;
+    turned: boolean;
+    page?: HTMLCanvasElement;
+} | {
+    type: 'window-drag';
+    active: boolean;
+} | {
+    type: 'set-a11y-mode';
+    mode: 'off' | 'delayed' | 'active';
+} | {
+    type: 'open-notification-center';
+} | {
+    type: 'fire-action';
+    id: string;
+    payload?: string;
+} | {
+    type: 'record-dialog-resolve';
+    mode: PeachRecordingMode | null;
+    options?: PeachRecordingStartOptions;
+} | {
+    type: 'devtools-toggle';
+    open?: boolean;
+    position?: DevtoolsDockPosition;
+    tab?: DevtoolsTab;
+    filterLogLevel?: LogLevel | null;
+};
+export declare const SOOTSIM_EVENT_NAME = "sootsim:engine-event";
+export declare const SOOTSIM_COMMAND_NAME = "sootsim:shell-command";
+export declare function createWindowStateChangeEvent(state: EngineWindowState): EngineEventWindowState;
+export declare function dispatchEngineEvent(detail: EngineEvent): void;
+export declare function dispatchShellCommand(detail: ShellCommand): void;
+export declare function listenEngineEvents(handler: (e: EngineEvent) => void): () => void;
+export declare function listenShellCommands(handler: (c: ShellCommand) => void): () => void;
+export declare function listenEngineEventType<T extends EngineEvent['type']>(type: T, handler: (e: Extract<EngineEvent, {
+    type: T;
+}>) => void): () => void;
+export declare function listenShellCommandType<T extends ShellCommand['type']>(type: T, handler: (c: Extract<ShellCommand, {
+    type: T;
+}>) => void): () => void;
+export {};