peachsim 0.1.1644 → 0.1.1653

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

@@ -0,0 +1,434 @@
+import { type SceneNativeBinding } from '../engine/scene-table.d.ts';
+import { buildGraphiteNativeProfileReport } from '../graphite-stats-fields.d.ts';
+import { GraphitePipelineCompiler } from './graphite-pipeline-compiler.d.ts';
+import type { CanvasKitRenderingApi } from '../engine/canvaskit-api.d.ts';
+import type { PipelineCompilerStats } from './graphite-pipeline-compiler-contract.d.ts';
+import type { CanvasKitInitOptions, Image as SkImage, RuntimeEffect, Surface } from 'canvaskit-wasm';
+export type WebGpuErrorScopeFilter = 'validation' | 'out-of-memory';
+export type CanvasKitGraphiteInitOptions = CanvasKitInitOptions;
+export interface GraphitePipelinePrecompileResult {
+    readonly status: 'seeded' | 'partial' | 'rejected' | 'absent';
+    readonly seeded: number;
+    readonly rejected: number;
+    readonly reason?: string;
+}
+export declare function initCanvasKitGraphiteModule(options: CanvasKitGraphiteInitOptions): Promise<GraphiteCanvasKitModule>;
+export type WebGpuErrorPort = GPUError;
+export type WebGpuDeviceLostInfoPort = unknown;
+export type WebGpuUncapturedErrorListener = (error: GPUError) => void;
+export type WebGpuTexturePort = GPUTexture;
+export type WebGpuBufferPort = GPUBuffer;
+export type WebGpuExternalImageSourcePort = GPUCopyExternalImageSource;
+export interface WebGpuExtent3DPort {
+    readonly width: number;
+    readonly height: number;
+    readonly depthOrArrayLayers?: number;
+}
+export interface WebGpuOrigin3DPort {
+    readonly x?: number;
+    readonly y?: number;
+    readonly z?: number;
+}
+export interface WebGpuImageCopyTexturePort {
+    readonly texture: GPUTexture;
+    readonly mipLevel?: number;
+    readonly origin?: WebGpuOrigin3DPort;
+}
+export interface WebGpuImageCopyBufferPort {
+    readonly buffer: GPUBuffer;
+    readonly offset?: number;
+    readonly bytesPerRow: number;
+    readonly rowsPerImage?: number;
+}
+export interface WebGpuImageCopyExternalImagePort {
+    readonly source: GPUCopyExternalImageSource;
+    readonly origin?: {
+        readonly x?: number;
+        readonly y?: number;
+    };
+    readonly flipY?: boolean;
+}
+export interface WebGpuImageCopyTextureTaggedPort extends WebGpuImageCopyTexturePort {
+    readonly colorSpace?: 'srgb';
+    readonly premultipliedAlpha?: boolean;
+}
+export type WebGpuCommandEncoderPort = Pick<GPUCommandEncoder, 'copyTextureToTexture' | 'copyTextureToBuffer' | 'finish'>;
+export type WebGpuQueuePort = Pick<GPUQueue, 'copyExternalImageToTexture' | 'writeTexture' | 'submit' | 'onSubmittedWorkDone'>;
+export interface WebGpuTextureDescriptorPort {
+    readonly label?: string;
+    readonly size: WebGpuExtent3DPort;
+    readonly format: GPUTextureFormat;
+    readonly usage: GPUTextureUsageFlags;
+    readonly sampleCount?: number;
+    readonly mipLevelCount?: number;
+    readonly dimension?: GPUTextureDimension;
+}
+export interface WebGpuBufferDescriptorPort {
+    readonly label?: string;
+    readonly size: number;
+    readonly usage: GPUBufferUsageFlags;
+    readonly mappedAtCreation?: boolean;
+}
+export interface WebGpuCommandEncoderDescriptorPort {
+    readonly label?: string;
+}
+export interface WebGpuDevicePort {
+    readonly queue: WebGpuQueuePort;
+    readonly lost: Promise<WebGpuDeviceLostInfoPort>;
+    createTexture(descriptor: WebGpuTextureDescriptorPort): GPUTexture;
+    createBuffer(descriptor: WebGpuBufferDescriptorPort): GPUBuffer;
+    createCommandEncoder(descriptor?: WebGpuCommandEncoderDescriptorPort): WebGpuCommandEncoderPort;
+    pushErrorScope(filter: WebGpuErrorScopeFilter): void;
+    popErrorScope(): Promise<GPUError | null>;
+    configureCanvas(context: WebGpuCanvasContextPort, configuration: WebGpuCanvasConfigurationPort): void;
+    addUncapturedErrorListener(listener: WebGpuUncapturedErrorListener): void;
+    removeUncapturedErrorListener(listener: WebGpuUncapturedErrorListener): void;
+}
+export type WebGpuCanvasConfigurationPort = Omit<GPUCanvasConfiguration, 'device'>;
+export type WebGpuCanvasContextPort = Pick<GPUCanvasContext, 'configure' | 'unconfigure' | 'getCurrentTexture'>;
+export type GraphiteNativeSurfacePort = Surface;
+export interface GraphiteResourceCacheStats {
+    readonly currentBudgetedBytes: number;
+    readonly currentPurgeableBytes: number;
+    readonly maxBudgetedBytes: number;
+    readonly contextCurrentBudgetedBytes: number;
+    readonly contextCurrentPurgeableBytes: number;
+    readonly contextMaxBudgetedBytes: number;
+    readonly recorderCurrentBudgetedBytes: number;
+    readonly recorderCurrentPurgeableBytes: number;
+    readonly recorderMaxBudgetedBytes: number;
+    readonly imageCacheMaxBytes: number;
+}
+export interface GraphiteResidencyBucket {
+    readonly type: string;
+    readonly label: string;
+    readonly count: number;
+    readonly bytes: number;
+    readonly bytesHeldByGpu: number;
+    readonly bytesHeldByClient: number;
+    readonly bytesHeldByBoth: number;
+    readonly bytesUnreferenced: number;
+}
+export interface GraphiteResidencyPool {
+    readonly buckets: readonly GraphiteResidencyBucket[];
+    readonly nonpurgeableBytes: number;
+    readonly purgeableBytes: number;
+    readonly budgetedBytes: number;
+    readonly maxBytes: number;
+    readonly nonpurgeableCount: number;
+    readonly purgeableCount: number;
+}
+export interface GraphiteResidencyReport {
+    readonly context: GraphiteResidencyPool;
+    readonly recorder: GraphiteResidencyPool;
+}
+export interface GraphiteNativeDeviceStats extends GraphiteResourceCacheStats {
+    readonly deviceIdentityChecks: number;
+    readonly queueIdentityChecks: number;
+    readonly recordingSnapshots: number;
+    readonly recorderSnapCpuMicros: number;
+    readonly recordingInsertions: number;
+    readonly recordingInsertionCpuMicros: number;
+    readonly recordingSubmissions: number;
+    readonly commandBufferFinishes: number;
+    readonly commandBufferFinishCpuMicros: number;
+    readonly queueSubmissions: number;
+    readonly queueSubmissionCpuMicros: number;
+    readonly encodedRenderPasses: number;
+    readonly encodedRenderPassCommands: number;
+    readonly encodedDrawCommands: number;
+    readonly submitFailures: number;
+    readonly cleanupRequests: number;
+    readonly cleanupFreedBytes: number;
+    readonly freeGpuResourcesCalls: number;
+    readonly imageCacheHits: number;
+    readonly imageCacheMisses: number;
+    readonly imageCacheUploads: number;
+    readonly imageCacheEvictions: number;
+    readonly imageCacheBytes: number;
+    readonly imageCacheEntries: number;
+    readonly shaderModuleCreations: number;
+    readonly renderPipelineCreations: number;
+    readonly shaderModuleCreationCpuMicros: number;
+    readonly renderPipelineCreationCpuMicros: number;
+    readonly pipelineCacheHits: number;
+    readonly pipelineCacheMisses: number;
+    readonly precompiledPipelineHits: number;
+    readonly capturedPipelines: number;
+    readonly unserializablePipelines: number;
+    readonly precompiledPipelinesLoaded: number;
+    readonly precompiledPipelinesRejected: number;
+    readonly asyncPipelineCompilesStarted: number;
+    readonly asyncPipelineCompilesFinished: number;
+    readonly asyncPipelineCompilesFailed: number;
+    readonly asyncPipelineCompilesPending: number;
+    readonly pendingPipelineFallbacks: number;
+    readonly pipelineCreationCpuMicros: number;
+    readonly submissionsCompleted: number;
+    readonly submissionGpuLatencyMicros: number;
+    readonly submissionGpuLatencyMaxMicros: number;
+    readonly submissionsRetired: number;
+    readonly submissionRetireLagMicros: number;
+    readonly submissionRetireLagMaxMicros: number;
+    readonly submissionGpuLatencyUnder1Ms: number;
+    readonly submissionGpuLatencyUnder2Ms: number;
+    readonly submissionGpuLatencyUnder4Ms: number;
+    readonly submissionGpuLatencyUnder8Ms: number;
+    readonly submissionGpuLatencyUnder17Ms: number;
+    readonly submissionGpuLatencyUnder33Ms: number;
+    readonly submissionGpuLatencyOver33Ms: number;
+    readonly submissionDepthSamples: number;
+    readonly submissionDepthSum: number;
+    readonly submissionDepthMax: number;
+    readonly submissionDepth0: number;
+    readonly submissionDepth1: number;
+    readonly submissionDepth2: number;
+    readonly submissionDepth3: number;
+    readonly submissionDepth4: number;
+    readonly submissionDepth5: number;
+    readonly submissionDepth6Plus: number;
+    readonly insertCommandBufferSetupCpuMicros: number;
+    readonly insertDeferredTargetSetupCpuMicros: number;
+    readonly insertLazyProxyInstantiationCpuMicros: number;
+    readonly insertAddCommandsCpuMicros: number;
+    readonly replayBeginRenderPassCalls: number;
+    readonly replayBeginRenderPassCpuMicros: number;
+    readonly replayPipelineLookupCalls: number;
+    readonly replayPipelineLookupCpuMicros: number;
+    readonly replayTextureBindGroupCalls: number;
+    readonly replayTextureBindGroupCpuMicros: number;
+    readonly replayUniformBindGroupCalls: number;
+    readonly replayUniformBindGroupCpuMicros: number;
+    readonly replayDynamicBufferWriteCalls: number;
+    readonly replayDynamicBufferWriteCpuMicros: number;
+    readonly replayInstrumentationEnabled: boolean;
+    readonly deviceLost: boolean;
+    readonly sameDeviceVerified: boolean;
+    readonly sameQueueVerified: boolean;
+}
+export interface GraphiteNativeOutstandingSubmissionPoll {
+    readonly outstandingDepth: number;
+    readonly submissionsCompleted: number;
+    readonly submissionsRetired: number;
+    readonly deviceLost: boolean;
+}
+export interface GraphiteNativeProfileMaxima {
+    readonly submissionGpuLatencyMaxMicros: number;
+    readonly submissionRetireLagMaxMicros: number;
+    readonly submissionDepthMax: number;
+}
+declare const graphiteNativeProfileCounterNames: ("asyncPipelineCompilesFailed" | "asyncPipelineCompilesFinished" | "asyncPipelineCompilesStarted" | "capturedPipelines" | "cleanupFreedBytes" | "cleanupRequests" | "commandBufferFinishCpuMicros" | "commandBufferFinishes" | "deviceIdentityChecks" | "encodedDrawCommands" | "encodedRenderPassCommands" | "encodedRenderPasses" | "freeGpuResourcesCalls" | "imageCacheEvictions" | "imageCacheHits" | "imageCacheMisses" | "imageCacheUploads" | "insertAddCommandsCpuMicros" | "insertCommandBufferSetupCpuMicros" | "insertDeferredTargetSetupCpuMicros" | "insertLazyProxyInstantiationCpuMicros" | "pipelineCacheHits" | "pipelineCacheMisses" | "pipelineCreationCpuMicros" | "precompiledPipelineHits" | "precompiledPipelinesLoaded" | "precompiledPipelinesRejected" | "queueIdentityChecks" | "queueSubmissionCpuMicros" | "queueSubmissions" | "recorderSnapCpuMicros" | "recordingInsertionCpuMicros" | "recordingInsertions" | "recordingSnapshots" | "recordingSubmissions" | "renderPipelineCreationCpuMicros" | "renderPipelineCreations" | "replayBeginRenderPassCalls" | "replayBeginRenderPassCpuMicros" | "replayDynamicBufferWriteCalls" | "replayDynamicBufferWriteCpuMicros" | "replayPipelineLookupCalls" | "replayPipelineLookupCpuMicros" | "replayTextureBindGroupCalls" | "replayTextureBindGroupCpuMicros" | "replayUniformBindGroupCalls" | "replayUniformBindGroupCpuMicros" | "shaderModuleCreationCpuMicros" | "shaderModuleCreations" | "submissionDepth0" | "submissionDepth1" | "submissionDepth2" | "submissionDepth3" | "submissionDepth4" | "submissionDepth5" | "submissionDepth6Plus" | "submissionDepthSamples" | "submissionDepthSum" | "submissionGpuLatencyMicros" | "submissionGpuLatencyOver33Ms" | "submissionGpuLatencyUnder17Ms" | "submissionGpuLatencyUnder1Ms" | "submissionGpuLatencyUnder2Ms" | "submissionGpuLatencyUnder33Ms" | "submissionGpuLatencyUnder4Ms" | "submissionGpuLatencyUnder8Ms" | "submissionRetireLagMicros" | "submissionsCompleted" | "submissionsRetired" | "submitFailures" | "unserializablePipelines")[];
+export type GraphiteNativeProfileCounters = Pick<GraphiteNativeDeviceStats, (typeof graphiteNativeProfileCounterNames)[number]>;
+export interface GraphiteNativeProfileBoundary {
+    readonly deviceIdentity: number;
+    readonly outstandingDepth: number;
+    readonly submissionsCompleted: number;
+    readonly submissionsRetired: number;
+    readonly pollCpuMs: number;
+}
+export interface GraphiteNativeProfileMeasurement {
+    readonly activeAtStop: true;
+    readonly sameDevice: true;
+    readonly window: {
+        readonly counters: GraphiteNativeProfileCounters;
+        readonly maxima: GraphiteNativeProfileMaxima & {
+            readonly polledOutstandingDepth: number;
+        };
+        readonly start: GraphiteNativeProfileBoundary;
+        readonly end: GraphiteNativeProfileBoundary;
+        readonly pollCpu: {
+            readonly count: number;
+            readonly totalMs: number;
+            readonly p50Ms: number;
+            readonly p95Ms: number;
+            readonly maxMs: number;
+        };
+        readonly pollDepthHistogram: {
+            readonly d0: number;
+            readonly d1: number;
+            readonly d2: number;
+            readonly d3: number;
+            readonly d4: number;
+            readonly d5: number;
+            readonly d6Plus: number;
+        };
+        readonly pollFailures: number;
+        readonly pollsWithCompletedUnretired: number;
+        readonly maxCompletedMinusRetired: number;
+    };
+    readonly lifetime: GraphiteNativeDeviceStats;
+}
+export interface GraphiteOutstandingSubmissionPoll {
+    readonly outstandingDepth: number;
+    readonly submissionsCompleted: number;
+    readonly submissionsRetired: number;
+    readonly cpuMs: number;
+}
+export { buildGraphiteNativeProfileReport };
+export interface GraphiteRecordingSubmission {
+    readonly submitted: boolean;
+    readonly insertedRecordings: number;
+    readonly approximateMaskDraws: number;
+}
+export interface GraphiteNativeTextureSurfaceOptions {
+    readonly width: number;
+    readonly height: number;
+    readonly format: GPUTextureFormat;
+    readonly colorSpace: 'srgb';
+    readonly alphaType: 'premul';
+    readonly sampleCount: 1;
+}
+export interface GraphiteNativeDeviceContextPort {
+    submitRecording(): GraphiteRecordingSubmission;
+    setWholeMaskResampling(enabled: boolean): void;
+    getStats(): GraphiteNativeDeviceStats;
+    residencyReport(): GraphiteResidencyReport;
+    setReplayInstrumentationEnabled(enabled: boolean): void;
+    checkAsyncWorkCompletion(): boolean;
+    hasPendingPipelineCompiles(): boolean;
+    pollOutstandingSubmissionDepth(): GraphiteNativeOutstandingSubmissionPoll;
+    beginProfileMeasurement(): void;
+    finishProfileMeasurement(): GraphiteNativeProfileMaxima;
+    setResourceCacheMaxBytes(bytes: number): void;
+    performDeferredCleanup(ageMs: number): void;
+    freeGpuResources(): void;
+    isDeviceLost(): boolean;
+    capturePipelineBlobs(): Uint8Array;
+    precompilePipelines(data: Uint8Array): number;
+    warmPipelines(data: Uint8Array): number;
+    delete(): void;
+}
+export interface GraphiteCanvasKitApi extends SceneNativeBinding {
+    MakeGraphiteDeviceContext(device: GPUDevice, knownRuntimeEffects: readonly RuntimeEffect[]): GraphiteNativeDeviceContextPort | null;
+    MakeGPUTextureSurface(context: GraphiteNativeDeviceContextPort, texture: WebGpuTexturePort, format: GPUTextureFormat, width: number, height: number): Surface | null;
+    MakeGPUTextureImage(context: GraphiteNativeDeviceContextPort, texture: WebGpuTexturePort, format: GPUTextureFormat, width: number, height: number, opaque: boolean, onRelease?: () => void): SkImage | null;
+}
+export type GraphiteCanvasKitModule = CanvasKitRenderingApi & GraphiteCanvasKitApi;
+export declare function requireGraphiteCanvasKitModule(value: unknown): GraphiteCanvasKitModule;
+export type GraphiteTextureKind = 'backing' | 'presentation' | 'snapshot' | 'readback-source' | 'sample';
+export interface GraphiteTextureIdentity {
+    readonly surfaceId: string;
+    readonly generation: number;
+    readonly textureEpoch: number;
+}
+export interface GraphiteOwnedTexture {
+    readonly texture: WebGpuTexturePort;
+    readonly kind: GraphiteTextureKind;
+    readonly identity: GraphiteTextureIdentity;
+    readonly metadata: GraphiteTextureMetadata;
+}
+export interface GraphiteTextureMetadata {
+    readonly width: number;
+    readonly height: number;
+    readonly depthOrArrayLayers: number;
+    readonly format: GPUTextureFormat;
+    readonly usage: GPUTextureUsageFlags;
+    readonly sampleCount: number;
+}
+export interface GraphiteOwnedBuffer {
+    readonly buffer: WebGpuBufferPort;
+    readonly identity: GraphiteTextureIdentity;
+}
+export interface GraphiteTextureSurface {
+    readonly texture: GraphiteOwnedTexture;
+    readonly surface: GraphiteNativeSurfacePort;
+    readonly byteSize: number;
+    dispose(): void;
+}
+export interface GraphiteDeviceContextStats {
+    readonly state: 'active' | 'lost' | 'disposed';
+    readonly pipelineCompiler: PipelineCompilerStats;
+    readonly texturesCreated: number;
+    readonly presentationTexturesAcquired: number;
+    readonly buffersCreated: number;
+    readonly textureSurfacesCreated: number;
+    readonly textureSurfaceCreateFailures: number;
+    readonly recordingSubmitCalls: number;
+    readonly recordingSubmissions: number;
+    readonly insertedRecordings: number;
+    readonly budgetChanges: number;
+    readonly budgetMaintenanceRequests: number;
+    readonly freeGpuResourceRequests: number;
+    readonly uncapturedErrors: number;
+    readonly lastUncapturedError: string | null;
+    readonly cache: GraphiteResourceCacheStats;
+    readonly native: GraphiteNativeDeviceStats;
+    readonly nativeProfile: {
+        readonly active: boolean;
+        readonly completed: GraphiteNativeProfileMeasurement | null;
+    };
+}
+export interface WebGpuTextureUsageContract {
+    readonly copySource: number;
+    readonly copyDestination: number;
+}
+export interface GraphiteDeviceContextOptions {
+    readonly device: WebGpuDevicePort;
+    readonly programDevice: GPUDevice;
+    readonly pipelineCompiler: GraphitePipelineCompiler;
+    readonly nativeContext: GraphiteNativeDeviceContextPort;
+    readonly makeTextureSurface: (options: GraphiteNativeTextureSurfaceOptions & {
+        readonly texture: WebGpuTexturePort;
+    }) => Surface | null;
+    readonly textureUsage: WebGpuTextureUsageContract;
+}
+export declare class GraphiteDeviceContext {
+    #private;
+    readonly device: WebGpuDevicePort;
+    readonly programDevice: GPUDevice;
+    readonly nativeContext: GraphiteNativeDeviceContextPort;
+    readonly textureUsage: WebGpuTextureUsageContract;
+    constructor(options: GraphiteDeviceContextOptions);
+    get state(): 'active' | 'lost' | 'disposed';
+    assertActive(): void;
+    configurePresentationCanvas(canvasContext: WebGpuCanvasContextPort, configuration: WebGpuCanvasConfigurationPort): void;
+    acquirePresentationTexture(canvasContext: WebGpuCanvasContextPort, identity: GraphiteTextureIdentity, metadata: GraphiteTextureMetadata): GraphiteOwnedTexture;
+    currentPresentationTexture(canvasContext: WebGpuCanvasContextPort): GPUTexture;
+    createTexture(descriptor: WebGpuTextureDescriptorPort, kind: Exclude<GraphiteTextureKind, 'presentation'>, identity: GraphiteTextureIdentity): GraphiteOwnedTexture;
+    createBuffer(descriptor: WebGpuBufferDescriptorPort, identity: GraphiteTextureIdentity): GraphiteOwnedBuffer;
+    createTextureSurface(options: {
+        readonly kind?: 'snapshot';
+        readonly descriptor: WebGpuTextureDescriptorPort;
+        readonly identity: GraphiteTextureIdentity;
+        readonly width: number;
+        readonly height: number;
+        readonly format: GPUTextureFormat;
+        readonly byteSize: number;
+    }): GraphiteTextureSurface;
+    createPresentationSurface(texture: GraphiteOwnedTexture): GraphiteNativeSurfacePort;
+    assertOwnsTexture(texture: GraphiteOwnedTexture): void;
+    assertOwnsBuffer(buffer: GraphiteOwnedBuffer): void;
+    submitRecording(): GraphiteRecordingSubmission;
+    setResourceCacheMaxBytes(bytes: number): void;
+    enforceResourceCacheBudget(): void;
+    performDeferredCleanup(ageMs: number): void;
+    beginProfileMeasurement(): void;
+    pollOutstandingSubmissionDepth(): GraphiteOutstandingSubmissionPoll;
+    finishProfileMeasurement(): GraphiteNativeProfileMeasurement;
+    waitForSubmittedQueueCompletion(): Promise<boolean>;
+    displayPipelinesSettled(): Promise<void> | null;
+    pipelineCompilesPending(): boolean;
+    waitForPipelineCompiles(): Promise<boolean>;
+    waitForSubmittedWorkCompletion(): Promise<boolean>;
+    freeGpuResources(): void;
+    residencyReport(): GraphiteResidencyReport;
+    setReplayInstrumentationEnabled(enabled: boolean): void;
+    setWholeMaskResampling(enabled: boolean): void;
+    capturePipelineBlobs(): Uint8Array;
+    precompilePipelines(data: Uint8Array, priority?: 'foreground' | 'background'): Promise<GraphitePipelinePrecompileResult>;
+    releasePipelineCompiler(): void;
+    warmPipelines(data: Uint8Array): Promise<{
+        readonly warmed: number;
+        readonly rejected: number;
+        readonly reason?: string;
+    }>;
+    getStats(): GraphiteDeviceContextStats;
+    dispose(): void;
+}
+export interface CreateGraphiteDeviceContextOptions {
+    readonly canvasKit: GraphiteCanvasKitApi;
+    readonly device: GPUDevice;
+    readonly knownRuntimeEffects: readonly RuntimeEffect[];
+    readonly textureUsage: WebGpuTextureUsageContract;
+}
+export declare function createGraphiteDeviceContext(options: CreateGraphiteDeviceContextOptions): GraphiteDeviceContext;

