peachsim 0.1.1644 → 0.1.1653

package/dist-types/packages/peach-engine/src/engine/layout-sab.d.ts

@@ -0,0 +1,43 @@
+export declare function createLayoutSAB(capacity?: number): SharedArrayBuffer;
+export declare function attachLayoutSAB(sab: SharedArrayBuffer, role: 'tenant' | 'shell' | 'compositor'): void;
+export declare function isLayoutSABAttached(): boolean;
+export declare function isLayoutSABWriter(): boolean;
+export declare function allocLayoutSlot(tag: number): number;
+export declare function freeLayoutSlot(slot: number, expectedTag: number): void;
+export declare function setLayoutSlotParent(slot: number, parent: number): void;
+export declare function setLayoutSlotParents(parents: ReadonlyMap<number, number>): void;
+export declare function readLayoutSubtreeRevision(slot: number, tag: number): number;
+export declare function writeLayoutSlot(slot: number, tag: number, x: number, y: number, width: number, height: number, textRevision?: number): void;
+export declare function getLayoutSlotWriteCount(): number;
+export interface LayoutSlotRead {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function readLayoutSlot(slot: number, tag: number, out: LayoutSlotRead, textRevision?: number): boolean;
+interface SlottedNode {
+    id: number;
+    __viewTag?: number;
+    _layoutSlot?: number;
+    _receivedTextLayoutRevision?: number;
+    layout: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    parent: SlottedNode | null;
+}
+export declare function layoutSlotTag(node: {
+    id: number;
+    __viewTag?: number;
+}): number;
+export declare function adoptNodeLayoutChainFromSAB(node: SlottedNode): boolean;
+export declare const __LAYOUT_SAB_INTERNALS: {
+    LAYOUT_SAB_MAGIC: number;
+    HEADER_LANES: number;
+    ENTRY_LANES: number;
+    DEFAULT_LAYOUT_CAPACITY: number;
+};
+export {};

package/dist-types/packages/peach-engine/src/engine/liquid-glass-rect.d.ts

@@ -0,0 +1,23 @@
+import type { SootSimStyle } from './types.d.ts';
+export declare const LIQUID_GLASS_MERGE_MEMBERS = 8;
+export declare function resolveAnimatedLiquidGlassRect(rect: SootSimStyle['_liquidGlassRect']): Parameters<typeof liquidGlassRectExtent>[0] | null | undefined;
+export declare function liquidGlassRectExtent(rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    merge?: {
+        spacing: number;
+        members: ReadonlyArray<{
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }>;
+    };
+}): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};

package/dist-types/packages/peach-engine/src/engine/liquid-glass-shaders.d.ts

@@ -0,0 +1,9 @@
+export type LiquidGlassType = 'clear' | 'regular';
+export type LiquidGlassRgba = [number, number, number, number];
+export declare const DEFAULT_LIQUID_GLASS_EDGE_AMBIENT = 0.1;
+export declare const LIGHT_DEFAULT_TINT: Record<LiquidGlassType, LiquidGlassRgba>;
+export declare const LIGHT_DEFAULT_DARK_TINT: Record<LiquidGlassType, LiquidGlassRgba>;
+export declare const DARK_DEFAULT_TINT: Record<LiquidGlassType, LiquidGlassRgba>;
+export declare const DARK_DEFAULT_DARK_TINT: Record<LiquidGlassType, LiquidGlassRgba>;
+export declare const LIQUID_GLASS_EDGE_LIGHTING_SKSL: string;
+export declare const LIQUID_GLASS_SKSL: string;

package/dist-types/packages/peach-engine/src/engine/liquid-glass.d.ts

