peachsim 0.1.1641 → 0.1.1653

package/dist-types/packages/peach-engine/src/render-worker/compositor-protocol.d.ts

@@ -0,0 +1,1945 @@
+import { type DriveAnimationGraph, type DriveColorAnimationGraph, type LinearLoopAnimationGraph, type NativeAnimationGraph, type ScrollAnimationGraph } from '../engine/animation-graph.d.ts';
+import { type CollapseBand, type ScrollMomentumPhysics } from '../engine/scroll-momentum-math.d.ts';
+import { type CSSKeyframesDrive } from './css-keyframes-drive.d.ts';
+import { type NativeWidgetSurfaceId, type NativeWidgetIdentity, type NativeWidgetMount } from './native-widgetContract.d.ts';
+import type { DeviceSpec, RuntimePlatform } from '../../../../../src/device-catalog.ts';
+import type { AndroidEdgeEffectState } from '../engine/android-stretch-effect.d.ts';
+import type { AnimatedDrivenStyleLease, AnimatedDrivenStyleRetirement } from '../engine/animated-driven-style.d.ts';
+import type { AnimationClockSnapshot } from '../engine/animation-clockContract.d.ts';
+import type { RemoteFontRegistration } from '../engine/app-font-registry.d.ts';
+import type { AppFontWireSpec } from '../engine/config-plugin-fonts.d.ts';
+import type { readImageAudit } from '../engine/image-audit.d.ts';
+import type { ImageLoaderStats } from '../engine/image-loader.d.ts';
+import type { LottieOwnerDiagnostics } from '../engine/lottie-runtime.d.ts';
+import type { LottieIntent, LottieLifecycleEvent } from '../engine/lottie-types.d.ts';
+import type { MetalShaderCompileRequest, MetalShaderCompileResponse } from '../engine/metalShaderContract.d.ts';
+import type { NativeAnimationGraphNode } from '../engine/native-animation-graph.d.ts';
+import type { NativeReplayReport, NativeReplayRequest } from '../engine/nativeReplayContract.d.ts';
+import type { NativeWindowPresentation } from '../engine/portalContract.d.ts';
+import type { ScrollRange } from '../engine/scroll-range.d.ts';
+import type { readTextPaintReceipt } from '../engine/text-paint-receipt.d.ts';
+import type { InterfaceRotation } from '../settings/interface-rotation.d.ts';
+import type { ReactNativeConfigurationSnapshot } from '../settings/react-native-configuration.d.ts';
+import type { WireframeModeConfig } from '../wireframe-mode.d.ts';
+import type { AuxAppSurfaceId } from './aux-surface-types.d.ts';
+import type { GraphitePipelineCacheLoadResult } from './canvaskit-shared.d.ts';
+import type { GraphiteDeviceContextStats, GraphitePipelinePrecompileResult, GraphiteResidencyReport } from './canvaskit-webgpu.d.ts';
+import type { CompositorGpuRegion } from './compositor-gpu.d.ts';
+import type { ScrollDragResampleTrace } from './compositor-runtime/scroll-drag-resample.d.ts';
+import type { EditMenuItemRect } from './edit-menu-geometry.d.ts';
+import type { EngineResourceRequest, EngineResourceResponse } from './engine-resource-relay.d.ts';
+import type { ImageLifecycleEvent } from './image-lifecycle-event.d.ts';
+import type { LiveFrameMirrorEnvelope } from './live-frame-mirror.d.ts';
+import type { ViewShotCaptureResultSpec, ViewShotCaptureSpec } from './native-ui-protocol.d.ts';
+import type { ResilientFrameClockStats } from './resilient-frame-clock.d.ts';
+import type { WireElementNode, WireSurfaceUpdate } from './shell-tree-wire.d.ts';
+import type { CursorBridgeEvent } from './text-inputContract.d.ts';
+import type { SurfaceTreePaintAckState } from './tree-sync-port.d.ts';
+import type { WebGpuFrameTransactionCounters } from './webgpu-frame-transaction.d.ts';
+import type { WebGpuReadbackCounters } from './webgpu-readback-scheduler.d.ts';
+import type { WorkerStorageSyncMessage } from './worker-storage.d.ts';
+import type { ScreenTransitionDriveDescriptor } from '../../../peach-compat/src/stubs/screen-transition-math.d.ts';
+import type { SootSimCaptureOptions, SootsimBootMark } from '../../../peach-globals/src/index.d.ts';
+export type NativeInterfaceRotation = InterfaceRotation & {
+    platform: RuntimePlatform;
+};
+export type BackdropSurfaceId = AuxAppSurfaceId | 'home';
+export type ShellAuthoredSurfaceId = 'home' | 'shell-overlay';
+export type CompositorSurfaceId = AuxAppSurfaceId | ShellAuthoredSurfaceId | NativeWidgetSurfaceId;
+export interface NativeWindowInputRegion extends NativeWindowPresentation {
+    viewTag: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface NativeWindowSource {
+    surfaceId: CompositorSurfaceId;
+    generation: number;
+}
+export interface NativeWindowOwnership extends NativeWindowSource {
+    windows: readonly NativeWindowInputRegion[];
+}
+export type CapturePublicationOrigin = 'tenant' | 'shell' | 'video';
+export type CompositorFatalReason = 'init' | 'device-lost' | 'frame-production' | 'profile-measurement';
+export interface GraphiteCachePoolSnapshot {
+    currentBytes: number;
+    purgeableBytes: number;
+    maxBytes: number;
+}
+export interface GraphiteDeviceCacheSnapshot {
+    contextResources: GraphiteCachePoolSnapshot;
+    recorderResources: GraphiteCachePoolSnapshot;
+}
+export interface SettledIdleCacheCleanupResult {
+    reason: 'over-budget-resources';
+    status: 'cleaned' | 'locked' | 'purgeable';
+    durationMs: number;
+    before: GraphiteDeviceCacheSnapshot;
+    after: GraphiteDeviceCacheSnapshot;
+}
+export type SettledIdleCacheBlockReason = 'never-scheduled' | 'no-context' | 'profile' | 'finite-interaction' | 'readback' | 'within-budget' | 'quiet-timer' | 'in-flight' | 'generation-complete' | 'recent-work' | 'waiting-for-completion' | 'cancelled' | 'locked' | 'purgeable-over-budget' | 'none' | 'completion-failed';
+export declare const SHELL_SURFACE_GENERATION = 1;
+export type CompositorAnimatedGraph = NativeAnimationGraph | ScrollAnimationGraph | DriveAnimationGraph | DriveColorAnimationGraph;
+export declare function isCompositorAnimatedGraph(value: unknown): value is CompositorAnimatedGraph;
+export interface CompositorAnimatedSlotGraph {
+    slot: number;
+    graph: CompositorAnimatedGraph;
+}
+export interface CompositorScrollEffectPresentation {
+    nodeId: number;
+    refreshHolding: boolean;
+    refreshPullProgress: number;
+    androidEdgeEffect: AndroidEdgeEffectState | null;
+}
+export interface CompositorSurfaceInit {
+    surfaceId: CompositorSurfaceId;
+    canvas: OffscreenCanvas;
+    physW: number;
+    physH: number;
+    contentW: number;
+    contentH: number;
+    dpr: number;
+}
+export interface CompositorSurfaceResize {
+    surfaceId: CompositorSurfaceId;
+    physW: number;
+    physH: number;
+    contentW: number;
+    contentH: number;
+    dpr: number;
+}
+export interface CompositorCapturedSurface {
+    surfaceId: CompositorSurfaceId;
+    bitmap: ImageBitmap;
+    frameToken?: number;
+    presentedAtEpochMs?: number;
+}
+export type PresentedFrameCaptureFormat = 'rgba' | 'sha256';
+export interface CompositorCapturedFrameHash {
+    surfaceId: CompositorSurfaceId;
+    frameToken: number;
+    presentedAtEpochMs: number;
+    width: number;
+    height: number;
+    pixelHash: string;
+}
+export interface CompositorCapturedPixelSurface extends CompositorCapturedFrameHash {
+    rgba: Uint8ClampedArray<ArrayBuffer>;
+}
+export interface PresentedFrameCaptureOptions {
+    surfaceId: CompositorSurfaceId;
+    maxWidth: number;
+    limit: number;
+}
+export interface CompositorSurfaceCaptureFailure {
+    surfaceId: CompositorSurfaceId;
+    message: string;
+}
+export interface CompositorSurfaceCaptureResult {
+    surfaces: CompositorCapturedSurface[];
+    pixelSurfaces?: CompositorCapturedPixelSurface[];
+    hashedSurfaces?: CompositorCapturedFrameHash[];
+    unavailableSurfaceIds: CompositorSurfaceId[];
+    failures: CompositorSurfaceCaptureFailure[];
+}
+export interface CompositorScrollTraceSample {
+    t: number;
+    seq: number;
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    surfaceEpoch: number;
+    textureEpoch: number;
+    frameToken: number;
+    nodeId: number;
+    x: number;
+    y: number;
+    slotX: number | null;
+    slotY: number | null;
+    slotSampleTime: number | null;
+    resampledAt: number | null;
+    drag: boolean;
+    momentum: boolean;
+    paint: number;
+}
+export interface CompositorTransitionTraceSample {
+    t: number;
+    surfaceId: AuxAppSurfaceId;
+    kind: 'transition';
+    stackId: number;
+    progress: number;
+    targetApplies: number;
+    targetChanges: number;
+    targetMisses: number;
+    paintCount: number;
+}
+export interface CompositorScrollResampleTraceSample extends ScrollDragResampleTrace {
+    kind: 'scroll-resample';
+    t: number;
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    nodeId: number;
+}
+export interface CompositorPressTraceSample {
+    kind: 'press';
+    inputSurfaceId: CompositorSurfaceId;
+    surfaceId: CompositorSurfaceId;
+    targetWasMounted: boolean;
+    pointerT: number;
+    treeT: number;
+    paintT: number;
+}
+export interface CompositorLayoutTraceSample {
+    kind: 'layout';
+    surfaceId: CompositorSurfaceId;
+    width: number;
+    height: number;
+    scale: number;
+    t: number;
+    frameToken: number;
+    chain?: CompositorPaintGate[];
+}
+export type CompositorTraceSample = CompositorScrollTraceSample | CompositorScrollResampleTraceSample | CompositorTransitionTraceSample | CompositorPressTraceSample | CompositorLayoutTraceSample;
+export interface ScrollMomentumDriveNode extends ScrollRange {
+    nodeId: number;
+    offset: number;
+}
+export interface ScrollMomentumDriveDescriptor extends ScrollRange {
+    driveId: number;
+    startedAtAnimationMs: number;
+    nodeId: number;
+    axis: 'x' | 'y';
+    offset: number;
+    velocity: number;
+    releasePanVelocity: number;
+    fastScrollMultiplier: number;
+    bounces: boolean;
+    paging: boolean;
+    pageSize: number;
+    pageStartPage: number;
+    boundsWidth: number;
+    pixelScale: number;
+    snapToInterval?: number;
+    snapToAlignment?: 'start' | 'center' | 'end';
+    snapToOffsets?: number[];
+    snapToStart: boolean;
+    snapToEnd: boolean;
+    disableIntervalMomentum: boolean;
+    collapseBand?: CollapseBand;
+    physics: ScrollMomentumPhysics;
+    nestedScrollChain?: ScrollMomentumDriveNode[];
+    timedScroll?: {
+        target: number;
+        durationMs: number;
+        curve: import('../engine/scroll-momentum-math.d.ts').TimedScrollCurve;
+    };
+}
+export interface ScrollMomentumExtentNode extends ScrollRange {
+    nodeId: number;
+}
+export declare function isScrollMomentumExtentChain(value: unknown): value is ScrollMomentumExtentNode[];
+export declare function isScrollMomentumDriveChain(value: unknown): value is ScrollMomentumDriveNode[];
+export declare function isScrollMomentumDriveDescriptor(value: unknown): value is ScrollMomentumDriveDescriptor;
+export interface CompositorPaintSample {
+    t: number;
+    frame: number;
+    surfaceId: CompositorSurfaceId;
+    paint: number;
+    warm?: boolean;
+    totalMs: number;
+    layoutMs: number;
+    renderMs: number;
+    flushMs: number;
+    gpuCacheBeforeBytes: number | null;
+    gpuCacheAfterRenderBytes: number | null;
+    gpuCacheAfterFlushBytes: number | null;
+    renderProfile: Record<string, number> | null;
+}
+export interface CompositorTimingSummary {
+    count: number;
+    avg: number;
+    p50: number;
+    p95: number;
+    max: number;
+}
+export interface CompositorWorkSummary extends CompositorTimingSummary {
+    frames: number;
+}
+export type CompositorFrameSource = 'display' | 'timer' | 'demand';
+export type CompositorDisplayClockPolicy = 'display-clock-present-v1';
+export type CompositorSchedulerEvent = {
+    kind: 'display';
+    t: number;
+    displayTimestampMs: number;
+} | {
+    kind: 'arm';
+    t: number;
+    requestId: number;
+    plannedFireMs: number;
+} | {
+    kind: 'fire' | 'cancel';
+    t: number;
+    requestId: number;
+} | {
+    kind: 'demand';
+    t: number;
+    coalesced: boolean;
+};
+export interface CompositorMotionCurve {
+    durationMs: number;
+    curve: Array<{
+        elapsedMs: number;
+        progress: number;
+    }>;
+}
+export interface CompositorMotionProgress {
+    id: string;
+    elapsedMs: number;
+    progress: number;
+    expected?: CompositorMotionCurve;
+}
+export type NativeFrameReceiptValue = number | '-0' | 'NaN' | 'Infinity' | '-Infinity';
+export type NativeFrameReceiptRect = Record<'left' | 'top' | 'right' | 'bottom', NativeFrameReceiptValue>;
+export interface NativeFrameReceiptState {
+    serial: NativeFrameReceiptValue;
+    frameTime: NativeFrameReceiptValue;
+    applies: NativeFrameReceiptValue;
+    incoherent: NativeFrameReceiptValue;
+    presentFailures: NativeFrameReceiptValue;
+    inputs: Array<{
+        slot: number;
+        kind: 'animation' | 'watch';
+        value: NativeFrameReceiptValue;
+    }>;
+    omittedInputs: number;
+    entries: Array<{
+        surfaceId: CompositorSurfaceId;
+        generation: number;
+        viewTag: number;
+        sceneSlot: number | null;
+        nativeId: number;
+        promoted: boolean;
+        settled: boolean;
+        slots: number[];
+        values: NativeFrameReceiptValue[];
+        sceneLanes: NativeFrameReceiptValue[] | null;
+        omittedValues: number;
+        properties: Record<string, number[]>;
+        omittedProperties: number;
+    }>;
+    omittedEntries: number;
+    surfaces: Array<{
+        surfaceId: CompositorSurfaceId;
+        generation: number;
+        root: NativeFrameReceiptValue;
+        damageId: NativeFrameReceiptValue;
+        animSurface: NativeFrameReceiptValue;
+        canvas: NativeFrameReceiptValue;
+        surfaceEpoch: number;
+        textureEpoch: number;
+        needsPaint: boolean;
+        layoutPending: boolean;
+        paints: NativeFrameReceiptValue;
+        presented: NativeFrameReceiptValue;
+        drawn: NativeFrameReceiptValue;
+        lastPaintSerial: NativeFrameReceiptValue;
+        lastPaintMs: NativeFrameReceiptValue;
+        damage: (Omit<import('../engine/render-damage.d.ts').PendingDamage, 'source'> & {
+            source: NativeFrameReceiptRect | null;
+        }) | null;
+        currentClip: NativeFrameReceiptRect | null;
+        lastClip: NativeFrameReceiptRect | null;
+    }>;
+}
+export interface NativeFrameReceipt {
+    status: number;
+    before: NativeFrameReceiptState;
+    after: NativeFrameReceiptState;
+}
+export interface NativeFrameReceiptRecord {
+    sequence: number;
+    receipt: NativeFrameReceipt;
+}
+export interface CompositorFramePhaseSample {
+    sequence: number;
+    t: number;
+    frameToken: number;
+    nativeFrame?: boolean;
+    frameSource: CompositorFrameSource;
+    rafMs: number;
+    intervalMs: number;
+    productionMs: number;
+    productionStartedAtMs: number;
+    productionEndedAtMs: number;
+    displayTimestampMs: number | null;
+    demandObservedAtMs: number | null;
+    admissionDepth: number | null;
+    productionOutcome: 'admitted' | 'deferred';
+    phases: {
+        javascriptMs: number;
+        layoutMs: number;
+        paintMs: number;
+        prewarmMs: number;
+        textureUploadMs: number;
+        gpuSubmitMs: number;
+        compositeMs: number;
+        captureMs: number;
+    };
+    captureBetweenFramesMs: number;
+    inputMessages: number;
+    slotEpochDelta: number;
+    scrollSlotApplies: number;
+    scrollMessageApplies: number;
+    appTreeUpdates: number;
+    scrollDragStartsMs: readonly number[];
+    slotEpochChanged: boolean;
+    engineQueuedAtStart: boolean;
+    engineDemandAfter: boolean;
+    motionPending: boolean;
+    paints: number;
+    presentedSurfaces: number;
+    motionProgress?: CompositorMotionProgress[];
+    prewarmPasses: number;
+    canvaskitFlushes: number;
+    canvaskitFlushMs: number;
+    canvaskitSubmissionIntervalMs: number | null;
+    afterCanvaskitFlush: boolean;
+    uninterruptedEngineEmpty: boolean;
+}
+export interface CompositorProductionStats {
+    budgetMs: number;
+    frames: CompositorTimingSummary;
+    overBudget: number;
+    overBudgetPct: number;
+    phases: {
+        javascript: CompositorTimingSummary;
+        layout: CompositorTimingSummary;
+        paint: CompositorTimingSummary;
+        prewarm: CompositorTimingSummary;
+        textureUpload: CompositorTimingSummary;
+        gpuSubmit: CompositorTimingSummary;
+        composite: CompositorTimingSummary;
+        capture: CompositorTimingSummary;
+    };
+    captureBetweenFrames: CompositorTimingSummary;
+    worstFrames: CompositorFramePhaseSample[];
+}
+export interface GPUUploadTrace {
+    texImage2DCalls: number;
+    texSubImage2DCalls: number;
+    uploadedByteUpperBound: number;
+    compileShaderCalls: number;
+    linkProgramCalls: number;
+    compileShaderMs: number;
+    shaderStatusMs: number;
+    linkProgramMs: number;
+    programStatusMs: number;
+    uploadMs: number;
+}
+export interface CompositorSurfacePaintStats {
+    surfaceId: CompositorSurfaceId;
+    physW: number;
+    physH: number;
+    generation: number;
+    launchPaintedGeneration: number | null;
+    contentPaintedGeneration: number | null;
+    treePaintAcks: SurfaceTreePaintAckState | null;
+    firstContent: {
+        appId: string;
+        readiness: 'empty' | 'pending-symbols' | 'ready';
+        layoutDirty: boolean;
+        textDataPending: boolean;
+        textDataFailed: boolean;
+        pendingSymbolCount: number;
+        pendingSymbols: Array<{
+            nodeId: number;
+            name: string | null;
+            paintGates: CompositorPaintGate[];
+        }>;
+    } | null;
+    hasLiveFrames: boolean;
+    paints: number;
+    paused: boolean;
+    awaitingBoundTree: boolean;
+    needsPaint: boolean;
+    appInMotion: boolean;
+    motionApproximate: boolean;
+    cacheUsageBytes?: number | null;
+    cacheLimitBytes?: number | null;
+    gpuUploads?: GPUUploadTrace | null;
+    nodeCount: number;
+    imageNodeCount: number;
+    fileImageNodeCount: number;
+    lastBackdropSampleBounds: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    } | null;
+    gpuCacheTrace: {
+        afterSurfaceCreateBytes: number | null;
+        prewarm: {
+            beforeBytes: number | null;
+            afterDrawBytes: number | null;
+            afterPurgeBytes: number | null;
+            scratchPixelBytes: number;
+            backdropPixelBytes: number;
+        } | null;
+        paintCheckpoints: Array<{
+            paint: number;
+            beforeBytes: number | null;
+            afterRenderBytes: number | null;
+            afterFlushBytes: number | null;
+        }>;
+    };
+    work: CompositorTimingSummary;
+    avgLayoutMs: number;
+    avgRenderMs: number;
+    avgFlushMs: number;
+    maxFlushMs: number;
+    sampledPaints: number;
+    jankPaints: number;
+    worstPaints: CompositorPaintSample[];
+    paintSeries: CompositorPaintSample[];
+    prewarm: {
+        passes: number;
+        records: number;
+        rasterPromotions: number;
+        realizeRasterBlits: number;
+        acceptedBeforeFirstPaint: number;
+        passesBeforeFirstPaint: number;
+        recordsBeforeFirstPaint: number;
+        rasterPromotionsBeforeFirstPaint: number;
+        msBeforeFirstPaint: number;
+        ms: number;
+        pending: boolean;
+    };
+}
+export type { ImageAuditRow } from '../engine/image-audit.d.ts';
+export type ImageAuditReport = ReturnType<typeof readImageAudit>;
+export type { TextPaintReceiptRow } from '../engine/text-paint-receipt.d.ts';
+export type TextPaintReceiptReport = ReturnType<typeof readTextPaintReceipt>;
+export interface TextPaintReceiptRequest {
+    scope?: string | null;
+    replay?: NativeReplayRequest;
+}
+export interface CompositorPaintGate {
+    nodeId: number;
+    viewTag: number | null;
+    type: string;
+    testID: string | null;
+    hidden: boolean;
+    display: string | null;
+    opacity: number | null;
+    wireframeHidden: boolean;
+    wireframeWallpaper: boolean;
+    layout: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    absolute: {
+        x: number;
+        y: number;
+    };
+    transform: Record<string, number>;
+    leasedKeys: string[];
+}
+export interface CompositorStyleProbe {
+    nodeId: number;
+    paintGates: CompositorPaintGate[];
+    paintBoundary: {
+        chunkCount: number;
+        layerChunks: number;
+        liveChunks: number;
+        pictureChunks: number;
+        records: number;
+        replays: number;
+        textureLayer: {
+            bytes: number;
+            dpr: number;
+            height: number;
+            width: number;
+        } | null;
+    } | null;
+    surfaceId: string;
+    style: Record<string, unknown>;
+    viewTag: number | null;
+}
+export interface GraphiteAdapterIdentity {
+    vendor: string;
+    architecture: string;
+    device: string;
+    description: string;
+    isFallbackAdapter: boolean;
+}
+export interface CompositorCadenceRequest {
+    detail: 'cadence';
+    nativeReceiptsAfter?: number;
+}
+export interface CompositorCadenceStats {
+    backend: 'ganesh' | 'graphite';
+    cadence: CompositorStats['cadence'];
+    nativeReceipts?: NativeFrameReceiptRecord[];
+    graphite: {
+        device: {
+            native: Pick<GraphiteDeviceContextStats['native'], 'renderPipelineCreations' | 'asyncPipelineCompilesPending'>;
+        };
+        pipelineWarm: Pick<NonNullable<CompositorStats['graphite']>['pipelineWarm'], 'queued' | 'warmed'>;
+        transactions: NonNullable<CompositorStats['graphite']>['transactions'];
+        residencyPeakBytes: number;
+        readbacks: WebGpuReadbackCounters;
+    } | null;
+}
+export type PendingSurfaceReason = 'paused' | 'unbound';
+export interface CompositorStats {
+    windowRotation: {
+        active: boolean;
+        running: boolean;
+        progress: number;
+        startedAt: number | null;
+        duration: number;
+    };
+    presentationCapture: {
+        active: boolean;
+        count: number;
+    };
+    backend?: 'ganesh' | 'graphite';
+    hostFrameClock?: {
+        published: ResilientFrameClockStats | null;
+        consumed: ResilientFrameClockStats;
+    };
+    imageAudit?: ImageAuditReport | null;
+    textPaint?: TextPaintReceiptReport | null;
+    nativeReplay?: NativeReplayReport | null;
+    hasFile?: boolean;
+    resourcePolicy: {
+        budgetScale: number;
+        contextBudgetApplications: number;
+        defaultSurfaceCacheBudgetBytes: number;
+        appSurfaceCacheBudgetBytes: number;
+        imageCacheLimitBytes: number;
+    };
+    graphite: {
+        device: GraphiteDeviceContextStats;
+        adapter: GraphiteAdapterIdentity;
+        pipelineCorpus: GraphitePipelinePrecompileResult;
+        pipelineWarm: {
+            queued: number;
+            inFlight: boolean;
+            sliceRecords: number;
+            warmed: number;
+            rejected: number;
+            reason: string | null;
+            blockedBy: 'finite-motion' | 'host-task' | null;
+            learnedScreens: number;
+            learnedRecords: number;
+            pageAppRecords: number;
+            learnedReason: string | null;
+        };
+        imageWarm: {
+            queued: number;
+            inFlight: boolean;
+            warmed: number;
+            failed: number;
+        };
+        residency: GraphiteResidencyReport | null;
+        residencyPeak: GraphiteResidencyReport | null;
+        residencyPeakBytes: number;
+        residencyPeakAtMs: number;
+        transactions: WebGpuFrameTransactionCounters;
+        readbacks: WebGpuReadbackCounters;
+        creationEvents: Array<{
+            label: string;
+            surfaces: Array<{
+                surfaceId: CompositorSurfaceId;
+                generation: number;
+                phase: 'first-paint' | 'device-prewarm';
+            }>;
+            shaderModulesCreated: number;
+            renderPipelinesCreated: number;
+            shaderModuleCreationCpuMicros: number;
+            renderPipelineCreationCpuMicros: number;
+            recorderSnapCpuMicros: number;
+            recordingInsertionCpuMicros: number;
+            commandBufferFinishCpuMicros: number;
+            queueSubmissionCpuMicros: number;
+            pipelineCacheHits: number;
+            pipelineCacheMisses: number;
+        }>;
+    } | null;
+    boundedFrameProduction: {
+        submissionLimit: number;
+        acceptedFrames: number;
+        deferredLogicalFrames: number;
+        pendingReplacements: number;
+        resumedProductions: number;
+        pending: boolean;
+        currentDeferredStreak: number;
+        longestDeferredStreak: number;
+        oldestPendingAgeMs: number;
+        latestDeferredAgeMs: number;
+    };
+    ticks: number;
+    paints: number;
+    frameLoopSleeps: number;
+    frameLoop: {
+        running: boolean;
+        frameScheduled: boolean;
+        idleFrames: number;
+        foregroundSurfaceId: CompositorSurfaceId | null;
+        immediateDemand: boolean;
+        pendingDemandBackingEpoch: number | null;
+        nativeFrameArmed: boolean;
+    };
+    demandPaintsSuperseded: number;
+    entryEvals: number;
+    count: number;
+    max: number;
+    avg: number;
+    over33: number;
+    over100: number;
+    displayClockPolicy: CompositorDisplayClockPolicy;
+    cadence: {
+        intervals: number;
+        p50: number;
+        p95: number;
+        max: number;
+        gaps: number;
+        phases: {
+            uninterruptedEngineEmpty: CompositorTimingSummary;
+            withCanvaskitFlush: CompositorTimingSummary;
+            afterCanvaskitFlush: CompositorTimingSummary;
+            queuedWithoutCanvaskitFlush: CompositorTimingSummary;
+        };
+        presentation: CompositorTimingSummary;
+        canvaskitSubmission: CompositorTimingSummary;
+        productionClock: {
+            displayTicks: number;
+            timerTicks: number;
+            producedDisplayFrames: number;
+            producedTimerFrames: number;
+            producedDemandFrames: number;
+            paintedDisplayFrames: number;
+            paintedTimerFrames: number;
+            paintedDemandFrames: number;
+            flushedDisplayFrames: number;
+            flushedTimerFrames: number;
+            flushedDemandFrames: number;
+            presentedDisplayFrames: number;
+            presentedTimerFrames: number;
+            presentedDemandFrames: number;
+            multiPaintClockIntervals: number;
+            multiPresentationClockIntervals: number;
+            productionFramesWithSlotDemand: number;
+            coalescedSlotWrites: number;
+        };
+        frameSeries: CompositorFramePhaseSample[];
+        scheduler: {
+            timerArms: number;
+            timerFires: number;
+            timerCancels: number;
+            demandWakes: number;
+            coalescedDemandWakes: number;
+            events: CompositorSchedulerEvent[];
+        };
+    };
+    production: CompositorProductionStats;
+    work: CompositorWorkSummary;
+    layout: {
+        adoptions: number;
+        yogaFallbacks: number;
+        unchangedTreeRepaints: number;
+        unchangedTreeSkips: number;
+    };
+    cull: {
+        examined: number;
+        kept: number;
+        skipped: number;
+    };
+    walkCensus: {
+        paints: number;
+        visits: Record<string, number>;
+        native: Record<string, number>;
+        clips: Record<string, number>;
+    } | null;
+    debug: {
+        paintBoundaryEvents: Array<{
+            t: number;
+            channel: 'paintBoundaries';
+            data: unknown;
+        }>;
+    } | null;
+    ambientGlow: {
+        active: boolean;
+        surfaceId: CompositorSurfaceId | null;
+        samples: number;
+        damageRejectedPaints: number;
+        bitmapFailures: number;
+        pendingDamageAreaRatio: number;
+    };
+    home: {
+        treeUpdatesReceived: number;
+        treeUpdatesApplied: number;
+        paints: number;
+        firstContentPaintedAt: number | null;
+    };
+    cursor: {
+        nodeId: number;
+        position: number;
+        opacity: number;
+        visible: boolean;
+        rect: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        } | null;
+        blinkTicks: number;
+        blinkPhaseMs: number | null;
+    } | null;
+    surfaces: CompositorSurfacePaintStats[];
+    appMotion: {
+        busy: boolean;
+        compositorMotionSurfaceIds: CompositorSurfaceId[];
+        pendingSurfaces: {
+            surfaceId: AuxAppSurfaceId;
+            reason: PendingSurfaceReason;
+        }[];
+    };
+    lottie: LottieOwnerDiagnostics;
+    surfacePrewarm: {
+        surfaces: number;
+        idleRealized: number;
+        bootRealized: number;
+        pending: number;
+        totalMs: number;
+        maxMs: number;
+        bootHomeMs: number;
+        attempts: number;
+        lastBlock: string;
+    } | null;
+    keyboardWarm: {
+        lastPaintAck: {
+            committedSeq: number | null;
+            acceptedSeq: number;
+        } | null;
+        requests: number;
+        grants: number;
+        denials: number;
+        paintAcks: number;
+        aborts: number;
+        ends: number;
+        active: boolean;
+        paintAttempts: number;
+        paints: number;
+        scratchCreates: number;
+        scratchReleases: number;
+        scratchMisses: number;
+    };
+    worldRealize: {
+        enabled: boolean;
+        passes: number;
+        realizeMs: number;
+        passLog: Array<{
+            surfaceId: CompositorSurfaceId;
+            bounds: [number, number, number, number] | null;
+            bytes: number;
+            records: number;
+            chunkReplays: number;
+            rasterPromotions: number;
+            rasterBlits: number;
+        }>;
+    };
+    settledIdleCache: {
+        delayMs: number;
+        cleanups: number;
+        attempts: number;
+        completions: number;
+        retries: number;
+        cancellations: number;
+        lockedCompletions: number;
+        reclaimedBytes: number;
+        totalMs: number;
+        maxMs: number;
+        inFlight: boolean;
+        lastBlock: SettledIdleCacheBlockReason;
+        last: SettledIdleCacheCleanupResult | null;
+    };
+    nativeFrame: {
+        armed: boolean;
+        arms: number;
+        ticks: number;
+        paintFrames: number;
+        handbacks: Record<string, number>;
+        lastBlock: string | null;
+        blocks: Record<string, number>;
+        walkCallbacks: number;
+    };
+    imageRealization: {
+        queued: number;
+        attempts: number;
+        pending: number;
+        realized: number;
+        mipmappedDraws: number;
+        cubicDraws: number;
+        repeatDraws: number;
+        exactDraws: number;
+        staleSurface: number;
+        staleGeneration: number;
+        staleNode: number;
+        staleRequest: number;
+        alreadyRealized: number;
+        droppedBudget: number;
+        deferredMotion: number;
+        failed: number;
+        draw: {
+            count: number;
+            totalMs: number;
+            maxMs: number;
+        };
+        flush: {
+            count: number;
+            totalMs: number;
+            maxMs: number;
+        };
+    };
+    glyphRealization: {
+        queued: number;
+        attempts: number;
+        pending: number;
+        realized: number;
+        staleSurface: number;
+        staleGeneration: number;
+        staleNode: number;
+        alreadyRealized: number;
+        droppedBudget: number;
+        deferredMotion: number;
+        failed: number;
+        draw: {
+            count: number;
+            totalMs: number;
+            maxMs: number;
+        };
+        flush: {
+            count: number;
+            totalMs: number;
+            maxMs: number;
+        };
+    };
+    appSurfaceLifecycle: {
+        liveAppSurfaces: number;
+        pendingPrewarms: number;
+        parkedCanvases: number;
+        parkedBackingPixels: number;
+        created: number;
+        coverPresents?: number;
+        disposed: number;
+        pausedReleases: number;
+        unboundReleases: number;
+        currentGenerationResumes: number;
+        releaseBlocks: {
+            snapshotMissing: number;
+            capturePending: number;
+        };
+        lastRelease: {
+            surfaceId: AuxAppSurfaceId;
+            generation: number;
+            appId: string | null;
+            reason: 'paused' | 'unbound';
+        } | null;
+        lastCurrentGenerationResume: {
+            surfaceId: AuxAppSurfaceId;
+            generation: number;
+            appId: string;
+        } | null;
+    };
+    styleProbe?: CompositorStyleProbe | null;
+    profile: unknown;
+    memory: unknown;
+    errors: {
+        count: number;
+        last: {
+            context: string;
+            message: string;
+            stack?: string;
+            t: number;
+        } | null;
+    };
+    scrollPresentation: {
+        presentedFrames: CompositorScrollTraceSample[];
+        registryEntries: number;
+        slotApplies: number;
+        dragInterpolations: number;
+        dragDeliveryBoundMs: number;
+        messageApplies: number;
+        momentumDrives: {
+            driveReceived: number;
+            cancelReceived: number;
+            rebaseReceived: number;
+            staleRejected: number;
+            begun: number;
+            done: number;
+            applies: number;
+            canceledMissingEntry: number;
+            active: number;
+        };
+        lastApplied: Array<{
+            surfaceId: AuxAppSurfaceId;
+            nodeId: number;
+            x: number;
+            y: number;
+            zoom: number;
+            refreshHolding: boolean;
+            refreshPullProgress: number;
+            edgeEffectMode: 'stretch' | null;
+            edgeReleasing: boolean;
+        }>;
+    };
+    animatedPresentation: {
+        registryEntries: number;
+        activeSurfaceIds: CompositorSurfaceId[];
+        laneRefusals: Record<string, number>;
+        slotApplies: number;
+        incoherentSkips: number;
+        graphSettledEntries: number;
+        messageApplies: number;
+        staleDrops: number;
+        entries: Array<{
+            surfaceId: CompositorSurfaceId;
+            generation: number;
+            viewTag: number;
+            targetExists: boolean;
+            dirty: boolean;
+            slotCount: number;
+            graphSlots: number;
+            objectKeys: readonly string[] | null;
+            styleKeys: readonly string[] | null;
+            boundaryRecords: number | null;
+            boundaryInvalidations: number | null;
+            boundaryNeedsContentRepaint: boolean | null;
+            opacity: number | null;
+            borderRadius: number | null;
+            globalX: number | null;
+            globalY: number | null;
+            width: number | null;
+            height: number | null;
+        }>;
+        layoutFrames: Array<{
+            surfaceId: AuxAppSurfaceId;
+            viewTag: number;
+            transitionId: number;
+            x: number;
+            y: number;
+            globalX: number;
+            globalY: number;
+            width: number;
+            height: number;
+        }>;
+        paintedPresentationFrames: Array<{
+            surfaceId: CompositorSurfaceId;
+            generation: number;
+            viewTag: number;
+            transitionId: number | null;
+            paint: number;
+            frameToken: number;
+            presentedAtEpochMs: number;
+            opacity: number | null;
+            globalX: number;
+            globalY: number;
+            width: number;
+            height: number;
+        }>;
+    };
+    screenTransitions: {
+        received: number;
+        staleGeneration: number;
+        missingSurface: number;
+        invalidDescriptor: number;
+        begun: number;
+        targetApplies: number;
+        targetChanges: number;
+        targetMisses: number;
+        paintedFrames: number;
+        endpointsSampled: number;
+        endpointsHeld: number;
+        endpointsPainted: number;
+        endpointsCommitted: number;
+        endpointsRetired: number;
+        endpointsNotified: number;
+        lastReceivedGeneration: number | null;
+        lastRuntimeGeneration: number | null;
+        active: number;
+    };
+    promotedLayers: {
+        promoted: number;
+        promotions: number;
+        demotions: number;
+        captureFailures: number;
+    };
+    snapshots: {
+        intervalMs: number;
+        requests: number;
+        pushes: number;
+        failures: number;
+        inFlight: number;
+        blurSource: {
+            appId: string;
+            surfaceId: BackdropSurfaceId;
+            generation: number;
+        } | null;
+        surfaces: Array<{
+            surfaceId: CompositorSurfaceId;
+            generation: number;
+            appId: string | null;
+            wantsBackdrop: boolean;
+            backdropDirty: boolean;
+            pending: number;
+            lastSnapshotMs: number;
+        }>;
+    };
+    images: ImageLoaderStats & {
+        totalCacheEntries: number;
+        memoryTrims: number;
+        gpuCacheBytes: number | null;
+    };
+    webViewCaptureSettled?: boolean;
+}
+export interface PromotedLayerOffer {
+    key: string;
+    surfaceId: CompositorSurfaceId;
+    z: number;
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    pivot: {
+        x: number;
+        y: number;
+    };
+    dpr: number;
+    bitmap: ImageBitmap;
+    graph: LinearLoopAnimationGraph;
+}
+export type CompositorHostToWorker = {
+    type: 'metalShaderCompile';
+    requestId: number;
+    request: MetalShaderCompileRequest;
+} | {
+    type: 'mountNativeWidget';
+    identity: NativeWidgetMount;
+    surface: CompositorSurfaceInit;
+    port: MessagePort;
+} | {
+    type: 'retireNativeWidget';
+    identity: NativeWidgetIdentity;
+} | {
+    type: 'webViewCaptureStream';
+    stream: ReadableStream<VideoFrame>;
+} | {
+    type: 'animationClock';
+    snapshot: AnimationClockSnapshot;
+} | {
+    type: 'promotedLayerShown';
+    key: string;
+} | {
+    type: 'init';
+    surfaces: CompositorSurfaceInit[];
+    treePort: MessagePort;
+    workletSAB?: SharedArrayBuffer;
+    uiFrameSAB?: SharedArrayBuffer;
+    layoutSAB?: SharedArrayBuffer;
+    hostTimeOrigin: number;
+    pageDisplayClock?: SharedArrayBuffer;
+    animationClock: AnimationClockSnapshot;
+    fontUrls: string[];
+    fontBuffers?: Record<string, ArrayBuffer>;
+    nativeResourcesPort: MessagePort;
+    canvasKitWasmModule: WebAssembly.Module;
+    pipelineCache: GraphitePipelineCacheLoadResult;
+    pipelineHelpers: MessagePort[];
+    wireframe: boolean;
+    initUrl: string;
+    headlessPresentation: boolean;
+    resourceBudgetScale: number;
+    colorScheme: 'light' | 'dark';
+    reactNativeConfiguration: ReactNativeConfigurationSnapshot;
+    deviceSpec: DeviceSpec;
+    localStorageEntries: Array<[string, string]>;
+} | {
+    type: 'start';
+} | {
+    type: 'stop';
+} | {
+    type: 'stepFrame';
+    requestId: number;
+    now: number;
+    awaitPageShown: boolean;
+} | {
+    type: 'lockstepMode';
+    epochMs: number | null;
+} | {
+    type: 'forceRender';
+    captureRequestId?: number;
+} | {
+    type: 'forceRender';
+    captureRequestId: number;
+    present: true;
+} | {
+    type: 'forceRender';
+    captureRequestId: number;
+    reuseSettledPixels: true;
+} | {
+    type: 'prepareWindowRotation';
+    requestId: number;
+} | {
+    type: 'beginWindowRotation';
+    rotation: NativeInterfaceRotation;
+} | {
+    type: 'startWindowRotation';
+    startedAt: number;
+    duration: number;
+} | {
+    type: 'endWindowRotation';
+} | {
+    type: 'waitForDisplayPresentation';
+    requestId: number;
+    surfaceIds: CompositorSurfaceId[];
+} | {
+    type: 'cancelDisplayPresentation';
+    requestId: number;
+} | {
+    type: 'beginCapturePublicationBarrier';
+    requestId: number;
+    origins: CapturePublicationOrigin[];
+} | {
+    type: 'cancelCapturePublicationBarrier';
+    requestId: number;
+} | {
+    type: 'ping';
+    nonce: number;
+} | {
+    type: 'captureSurfaces';
+    requestId: number;
+    surfaceIds: CompositorSurfaceId[];
+    scale?: number;
+    directImage?: boolean;
+    region?: CompositorGpuRegion;
+    presentedFrames?: number | 'all';
+    presentedBeforeEpochMs?: number;
+    format?: PresentedFrameCaptureFormat;
+    suppressText?: SootSimCaptureOptions['suppressText'];
+    captureFilter?: SootSimCaptureOptions['captureFilter'];
+} | ({
+    type: 'dump';
+    requestId: number;
+} & (CompositorCadenceRequest | {
+    detail?: 'full';
+    resetCull?: boolean;
+    includeMemory?: boolean;
+    styleTestID?: string;
+    imageAudit?: 'enable' | 'read' | 'disable';
+    textPaint?: TextPaintReceiptRequest;
+    hasFileUri?: string;
+})) | {
+    type: 'captureGraphitePipelines';
+    requestId: number;
+} | {
+    type: 'startScrollTrace';
+    requestId: number;
+    limit?: number;
+    pressTestID?: string;
+    layoutTestID?: string;
+} | {
+    type: 'stopScrollTrace';
+    requestId: number;
+} | {
+    type: 'pointer';
+    phase: 'down' | 'move' | 'up' | 'cancel';
+    surfaceId: CompositorSurfaceId;
+    t: number;
+    x: number;
+    y: number;
+} | {
+    type: 'profileStart';
+    requestId: number;
+    renderProfile: boolean;
+    presentationCapture?: PresentedFrameCaptureOptions;
+    nativeReceipts?: boolean;
+} | {
+    type: 'profileStop';
+    requestId: number;
+} | {
+    type: 'trimMemory';
+    keepFraction: number;
+} | {
+    type: 'imageGetSize';
+    requestId: number;
+    uri: string;
+    headers?: Record<string, string>;
+} | {
+    type: 'imagePrefetch';
+    requestId: number;
+    uri: string;
+    imageRequestId?: number;
+    exactCacheKey?: string;
+    headers?: Record<string, string>;
+} | {
+    type: 'imageStoreBytes';
+    requestId: number;
+    uri: string;
+    bytes: ArrayBuffer;
+    headers?: Record<string, string>;
+} | {
+    type: 'imageAbort';
+    requestId: number;
+    imageRequestId: number;
+} | {
+    type: 'imageQueryCache';
+    requestId: number;
+    uris: string[];
+} | {
+    type: 'colorScheme';
+    value: 'light' | 'dark';
+} | {
+    type: 'setReactNativeConfiguration';
+    configuration: ReactNativeConfigurationSnapshot;
+} | {
+    type: 'wireframe';
+    config: WireframeModeConfig | null;
+} | {
+    type: 'resize';
+    surfaces: CompositorSurfaceResize[];
+    deviceSpec: DeviceSpec;
+} | {
+    type: 'renderActivitySubscription';
+    active: boolean;
+} | {
+    type: 'ambientGlow';
+    active: boolean;
+} | {
+    type: 'frameBreakdown';
+    buffer: SharedArrayBuffer | null;
+} | {
+    type: 'debugChannels';
+    active: string[];
+};
+export type KeyboardWarmShellMessage = {
+    type: 'keyboardWarm';
+    phase: 'request' | 'ended';
+} | {
+    type: 'keyboardWarm';
+    phase: 'committed';
+    seq: number;
+};
+export type KeyboardWarmCompositorPhase = 'granted' | 'denied' | 'painted' | 'abort';
+export interface CompositorScrollRegistryEntry {
+    allocationId: string;
+    nodeId: number;
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    slotX: number;
+    slotY: number;
+    slotZoom: number;
+    slotVersion: number;
+    slotSampleTime: number;
+    slotDragStartTime: number;
+    slotPresentationDisplacementY: number;
+}
+export type ShellToCompositorMessage = {
+    type: 'screenCaptureProtection';
+    request: import('../capture/nativeScreenCaptureContract.d.ts').NativeScreenCaptureRequest;
+    active: boolean;
+    prevented: boolean;
+} | {
+    type: 'panRecognized';
+    epochMs: number;
+} | {
+    type: 'foldMotion';
+    active: boolean;
+} | EngineResourceResponse | WireSurfaceUpdate | {
+    type: 'shellInbox';
+    buffer: SharedArrayBuffer;
+} | {
+    type: 'nativeSurfaceRegistrations';
+    surfaces: import('../../../peach-globals/src/index.d.ts').NativeSurfaceRegistration[];
+} | {
+    type: 'webViewCaptureRegistrations';
+    views: import('./webview-capture-protocol.d.ts').WebViewCaptureRegistration[];
+} | {
+    type: 'webViewCaptureReady';
+    ready: boolean;
+} | {
+    type: 'webViewCaptureLowered';
+    instanceId: string;
+    sequence: number;
+} | {
+    type: 'webViewCaptureHostMotion';
+    source: 'pointer' | 'fold' | 'rotation';
+    active: boolean;
+} | ({
+    type: 'remoteFontRegister';
+} & RemoteFontRegistration) | {
+    type: 'capturePublicationBarrier';
+    requestId: number;
+    origin: CapturePublicationOrigin;
+    expectedVideoFrames?: number;
+} | {
+    type: 'shellAuthoredTreeUpdate';
+    update: WireSurfaceUpdate;
+    contentW: number;
+    contentH: number;
+    dpr: number;
+} | KeyboardWarmShellMessage | {
+    type: 'editMenuMirror';
+    payload: import('./text-inputContract.d.ts').EditMenuBridgeEvent;
+} | WorkerStorageSyncMessage | {
+    type: 'surfaceState';
+    backdropSurfaceId: BackdropSurfaceId | null;
+    snapshotOwners: import('../engine/snapshot-cache-policy.d.ts').AppSnapshotOwner[];
+    surfaces: Array<{
+        surfaceId: AuxAppSurfaceId;
+        appId: string | null;
+        generation: number;
+        paused: boolean;
+        wantsChromeLuminance: boolean;
+    }>;
+} | {
+    type: 'foregroundSurface';
+    surfaceId: CompositorSurfaceId | null;
+} | {
+    type: 'appMotion';
+    busy: boolean;
+} | {
+    type: 'uiFrameDemand';
+    wanted: boolean;
+} | {
+    type: 'pipelineWarmApp';
+    appId: string | null;
+    warmPipelines?: readonly string[];
+} | {
+    type: 'pipelineWarmScreen';
+    appId: string;
+    bundleRevision: string | null;
+    route: string;
+    state: string;
+    idle: boolean;
+} | {
+    type: 'layoutTick';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+} | {
+    type: 'insertSharedTransitionContainer';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    wire: WireElementNode;
+    layout: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} | {
+    type: 'releaseRetainedRemoval';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    viewTag: number;
+} | {
+    type: 'registerAppFonts';
+    requestId?: number;
+    specs: readonly AppFontWireSpec[];
+} | {
+    type: 'rasterizeSvgResult';
+    requestId: number;
+    pngBytes: ArrayBuffer | null;
+} | {
+    type: 'captureSnapshot';
+    surfaceId: AuxAppSurfaceId;
+    appId?: string;
+    requestId?: number;
+    scale?: number;
+} | {
+    type: 'captureViewShot';
+    surfaceId: AuxAppSurfaceId;
+    requestId: number;
+    spec: ViewShotCaptureSpec;
+} | {
+    type: 'scrollRegistry';
+    retirements?: import('./scroll-mirror.d.ts').ScrollSlotRetirement[];
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    entries: CompositorScrollRegistryEntry[];
+} | {
+    type: 'animatedPresentation';
+    surfaceId: CompositorSurfaceId;
+    generation: number;
+    viewTag: number;
+    slotVersion: number;
+    slotOwner: number;
+    template: unknown;
+    lease?: AnimatedDrivenStyleLease;
+    graphs?: CompositorAnimatedSlotGraph[];
+} | {
+    type: 'animatedPresentationChanged';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+} | {
+    type: 'animatedDriveCreate';
+    drive: number;
+    surfaceId: AuxAppSurfaceId;
+    root: NativeAnimationGraphNode | CSSKeyframesDrive;
+    valueIds: number[];
+    valueSlots: number[];
+    versionSlot: number;
+    lowPriority: boolean;
+    presentationOnly?: boolean;
+} | {
+    type: 'animatedDriveStop';
+    drive: number;
+    retirementId: number;
+} | {
+    type: 'animatedDriveVisibility';
+    drive: number;
+    visible: boolean;
+} | {
+    type: 'clearAnimatedPresentation';
+    surfaceId: CompositorSurfaceId;
+    generation: number;
+    viewTag: number;
+    retirementId: number;
+    slotVersion: number;
+    tenantEndpoint?: Record<string, unknown>;
+} | {
+    type: 'cursorMirror';
+    surfaceId: CompositorSurfaceId;
+    generation: number;
+    payload: CursorBridgeEvent;
+} | {
+    type: 'loupeMirror';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    payload: import('./text-inputContract.d.ts').LoupeState;
+} | {
+    type: 'scrollPresentationChanged';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    effects: CompositorScrollEffectPresentation[];
+} | {
+    type: 'animatedProps';
+    surfaceId: CompositorSurfaceId;
+    generation: number;
+    viewTag: number;
+    updates: Record<string, unknown>;
+    lease?: AnimatedDrivenStyleLease;
+} | {
+    type: 'retireAnimatedDrivenStyle';
+    surfaceId: CompositorSurfaceId;
+    generation: number;
+    viewTag: number;
+    retirementId: number;
+    retirement: AnimatedDrivenStyleRetirement;
+} | {
+    type: 'screenTransitionDrive';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    descriptor: ScreenTransitionDriveDescriptor;
+} | {
+    type: 'screenTransitionCardTargetsRetired';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    stackId: number;
+    transitionId: number;
+    viewTags: number[];
+} | {
+    type: 'screenTransitionEntrySettled';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    stackId: number;
+    transitionId: number;
+} | {
+    type: 'screenTransitionCancel';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    stackId: number;
+    hold: boolean;
+} | {
+    type: 'lottieIntent';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    intent: LottieIntent;
+} | ({
+    type: 'scrollMomentumDrive';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+} & ScrollMomentumDriveDescriptor) | {
+    type: 'scrollIndicatorFlash';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    nodeId: number;
+} | {
+    type: 'scrollMomentumCancel';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    nodeId: number;
+    driveId: number;
+} | {
+    type: 'scrollMomentumRebase';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    nodeId: number;
+    driveId: number;
+    min: number;
+    max: number;
+    offsetShift?: number;
+    nestedScrollExtentChain?: ScrollMomentumExtentNode[];
+} | {
+    type: 'liveFrameMirror';
+    surfaceId: CompositorSurfaceId;
+    generation: number;
+    payload: LiveFrameMirrorEnvelope;
+} | {
+    type: 'tenantLiveFramePort';
+    port: MessagePort;
+};
+export type ShellCompositorInboxMessage = Extract<ShellToCompositorMessage, WireSurfaceUpdate | {
+    type: 'appMotion' | 'retireAnimatedDrivenStyle';
+}>;
+export declare function isShellCompositorInboxMessage(message: ShellToCompositorMessage): message is ShellCompositorInboxMessage;
+export type CompositorWorkerToHost = {
+    type: 'metalShaderCompileResult';
+    requestId: number;
+    response: MetalShaderCompileResponse;
+} | {
+    type: 'nativeWindowOwnership';
+    ownership: NativeWindowOwnership | null;
+} | {
+    type: 'displayClockDemand';
+    active: boolean;
+} | ({
+    type: 'promotedLayerOffer';
+} & PromotedLayerOffer) | {
+    type: 'promotedLayerRetire';
+    key: string;
+} | {
+    type: 'bootstrapped';
+} | {
+    type: 'ready';
+    adapter: GraphiteAdapterIdentity;
+} | {
+    type: 'profileStarted';
+    requestId: number;
+} | {
+    type: 'profileStopped';
+    requestId: number;
+} | {
+    type: 'bootMark';
+    mark: SootsimBootMark;
+} | {
+    type: 'firstContentPainted';
+    surfaceId: CompositorSurfaceId;
+    atEpochMs: number;
+} | {
+    type: 'renderActivity';
+    busy: boolean;
+    frameToken: number;
+} | {
+    type: 'liveFrameMotion';
+    active: boolean;
+} | {
+    type: 'ambientGlowSample';
+    bitmap: ImageBitmap;
+} | {
+    type: 'capturePublicationProgress';
+    requestId: number;
+    origin: CapturePublicationOrigin;
+} | {
+    type: 'capturePublicationReady';
+    requestId: number;
+} | {
+    type: 'displayPresentationReady';
+    requestId: number;
+    frameToken: number;
+} | {
+    type: 'windowRotationPrepared';
+    requestId: number;
+} | {
+    type: 'forceRenderDone';
+    requestId: number;
+    frameToken: number;
+} | ({
+    type: 'stats';
+    requestId: number;
+    detail: 'full';
+} & CompositorStats) | ({
+    type: 'stats';
+    requestId: number;
+    detail: 'cadence';
+} & CompositorCadenceStats) | {
+    type: 'stats';
+    requestId: number;
+    detail: 'error';
+    error: string;
+} | {
+    type: 'graphitePipelineCapture';
+    requestId: number;
+    bytes?: ArrayBuffer;
+    error?: string;
+} | {
+    type: 'scrollTraceStarted';
+    requestId: number;
+} | {
+    type: 'scrollTraceStopped';
+    requestId: number;
+    samples: CompositorTraceSample[];
+} | {
+    type: 'error';
+    context: string;
+    message: string;
+    stack?: string;
+} | {
+    type: 'fatal';
+    reason: CompositorFatalReason;
+    message: string;
+    stack?: string;
+} | {
+    type: 'heartbeat';
+    count: number;
+    paints: number;
+} | {
+    type: 'pong';
+    nonce: number;
+} | {
+    type: 'captureSurfacesResult';
+    requestId: number;
+    surfaces: CompositorCapturedSurface[];
+    pixelSurfaces?: CompositorCapturedPixelSurface[];
+    hashedSurfaces?: CompositorCapturedFrameHash[];
+    unavailableSurfaceIds: CompositorSurfaceId[];
+    failures: CompositorSurfaceCaptureFailure[];
+} | {
+    type: 'stepFrameDone';
+    requestId: number;
+    frameToken: number;
+} | {
+    type: 'imageGetSizeResult';
+    requestId: number;
+    size?: {
+        width: number;
+        height: number;
+    };
+    error?: string;
+} | {
+    type: 'imageStoreBytesResult';
+    requestId: number;
+    error?: string;
+} | {
+    type: 'imagePrefetchResult';
+    requestId: number;
+    loaded: boolean;
+    error?: string;
+} | {
+    type: 'imageAbortResult';
+    requestId: number;
+    aborted: boolean;
+    error?: string;
+} | {
+    type: 'imageQueryCacheResult';
+    requestId: number;
+    entries: Record<string, 'memory'>;
+    error?: string;
+};
+export type CompositorToShellMessage = {
+    type: 'screenCaptureProtectionApplied';
+    request: import('../capture/nativeScreenCaptureContract.d.ts').NativeScreenCaptureRequest;
+} | {
+    type: 'uiFrame';
+    epochMs: number;
+} | EngineResourceRequest | {
+    type: 'shellInboxAccepted';
+} | {
+    type: 'keyboardWarm';
+    phase: KeyboardWarmCompositorPhase;
+} | {
+    type: 'webViewFrameReady';
+    instanceId: string;
+} | {
+    type: 'webViewCaptureFailed';
+} | {
+    type: 'webViewCaptureTarget';
+    target: import('./webview-capture-protocol.d.ts').WebViewCaptureTarget;
+} | {
+    type: 'nativeSurfacePresented';
+    presentation: import('../../../peach-globals/src/index.d.ts').NativeSurfacePresented;
+} | {
+    type: 'webViewLower';
+    instanceId: string;
+    sequence: number;
+} | {
+    type: 'liveFrameConsumed';
+    channelId: string;
+    remoteFrame?: LiveFrameMirrorEnvelope['remoteFrame'];
+} | {
+    type: 'tenantLiveFrameCaptureBarrier';
+    requestId: number;
+} | {
+    type: 'surfaceTreePainted';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    seq: number;
+} | {
+    type: 'requestSurfaceResync';
+    surfaceId: AuxAppSurfaceId;
+} | {
+    type: 'appFontsRegistered';
+    requestId: number;
+    ok: boolean;
+} | {
+    type: 'requestShellSurfaceResync';
+    surfaceId: ShellAuthoredSurfaceId;
+} | {
+    type: 'screenTransitionStarted';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    stackId: number;
+    transitionId: number;
+} | {
+    type: 'screenTransitionClock';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    stackId: number;
+    transitionId: number;
+    startedAt: number;
+    backCapsulePulseStartedAt: number;
+} | {
+    type: 'screenTransitionProgress';
+    event: import('../../../peach-kit/src/runtime.d.ts').ScreenTransitionProgress;
+    reportProgress?: boolean;
+    shared?: {
+        screenTag: number;
+        progress: number;
+        finished: boolean;
+    };
+} | {
+    type: 'screenTransitionDone';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    stackId: number;
+    transitionId: number;
+    dropped: boolean;
+} | {
+    type: 'screenTransitionLanded';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    stackId: number;
+    transitionId: number;
+} | {
+    type: 'scrollMomentumPresented';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    nodeId: number;
+    driveId: number;
+    phase: 'step' | 'done' | 'refused' | 'canceled';
+    velocity: number;
+    chain: ScrollMomentumDriveNode[];
+} | {
+    type: 'chromeLuminance';
+    surfaceId: AuxAppSurfaceId;
+    statusBarDark?: boolean;
+    homeIndicatorDark?: boolean;
+} | {
+    type: 'snapshot';
+    lease: number;
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    appId: string;
+    requestId?: number;
+    width: number;
+    height: number;
+    scale: number;
+} | {
+    type: 'cursorRectBack';
+    surfaceId: CompositorSurfaceId;
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+} | {
+    type: 'snapshotsReleased';
+    owners: import('../engine/snapshot-cache-policy.d.ts').AppSnapshotOwner[];
+} | {
+    type: 'imageLifecycleEvent';
+    event: ImageLifecycleEvent;
+} | {
+    type: 'lottieLifecycleEvent';
+    event: LottieLifecycleEvent;
+} | {
+    type: 'rasterizeSvgRequest';
+    requestId: number;
+    bytes: ArrayBuffer;
+    targetWidth: number;
+    targetHeight: number;
+} | {
+    type: 'viewShotResult';
+    requestId: number;
+    result: ViewShotCaptureResultSpec;
+} | {
+    type: 'shellSurfaceFirstContentPainted';
+    surfaceId: ShellAuthoredSurfaceId;
+    t: number;
+} | {
+    type: 'editMenuRectsBack';
+    barRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    itemRects: EditMenuItemRect[];
+} | {
+    type: 'appLaunchPainted';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    appId: string;
+} | {
+    type: 'appLaunchInvalidated';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    appId: string | null;
+} | {
+    type: 'appContentPainted';
+    surfaceId: AuxAppSurfaceId;
+    generation: number;
+    appId: string;
+} | {
+    type: 'scrollSlotsRetired';
+    retirements: import('./scroll-mirror.d.ts').ScrollSlotRetirement[];
+} | {
+    type: 'animatedPresentationRetired';
+    retirementId: number;
+} | {
+    type: 'animatedDriveEnd';
+    drive: number;
+    values: number[];
+} | {
+    type: 'animatedDrivenStyleRetired';
+    surfaceId: CompositorSurfaceId;
+    generation: number;
+    viewTag: number;
+    retirementId: number;
+    retirement: AnimatedDrivenStyleRetirement;
+};
+export declare function isAuxAppSurfaceId(value: unknown): value is AuxAppSurfaceId;
+export declare function isBackdropSurfaceId(value: unknown): value is BackdropSurfaceId;
+export declare function isShellAuthoredSurfaceId(value: unknown): value is ShellAuthoredSurfaceId;
+export declare function isCompositorSurfaceId(value: unknown): value is CompositorSurfaceId;
+export declare function isAnimatedDriveCreateMessage(value: unknown): value is Extract<ShellToCompositorMessage, {
+    type: 'animatedDriveCreate';
+}>;
+export declare function isSharedTransitionContainerMessage(value: unknown): value is Extract<ShellToCompositorMessage, {
+    type: 'insertSharedTransitionContainer';
+}>;