peachsim 0.1.1644 → 0.1.1653

package/dist-types/packages/peach-engine/src/render-worker/reanimated-css-contract.d.ts

@@ -0,0 +1,63 @@
+import type { AnimatedDrivenStyleLease, AnimatedDrivenStyleRetirement } from '../engine/animated-driven-style.d.ts';
+import type { CSSKeyframesDrive } from './css-keyframes-drive.d.ts';
+import type { WorkletViewRef } from './worklet-runtime.d.ts';
+export type CSSEventType = 'animationStart' | 'animationEnd' | 'animationIteration' | 'animationCancel' | 'transitionRun' | 'transitionStart' | 'transitionEnd' | 'transitionCancel';
+export interface NativeCSSEvent {
+    tag: number;
+    type: CSSEventType;
+    name: string;
+    elapsedTime: number;
+}
+export declare const CSS_EVENT_MASK: {
+    readonly animationStart: number;
+    readonly animationEnd: number;
+    readonly animationIteration: number;
+    readonly animationCancel: number;
+    readonly transitionRun: number;
+    readonly transitionStart: number;
+    readonly transitionEnd: number;
+    readonly transitionCancel: number;
+};
+export interface CSSRelativeTo {
+    node: 'self' | 'parent';
+    dimension: 'width' | 'height';
+}
+export type CSSLayoutResolver = (target: WorkletViewRef, relativeTo: CSSRelativeTo) => number | null;
+export interface CSSShellHost {
+    resolveLayout: CSSLayoutResolver;
+    retireDrivenStyle: (target: WorkletViewRef, retirement: AnimatedDrivenStyleRetirement) => void;
+    createDrive: (target: WorkletViewRef, drive: CSSKeyframesDrive, seeds: number[], onEnd: () => void) => number | null;
+    driveLink: (target: WorkletViewRef, drive: number, value: number, prop: string, angle: boolean) => unknown;
+    stopDrive: (drive: number) => void;
+}
+export interface ReanimatedCSSRuntimeHost extends CSSShellHost {
+    applyUpdates: (target: WorkletViewRef, updates: Record<string, unknown>, lease: AnimatedDrivenStyleLease) => void;
+    reportEvents?: (events: NativeCSSEvent[]) => void;
+    now: () => number;
+}
+export interface ReanimatedCSSRuntimeStats {
+    activeViews: number;
+    keyframes: number;
+    views: number;
+    nativeViewTags: number[];
+}
+export interface ReanimatedCSSRuntimeLike {
+    setViewStyle(target: WorkletViewRef, style: unknown, timestamp: number): boolean;
+    registerTransition(target: WorkletViewRef, config: unknown): void;
+    updateTransition(target: WorkletViewRef, config: unknown, timestamp: number): boolean;
+    registerKeyframes(name: string, componentName: string, config: unknown): void;
+    unregisterKeyframes(name: string, componentName: string): void;
+    applyAnimations(target: WorkletViewRef, componentName: string, value: unknown, timestamp: number): boolean;
+    unregisterAnimations(target: WorkletViewRef, timestamp?: number): boolean;
+    runTransition(target: WorkletViewRef, value: unknown, timestamp: number, eventMask?: number): boolean;
+    unregisterTransition(target: WorkletViewRef, timestamp?: number): boolean;
+    removeView(target: WorkletViewRef, timestamp?: number): boolean;
+    getStats(): ReanimatedCSSRuntimeStats;
+    isActive(): boolean;
+    tick(timestamp: number): boolean;
+    clear(): void;
+    retirePeerState(): void;
+}
+export type ReanimatedCSSRuntimeCtor = new (host: ReanimatedCSSRuntimeHost) => ReanimatedCSSRuntimeLike;
+export declare function registerReanimatedCSSRuntimeCtor(ctor: ReanimatedCSSRuntimeCtor): void;
+export declare function getReanimatedCSSRuntimeCtor(): ReanimatedCSSRuntimeCtor | null;

package/dist-types/packages/peach-engine/src/render-worker/reanimated-readiness.d.ts