@@ -0,0 +1,283 @@
+import { type DamageRect } from './damage-rect.d.ts';
+import { type GlassInteractionGlow, type GlassMotionScope, type GlassShapeArrow, type GlassShape, type GlassStyle } from './glass-material.d.ts';
+import { resolveAnimatedLiquidGlassRect } from './liquid-glass-rect.d.ts';
+import { type LiquidGlassType } from './liquid-glass-shaders.d.ts';
+import { type FrameDamage } from './render-damage.d.ts';
+import type { CanvasKitRenderingApi as CanvasKit } from './canvaskit-api.d.ts';
+import type { SootSimLensFold } from './types.d.ts';
+import type { Canvas, Surface, RuntimeEffect, Image as SkImage, Shader } from 'canvaskit-wasm';
+type LiquidGlassColorScheme = 'auto' | 'light' | 'dark';
+type ResolvedGlassColorScheme = 'light' | 'dark';
+export declare const DEFAULT_LIQUID_GLASS_CAPTURE_PADDING = 22;
+export declare function glassMaterialDraws<Config extends Pick<LiquidGlassConfig, 'material' | 'adaptiveForeground' | 'glassTint' | 'glassBodyTint'>>(config: Config): config is Config & {
+    material: GlassStyle;
+};
+export declare function liquidGlassCapturePadding(config: Pick<LiquidGlassConfig, 'capturePadding' | 'material' | 'interactionIntensity'>, width: number, height: number): number;
+export interface LiquidGlassRimLighting {
+    ambient: number;
+    key: number;
+    kick: number;
+    tail?: number;
+    lobe?: number;
+    endShare?: number;
+    endReach?: [number, number];
+    topReach?: [number, number, number, number];
+    lobeBody?: boolean;
+    baseSlope?: number;
+    baseChannels?: boolean;
+    chromaLift?: number;
+}
+export interface LiquidGlassLensOptics {
+    refractionDisplacement: number;
+    reflectionDisplacementX: number;
+    reflectionDirection: number;
+    reflectionEdgeEnd: number;
+    reflectionOpacity: number;
+    reflectionSharpness: number;
+    reflectionPersistence: number;
+}
+export interface TenantGlassBackdrop {
+    image: SkImage;
+    pixelsPerSurfacePixel: number;
+}
+export interface LiquidGlassConfig {
+    material?: GlassStyle;
+    materialization?: number;
+    materialTint?: {
+        gain: number;
+        bias: number;
+        opacity: number;
+    };
+    type?: LiquidGlassType;
+    colorScheme?: LiquidGlassColorScheme;
+    backdropSource?: 'tenant';
+    staticBackdrop?: boolean;
+    tintColor?: [number, number, number, number];
+    tintColorDark?: [number, number, number, number];
+    darkTintColor?: [number, number, number, number];
+    glassTint?: [number, number, number, number];
+    glassBodyTint?: [number, number, number, number];
+    tintShade?: {
+        light: [number, number];
+        dark: [number, number];
+    };
+    blurSigma?: number;
+    cornerRadius?: number;
+    cornerRadii?: [number, number, number, number];
+    shapeArrow?: GlassShapeArrow;
+    clipToStyleCorners?: boolean;
+    outerRim?: {
+        width: number;
+        wallOpacity: number;
+        endOpacity: number;
+    };
+    bodyOpacity?: number;
+    thickness?: number;
+    lightAngle?: number;
+    lightIntensity?: number;
+    ambientStrength?: number;
+    interactive?: boolean;
+    capturePadding?: number;
+    interactionIntensity?: number;
+    interactionGlow?: GlassInteractionGlow;
+    chromaticAberration?: number;
+    refractionInset?: number;
+    lensStrength?: number;
+    refractionExponent?: number;
+    magnification?: number;
+    refractionSampleOffset?: [number, number];
+    rimFold?: [number, number, number];
+    lensOptics?: LiquidGlassLensOptics;
+    measuredTransfer?: number;
+    bodyLift?: [number, number];
+    bodyLiftOutside?: {
+        lift: [number, number];
+        chroma?: [number, number];
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        radius: number;
+        scaleX: number;
+        scaleY: number;
+    };
+    darkContextLean?: number;
+    detailLift?: number;
+    tallNarrowSigma?: number;
+    refractionAnisotropy?: [number, number];
+    refractionZone?: number;
+    refractionSharpShare?: number;
+    softFold?: [number, number];
+    foldLimit?: [number, number];
+    bodyCurve?: {
+        level: [number, number, number, number];
+        chromaGain: number;
+        rim: {
+            base: number;
+            perLuma: number;
+            perLevel: number;
+            falloff: number;
+            horizontalOnly?: boolean;
+            perBody?: number;
+            centre?: [number, number];
+            linear?: boolean;
+            tail?: [number, number];
+            soft?: boolean;
+            wrap?: [number, number, number, number];
+        };
+    };
+    bodyCurveDark?: LiquidGlassConfig['bodyCurve'];
+    accessibleBody?: Record<'reduceTransparency' | 'increaseContrast', Record<ResolvedGlassColorScheme, [number, number, number]>>;
+    vibrancy?: number;
+    vibrancyDark?: number;
+    vibrancyLuma?: 'rec601' | 'rec709';
+    refractVariant?: 'soft' | 'lens' | 'ends';
+    edgeAmbient?: number;
+    rimLighting?: {
+        light: LiquidGlassRimLighting;
+        dark: LiquidGlassRimLighting;
+    };
+    rimWidth?: number;
+    continuousCorners?: boolean;
+    contourRing?: Record<ResolvedGlassColorScheme, LiquidGlassContourRing>;
+    sharedMaterialProbe?: {
+        key: string;
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+        absolute?: boolean;
+    };
+    merge?: LiquidGlassMerge;
+    adaptiveForeground?: {
+        lightMaterial: {
+            baseLevel: number;
+            levelLumaSlope: number;
+            chromaGain: number;
+        };
+        darkMaterial: {
+            baseLevel: number;
+            levelLumaSlope: number;
+            chromaGain: number;
+        };
+    };
+    shadow?: LiquidGlassShadow;
+    tallShadow?: LiquidGlassShadow;
+    contour?: readonly LiquidGlassShadow[];
+}
+export interface LiquidGlassMerge {
+    key: string;
+    spacing: number;
+    members: ReadonlyArray<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        radius: number;
+        earlier: boolean;
+        folded: boolean;
+    }>;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    centre: {
+        x: number;
+        y: number;
+    };
+}
+export { LIQUID_GLASS_MERGE_MEMBERS, liquidGlassRectExtent, resolveAnimatedLiquidGlassRect, } from './liquid-glass-rect.d.ts';
+export type MenuLiquidGlassConfig = LiquidGlassConfig & {
+    vibrancy: number;
+    blurSigma: number;
+};
+export interface LiquidGlassShadow {
+    opacity: number;
+    opacityDark: number;
+    sigma: number;
+    offsetY?: number;
+    spread?: number | readonly [x: number, y: number];
+    afterCapture?: boolean;
+    stroke?: number;
+    continuous?: boolean;
+}
+export interface LiquidGlassContourRing {
+    end: readonly [row0: number, row1: number];
+    wall: readonly [row0: number, row1: number];
+    slope: number;
+    knee?: readonly [luma: number, gain: number];
+    highlight?: {
+        height: number;
+        angle: number;
+        spread: number;
+        bias: number;
+        softness: number;
+    };
+}
+export interface LiquidGlassEdgeConfig {
+    cornerRadius?: number;
+    lightAngle?: number;
+    lightIntensity?: number;
+    opacity?: number;
+}
+export declare const LIQUID_GLASS_REFRACT_UNIFORM_OFFSETS: Readonly<Record<string, number>>;
+export declare const LIQUID_GLASS_REFRACT_UNIFORM_FLOAT_COUNT: number;
+export declare function drawWithSdfDisplacement(opts: {
+    ck: CanvasKit;
+    canvas: Canvas;
+    parentSurface: Surface;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    dpr: number;
+    first: GlassShape;
+    second: GlassShape;
+    height: number;
+    amount: number;
+    gaussianRadius: number;
+    drawIntoOffscreen: (canvas: Canvas) => void;
+}): void;
+export declare function glassSurfaceId(surface: Surface): number;
+export declare function disposeLiquidGlassSurface(surface: Surface): void;
+export declare function drawWithLensFold(opts: {
+    ck: CanvasKit;
+    canvas: Canvas;
+    parentSurface: Surface;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    dpr: number;
+    fold: SootSimLensFold;
+    drawIntoOffscreen: (offscreenCanvas: Canvas) => void;
+}): boolean;
+export declare function resetGlassFrameCache(frameTimeMs: number, surface?: Surface, damage?: FrameDamage | null, dpr?: number): void;
+export declare function liquidGlassFrameEpoch(): number;
+export declare function beginGlassJsFrame(frameTimeMs: number): void;
+export declare function replayedLiquidGlassSamples(ck: CanvasKit): {
+    bounds: DamageRect | null;
+    moved: boolean;
+};
+export declare function initLiquidGlass(ck: CanvasKit): RuntimeEffect[];
+export declare function disposeLiquidGlass(): void;
+export declare function makeLiquidGlassAdaptiveForegroundShader(ck: CanvasKit, backdropCacheKey: number, foregroundOffset: [number, number]): Shader | null;
+export declare function liquidGlassMaterialTintShader(ck: CanvasKit, glassId: string | number, light: Float32Array, dark: Float32Array, base: Float32Array | null): Shader | null;
+export declare function liquidGlassSharedMaterialShader(ck: CanvasKit, surface: Surface, key: string, light: Shader, dark: Shader): {
+    shader: Shader;
+    active: boolean;
+} | null;
+export declare function liquidGlassPrewarmShapeCount(config: LiquidGlassConfig): 1 | 3;
+export declare function prewarmLiquidGlassPrograms(ck: CanvasKit, sourceSurface: Surface, configs: readonly LiquidGlassConfig[], dpr?: number, flush?: boolean, shapeIndex?: 0 | 1 | 2): {
+    ok: boolean;
+    ms: number;
+};
+export declare function drawLiquidGlassEdge(ck: CanvasKit, canvas: Canvas, dpr: number, x: number, y: number, w: number, h: number, config: LiquidGlassEdgeConfig): void;
+export declare const LIQUID_GLASS_MOVING = 1;
+export declare const LIQUID_GLASS_REPLAYABLE = 2;
+export declare function beginLiquidGlassProgram(ck: CanvasKit, slot: number, id: number, width: number, height: number, x?: number, y?: number, fixed?: boolean, rect?: NonNullable<ReturnType<typeof resolveAnimatedLiquidGlassRect>>, capturePadding?: number): void;
+export declare function endLiquidGlassProgram(ck: CanvasKit): void;
+export declare function liquidGlassProgramCommand(ck: CanvasKit, kind: number, x: number, y: number, width: number, height: number, values?: readonly number[]): void;
+export declare function drawLiquidGlass(ck: CanvasKit, canvas: Canvas, surface: Surface, dpr: number, x: number, y: number, w: number, h: number, config: LiquidGlassConfig, backdropCacheKey?: string | number, tenantBackdrop?: TenantGlassBackdrop, portalPass?: boolean, layered?: boolean, motionScope?: GlassMotionScope | null): number;

