peachsim 0.1.1620 → 0.1.1635

package/src/dev-bundle-resolution.ts

@@ -3,6 +3,7 @@ import {
   isLoopbackHost,
   LOOPBACK_PROBE_HOSTNAMES,
 } from './backend-origin'
+import { parseExpoManifestBody } from './expo-manifest-body'
 import {
   alignLoopbackBundleUrlWithProbe,
   METRO_BUNDLE_PATH,
@@ -159,11 +160,15 @@ type ManifestProbe =
 // manifest whose response consistently takes longer than that probe.
 export const MANIFEST_PROBE_TIMEOUT_MS = 30_000
 
-async function probeExpoManifest(
-  normalizedBaseUrl: string,
-  port: number,
-): Promise<ManifestProbe> {
-  let body: string
+const manifestRequests = new Map<string, Promise<Response | undefined>>()
+
+// the scanner, its enrichment and explicit opens share the complete response.
+// a short scan deadline must not discard work that an open is still awaiting.
+export async function fetchDevManifest(baseUrl: string): Promise<Response | undefined> {
+  const normalizedBaseUrl = baseUrl.replace(/\/+$/, '')
+  const existing = manifestRequests.get(normalizedBaseUrl)
+  if (existing) return (await existing)?.clone()
+
   // the deadline means STOP WAITING, not KILL THE REQUEST. `AbortSignal.timeout`
   // does the second: it tears down a dev server that is still assembling its
   // manifest, which fires "Cannot pipe to a closed or destroyed stream" into
@@ -173,39 +178,55 @@ async function probeExpoManifest(
   const pending = fetchDevProbe(`${normalizedBaseUrl}/`, {
     headers: { 'expo-platform': 'ios' },
   })
-    .then(async (res) => ({
-      status: res.status,
-      contentType: res.headers.get('content-type') || '',
-      body: await res.text(),
-    }))
+    .then(async (res) => {
+      const body = await res.arrayBuffer()
+      return new Response(body.byteLength ? body : null, {
+        status: res.status,
+        headers: res.headers,
+      })
+    })
     .catch(() => undefined)
   let probeDeadline: ReturnType<typeof setTimeout> | undefined
-  const answered = await Promise.race([
+  const request = Promise.race([
     pending,
     new Promise<'timeout'>((resolve) => {
       probeDeadline = setTimeout(() => resolve('timeout'), MANIFEST_PROBE_TIMEOUT_MS)
     }),
   ])
-  // the race is settled, so drop the deadline rather than leaving it pending.
-  clearTimeout(probeDeadline)
-  if (answered === 'timeout')
-    throw new Error(
-      `Metro manifest request timed out after ${MANIFEST_PROBE_TIMEOUT_MS / 1000}s: ${normalizedBaseUrl}/. Wait for the dev server to finish starting or check its manifest endpoint.`,
-    )
+    .then((answered) => {
+      if (answered === 'timeout')
+        throw new Error(
+          `Metro manifest request timed out after ${MANIFEST_PROBE_TIMEOUT_MS / 1000}s: ${normalizedBaseUrl}/. Wait for the dev server to finish starting or check its manifest endpoint.`,
+        )
+      return answered
+    })
+    .finally(() => {
+      clearTimeout(probeDeadline)
+      manifestRequests.delete(normalizedBaseUrl)
+    })
+  manifestRequests.set(normalizedBaseUrl, request)
+  return (await request)?.clone()
+}
+
+async function probeExpoManifest(
+  normalizedBaseUrl: string,
+  port: number,
+): Promise<ManifestProbe> {
+  const answered = await fetchDevManifest(normalizedBaseUrl)
   if (answered === undefined) return { state: 'no-answer' }
   if (answered.status === 404 || answered.status === 405) return { state: 'no-manifest' }
   if (answered.status < 200 || answered.status >= 300)
     throw new Error(
       `Metro manifest request failed: HTTP ${answered.status} at ${normalizedBaseUrl}/`,
     )
-  body = answered.body
+  const body = await answered.text()
   if (!body.trim()) return { state: 'no-answer' }
 
   let manifest: unknown
   try {
-    manifest = JSON.parse(body)
+    manifest = parseExpoManifestBody(body)
   } catch {
-    if (answered.contentType.includes('json'))
+    if (answered.headers.get('content-type')?.includes('json'))
       throw new Error(`Metro returned invalid manifest JSON at ${normalizedBaseUrl}/`)
     // a page rather than a manifest — Metro's landing page, or an app's own
     // SSR html. that is a real answer: this server serves no manifest.
@@ -309,12 +330,25 @@ async function probeBaseUrlBundle(
 export async function probePortBundle(port: number): Promise<ResolvedDevBundle | null> {
   const viaScan = await resolvePortViaServerScan(port)
   if (viaScan) return viaScan
-  const candidates = await Promise.all(
-    LOOPBACK_PROBE_HOSTNAMES.map((hostname) =>
-      probeBaseUrlBundleDirect(buildLoopbackProbeBaseUrl('http:', hostname, port), port),
-    ),
-  )
-  return candidates.find((candidate) => candidate !== null) ?? null
+  const unresolved = buildUnresolvedTargetError(`localhost:${port}`)
+  try {
+    // a silent or failed address family must not hold back a valid sibling.
+    return await Promise.any(
+      LOOPBACK_PROBE_HOSTNAMES.map(async (hostname) => {
+        const bundle = await probeBaseUrlBundleDirect(
+          buildLoopbackProbeBaseUrl('http:', hostname, port),
+          port,
+        )
+        if (!bundle) throw unresolved
+        return bundle
+      }),
+    )
+  } catch (error) {
+    if (!(error instanceof AggregateError)) throw error
+    const failure = error.errors.find((candidate) => candidate !== unresolved)
+    if (failure !== undefined) throw failure
+    return null
+  }
 }
 
 export async function resolveConnectionInput(input: string): Promise<ResolvedDevBundle> {

package/src/expo-kotlin-host.ts

@@ -1,22 +1,15 @@
 // local Expo modules on an Android device: expo's own autolinker selects the
 // app-owned Android modules, as its gradle plugin does, and their Kotlin
 // compiles into one Kotlin/Wasm process with the expo-modules-core DSL port.
-import { execFile } from 'node:child_process'
 import fs from 'node:fs'
-import { createRequire } from 'node:module'
 import path from 'node:path'
-import { promisify } from 'node:util'
-import { RNX_FORKED_SCRIPT_ENV } from '../cli/internal-child'
+import { resolveExpoAndroidAutolinking } from './android-autolinking'
 import { isLoopbackHost } from './backend-origin'
 import { isRecord } from './is-record'
 import { peachKotlinModuleRoot } from './kotlin-module'
 import type { ExpoKotlinCompilationResult } from './expoKotlinContract'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 
-const run = promisify(execFile)
-// the compiled CLI's execPath is peach itself, which runs a forked `.js` as a
-// script only with this set; node and bun ignore it.
-const scriptEnv = { ...process.env, [RNX_FORKED_SCRIPT_ENV]: '1' }
 export const EXPO_KOTLIN_ROUTE = '/__peach/expo-kotlin'
 
 export interface ExpoKotlinModules {
@@ -28,35 +21,12 @@ export interface ExpoKotlinModules {
 export async function collectExpoKotlinModules(
   appRoot: string,
 ): Promise<ExpoKotlinModules | null> {
-  appRoot = fs.realpathSync(appRoot)
-  let autolinker: string
-  try {
-    autolinker = createRequire(path.join(appRoot, 'package.json')).resolve(
-      'expo-modules-autolinking/package.json',
-    )
-  } catch (error) {
-    if (isRecord(error) && error.code === 'MODULE_NOT_FOUND') return null
-    throw error
-  }
-  const { stdout } = await run(
-    process.execPath,
-    [
-      path.join(path.dirname(autolinker), 'bin/expo-modules-autolinking.js'),
-      'resolve',
-      '--platform',
-      'android',
-      '--project-root',
-      appRoot,
-      '--json',
-    ],
-    { timeout: 30_000, maxBuffer: 8 * 1024 * 1024, env: scriptEnv },
-  )
-  const resolved: unknown = JSON.parse(stdout)
-  if (!isRecord(resolved) || !Array.isArray(resolved.modules))
-    throw new Error('invalid Expo Android resolution')
+  const modules = await resolveExpoAndroidAutolinking(appRoot)
   const result: ExpoKotlinModules = { modules: [], sources: [] }
-  for (const entry of resolved.modules) {
-    if (!isRecord(entry) || !Array.isArray(entry.projects))
+  for (const entry of modules) {
+    // plugin-only dependencies have no local Kotlin module project.
+    if (entry.projects === undefined) continue
+    if (!Array.isArray(entry.projects))
       throw new Error('invalid Expo Android module entry')
     for (const project of entry.projects) {
       if (

package/src/expo-manifest-body.ts

@@ -0,0 +1,13 @@
+// an Expo packager serves its manifest as JSON, or as the multipart form body
+// Expo Updates defines (older CLIs always, whatever the request accepts) whose
+// `manifest` part carries the same JSON.
+export function parseExpoManifestBody(body: string) {
+  const opening = /^(--[^\r\n]+)\r?\n/.exec(body)
+  if (!opening) return JSON.parse(body)
+  for (const part of body.split(opening[1])) {
+    const headerEnd = part.search(/\r?\n\r?\n/)
+    if (headerEnd < 0 || !/\bname="manifest"/.test(part.slice(0, headerEnd))) continue
+    return JSON.parse(part.slice(headerEnd).trim())
+  }
+  throw new Error('Expo manifest response has no manifest part')
+}

package/src/expo-swift-bundle.ts

@@ -12,20 +12,25 @@ export async function buildExpoSwiftBundle(
   appRoot: string,
 ): Promise<ExpoSwiftBundle | null> {
   const assets: ExpoSwiftBundle['assets'] = []
-  const metadata = await compileExpoSwiftModules(appRoot, '', async (artifact) => {
-    assets.push({
-      path: `__peach/swift/${artifact.hash}.wasm`,
-      bytes: artifact.bytes,
-      contentType: 'application/wasm',
-    })
-    if ('gzip' in artifact.icu) {
+  const metadata = await compileExpoSwiftModules(
+    appRoot,
+    '',
+    async (artifact, signal) => {
+      signal.throwIfAborted()
       assets.push({
-        path: `__peach/swift-icu/${artifact.icu.sha256}`,
-        bytes: artifact.icu.gzip,
-        contentType: 'application/gzip',
+        path: `__peach/swift/${artifact.hash}.wasm`,
+        bytes: artifact.bytes,
+        contentType: 'application/wasm',
       })
-    }
-  })
+      if ('gzip' in artifact.icu) {
+        assets.push({
+          path: `__peach/swift-icu/${artifact.icu.sha256}`,
+          bytes: artifact.icu.gzip,
+          contentType: 'application/gzip',
+        })
+      }
+    },
+  )
   if (!metadata) return null
 
   return { metadata, assets }