peachsim 0.1.1644 → 0.1.1653

package/dist-types/packages/peach-compat/src/stubs/transition-scalar.d.ts

@@ -0,0 +1,25 @@
+export interface TransitionScalarMath<T> {
+    constant(value: number): T;
+    add(a: T, b: T): T;
+    sub(a: T, b: T): T;
+    mul(a: T, b: T): T;
+    div(a: T, b: T): T;
+    min(a: T, b: T): T;
+    max(a: T, b: T): T;
+    gt(a: T, b: T): T;
+    gte(a: T, b: T): T;
+    select(condition: T, yes: T, no: T): T;
+    neg(value: T): T;
+    pow(value: T, exponent: T): T;
+    cbrt(value: T): T;
+    exp(value: T): T;
+    sin(value: T): T;
+    cos(value: T): T;
+    sqrt(value: T): T;
+    abs(value: T): T;
+    quotient(a: T, b: T): T;
+    sampledCurve(samples: readonly number[], elapsedMs: T, frameMs: number): T;
+    presentationSpring(elapsedMs: T, response: number, damping: number): T;
+}
+export declare const transitionNumberMath: TransitionScalarMath<number>;
+export declare function transitionClamp<T>(math: TransitionScalarMath<T>, value: T): T;

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

@@ -0,0 +1,64 @@
+export type Plan = 'free' | 'carbon' | 'carbon_plus' | 'peach_team' | 'enterprise';
+export type CheckoutPlan = 'topup';
+export declare const PLANS: readonly Plan[];
+export declare const CHECKOUT_PLANS: readonly ["topup"];
+export declare function isCheckoutPlan(value: unknown): value is CheckoutPlan;
+export type BillingProduct = 'contrast' | 'sootsim';
+export declare const PLAN_LABELS: Record<Exclude<Plan, 'free'>, string>;
+export declare function planLabel(plan: Plan, product: BillingProduct): string;
+export type BillingEntitlements = {
+    apiKeys: boolean;
+    ciUploads: boolean;
+    desktopRecording: boolean;
+    teamWorkflows: boolean;
+    agentFlows: boolean;
+    aiFlows: boolean;
+};
+export declare const CARBON_MONTHLY_PRICE = 10;
+export declare const CARBON_MONTHLY_DISPLAY = "$10/mo";
+export declare const CARBON_YEARLY_PRICE = 100;
+export declare const PEACH_TEAM_MONTHLY_PRICE = 30;
+export declare const PEACH_TEAM_YEARLY_PRICE = 300;
+export declare const PEACH_TEAM_MONTHLY_INCLUDED_USD = 10;
+export type BillingInterval = 'month' | 'year';
+export declare const TOPUP_MIN_USD = 5;
+export declare const TOPUP_MAX_USD = 500;
+export declare const TOPUP_PRESETS_USD: readonly [10, 20];
+export declare const TOPUP_DEFAULT_USD = 10;
+export declare const PEACH_TOPUP_MATCH_MAX_USD = 20;
+export declare const STARTER_MONTHLY_FREE_USD = 5;
+export declare const AUTO_TOPUP_THRESHOLD_USD = 2;
+export declare const AUTO_TOPUP_DEFAULT_MONTHLY_CAP_USD = 50;
+export declare function parseTopupUsd(value: unknown): number | null;
+export declare function formatUsd(usd: number): string;
+export declare const MICROCENTS_PER_USD = 1000000;
+export declare function formatBillingMicrocents(microcents: number): string;
+export declare function formatBillingUsdCents(cents: number): string;
+export declare const SOOTSIM_PREVIEW_UPLOAD_USD_CENTS = 2;
+export declare const SOOTSIM_AI_FLOW_USD_CENTS = 20;
+export type RequestSurface = 'ui' | 'ci' | 'api';
+export declare const SOOTSIM_API_PREVIEW_UPLOAD_USD_CENTS = 2;
+export declare function sootsimPreviewUploadUsdCentsFor(surface: RequestSurface): number;
+export declare const CARBON_CLOUD_POLICY: {
+    readonly activePreviewRetention: 25000;
+    readonly previewRetentionDays: 90;
+    readonly flowVideoRetentionDays: 90;
+};
+export type CarbonCloudPolicy = typeof CARBON_CLOUD_POLICY;
+export declare const CARBON_PLUS_CLOUD_POLICY: {
+    readonly activePreviewRetention: 25000;
+    readonly previewRetentionDays: 365;
+    readonly flowVideoRetentionDays: 365;
+};
+export type CarbonPlusCloudPolicy = typeof CARBON_PLUS_CLOUD_POLICY;
+export declare const ENTERPRISE_CLOUD_POLICY: {
+    readonly activePreviewRetention: 250000;
+    readonly previewRetentionDays: 1095;
+    readonly flowVideoRetentionDays: 730;
+};
+export type EnterpriseCloudPolicy = typeof ENTERPRISE_CLOUD_POLICY;
+export declare function cloudPolicyFor(plan: Plan): CarbonCloudPolicy | CarbonPlusCloudPolicy | EnterpriseCloudPolicy | null;
+export declare function planEntitlementsFor(plan: Plan): BillingEntitlements;
+export declare const DEFAULT_SPENDING_CAP_USD_CENTS = 10000;
+export declare const SPENDING_CAP_ALERT_THRESHOLDS: readonly [0.5, 0.8, 1];
+export declare const TEAM_DEFAULT_MODEL = "claude-sonnet-4-6";

