peachsim 0.1.1644 → 0.1.1653

package/dist-types/packages/peach-engine/src/render-worker/compositor-runtime/scroll-drag-resample.d.ts

@@ -0,0 +1,44 @@
+export declare class ScrollDragDeliveryBound {
+    #private;
+    note(lagMs: number, sampleTime: number, observedAt: number): void;
+    get ms(): number;
+}
+export interface ScrollDragSample {
+    t: number;
+    x: number;
+    y: number;
+}
+export interface ScrollDragResampleTrace {
+    hostNow: number;
+    resampleAt: number | null;
+    deliveryBoundMs: number;
+    version: number;
+    sampleTime: number;
+    dragStartTime: number;
+    presentedAt: number | null;
+    pendingStart: number | null;
+    pendingEnd: number | null;
+    pendingCount: number;
+    awaitingSample: boolean;
+}
+export interface ScrollDragTrack {
+    start: number;
+    presented: ScrollDragSample | null;
+    pending: ScrollDragSample[];
+}
+export declare function createScrollDragTrack(start: number, presented: ScrollDragSample | null): ScrollDragTrack;
+export declare function ingestScrollDragSample(track: ScrollDragTrack, sample: ScrollDragSample): void;
+export declare function hasPendingScrollDragSamples(track: ScrollDragTrack | null): boolean;
+export declare function resampleScrollDrag(track: ScrollDragTrack, target: number): ScrollDragSample | null;
+export declare function resolveScrollDragOffset<Entry extends {
+    dragTrack: ScrollDragTrack | null;
+    dragSampleVersion: number;
+}>(entry: Entry, version: number, x: number, y: number, sampleTime: number, dragStartTime: number, hostNow: number, resampleAt: number | null, deliveryBound: ScrollDragDeliveryBound, restingOffset: (entry: Entry) => {
+    x: number;
+    y: number;
+} | null, onDragStart: (dragStartTime: number) => void, trace?: (sample: ScrollDragResampleTrace) => void): {
+    x: number;
+    y: number;
+    interpolated: boolean;
+    drag: boolean;
+} | null;

package/dist-types/packages/peach-engine/src/render-worker/css-keyframes-drive.d.ts

@@ -0,0 +1,36 @@
+export type CSSDriveEasing = {
+    kind: 'linear';
+} | {
+    kind: 'cubicBezier';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+} | {
+    kind: 'steps' | 'linearStops';
+    x: number[];
+    y: number[];
+};
+export type CSSDriveTrackKind = 'value' | 'operation' | 'angle';
+export interface CSSDriveTrack {
+    kind: CSSDriveTrackKind;
+    reset: number;
+    keyframes: number[];
+}
+export interface CSSKeyframesDrive {
+    t: 'css';
+    start: number;
+    duration: number;
+    delay: number;
+    iterations: number;
+    direction: 'normal' | 'reverse' | 'alternate' | 'alternate-reverse';
+    fillBackwards: boolean;
+    fillForwards: boolean;
+    easing: CSSDriveEasing;
+    keyframeEasings: Array<{
+        offset: number;
+        easing: CSSDriveEasing;
+    }>;
+    tracks: CSSDriveTrack[];
+}
+export declare function isCSSKeyframesDrive(value: unknown): value is CSSKeyframesDrive;

package/dist-types/packages/peach-engine/src/render-worker/edit-menu-geometry.d.ts

@@ -0,0 +1,8 @@
+export type EditMenuItemRect = {
+    action: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    labelRect: Pick<EditMenuItemRect, 'x' | 'y' | 'width' | 'height'> | null;
+};

package/dist-types/packages/peach-engine/src/render-worker/engine-resource-relay.d.ts

@@ -0,0 +1,21 @@
+import { type EngineResourceLoader } from '../engine/engine-resource.d.ts';
+export interface EngineResourceRequest {
+    type: 'requestEngineResource';
+    url: string;
+    credentials: RequestCredentials;
+}
+export type EngineResourceResponse = {
+    type: 'engineResource';
+    url: string;
+    buffer: ArrayBuffer;
+} | {
+    type: 'engineResource';
+    url: string;
+    buffer: null;
+    error: string;
+};
+export declare function replyEngineResource(request: EngineResourceRequest, post: (response: EngineResourceResponse) => void, load?: EngineResourceLoader): Promise<void>;
+export declare function createEngineResourceRelay(post: (request: EngineResourceRequest) => void, retain?: boolean): {
+    load: (url: string, credentials?: RequestCredentials) => Promise<ArrayBuffer>;
+    receive: (response: unknown) => void;
+};

package/dist-types/packages/peach-engine/src/render-worker/expo-widgetContract.d.ts

@@ -0,0 +1,16 @@
+export interface ExpoWidgetSnapshot {
+    layout: string | null;
+    timestamp?: number;
+    props?: Record<string, unknown>;
+}
+export interface ExpoWidgetEntry extends ExpoWidgetSnapshot {
+    runtimeBundle: string;
+    name: string;
+    environment: Record<string, unknown>;
+}
+export interface ExpoWidgetNode {
+    type: string;
+    props: Record<string, unknown>;
+    __expoWidgetIdentity?: string;
+}
+export declare function isExpoWidgetNode(value: unknown): value is ExpoWidgetNode;