@@ -0,0 +1,29 @@
+export type ReanimatedAnimationKind = 'repeat' | 'delay' | 'sequence' | 'clamp';
+export type AnimationResultObserver = (result: unknown, args: unknown[]) => void;
+export type ReanimatedAnimationComposition = {
+    kind: ReanimatedAnimationKind;
+    children: (object | undefined)[];
+    repetitions?: number;
+};
+export declare function reanimatedAnimationComposition(animation: object): ReanimatedAnimationComposition | null;
+export declare function reanimatedAnimationModuleKind(path: string): ReanimatedAnimationKind | null;
+export declare function reanimatedFactoryKind(name: string): ReanimatedAnimationKind | null;
+export declare function registerAnimationInitializerBodies(kind: ReanimatedAnimationKind, bodies: string[]): void;
+export declare function clearAnimationInitializerBodies(): void;
+export declare function registerAnimationInitializer(initializer: object, kind: ReanimatedAnimationKind): void;
+export declare function animationInitializerKind(source: object): ReanimatedAnimationKind | null;
+export declare function animationFactoryKind(source: object): ReanimatedAnimationKind | null;
+export declare function registerAnimationFactory(factory: object, kind: ReanimatedAnimationKind): void;
+export declare function recordAnimationInitializerResult(kind: ReanimatedAnimationKind, result: unknown, nativeClosure: object, source: object): void;
+export declare function recordAnimationFactoryResult(kind: ReanimatedAnimationKind, result: unknown, args: unknown[]): void;
+export declare function animationResultObserver(source: object, readClosure: () => unknown): AnimationResultObserver | null;
+export declare function noteComposedChild(worklet: object, result: unknown): void;
+export declare function runObservedAnimation<T>(worklet: object, observe: AnimationResultObserver, args: unknown[], call: () => T): T;
+export declare function observeReanimatedSetter(mutable: object, value: unknown, call: () => void): void;
+export declare function observeAnimationFrameRequest(callback: FrameRequestCallback): void;
+export declare function requestPlaybackFrame(isPlayback: () => boolean, request: () => number): number;
+export declare function isBackgroundAnimationFrame(callback: FrameRequestCallback): boolean;
+export declare function isBackgroundRepeatAnimation(animation: object): boolean;
+export type SharedValuePlayback = 'idle' | 'blocking' | 'background';
+export declare function setDerivedValuePlayback(value: object, playback: SharedValuePlayback): void;
+export declare function sharedValuePlayback(value: object): SharedValuePlayback;

package/dist-types/packages/peach-engine/src/render-worker/resilient-frame-clock.d.ts

@@ -0,0 +1,22 @@
+export type ResilientFrameSource = 'display' | 'timer';
+export interface ResilientFrameClockStats {
+    displayFrames: number;
+    timerFrames: number;
+}
+export interface ResilientFrameClockOptions {
+    requestFrame: (callback: FrameRequestCallback) => number;
+    cancelFrame: (id: number) => void;
+    isHidden: () => boolean;
+    hiddenFrameMs?: number;
+    now?: () => number;
+    setTimer?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+    clearTimer?: (id: ReturnType<typeof setTimeout>) => void;
+}
+export interface ResilientFrameClock {
+    request(callback: (now: number, source: ResilientFrameSource) => void): number;
+    cancel(id: number): void;
+    getStats(): ResilientFrameClockStats;
+    resetStats(): void;
+    dispose(): void;
+}
+export declare function createResilientFrameClock(options: ResilientFrameClockOptions): ResilientFrameClock;

package/dist-types/packages/peach-engine/src/render-worker/retained-app-load.d.ts