package/dist-types/packages/peach-engine/src/render-worker/canvaskit-worker-init.d.ts

@@ -0,0 +1,12 @@
+import { configureNativeResources, type NativeResourceSuppliers } from '../engine/native-resources.d.ts';
+import type { CanvasKit, CanvasKitInitOptions } from 'canvaskit-wasm';
+export interface SharedCanvasKitInitOptions {
+    locateFile(file: string): string;
+    canvasKitWasmModule: WebAssembly.Module;
+    onWasmInstance?: (instance: WebAssembly.Instance) => void;
+    nativeResources: NativeResourceSuppliers;
+    reportSite?: boolean;
+}
+export type CanvasKitInitializer<T> = (opts: CanvasKitInitOptions) => Promise<T>;
+export declare function isCanvasKitRuntime(value: unknown): value is CanvasKit;
+export declare function initializeCanvasKit<T extends Pick<CanvasKit, '_peachSetIosTextMask' | '_peach_site_policy' | '_peach_site_unlisted' | 'Malloc' | 'Free'> & Parameters<typeof configureNativeResources>[0]>(initialize: CanvasKitInitializer<T>, opts: SharedCanvasKitInitOptions): Promise<T>;

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

@@ -0,0 +1,31 @@
+export type CompositorBackend = 'ganesh' | 'graphite';
+export type CompositorBackendOverride = CompositorBackend | null;
+export interface CompositorBackendAdmission {
+    readonly backend: CompositorBackend;
+    readonly requestedOverride: CompositorBackendOverride;
+    readonly webGpuApiAvailable: boolean;
+    readonly adapterAvailable: boolean | null;
+    readonly reason: 'adapter-available' | 'adapter-error' | 'adapter-unavailable' | 'forced-ganesh' | 'forced-graphite' | 'native-host-graphite' | 'webgpu-unavailable';
+    readonly adapterError?: string;
+}
+export type CompositorDeviceProbe = {
+    readonly webGpu: false;
+} | {
+    readonly webGpu: true;
+    readonly device: boolean;
+    readonly error?: string;
+};
+export interface CompositorBackendEnvironment {
+    readonly webGpuApiAvailable: boolean;
+    readonly nativeHost: boolean;
+    readonly probeDevice: () => Promise<CompositorDeviceProbe>;
+    readonly search: string;
+}
+
+export declare function readCompositorBackendOverride(search: string): CompositorBackendOverride;
+export declare function selectCompositorBackend(environment: CompositorBackendEnvironment): Promise<CompositorBackendAdmission>;
+export declare function renderCurrentCompositorBackendAdmissionExpression(): string;
+export declare function getCurrentCompositorBackendAdmission(): Promise<CompositorBackendAdmission>;
+export declare function selectCurrentCompositorBackend(): Promise<CompositorBackend>;
+export declare function admitSelectedCompositorWorkerBackend(backend: CompositorBackend): Promise<void>;
+export declare function takeAdmittedCompositorWorkerAdapter(): GPUAdapter;