package/dist-types/packages/peach-engine/src/browser-page-target.d.ts

@@ -0,0 +1,2 @@
+import type { Page } from 'playwright-core';
+export declare function createBrowserPageTargetReader(): (page: Page) => Promise<string>;

package/dist-types/packages/peach-engine/src/bundle-platform-url.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimePlatform } from '../../../../src/device-catalog.ts';
+export declare function bundleUrlForPlatform(bundleUrl: string, platform: RuntimePlatform, base: () => string): string;
+export declare function bundleUrlForActivePlatform(bundleUrl: string): string;

package/dist-types/packages/peach-engine/src/capture/browser-accessibility-host.d.ts

@@ -0,0 +1,3 @@
+import type { BrowserAccessibilityCapture } from './browserAccessibilityContract.d.ts';
+import type { Page } from 'playwright-core';
+export declare function captureBrowserAccessibility(page: Page, instanceIds: string[]): Promise<BrowserAccessibilityCapture>;

package/dist-types/packages/peach-engine/src/capture/browser-composite.d.ts

@@ -0,0 +1,55 @@
+export interface BrowserCompositeCaptureRequest {
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    outputWidth: number;
+    outputHeight: number;
+}
+export interface BrowserCompositeCapture {
+    dataUrl: string;
+    originX: number;
+    originY: number;
+}
+export type BrowserCompositeCaptureProvider = (request: BrowserCompositeCaptureRequest) => Promise<BrowserCompositeCapture>;
+export declare function assertBrowserCompositeRootStill(expected: BrowserCompositeCaptureRequest['rect'], actual: BrowserCompositeCaptureRequest['rect']): void;
+export declare function resolveBrowserCompositeCdpClip(request: BrowserCompositeCaptureRequest, metrics: unknown): {
+    clip: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        scale: number;
+    };
+    originX: number;
+    originY: number;
+};
+export declare const BROWSER_COMPOSITE_RIM_COLORS: {
+    readonly light: 'rgb(255 255 255)';
+    readonly dark: 'rgb(0 0 0)';
+};
+export declare const BROWSER_COMPOSITE_RIM_WIDTH = 4;
+export interface BrowserCompositeRaster {
+    width: number;
+    height: number;
+    read(x: number, y: number, width: number, height: number): Uint8ClampedArray;
+}
+export declare function browserCompositeOverscan(outputScale: number): number;
+export declare function locateBrowserCompositePaintedOrigin(rims: {
+    light: BrowserCompositeRaster;
+    dark: BrowserCompositeRaster;
+}, size: {
+    width: number;
+    height: number;
+}, hint: {
+    x: number;
+    y: number;
+}, outputScale: number): {
+    x: number;
+    y: number;
+};
+export declare function readBrowserCompositeCapture(value: unknown): BrowserCompositeCapture;
+export declare function readBrowserCompositeCaptureRequest(value: unknown): BrowserCompositeCaptureRequest;
+export declare function getBrowserCompositeCaptureProvider(preparePresentation: () => Promise<void>): BrowserCompositeCaptureProvider | undefined;

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