@@ -0,0 +1,20 @@
+import type { NativePreviewBundle, NativePreviewBundleShared } from '../native-preview-bundle.d.ts';
+import type { AppLoadRequest } from './protocol.d.ts';
+type RetainedInlineBundle = NativePreviewBundleShared & {
+    code?: Blob;
+    update?: {
+        code: Blob;
+        baseSequence: number;
+    } | null;
+};
+export type RetainedAppLoadRequest = Exclude<AppLoadRequest, {
+    kind: 'shell';
+}> | (Omit<Extract<AppLoadRequest, {
+    kind: 'shell';
+}>, 'inlineBundle'> & {
+    inlineBundle?: RetainedInlineBundle;
+});
+export declare function retainInlineBundle(bundle: NativePreviewBundle): RetainedInlineBundle;
+export declare function retainAppLoad(request: AppLoadRequest): RetainedAppLoadRequest;
+export declare function materializeAppLoad(request: RetainedAppLoadRequest): Promise<AppLoadRequest>;
+export {};

package/dist-types/packages/peach-engine/src/render-worker/screen-edge-swipe-commit-protocol.d.ts

@@ -0,0 +1 @@
+export type { ScreenEdgeSwipeCommit } from '../../../peach-kit/src/runtime.d.ts';

package/dist-types/packages/peach-engine/src/render-worker/screen-form-sheet-commit-protocol.d.ts

@@ -0,0 +1,26 @@
+import type { SheetDismissalLifecycle, SheetDismissalResult } from '../../../peach-kit/src/ui/presentationContract.d.ts';
+export type ScreenFormSheetMotion = {
+    surfaceId: string;
+    generation: number;
+    viewTag: number;
+} & ({
+    kind: 'position';
+    fromTop: number;
+    toTop: number;
+} | {
+    kind: 'dismissalDecision';
+    requestId: number;
+    result: SheetDismissalResult;
+});
+export type ScreenFormSheetCommit = {
+    stackId: number;
+    target: 'detent' | 'dismiss';
+    index?: number;
+    previousIndex: number;
+    dismissAttempt?: boolean;
+} & ({
+    phase: 'release' | 'settle' | 'endEditing';
+} | {
+    phase: 'request' | 'cancel';
+    requestId: number;
+} | SheetDismissalLifecycle);

package/dist-types/packages/peach-engine/src/render-worker/scroll-mirror-tenant.d.ts

@@ -0,0 +1,37 @@
+import { type ScrollMirrorOwner, type ScrollMirrorControlMessage } from './scroll-mirror.d.ts';
+import type { SootSimNode } from '../engine/node.d.ts';
+import type { ScrollHandler } from '../engine/scroll.d.ts';
+import type { TenantToShellPeerMessage } from './tree-sync-port.d.ts';
+import type { SootSimScrollOffsetSample } from '../../../peach-globals/src/index.d.ts';
+type PostMessage = (msg: Extract<TenantToShellPeerMessage, {
+    type: 'scrollMirror' | 'scrollControl';
+}>) => void;
+type ImperativeScrollCommand = Pick<Extract<ScrollMirrorControlMessage, {
+    type: 'scrollTo';
+}>, 'type' | 'contentOffsetX' | 'contentOffsetY' | 'animation'> | Pick<Extract<ScrollMirrorControlMessage, {
+    type: 'flashIndicators';
+}>, 'type'>;
+export declare function readNodeSurfaceId(node: SootSimNode): string | undefined;
+export declare function readNodeScrollOwner(node: SootSimNode): ScrollMirrorOwner | null;
+export declare function publishScrollMirrorNow(post: PostMessage): void;
+export declare function scheduleScrollMirrorPublish(surfaceId?: string): void;
+export declare function subscribeScrollMirrorRegistryInvalidation(listener: () => void): () => void;
+export declare function subscribeImperativeScroll(listener: (node: SootSimNode, command: ImperativeScrollCommand) => void): () => void;
+export declare function postImperativeScrollToShell(node: SootSimNode, command: ImperativeScrollCommand): void;
+export declare function installScrollMirrorTenantPublisher(opts: {
+    post: PostMessage;
+}): void;
+export declare function getScrollMirrorTenantDebug(): Record<string, unknown>;
+export declare function startTenantScrollPerformanceTrace(limit?: number): void;
+export declare function stopTenantScrollPerformanceTrace(): SootSimScrollOffsetSample[];
+export declare function attachScrollSABWriter(handler: ScrollHandler, owner: ScrollMirrorOwner, requestRender?: () => void): void;
+export declare function detachScrollSABWriter(handler: ScrollHandler): void;
+export declare function triggerShellRefresh(owner: ScrollMirrorOwner): boolean;
+export declare function syncAttachedScrollWriterBaseline(node: SootSimNode, opts?: {
+    fromShell?: boolean;
+}): void;
+export declare function endShellScrollOffsetPolling(owner: ScrollMirrorOwner, opts?: {
+    forceScrollEvent?: boolean;
+}): boolean;
+export declare function __resetScrollMirrorTenantPublisherInstalled(): void;
+export {};

