peachsim 0.1.1644 → 0.1.1653

package/src/host/bridge-host.ts

@@ -13,6 +13,7 @@ import {
   SOOTSIM_BRIDGE_SIM_CLOSE_CODE,
   SOOTSIM_BRIDGE_SIM_CLOSE_REASON,
 } from '../bridge-constants.ts'
+import { commandWritesSim, type WsCommand } from '../bridge-contract.ts'
 import { getCliVersion } from '../cli-version.ts'
 import { activeDesktopHostApp } from '../desktop-host-delivery.ts'
 import { handleExpoSwiftRequest } from '../expo-swift-host.ts'
@@ -69,7 +70,6 @@ import {
   handleWebSocketProxyUpgrade,
   rejectUntrustedBridgeUpgrade,
 } from './websocket-proxy.ts'
-import type { WsCommand } from '../bridge-contract.ts'
 
 const SOOTSIM_CROSS_ORIGIN_EMBEDDER_POLICY = 'require-corp'
 
@@ -197,22 +197,6 @@ interface BridgeCliLease {
   ownerSocket?: WebSocket
 }
 
-// interactive commands change app state and must respect the lease.
-// observational/lifecycle commands (evaluate/tree/query/resolve/screenshot/capture/focus/call/close)
-// pass through without taking or checking a lease so cleanup never gets stuck
-// behind a stale cli owner.
-// `call` used to acquire a lease too, but most call paths are queries
-// (`__sootsimTest.findByTestId`, state reads, etc.). the CLI opts write
-// calls into lease acquisition via msg.acquireLock=true.
-const WRITE_COMMAND_TYPES = new Set([
-  'tap',
-  'keyboard',
-  'longPress',
-  'perform',
-  'reset',
-  'camera',
-])
-
 // how long a `close` waits for the sim page to tear itself down before the
 // host disconnects the sim socket. the close code is part of the protocol:
 // browser clients treat it as terminal and skip their normal reconnect loop.
@@ -223,13 +207,6 @@ const FORCE_CLOSE_TERMINATE_MS = 1000
 // type). a duplicate copy used to live here from a concurrent edit and
 // broke the standalone CLI esbuild bundle ("symbol already declared").
 
