peachsim 0.1.1641 → 0.1.1653

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

@@ -0,0 +1,217 @@
+import { type SwiftMetalSource } from '../../../../../src/swiftContract.ts';
+export type MetalShaderAttribute = {
+    name: string;
+    index: number | null;
+    value: string | null;
+};
+export type MetalShaderAnnotation = {
+    key: string;
+    value: string;
+};
+export type MetalShaderResource = {
+    kind: 'buffer' | 'texture' | 'sampler';
+    index: number;
+    group: number;
+    binding: number;
+    textureFormatBinding?: number;
+    pointer?: true;
+    mslType?: string;
+    elementStride?: number;
+    sourceElementStride?: number;
+};
+export type MetalShaderSamplerState = {
+    magFilter: GPUFilterMode;
+    minFilter: GPUFilterMode;
+    mipmapFilter: GPUMipmapFilterMode;
+    addressModeU: GPUAddressMode;
+    addressModeV: GPUAddressMode;
+    addressModeW: GPUAddressMode;
+    coord: 'normalized' | 'pixel';
+    compare?: GPUCompareFunction;
+    maxAnisotropy?: number;
+};
+export type MetalShaderSampler = {
+    kind: 'sampler';
+    group: 0;
+    binding: number;
+    sampler: MetalShaderSamplerState;
+};
+export type MetalShaderParameter = {
+    name: string;
+    mslType: string;
+    wgslType: string;
+    attributes: MetalShaderAttribute[];
+    resource: MetalShaderResource | null;
+    textureFormatArgument?: true;
+};
+export type MetalShaderFunction = {
+    name: string;
+    takesLayer?: true;
+    qualifier: string;
+    returnType: string;
+    mslReturnType: string;
+    parameters: MetalShaderParameter[];
+    resources?: MetalShaderSampler[];
+    attributes: MetalShaderAttribute[];
+    hostName?: string;
+    annotations?: MetalShaderAnnotation[];
+};
+export type MetalShaderBinding = {
+    group: number;
+    binding: number;
+    name: string;
+    type: string;
+    dataType: string;
+    visibility: string;
+    access?: 'read' | 'read_write';
+};
+export type MetalShaderMetadata = {
+    version: 4;
+    shader: {
+        vertexEntry: string | null;
+        fragmentEntry: string | null;
+        computeEntry: string | null;
+    };
+    functions: MetalShaderFunction[];
+    bindings: MetalShaderBinding[];
+};
+export type MetalShaderDiagnostic = {
+    severity: 1 | 2 | 3 | 4;
+    line: number;
+    column: number;
+    endLine: number;
+    endColumn: number;
+    message: string;
+};
+export type MetalSourceCompilation = {
+    ok: boolean;
+    wgsl: string;
+    metadata: MetalShaderMetadata | null;
+    metadataJson: string;
+    error: string;
+    diagnostics: MetalShaderDiagnostic[];
+};
+export type MetalNumericArgument = {
+    kind: 'float';
+    value: number;
+} | {
+    kind: 'float2';
+    value: readonly [number, number];
+} | {
+    kind: 'float3';
+    value: readonly [number, number, number];
+} | {
+    kind: 'float4';
+    value: readonly [number, number, number, number];
+} | {
+    kind: 'buffer';
+    bytes: Uint8Array;
+    count: number;
+} | {
+    kind: 'texture';
+    texture: GPUTexture;
+};
+export declare function metalTextureFormatCode(format: GPUTextureFormat): number;
+export type MetalColorEffectGeometry = {
+    origin: readonly [number, number];
+    pixelsPerPoint: readonly [number, number];
+    inputInset: readonly [number, number];
+    shape: {
+        size: readonly [number, number];
+        coverage: MetalShapeCoverage;
+    } | null;
+};
+export type MetalShapeCoverage = {
+    type: 'content';
+} | {
+    type: 'circle-stroke' | 'rectangle-stroke';
+    lineWidth: number;
+    inset: boolean;
+};
+export type MetalShaderImageSource = {
+    uri: string;
+} | {
+    systemName: string;
+};
+export type MetalShaderArgumentWire = {
+    kind: 'boundingRect';
+} | {
+    kind: 'float' | 'float2' | 'float3' | 'float4' | 'floatArray';
+    values: number[];
+} | {
+    kind: 'color';
+    color: unknown;
+} | {
+    kind: 'colorArray';
+    colors: unknown[];
+} | {
+    kind: 'data';
+    base64: string;
+} | ({
+    kind: 'image';
+} & MetalShaderImageSource);
+export type MetalShaderEffectUsage = 'color' | 'distortion' | 'layer' | 'shape';
+export type MetalShaderCompileUsage = MetalShaderEffectUsage;
+export declare const MAX_METAL_LIBRARY_BYTES: number;
+export declare function isMetalCompiledLibraryBytes(value: unknown): value is string;
+export type MetalShaderLibraryInput = {
+    type: 'source';
+    sources: Record<string, SwiftMetalSource>;
+} | {
+    type: 'compiled';
+    metallib: string;
+    url?: {
+        scope: string;
+        path: string;
+        instance: string;
+    };
+};
+export declare function isMetalShaderLibraryInput(value: unknown): value is MetalShaderLibraryInput;
+export type MetalShaderCompileRequest = {
+    library: MetalShaderLibraryInput;
+    function: string;
+    usage: MetalShaderCompileUsage;
+    argumentCount: number;
+};
+export type MetalShaderCompileResponse = {
+    ok: true;
+} | {
+    ok: false;
+    domain: string;
+    code: number;
+    error: string;
+};
+export declare class MetalShaderCompileError extends Error {
+    readonly code: number;
+    readonly domain = "com.apple.RenderBox.RBShaderError";
+    constructor(code: number, message: string);
+}
+export declare function metalShaderCompileFailure(error: unknown): MetalShaderCompileResponse;
+export declare function isMetalShaderCompileRequest(value: unknown): value is MetalShaderCompileRequest;
+declare let compileService: ((request: MetalShaderCompileRequest) => Promise<MetalShaderCompileResponse>) | undefined;
+export declare function setMetalShaderCompileService(next: typeof compileService): void;
+export declare function compileMetalShader(request: MetalShaderCompileRequest): Promise<MetalShaderCompileResponse>;
+export type MetalShaderEffectFilter = {
+    maxSampleOffset: [number, number];
+    library: MetalShaderLibraryInput;
+    function: string;
+    arguments: MetalShaderArgumentWire[];
+    enabled: boolean;
+} & ({
+    usage: 'shape';
+    boundsOutset: [number, number];
+    coverage: MetalShapeCoverage;
+} | {
+    usage: 'color' | 'distortion' | 'layer';
+});
+export declare function isMetalShaderEffectFilter(value: unknown): value is MetalShaderEffectFilter;
+export declare function metalColorEffectArguments(effect: MetalShaderEffectFilter, size: {
+    readonly width: number;
+    readonly height: number;
+}, resolveColor: (color: unknown) => ArrayLike<number>, resolveImage: (source: MetalShaderImageSource) => GPUTexture): MetalNumericArgument[];
+export declare function halfBits(value: number): number;
+export declare function halfValue(bits: number): number;
+export declare const metalCompilerFunctionExports: string[];
+export declare const metalAirCompilerExports: readonly ['air_alloc', 'air_free', 'air_describe', 'air_compile_compute', 'air_compile_library', 'air_compile_render', 'air_result_ok', 'air_result_code', 'air_result_wgsl', 'air_result_wgsl_len', 'air_result_metadata', 'air_result_metadata_len', 'air_result_error', 'air_result_error_len', 'air_result_free'];
+export declare function parseMetalShaderMetadata(json: string): MetalShaderMetadata;
+export {};

