peachsim 0.1.1644 → 0.1.1653

package/dist-types/packages/peach-kit/src/internal.d.ts

@@ -0,0 +1,4 @@
+export { setEngineConfig, setEngineConfigInitializer, resetCapabilityStore, type SootSimEngineConfig, } from './capabilities.d.ts';
+export { bindReact } from './react-bridge.d.ts';
+export { POPOVER_ARROWS, POPOVER_CORNER_RADIUS, placePopover, centerArrowlessPopover, popoverGlassArrow, popoverRegion, } from './ui/popover-placement.d.ts';
+export { HostingSafeAreaContext, systemLayoutMargin, type HostingSafeAreaContainer, } from './ui/hosting-safe-area.d.ts';

package/dist-types/packages/peach-kit/src/materials/types.d.ts

@@ -0,0 +1,27 @@
+import type { Ref } from 'react';
+import type { View, ViewProps } from 'react-native';
+type SystemBlurStyle = 'systemUltraThinMaterial' | 'systemThinMaterial' | 'systemMaterial' | 'systemThickMaterial' | 'systemChromeMaterial';
+export type BlurStyle = SystemBlurStyle | `${SystemBlurStyle}Light` | `${SystemBlurStyle}Dark` | 'extraLight' | 'light' | 'dark' | 'regular' | 'prominent';
+export interface ProgressiveBlurViewProps extends ViewProps {
+    maxRadius: number;
+    direction: 'top' | 'bottom' | 'center';
+    startOffset?: number;
+    blurStyle?: BlurStyle;
+    ref?: Ref<View>;
+}
+interface VariableBlurAppearance {
+    fillDarken: number;
+    fillLighten: number;
+    fillNormal: number;
+    plateColor: readonly [number, number, number];
+    plateOpacity: number;
+}
+export interface VariableBlurStyle {
+    radius: number;
+    fillRadius: number;
+    captureFactor?: number;
+    light: VariableBlurAppearance;
+    dark: VariableBlurAppearance;
+    radiusMaskHex: string;
+}
+export {};

package/dist-types/packages/peach-kit/src/materials/uikit-blur-material.d.ts

@@ -0,0 +1,14 @@
+import type { VariableBlurStyle } from './types.d.ts';
+export type UIBlurMaterialStyle = {
+    lightSigma: number;
+    darkSigma: number;
+    light: number[];
+    dark: number[];
+    amount: number;
+    sampleWithinBounds?: true;
+    tileMode?: 'mirror';
+    colorMatrix?: readonly number[];
+    variableBlur?: VariableBlurStyle;
+};
+export declare const IDENTITY_MATERIAL: number[];
+export declare const UI_MATERIAL_RECIPES: Record<string, Omit<UIBlurMaterialStyle, 'amount'>>;

package/dist-types/packages/peach-kit/src/navigation-types.d.ts

@@ -0,0 +1,11 @@
+import type { ShellNativeEvaluationOwner } from '../../peach-globals/src/index.d.ts';
+export interface ScreenInfo {
+    id: string;
+    owner: ShellNativeEvaluationOwner | null;
+    routeName?: string;
+    isActive: boolean;
+    headerHeight: number;
+    largeTitleState?: 'expanded' | 'collapsed' | 'collapsing' | 'expanding';
+    presentation?: string;
+    depth?: number;
+}

package/dist-types/packages/peach-kit/src/react-bridge.d.ts

