peachsim 0.1.1644 → 0.1.1653

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

@@ -0,0 +1,57 @@
+import type { PaintBoundaryNode, PaintBoundaryState } from './paint-boundary-types.d.ts';
+import type { SootSimStyle } from './types.d.ts';
+export type { PaintBoundaryNode, PaintBoundaryState, PaintChunk, RecordOrigin, TextureLayerFlattenSnapshot, } from './paint-boundary-types.d.ts';
+export declare function getDynamicColorEpoch(pinned: boolean): number;
+export declare function createPaintBoundaryState(): PaintBoundaryState;
+export declare function ensurePaintBoundaryState(node: PaintBoundaryNode): PaintBoundaryState;
+export declare const SCROLL_RETENTION: {
+    retainContent: boolean;
+    rowRaster: boolean;
+    transitionActive: boolean;
+};
+export declare function applyScrollRetentionFromUrl(href: string | null | undefined, chromiumSchedulerAvailable: boolean): void;
+export declare function setScrollRetentionTransitionActive(active: boolean): void;
+export declare function isScrollContentContainer(node: PaintBoundaryNode): boolean;
+export declare function subtreeSamplesLiveBackdropCached(node: PaintBoundaryNode): boolean;
+export type LayerHostReason = 'explicit' | 'scroll-container' | 'auto-retained-scroll' | 'presentation' | 'driven-transform' | 'driven-opacity' | 'driven-frame' | 'animated-value' | 'window-light';
+export declare function layerHostReason(node: PaintBoundaryNode): LayerHostReason | null;
+export declare function isLayerHost(node: PaintBoundaryNode): boolean;
+export declare function isAutoRetainedScrollContent(node: PaintBoundaryNode): boolean;
+export declare function hasScrollAncestor(node: PaintBoundaryNode): boolean;
+export declare function isAutoRetainedScrollContentBase(node: PaintBoundaryNode): boolean;
+export declare function adaptiveForegroundGlassAncestor<T extends {
+    rawStyle: Readonly<SootSimStyle>;
+    parent: T | null;
+}>(node: T, throughPreservedForeground?: boolean): T | null;
+export declare function subtreeSamplesLiveBackdrop(node: PaintBoundaryNode): boolean;
+export declare function subtreeReadsLayerBackdrop(node: PaintBoundaryNode): boolean;
+export declare function subtreeContainsTextInputHost(node: PaintBoundaryNode): boolean;
+export declare function subtreeContainsLivePresentation(node: PaintBoundaryNode): boolean;
+export declare function invalidateTextPresentationBoundary(node: PaintBoundaryNode): void;
+export declare function invalidateSubtreeLivePresentationCache(node: PaintBoundaryNode): void;
+export declare function subtreeContainsRasterImage(node: {
+    _sceneSlot: number;
+}): boolean;
+export declare function readImageSourceUri(source: unknown): string | null;
+export declare function readImageSourceScale(source: unknown): number;
+export declare function dropNativeReplay(state: PaintBoundaryState): void;
+export declare function beginPictureImages(): void;
+export declare function notePictureImage(cacheKey: string): void;
+export declare function endPictureImages(): string[];
+export declare function abandonPictureImages(): void;
+export declare function pictureDrawsImage(cacheKey: string): boolean;
+export declare function releaseChunks(state: PaintBoundaryState, flattenReleaseReason?: 'param' | 'content'): void;
+export declare function publishBoundaryRecord(node: PaintBoundaryNode, state: PaintBoundaryState): void;
+export declare function releaseRasterCachesInSubtree(node: PaintBoundaryNode): number;
+export declare function isMovingPaintChild(state: PaintBoundaryState, child: PaintBoundaryNode): boolean;
+export declare function invalidateNearestPaintBoundary(node: PaintBoundaryNode | null | undefined, cause?: string, mutation?: 'content' | 'geometry' | 'paint' | 'scroll'): void;
+export declare function paintBoundaryStyleChangePreservesChildContent(node: PaintBoundaryNode, changedKeys: ReadonlySet<string>): boolean;
+export declare function animatedUpdateInvalidatesPaintContent(node: PaintBoundaryNode, wasLayerHost: boolean, update: {
+    layoutAffecting: boolean;
+    changedKeys: ReadonlySet<string>;
+}): boolean;
+export declare function disposePaintBoundary(node: PaintBoundaryNode): void;
+export declare function disposePaintBoundariesInSubtree(node: PaintBoundaryNode): void;
+export declare function getLivePaintBoundaryCount(): number;
+export declare function captureRecordOrigin(state: PaintBoundaryState, x: number, y: number): void;
+export declare function recordOriginMatches(state: PaintBoundaryState, x: number, y: number): boolean;

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