package/dist-types/packages/peach-engine/src/engine/native-animation-driver.d.ts

@@ -0,0 +1,112 @@
+import { type NativeAnimationGraph } from './animation-graph.d.ts';
+export type { NativeAnimationGraph } from './animation-graph.d.ts';
+export type NativeAnimatedValue = {
+    _value: number;
+    _listeners: Map<string, Function> | Set<Function>;
+    _nativeBatchUpdate?: boolean;
+    _alwaysRenderOnUpdate?: boolean;
+    _sootsimNativeAnimationId?: number;
+    ___sootsimNodeTags?: Set<number>;
+};
+type AnimatedValue = NativeAnimatedValue;
+export type NativeAnimationPriority = 'normal' | 'low' | 'high';
+export declare const VISIBILITY_GRACE_MS = 500;
+export interface NativeAnimationOptions {
+    priority?: NativeAnimationPriority;
+    graph?: NativeAnimationGraph;
+    layoutBound?: boolean;
+}
+export declare function setNativeAnimationRemoteReleaseCallback(cb: ((value: AnimatedValue) => void) | null): void;
+export declare function subscribeExternalValueAnimationGraphChanges(listener: (value: object, graph: NativeAnimationGraph | null) => void): () => void;
+export declare function setExternalValueAnimationGraph(value: AnimatedValue, graph: NativeAnimationGraph): void;
+export declare function clearExternalValueAnimationGraph(value: AnimatedValue): void;
+export declare function setExternalValueGraphPresented(value: AnimatedValue, presented: boolean): void;
+export declare function isExternalValueGraphPresented(value: AnimatedValue): boolean;
+export declare function getNativeAnimationGraphForValue(value: AnimatedValue): NativeAnimationGraph | null;
+export declare function setNativeAnimationLockstepActive(active: boolean): void;
+export declare function setNativeAnimationRemoteDriven(value: AnimatedValue, driven: boolean): void;
+export declare function registerExternalNativeDriver(kick: () => void): () => void;
+export declare function isNativeDriverExternallyDriven(): boolean;
+export declare function setNativeDriverExternallyDriven(driven: boolean, kick?: (() => void) | null): void;
+export declare function setNativeAnimationVisibilityRefreshCallback(cb: (() => void) | null): void;
+export declare function hasActiveNativeAnimationsInternal(): boolean;
+export declare function hasActiveNonLowPriorityNativeAnimations(): boolean;
+export declare function hasActiveLowPriorityNativeAnimations(): boolean;
+export declare function createNativeVisibilityWatcher(): number;
+export declare function dropNativeVisibilityWatcher(id: number): void;
+export declare function isNativeVisibilityWatcherVisible(id: number): boolean;
+export declare function hasNativeVisibilityWork(): boolean;
+export declare function beginNativeAnimationVisibilityFrame(): void;
+export declare function markNativeAnimationVisible(id: number | null | undefined): void;
+export declare function getNativeAnimationVisibilityMarkCount(): number;
+export declare function countNativeAnimationsAwaitingVisibility(): number;
+export declare function setNativeDriverRenderCallback(cb: ((updatedValues: AnimatedValue[], anyLayoutBoundChange: boolean) => void) | null): void;
+export type NativeAnimResult = {
+    finished: boolean;
+    reason: 'completed' | 'stalled' | 'stopped';
+};
+export declare function registerNativeAnimation(value: AnimatedValue, step: (now: number) => boolean, callback?: (result: NativeAnimResult) => void, options?: NativeAnimationOptions): number;
+export declare function sampleNativeAnimationPresentedValue(id: number, value: NativeAnimatedValue): number | null;
+export declare function stopNativeAnimation(id: number): void;
+export declare function stopNativeAnimationsForValue(value: AnimatedValue): void;
+export declare function runNativeDriverTick(now: number): void;
+export declare function createTimingStep(value: AnimatedValue, config: {
+    toValue: number;
+    duration?: number;
+    easing?: (t: number) => number;
+}): (now: number) => boolean;
+export declare function createLoopingTimingStep(value: AnimatedValue, config: {
+    fromValue?: number;
+    toValue: number;
+    duration?: number;
+    easing?: (t: number) => number;
+}): (now: number) => boolean;
+export declare function createSpringStep(value: AnimatedValue, config: {
+    toValue: number;
+    stiffness?: number;
+    tension?: number;
+    damping?: number;
+    friction?: number;
+    velocity?: number;
+    mass?: number;
+    bounciness?: number;
+    speed?: number;
+    overshootClamping?: boolean;
+    restSpeedThreshold?: number;
+    restVelocityThreshold?: number;
+    restDisplacementThreshold?: number;
+}): (now: number) => boolean;
+export declare function hasActiveNativeAnimations(): boolean;
+export declare function getActiveAnimationCount(): number;
+export declare function getNativeAnimationDriverStats(): {
+    activeAnimationCount: number;
+    tickCount: number;
+    stalledTickCount: number;
+    hasRafScheduled: boolean;
+};
+export declare function snapshotActiveAnimationFingerprint(): number;
+export interface NativeDriverAnimationInfo {
+    id: number;
+    value: AnimatedValue;
+    kind: NativeAnimationGraph['kind'] | null;
+    from: number | null;
+    to: number | null;
+    current: number;
+    elapsedMs: number;
+    priority: NativeAnimationPriority;
+    visible: boolean;
+    graphBacked: boolean;
+    remoteDriven: boolean;
+    listenerCount: number;
+}
+export declare function listNativeDriverAnimations(now?: number): NativeDriverAnimationInfo[];
+export declare function getNativeAnimationDebugInfo(): {
+    id: number;
+    ageMs: number;
+    idleTicks: number;
+    currentValue: number;
+    priority: NativeAnimationPriority;
+    visible: boolean;
+    stepSource: string;
+    registrationStack: string | undefined;
+}[];