package/dist-types/packages/peach-engine/src/render-worker/scroll-mirror.d.ts

@@ -0,0 +1,164 @@
+import { type IosFastScroll } from '../engine/ios-fast-scroll.d.ts';
+import type { AndroidEdgeEffectState } from '../engine/android-stretch-effect.d.ts';
+import type { CollapseBand, ScrollRelease } from '../engine/scroll-momentum-math.d.ts';
+import type { ScrollContentInset } from '../engine/scroll-range.d.ts';
+import type { WorkletRuntime } from './worklet-runtime.d.ts';
+export interface ScrollMirrorRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface ScrollMirrorOwner {
+    surfaceId: string;
+    generation: number;
+    nodeId: number;
+}
+export interface ScrollMirrorEntry extends ScrollMirrorOwner {
+    allocationId: string;
+    slotX: number;
+    slotY: number;
+    slotZoom: number;
+    slotVersion: number;
+    slotSampleTime: number;
+    slotDragStartTime: number;
+    slotPresentationDisplacementY: number;
+    abs: ScrollMirrorRect;
+    contentWidth: number;
+    contentHeight: number;
+    contentInset?: ScrollContentInset;
+    automaticContentInset?: Partial<ScrollContentInset>;
+    zoomScale?: number;
+    minimumZoomScale?: number;
+    maximumZoomScale?: number;
+    horizontal: boolean;
+    directionalLockEnabled?: boolean;
+    axisFlipped?: boolean;
+    scrollEnabled: boolean;
+    parentNodeId: number | null;
+    nestedScrollEnabled?: boolean;
+    pagingEnabled: boolean;
+    snapToInterval?: number;
+    snapToAlignment?: 'start' | 'center' | 'end';
+    snapToOffsets?: number[];
+    snapToStart: boolean;
+    snapToEnd: boolean;
+    disableIntervalMomentum: boolean;
+    collapseBand?: CollapseBand;
+    decelerationRate?: unknown;
+    scrollEventThrottle?: number;
+    refreshEnabled: boolean;
+    refreshing: boolean;
+    refreshHasTitle?: boolean;
+    refreshTitleFontSize?: number;
+    overScrollMode?: unknown;
+    bounces?: boolean;
+    requiresGestureClaim?: boolean;
+}
+export interface ScrollMirrorRegistry {
+    surfaceId: string;
+    generation: number;
+    entries: ScrollMirrorEntry[];
+    retirements?: ScrollSlotRetirement[];
+}
+export interface ScrollSlotRetirement extends ScrollMirrorOwner {
+    retirementId: string;
+    slotX: number;
+}
+export declare function isScrollSlotRetirement(value: unknown): value is ScrollSlotRetirement;
+export type ScrollMirrorRegistryMessage = {
+    type: 'registry';
+    registry: ScrollMirrorRegistry;
+};
+export type ScrollMirrorControlMessage = ({
+    type: 'flashIndicators';
+} & ScrollMirrorOwner) | ({
+    type: 'claim';
+    pointerId: number;
+} & ScrollMirrorOwner) | ({
+    type: 'release';
+    pointerId: number;
+} & ScrollRelease & ScrollMirrorOwner) | ({
+    type: 'endDrag';
+    pointerId: number;
+} & ScrollMirrorOwner) | ({
+    type: 'momentumBegin';
+    pointerId: number;
+} & ScrollMirrorOwner) | ({
+    type: 'momentumEnd';
+    pointerId: number;
+} & ScrollMirrorOwner) | ({
+    type: 'cancel';
+    pointerId: number;
+} & ScrollMirrorOwner) | ({
+    type: 'abandon';
+    pointerId: number;
+} & ScrollMirrorOwner) | ({
+    type: 'confirm';
+    pointerId: number;
+} & ScrollMirrorOwner) | ({
+    type: 'scrollTo';
+    animation?: import('../engine/scroll-momentum-math.d.ts').TimedScrollControl;
+    contentOffsetX: number;
+    contentOffsetY: number;
+} & ScrollMirrorOwner) | ({
+    type: 'refresh';
+    pointerId: number;
+} & ScrollMirrorOwner) | ({
+    type: 'scroll';
+    animation?: import('../engine/scroll-momentum-math.d.ts').TimedScrollPresentation;
+    pointerId: number;
+    contentOffsetX: number;
+    contentOffsetY: number;
+    refreshPullProgress: number;
+    androidEdgeEffect: AndroidEdgeEffectState | null;
+    ts: number;
+} & ScrollMirrorOwner);
+export type ScrollMirrorEnvelope = ScrollMirrorRegistryMessage;
+export type ScrollControlEnvelope = ScrollMirrorControlMessage;
+interface SlotPair {
+    allocationId: string;
+    slotX: number;
+    slotY: number;
+    slotZoom: number;
+    slotVersion: number;
+    slotSampleTime: number;
+    slotDragStartTime: number;
+    slotPresentationDisplacementY: number;
+}
+export declare function scrollMirrorOwnerKey(owner: ScrollMirrorOwner): string;
+export declare function sameScrollMirrorOwner(left: ScrollMirrorOwner, right: ScrollMirrorOwner): boolean;
+export declare function getOrAllocateScrollSlots(runtime: WorkletRuntime, owner: ScrollMirrorOwner): SlotPair | null;
+export declare function getKnownScrollSlots(owner: ScrollMirrorOwner): SlotPair | null;
+export declare function releaseScrollSlots(runtime: WorkletRuntime, owner: ScrollMirrorOwner): boolean;
+export declare function releaseScrollSlotsExcept(runtime: WorkletRuntime, liveOwners: ReadonlySet<string>): number;
+export declare function publishScrollMirrorRegistry(runtime: WorkletRuntime, registry: Omit<ScrollMirrorRegistry, 'retirements'>, post: (registry: ScrollMirrorRegistry) => void): void;
+export declare function acknowledgeScrollSlotRetirement(runtime: WorkletRuntime, receipt: ScrollSlotRetirement): boolean;
+export declare function writeScrollOffset(runtime: WorkletRuntime, owner: ScrollMirrorOwner, offsetX: number, offsetY: number, opts?: {
+    notifyPeer?: boolean;
+    zoomScale?: number;
+    presented?: boolean;
+    sampleTime?: number;
+    dragStartTime?: number;
+    presentationDisplacementY?: number;
+}): void;
+export declare function setShellRefreshHold(owner: ScrollMirrorOwner, holding: boolean): void;
+export declare function isShellRefreshHolding(owner: ScrollMirrorOwner): boolean;
+export declare function setShellRefreshPullProgress(owner: ScrollMirrorOwner, progress: number): void;
+export declare function getShellRefreshPullProgress(owner: ScrollMirrorOwner): number;
+export declare function setShellAndroidEdgeEffect(owner: ScrollMirrorOwner, effect: AndroidEdgeEffectState | null): void;
+export declare function getShellAndroidEdgeEffect(owner: ScrollMirrorOwner): AndroidEdgeEffectState | null;
+export declare function getShellIosFastScroll(owner: ScrollMirrorOwner): IosFastScroll;
+export declare function applyScrollMirrorRegistry(registry: ScrollMirrorRegistry): boolean;
+export declare function retireScrollMirrorEntries(retirements: readonly ScrollSlotRetirement[]): void;
+export declare function subscribeScrollMirror(fn: (reg: ScrollMirrorRegistry) => void): () => void;
+export declare function getScrollMirrorEntry(owner: ScrollMirrorOwner): ScrollMirrorEntry | null;
+export declare function getAllScrollMirrorEntries(): ScrollMirrorEntry[];
+export declare function forEachShellScrollEntry(cb: (entry: ScrollMirrorEntry) => void): void;
+export declare function getScrollMirrorOffset(runtime: WorkletRuntime, owner: ScrollMirrorOwner): {
+    x: number;
+    y: number;
+} | null;
+export declare function findScrollablesAt(surfaceId: string, x: number, y: number): ScrollMirrorEntry[];
+export declare function findScrollableAt(x: number, y: number, surfaceId?: string): ScrollMirrorEntry | null;
+export {};

