peachsim 0.1.1644 → 0.1.1653

package/dist-lib/worklet-executable.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1644 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1653 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;

package/dist-lib/worklet-executable.mjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1644 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1653 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 
 // src/worklet-executable.ts
 import { parse } from "acorn";

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

@@ -0,0 +1,2 @@
+export * from '../../peach-kit/src/runtime.d.ts';
+export { setEngineConfig, setEngineConfigInitializer, resetCapabilityStore, type SootSimEngineConfig, } from '../../peach-kit/src/internal.d.ts';

package/dist-types/packages/peach-compat/src/stubs/form-sheet-spring.d.ts

@@ -0,0 +1,9 @@
+export declare const FORM_SHEET_SETTLE_STIFFNESS = 333.3333332805039;
+export declare const FORM_SHEET_SETTLE_DAMPING = 36.51483716411749;
+export declare const FORM_SHEET_SETTLE_FAST_DAMPING = 29.21186973129399;
+export declare const FORM_SHEET_SETTLE_REST_DISTANCE = 0.05;
+export declare const FORM_SHEET_SETTLE_REST_SPEED = 3;
+export declare function sampleFormSheetSpring(offset: number, velocity: number, elapsedMs: number, stiffness: number, damping: number): {
+    remaining: number;
+    speed: number;
+};

package/dist-types/packages/peach-compat/src/stubs/native-evaluation-lease.d.ts

@@ -0,0 +1,47 @@
+import type { ShellNativeEvaluationOwner } from '../../../peach-globals/src/index.d.ts';
+export type { ShellNativeEvaluationOwner } from '../../../peach-globals/src/index.d.ts';
+export declare function sameShellNativeEvaluationOwner(left: ShellNativeEvaluationOwner | undefined, right: ShellNativeEvaluationOwner | undefined): boolean;
+export interface HeadlessNativeEvaluationOwner {
+    readonly kind: 'headless';
+    readonly runtime: object;
+}
+export type NativeEvaluationOwner = ShellNativeEvaluationOwner | HeadlessNativeEvaluationOwner;
+type NativeEvaluationDiagnostic = {
+    evaluationId: string;
+    owner: ShellNativeEvaluationOwner | {
+        kind: 'headless';
+    };
+    live: boolean;
+    retiredAt: number | null;
+    retirementStack: string[];
+};
+export declare class NativeEvaluationRetiredError extends Error {
+    readonly code = "ERR_NATIVE_EVALUATION_RETIRED";
+    readonly evaluation?: NativeEvaluationDiagnostic;
+    constructor(lease?: NativeEvaluationLease);
+}
+export declare function createNativeIdentity(): string;
+export declare class NativeEvaluationLease {
+    readonly owner: NativeEvaluationOwner;
+    private identity;
+    private retired;
+    private retiredAt;
+    private retirementStack;
+    private retirementFailureReported;
+    private mounts;
+    private readonly disposables;
+    private readonly retiredResult;
+    constructor(owner: NativeEvaluationOwner);
+    get evaluationId(): string;
+    get live(): boolean;
+    get pendingMounts(): number;
+    beginMount(): () => void;
+    assertLive(): void;
+    get diagnostic(): NativeEvaluationDiagnostic;
+    reportRetiredError(error: unknown): void;
+    wait<T>(operation: () => T | PromiseLike<T>): Promise<T>;
+    waitForNativeResult<T>(operation: () => T | PromiseLike<T>): Promise<T>;
+    schedule(operation: () => void, delay: number): ReturnType<typeof setTimeout>;
+    addDisposable(dispose: () => void): () => void;
+    retire(): void;
+}

package/dist-types/packages/peach-compat/src/stubs/native-seams/react-native-cookies.d.ts