package/dist-types/packages/peach-engine/src/engine/native-animation-graph.d.ts

@@ -0,0 +1,62 @@
+import { type NativeAnimatedValue } from './native-animation-driver.d.ts';
+export interface NativeAnimationGraphSpring {
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    velocity?: number;
+    bounciness?: number;
+    speed?: number;
+    overshootClamping?: boolean;
+    restSpeedThreshold?: number;
+    restDisplacementThreshold?: number;
+}
+export type NativeAnimationGraphNode = {
+    t: 'timing';
+    valueId: number;
+    from: number;
+    fromCurrent?: boolean;
+    to: number;
+    duration: number;
+    frames?: number[];
+} | {
+    t: 'spring';
+    valueId: number;
+    from: number;
+    to: number;
+    spring?: NativeAnimationGraphSpring;
+} | {
+    t: 'decay';
+    valueId: number;
+    from: number;
+    velocity: number;
+    deceleration: number;
+} | {
+    t: 'delay';
+    ms: number;
+} | {
+    t: 'loop';
+    child: NativeAnimationGraphNode;
+    iterations: number;
+    resetBeforeIteration: boolean;
+} | {
+    t: 'sequence';
+    children: NativeAnimationGraphNode[];
+} | {
+    t: 'parallel';
+    children: NativeAnimationGraphNode[];
+    stopTogether: boolean;
+};
+export interface NativeAnimationGraphRunner {
+    step(now: number): boolean;
+    reset(resetValues?: boolean): void;
+}
+export interface NativeAnimationGraphRunnerOptions {
+    absoluteLowPriorityLoopPhase: boolean;
+}
+export declare function createNativeAnimationFrameTimingStep(value: NativeAnimatedValue, from: number, to: number, frames: number[]): (now: number) => boolean;
+export declare function createNativeAnimationDecayStep(value: NativeAnimatedValue, config: {
+    velocity: number;
+    deceleration: number;
+}): (now: number) => boolean;
+export declare function getNativeAnimationGraphSeeds(root: NativeAnimationGraphNode): Map<number, number>;
+export declare function createNativeAnimationGraphRunner(node: NativeAnimationGraphNode, valueOf: (id: number) => NativeAnimatedValue, options: NativeAnimationGraphRunnerOptions): NativeAnimationGraphRunner;

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

