peachsim 0.1.1644 → 0.1.1653

package/dist-types/packages/peach-engine/src/render-worker/shell-tree-inline-sources.d.ts

@@ -0,0 +1,13 @@
+import type { WireSurfaceUpdate } from './shell-tree-wire.d.ts';
+export interface WireInlineSources {
+    define?: Array<[id: number, uri: string]>;
+    release?: number[];
+}
+export declare class WireInlineSourceEncoder {
+    #private;
+    encode(update: WireSurfaceUpdate): WireSurfaceUpdate;
+}
+export declare class WireInlineSourceDecoder {
+    #private;
+    decode(update: WireSurfaceUpdate): void;
+}

package/dist-types/packages/peach-engine/src/render-worker/shell-tree-wire.d.ts

@@ -0,0 +1,87 @@
+import { type AnimatedDrivenStyleLease, type AnimatedDrivenStyleRetirement } from '../engine/animated-driven-style.d.ts';
+import { type LayoutSlotRead } from '../engine/layout-sab.d.ts';
+import { SootSimNode, SootSimTextNode } from '../engine/node.d.ts';
+import type { SootSimNodeType } from '../engine/types.d.ts';
+import type { LayoutAnimationConfig } from '../react-native/layout-animation.d.ts';
+import type { GraphPresentation } from './graph-linked-value.d.ts';
+import type { WireInlineSources } from './shell-tree-inline-sources.d.ts';
+export interface WireElementNode {
+    k: 0;
+    id: number;
+    type: SootSimNodeType;
+    props: Record<string, unknown>;
+    style?: Record<string, unknown>;
+    animDriven?: AnimatedDrivenStyleLease[];
+    animDrivenRetired?: AnimatedDrivenStyleRetirement[];
+    text?: string;
+    textFontScale?: number;
+    textLayout?: LayoutSlotRead & {
+        revision: number;
+    };
+    accessibilityTextScale?: number;
+    accessibilityBoldText?: boolean;
+    hidden?: true;
+    flattens?: true;
+    sharedTransitionBoundary?: true;
+    scrollX?: number;
+    scrollY?: number;
+    zoom?: number;
+    selectionStart?: number;
+    selectionEnd?: number;
+    selectionHandlesHidden?: true;
+    children: number[];
+    ls?: number;
+}
+export interface WireTextNode {
+    k: 1;
+    id: number;
+    text: string;
+    hidden?: true;
+}
+export type WireNode = WireElementNode | WireTextNode;
+export interface WireDelta {
+    full: boolean;
+    rootId: number | null;
+    upserts: WireNode[];
+    removed: number[];
+    exiting?: number[];
+    layoutCandidates?: number[];
+    coreLayoutAnimation?: LayoutAnimationConfig;
+    scrollOnly?: number[];
+}
+export type WireSurfaceUpdate = WireDelta & {
+    surfaceId: string;
+    layoutAnimationConfiguration?: Extract<import('./worklet-runtime.d.ts').WorkletMessage, {
+        type: 'layoutAnimationConfigureBatch';
+    }>;
+    contentReady?: true;
+    generation: number;
+    seq: number;
+    layoutRevision?: number;
+    graphPresentations?: GraphPresentation[];
+    graphPresentationEnds?: number[];
+    inlineSources?: WireInlineSources;
+};
+export declare function sanitizeProps(props: Record<string, unknown>, nodeType?: SootSimNodeType): Record<string, unknown>;
+export declare function sanitizeStyle(style: Record<string, unknown>): Record<string, unknown>;
+interface WireCacheEntry {
+    node: SootSimNode | SootSimTextNode;
+    wire: WireNode;
+    propsRef?: unknown;
+    styleEpoch?: number;
+    subtreeRevision: number;
+}
+export interface WireCache {
+    rootId: number | null;
+    entries: Map<number, WireCacheEntry>;
+}
+export type WireEchoKey = (node: SootSimNode, key: string) => boolean;
+export declare function serializeSurfaceTree(root: SootSimNode | null, prevCache?: WireCache, echoKey?: WireEchoKey, { slots, presentationNodes, }?: {
+    slots?: boolean;
+    presentationNodes?: Iterable<SootSimNode>;
+}): {
+    delta: WireDelta;
+    cache: WireCache;
+};
+export declare function freeLayoutSlotsForCache(cache: WireCache): void;
+export {};

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