@@ -0,0 +1,27 @@
+import type { NativeSurfacePresented } from '../../../peach-globals/src/index.d.ts';
+export interface BrowserAccessibilityNode {
+    nodeId: string;
+    parentId: string | null;
+    role: string;
+    name: string;
+    value: string;
+    disabled: boolean;
+    centerVisible: boolean;
+    frame: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    visibleFrame: BrowserAccessibilityNode['frame'];
+}
+export interface BrowserAccessibilitySurface {
+    captureId: string;
+    presentation: NativeSurfacePresented;
+    nodes: BrowserAccessibilityNode[];
+}
+export interface BrowserAccessibilityCapture {
+    schema: 1;
+    surfaces: BrowserAccessibilitySurface[];
+}
+

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

@@ -0,0 +1,22 @@
+import type { ShellNativeEvaluationOwner, NativeScreenCaptureState } from '../../../peach-globals/src/index.d.ts';
+export type { NativeScreenCaptureState } from '../../../peach-globals/src/index.d.ts';
+export type NativeScreenCaptureRequest = {
+    kind: 'screenCapture.perform';
+    owner: ShellNativeEvaluationOwner;
+    evaluationId: string;
+    objectId: string;
+    requestId: number;
+    platform: 'ios' | 'android';
+    operation: 'attach' | 'observe' | 'prevent' | 'allow' | 'retire';
+};
+export type NativeScreenCaptureSnapshot = {
+    kind: 'screenCapture.snapshot';
+    owner: ShellNativeEvaluationOwner;
+    evaluationId: string;
+    objectId: string;
+    requestId?: number;
+    state: NativeScreenCaptureState;
+    prevented: boolean;
+    windowProtected: boolean;
+    error?: string;
+};

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