package/dist-types/packages/peach-engine/src/render-worker/shell-event-registry.d.ts

@@ -0,0 +1,119 @@
+export declare const RENDER_WORKER_SHELL_EVENT_SPECS: readonly [{
+    readonly type: 'peach:screenCaptureState';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:ringHint';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: true;
+}, {
+    readonly type: 'sootsim:ringModeChange';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: true;
+}, {
+    readonly type: 'sootsim:homeIntro';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:uploadActivity';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:statusBarOverride';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:previewReplayClock';
+    readonly forwardToShellWorker: false;
+    readonly forwardToTenantWorker: true;
+}, {
+    readonly type: 'sootsim:hostFocusChange';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:goHome';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:appSwitcher';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:toggleLock';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:shake';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: true;
+}, {
+    readonly type: 'sootsim:screenshotTaken';
+    readonly forwardToShellWorker: false;
+    readonly forwardToTenantWorker: true;
+}, {
+    readonly type: 'sootsim:agentAction';
+    readonly forwardToShellWorker: false;
+    readonly forwardToTenantWorker: true;
+}, {
+    readonly type: 'sootsim:openNotificationCenter';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:openControlCenter';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:closeNotificationCenter';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:closeControlCenter';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:setTopOverlay';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:inspectModeChange';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: true;
+}, {
+    readonly type: 'sootsim:hoverPosition';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:hoverLeave';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:inspectSelectPosition';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: true;
+}, {
+    readonly type: 'sootsim:inspectHoverNode';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:inspectSelectNode';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: false;
+}, {
+    readonly type: 'sootsim:hostKey';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: true;
+}, {
+    readonly type: 'sootsim:menuAnimOverride';
+    readonly forwardToShellWorker: true;
+    readonly forwardToTenantWorker: true;
+}];
+export type ShellEventType = (typeof RENDER_WORKER_SHELL_EVENT_SPECS)[number]['type'];
+export type ShellWorkerShellEventType = Extract<(typeof RENDER_WORKER_SHELL_EVENT_SPECS)[number], {
+    forwardToShellWorker: true;
+}>['type'];
+export type TenantWorkerShellEventType = Extract<(typeof RENDER_WORKER_SHELL_EVENT_SPECS)[number], {
+    forwardToTenantWorker: true;
+}>['type'];
+export declare const SHELL_WORKER_SHELL_EVENT_TYPES: ("peach:screenCaptureState" | "sootsim:appSwitcher" | "sootsim:closeControlCenter" | "sootsim:closeNotificationCenter" | "sootsim:goHome" | "sootsim:homeIntro" | "sootsim:hostFocusChange" | "sootsim:hostKey" | "sootsim:hoverLeave" | "sootsim:hoverPosition" | "sootsim:inspectHoverNode" | "sootsim:inspectModeChange" | "sootsim:inspectSelectNode" | "sootsim:inspectSelectPosition" | "sootsim:menuAnimOverride" | "sootsim:openControlCenter" | "sootsim:openNotificationCenter" | "sootsim:ringHint" | "sootsim:ringModeChange" | "sootsim:setTopOverlay" | "sootsim:shake" | "sootsim:statusBarOverride" | "sootsim:toggleLock" | "sootsim:uploadActivity")[];
+export declare const TENANT_WORKER_SHELL_EVENT_TYPES: ("sootsim:agentAction" | "sootsim:hostKey" | "sootsim:inspectModeChange" | "sootsim:inspectSelectPosition" | "sootsim:menuAnimOverride" | "sootsim:previewReplayClock" | "sootsim:ringHint" | "sootsim:ringModeChange" | "sootsim:screenshotTaken" | "sootsim:shake")[];
+export declare function readRenderWorkerShellEventDetail(eventType: ShellEventType, event: Event): unknown;