@@ -0,0 +1,47 @@
+import type { SootSimTestBridge, SootSimTestBridgeArgs, SootSimTestBridgeMethod, SootSimTestBridgeResult } from '../../../peach-globals/src/index.d.ts';
+export type ShellTestBridgeMethod = 'debugSnapshot' | 'debugFind' | 'captureAccessibilityTree' | 'dumpAccessibilityTree' | 'dumpTree' | 'findAllByA11yState' | 'findAllByRole' | 'ancestorChainById' | 'ancestorChainByTestId' | 'findByHint' | 'findById' | 'findByLabel' | 'findByTestId' | 'findByText' | 'findByTextOrLabel' | 'findPressable' | 'getNodeCount' | 'getWindowNodeCount' | 'getSurfaceMetricsSnapshot' | 'getTreeQuietMs' | 'getGeometryRevision' | 'getCullStats' | 'getFontDebug' | 'getImageLoaderStats' | 'getPeerStats' | 'getWorkletSlotStats' | 'getShellGestureSeamDebug' | 'getShellPointerDebug' | 'getShellNativeAnimDebug' | 'getShellAnimatedGraphDebug' | 'getShellAuxPresentationDebug' | 'startShellChromeTrajectoryCapture' | 'markShellChromeTrajectoryPhase' | 'getShellChromeTrajectoryCapture' | 'getShellScrollInputDebug' | 'startScrollPerformanceTrace' | 'stopScrollPerformanceTrace' | 'getShellScrollState' | 'getShellCursorState' | 'getShellInspectSchedulingStats' | 'getShellReanimatedTrace' | 'getShellLayoutAnimationDebug' | 'getShellMirrorStyle' | 'getShellBackgroundPlaybackViewTags' | 'getShellChromeLuminance' | 'getShellSnapshotDebug' | 'recordShellPresentationWrites' | 'dispatchShellSensorSample' | 'getScrollMirrorDebug' | 'setShellMapperReleaseTestState' | 'setShellReanimatedTraceEnabled' | 'getShellFeatureFlagsSnapshot' | 'inspectAt' | 'inspectByNodeId' | 'inspectHoverAt' | 'inspectNeighbor' | 'inspectSetStyleOverride' | 'listAnimations' | 'listInspectable' | 'listSemanticInspectable' | 'inspectTree' | 'queryAll' | 'queryMatchingNodes' | 'observeTapTarget' | 'queryMountedShell' | 'queryTextCandidates' | 'replaceTextByTestId' | 'resolveTapTarget' | 'verifyTapTargetAt' | 'stopAnimation' | 'waitForScreenTransitions';
+export type ShellInspectBridgeMethod = Extract<SootSimTestBridgeMethod, 'inspectAt' | 'inspectHoverAt' | 'inspectByNodeId' | 'inspectNeighbor' | 'inspectSetStyleOverride' | 'inspectSetHandlerLogging' | 'listInspectable' | 'listSemanticInspectable' | 'inspectTree'>;
+type BridgeRequestType = 'testBridge' | 'shellTestBridge' | 'inspectRequest';
+type ShellOnlyTestBridgeArgs<Method extends string> = Method extends 'queryMountedShell' ? SootSimTestBridgeArgs<'queryAll'> : Method extends 'setShellMapperReleaseTestState' ? [testID: string, state: 'drive' | 'release'] : Method extends 'replaceTextByTestId' ? [testID: string, text: string] : Method extends 'startScrollPerformanceTrace' ? [limit?: number] : Method extends 'startShellChromeTrajectoryCapture' ? [testID: string, durationMs: number, relatedTestID?: string] : Method extends 'markShellChromeTrajectoryPhase' ? [phase: string] : Method extends 'getFontDebug' ? [family?: string, fontWeight?: unknown] : Method extends 'getShellScrollState' ? [id: string] : Method extends 'getShellMirrorStyle' ? [viewTag: number] : Method extends 'getShellSnapshotDebug' ? [reset?: boolean] : Method extends 'recordShellPresentationWrites' ? [action: 'start' | 'read' | 'drain' | 'stop'] : Method extends 'dispatchShellSensorSample' ? [
+    sensorType: number,
+    data: Record<string, number>,
+    eventTimestamp: number
+] : [];
+type ShellOnlyTestBridgeResult<Method extends string> = Method extends 'queryMountedShell' ? SootSimTestBridgeResult<'queryAll'> : Method extends 'setShellMapperReleaseTestState' ? boolean : Method extends 'replaceTextByTestId' ? boolean : Method extends 'stopScrollPerformanceTrace' ? import('../../../peach-globals/src/index.d.ts').SootSimScrollOffsetSample[] : Method extends 'getShellCursorState' ? unknown : Method extends 'getShellInspectSchedulingStats' ? unknown : Method extends 'recordShellPresentationWrites' ? number[] : Method extends 'dispatchShellSensorSample' ? number : Method extends 'getShellBackgroundPlaybackViewTags' ? number[] : unknown;
+type TestBridgeEnvelopeArgs<Method extends string> = Method extends SootSimTestBridgeMethod ? SootSimTestBridgeArgs<Method> : ShellOnlyTestBridgeArgs<Method>;
+export interface ShellTestBridgeOptions {
+    nativeUiOnly?: boolean;
+}
+export type ShellTestBridgeArgs<M extends ShellTestBridgeMethod> = M extends SootSimTestBridgeMethod ? SootSimTestBridgeArgs<M> : ShellOnlyTestBridgeArgs<M>;
+export type ShellTestBridgeResult<M extends ShellTestBridgeMethod> = M extends SootSimTestBridgeMethod ? SootSimTestBridgeResult<M> : ShellOnlyTestBridgeResult<M>;
+export declare function createTestBridgeProxy(call: (method: SootSimTestBridgeMethod, args: unknown[]) => Promise<unknown>): SootSimTestBridge;
+export interface TestBridgeEnvelope<Type extends BridgeRequestType, Method extends string = SootSimTestBridgeMethod> {
+    type: Type;
+    requestId: number;
+    deliveryEpochMs?: number;
+    method: Method;
+    args: TestBridgeEnvelopeArgs<Method>;
+    options?: Type extends 'shellTestBridge' ? ShellTestBridgeOptions : never;
+}
+export type TestBridgeRequest = {
+    [M in SootSimTestBridgeMethod]: TestBridgeEnvelope<'testBridge', M>;
+}[SootSimTestBridgeMethod];
+export type ShellTestBridgeRequest = {
+    [M in ShellTestBridgeMethod]: TestBridgeEnvelope<'shellTestBridge', M>;
+}[ShellTestBridgeMethod];
+export type ShellInspectBridgeRequest = {
+    [M in ShellInspectBridgeMethod]: TestBridgeEnvelope<'inspectRequest', M>;
+}[ShellInspectBridgeMethod];
+type TestBridgeRequestFor<M extends SootSimTestBridgeMethod> = Extract<TestBridgeRequest, {
+    method: M;
+}>;
+type ShellTestBridgeRequestFor<M extends ShellTestBridgeMethod> = Extract<ShellTestBridgeRequest, {
+    method: M;
+}>;
+type ShellInspectBridgeRequestFor<M extends ShellInspectBridgeMethod> = Extract<ShellInspectBridgeRequest, {
+    method: M;
+}>;
+export declare function createTestBridgeRequest<M extends SootSimTestBridgeMethod>(requestId: number, method: M, args: SootSimTestBridgeArgs<M>): TestBridgeRequestFor<M>;
+export declare function createShellTestBridgeRequest<M extends ShellTestBridgeMethod>(requestId: number, method: M, args: ShellTestBridgeArgs<M>, options?: ShellTestBridgeOptions): ShellTestBridgeRequestFor<M>;
+export declare function createShellInspectBridgeRequest<M extends ShellInspectBridgeMethod>(requestId: number, method: M, args: SootSimTestBridgeArgs<M>): ShellInspectBridgeRequestFor<M>;
+export {};