package/dist-types/packages/peach-engine/src/engine/live-object-counts.d.ts

@@ -0,0 +1,6 @@
+export declare const LIVE: {
+    pictures: number;
+    paragraphs: number;
+    yogaNodes: number;
+};
+export declare function readLiveObjectCounts(): typeof LIVE;

package/dist-types/packages/peach-engine/src/engine/lottie-runtime.d.ts

@@ -0,0 +1,32 @@
+import { type SootSimNode } from './node.d.ts';
+import type { CanvasKitRenderingApi } from './canvaskit-api.d.ts';
+import type { LottieIntent, LottieLifecycleEvent, SootSimLottieState } from './lottie-types.d.ts';
+export type { LottieColorFilter, SootSimLottieState } from './lottie-types.d.ts';
+export declare function setLottieLifecycleEventSink(sink: ((event: LottieLifecycleEvent) => void) | null): void;
+export declare function ensureLottieState(node: SootSimNode): SootSimLottieState;
+export declare function setLottiePaintContinuation(cb: ((node: SootSimNode) => void) | null): void;
+export declare function requestLottiePaint(node: SootSimNode): void;
+export interface LottieOwnerDiagnostics {
+    nodes: {
+        nodeId: number;
+        source: string;
+        sourceGen: number;
+        status: SootSimLottieState['status'];
+        isPlaying: boolean;
+        animationDeleted: boolean | null;
+    }[];
+    released: {
+        source: string;
+        deleted: boolean;
+    }[];
+}
+export declare function lottieOwnerDiagnostics(): LottieOwnerDiagnostics;
+export declare function clearLottieSource(node: SootSimNode): void;
+export declare function syncLottieOwnerNode(node: SootSimNode, canvasKit: CanvasKitRenderingApi, props: Record<string, unknown>): SootSimLottieState;
+export declare function applyLottieIntent(node: SootSimNode, intent: LottieIntent): boolean;
+export declare function disposeLottieNode(node: SootSimNode): void;
+export declare function advanceLottieAnimations(now: number, onChanged?: (node: SootSimNode) => void): {
+    anyChange: boolean;
+};
+export declare function hasActiveLottieAnimations(): boolean;
+export declare function notifyLottieRendered(node: SootSimNode): void;