@@ -0,0 +1,21 @@
+import type { SootSimNode } from './node.d.ts';
+export interface NativeWindowPresentation {
+    target: 'app-window' | 'keyboard-window';
+    order: number;
+}
+export interface PortalDestination {
+    node: SootSimNode;
+    host: SootSimNode | null;
+    window: SootSimNode | null;
+}
+export interface PortalPlan {
+    portals: readonly PortalDestination[];
+    appPortals: readonly SootSimNode[];
+    hostedPortals: ReadonlyMap<SootSimNode, readonly SootSimNode[]>;
+    windows: readonly NativeWindowPortalLayer[];
+}
+export interface NativeWindowPortalLayer {
+    root: SootSimNode;
+    presentation: NativeWindowPresentation;
+    portals: readonly SootSimNode[];
+}

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

@@ -0,0 +1,20 @@
+import { type DamageBatch } from './render-damage.d.ts';
+import type { DamageRect } from './damage-rect.d.ts';
+import type { SootSimNode } from './node.d.ts';
+import type { NativeWindowPresentation, PortalPlan } from './portalContract.d.ts';
+import type { RenderContext } from './types.d.ts';
+export declare function readNativeWindowPresentation(node: SootSimNode): NativeWindowPresentation | null;
+export declare function subtreePortalEnds(node: SootSimNode): {
+    views: SootSimNode[];
+    holdsHost: boolean;
+};
+export interface PhasedDamage {
+    entries?: DamageBatch;
+}
+export declare function addPhasedRect(into: PhasedDamage, rect: DamageRect | null, portal: boolean): void;
+export declare function addNodeDamage(into: PhasedDamage, node: SootSimNode, rect: DamageRect | null, keepsOwnCapture?: boolean): void;
+export declare function addPhasedDamage(ctx: RenderContext, from: PhasedDamage): void;
+export declare function findPortalHost(root: SootSimNode, portal: SootSimNode): SootSimNode | null;
+export declare function getPortalPlan(root: SootSimNode): PortalPlan;
+export declare function getHostedPortals(host: SootSimNode): readonly SootSimNode[];
+export declare function syncPortalHostPositions(root: SootSimNode): void;

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