@@ -0,0 +1,133 @@
+import type { CanvasKitRenderingApi as CanvasKit } from './canvaskit-api.d.ts';
+export interface NativeLayoutExports {
+    _peach_layout_values(): number;
+    _peach_layout_units(): number;
+    _peach_layout_enums(): number;
+    _peach_layout_scratch(): number;
+    _peach_layout_node_new(pointScaleFactor: number, measured: number): number;
+    _peach_layout_node_free(slot: number): void;
+    _peach_layout_bind(slot: number, sceneSlot: number, tag: number, observers: number, scale: number): void;
+    _peach_layout_apply(slot: number): void;
+    _peach_layout_attach(parent: number, child: number, index: number): void;
+    _peach_layout_detach(parent: number, child: number): void;
+    _peach_layout_owner(slot: number): number;
+    _peach_layout_child_count(slot: number): number;
+    _peach_layout_mark_dirty(slot: number): void;
+    _peach_layout_force(slot: number): void;
+    _peach_layout_force_subtree(slot: number): void;
+    _peach_layout_seen(slot: number): void;
+    _peach_layout_dirty(slot: number): number;
+    _peach_layout_calculate(root: number, width: number, height: number, direction: number): void;
+    _peach_layout_computed(slot: number): number;
+    _peach_layout_readback(root: number): number;
+    _peach_layout_readback_take(root: number): number;
+    _peach_layout_readback_records(): number;
+    _peach_layout_commit(paintGen: number, boundsGen: number, retainedArea: number): number;
+    readonly HEAPU8: Uint8Array;
+    readonly HEAP32: Int32Array;
+    readonly HEAPF32: Float32Array;
+    peachLayoutMeasure?: MeasureHook;
+    peachLayoutExit?: (slot: number) => void;
+}
+export type MeasureHook = (slot: number, width: number, widthMode: number, height: number, heightMode: number) => void;
+export declare const L_WIDTH = 0;
+export declare const L_HEIGHT = 1;
+export declare const L_MIN_WIDTH = 2;
+export declare const L_MIN_HEIGHT = 3;
+export declare const L_MAX_WIDTH = 4;
+export declare const L_MAX_HEIGHT = 5;
+export declare const L_FLEX_BASIS = 6;
+export declare const L_PADDING = 7;
+export declare const L_MARGIN = 16;
+export declare const L_POSITION = 25;
+export declare const L_GAP = 34;
+export declare const LENGTH_COUNT = 37;
+export declare const V_FLEX = 37;
+export declare const V_FLEX_GROW = 38;
+export declare const V_FLEX_SHRINK = 39;
+export declare const V_ASPECT_RATIO = 40;
+export declare const V_BORDER = 41;
+export declare const VALUE_COUNT = 50;
+export declare const E_DIRECTION = 0;
+export declare const E_FLEX_DIRECTION = 1;
+export declare const E_JUSTIFY_CONTENT = 2;
+export declare const E_ALIGN_CONTENT = 3;
+export declare const E_ALIGN_ITEMS = 4;
+export declare const E_ALIGN_SELF = 5;
+export declare const E_POSITION_TYPE = 6;
+export declare const E_FLEX_WRAP = 7;
+export declare const E_OVERFLOW = 8;
+export declare const E_DISPLAY = 9;
+export declare const E_KIND = 10;
+export declare const E_TEXT_ROUNDING = 11;
+export declare const ENUM_COUNT = 12;
+export declare const UNIT_UNDEFINED = 0;
+export declare const UNIT_POINT = 1;
+export declare const UNIT_PERCENT = 2;
+export declare const UNIT_AUTO = 3;
+export declare const KIND_DEFAULT = 0;
+export declare const KIND_PORTAL = 1;
+export declare const OP_WRITE = 0;
+export declare const OP_PORTAL = 1;
+export declare const OP_EXIT = 2;
+export declare const OP_COMMITTED = 3;
+export declare const OBSERVE_WRITE = 1;
+export declare const OBSERVE_EXIT = 2;
+export declare const OBSERVE_TRANSFORM = 4;
+export declare const READBACK_STRIDE = 5;
+export declare const EDGE_LEFT = 0;
+export declare const EDGE_TOP = 1;
+export declare const EDGE_RIGHT = 2;
+export declare const EDGE_BOTTOM = 3;
+export declare const EDGE_START = 4;
+export declare const EDGE_END = 5;
+export declare const EDGE_HORIZONTAL = 6;
+export declare const EDGE_VERTICAL = 7;
+export declare const EDGE_ALL = 8;
+export declare const GUTTER_COLUMN = 0;
+export declare const GUTTER_ROW = 1;
+export declare const GUTTER_ALL = 2;
+export declare const DIRECTION_INHERIT = 0;
+export declare const DIRECTION_LTR = 1;
+export declare const DIRECTION_RTL = 2;
+export declare const FLEX_DIRECTION_COLUMN = 0;
+export declare const FLEX_DIRECTION_COLUMN_REVERSE = 1;
+export declare const FLEX_DIRECTION_ROW = 2;
+export declare const FLEX_DIRECTION_ROW_REVERSE = 3;
+export declare const JUSTIFY_FLEX_START = 0;
+export declare const JUSTIFY_CENTER = 1;
+export declare const JUSTIFY_FLEX_END = 2;
+export declare const JUSTIFY_SPACE_BETWEEN = 3;
+export declare const JUSTIFY_SPACE_AROUND = 4;
+export declare const JUSTIFY_SPACE_EVENLY = 5;
+export declare const ALIGN_AUTO = 0;
+export declare const ALIGN_FLEX_START = 1;
+export declare const ALIGN_CENTER = 2;
+export declare const ALIGN_FLEX_END = 3;
+export declare const ALIGN_STRETCH = 4;
+export declare const ALIGN_BASELINE = 5;
+export declare const ALIGN_SPACE_BETWEEN = 6;
+export declare const ALIGN_SPACE_AROUND = 7;
+export declare const ALIGN_SPACE_EVENLY = 8;
+export declare const POSITION_TYPE_RELATIVE = 1;
+export declare const POSITION_TYPE_ABSOLUTE = 2;
+export declare const WRAP_NO_WRAP = 0;
+export declare const WRAP_WRAP = 1;
+export declare const WRAP_WRAP_REVERSE = 2;
+export declare const OVERFLOW_VISIBLE = 0;
+export declare const OVERFLOW_HIDDEN = 1;
+export declare const OVERFLOW_SCROLL = 2;
+export declare const DISPLAY_FLEX = 0;
+export declare const DISPLAY_NONE = 1;
+export declare const DISPLAY_CONTENTS = 2;
+export declare const MEASURE_MODE_UNDEFINED = 0;
+export declare const MEASURE_MODE_EXACTLY = 1;
+export declare const MEASURE_MODE_AT_MOST = 2;
+export interface NativeLayout {
+    readonly exports: NativeLayoutExports;
+    readonly values: number;
+    readonly units: number;
+    readonly enums: number;
+    readonly scratch: number;
+}
+export declare function bindNativeLayout(ck: CanvasKit, measure: MeasureHook, exit: (slot: number) => void): NativeLayout;

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