@@ -0,0 +1,53 @@
+import * as _defaultReact from 'react';
+export declare function bindReact(react: typeof _defaultReact): void;
+export declare function getReact(): typeof _defaultReact;
+export declare function useState<T>(init: T | (() => T)): [T, (v: T | ((prev: T) => T)) => void];
+export declare function use<T>(usable: import('react').Usable<T>): T;
+export declare function useActionState(...args: any[]): any;
+export declare function useEffect(effect: () => void | (() => void | undefined), deps?: readonly any[]): void;
+export declare function useEffectEvent<T extends (...args: any[]) => any>(event: T): T;
+export declare function useLayoutEffect(effect: () => void | (() => void | undefined), deps?: readonly any[]): void;
+export declare function useCallback<T extends (...args: any[]) => any>(cb: T, deps: readonly any[]): T;
+export declare function useId(): string;
+export declare function useRef<T>(init: T): import('react').RefObject<T>;
+export declare function useRef<T>(init: T | null): import('react').RefObject<T | null>;
+export declare function useRef<T = undefined>(): import('react').RefObject<T | undefined>;
+export declare function useMemo<T>(factory: () => T, deps: readonly any[]): T;
+export declare function useOptimistic(...args: any[]): any;
+export declare function useContext<T>(ctx: import('react').Context<T>): T;
+export declare function useReducer(...args: any[]): any;
+export declare function useImperativeHandle(...args: any[]): void;
+export declare function useInsertionEffect(effect: () => void | (() => void | undefined), deps?: readonly any[]): any;
+export declare function useDeferredValue<T>(value: T): T;
+export declare function useTransition(): [boolean, (cb: () => void) => void];
+export declare function useDebugValue(value: any, format?: (v: any) => any): void;
+export declare function useSyncExternalStore<T>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T): T;
+export declare function startTransition(fn: () => void): void;
+export declare function unstable_useCacheRefresh(): () => void;
+export declare function act(...args: any[]): any;
+export declare function cache<T extends (...args: any[]) => any>(fn: T): T;
+export declare function cacheSignal(): import('react').CacheSignal | null;
+export declare function captureOwnerStack(): string | null;
+export declare function createElement(...args: any[]): any;
+export declare function createContext<T>(defaultValue?: T): import('react').Context<T>;
+export declare function forwardRef(render: any): any;
+export declare function createRef<T = unknown>(): import('react').RefObject<T | null>;
+export declare function memo(component: any, compare?: any): any;
+export declare function lazy(factory: any): any;
+export declare function isValidElement(el: unknown): el is _defaultReact.ReactElement;
+export declare function cloneElement(...args: any[]): any;
+export declare const Children: typeof _defaultReact.Children;
+export declare let Activity: any;
+export declare let Fragment: any;
+export declare let Profiler: any;
+export declare let StrictMode: any;
+export declare let Suspense: any;
+export declare let Component: any;
+export declare let PureComponent: any;
+export declare const __CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE: any;
+export declare const __COMPILER_RUNTIME: any;
+export declare const __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: any;
+export declare const version: string;
+declare const _default: typeof _defaultReact;
+export default _default;
+export type { ComponentType, Context, Dispatch, FC, JSX, PropsWithChildren, ReactElement, ReactNode, Ref, RefObject, SetStateAction, } from 'react';

package/dist-types/packages/peach-kit/src/runtime.d.ts

@@ -0,0 +1,26 @@
+import { type NativeAlertsConfig, type SootSimEngineConfig } from './capabilities.d.ts';
+export type { ScreenInfo } from './navigation-types.d.ts';
+export { getEngineConfig, getOptionalEngineConfig, type SootSimEngineConfig, type ColorPickerControlProps, type BottomTabAccessoryPlacement, type BottomTabAccessoryRenderer, type BottomTabBarItem, type BottomTabBarProps, type TabBarIconImage, type GestureSeamOwner, type ScreenEdgeSwipeCommit, type ScreenTransitionAnimation, type ScreenTransitionProgress, isScreenTransitionAnimation, type NativeAlertPromptValue, type NativeAlertsConfig, type NativeNotificationsConfig, type NativePermissionsConfig, type NotifAction, type NotifCategory, type NotifChannel, type NotifChannelGroup, type NotifEvent, type NotifEventType, type NotifForegroundPresenter, type NotifPermission, type NotifPresentation, type NotifSpec, type NotifToken, type NotifTrigger, type NotificationBusInterface, type SystemNotificationSettings, type SystemPermissionDescriptor, type SystemPermissionKind, type SystemPermissionLocationAccuracy, type SystemPermissionState, type SystemPermissionStatus, } from './capabilities.d.ts';
+export declare function getReactNative(): {
+    [key: string]: any;
+    usePinnedTraitColorScheme: () => 'light' | 'dark' | null;
+    Platform: any;
+    Dimensions: any;
+    UIManager: any;
+    Keyboard: any;
+    findNodeHandle?: (component: any) => number | null;
+    BackHandler: {
+        emitBackPress: () => boolean;
+    };
+    AppRegistry: any;
+    NativeEventEmitter: any;
+    DeviceEventEmitter: any;
+    Animated?: any;
+    Easing?: any;
+};
+export declare function getEngine(): SootSimEngineConfig['engine'];
+export declare function getNativeNotifications(): import("../../peach-engine/src/react-bridge.d.ts").NativeNotificationsConfig | undefined;
+export declare function getNativeAlerts(): NativeAlertsConfig;
+export declare function getSystemPermissions(): import("../../peach-engine/src/react-bridge.d.ts").NativePermissionsConfig | undefined;
+export declare function getPlatform(): string;
+export { getReact, useState, use, useActionState, useEffect, useEffectEvent, useLayoutEffect, useCallback, useId, useRef, useMemo, useOptimistic, useContext, useReducer, useImperativeHandle, useInsertionEffect, useDeferredValue, useTransition, useDebugValue, useSyncExternalStore, startTransition, unstable_useCacheRefresh, act, cache, cacheSignal, captureOwnerStack, createElement, createContext, forwardRef, createRef, memo, lazy, isValidElement, cloneElement, Children, Activity, Fragment, Profiler, StrictMode, Suspense, Component, PureComponent, version, __CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, __COMPILER_RUNTIME, __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, type ComponentType, type Context, type Dispatch, type FC, type JSX, type PropsWithChildren, type ReactElement, type ReactNode, type Ref, type RefObject, type SetStateAction, default, } from './react-bridge.d.ts';