@@ -0,0 +1,107 @@
+import { type DamageRect } from './damage-rect.d.ts';
+import type { Surface } from 'canvaskit-wasm';
+export declare const DAMAGE_CLIP_THRESHOLD = 0.8;
+declare const CLIP_REASONS: readonly [null, 'no-damage', 'full-damage', 'empty-damage', 'empty-surface', 'threshold'];
+interface DamageNative {
+    _peach_damage_batch_input(count: number): number;
+    _peach_damage_batch(id: number, count: number): void;
+    _peach_damage_glass_read(id: number, index: number): number;
+    _peach_damage_out(): number;
+    _peach_damage_create(): number;
+    _peach_damage_dispose(id: number): void;
+    _peach_damage_add(id: number, bucket: number, left: number, top: number, right: number, bottom: number): void;
+    _peach_damage_source_pair(id: number, hasBefore: number, beforeLeft: number, beforeTop: number, beforeRight: number, beforeBottom: number, hasAfter: number, afterLeft: number, afterTop: number, afterRight: number, afterBottom: number): void;
+    _peach_damage_glass_content(id: number, glassId: number, portal: number, left: number, top: number, right: number, bottom: number): void;
+    _peach_damage_touch(id: number): void;
+    _peach_damage_unknown(id: number, unknown: number): void;
+    _peach_damage_force_full(id: number): void;
+    _peach_damage_glow_ratio(id: number, width: number, height: number): number;
+    _peach_damage_glow_paint(id: number, width: number, height: number): number;
+    _peach_damage_glow_pending(id: number, full: number, resetTime: number): void;
+    _peach_damage_glow_due(id: number, eligible: number, now: number, width: number, height: number, threshold: number, interval: number, event: number): number;
+    _peach_damage_glow_complete(id: number, failed: number): void;
+    _peach_damage_reset(id: number): void;
+    _peach_damage_begin(id: number, width: number, height: number, dpr: number, threshold: number, forced: number, root: number, floor: number): void;
+    _peach_damage_end(id: number, hasReplayed: number, left: number, top: number, right: number, bottom: number, moved: number): void;
+    _peach_damage_read(id: number, which: number): void;
+    _peach_layout_damage_slots(count: number): number;
+    _peach_layout_damage(id: number, count: number, mode: number): number;
+    readonly HEAPU8: Uint8Array;
+}
+export interface FrameDamage {
+    readonly native: DamageNative;
+    readonly id: number;
+}
+export declare function createFrameDamage(module: object, initial: DamageRect | null): FrameDamage;
+export declare function disposeFrameDamage(damage: FrameDamage | null | undefined): void;
+export declare function frameDamageId(damage: FrameDamage | null | undefined, module: object): number;
+export declare function addSourceDamagePair(damage: FrameDamage | null | undefined, before: DamageRect | null, after: DamageRect | null): void;
+export type DamageBatch = number[];
+export declare function addDamageBatch(damage: FrameDamage | null | undefined, entries: DamageBatch): void;
+export declare const LAYOUT_DAMAGE: {
+    readonly begin: 0;
+    readonly continue: 1;
+    readonly landed: 2;
+};
+export type LayoutDamageMode = (typeof LAYOUT_DAMAGE)[keyof typeof LAYOUT_DAMAGE];
+export declare function addLayoutMovedDamage(damage: FrameDamage | null | undefined, nodes: readonly {
+    readonly _sceneSlot: number;
+}[], mode: LayoutDamageMode): boolean;
+export declare function pendingPhaseDamage(damage: FrameDamage): {
+    source: DamageRect | null;
+    portal: DamageRect | null;
+    glassContents: {
+        id: number;
+        portal: boolean;
+        rect: DamageRect;
+    }[];
+};
+export declare function addDamage(damage: FrameDamage | null | undefined, rect: DamageRect | null | undefined): void;
+export declare function addPortalDamage(damage: FrameDamage | null | undefined, rect: DamageRect | null | undefined): void;
+export declare function addGlassAnimationDamage(damage: FrameDamage | null | undefined, rect: DamageRect | null | undefined): void;
+export declare function addGlassContentDamage(damage: FrameDamage | null | undefined, glassId: number, rect: DamageRect, portal: boolean): void;
+export declare function addBackdropSample(damage: FrameDamage | null | undefined, rect: DamageRect | null | undefined): void;
+export declare function addTransformedBackdropSample(damage: FrameDamage | null | undefined, dpr: number, sourceSurface: Surface, matrix: Float32Array | number[], x: number, y: number, w: number, h: number): void;
+export declare function touchDamage(damage: FrameDamage | null | undefined): void;
+export declare function setSourceUnknown(damage: FrameDamage | null | undefined, unknown: boolean): void;
+export declare function forceFullRedraw(damage: FrameDamage | null | undefined): void;
+export declare function ambientGlowDamageRatio(damage: FrameDamage | null | undefined, width: number, height: number): number;
+export declare function noteAmbientGlowDamage(damage: FrameDamage | null | undefined, width: number, height: number): number;
+export declare function setAmbientGlowDamage(damage: FrameDamage | null | undefined, full: boolean, resetTime?: boolean): void;
+export type AmbientGlowSampleEvent = 'query' | 'begin' | 'finish';
+export declare function ambientGlowSampleDelay(damage: FrameDamage | null | undefined, eligible: boolean, now: number, width: number, height: number, threshold: number, interval: number, event?: AmbientGlowSampleEvent): number | null;
+export declare function completeAmbientGlowSample(damage: FrameDamage | null | undefined, failed: boolean): void;
+export declare function resetDamage(damage: FrameDamage | null | undefined): void;
+export interface PendingDamage {
+    source: DamageRect | null;
+    unknown: boolean;
+    forceFull: boolean;
+    glassAnimation: boolean;
+}
+export declare function pendingDamage(damage: FrameDamage): PendingDamage;
+export declare function hasFullDamage(damage: FrameDamage | null | undefined): boolean;
+export declare function hasDeferredDamage(damage: FrameDamage | null | undefined): boolean;
+export declare function hasPendingDamage(damage: FrameDamage | null | undefined): boolean;
+export declare function currentFrameClip(damage: FrameDamage): DamageRect | null;
+export declare function lastFrameClip(damage: FrameDamage | null | undefined): DamageRect | null;
+export declare function lastBackdropSample(damage: FrameDamage | null | undefined): DamageRect | null;
+export interface DamageFrame {
+    source: DamageRect | null;
+    sourceUnknown: boolean;
+    portal: DamageRect | null;
+    glassAnimation: boolean;
+    initial: DamageRect | null;
+    clip: DamageRect | null;
+    reason: (typeof CLIP_REASONS)[number];
+    area: number;
+    ratio: number;
+    grown: boolean;
+}
+export declare function beginDamageFrame(damage: FrameDamage, forced: boolean, width: number, height: number, dpr: number, root: number, floor: number): DamageFrame;
+export interface DamageFrameEnd {
+    discovered: DamageRect | null;
+    damage: DamageRect | null;
+    deferred: DamageRect | null;
+}
+export declare function endDamageFrame(damage: FrameDamage, replayedGlass: DamageRect | null, replayedGlassMoved: boolean): DamageFrameEnd;
+export {};

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