package/dist-types/packages/peach-engine/src/render-worker/text-inputContract.d.ts

@@ -0,0 +1,93 @@
+import type { EditMenuItemRect } from './edit-menu-geometry.d.ts';
+import type { WorkerHostNode } from './worker-input-runtime.d.ts';
+export interface KeyMods {
+    mod?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+}
+export interface TextInputRefinementOffset {
+    x: number;
+    y: number;
+}
+export interface TextInputTapContext {
+    refinementOffset: TextInputRefinementOffset | null;
+    duration: number;
+}
+export type TextInputCursorGranularity = 'character' | 'word';
+export type TextInputRefinementPlacement = (node: WorkerHostNode, x: number, y: number, granularity?: TextInputCursorGranularity) => boolean;
+export interface TextInputHoldInteraction {
+    textInputNode: WorkerHostNode | null;
+    textInputRefinementOffset: TextInputRefinementOffset | null;
+    textInputRefinementActive: boolean;
+    pointerDownX: number;
+    pointerDownY: number;
+    lastX: number;
+    lastY: number;
+    textInputLongPressTimer: ReturnType<typeof setTimeout> | null;
+    textInputLongPressActive: boolean;
+    longPressFired: boolean;
+}
+export interface LoupeState {
+    x: number;
+    y: number;
+    active: boolean;
+}
+export interface EditMenuItemSpec {
+    action: string;
+    label: string;
+    systemImage?: string;
+    symbolCodePoint?: number;
+    section?: number;
+    shelf?: boolean;
+    submenu?: boolean;
+    submenuSymbolCodePoint?: number;
+}
+export type EditMenuBridgeEvent = {
+    kind: 'set';
+    items: EditMenuItemSpec[];
+    anchor: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    expandedFrom: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    opensBelow: boolean | null;
+} | {
+    kind: 'clear';
+} | {
+    kind: 'rects';
+    barRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    itemRects: EditMenuItemRect[];
+};
+export type CursorBridgeEvent = {
+    kind: 'set';
+    nodeId: number;
+    position: number;
+} | {
+    kind: 'move';
+    position: number;
+} | {
+    kind: 'capture';
+    active: boolean;
+} | {
+    kind: 'clear';
+} | {
+    kind: 'rect';
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+};