package/dist-types/packages/peach-kit/src/ui/hosting-safe-area.d.ts

@@ -0,0 +1,24 @@
+import { type RefObject } from 'react';
+export interface HostingSafeAreaContainer {
+    view: RefObject<unknown>;
+    height: number;
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    margins: {
+        left: number;
+        right: number;
+    };
+    rowInset?: number;
+}
+export declare const HostingSafeAreaContext: import("react").Context<HostingSafeAreaContainer | null>;
+export declare function systemLayoutMargin(screen: {
+    width: number;
+    height: number;
+}): number;
+export declare const SWIFTUI_TOGGLE_TRAILING_PLACEMENT = -1.5;
+export declare function expoUiFormToggleTrackTrailingInset(screen: {
+    width: number;
+    height: number;
+}): number;

package/dist-types/packages/peach-kit/src/ui/popover-placement.d.ts

@@ -0,0 +1,53 @@
+export declare const POPOVER_ARROW_DEPTH = 13;
+export declare const POPOVER_ARROW_END_INSET = 19;
+export declare const POPOVER_SIDE_MARGIN = 10;
+export declare const POPOVER_CORNER_RADIUS = 33;
+export declare const POPOVER_ARROW_TIP_RADIUS = 1.5;
+export declare const POPOVER_ARROW_JOIN_RADIUS = 6;
+export type PopoverArrow = 'up' | 'down' | 'left' | 'right';
+export declare const POPOVER_ARROWS: PopoverArrow[];
+export interface PopoverSource {
+    absX: number;
+    absY: number;
+    width: number;
+    height: number;
+}
+export declare function centerArrowlessPopover(source: PopoverSource, content: {
+    width: number;
+    height: number;
+}): {
+    cardX: number;
+    cardY: number;
+};
+export interface PopoverRegion {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export declare function popoverRegion(windowWidth: number, safeTop: number, safeBottom: number): PopoverRegion;
+export declare function placePopover(source: PopoverSource, content: {
+    width: number;
+    height: number;
+}, region: PopoverRegion, arrows: PopoverArrow[], narrowsBesideSource?: boolean): {
+    cardX: number;
+    cardY: number;
+    cardWidth: number | undefined;
+    direction: PopoverArrow;
+    arrowX: number;
+    arrowY: number;
+    pivotX: number;
+    pivotY: number;
+    pinned: "end" | "start" | undefined;
+    arrowCentre: number;
+};
+export declare function popoverGlassArrow(placed: ReturnType<typeof placePopover>): {
+    x: number;
+    y: number;
+    direction: PopoverArrow;
+    depth: number;
+    tipRadius: number;
+    joinRadius: number;
+    pinned: "end" | "start" | undefined;
+    centre: number;
+};

package/dist-types/packages/peach-kit/src/ui/presentationContract.d.ts

@@ -0,0 +1,17 @@
+export type SheetDismissalDecision = readonly [requestId: number, allowed: boolean];
+export type SheetDismissalResult = 'allowed' | 'denied' | 'cancelled';
+export interface SheetDismissalAttempt {
+    result: Promise<SheetDismissalResult>;
+    cancel: () => void;
+}
+export type SheetDismissalRequest = () => SheetDismissalAttempt;
+export type SheetDismissalLifecycle = {
+    phase: 'begin';
+    interactive: boolean;
+} | {
+    phase: 'interaction';
+    cancelled: boolean;
+} | {
+    phase: 'cancelled';
+};
+export type SheetDismissalObserver = (event: SheetDismissalLifecycle) => void;

package/kotlin/ComposeSources/PeachComposeHost.kt

@@ -1,4 +1,4 @@
-@file:OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class, androidx.compose.ui.InternalComposeUiApi::class, androidx.compose.ui.text.ExperimentalTextApi::class, kotlin.js.ExperimentalJsExport::class, kotlin.js.ExperimentalWasmJsInterop::class, org.jetbrains.skiko.InternalSkikoApi::class)
+@file:OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class, androidx.compose.ui.InternalComposeUiApi::class, androidx.compose.ui.text.ExperimentalTextApi::class, kotlin.js.ExperimentalJsExport::class, org.jetbrains.skiko.InternalSkikoApi::class)
 
 import androidx.compose.foundation.LocalPlatformMagnifierFactory
 import androidx.compose.runtime.Composable