@@ -0,0 +1,420 @@
+import type { ImageFrameSource } from '../render-worker/image-pixel-contract.d.ts';
+export type RiveScalarType = 'number' | 'string' | 'boolean' | 'color' | 'enum';
+export type RiveScalar = number | string | boolean;
+export type RiveEventDescriptor = {
+    name: string;
+    type?: number;
+    delay?: number;
+    properties?: Record<string, RiveScalar>;
+    url?: string;
+    target?: string;
+};
+export type RiveProperty = {
+    name: string;
+    type: RivePropertyKind | 'unsupported';
+};
+export type RiveIndexedSelection = {
+    type: 'name';
+    name: string;
+} | {
+    type: 'index';
+    index: number;
+};
+export type RiveArtboardSelection = RiveIndexedSelection | {
+    type: 'default';
+};
+export type RiveInstanceSelection = RiveArtboardSelection | {
+    type: 'blank';
+};
+export type RiveInputDescriptor = {
+    name: string;
+    type: 'boolean' | 'number' | 'trigger';
+};
+export type RiveArtboardDescriptor = {
+    kind: 'artboard';
+    id: number;
+    name: string;
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    width: number;
+    height: number;
+    animationNames: string[];
+    stateMachineNames: string[];
+};
+export type RiveMachineDescriptor = {
+    kind: 'machine';
+    id: number;
+    name: string;
+    inputs: RiveInputDescriptor[];
+};
+declare const RIVE_ALIGNMENTS: readonly ['topLeft', 'topCenter', 'topRight', 'centerLeft', 'center', 'centerRight', 'bottomLeft', 'bottomCenter', 'bottomRight'];
+export type RiveAlignment = (typeof RIVE_ALIGNMENTS)[number];
+export type RiveViewBinding = {
+    type: 'auto';
+} | {
+    type: 'none';
+} | {
+    type: 'instance';
+    instanceId: number;
+} | {
+    type: 'byName';
+    name: string;
+};
+export type RiveViewConfiguration = {
+    fileId: number;
+    artboardName?: string;
+    stateMachineName?: string;
+    autoPlay: boolean;
+    fit: number;
+    alignment: RiveAlignment;
+    layoutScaleFactor?: number;
+    preferredFramesPerSecond?: number;
+};
+export type RiveWatchType = RiveScalarType | 'trigger' | 'list' | 'image';
+export type RivePropertyKind = RiveWatchType | 'artboard';
+export type RiveListAction = {
+    action: 'length';
+} | {
+    action: 'at' | 'removeAt';
+    index: number;
+} | {
+    action: 'add' | 'remove';
+    valueId: number;
+} | {
+    action: 'addAt';
+    valueId: number;
+    index: number;
+} | {
+    action: 'swap';
+    index: number;
+    other: number;
+};
+export type RivePropertyChange = {
+    instanceId: number;
+    path: string;
+    propertyType: RiveWatchType;
+    value?: RiveScalar;
+};
+export type RiveLinearAnimationDescriptor = {
+    kind: 'animation';
+    id: number;
+    name: string;
+    duration: number;
+    fps: number;
+    workStart: number;
+    workEnd: number;
+};
+export type RiveSharedViewConfiguration = {
+    artboardId: number;
+    machineId?: number;
+    animationId?: number;
+    fit: number;
+    alignment: RiveAlignment;
+    layoutScaleFactor?: number;
+    preferredFramesPerSecond?: number;
+};
+export type RiveOperation = {
+    type: 'initialize';
+} | ({
+    type: 'view';
+} & RiveViewConfiguration) | ({
+    type: 'sharedView';
+} & RiveSharedViewConfiguration) | ({
+    type: 'viewConfiguration';
+    viewId: number;
+} & Pick<RiveViewConfiguration, 'fit' | 'alignment' | 'layoutScaleFactor' | 'preferredFramesPerSecond'>) | {
+    type: 'frame';
+    viewId: number;
+    channelId: string;
+    refresh: boolean;
+    playing: boolean;
+    onscreen: boolean;
+    width: number;
+    height: number;
+    pixelRatio: number;
+} | {
+    type: 'pointer';
+    machineId: number;
+    fit: number;
+    alignment: RiveAlignment;
+    phase: 'down' | 'move' | 'up' | 'exit';
+    x: number;
+    y: number;
+    pointerId: number;
+    width: number;
+    height: number;
+} | {
+    type: 'play' | 'pause' | 'reset';
+    viewId: number;
+} | {
+    type: 'viewBind';
+    viewId: number;
+    binding: RiveViewBinding;
+} | {
+    type: 'viewInstance';
+    viewId: number;
+} | {
+    type: 'viewInput';
+    viewId: number;
+    name: string;
+    path?: string;
+    input: 'number' | 'boolean' | 'trigger';
+    value?: number | boolean;
+} | {
+    type: 'viewText';
+    viewId: number;
+    name: string;
+    path?: string;
+    value?: string;
+} | {
+    type: 'artboardText';
+    artboardId: number;
+    name: string;
+    path?: string;
+    value?: string;
+} | {
+    type: 'trigger' | 'nested';
+    instanceId: number;
+    path: string;
+} | {
+    type: 'instanceName';
+    instanceId: number;
+} | {
+    type: 'has';
+    instanceId: number;
+    path: string;
+    propertyType: RivePropertyKind;
+} | {
+    type: 'assetValue';
+    instanceId: number;
+    path: string;
+    asset: 'image' | 'artboard';
+    valueId?: number;
+} | {
+    type: 'image';
+    bytes: ArrayBuffer;
+} | {
+    type: 'font';
+    bytes: ArrayBuffer;
+} | {
+    type: 'fallbackFonts';
+    weights?: RiveFallbackWeight[];
+} | {
+    type: 'bindableArtboard';
+    fileId: number;
+    name: string;
+} | {
+    type: 'replace';
+    instanceId: number;
+    path: string;
+    valueId: number;
+} | ({
+    type: 'list';
+    instanceId: number;
+    path: string;
+} & RiveListAction) | {
+    type: 'watch';
+    instanceId: number;
+    path: string;
+    propertyType: RiveWatchType;
+    watch: boolean;
+} | {
+    type: 'load';
+    bytes: ArrayBuffer;
+    loadCdn: boolean;
+    referenced?: string[];
+} | {
+    type: 'assetData';
+    fileId: number;
+    uniqueName: string;
+    bytes?: ArrayBuffer;
+    imageId?: number;
+} | {
+    type: 'artboard';
+    fileId: number;
+    selection: RiveArtboardSelection;
+} | {
+    type: 'machine';
+    artboardId: number;
+    selection: RiveIndexedSelection;
+} | {
+    type: 'animation';
+    artboardId: number;
+    selection: RiveIndexedSelection;
+} | {
+    type: 'animationTime';
+    animationId: number;
+    time?: number;
+} | {
+    type: 'animationAdvance';
+    animationId: number;
+    elapsed: number;
+} | {
+    type: 'animationLoop';
+    animationId: number;
+    loop?: number;
+} | {
+    type: 'animationDirection';
+    animationId: number;
+    direction?: number;
+} | {
+    type: 'animationDidLoop';
+    animationId: number;
+} | {
+    type: 'advance';
+    id: number;
+    elapsed: number;
+} | {
+    type: 'artboardMetrics';
+    artboardId: number;
+} | {
+    type: 'states' | 'events';
+    machineId: number;
+} | {
+    type: 'input';
+    machineId: number;
+    index: number;
+    value?: number | boolean;
+    fire?: boolean;
+} | {
+    type: 'nestedInput';
+    artboardId: number;
+    name: string;
+    path: string;
+    value?: number | boolean;
+    fire?: boolean;
+} | {
+    type: 'model';
+    fileId: number;
+    name: string;
+} | {
+    type: 'modelIndex';
+    fileId: number;
+    index: number;
+} | {
+    type: 'defaultModel';
+    fileId: number;
+    artboard: string | number | undefined;
+} | {
+    type: 'instance';
+    modelId: number;
+    selection: RiveInstanceSelection;
+} | {
+    type: 'read';
+    instanceId: number;
+    path: string;
+    propertyType: RiveScalarType;
+} | {
+    type: 'write';
+    instanceId: number;
+    path: string;
+    propertyType: RiveScalarType;
+    value: RiveScalar;
+} | {
+    type: 'retain';
+    id: number;
+} | {
+    type: 'release';
+    id: number;
+};
+export type RiveFallbackWeight = {
+    weight: number;
+    fonts: (number | 'system')[];
+};
+export type RiveFileDescriptor = {
+    kind: 'file';
+    id: number;
+    artboardNames: string[];
+    defaultArtboardName: string | undefined;
+    defaultMachineIndexes: (number | null)[] | null;
+    stateMachineNames: Record<string, string[]>;
+    viewModelNames: string[];
+    assets: {
+        uniqueName: string;
+        key: string;
+    }[];
+};
+export type RiveModelDescriptor = {
+    kind: 'model';
+    id: number;
+    modelName: string;
+    propertyCount: number;
+    instanceNames: string[];
+    properties: RiveProperty[];
+};
+export type RiveInstanceDescriptor = {
+    kind: 'instance';
+    id: number;
+    properties: RiveProperty[];
+};
+export type RiveResult = RiveFileDescriptor | RiveModelDescriptor | RiveInstanceDescriptor | RiveArtboardDescriptor | RiveMachineDescriptor | RiveLinearAnimationDescriptor | ({
+    kind: 'artboardMetrics';
+} & Pick<RiveArtboardDescriptor, 'bounds' | 'width' | 'height'>) | {
+    kind: 'states';
+    names: string[];
+} | {
+    kind: 'events';
+    events: RiveEventDescriptor[];
+} | {
+    kind: 'value';
+    value: RiveScalar;
+    changed?: boolean;
+} | {
+    kind: 'missing';
+} | {
+    kind: 'view';
+    id: number;
+} | {
+    kind: 'image';
+    id: number;
+    byteSize: number;
+} | {
+    kind: 'font';
+    id: number;
+} | {
+    kind: 'bindableArtboard';
+    id: number;
+    name: string;
+} | {
+    kind: 'frame';
+    bitmap?: ImageFrameSource;
+    events?: RiveEventDescriptor[];
+    changes?: RivePropertyChange[];
+} | {
+    kind: 'done';
+};
+export type RiveHostResponse = {
+    type: 'riveResult';
+    requestId: number;
+    ok: true;
+    result: RiveResult;
+} | {
+    type: 'riveResult';
+    requestId: number;
+    ok: false;
+    error: string;
+};
+export declare function isRiveOperation(value: unknown): value is RiveOperation;
+export declare const RIVE_SYNC_REPLY_BYTES: number;
+export type RiveSyncResponse = {
+    ok: true;
+    result: RiveResult;
+} | {
+    ok: false;
+    error: string;
+};
+export type RiveSyncOperation = Extract<RiveOperation, {
+    type: 'initialize' | 'load' | 'retain' | 'release' | 'model' | 'modelIndex' | 'defaultModel' | 'instance' | 'read' | 'artboard' | 'machine' | 'animation' | 'animationTime' | 'animationAdvance' | 'animationLoop' | 'animationDirection' | 'animationDidLoop' | 'advance' | 'states' | 'events' | 'input' | 'nestedInput' | 'pointer' | 'artboardMetrics' | 'sharedView' | 'viewConfiguration' | 'viewBind' | 'viewInstance' | 'viewInput' | 'viewText' | 'artboardText' | 'trigger' | 'nested' | 'instanceName' | 'assetValue' | 'bindableArtboard' | 'font' | 'watch' | 'has' | 'replace' | 'list';
+}>;
+export declare function isRiveSyncOperation(value: unknown): value is RiveSyncOperation;
+export declare function completeRiveSyncReply(reply: SharedArrayBuffer, response: RiveSyncResponse): void;
+declare let requestRiveSync: ((operation: RiveSyncOperation) => RiveResult) | undefined;
+export declare function callRiveHostSync(operation: RiveSyncOperation): RiveResult;
+declare let requestRive: ((operation: RiveOperation) => Promise<RiveResult>) | undefined;
+export declare function setRiveHostService(service: typeof requestRive, syncService?: typeof requestRiveSync): void;
+export declare function callRiveHost(operation: RiveOperation): Promise<RiveResult>;
+export {};

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