package/dist-types/packages/peach-engine/src/render-worker/gesture-seam-protocol.d.ts

@@ -0,0 +1,152 @@
+import type { WorkletPeerEpoch } from './worklet-runtime.d.ts';
+import type { SeamPointerEvent } from '../../../peach-compat/src/stubs/native-seams/react-native-gesture-handler.d.ts';
+export type GestureSurfaceOwner = {
+    kind: 'app';
+    peerEpoch: WorkletPeerEpoch;
+    surfaceId: 'app:one' | 'app:two';
+    generation: number;
+} | {
+    kind: 'shell-overlay';
+    peerEpoch: WorkletPeerEpoch;
+    surfaceId: 'shell-overlay';
+    generation: 1;
+};
+export interface ShellGestureNativeHost {
+    resolveNode(owner: GestureSurfaceOwner, viewTag: number): unknown;
+    dispatchEvent(owner: GestureSurfaceOwner, viewTag: number, event: {
+        eventName: string;
+    } & Record<string, unknown>, timestamp: number): void;
+}
+export interface GestureArbitrationGraph {
+    owner: GestureSurfaceOwner;
+    detectorId: number;
+    generation: number;
+    revision: number;
+    memberTags: number[];
+    groups: Array<{
+        kind: 'race' | 'exclusive' | 'simultaneous';
+        members: number[][];
+    }>;
+    relations: Array<{
+        handlerTag: number;
+        simultaneousWith: number[];
+        requireToFail: number[];
+        blocksExternal: number[];
+    }>;
+}
+export type GestureSeamRequest = {
+    kind: 'create';
+    handlerName: string;
+    handlerTag: number;
+    config: Record<string, unknown>;
+    graph: GestureArbitrationGraph;
+} | {
+    kind: 'attach';
+    handlerTag: number;
+    viewTag: number;
+    actionType: number;
+    owner: GestureSurfaceOwner;
+    viewIsUIControl: boolean;
+    reanimatedEventViewTag?: number;
+    reanimatedHandlerTag?: number;
+} | {
+    kind: 'update';
+    handlerTag: number;
+    config: Record<string, unknown>;
+    graph: GestureArbitrationGraph;
+} | {
+    kind: 'drop';
+    handlerTag: number;
+    owner: GestureSurfaceOwner;
+} | {
+    kind: 'setState';
+    handlerTag: number;
+    newState: number;
+    owner: GestureSurfaceOwner;
+};
+export declare function gestureSeamRequestOwner(request: GestureSeamRequest): GestureSurfaceOwner;
+export interface GestureSeamNativeRecognitionEvent {
+    handlerTag: number;
+    state: number;
+    oldState: number;
+    numberOfPointers: number;
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+    translationX?: number;
+    translationY?: number;
+    velocityX?: number;
+    velocityY?: number;
+    velocity?: number;
+    scale?: number;
+    focalX?: number;
+    focalY?: number;
+    rotation?: number;
+    anchorX?: number;
+    anchorY?: number;
+    pointerInside?: boolean;
+    pointerType?: number;
+    stylusData?: Record<string, number>;
+    duration?: number;
+    timestamp?: number;
+}
+export type GestureSeamCallbackPayload = Pick<GestureSeamNativeRecognitionEvent, 'handlerTag' | 'state' | 'numberOfPointers' | 'pointerType'> & Partial<Omit<GestureSeamNativeRecognitionEvent, 'handlerTag' | 'state' | 'oldState' | 'numberOfPointers' | 'pointerType'>>;
+export interface GestureSeamRecognitionEvent {
+    owner: GestureSurfaceOwner;
+    channel: 'stateChange' | 'update';
+    handlerTag: number;
+    state: number;
+    oldState: number;
+    numberOfPointers: number;
+    x?: number;
+    y?: number;
+    absoluteX?: number;
+    absoluteY?: number;
+    translationX?: number;
+    translationY?: number;
+    velocityX?: number;
+    velocityY?: number;
+    velocity?: number;
+    scale?: number;
+    focalX?: number;
+    focalY?: number;
+    rotation?: number;
+    anchorX?: number;
+    anchorY?: number;
+    pointerInside?: boolean;
+    pointerType?: number;
+    stylusData?: Record<string, number>;
+    duration?: number;
+    timestamp?: number;
+    sourcePhase?: 'down' | 'move' | 'up' | 'cancel';
+}
+export interface GestureSeamTouchEvent {
+    owner: GestureSurfaceOwner;
+    channel: 'touch';
+    handlerTag: number;
+    pointerType: number;
+    x: number;
+    y: number;
+    changedTouch: SeamPointerEvent['changedTouch'];
+    touches: ReadonlyArray<{
+        pageX: number;
+        pageY: number;
+        identifier: number;
+    }>;
+    viewRect: {
+        pageX: number;
+        pageY: number;
+    };
+    sourcePhase: 'down' | 'move' | 'up' | 'cancel';
+}
+export interface GestureSeamTouchCancellationEvent {
+    owner: GestureSurfaceOwner;
+    channel: 'touchCancellation';
+    handlerTag: number;
+    pointerIds: readonly number[];
+    cancelsJSResponder: boolean;
+    cancelsNativeTouch: boolean;
+    sourcePhase: 'down' | 'move' | 'up' | 'cancel';
+}
+export type GestureSeamEvent = GestureSeamRecognitionEvent | GestureSeamTouchEvent | GestureSeamTouchCancellationEvent;