@@ -0,0 +1,26 @@
+import type { CanvasKitRenderingApi } from './canvaskit-api.d.ts';
+import type { SootSimNode } from './node.d.ts';
+export type NativeResourceSuppliers = {
+    skottie(): Promise<WebAssembly.Module>;
+    gif(): Promise<WebAssembly.Module>;
+    textData(): Promise<ArrayBuffer>;
+};
+export declare class NativeTextDataPending extends Error {
+    readonly ready: Promise<void>;
+    readonly code = "PEACH_TEXT_DATA_PENDING";
+    constructor(ready: Promise<void>);
+}
+type NativeCanvasKit = Pick<CanvasKitRenderingApi, 'LoadSkottie' | 'LoadGif' | '_peach_gif_ready' | '_peachGifEncodedDemand' | '_peachSkottieGifDemand' | '_peachTextStatus' | '_peachSkottieTextDemand' | '_peach_text_data_ready' | '_peach_text_data_register' | '_malloc' | '_free' | 'HEAPU8'>;
+export declare function configureNativeResources(canvasKit: NativeCanvasKit, suppliers: NativeResourceSuppliers): void;
+export declare function ensureSkottie(canvasKit: NativeCanvasKit): Promise<void>;
+export declare function ensureGif(canvasKit: NativeCanvasKit): Promise<void>;
+export declare function ensureGifForEncodedImage(canvasKit: NativeCanvasKit, input: ArrayBuffer | Uint8Array): Promise<void>;
+export declare function ensureGifForSkottie(canvasKit: NativeCanvasKit, json: string, assets?: Record<string, ArrayBuffer | Uint8Array>): Promise<void>;
+export declare function ensureTextDataForText(canvasKit: NativeCanvasKit, text: string): Promise<void>;
+export declare function pendingTextDataForText(canvasKit: NativeCanvasKit, text: string): Promise<void> | null;
+export declare function ensureTextDataForSkottie(canvasKit: NativeCanvasKit, json: string, assets?: Record<string, ArrayBuffer | Uint8Array>): Promise<void>;
+export declare function readTextDataForText(canvasKit: NativeCanvasKit, text: string): void;
+export declare function requireTextDataForText(canvasKit: NativeCanvasKit, text: string): void;
+export declare function pendingTextDataForTree(canvasKit: NativeCanvasKit, root: SootSimNode): Promise<void> | null;
+export declare function requireTextDataForTree(canvasKit: NativeCanvasKit, root: SootSimNode): void;
+export {};

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