@@ -0,0 +1,51 @@
+export declare function fromOrigamiTensionAndFriction(tension: number, friction: number): {
+    stiffness: number;
+    damping: number;
+};
+export declare function fromBouncinessAndSpeed(bounciness: number, speed: number): {
+    stiffness: number;
+    damping: number;
+};
+export interface SpringInput {
+    toValue?: number;
+    velocity?: number;
+    bounciness?: number;
+    speed?: number;
+    tension?: number;
+    friction?: number;
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    overshootClamping?: boolean;
+    restDisplacementThreshold?: number;
+    restSpeedThreshold?: number;
+    restVelocityThreshold?: number;
+    uikitRestEpsilon?: number;
+}
+export interface ResolvedSpring {
+    stiffness: number;
+    damping: number;
+    mass: number;
+    initialVelocity: number;
+    overshootClamping: boolean;
+    restDisplacementThreshold: number;
+    restSpeedThreshold: number;
+    uikitRestEpsilon?: number;
+}
+export declare function resolveSpringConfig(config: SpringInput): ResolvedSpring;
+export declare function springAtRest(resolved: ResolvedSpring, toValue: number, position: number, velocity: number): boolean;
+export interface SpringSample {
+    value: number;
+    velocity: number;
+    done: boolean;
+}
+export interface SpringSampler {
+    (now: number): SpringSample;
+    lastVelocity: number;
+    lastTime: number | null;
+}
+export declare function evaluateRNSpringAt(fromValue: number, resolved: Pick<ResolvedSpring, 'stiffness' | 'damping' | 'mass' | 'initialVelocity'>, toValue: number, tSeconds: number): {
+    position: number;
+    velocity: number;
+};
+export declare function createRNSpringSampler(fromValue: number, resolved: ResolvedSpring, toValue: number, previous?: SpringSampler | null, startedAt?: number | null): SpringSampler;