package/dist-types/packages/peach-engine/src/engine/lottie-types.d.ts

@@ -0,0 +1,138 @@
+import type { ManagedSkottieAnimation } from 'canvaskit-wasm';
+export interface LottieColorFilter {
+    keypath?: string;
+    color?: unknown;
+}
+export interface DotLottiePlayback {
+    platform: 'ios' | 'android';
+    frame: number;
+    mode: number;
+    direction: number;
+    playback: 'stopped' | 'paused' | 'playing';
+    frozen: boolean;
+    interpolation: boolean;
+    activeAnimationId: string;
+    marker: string;
+    configuredMarker: string;
+    markers: Record<string, [number, number]>;
+    segment: [number, number] | null;
+    appliedProps: Record<string, unknown>;
+    pendingEvent?: 'loop' | 'complete';
+    restartLoop?: boolean;
+    renderedFrame?: number;
+    viewSize?: [number, number, number];
+    resize?: [number, number];
+}
+export interface SootSimLottieState {
+    dotLottie?: DotLottiePlayback;
+    animation: ManagedSkottieAnimation | null;
+    sourceKey: string | null;
+    surfaceId: string | null;
+    generation: number;
+    sourceGen: number;
+    lastIntentSeq: number;
+    lastMetricsSeq: number;
+    configuredSourceKey: string | null;
+    pendingIntents: LottieIntent[];
+    checkpointRevision: number;
+    restoredCheckpointRevision: number;
+    status: 'empty' | 'pending' | 'ready' | 'failed';
+    error: string | null;
+    durationMs: number;
+    fps: number;
+    currentTimeMs: number;
+    segmentStartMs: number;
+    segmentEndMs: number | null;
+    isPlaying: boolean;
+    loop: boolean;
+    speed: number;
+    appliedSpeed: number | null;
+    appliedLoop: boolean | null;
+    wasPausedByZeroSpeed: boolean;
+    debugSeen?: boolean;
+    resizeMode: 'cover' | 'contain' | 'center';
+    colorFilters: LottieColorFilter[];
+    colorFiltersKey: string;
+    appliedColorFiltersKey: string | null;
+    appliedProgress: number | null;
+    appliedProgressSourceKey: string | null;
+    autoPlay: boolean;
+    previousAutoPlay: boolean;
+    autoPlaySourceKey: string | null;
+    lastTickMs: number | null;
+    loopCount: number;
+}
+export type LottieIntentKind = 'play' | 'pause' | 'resume' | 'reset' | 'seekFrame' | 'segment' | 'speed' | 'loop' | 'playMode' | 'metrics' | 'freeze' | 'unfreeze' | 'marker' | 'animation' | 'resize';
+export interface LottieIntent {
+    nodeId: number;
+    sourceGen: number;
+    intentSeq: number;
+    kind: LottieIntentKind;
+    startFrame?: number;
+    endFrame?: number;
+    frame?: number;
+    speed?: number;
+    loop?: boolean;
+    mode?: number;
+    name?: string;
+    width?: number;
+    height?: number;
+}
+export type LottieLifecyclePhase = 'loaded' | 'failed' | 'finished' | 'checkpoint' | 'metrics' | 'dotLottie';
+export interface LottiePlaybackCheckpoint {
+    dotLottie?: DotLottiePlayback;
+    loopCount?: number;
+    revision: number;
+    sourceGen: number;
+    intentSeq: number;
+    capturedAtMs: number;
+    currentTimeMs: number;
+    segmentStartMs: number;
+    segmentEndMs: number | null;
+    isPlaying: boolean;
+    speed: number;
+    loop: boolean;
+}
+export declare function isLottiePlaybackCheckpoint(value: unknown): value is LottiePlaybackCheckpoint;
+export interface LottieMetrics {
+    requestSeq: number;
+    durationMs: number;
+    fps: number;
+    currentTimeMs: number;
+    speed: number;
+    isPlaying: boolean;
+    status: 'empty' | 'pending' | 'ready' | 'failed';
+    loopCount: number;
+    playback?: 'stopped' | 'paused' | 'playing';
+    activeAnimationId?: string;
+}
+export declare function isLottieMetrics(value: unknown): value is LottieMetrics;
+export interface LottieLifecycleEvent {
+    surfaceId: string;
+    generation: number;
+    nodeId: number;
+    sourceGen: number;
+    phase: LottieLifecyclePhase;
+    durationMs?: number;
+    fps?: number;
+    error?: string;
+    isCancelled?: boolean;
+    checkpoint?: LottiePlaybackCheckpoint;
+    metrics?: LottieMetrics;
+    dotEvent?: string;
+    frameNo?: number;
+    loopCount?: number;
+}
+export interface SootSimLottieIntentState {
+    pendingMetrics: Map<number, {
+        resolve: (value: LottieMetrics) => void;
+        reject: (error: Error) => void;
+    }>;
+    sourceGen: number;
+    intentSeq: number;
+    sourceKey: string | null;
+    commandFrame: number | undefined;
+}
+export declare function isLottieIntent(value: unknown): value is LottieIntent;
+export declare function isLottieLifecycleEvent(value: unknown): value is LottieLifecycleEvent;
+export declare const DOT_LOTTIE_ANDROID_COMMANDS: Readonly<Record<string, number>>;