@@ -0,0 +1,36 @@
+export declare const cliCompanionAbi = 1;
+export * as billing_plans from './billing/plans.d.ts';
+export * as browser_page_target from './browser-page-target.d.ts';
+export * as bundle_platform_url from './bundle-platform-url.d.ts';
+export * as capture_browser_accessibility_host from './capture/browser-accessibility-host.d.ts';
+export * as capture_browser_composite from './capture/browser-composite.d.ts';
+export * as components_native_ui_webview_frame_bridge from './components/native-ui/webview-frame-bridge.d.ts';
+export * as engine_app_catalog_wire from './engine/app-catalog-wire.d.ts';
+export * as engine_config_plugin_fonts from './engine/config-plugin-fonts.d.ts';
+export * as engine_config_plugin_splash from './engine/config-plugin-splash.d.ts';
+export * as engine_expo_manifest from './engine/expo-manifest.d.ts';
+export * as engine_scroll_platform from './engine/scroll-platform.d.ts';
+export * as guest_import_meta from './guest-import-meta.d.ts';
+export * as guest_module_overrides from './guest-module-overrides.d.ts';
+export * as ios_chrome_metrics from './ios/chrome-metrics.d.ts';
+export * as ios_duo_housing from './ios/duo-housing.d.ts';
+export * as metro_fingerprint from './metro-fingerprint.d.ts';
+export * as metro_fingerprint_registry_client from './metro-fingerprint-registry-client.d.ts';
+export * as peach_warm_manifest from './peach-warm-manifest.d.ts';
+export * as preview_bundle_layout from './preview/bundle-layout.d.ts';
+export * as preview_compress from './preview/compress.d.ts';
+export * as preview_compress_node from './preview/compress-node.d.ts';
+export * as preview_presigned_upload from './preview/presigned-upload.d.ts';
+export * as preview_trace from './preview/trace.d.ts';
+export * as profiler_profile_trace from './profiler/profile-trace.d.ts';
+export * as remote_stream_scene_recording from './remote-stream/scene-recording.d.ts';
+export * as render_worker_app_load from './render-worker/app-load.d.ts';
+export * as screenshots_timeline_assets from './screenshots/timeline-assets.d.ts';
+export * as screenshots_tokens from './screenshots/tokens.d.ts';
+export * as settings_devices from './settings/devices.d.ts';
+export * as settings_duo_fold_bus from './settings/duo-fold-bus.d.ts';
+export * as settings_store from './settings/store.d.ts';
+export * as web_authentication_automation_host from './web-authentication-automation-host.d.ts';
+export * as webview_automation_host from './webview-automation-host.d.ts';
+export * as playwright_sim_host from './playwright-sim-host.d.ts';
+export * as rolldown_production_fingerprint from './rolldown-production-fingerprint.d.ts';

package/dist-types/packages/peach-engine/src/components/native-ui/webview-frame-bridge.d.ts

@@ -0,0 +1,34 @@
+import type { SootSimWebKitConfiguration, SootSimWebViewCookieStore, PeachWebViewDocumentData } from '../../../../peach-globals/src/index.d.ts';
+export declare function webKitNavigationType(type: unknown): number;
+export declare const WEBVIEW_FRAME_CONFIG_ATTRIBUTE = "data-peach-webview-config";
+export declare const WEBVIEW_FRAME_HOOK = "peach.webview";
+export type WebViewFrameBridgeConfig = {
+    documentUrl: string;
+    dataDocumentMetadata?: {
+        mimeType: string;
+        encoding: string;
+    };
+    hasOpenWindowHandler: boolean;
+    cookieStore?: SootSimWebViewCookieStore;
+    webKit?: SootSimWebKitConfiguration;
+    defaultStyle: string;
+    colorScheme: 'light' | 'dark';
+    deviceScale?: number;
+    injectedObjectJson?: string;
+    expoDomWebViewGlobalsSource?: string;
+    beforeKey?: string;
+};
+export declare function expoDomWebViewGlobalsSource(webViewId: number, instanceId: string): string;
+export declare const WEBVIEW_FRAME_BRIDGE_SOURCE: string;
+export declare function webViewHtmlDocument(html: string, { baseUrl, beforeContent, }: {
+    baseUrl?: string;
+    beforeContent?: string;
+}): string;
+export declare function webViewBlankDataDocumentScript(data: PeachWebViewDocumentData, config: WebViewFrameBridgeConfig): string;
+export declare function webViewFrameBridgeScript(config: WebViewFrameBridgeConfig): string;
+export type WebViewFrameElementConfig = WebViewFrameBridgeConfig & {
+    beforeContent: string;
+};
+export declare const WEBVIEW_SAME_ORIGIN_BOOTSTRAP_SOURCE: string;
+export declare function webViewBeforeContentKey(source: string): string;
+export declare const WEBVIEW_HOST_BOOTSTRAP_SOURCE: string;

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

@@ -0,0 +1,5 @@
+import type { PeachConfig as PublicPeachConfig } from '../../../../src/config.ts';
+import type { SettingsValues } from '../../../../src/settingsContract.ts';
+export { PEACH_CONFIG_QUERY_PARAM, applyPeachConfigToUrl, collectConfiguredFileModules, defineConfig, hasPeachConfig, mergePeachConfig, readPeachConfigFromSearchParams, } from '../../../../src/config.ts';
+export type { ModuleResolution, NativeModuleResolution, NativeViewResolution, } from '../../../../src/config.ts';
+export type PeachConfig = PublicPeachConfig<SettingsValues>;