package/kotlin/JniSources/com/facebook/jni/HybridData.kt

@@ -1,5 +1,3 @@
-@file:OptIn(kotlin.js.ExperimentalWasmJsInterop::class)
-
 package com.facebook.jni
 
 import dev.peach.jni.isNativeRuntimeActive

package/kotlin/JniSources/dev/peach/jni/NativeBindings.kt

@@ -1,5 +1,3 @@
-@file:OptIn(kotlin.js.ExperimentalWasmJsInterop::class)
-
 package dev.peach.jni
 
 import kotlin.js.*

package/kotlin/JniTransportSources/dev/peach/jni/integration/JniTransport.kt

@@ -1,5 +1,3 @@
-@file:OptIn(kotlin.js.ExperimentalWasmJsInterop::class)
-
 package dev.peach.jni.integration
 
 import dev.peach.jni.*

package/kotlin/README.md

@@ -72,3 +72,9 @@ The eager Vite entry must remain byte-identical. Compose dispatch runs in a
 browser worker with no document, after official Skiko initializes. This proves
 runtime behavior, with no Compose UI or Android pixel grade. UI fixtures still
 use the paired Compose oracle.
+
+The npm package publishes the `*Sources/` directories, `tools/` and
+`toolchain.json` required by client compilation, plus this documentation and
+the fork licenses and notices. `fork/` patches, pins and producer scripts,
+and development fixtures remain in private Git. The package smoke check rejects
+these build inputs in actual npm payloads, including a supplied tarball.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peachsim",
-  "version": "0.1.1644",
+  "version": "0.1.1653",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",
@@ -313,9 +313,26 @@
     "install.mjs",
     "install.sh",
     "dist-lib/",
+    "dist-types/",
+    "runtime-companion.json",
     "src/",
     "cli/",
-    "kotlin/",
+    "kotlin/AndroidViewSources/",
+    "kotlin/AppSources/",
+    "kotlin/CompilerSources/",
+    "kotlin/ComposeSources/",
+    "kotlin/ExpoComposeSources/",
+    "kotlin/ExpoSources/",
+    "kotlin/JniPlatformSources/",
+    "kotlin/JniSources/",
+    "kotlin/JniTransportSources/",
+    "kotlin/Sources/",
+    "kotlin/tools/",
+    "kotlin/toolchain.json",
+    "kotlin/README.md",
+    "kotlin/fork/LICENSE",
+    "kotlin/fork/SKIA_LICENSE",
+    "kotlin/fork/NOTICE",
     "skills/",
     "scripts/dev-server-scanner.ts",
     "scripts/optional-demo-registry.ts",
@@ -374,5 +391,8 @@
     "typescript": "7.1.0-beta",
     "vite": "8.3.3",
     "yaml": "^2.8.3"
+  },
+  "imports": {
+    "#peach-cli-contract/*": "./dist-types/packages/peach-engine/src/*.d.ts"
   }
 }

package/runtime-companion.json

@@ -0,0 +1 @@
+{"abi":1,"sha256":"d58f0fedc3c0065faaafcf578781567b6cdac88e5c062a8354111d37fdf3c465","file":"node/cli-d58f0fedc3c0065faaafcf578781567b6cdac88e5c062a8354111d37fdf3c465.cjs"}

package/skills/contrast/SKILL.md