package/dist-types/packages/peach-engine/src/render-worker/tree-sync-port.d.ts

@@ -0,0 +1,102 @@
+import type { RemoteFontRegistration } from '../engine/app-font-registry.d.ts';
+import type { ShellToCompositorMessage } from './compositor-protocol.d.ts';
+import type { LiveFrameMirrorEnvelope, RemoteLiveFrameIdentity } from './live-frame-mirror.d.ts';
+import type { NativeAnimMirrorEnvelope } from './nativeAnimMirrorContract.d.ts';
+import type { HostToWorker } from './protocol.d.ts';
+import type { ShellHostToWorker } from './shell-protocol.d.ts';
+import type { WireSurfaceUpdate } from './shell-tree-wire.d.ts';
+export type TenantToShellPeerMessage = Extract<ShellHostToWorker, {
+    type: 'worklet' | 'workletBatch' | 'scrollMirror' | 'scrollControl' | 'nativeUIRequest' | 'gestureSeamRequest' | 'gestureSeamRequestBatch' | 'nativeMenuGestureBegin' | 'cursorMirror' | 'editMenuMirror' | 'loupeMirror' | 'registerAppFonts' | 'requestEngineResource' | 'engineResource' | 'storageSync';
+}>;
+export type ShellToTenantPeerMessage = Extract<HostToWorker, {
+    type: 'worklet' | 'scrollControl' | 'scrollSlotsRetired' | 'gestureSeamEvent' | 'screenEdgeSwipeCommit' | 'shellScreenInteractive' | 'screenFormSheetCommit' | 'screenTransitionStarted' | 'screenTransitionProgress' | 'cursorRectBack' | 'editMenuRectsBack' | 'imageLifecycleEvent' | 'lottieLifecycleEvent' | 'appFontsRegistered' | 'engineResource' | 'requestEngineResource';
+}>;
+export declare function isTenantToShellPeerMessage(message: object): message is TenantToShellPeerMessage;
+export declare function isShellToTenantPeerMessage(message: object): message is ShellToTenantPeerMessage;
+export type TreeSyncPublishKind = 'commit' | 'dirty-frame' | 'resync';
+export type TreeSyncPortMessage = {
+    type: 'liveFramePort';
+    port: MessagePort;
+} | {
+    type: 'requestLiveFramePort';
+} | {
+    type: 'liveFrameCaptureBarrier';
+    requestId: number;
+} | {
+    type: 'remoteLiveFrame';
+    surfaceId: string;
+    generation: number;
+    payload: LiveFrameMirrorEnvelope;
+} | ({
+    type: 'remoteLiveFrameConsumed';
+} & RemoteLiveFrameIdentity) | {
+    type: 'shellTreeUpdate';
+    payload: WireSurfaceUpdate;
+    nativeAnimMirrors?: NativeAnimMirrorEnvelope[];
+    publishedAtEpochMs: number;
+    publishKind: TreeSyncPublishKind;
+} | {
+    type: 'requestSurfaceResync';
+    surfaceId: string;
+} | {
+    type: 'nativeAnimMirror';
+    envelope: NativeAnimMirrorEnvelope;
+} | ({
+    type: 'remoteFontRegister';
+} & RemoteFontRegistration) | {
+    type: 'surfaceTreeApplied';
+    surfaceId: string;
+    generation: number;
+    seq: number;
+} | {
+    type: 'surfaceTreePainted';
+    surfaceId: string;
+    generation: number;
+    seq: number;
+} | {
+    type: 'capturePublicationBarrier';
+    requestId: number;
+} | {
+    type: 'appMotion';
+    busy: boolean;
+} | Extract<ShellToCompositorMessage, {
+    type: 'pipelineWarmApp';
+}> | {
+    type: 'pipelineWarmScreen';
+    appId: string;
+    bundleRevision: string | null;
+    route: string;
+    state: string;
+    idle: boolean;
+} | {
+    type: 'surfaceLayoutTick';
+    surfaceId: string;
+    generation: number;
+};
+export interface UnchangedPaintAckGate {
+    readonly generation: number;
+    readonly superseded: {
+        readonly generation: number;
+        readonly seq: number;
+    } | undefined;
+    readonly acknowledged: {
+        readonly generation: number;
+        readonly seq: number;
+    } | undefined;
+    readonly needsPaint: boolean;
+}
+export declare function shouldAckUnchangedPaintImmediately(gate: UnchangedPaintAckGate): boolean;
+export interface SurfaceTreePaintAckState {
+    readonly accepted: SurfaceTreePaintAck | null;
+    readonly acknowledged: SurfaceTreePaintAck | null;
+}
+export interface SurfaceTreePaintAck {
+    readonly generation: number;
+    readonly seq: number;
+}
+export declare function createSurfaceTreePaintAcks<SurfaceId extends string>(postPainted: (surfaceId: SurfaceId, ack: SurfaceTreePaintAck) => void): {
+    snapshot(surfaceId: SurfaceId): SurfaceTreePaintAckState;
+    accept(surfaceId: SurfaceId, ack: SurfaceTreePaintAck): SurfaceTreePaintAck | undefined;
+    acknowledgeUnchanged(surfaceId: SurfaceId, ack: SurfaceTreePaintAck, superseded: SurfaceTreePaintAck | undefined, needsPaint: boolean): boolean;
+    acknowledgePainted(surfaceId: SurfaceId, generation: number): void;
+};