@@ -0,0 +1,113 @@
+import type { NativeEvaluationOwner } from '../native-evaluation-lease.d.ts';
+export type NativeCookie = {
+    name: string;
+    value: string;
+    path?: string;
+    domain?: string;
+    version?: string;
+    expires?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'lax' | 'strict' | 'none';
+    maxAge?: number;
+};
+export type StoredCookie = NativeCookie & {
+    domain: string;
+    path: string;
+    hostOnly: boolean;
+    expiresAt: number | null;
+};
+export type CookieStore = Map<string, StoredCookie>;
+export type CookieStoreErrorKind = 'invalid-url' | 'invalid-cookie' | 'domain-mismatch';
+declare class WebKitCookieJar extends Map<string, StoredCookie> {
+    private changed;
+    set(key: string, value: StoredCookie): this;
+    delete(key: string): boolean;
+    clear(): void;
+}
+export declare function bindNativeCookieStore(owner: NativeEvaluationOwner): void;
+export declare const cookieStores: {
+    readonly native: Map<string, StoredCookie>;
+    readonly webKit: WebKitCookieJar;
+};
+export declare function createCookieOperations(): {
+    storeResponseCookies: (store: CookieStore, url: string, headers: readonly string[]) => void;
+    restore: (cookies: unknown) => CookieStore;
+    cookiesMatching: (store: CookieStore, parsed: URL) => StoredCookie[];
+    parseCookieUrl: (url: string) => URL;
+    normalizedDomain: (domain: string) => string;
+    domainMatches: (hostname: string, domain: string, hostOnly: boolean) => boolean;
+    pathMatches: (requestPath: string, cookiePath: string) => boolean;
+    cookieKey: (cookie: Pick<StoredCookie, 'domain' | 'path' | 'name'>) => string;
+    purgeExpired: (store: CookieStore) => void;
+    storeCookie: (store: CookieStore, cookie: StoredCookie) => void;
+    publicCookie: (cookie: StoredCookie) => NativeCookie;
+    setCookie: (store: CookieStore, url: string, cookie: NativeCookie) => boolean;
+    getCookies: (store: CookieStore, url: string) => Record<string, NativeCookie>;
+    getAllCookies: (store: CookieStore) => Record<string, NativeCookie>;
+    cookieFromResponse: (cookieString: string) => NativeCookie;
+    clearCookiesByName: (store: CookieStore, url: string, name: string) => boolean;
+    removeSessionCookies: (store: CookieStore) => boolean;
+};
+declare const { storeResponseCookies, cookiesMatching, parseCookieUrl, normalizedDomain, domainMatches, pathMatches, cookieKey, purgeExpired, storeCookie, publicCookie, setCookie, getCookies, getAllCookies, cookieFromResponse, clearCookiesByName, removeSessionCookies, }: {
+    storeResponseCookies: (store: CookieStore, url: string, headers: readonly string[]) => void;
+    restore: (cookies: unknown) => CookieStore;
+    cookiesMatching: (store: CookieStore, parsed: URL) => StoredCookie[];
+    parseCookieUrl: (url: string) => URL;
+    normalizedDomain: (domain: string) => string;
+    domainMatches: (hostname: string, domain: string, hostOnly: boolean) => boolean;
+    pathMatches: (requestPath: string, cookiePath: string) => boolean;
+    cookieKey: (cookie: Pick<StoredCookie, 'domain' | 'path' | 'name'>) => string;
+    purgeExpired: (store: CookieStore) => void;
+    storeCookie: (store: CookieStore, cookie: StoredCookie) => void;
+    publicCookie: (cookie: StoredCookie) => NativeCookie;
+    setCookie: (store: CookieStore, url: string, cookie: NativeCookie) => boolean;
+    getCookies: (store: CookieStore, url: string) => Record<string, NativeCookie>;
+    getAllCookies: (store: CookieStore) => Record<string, NativeCookie>;
+    cookieFromResponse: (cookieString: string) => NativeCookie;
+    clearCookiesByName: (store: CookieStore, url: string, name: string) => boolean;
+    removeSessionCookies: (store: CookieStore) => boolean;
+};
+export { cookieKey };
+export declare const nativeFetchCookies: {
+    request(url: string, store?: Map<string, StoredCookie>): string;
+    response(url: string, headers: readonly string[], store?: Map<string, StoredCookie>): void;
+};
+export declare const webKitCookieOperationsSource: string;
+export declare const webKitCookieStorage: {
+    readonly default: WebKitCookieJar;
+    isolated: () => CookieStore;
+    response(store: CookieStore, url: string, headers: readonly string[]): void;
+    observe(store: CookieStore, changed: () => void): () => void;
+    request(store: CookieStore, url: string, script?: boolean): string;
+    script(store: CookieStore, url: string, line: string): void;
+    policy(store: CookieStore): 0 | 1;
+    setPolicy(store: CookieStore, policy: 0 | 1): void;
+    matching(store: CookieStore, url: string): StoredCookie[];
+    setMany(store: CookieStore, cookies: StoredCookie[]): void;
+    all(store: CookieStore): StoredCookie[];
+    set(store: CookieStore, cookie: StoredCookie): void;
+    delete(store: CookieStore, cookie: Pick<StoredCookie, 'domain' | 'path' | 'name'>): void;
+};
+export declare const RNCookieManagerAndroidNativeModule: {
+    get: (url: string, _useWebKit?: boolean) => Promise<Record<string, NativeCookie>>;
+    getAll: (_useWebKit?: boolean) => Promise<never>;
+    set: (url: string, cookie: NativeCookie, _useWebKit?: boolean) => Promise<boolean>;
+    setFromResponse: (url: string, cookie: string) => Promise<boolean>;
+    getFromResponse: (url: string) => Promise<string>;
+    clearByName: (_url: string, _name: string, _useWebKit?: boolean) => Promise<never>;
+    clearAll: (_useWebKit?: boolean) => Promise<boolean>;
+    flush: () => Promise<boolean>;
+    removeSessionCookies: () => Promise<boolean>;
+};
+export declare const RNCookieManagerIOSNativeModule: {
+    get: (url: string, useWebKit?: boolean) => Promise<Record<string, NativeCookie>>;
+    getAll: (useWebKit?: boolean) => Promise<Record<string, NativeCookie>>;
+    set: (url: string, cookie: NativeCookie, useWebKit?: boolean) => Promise<boolean>;
+    setFromResponse: (url: string, cookie: string) => Promise<boolean>;
+    getFromResponse: (url: string) => Promise<Record<string, string>>;
+    clearByName: (url: string, name: string, useWebKit?: boolean) => Promise<boolean>;
+    clearAll: (useWebKit?: boolean) => Promise<boolean>;
+    clearAllStores: () => Promise<boolean>;
+    removeSessionCookies: (clearNative: boolean, clearWebKit: boolean) => Promise<boolean>;
+};

