peachsim 0.1.1641 → 0.1.1653

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

@@ -0,0 +1,202 @@
+import type { CanvasKitRenderingApi } from '../engine/canvaskit-api.d.ts';
+import type { SharedDeviceImageBridge } from '../engine/image-loader.d.ts';
+import type { CompositorCadenceStats, CompositorHostToWorker, CompositorStats, CompositorSurfaceId, GraphiteAdapterIdentity, GraphiteDeviceCacheSnapshot, ShellToCompositorMessage } from './compositor-protocol.d.ts';
+import type { GPUUploadTrace } from './compositor-protocol.d.ts';
+import type { WebGpuGraphiteSubmissionBudget } from './webgpu-frame-transaction.d.ts';
+import type { WebGpuReadbackKind } from './webgpu-readback-scheduler.d.ts';
+import type { FontMgr, Image as SkImage, Surface } from 'canvaskit-wasm';
+export type CompositorGpuBackendKind = 'graphite' | 'ganesh';
+export type CompositorFrameKind = 'display' | 'capture' | 'auxiliary';
+export type GpuFrameSource = 'display-frame' | 'demand-frame' | 'forced-display' | 'step-frame' | 'capture-batch' | 'capture-single' | 'prewarm-initial';
+export interface CompositorFrameOptions {
+    readonly kind: CompositorFrameKind;
+    readonly source: GpuFrameSource;
+    readonly present: boolean;
+    readonly label?: string;
+    readonly measure: boolean;
+}
+export interface CompositorFrameTimings {
+    readonly totalMs: number;
+    readonly textureUploadMs: number;
+    readonly gpuSubmitMs: number;
+    readonly compositeMs: number;
+    readonly captureMs: number;
+}
+export interface CompositorFrameResult {
+    readonly submitted: boolean;
+    readonly presentationCopies: number;
+    readonly approximateMaskDraws: number;
+    readonly timings: CompositorFrameTimings | null;
+}
+export interface CompositorFrameCompletion<T> {
+    readonly value: T;
+    readonly result: CompositorFrameResult;
+    readonly validation: Promise<void>;
+}
+export interface CompositorGpuAdmission {
+    readonly source: GpuFrameSource;
+}
+export type CompositorGpuAdmissionDecision = {
+    readonly status: 'admitted';
+    readonly admission: CompositorGpuAdmission;
+    readonly outstandingDepth: number;
+} | {
+    readonly status: 'deferred';
+    readonly outstandingDepth: number;
+};
+export interface CompositorGpuPixels {
+    readonly rgba: Uint8Array<ArrayBuffer>;
+    readonly width: number;
+    readonly height: number;
+}
+export interface CompositorGpuRegion {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface CompositorGpuReadbackRequest {
+    readonly kind: WebGpuReadbackKind;
+    readonly coalesceKey?: string;
+    readonly region: CompositorGpuRegion;
+}
+export type CompositorGpuRead = (target: CompositorGpuTarget, request: CompositorGpuReadbackRequest) => Promise<CompositorGpuPixels>;
+export interface CompositorGpuTarget {
+    readonly surface: Surface;
+    readonly width: number;
+    readonly height: number;
+    readonly generation: number;
+    readonly surfaceEpoch: number;
+    readonly textureEpoch: number;
+    readonly resolveDraws: (() => void) | undefined;
+}
+export interface CompositorDisplayLayout {
+    readonly dpr: number;
+    readonly contentW: number;
+    readonly contentH: number;
+}
+export interface CompositorGpuDisplay {
+    readonly surfaceId: CompositorSurfaceId;
+    readonly target: CompositorGpuTarget;
+}
+export type NativeFramePresenter = (mask: number, submitted: boolean) => void;
+export interface CompositorGpuFrame {
+    readonly present: boolean;
+    recordWork(target: CompositorGpuTarget): void;
+    recordProgramInput(target: CompositorGpuTarget): void;
+    readonly programPassCapacity: number;
+    runProgramPass(targets: readonly CompositorGpuTarget[], encode: (encoder: GPUCommandEncoder) => readonly GPUBuffer[]): void;
+    presentDisplay(display: CompositorGpuDisplay): void;
+    readPixels: CompositorGpuRead;
+    exportSurfaceImage(display: CompositorGpuDisplay): Promise<ImageBitmap>;
+    copySnapshot(target: CompositorGpuTarget, snapshot: {
+        readonly appId: string;
+        readonly width: number;
+        readonly height: number;
+    }, done: (committed: boolean) => void): void;
+    sampleThumbnail(display: CompositorGpuDisplay, size: {
+        readonly width: number;
+        readonly height: number;
+    }): Promise<ImageBitmap>;
+    retainThumbnail(display: CompositorGpuDisplay, size: {
+        readonly width: number;
+        readonly height: number;
+    }): CompositorGpuTarget;
+    noteFirstPaint(surfaceId: CompositorSurfaceId, generation: number): void;
+}
+export interface CompositorSettledCleanup {
+    readonly status: 'cleaned' | 'purgeable' | 'locked';
+    readonly durationMs: number;
+    readonly before: GraphiteDeviceCacheSnapshot;
+    readonly after: GraphiteDeviceCacheSnapshot;
+}
+export type PipelineWarmScreen = Extract<ShellToCompositorMessage, {
+    type: 'pipelineWarmScreen';
+}>;
+export interface CompositorGpuWarm {
+    start(): void;
+    receiveScreen(screen: PipelineWarmScreen): void;
+    setColorMode(mode: 'light' | 'dark' | 'system'): void;
+    prioritizeApp(appId: string | null, warmPipelines?: readonly string[]): void;
+    noteForegroundApp(appId: string | null): void;
+    noteClockFrame(clockAt: number): void;
+    noteClockParked(): void;
+    pumpIfQueued(): void;
+    notePaintFlushed(): void;
+}
+export interface CompositorGpuWarmDeps {
+    prewarmBlocked(): boolean;
+    finiteInteraction(): boolean;
+    foregroundAppMoving(): boolean;
+    appMotionBusy(): boolean;
+    foregroundAppId(): string | null;
+    fontMgr(): FontMgr | null;
+}
+export interface CompositorGpuBackend {
+    readonly kind: CompositorGpuBackendKind;
+    readonly adapter: GraphiteAdapterIdentity;
+    readonly lost: boolean;
+    readonly warm: CompositorGpuWarm;
+    readonly imageBridge: SharedDeviceImageBridge | null;
+    prepareDisplay(canvas: OffscreenCanvas, surfaceId: CompositorSurfaceId, layout: CompositorDisplayLayout): void;
+    createDisplay(canvas: OffscreenCanvas, surfaceId: CompositorSurfaceId, generation: number, layout: CompositorDisplayLayout): CompositorGpuDisplay;
+    resizeDisplay(display: CompositorGpuDisplay, generation: number, layout: CompositorDisplayLayout): void;
+    replaceDisplayTarget(display: CompositorGpuDisplay, generation: number): void;
+    releaseDisplay(display: CompositorGpuDisplay): void;
+    createScratch(display: CompositorGpuDisplay, generation: number, width: number, height: number): CompositorGpuTarget;
+    retireScratch(target: CompositorGpuTarget): void;
+    readonly programDevice: GPUDevice | null;
+    createProgramTarget(display: CompositorGpuDisplay, generation: number, width: number, height: number): CompositorGpuTarget;
+    programTexture(target: CompositorGpuTarget): GPUTexture;
+    targetImage(target: CompositorGpuTarget): SkImage;
+    readonly admissionLimit: number;
+    tryAdmit(source: GpuFrameSource, graphiteSubmissionBudget?: WebGpuGraphiteSubmissionBudget, defer?: boolean): CompositorGpuAdmissionDecision;
+    waitForAdmission(source: GpuFrameSource, stillWanted?: () => boolean, graphiteSubmissionBudget?: WebGpuGraphiteSubmissionBudget): Promise<CompositorGpuAdmission>;
+    failPendingAdmissions(error: Error): void;
+    runFrame<T>(admission: CompositorGpuAdmission, options: CompositorFrameOptions, record: (frame: CompositorGpuFrame) => T): CompositorFrameCompletion<T>;
+    nativeFramePresenter(displays: readonly CompositorGpuDisplay[], sample: (mask: number, read: CompositorGpuRead) => void, presentsToPage: () => boolean): NativeFramePresenter;
+    readonly currentFrame: CompositorGpuFrame | null;
+    submittedWorkDone(): Promise<void>;
+    withFullSurfaceReadbacks<T>(surfaceIds: readonly CompositorSurfaceId[], run: () => Promise<T>): Promise<T>;
+    readonly fullSurfaceReadbacksActive: boolean;
+    readonly readbacksInFlight: number;
+    cacheBudgetBytes(surfaceId: CompositorSurfaceId, physW: number, physH: number): number;
+    applyCacheBudgets(budgets: ReadonlyArray<readonly [CompositorGpuDisplay, number]>): void;
+    enforceCacheBudget(display: CompositorGpuDisplay): void;
+    cacheUsageBytes(display: CompositorGpuDisplay | null): number;
+    cacheLimitBytes(display: CompositorGpuDisplay): number;
+    readonly imageCacheLimitBytes: number;
+    settledCacheNeedsCleanup(): boolean;
+    waitForSettledWork(): Promise<boolean>;
+    cleanupSettledCaches(): CompositorSettledCleanup;
+    trimMemory(): Promise<boolean>;
+    capturePipelines(): Uint8Array;
+    displayUploads(display: CompositorGpuDisplay): GPUUploadTrace | null;
+    noteFrameSample(now: number): void;
+    resetProfile(): void;
+    readonly profileMeasurementActive: boolean;
+    beginProfileMeasurement(): void;
+    finishProfileMeasurement(): void;
+    cadenceStats(): Pick<CompositorCadenceStats, 'backend' | 'graphite'>;
+    stats(includeMemory: boolean): Pick<CompositorStats, 'backend' | 'graphite' | 'surfacePrewarm'>;
+}
+export interface CompositorGpuInit {
+    readonly message: Extract<CompositorHostToWorker, {
+        type: 'init';
+    }>;
+    readonly locateFile: (file: string) => string;
+    readonly nativeResources: Parameters<typeof import('./canvaskit-worker-init.d.ts').initializeCanvasKit>[1]['nativeResources'];
+    onWorkSettled(): void;
+    onDeviceLost(error: Error): void;
+}
+export interface CompositorGpuCreated {
+    readonly canvasKit: CanvasKitRenderingApi;
+    readonly gpu: CompositorGpuBackend;
+}
+export interface CompositorGpuModule<W extends CompositorGpuWarm> {
+    createWarm(deps: CompositorGpuWarmDeps): W;
+    create(init: CompositorGpuInit, warm: W): Promise<CompositorGpuCreated>;
+}
+export declare function installCompositorGpu<W extends CompositorGpuWarm>(module: CompositorGpuModule<W>): void;
+export declare function createInstalledCompositorWarm(deps: CompositorGpuWarmDeps): CompositorGpuWarm;
+export declare function createInstalledCompositorGpu(init: CompositorGpuInit): Promise<CompositorGpuCreated>;