package/dist-types/packages/peach-engine/src/render-worker/webgpu-frame-transaction.d.ts

@@ -0,0 +1,292 @@
+import type { GraphiteDeviceContext, GraphiteOutstandingSubmissionPoll, GraphiteOwnedBuffer, GraphiteOwnedTexture, WebGpuErrorPort, WebGpuExternalImageSourcePort, WebGpuExtent3DPort, WebGpuImageCopyBufferPort, WebGpuImageCopyTexturePort, WebGpuOrigin3DPort } from './canvaskit-webgpu.d.ts';
+export type WebGpuFrameTransactionKind = 'display' | 'capture' | 'auxiliary';
+export type WebGpuFrameTransactionSource = 'display-frame' | 'demand-frame' | 'forced-display' | 'step-frame' | 'capture-batch' | 'capture-single' | 'prewarm-initial';
+export interface WebGpuFrameTransactionOptions {
+    readonly kind: WebGpuFrameTransactionKind;
+    readonly source: WebGpuFrameTransactionSource;
+    readonly present: boolean;
+    readonly label?: string;
+    readonly measureTimings?: boolean;
+}
+export declare const MAX_OUTSTANDING_GRAPHITE_SUBMISSIONS = 3;
+export interface WebGpuFrameAdmission {
+    readonly source: WebGpuFrameTransactionSource;
+    readonly poll: GraphiteOutstandingSubmissionPoll;
+    readonly graphiteSubmissionBudget: WebGpuGraphiteSubmissionBudget;
+    readonly admissionToken: never;
+}
+export type WebGpuGraphiteSubmissionBudget = number;
+export interface WebGpuFrameAdmissionOptions {
+    readonly graphiteSubmissionBudget?: WebGpuGraphiteSubmissionBudget;
+    readonly defer?: boolean;
+}
+export type WebGpuFrameAdmissionDecision = {
+    readonly status: 'admitted';
+    readonly admission: WebGpuFrameAdmission;
+    readonly poll: GraphiteOutstandingSubmissionPoll;
+} | {
+    readonly status: 'deferred';
+    readonly poll: GraphiteOutstandingSubmissionPoll;
+};
+export interface WebGpuFrameTransactionTimings {
+    readonly totalMs: number;
+    readonly textureUploadMs: number;
+    readonly gpuSubmitMs: number;
+    readonly compositeMs: number;
+    readonly captureMs: number;
+}
+export interface WebGpuTextureCopyOptions {
+    readonly kind: 'presentation' | 'snapshot' | 'bitmap';
+    readonly source: GraphiteOwnedTexture;
+    readonly destination: GraphiteOwnedTexture;
+    readonly sourceOrigin?: WebGpuOrigin3DPort;
+    readonly destinationOrigin?: WebGpuOrigin3DPort;
+    readonly size: WebGpuExtent3DPort;
+}
+export interface WebGpuTextureReadbackOptions {
+    readonly source: GraphiteOwnedTexture;
+    readonly destination: GraphiteOwnedBuffer;
+    readonly sourceOrigin?: WebGpuOrigin3DPort;
+    readonly destinationOffset?: number;
+    readonly bytesPerRow: number;
+    readonly rowsPerImage?: number;
+    readonly size: WebGpuExtent3DPort;
+}
+export interface WebGpuExternalImageUploadOptions {
+    readonly source: WebGpuExternalImageSourcePort;
+    readonly destination: GraphiteOwnedTexture;
+    readonly sourceOrigin?: {
+        readonly x?: number;
+        readonly y?: number;
+    };
+    readonly destinationOrigin?: WebGpuOrigin3DPort;
+    readonly flipY?: boolean;
+    readonly size: WebGpuExtent3DPort;
+}
+export interface WebGpuImagePixelUploadOptions {
+    readonly pixels: Uint8Array;
+    readonly destination: GraphiteOwnedTexture;
+    readonly size: WebGpuExtent3DPort;
+}
+export interface WebGpuRetirableResource {
+    readonly resourceKind: string;
+    readonly surfaceId: string;
+    readonly generation: number;
+    readonly surfaceEpoch: number;
+    readonly textureEpoch: number;
+    dispose(): void;
+}
+export interface WebGpuReadbackEncoding {
+    copyTextureToReadback(options: WebGpuTextureReadbackOptions): void;
+}
+export type WebGpuReadbackSubmission = Pick<WebGpuFrameTransactionResult, 'commandBatchSubmitted' | 'readbackCopies' | 'submissionSerial'>;
+export interface WebGpuFrameTransactionResult {
+    readonly kind: WebGpuFrameTransactionKind;
+    readonly present: boolean;
+    readonly graphiteSubmitted: boolean;
+    readonly insertedRecordings: number;
+    readonly approximateMaskDraws: number;
+    readonly commandBatchSubmitted: boolean;
+    readonly presentationCopies: number;
+    readonly snapshotCopies: number;
+    readonly readbackCopies: number;
+    readonly externalImageUploads: number;
+    readonly submissionSerial: number;
+    readonly timings: WebGpuFrameTransactionTimings | null;
+}
+export interface WebGpuFrameTransactionCompletion<T> {
+    readonly value: T;
+    readonly transaction: WebGpuFrameTransactionResult;
+    readonly validation: Promise<void>;
+}
+export interface WebGpuFrameTransactionSourceCounters {
+    readonly displayFrame: number;
+    readonly demandFrame: number;
+    readonly forcedDisplay: number;
+    readonly stepFrame: number;
+    readonly captureBatch: number;
+    readonly captureSingle: number;
+    readonly prewarmInitial: number;
+    readonly unclassified: number;
+}
+export interface WebGpuFrameTransactionMeasurementCounters {
+    readonly started: number;
+    readonly committed: number;
+    readonly aborted: number;
+    readonly displayTransactions: number;
+    readonly captureTransactions: number;
+    readonly auxiliaryTransactions: number;
+    readonly graphiteSubmitCalls: number;
+    readonly graphiteSubmissions: number;
+    readonly jsCommandBatches: number;
+    readonly presentationCopies: number;
+    readonly snapshotCopies: number;
+    readonly readbackCopies: number;
+    readonly sources: WebGpuFrameTransactionSourceCounters;
+    readonly admissionAttempts: number;
+    readonly admissions: number;
+    readonly admissionDeferrals: number;
+    readonly admissionSources: WebGpuFrameTransactionSourceCounters;
+    readonly admissionDeferralSources: WebGpuFrameTransactionSourceCounters;
+}
+export interface WebGpuFrameTransactionProfileMeasurement {
+    readonly activeAtStop: true;
+    readonly window: WebGpuFrameTransactionMeasurementCounters;
+    readonly lifetime: WebGpuFrameTransactionMeasurementCounters;
+}
+export interface WebGpuFrameTransactionCounters {
+    readonly admissionLimit: number;
+    readonly admissionAttempts: number;
+    readonly admissions: number;
+    readonly admissionDeferrals: number;
+    readonly admissionTokenRejected: number;
+    readonly admissionWaiters: number;
+    readonly admissionTaskYields: number;
+    readonly admissionWaitCompletions: number;
+    readonly admissionWaitRejections: number;
+    readonly currentAdmissionDepth: number;
+    readonly maximumAdmissionDepth: number;
+    readonly started: number;
+    readonly committed: number;
+    readonly aborted: number;
+    readonly nestingRejected: number;
+    readonly displayTransactions: number;
+    readonly captureTransactions: number;
+    readonly auxiliaryTransactions: number;
+    readonly graphiteSubmitCalls: number;
+    readonly graphiteSubmissions: number;
+    readonly jsCommandBatches: number;
+    readonly presentationCopies: number;
+    readonly snapshotCopies: number;
+    readonly readbackCopies: number;
+    readonly externalImageUploads: number;
+    readonly externalImageUploadBytes: number;
+    readonly externalImageCleanupRequests: number;
+    readonly externalImageCleanupCompletions: number;
+    readonly externalImageCleanupCancellations: number;
+    readonly externalImageCleanupFailures: number;
+    readonly externalImageCleanupPending: number;
+    readonly externalImageCleanupTotalMs: number;
+    readonly externalImageCleanupMaxMs: number;
+    readonly externalImageCleanupLastMs: number;
+    readonly submissionCompletionRequests: number;
+    readonly submissionCompletionCompletions: number;
+    readonly submissionCompletionFailures: number;
+    readonly submissionCompletionPending: number;
+    readonly presentFalseTransactions: number;
+    readonly errorScopeFailures: number;
+    readonly lastErrorScopeMessage: string | null;
+    readonly retireQueued: number;
+    readonly retireDeferred: number;
+    readonly retireDisposed: number;
+    readonly retireDuplicateRejected: number;
+    readonly retireWaitFailures: number;
+    readonly retireDisposeFailures: number;
+    readonly pendingRetirements: number;
+    readonly submissionSerial: number;
+    readonly completedSubmissionSerial: number;
+    readonly sources: WebGpuFrameTransactionSourceCounters;
+    readonly admissionSources: WebGpuFrameTransactionSourceCounters;
+    readonly admissionDeferralSources: WebGpuFrameTransactionSourceCounters;
+    readonly profile: {
+        readonly active: boolean;
+        readonly completed: WebGpuFrameTransactionProfileMeasurement | null;
+    };
+}
+interface TextureCopyCommand {
+    readonly type: 'texture-to-texture';
+    readonly kind: 'presentation' | 'snapshot' | 'bitmap';
+    readonly source: WebGpuImageCopyTexturePort;
+    readonly destination: WebGpuImageCopyTexturePort;
+    readonly size: WebGpuExtent3DPort;
+}
+interface TextureReadbackCommand {
+    readonly type: 'texture-to-buffer';
+    readonly source: WebGpuImageCopyTexturePort;
+    readonly destination: WebGpuImageCopyBufferPort;
+    readonly size: WebGpuExtent3DPort;
+}
+type FrameCommand = TextureCopyCommand | TextureReadbackCommand;
+type ImageUpload = ({
+    readonly kind: 'external';
+} & WebGpuExternalImageUploadOptions) | ({
+    readonly kind: 'pixels';
+} & WebGpuImagePixelUploadOptions);
+export declare class WebGpuTransactionError extends Error {
+    readonly scopeErrors: readonly WebGpuErrorPort[];
+    constructor(message: string, scopeErrors: readonly WebGpuErrorPort[], cause?: unknown);
+}
+export declare class WebGpuFrameTransaction {
+    #private;
+    constructor(owner: WebGpuFrameTransactionOwner, options: WebGpuFrameTransactionOptions, graphiteSubmissionBudget: WebGpuGraphiteSubmissionBudget);
+    get present(): boolean;
+    get measureTimings(): boolean;
+    get graphiteSubmissionBudget(): WebGpuGraphiteSubmissionBudget;
+    get label(): string | undefined;
+    recordGraphiteWork(...textures: readonly GraphiteOwnedTexture[]): void;
+    recordGraphitePassInput(...textures: readonly GraphiteOwnedTexture[]): void;
+    runWebGpuPass(textures: readonly GraphiteOwnedTexture[], encode: (encoder: GPUCommandEncoder) => void): void;
+    copyTexture(options: WebGpuTextureCopyOptions): void;
+    copyTextureToReadback(options: WebGpuTextureReadbackOptions): void;
+    copyExternalImageToTexture(options: WebGpuExternalImageUploadOptions): void;
+    writeImagePixels(options: WebGpuImagePixelUploadOptions): void;
+    close(): void;
+    get graphiteWorkRecorded(): boolean;
+    get graphiteWorkVersion(): number;
+    get graphiteWorkPending(): boolean;
+    get graphiteSubmitCalls(): number;
+    noteGraphiteSubmitCall(): void;
+    get externalImageUploadsPending(): readonly ImageUpload[];
+    get commandsPending(): readonly FrameCommand[];
+    get graphiteSubmitted(): boolean;
+    get insertedRecordings(): number;
+    get approximateMaskDraws(): number;
+    get commandBatchSubmitted(): boolean;
+    get queueWorkSubmitted(): boolean;
+    get submissionSerialAdvanced(): boolean;
+    get shaderPassesSubmitted(): number;
+    get graphiteCompositionRecorded(): boolean;
+    get externalImageUploadsSubmitted(): number;
+    get externalImageUploadBytesSubmitted(): number;
+    get transactionTimings(): Pick<WebGpuFrameTransactionTimings, 'textureUploadMs' | 'gpuSubmitMs' | 'compositeMs' | 'captureMs'>;
+    noteGraphiteRecordingSubmitted(workVersion: number, submitted: boolean, insertedRecordings: number, approximateMaskDraws: number, elapsedMs: number): void;
+    noteExternalImageUploadSubmitted(upload: ImageUpload, elapsedMs: number): void;
+    noteWebGpuPassSubmitted(commandCount: number, elapsedMs: number): void;
+    noteCommandBatchSubmitted(commandCount: number): void;
+    noteSubmissionSerialAdvanced(): void;
+    noteCommandTiming(kind: 'composite' | 'capture', elapsedMs: number): void;
+    noteCommandBatchTiming(elapsedMs: number): void;
+    get commands(): readonly FrameCommand[];
+    get externalImageUploads(): readonly ImageUpload[];
+    get presentationCopies(): number;
+    get snapshotCopies(): number;
+    get readbackCopies(): number;
+}
+export declare class NativeFrameReadbacks implements WebGpuReadbackEncoding {
+    #private;
+    readonly commands: TextureReadbackCommand[];
+    constructor(deviceContext: GraphiteDeviceContext);
+    copyTextureToReadback(options: WebGpuTextureReadbackOptions): void;
+}
+export declare class WebGpuFrameTransactionOwner {
+    #private;
+    readonly deviceContext: GraphiteDeviceContext;
+    constructor(deviceContext: GraphiteDeviceContext, onTransactionCommitted: () => void);
+    tryAcquireAdmission(source: WebGpuFrameTransactionSource, options?: WebGpuFrameAdmissionOptions): WebGpuFrameAdmissionDecision;
+    waitForAdmission(source: WebGpuFrameTransactionSource, requestStillCurrent?: () => boolean, options?: WebGpuFrameAdmissionOptions): Promise<WebGpuFrameAdmission>;
+    failPendingAdmissions(error: Error): void;
+    runSync<T>(admission: WebGpuFrameAdmission, options: WebGpuFrameTransactionOptions, record: (transaction: WebGpuFrameTransaction) => T): WebGpuFrameTransactionCompletion<T>;
+    run<T>(admission: WebGpuFrameAdmission, options: WebGpuFrameTransactionOptions, record: (transaction: WebGpuFrameTransaction) => T | Promise<T>): Promise<{
+        readonly value: T;
+        readonly transaction: WebGpuFrameTransactionResult;
+    }>;
+    runWebGpuPass(transaction: WebGpuFrameTransaction, textures: readonly GraphiteOwnedTexture[], encode: (encoder: GPUCommandEncoder) => void): void;
+    retireWhenSubmitted(resource: WebGpuRetirableResource): void;
+    waitForRetirements(): Promise<void>;
+    waitForErrorScopes(): Promise<void>;
+    beginProfileMeasurement(): void;
+    finishProfileMeasurement(): WebGpuFrameTransactionProfileMeasurement;
+    getCounters(): WebGpuFrameTransactionCounters;
+    commitNativeFrame(submitted: boolean, copies: number, readbackCopies: number): WebGpuReadbackSubmission;
+}
+export {};