@@ -0,0 +1,25 @@
+export interface NativeReanimatedGraph {
+    createNode(id: number, config: object): void;
+    dropNode(id: number): void;
+    connectNodes(parent: number, child: number): void;
+    disconnectNodes(parent: number, child: number): void;
+    connectNodeToView(id: number, view: number): void;
+    disconnectNodeFromView(id: number): void;
+    setValue(id: number, value: unknown): void;
+    getValue(id: number, now: number): unknown;
+    event(id: number, payload: unknown): void;
+    validateEvent(id: number): void;
+    configureProps(ui: string[], native: string[]): void;
+    step(now: number): boolean;
+    pending(): boolean;
+    takeOutputs(): Array<{
+        kind: number;
+        node: number;
+        view: number;
+        value: unknown;
+    }>;
+    delete(): void;
+}
+export interface CanvasKitReanimatedApi {
+    p13: new () => NativeReanimatedGraph;
+}

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

@@ -0,0 +1,64 @@
+export type NativeReplayKind = 'direct-text' | 'text-backing' | 'direct-picture' | 'text-visit-picture' | 'retained-picture' | 'host-picture' | 'layer-picture' | 'cache-blit' | 'motion-cache';
+export interface NativeReplayObservation {
+    slot: number;
+    tag: number;
+    frame: number;
+    target: number;
+    device: number;
+    kind: NativeReplayKind;
+    identity: number;
+    ctm: number[];
+    deviceCtm: number[];
+    clip: [number, number, number, number];
+    clipRectangular: boolean;
+    clipAntialiased: boolean;
+    inkBounds: [number, number, number, number];
+}
+export interface CanvasKitReplayApi {
+    p15(rows: number, frames: number, tag: number, target: number): void;
+    p14(): {
+        rows: NativeReplayObservation[];
+        dropped: number;
+        frames: number;
+    };
+}
+export type NativeReplayRequest = 'read' | null | {
+    rows: number;
+    frames: number;
+    tag: number;
+    target: number;
+};
+export interface NativeReplayFrameBinding {
+    frame: number;
+    serial: number;
+    target: number;
+}
+export interface NativeReplaySurfaceFacts {
+    surfaceId: string;
+    generation: number;
+    dpr: number;
+    currentClip: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    } | null;
+    lastClip: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    } | null;
+    binding: NativeReplayFrameBinding | null;
+    prerequisite: string | null;
+}
+export interface NativeReplayReport {
+    rows: (NativeReplayObservation & {
+        rootFrame: number | null;
+    })[];
+    dropped: number;
+    frames: number;
+    surfaceFacts: NativeReplaySurfaceFacts[];
+    rootPrerequisite: string;
+    clipInputsPrerequisite: string;
+}