package/dist-types/packages/peach-engine/src/engine/android-stretch-effect.d.ts

@@ -0,0 +1,57 @@
+import type { CanvasKitRenderingApi as CanvasKit } from './canvaskit-api.d.ts';
+import type { Canvas, RuntimeEffect, Surface } from 'canvaskit-wasm';
+export interface AndroidEdgeEffectState {
+    edge: 'top' | 'bottom' | 'left' | 'right';
+    progress: number;
+    mode: 'stretch';
+    overscrollX: number;
+    overscrollY: number;
+    rawDistanceX: number;
+    rawDistanceY: number;
+    releasing: boolean;
+    springVelocityX: number;
+    springVelocityY: number;
+    springLastTime: number;
+}
+export declare function isAndroidEdgeEffectState(value: unknown): value is AndroidEdgeEffectState;
+export declare function androidEdgeEffectStatesEqual(left: AndroidEdgeEffectState | null | undefined, right: AndroidEdgeEffectState | null | undefined): boolean;
+export declare function initAndroidStretchEffect(ck: CanvasKit): RuntimeEffect | null;
+export declare function disposeAndroidStretchEffect(): void;
+export declare function disposeAndroidStretchSurface(parentSurface: Surface): void;
+export declare function dampStretchVector(normalizedDistance: number): number;
+export declare function createAndroidEdgeEffectPull({ horizontal, signedPull, viewportSize, now, }: {
+    horizontal: boolean;
+    signedPull: number;
+    viewportSize: number;
+    now: number;
+}): AndroidEdgeEffectState | null;
+export declare function createAndroidEdgeEffectAbsorb({ edge, horizontal, velocity, viewportSize, now, }: {
+    edge: 'start' | 'end';
+    horizontal: boolean;
+    velocity: number;
+    viewportSize: number;
+    now: number;
+}): AndroidEdgeEffectState | null;
+export declare function beginAndroidEdgeEffectRelease(effect: AndroidEdgeEffectState, now: number): void;
+export declare const SPRING_NATURAL_FREQUENCY = 24.657;
+export declare const SPRING_DAMPING_RATIO = 0.98;
+export declare function advanceSpring(distance: number, velocity: number, dtSeconds: number): {
+    distance: number;
+    velocity: number;
+    done: boolean;
+};
+export declare function advanceAndroidEdgeEffectRelease(effect: AndroidEdgeEffectState, dtSeconds: number, now: number): boolean;
+export interface StretchDrawOptions {
+    ck: CanvasKit;
+    ctxCanvas: Canvas;
+    parentSurface: Surface;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    dpr: number;
+    overscrollX: number;
+    overscrollY: number;
+    drawIntoOffscreen: (offscreenCanvas: Canvas) => void;
+}
+export declare function drawWithAndroidStretch(opts: StretchDrawOptions): boolean;

package/dist-types/packages/peach-engine/src/engine/animated-driven-style.d.ts