package/dist-types/packages/peach-engine/src/render-worker/shell-gesture-regions.d.ts

@@ -0,0 +1,41 @@
+import { type DeviceSpec } from '../../../../../src/device-catalog.ts';
+import { type AndroidSystemBarsWindow } from '../platform/system-bars-state.d.ts';
+export type ShellGestureRegion = 'top-left' | 'top-right' | 'android-shade' | 'android-status-reveal' | 'android-navigation-reveal' | 'island' | 'bottom' | 'android-bottom' | 'android-edge-left' | 'android-edge-right' | 'android-corner-left' | 'android-corner-right' | 'android-reveal-corner-left' | 'android-reveal-corner-right' | 'fullscreen' | null;
+export type AndroidEdgeBackRegion = 'android-edge-left' | 'android-edge-right';
+export type AndroidCornerGestureRegion = 'android-corner-left' | 'android-corner-right' | 'android-reveal-corner-left' | 'android-reveal-corner-right';
+export type AndroidSystemGestureCandidateRegion = 'android-bottom' | 'android-status-reveal' | 'android-navigation-reveal' | AndroidEdgeBackRegion | AndroidCornerGestureRegion;
+export type AndroidSystemGestureClaimRegion = 'android-bottom' | 'android-status-reveal' | 'android-navigation-reveal' | 'android-shade' | AndroidEdgeBackRegion;
+export type AndroidSystemGestureDecision = {
+    state: 'wait' | 'cancel';
+} | {
+    state: 'activate';
+    region: AndroidSystemGestureClaimRegion;
+} | {
+    state: 'narrow';
+    region: 'android-status-reveal';
+};
+export declare const ANDROID_SYSTEM_BARS_REVEAL_START_THRESHOLD = 24;
+export declare const ANDROID_SYSTEM_BARS_REVEAL_DISTANCE = 24;
+export declare const ANDROID_SYSTEM_BARS_REVEAL_TIMEOUT_MS = 500;
+export declare function getShellGestureRegion(spec: DeviceSpec, x: number, y: number, opts?: {
+    fullscreen?: boolean;
+    statusBarHidden?: boolean;
+    androidWindow?: AndroidSystemBarsWindow;
+}): ShellGestureRegion;
+export declare function isShellTopGestureRegion(region: ShellGestureRegion): boolean;
+export declare function isAndroidEdgeBackRegion(region: ShellGestureRegion): region is AndroidEdgeBackRegion;
+export declare function isAndroidSystemGestureCandidateRegion(region: ShellGestureRegion): region is AndroidSystemGestureCandidateRegion;
+export declare function androidSystemGestureCandidateAllowsContentFallback(region: AndroidSystemGestureCandidateRegion): boolean;
+export declare function isAndroidBackGestureCandidateRegion(region: AndroidSystemGestureCandidateRegion): boolean;
+export declare function resolveAndroidSystemGestureIntent(params: {
+    region: AndroidSystemGestureCandidateRegion;
+    startX: number;
+    startY: number;
+    x: number;
+    y: number;
+    displayHeight: number;
+    elapsedMs: number;
+    statusRevealStartThreshold: number;
+    backGestureExcluded?: boolean;
+}): AndroidSystemGestureDecision;
+export declare function isShellExclusiveGestureRegion(region: ShellGestureRegion): boolean;