-function shouldAcquireLease(msg: any): boolean {
-  if (!msg || 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)
-}
-
 interface BridgeRestorableSimState {
   recentActions: BridgeRecentAction[]
   lastActiveAt: number
@@ -1075,7 +1052,7 @@ export class SootSimBridgeHost {
             }
 
             const targetSim = await this.waitForSim(msg.simId)
-            if (shouldAcquireLease(msg)) {
+            if (commandWritesSim(msg)) {
               const outcome = this.tryAcquireLease(ws, targetSim)
               if (!outcome.granted) {
                 if (ws.readyState === WebSocket.OPEN) {
@@ -2516,7 +2493,7 @@ export class SootSimBridgeHost {
   // called when the sim reports a real user interaction (pointerdown,
   // keydown, wheel, touch). creates or refreshes a short `user-active` lease
   // that keeps agent writes from trampling a user who is driving the sim.
-  // reads still pass through — shouldAcquireLease only blocks on writes.
+  // reads still pass through — commandWritesSim only blocks on writes.
   private updateUserActivity(sim: BridgeSimConnection) {
     const existing = this.getActiveLease(sim)
     if (existing && existing.kind === 'cli') {

package/src/host/browser-pointer.ts

@@ -0,0 +1,71 @@
+export interface BrowserPointerRequest {
+  phase: 'down' | 'move' | 'up' | 'cancel'
+  x: number
+  y: number
+  pointerId: number
+}
+
+// both browser hosts use chromium input so editable defaults and cross-origin
+// iframe hit testing run in the browser, rather than simulated DOM events.
+export function createBrowserPointerDispatcher(
+  send: (
+    method: 'Input.dispatchTouchEvent',
+    params: {
+      type: 'touchStart' | 'touchMove' | 'touchEnd' | 'touchCancel'
+      touchPoints: Array<{ x: number; y: number; id: number }>
+    },
+  ) => Promise<unknown>,
+) {
+  const points = new Map<number, { x: number; y: number; id: number }>()
+  return async (value: unknown): Promise<void> => {
+    if (!value || typeof value !== 'object') throw new Error('missing browser pointer')
+    const phase = Reflect.get(value, 'phase')
+    const x = Reflect.get(value, 'x')
+    const y = Reflect.get(value, 'y')
+    const pointerId = Reflect.get(value, 'pointerId')
+    if (phase !== 'down' && phase !== 'move' && phase !== 'up' && phase !== 'cancel')
+      throw new Error('invalid browser pointer phase')
+    if (
+      typeof x !== 'number' ||
+      !Number.isFinite(x) ||
+      typeof y !== 'number' ||
+      !Number.isFinite(y)
+    )
+      throw new Error('browser pointer coordinates must be finite')
+    if (
+      typeof pointerId !== 'number' ||
+      !Number.isSafeInteger(pointerId) ||
+      pointerId < 0
+    )
+      throw new Error('browser pointer id must be a nonnegative integer')
+    const request: BrowserPointerRequest = { phase, x, y, pointerId }
+    if (request.phase === 'down') {
+      if (points.has(request.pointerId)) throw new Error('browser pointer already down')
+      points.set(request.pointerId, { x: request.x, y: request.y, id: request.pointerId })
+    } else {
+      // chromium cancels the entire touch stream at once; the caller still
+      // releases each bound pointer while unwinding a multi-touch gesture.
+      if (request.phase === 'cancel' && points.size === 0) return
+      if (!points.has(request.pointerId)) throw new Error('browser pointer is not down')
+      if (request.phase === 'move')
+        points.set(request.pointerId, {
+          x: request.x,
+          y: request.y,
+          id: request.pointerId,
+        })
+      else if (request.phase === 'cancel') points.clear()
+      else points.delete(request.pointerId)
+    }
+    await send('Input.dispatchTouchEvent', {
+      type:
+        request.phase === 'down'
+          ? 'touchStart'
+          : request.phase === 'move'
+            ? 'touchMove'
+            : request.phase === 'up'
+              ? 'touchEnd'
+              : 'touchCancel',
+      touchPoints: [...points.values()],
+    })
+  }
+}

package/src/host/dev-server-package-versions.ts

@@ -0,0 +1,23 @@
+import fs from 'fs'
+import path from 'path'
+import { readInstalledNativePackageVersionsAsync } from '../installed-package-versions.ts'
+import { resolveMetroProjectRoot } from '../metro-project-root.ts'
+import type { PackageVersions } from '../packageVersionsContract'
+
+// a plain Metro or Expo dev server records no installed versions in its
+// bundle. the bridge serving that bundle reads them from the project the
+// server names, the way `peach open` reads its own project. a server that
+// names no project, or one whose project is not on this machine, gets none.
+export async function readDevServerPackageVersions(
+  bundleUrl: URL,
+): Promise<PackageVersions | null> {
+  if (!bundleUrl.pathname.endsWith('.bundle')) return null
+  const projectRoot = await resolveMetroProjectRoot(bundleUrl.href)
+  if (!projectRoot) return null
+  try {
+    await fs.promises.access(path.join(projectRoot, 'package.json'))
+  } catch {
+    return null
+  }
+  return readInstalledNativePackageVersionsAsync(projectRoot)
+}

package/src/host/fetch-proxy-handler.ts

@@ -33,6 +33,8 @@ import {
   isTrustedBridgeRequest,
   normalizeHostname,
 } from '../backend-origin.ts'
+import { PACKAGE_VERSIONS_HEADER } from '../packageVersionsContract'
+import { readDevServerPackageVersions } from './dev-server-package-versions.ts'
 import {
   buildFetchProxyUpstreamHeaders,
   FETCH_PROXY_FAILURE_HEADER,
@@ -218,7 +220,7 @@ export async function handleFetchProxyRequest(
 
   await proxyUpstream(req, res, upstreamUrl, params.has(FETCH_PROXY_FAILURE_PARAM), {
     requestHeaders: (target) => buildFetchProxyHeaders(req.headers, target),
-    respond: (upstream, setCookies) => {
+    respond: async (upstream, setCookies) => {
       for (const [key, value] of Object.entries(upstream.headers)) {
         const lowerKey = key.toLowerCase()
         if (
@@ -240,6 +242,17 @@ export async function handleFetchProxyRequest(
         }
         res.setHeader(key, value)
       }
+      // a bundle whose server records no install gets the one its project holds
+      if (
+        isBundleProxyRequestUrl(req.url) &&
+        req.method === 'GET' &&
+        upstream.statusCode === 200 &&
+        !res.hasHeader(PACKAGE_VERSIONS_HEADER)
+      ) {
+        const packageVersions = await readDevServerPackageVersions(upstreamUrl)
+        if (packageVersions)
+          res.setHeader(PACKAGE_VERSIONS_HEADER, JSON.stringify(packageVersions))
+      }
       applyFetchProxyCors(req, res)
       if (setCookies.length > 0)
         res.setHeader('x-sootsim-set-cookie', setCookies.join(', '))
@@ -345,7 +358,7 @@ async function proxyUpstream(
   reportFailure: boolean,
   route: {
     requestHeaders: (targetUrl: URL) => Record<string, string | string[]>
-    respond: (upstream: IncomingMessage, setCookies: string[]) => void
+    respond: (upstream: IncomingMessage, setCookies: string[]) => void | Promise<void>
   },
 ): Promise<void> {
   const originalMethod = req.method || 'GET'
@@ -444,7 +457,7 @@ async function proxyUpstream(
         redirectLimit: 10,
       }
       res.setHeader(FETCH_PROXY_NATIVE_COOKIE_RESPONSE_HEADER, nativeCookieHopHeader(hop))
-      route.respond(proxyRes, hopCookies)
+      await route.respond(proxyRes, hopCookies)
       if (isNativeCookieRedirect(hop)) res.removeHeader('location')
       res.statusCode = isNativeCookieRedirect(hop) ? 200 : status
       await pipeline(proxyRes, res)
@@ -479,7 +492,7 @@ async function proxyUpstream(
     }
 
     if (redirects > 0) res.setHeader(FETCH_PROXY_RESPONSE_URL_HEADER, targetUrl.href)
-    route.respond(proxyRes, hopCookies)
+    await route.respond(proxyRes, hopCookies)
     res.statusCode = status
     await pipeline(proxyRes, res)
   }

package/src/installed-package-versions.ts

@@ -2,38 +2,144 @@
 // compiles a package's native side from the copy autolinking finds, which is
 // Node resolution from the project root, so that is the copy read here even
 // when the graph also bundles a nested one.
+//
+// each walk yields the file system reads it needs. the sync driver answers
+// them for one-shot callers; the async one for servers that must keep
+// answering other requests while a large workspace is read.
 
 import fs from 'fs'
 import path from 'path'
 import { LAZY_STUB_PATTERNS } from '@peach/compat/lazy-stub-patterns'
 import { NATIVE_RUNTIME_PACKAGE_NAMES } from '@peach/compat/native-package-names'
 import { COMPAT_STUBS } from '@peach/compat/stub-manifest'
-import { extractPackageFromPath } from '../../peach-engine/src/stub-pattern-matcher'
+import { extractPackageFromPath } from './stub-pattern-matcher.ts'
 import type { PackageVersions } from './packageVersionsContract'
 
-function readInstalledPackage(projectRoot: string, name: string) {
-  let dir = projectRoot
-  for (;;) {
-    let manifest: unknown
-    try {
-      manifest = JSON.parse(
-        fs.readFileSync(path.join(dir, 'node_modules', name, 'package.json'), 'utf8'),
-      )
-    } catch (error) {
-      if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) {
-        throw error
+type InstalledPackage = { root: string; manifest: object }
+
+type FsStep =
+  | { op: 'exists'; path: string }
+  | { op: 'realpath'; path: string }
+  // the parsed package.json, or null when there is none or it is not an object
+  | { op: 'manifest'; path: string }
+type FsAnswer = boolean | string | object | null
+type FsWalk<T> = Generator<FsStep, T, FsAnswer>
+
+function* exists(target: string): FsWalk<boolean> {
+  return (yield { op: 'exists', path: target }) === true
+}
+
+function* realpath(target: string): FsWalk<string> {
+  const resolved = yield { op: 'realpath', path: target }
+  if (typeof resolved !== 'string') throw new Error(`could not resolve ${target}`)
+  return resolved
+}
+
+function* readManifest(target: string): FsWalk<object | null> {
+  const manifest = yield { op: 'manifest', path: target }
+  return typeof manifest === 'object' ? manifest : null
+}
+
+function parseManifest(source: string): object | null {
+  const manifest: unknown = JSON.parse(source)
+  return typeof manifest === 'object' && manifest !== null ? manifest : null
+}
+
+function isMissing(error: unknown): boolean {
+  return error instanceof Error && 'code' in error && error.code === 'ENOENT'
+}
+
+function answerSync(step: FsStep): FsAnswer {
+  if (step.op === 'exists') return fs.existsSync(step.path)
+  if (step.op === 'realpath') return fs.realpathSync(step.path)
+  try {
+    return parseManifest(fs.readFileSync(step.path, 'utf8'))
+  } catch (error) {
+    if (isMissing(error)) return null
+    throw error
+  }
+}
+
+async function answerAsync(step: FsStep): Promise<FsAnswer> {
+  if (step.op === 'exists')
+    return fs.promises.access(step.path).then(
+      () => true,
+      () => false,
+    )
+  if (step.op === 'realpath') return fs.promises.realpath(step.path)
+  try {
+    return parseManifest(await fs.promises.readFile(step.path, 'utf8'))
+  } catch (error) {
+    if (isMissing(error)) return null
+    throw error
+  }
+}
+
+function runSync<T>(walk: FsWalk<T>): T {
+  for (let step = walk.next(); ; ) {
+    if (step.done) return step.value
+    step = walk.next(answerSync(step.value))
+  }
+}
+
+async function runAsync<T>(walk: FsWalk<T>): Promise<T> {
+  for (let step = walk.next(); ; ) {
+    if (step.done) return step.value
+    step = walk.next(await answerAsync(step.value))
+  }
+}
+
+// Node resolution looks in each ancestor's node_modules, skipping directories
+// that are themselves node_modules. one walk asks the same ancestors for many
+// names, so each directory's node_modules is checked once and each manifest
+// read once.
+function createInstalledPackageReader() {
+  const hasModules = new Map<string, boolean>()
+  const manifests = new Map<string, InstalledPackage | null>()
+  return function* readInstalledPackage(
+    fromDir: string,
+    name: string,
+  ): FsWalk<InstalledPackage | null> {
+    for (let dir = fromDir; ; ) {
+      if (path.basename(dir) !== 'node_modules') {
+        const modules = path.join(dir, 'node_modules')
+        let present = hasModules.get(dir)
+        if (present === undefined) {
+          present = yield* exists(modules)
+          hasModules.set(dir, present)
+        }
+        if (present) {
+          const root = path.join(modules, name)
+          let installed = manifests.get(root)
+          if (installed === undefined) {
+            const manifest = yield* readManifest(path.join(root, 'package.json'))
+            installed = manifest ? { root, manifest } : null
+            manifests.set(root, installed)
+          }
+          if (installed) return installed
+        }
       }
       const parent = path.dirname(dir)
       if (parent === dir) return null
       dir = parent
-      continue
     }
-    return typeof manifest === 'object' && manifest !== null
-      ? { root: path.join(dir, 'node_modules', name), manifest }
-      : null
   }
 }
 
+function* installedVersionsWalk(
+  projectRoot: string,
+  names: Iterable<string>,
+): FsWalk<PackageVersions> {
+  const readInstalledPackage = createInstalledPackageReader()
+  const versions: PackageVersions = {}
+  for (const name of [...names].sort()) {
+    const installed = yield* readInstalledPackage(projectRoot, name)
+    const version = installed && Reflect.get(installed.manifest, 'version')
+    if (typeof version === 'string' && version.length > 0) versions[name] = version
+  }
+  return versions
+}
+
 export function readInstalledPackageVersions(
   projectRoot: string,
   modulePaths: Iterable<string>,
@@ -43,20 +149,14 @@ export function readInstalledPackageVersions(
     const name = extractPackageFromPath(modulePath.replaceAll(path.sep, '/'))
     if (name) names.add(name)
   }
-  const versions: PackageVersions = {}
-  for (const name of [...names].sort()) {
-    const installed = readInstalledPackage(projectRoot, name)
-    const version = installed && Reflect.get(installed.manifest, 'version')
-    if (typeof version === 'string' && version.length > 0) versions[name] = version
-  }
-  return versions
+  return runSync(installedVersionsWalk(projectRoot, names))
 }
 
 // plain expo and one servers need no peach plugin. the launcher reads their
 // installed native packages from the app's dependency graph. an unrelated
 // package hoisted beside a workspace app is resolvable but is not linked.
-export function readInstalledNativePackageVersions(projectRoot: string): PackageVersions {
-  const appRoot = fs.realpathSync(projectRoot)
+function* nativePackageVersionsWalk(projectRoot: string): FsWalk<PackageVersions> {
+  const appRoot = yield* realpath(projectRoot)
   const nativeNames = new Set<string>()
   for (const specifier of [
     'react-native',
@@ -67,17 +167,14 @@ export function readInstalledNativePackageVersions(projectRoot: string): Package
     const name = extractPackageFromPath(`node_modules/${specifier}`)
     if (name) nativeNames.add(name)
   }
-  const manifest: unknown = JSON.parse(
-    fs.readFileSync(path.join(appRoot, 'package.json'), 'utf8'),
-  )
-  if (typeof manifest !== 'object' || manifest === null) {
-    throw new Error('app package.json must contain an object')
-  }
-  const pending = [{ root: appRoot, manifest }]
+  const manifest = yield* readManifest(path.join(appRoot, 'package.json'))
+  if (!manifest) throw new Error('app package.json must contain an object')
+  const readInstalledPackage = createInstalledPackageReader()
+  const pending: InstalledPackage[] = [{ root: appRoot, manifest }]
   const visited = new Set<string>()
   const needed = new Set<string>()
   for (let next = pending.pop(); next; next = pending.pop()) {
-    const root = fs.realpathSync(next.root)
+    const root = yield* realpath(next.root)
     if (visited.has(root)) continue
     visited.add(root)
     const fields = ['dependencies', 'optionalDependencies', 'peerDependencies']
@@ -92,15 +189,22 @@ export function readInstalledNativePackageVersions(projectRoot: string): Package
           if (typeof peer === 'object' && peer !== null && Reflect.get(peer, 'optional'))
             continue
         }
-        const installed = readInstalledPackage(root, name)
+        const installed = yield* readInstalledPackage(root, name)
         if (!installed) continue
         if (nativeNames.has(name)) needed.add(name)
         pending.push(installed)
       }
     }
   }
-  return readInstalledPackageVersions(
-    projectRoot,
-    [...needed].map((specifier) => `node_modules/${specifier}`),
-  )
+  return yield* installedVersionsWalk(projectRoot, needed)
+}
+
+export function readInstalledNativePackageVersions(projectRoot: string): PackageVersions {
+  return runSync(nativePackageVersionsWalk(projectRoot))
+}
+
+export function readInstalledNativePackageVersionsAsync(
+  projectRoot: string,
+): Promise<PackageVersions> {
+  return runAsync(nativePackageVersionsWalk(projectRoot))
 }

package/src/kotlin-host.ts

@@ -325,7 +325,7 @@ function entrySource(ids: string[]): string {
     '@JsExport',
     'fun peachSetAndroidBuildInfo(model: String, release: String) = Build.setDevice(model, release)',
     '',
-    '@OptIn(kotlin.js.ExperimentalJsExport::class, kotlin.js.ExperimentalWasmJsInterop::class, kotlinx.coroutines.DelicateCoroutinesApi::class)',
+    '@OptIn(kotlin.js.ExperimentalJsExport::class, kotlinx.coroutines.DelicateCoroutinesApi::class)',
     '@JsExport',
     'fun peachNativeCall(module: String, method: String, argsJson: String, contractHash: String): Promise<JsAny?> =',
     '    GlobalScope.promise(Dispatchers.Main) {',

package/src/metro-plugin.ts

@@ -12,10 +12,6 @@ import fs from 'fs'
 import { createRequire } from 'module'
 import { randomUUID } from 'node:crypto'
 import path from 'path'
-import {
-  getRuntimePlatformAdapter,
-  isRuntimePlatform,
-} from '../../peach-engine/src/platform/adapter'
 import { resolveAppProject } from '../cli/app-project'
 import { collectAndroidAutolinkedPackages } from './android-autolinking'
 import { insertAndroidAutolinkingFooter } from './androidAutolinkingContract'
@@ -51,6 +47,10 @@ import {
   serveRuntimeFile,
   SOOTSIM_RUNTIME_MISSING_MESSAGE,
 } from './runtime-assets'
+import {
+  getRuntimePlatformAdapter,
+  isRuntimePlatform,
+} from './runtimePlatformContract.ts'
 
 const prefix = '/__peachsim'
 export { toPeachDevelopmentBundleUrl, toPeachProductionBundleUrl }

package/src/metro-project-root.ts

@@ -0,0 +1,68 @@
+import { resolveListeningPid, resolveProcessCwd } from '../scripts/dev-server-scanner'
+import { loopbackOriginOf } from './backend-origin'
+import { MANIFEST_PROBE_TIMEOUT_MS } from './dev-bundle-resolution'
+import { parseExpoManifestBody } from './expo-manifest-body'
+
+// resolve a metro dev server's project root. Expo's middleware advertises it
+// in X-React-Native-Project-Root, encoded with encodeURI. Older servers name it
+// in extra.expoClient._internal.projectRoot. The local peach open path runs from the
+// CLI's cwd, which almost never owns the bundle being opened (e.g.
+// `peach open 8081` run from ~/contrast against a 3pc metro), so scanning cwd for
+// font declarations finds nothing.
+//
+// a bare react-native packager serves no such manifest, so the same resolver
+// asks the OS for the listening process's cwd. that is still the development
+// server's project identity; the invoking CLI's cwd is never consulted.
+//
+// it waits on the same budget as the manifest resolution that found this dev
+// server. a cold Expo Metro answers /status in 2-4s while it builds a bundle,
+// and dropping the project there opens the app without its fonts, splash or
+// Firebase config. a server that stays silent past the budget fails the open.
+export async function resolveMetroProjectRoot(bundleUrl: string): Promise<string | null> {
+  const origin = loopbackOriginOf(bundleUrl)
+  if (!origin) return null
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), MANIFEST_PROBE_TIMEOUT_MS)
+  let servedManifest = false
+  let metroRunning = false
+  try {
+    const status = await fetch(`${origin}/status`, { signal: controller.signal })
+    const advertisedRoot = status.headers.get('X-React-Native-Project-Root')
+    if (status.ok && advertisedRoot) return decodeURI(advertisedRoot)
+    metroRunning = status.ok && (await status.text()).trim() === 'packager-status:running'
+    const res = await fetch(`${origin}/`, {
+      headers: { 'expo-platform': 'ios', Accept: 'application/json' },
+      signal: controller.signal,
+    })
+    if (res.ok) {
+      const manifest: unknown = parseExpoManifestBody(await res.text())
+      servedManifest = true
+      let root: unknown = manifest
+      for (const key of ['extra', 'expoClient', '_internal', 'projectRoot']) {
+        root =
+          typeof root === 'object' && root !== null ? Reflect.get(root, key) : undefined
+      }
+      if (typeof root === 'string' && root.length > 0) return root
+    }
+  } catch {
+    if (controller.signal.aborted)
+      throw new Error(
+        `Metro project root request timed out after ${MANIFEST_PROBE_TIMEOUT_MS / 1000}s: ${origin}. Wait for the dev server to finish starting or pass --project-root.`,
+      )
+  } finally {
+    clearTimeout(timer)
+  }
+
+  // a server that answered with a manifest has already told us everything it
+  // knows. if it did not name a project root there is none to learn, and asking
+  // the OS about the listening process would answer with whatever directory
+  // that process happens to sit in — which is the CLI's own cwd trap this
+  // function exists to avoid. only a server whose status identifies Metro
+  // and which served no manifest gets the process lookup.
+  if (servedManifest || !metroRunning) return null
+
+  const port = Number(new URL(origin).port)
+  if (!Number.isFinite(port) || port <= 0) return null
+  const pid = await resolveListeningPid(port)
+  return pid === null ? null : resolveProcessCwd(pid)
+}

package/src/nitro-adapter.lock.json

@@ -0,0 +1,26 @@
+{
+  "schema": 1,
+  "platform": "ios",
+  "target": "wasm32-unknown-wasip1",
+  "recipe": "93ec12de28e70ccd6a0ff72c91fe59add61930da9b9f0c981c35b8ff64abdf8e",
+  "adapter": {
+    "sha256": "051a6905f1194aa18075d68e0444d30e69b4e52dc6017f3e70815a2403e3c306"
+  },
+  "headers": {
+    "reactNativeJsi": "96db4e758dd53e9320cef7cad485e00aa06e7a982cefd920f17007de8a5bd9f9",
+    "nitroModules": "372b6f69fc063a0b316792eec9b26f36063868dc206f169acbb5d993c6572f65"
+  },
+  "compiler": "swift-6.4.0-RELEASE-custom-0d775d32d7c74eae",
+  "sdk": {
+    "id": "swift-6.4.0-RELEASE_wasm-peach-f02bd198",
+    "checksum": "1e19ea768fd4e821aae34b8966c4ddcee45615c4b3cf018979b061aee2fb5504"
+  },
+  "framework": {
+    "distribution": "e3bdd3d8fa4f9993",
+    "wireAbi": "ed0b01fcc0a79236d88ef9ac7950ac30932dfc19c19112c69d1d6a039a489292"
+  },
+  "archive": {
+    "sha256": "1cf000ee821aaf65b04a3d6702c7d4341e450371cfd199e5887c6056f80af899",
+    "size": 31175
+  }
+}