package/dist-types/packages/peach-engine/src/render-worker/graph-linked-value.d.ts

@@ -0,0 +1,29 @@
+import { AnimatedInterpolation } from '../engine/animated.d.ts';
+import { type NativeAnimationGraph } from '../engine/animation-graph.d.ts';
+export type GraphPresentationLeaf = {
+    __graph: NativeAnimationGraph;
+    value: number | string;
+} | {
+    __graphParts: NativeAnimationGraph[];
+    value: string;
+};
+export interface GraphPresentation {
+    viewTag: number;
+    template: Record<string, unknown>;
+}
+export declare function interpolationAnimationGraph(graph: NativeAnimationGraph, value: AnimatedInterpolation): NativeAnimationGraph | null;
+export declare function interpolationPartGraphs(graph: NativeAnimationGraph, value: AnimatedInterpolation, presented: string): NativeAnimationGraph[] | null;
+export declare class GraphLinkedValue {
+    readonly graph: NativeAnimationGraph;
+    readonly value: number | string;
+    constructor(graph: NativeAnimationGraph, value: number | string);
+    getValue(): number | string;
+}
+export declare class GraphLinkedString {
+    readonly parts: readonly NativeAnimationGraph[];
+    readonly value: string;
+    constructor(parts: readonly NativeAnimationGraph[], value: string);
+    getValue(): string;
+    partLinks(values: readonly number[]): GraphLinkedValue[] | null;
+}
+export declare function decodeGraphPresentationTemplate(template: unknown): unknown;

package/dist-types/packages/peach-engine/src/render-worker/graphite-pipeline-compiler-contract.d.ts

@@ -0,0 +1,49 @@
+export interface CompilerBindGroupLayout {
+    readonly descriptor: GPUBindGroupLayoutDescriptor;
+}
+export interface CompilerPipelineLayout {
+    readonly descriptor: Omit<GPUPipelineLayoutDescriptor, 'bindGroupLayouts'> & {
+        readonly bindGroupLayouts: readonly (CompilerBindGroupLayout | null | undefined)[];
+    };
+}
+export interface CompilerShaderModule {
+    readonly descriptor: Omit<GPUShaderModuleDescriptor, 'compilationHints'> & {
+        readonly compilationHints?: readonly {
+            readonly entryPoint: string;
+            readonly layout?: CompilerPipelineLayout | GPUAutoLayoutMode;
+        }[];
+    };
+}
+export interface CompilerPipelineDescriptor extends Omit<GPURenderPipelineDescriptor, 'layout' | 'vertex' | 'fragment'> {
+    readonly layout: CompilerPipelineLayout | GPUAutoLayoutMode;
+    readonly vertex: Omit<GPUVertexState, 'module'> & {
+        readonly module: CompilerShaderModule;
+    };
+    readonly fragment?: Omit<GPUFragmentState, 'module'> & {
+        readonly module: CompilerShaderModule;
+    };
+}
+export interface PipelineCompilerRequest {
+    readonly id: number;
+    readonly descriptor: CompilerPipelineDescriptor;
+}
+export type PipelineCompilerReply = {
+    readonly kind: 'compiled';
+    readonly id: number;
+} | {
+    readonly kind: 'rejected';
+    readonly id: number;
+    readonly error: string;
+} | {
+    readonly kind: 'failed';
+    readonly error: string;
+};
+export interface PipelineCompilerStats {
+    readonly active: boolean;
+    readonly lanes: number;
+    readonly started: number;
+    readonly finished: number;
+    readonly failed: number;
+    readonly pending: number;
+    readonly lastError: string | null;
+}

package/dist-types/packages/peach-engine/src/render-worker/graphite-pipeline-compiler.d.ts

@@ -0,0 +1,12 @@
+import type { PipelineCompilerStats } from './graphite-pipeline-compiler-contract.d.ts';
+export declare const COMPILER_LANES: number;
+export declare class GraphitePipelineCompiler {
+    #private;
+    constructor(device: GPUDevice);
+    run<T>(priority: 'foreground' | 'background', issue: () => T): T;
+    getStats(): PipelineCompilerStats;
+    displayPipelinesSettled(): Promise<void> | null;
+    allPipelinesSettled(): Promise<void> | null;
+    release(): void;
+    dispose(): void;
+}