package/dist-types/packages/peach-engine/src/engine/memory-counts.d.ts

@@ -0,0 +1,27 @@
+import { hostLedger } from './host-composite.d.ts';
+import { getImageLoaderStats } from './image-loader.d.ts';
+import { readLiveObjectCounts } from './live-object-counts.d.ts';
+import type { CanvasKitRenderingApi as CanvasKit } from './canvaskit-api.d.ts';
+
+export declare function trackSwiftMemory(memory: WebAssembly.Memory, initialBytes: number): () => void;
+declare function readJsHeap(): {
+    usedJSHeapSize: number;
+    totalJSHeapSize: number;
+    jsHeapSizeLimit: number;
+} | null;
+export interface EngineMemoryCounts {
+    nodesRegistered: number;
+    nodesDetached: number;
+    detachedTypes: Record<string, number>;
+    objects: ReturnType<typeof readLiveObjectCounts> & ReturnType<typeof hostLedger>;
+    activeNativeAnimations: number;
+    imageLoader: ReturnType<typeof getImageLoaderStats>;
+    workerHeap: ReturnType<typeof readJsHeap>;
+    wasmHeapBytes: number | null;
+    swiftWasmHeapBytes: number | null;
+    swiftWasmGrowthBytes: number | null;
+    nativePreviewLastApply: 'hot' | 'cold' | null;
+    orphansReleased: number | null;
+}
+export declare function collectEngineMemoryCounts(canvasKit: CanvasKit | null): EngineMemoryCounts;
+export {};