@@ -60,6 +60,7 @@ automation, inspecting the render tree, and managing sims.
 | `peach close` | close a connected sim |
 | `peach setup` | configure optional local conveniences |
 | `peach doctor` | check what of an app Peach runs |
+| `peach coverage` | scan repository source for mapped APIs and unknown reach |
 | `peach project-report` | print local project and toolchain metadata |
 | `peach support` | ask for help, report a problem, and read our replies |
 | `peach desktop` | launch or install the desktop companion |

package/src/assetCatalogContract.ts

@@ -60,6 +60,8 @@ export interface SfSymbolImageDrawing {
   referencePointSize: number
   basePointSize: number
   baselineOffsetUnrounded: number
+  // coreui's glyph cap height at basePointSize, before scale rounding
+  capHeightUnrounded: number
   referenceCanvasSize: readonly [number, number]
   insets: readonly [number, number, number, number]
   layers: readonly { d: string; opacity: number; eraser: boolean; threshold?: number }[]
@@ -115,6 +117,25 @@ export function sfSymbolImageDimensions(
   }
 }
 
+// uiimage's baseline above the image bottom and its cap height, in device
+// pixels: each glyph metric rounds at the display scale, and the baseline
+// rides on the bottom bearing
+// (docs/ios-framework-oracle/sf-symbol-image-alignment-metrics-and-weight-scale-boundary-uikitcore-coreui.md)
+export function sfSymbolImageAlignment(
+  drawing: SfSymbolImageMetadata,
+  pointSize: number,
+  scale: number,
+) {
+  const dimensions = sfSymbolImageDimensions(drawing, pointSize, scale)
+  const round = (value: number) =>
+    Math.round((value * pointSize * scale) / drawing.basePointSize)
+  return {
+    ...dimensions,
+    baseline: round(drawing.baselineOffsetUnrounded) + dimensions.insets[3],
+    capHeight: round(drawing.capHeightUnrounded),
+  }
+}
+
 // roundtrip Float64 decimal coordinates with shared svg verb programs.
 export interface SfSymbolPathEncoding {
   format: 'float64-table'

package/src/bridge-contract-input.ts

@@ -5,6 +5,8 @@ import { isRecord } from './is-record'
 // WebSocket routes) validates its request bodies here rather than growing a
 // second reader for the same shapes.
 import type {
+  DiagnosticsOptions,
+  DiagnosticsResult,
   ResetOptions,
   SemanticWaitOptions,
   SimSemanticQuery,
@@ -343,6 +345,88 @@ export function findInvalidPointerSequence(
   }
 }
 
+function diagnosticsChannels(value: unknown, path: string): string[] {
+  if (!Array.isArray(value)) validationFailure(path, 'must be a list of channel names')
+  return value.map((channel) => stringValue(channel, path))
+}
+
+export function parseDiagnosticsResult(value: unknown): DiagnosticsResult {
+  if (
+    !isRecord(value) ||
+    !Array.isArray(value.channels) ||
+    !value.channels.every((channel) => typeof channel === 'string') ||
+    !Array.isArray(value.availableChannels) ||
+    !value.availableChannels.every((channel) => typeof channel === 'string') ||
+    !Array.isArray(value.events)
+  ) {
+    validationFailure(
+      'remote diagnostics',
+      'returned an incompatible native host response',
+    )
+  }
+  return {
+    channels: value.channels,
+    availableChannels: value.availableChannels,
+    runtime: value.runtime,
+    found: value.found,
+    events: value.events,
+  }
+}
+
+export function parseDiagnosticsOptions(value: unknown): DiagnosticsOptions {
+  const options = recordValue(value, 'diagnostics')
+  const channels =
+    options.channels === undefined
+      ? undefined
+      : diagnosticsChannels(options.channels, 'diagnostics.channels')
+  let channelControl: DiagnosticsOptions['channelControl']
+  if (options.channelControl !== undefined) {
+    if (channels !== undefined) {
+      validationFailure('diagnostics.channelControl', 'cannot be combined with channels')
+    }
+    const control = recordValue(options.channelControl, 'diagnostics.channelControl')
+    const action = control.action
+    if (action !== 'enable' && action !== 'disable' && action !== 'toggle') {
+      validationFailure(
+        'diagnostics.channelControl.action',
+        'must be enable, disable, or toggle',
+      )
+    }
+    const selected = diagnosticsChannels(
+      control.channels,
+      'diagnostics.channelControl.channels',
+    )
+    if (action === 'toggle' && (selected.length !== 1 || selected[0] === 'all')) {
+      validationFailure('diagnostics.channelControl', 'toggle requires one channel')
+    }
+    channelControl = { action, channels: selected }
+  }
+  const find = options.find
+  if (
+    find !== undefined &&
+    find !== 'sheets' &&
+    find !== 'portals' &&
+    find !== 'boundaries'
+  ) {
+    validationFailure('diagnostics.find', 'must be sheets, portals, or boundaries')
+  }
+  return {
+    ...(channels === undefined ? {} : { channels }),
+    ...(channelControl === undefined ? {} : { channelControl }),
+    ...(find === undefined ? {} : { find }),
+    ...(options.recentChannel === undefined
+      ? {}
+      : {
+          recentChannel: stringValue(options.recentChannel, 'diagnostics.recentChannel'),
+        }),
+    ...(options.recentLimit === undefined
+      ? {}
+      : {
+          recentLimit: numberValue(options.recentLimit, 'diagnostics.recentLimit'),
+        }),
+  }
+}
+
 export function parseStateOptions(value: unknown): SimStateOptions {
   const input = recordValue(value, 'state')
   const route = optionalBoolean(input, 'route', 'state')

package/src/bridge-contract.ts

@@ -437,9 +437,15 @@ export interface SemanticWaitResult {
 // ---------------------------------------------------------------------------
 
 export interface DiagnosticsOptions {
-  // debug channels to record from this point on. omitted leaves recording as
-  // it is; an empty list stops recording.
+  // debug channel selection. omitted leaves recording as it is; replacement
+  // with an empty list stops recording.
   channels?: readonly string[]
+  // controls update the tenant's selection atomically instead of replacing it.
+  // enable/disable accept 'all' or an empty list for every native channel.
+  channelControl?: {
+    action: 'enable' | 'disable' | 'toggle'
+    channels: readonly string[]
+  }
   find?: 'sheets' | 'portals' | 'boundaries'
   recentChannel?: string
   recentLimit?: number
@@ -447,8 +453,9 @@ export interface DiagnosticsOptions {
 
 export interface DiagnosticsResult {
   channels: string[]
+  availableChannels: string[]
   runtime: unknown
-  found: unknown[] | null
+  found: unknown
   events: unknown[]
 }
 
@@ -657,3 +664,28 @@ export interface LocationResult {
   fix?: LocationFix
   error?: string
 }
+
+// commands that change what a sim shows or runs must respect the cli lease.
+// observational/lifecycle commands pass through the host without taking or
+// checking one so cleanup never gets stuck behind a stale cli owner.
+export const WRITE_COMMAND_TYPES: ReadonlySet<string> = new Set([
+  'tap',
+  'keyboard',
+  'longPress',
+  'perform',
+  'reset',
+  'camera',
+])
+
+// `call` and `evaluate` are mostly queries, so they opt into the lease with
+// acquireLock=true when they mutate (a reload, a storage clear).
+export function commandWritesSim(msg: {
+  type?: unknown
+  acquireLock?: unknown
+  readOnly?: unknown
+}): boolean {
+  if (typeof msg.type !== 'string') return false
+  if (msg.acquireLock === true) return true
+  if (msg.readOnly === true) return false
+  return WRITE_COMMAND_TYPES.has(msg.type)
+}

package/src/browser-launch-policy.ts

@@ -0,0 +1 @@
+export const DRIVER_AUTOPLAY_POLICY = '--autoplay-policy=no-user-gesture-required'

package/src/bundle-channel.mjs

@@ -1,11 +1,11 @@
 // publish the plain OTA bundle for Peach without changing the phone's bytecode.
 import { createHash } from 'node:crypto'
 import { Script } from 'node:vm'
-import { terminateProcessGroup } from './process-group'
 import { isLoopbackHost } from './backend-origin'
 import { insertExpoKotlinFooter } from './expoKotlinContract'
 import { insertExpoSwiftFooter } from './expoSwiftContract'
 import { insertNitroFooter } from './nitroContract'
+import { terminateProcessGroup } from './process-group'
 
 const digest = (bytes) => createHash('sha256').update(bytes).digest('hex')
 const segment = /^[a-zA-Z0-9._-]+$/
@@ -286,7 +286,8 @@ export async function publishBundleChannel(release, { put, fetchObject = fetch }
 // peach boots an app from the dev server's bundle: it carries the module graph
 // peach maps native seams by, which a release build erases. snapshot each
 // platform's bundle from a running dev server and package the files its
-// assets register, with the app's local Expo native modules for that platform.
+// assets register, with the app's local Expo native modules for that platform
+// and, on ios, one executable of its installed Nitro providers.
 export async function snapshotDevServerBundles(
   origin,
   projectRoot,
@@ -343,6 +344,7 @@ export async function snapshotDevServerBundles(
             expoSwift: await (
               await import('./expo-swift-bundle')
             ).buildExpoSwiftBundle(projectRoot),
+            nitro: await (await import('./nitro-bundle')).buildNitroBundle(projectRoot),
           }
         : {
             expoKotlin: await (

package/src/cli-runtime.ts

@@ -0,0 +1,55 @@
+import { createHash } from 'node:crypto'
+import { readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { join } from 'node:path'
+import companionIdentity from '../runtime-companion.json' with { type: 'json' }
+import {
+  resolveActiveRuntimeRoot,
+  resolveDevCheckoutRuntimeAssetRoot,
+} from './runtime-assets'
+import type * as CliRuntime from '#peach-cli-contract/cli-companion'
+
+export const CLI_COMPANION_ABI = 1
+
+export function cliCompanionPath(): string {
+  return `node/cli-${companionIdentity.sha256}.cjs`
+}
+
+export function verifyCliCompanion(root: string): void {
+  const file = join(root, cliCompanionPath())
+  let bytes: Buffer
+  try {
+    bytes = readFileSync(file)
+  } catch (cause) {
+    throw new Error(
+      'Peach runtime is missing the companion required by this CLI; run `peach runtime install`',
+      { cause },
+    )
+  }
+  const hash = createHash('sha256').update(bytes).digest('hex')
+  if (hash !== companionIdentity.sha256) {
+    throw new Error(
+      'Peach runtime companion does not match this CLI; run `peach runtime install`',
+    )
+  }
+}
+
+let loaded: { root: string; runtime: typeof CliRuntime } | undefined
+
+// select once per runtime, verify before evaluation, and retain the real functions
+// so host serializers receive their implementation rather than a forwarding closure.
+export function getCliRuntime(): typeof CliRuntime {
+  if (loaded) return loaded.runtime
+  const root = resolveDevCheckoutRuntimeAssetRoot() ?? resolveActiveRuntimeRoot()
+  if (!root) throw new Error('No Peach runtime installed; run `peach runtime install`')
+  verifyCliCompanion(root)
+  const require = createRequire(import.meta.url)
+  const runtime: typeof CliRuntime = require(join(root, cliCompanionPath()))
+  if (runtime.cliCompanionAbi !== CLI_COMPANION_ABI) {
+    throw new Error(
+      'Incompatible Peach runtime companion ABI; run `peach runtime install`',
+    )
+  }
+  loaded = { root, runtime }
+  return runtime
+}

package/src/crash-fingerprint.ts

@@ -0,0 +1,26 @@
+// the text an automatic crash report's signature hashes, shared by the app's
+// red screen and the CLI. it keeps the error kind and the message's words and
+// blanks everything that varies between occurrences of one crash (paths and
+// URLs, quoted values, numbers, hex ids), and leaves stacks out entirely, so
+// one crash dedupes onto one report whatever its frames, directories or data.
+export function crashFingerprint(
+  source: 'app' | 'cli',
+  kind: string,
+  message: string,
+): string {
+  let fuzzy = message.toLowerCase()
+  // redacted locations nest (<v1/users/<n>/>); collapse them from the inside out
+  for (let previous = ''; previous !== fuzzy; ) {
+    previous = fuzzy
+    fuzzy = fuzzy.replace(/<[^<>]*>/g, '\u0000')
+  }
+  fuzzy = fuzzy
+    .replace(/https?:\/\/\S+/g, '\u0000')
+    .replace(/(["'`])[^"'`]*\1/g, "''")
+    .replace(/\b0x[0-9a-f]+\b|\b[0-9a-f]{8,}\b/g, '#')
+    .replace(/\d+/g, '#')
+    .replace(/\u0000/g, '<>')
+    .replace(/\s+/g, ' ')
+    .trim()
+  return `${source}\n${kind.trim()}\n${fuzzy}`
+}