package/dist-types/packages/peach-compat/src/stubs/native-seams/react-native-gesture-handler.d.ts

@@ -0,0 +1,154 @@
+declare const State: {
+    readonly UNDETERMINED: 0;
+    readonly FAILED: 1;
+    readonly BEGAN: 2;
+    readonly CANCELLED: 3;
+    readonly ACTIVE: 4;
+    readonly END: 5;
+};
+export interface SeamPointerEvent {
+    x: number;
+    y: number;
+    changedTouch: SeamPointerEvent['touches'][number];
+    pointerType?: number;
+    stylusData?: {
+        tiltX: number;
+        tiltY: number;
+        altitudeAngle: number;
+        azimuthAngle: number;
+        pressure: number;
+    };
+    timestamp?: number;
+    touches: ReadonlyArray<{
+        pageX: number;
+        pageY: number;
+        identifier: number;
+    }>;
+}
+type LastPointer = {
+    x: number;
+    y: number;
+    numberOfPointers: number;
+    pointerType: number;
+    stylusData?: SeamPointerEvent['stylusData'];
+    timestamp?: number;
+};
+interface HandlerEntry {
+    tag: number;
+    name: string;
+    config: Record<string, unknown>;
+    viewTag: number | null;
+    viewIsUIControl: boolean;
+    state: number;
+    lastPointer: LastPointer;
+    cleanup: (() => void) | null;
+    cleanupConsumed: boolean;
+    cleanupRuns: number;
+    activationCount: number;
+    yieldedToDescendantScroll: boolean;
+    simultaneousNativeScroll: boolean;
+    onExternalStateChange: ((newState: number) => void) | null;
+    pointerHandlers: {
+        onDown: (event: SeamPointerEvent) => void;
+        onMove: (event: SeamPointerEvent) => void;
+        onUp: (event: SeamPointerEvent) => void;
+    } | null;
+}
+export type GestureEvent = {
+    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;
+};
+type Listener = (event: GestureEvent) => void;
+export declare function cancelGestureHandlerFromOrchestrator(event: GestureEvent, visible: boolean): void;
+export declare function emitStateChangeDirect(event: GestureEvent): void;
+export declare function setNodeResolver(fn: ((handlerTag: number, viewTag: number) => unknown) | null): void;
+export declare function setStateChangeInterceptor(fn: ((event: GestureEvent, emit: (event: GestureEvent) => void) => void) | null): void;
+export declare function hitSlopContainsLocalPoint(hitSlop: unknown, localX: number, localY: number, width: number, height: number): boolean;
+interface PanRecognizerState {
+    startX: number;
+    startY: number;
+    currentX: number;
+    currentY: number;
+    lastT: number;
+    velocityX: number;
+    velocityY: number;
+    velocitySamples: Array<{
+        x: number;
+        y: number;
+        t: number;
+    }>;
+    active: boolean;
+    prevCount: number;
+}
+export declare function estimatePanVelocity(samples: PanRecognizerState['velocitySamples']): {
+    x: number;
+    y: number;
+};
+declare const RNGestureHandlerModule: {
+    handleSetJSResponder: (_tag: number, _blockNativeResponder: boolean) => void;
+    handleClearJSResponder: () => void;
+    createGestureHandler: (handlerName: string, handlerTag: number, config: Record<string, unknown>) => void;
+    attachGestureHandler: (handlerTag: number, viewTag: number, _actionType: number, viewIsUIControl?: boolean) => void;
+    updateGestureHandler: (handlerTag: number, newConfig: Record<string, unknown>) => void;
+    dropGestureHandler: (handlerTag: number) => void;
+    getPointerHandlersForTag: (handlerTag: number) => HandlerEntry['pointerHandlers'];
+    getRelationsForTag: (handlerTag: number) => {
+        simultaneousWith: number[];
+        requireToFail: number[];
+        blocksExternal: number[];
+    };
+    getStateForTag: (handlerTag: number) => number | null;
+    getActivationCountForTag: (handlerTag: number) => number | null;
+    handlerCancelsJSResponder: (handlerTag: number) => boolean;
+    handlerCancelsTouchesInView: (handlerTag: number) => boolean;
+    handlerPreservesNativeTouch: (handlerTag: number) => boolean;
+    setSimultaneousNativeScroll: (handlerTag: number, value: boolean) => void;
+    resetGestureHandlerForNewPointer: (handlerTag: number) => void;
+    getCleanupRunsForTag: (handlerTag: number) => number | null;
+    getHandlerNameForTag: (handlerTag: number) => string | null;
+    getDeclaredPanAxisForTag: (handlerTag: number) => 'horizontal' | 'vertical' | null;
+    hasYieldedToDescendantScroll: (handlerTag: number) => boolean;
+    handlerNeedsPointerData: (handlerTag: number) => boolean;
+    setGestureState: (handlerTag: number, newState: number) => void;
+    cancelGestureHandler: (handlerTag: number) => void;
+    install: () => boolean;
+    flushOperations: () => void;
+    addListener: (eventName: string) => {
+        remove: () => void;
+    };
+    removeListeners: (_count: number) => void;
+    addStateChangeListener: (cb: Listener) => {
+        remove: () => void;
+    };
+    addUpdateListener: (cb: Listener) => {
+        remove: () => void;
+    };
+    __getStateForTests: () => {
+        handlers: HandlerEntry[];
+        listeners: number;
+    };
+};
+export { State };
+export default RNGestureHandlerModule;