package/dist-types/packages/peach-engine/src/engine/metalDirectContract.d.ts

@@ -0,0 +1,108 @@
+import type { MetalShaderFunction } from './metalShaderContract.d.ts';
+export type MetalDimensions = readonly [number, number, number];
+export type MetalRenderPipeline = {
+    id: number;
+    vertex: string;
+    fragment: string;
+};
+export type MetalResourceBytes = {
+    index: number;
+    bytes: string;
+};
+export type MetalTextureBytes = MetalResourceBytes & {
+    width: number;
+    height: number;
+};
+export type MetalSamplerBinding = {
+    index: number;
+    minFilter: 'nearest' | 'linear';
+    magFilter: 'nearest' | 'linear';
+    addressU: 'clamp-to-edge' | 'repeat';
+    addressV: 'clamp-to-edge' | 'repeat';
+};
+export type MetalResourceBindings = {
+    buffers: MetalResourceBytes[];
+    textures: MetalTextureBytes[];
+    samplers: MetalSamplerBinding[];
+};
+export type MetalRenderDraw = {
+    start: number;
+    count: number;
+    instances: number;
+    vertex: MetalResourceBindings;
+    fragment: MetalResourceBindings;
+};
+export type MetalDirectOperation = {
+    type: 'library';
+    source: string;
+} | {
+    type: 'library';
+    metallib: string;
+} | {
+    type: 'release';
+    id: number;
+} | {
+    type: 'pipeline';
+    id: number;
+    function: string;
+} | ({
+    type: 'renderPipeline';
+} & MetalRenderPipeline) | {
+    type: 'wait';
+    id: number;
+} | {
+    type: 'releaseCommand';
+    id: number;
+} | (MetalResourceBindings & {
+    type: 'compute';
+    id: number;
+    function: string;
+    threads: MetalDimensions;
+    threadgroup: MetalDimensions;
+}) | {
+    type: 'render';
+    pipeline: MetalRenderPipeline | null;
+    width: number;
+    height: number;
+    bytes: string;
+    load: 'load' | 'clear';
+    clear: readonly [number, number, number, number];
+    draws: MetalRenderDraw[];
+};
+export type MetalDirectResult = {
+    kind: 'library';
+    id: number;
+    functions: MetalShaderFunction[];
+} | {
+    kind: 'released';
+} | {
+    kind: 'pipeline';
+} | {
+    kind: 'completed';
+    buffers: MetalResourceBytes[];
+    textures?: MetalResourceBytes[];
+};
+export type MetalDirectResponse = {
+    ok: true;
+    result: MetalDirectResult;
+} | {
+    ok: false;
+    domain: string;
+    code: number;
+    error: string;
+};
+export declare function parseMetalDirectResponse(value: unknown): MetalDirectResponse;
+export declare function metalDirectFailure(error: unknown): MetalDirectResponse;
+export declare const METAL_SYNC_REPLY_BYTES: number;
+export type MetalCommandOperation = Extract<MetalDirectOperation, {
+    type: 'compute' | 'render';
+}>;
+export declare function isMetalDimensions(value: unknown): value is MetalDimensions;
+export declare function isMetalDirectOperation(value: unknown): value is MetalDirectOperation;
+export declare function completeMetalSyncReply(reply: SharedArrayBuffer, response: MetalDirectResponse): void;
+declare let service: ((operation: MetalDirectOperation) => MetalDirectResponse) | undefined;
+declare let submit: ((operation: MetalCommandOperation, completed: (response: MetalDirectResponse) => void) => number) | undefined;
+export declare function setMetalDirectHostService(next: typeof service, nextSubmit?: typeof submit): void;
+export declare function submitMetalDirectCommand(operation: MetalCommandOperation, completed: (response: MetalDirectResponse) => void): number;
+export declare function callMetalDirectHostSync(operation: MetalDirectOperation): MetalDirectResponse;
+export {};