@@ -0,0 +1,47 @@
+export interface AnimatedDrivenStyleLeaseOwner {
+    family: string;
+    id: string;
+    generation: number;
+}
+export interface AnimatedDrivenStyleLease {
+    owner: AnimatedDrivenStyleLeaseOwner;
+    version: number;
+    keys: string[];
+    anchorTop?: number;
+}
+export interface AnimatedDrivenStyleRetirement {
+    owner: AnimatedDrivenStyleLeaseOwner;
+    throughVersion: number;
+    keys: string[];
+    closed?: boolean;
+}
+export declare function isAnimatedDrivenStyleLease(value: unknown): value is AnimatedDrivenStyleLease;
+export declare function isAnimatedDrivenStyleRetirement(value: unknown): value is AnimatedDrivenStyleRetirement;
+export declare function isAnimatedDrivenStyleLeaseCoveredByRetirement(lease: AnimatedDrivenStyleLease, retirement: AnimatedDrivenStyleRetirement): boolean;
+export declare const ANIMATED_HOOK_STYLE_FAMILY = "useAnimatedStyle";
+export declare const REANIMATED_CSS_DRIVEN_STYLE_FAMILY = "reanimated-css";
+export declare const REANIMATED_LAYOUT_DRIVEN_STYLE_FAMILY = "layout";
+export declare const SCREEN_TRANSITION_LEASE_FAMILY = "screen-transition";
+export declare function animatedDrivenStyleOwnerKey(owner: AnimatedDrivenStyleLeaseOwner): string;
+export declare function setAnimatedDrivenStyleActiveWriterProbe(probe: (node: object, key: string) => boolean): void;
+export declare function getAnimatedDrivenStyleActiveWriter(node: object, key: string): boolean | null;
+export declare function markLiveAnimatedStyle(style: unknown): void;
+export declare function clearLiveAnimatedStyle(style: unknown): void;
+export declare function hasAnyLiveAnimatedStyle(): boolean;
+export declare function hasLiveAnimatedStyle(style: unknown): boolean;
+export declare function acquireAnimatedDrivenStyleLease(style: unknown, lease: AnimatedDrivenStyleLease): boolean;
+export declare function getAnimatedDrivenStyleAnchorTop(style: unknown, key: string): number | undefined;
+export declare function withTransformChannel(transform: Array<Record<string, unknown>> | undefined, channel: string, value: unknown): Array<Record<string, unknown>>;
+export declare function transformChannelValue(transform: Array<Record<string, unknown>> | undefined, channel: string): unknown;
+export declare function retireAnimatedDrivenStyleLease(style: unknown, retirement: AnimatedDrivenStyleRetirement): boolean;
+export declare function getAnimatedDrivenStyleLeaseVersion(style: unknown, owner: AnimatedDrivenStyleLeaseOwner, key: string): number | undefined;
+export declare function animatedDrivenStyleKeyHasOwner(style: unknown, key: string, families: ReadonlySet<string>): boolean;
+export declare function getAnimatedDrivenStyleLeases(style: unknown): AnimatedDrivenStyleLease[];
+export declare function getAnimatedDrivenStyleRetirements(style: unknown): AnimatedDrivenStyleRetirement[];
+export declare function copyAnimatedDrivenStyleLeaseState(from: unknown, to: unknown, keys?: ReadonlySet<string>): void;
+export declare function getAnimatedDrivenStyleKeys(style: unknown): ReadonlySet<string> | undefined;
+export declare function markAnimatedDrivenStyleKeys(style: unknown, keys: ReadonlySet<string>): void;
+export declare function unmarkAnimatedDrivenStyleKeys(style: unknown, keys: ReadonlySet<string>): boolean;
+export declare function hasAnimatedDrivenStyleKeys(style: unknown): boolean;
+export declare function hasAnimatedDrivenStyleKey(style: unknown, key: string): boolean;
+export declare function getAnimatedDrivenStyleKeyNames(style: unknown): string[];

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

@@ -0,0 +1,5 @@
+export declare function isAnimatedValue(value: any): boolean;
+export declare function beginReadFrame(): void;
+export declare function endReadFrame(): void;
+export declare function readAnimatedValue(value: any): any;
+export declare function readPresentedAnimatedValue(value: any): any;

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

@@ -0,0 +1,195 @@
+import { type AnimatedArithmetic } from './animation-graph.d.ts';
+import { type TaggedBezierEasing } from './animation-graph.d.ts';
+import { type SpringSampler } from './rn-spring.d.ts';
+declare function cubicBezier(x1: number, y1: number, x2: number, y2: number): TaggedBezierEasing;
+export declare const Easing: {
+    readonly linear: TaggedBezierEasing;
+    readonly ease: TaggedBezierEasing;
+    readonly easeIn: TaggedBezierEasing;
+    readonly easeOut: TaggedBezierEasing;
+    readonly easeInOut: (t: number) => number;
+    readonly bezier: typeof cubicBezier;
+};
+export declare const defaultTimingEasing: (t: number) => number;
+export interface AnimationResult {
+    finished: boolean;
+}
+export interface Animation {
+    start(callback?: (result: AnimationResult) => void): void;
+    stop(): void;
+    springSampler?: SpringSampler | null;
+}
+interface EngineAnimationRecord {
+    value: AnimatedValue;
+    kind: 'timing' | 'spring';
+    from: number;
+    to: number;
+    startedAt: number;
+    duration?: number;
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    startStack?: string;
+}
+export interface EngineAnimationInfo extends EngineAnimationRecord {
+    id: number;
+    current: number;
+    elapsedMs: number;
+    progress: number;
+    listenerCount: number;
+}
+export declare function listEngineAnimations(now?: number): EngineAnimationInfo[];
+export declare function stopEngineAnimation(id: number): boolean;
+export declare function snapshotEngineAnimationFingerprint(): number;
+export declare function setEngineAnimationStepRenderCallback(cb: ((value: AnimatedValue) => void) | null): void;
+export declare function getAnimatedDebugState(): {
+    activeTimings: {
+        id: number;
+        from: number;
+        to: number;
+        duration: number;
+        startedAt: number;
+        startStack: string | undefined;
+    }[];
+};
+export declare class AnimatedValue {
+    _value: number;
+    private _nativeDrivenValue;
+    private _modelValue;
+    _activeEngineAnimation: Animation | null;
+    _listeners: Map<string, (value: number) => void>;
+    private _directValueListeners;
+    _animationStepBatchUpdate: boolean;
+    _sootsimNativeAnimationId?: number;
+    constructor(initialValue: number);
+    setValue(value: number): void;
+    _setValueFromAnimation(value: number): void;
+    _attachEngineAnimation(animation: Animation): void;
+    _detachEngineAnimation(animation: Animation): void;
+    stopAnimation(): void;
+    private _setValue;
+    setNativeDrivenValue(value: number): void;
+    getValue(): number;
+    setModelValue(value: number | null): void;
+    getModelValue(): number | null;
+    getRenderValue(): number;
+    getPresentedValue(): number;
+    interpolate(config: {
+        inputRange: number[];
+        outputRange: (string | number)[];
+        extrapolate?: 'clamp' | 'extend' | 'identity';
+        extrapolateLeft?: 'clamp' | 'extend' | 'identity';
+        extrapolateRight?: 'clamp' | 'extend' | 'identity';
+    }): AnimatedInterpolation;
+    addListener(callback: (value: number) => void): string;
+    removeListener(id: string): void;
+    removeAllListeners(): void;
+    addDirectValueListener(callback: () => void): string;
+    removeDirectValueListener(id: string): void;
+    private _notifyListeners;
+}
+export declare class AnimatedInterpolation {
+    #private;
+    readonly _parent: AnimatedValue | AnimatedInterpolation;
+    private _inputRange;
+    private _outputRange;
+    private _extrapolateLeft;
+    private _extrapolateRight;
+    _listeners: Map<string, Function>;
+    get _value(): any;
+    get _config(): {
+        inputRange: number[];
+        outputRange: (string | number)[];
+        extrapolateLeft: 'clamp' | 'extend' | 'identity';
+        extrapolateRight: 'clamp' | 'extend' | 'identity';
+    };
+    get _root(): AnimatedValue;
+    constructor(parent: AnimatedValue | AnimatedInterpolation, config: {
+        inputRange: number[];
+        outputRange: (string | number)[];
+        extrapolate?: 'clamp' | 'extend' | 'identity';
+        extrapolateLeft?: 'clamp' | 'extend' | 'identity';
+        extrapolateRight?: 'clamp' | 'extend' | 'identity';
+    });
+    getValue(): string | number;
+    getPresentedValue(): string | number;
+    interpolate(config: {
+        inputRange: number[];
+        outputRange: (string | number)[];
+        extrapolate?: 'clamp' | 'extend' | 'identity';
+        extrapolateLeft?: 'clamp' | 'extend' | 'identity';
+        extrapolateRight?: 'clamp' | 'extend' | 'identity';
+    }): AnimatedInterpolation;
+    private _parentListeners;
+    addListener(callback: (value: number) => void): string;
+    removeListener(id: string): void;
+    removeAllListeners(): void;
+    get _sootsimNativeAnimationId(): number | undefined;
+}
+export interface TimingConfig {
+    toValue: number;
+    owner?: string;
+    duration?: number;
+    easing?: (t: number) => number;
+    delay?: number;
+    useNativeDriver?: boolean;
+    graph?: boolean;
+}
+export declare function setLockstepCaptureActive(active: boolean): void;
+export declare function timing(value: AnimatedValue, config: TimingConfig): Animation;
+export interface SpringConfig {
+    toValue: number;
+    owner?: string;
+    delay?: number;
+    tension?: number;
+    friction?: number;
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    velocity?: number;
+    overshootClamping?: boolean;
+    restSpeedThreshold?: number;
+    restDisplacementThreshold?: number;
+    uikitRestEpsilon?: number;
+    fixedDurationMs?: number;
+    useNativeDriver?: boolean;
+    graph?: boolean;
+    [key: string]: unknown;
+}
+export declare function spring(value: AnimatedValue, config: SpringConfig): Animation;
+export declare function parallel(animations: Animation[]): Animation;
+export declare function sequence(animations: Animation[]): Animation;
+export declare function useAnimatedValue(initialValue: number): AnimatedValue;
+export declare const Animated: {
+    readonly Value: typeof AnimatedValue;
+    readonly timing: typeof timing;
+    readonly spring: typeof spring;
+    readonly parallel: typeof parallel;
+    readonly sequence: typeof sequence;
+    readonly Easing: {
+        readonly linear: TaggedBezierEasing;
+        readonly ease: TaggedBezierEasing;
+        readonly easeIn: TaggedBezierEasing;
+        readonly easeOut: TaggedBezierEasing;
+        readonly easeInOut: (t: number) => number;
+        readonly bezier: typeof cubicBezier;
+    };
+};
+export type AnimatedNumber = number | AnimatedValue | AnimatedInterpolation | AnimatedExpression;
+export declare class AnimatedExpression {
+    readonly _opKind: AnimatedArithmetic;
+    readonly _a: AnimatedNumber;
+    readonly _b: AnimatedNumber;
+    readonly _listeners: Map<string, (value: number) => void>;
+    private readonly subscriptions;
+    constructor(_opKind: AnimatedArithmetic, _a: AnimatedNumber, _b: AnimatedNumber);
+    get _value(): number;
+    getValue(): number;
+    getRenderValue(): number;
+    getPresentedValue(): number;
+    addListener(callback: (value: number) => void): string;
+    removeListener(id: string): void;
+    removeAllListeners(): void;
+}
+export declare function animatedExpression(op: AnimatedArithmetic, a: AnimatedNumber, b: AnimatedNumber): AnimatedNumber;
+export {};

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

@@ -0,0 +1,15 @@
+export interface AnimationClockSnapshot {
+    anchorH: number;
+    anchorA: number;
+    rate: 1 | 0.1;
+    revision: number;
+    workletOrigin?: {
+        anchorMs: number;
+        seconds: number;
+    };
+    workletFrames?: {
+        anchorMs: number;
+        frameDurationMs: number;
+        timestampsSeconds: number[];
+    };
+}