peachsim 0.1.1620 → 0.1.1625

package/src/android-strings.ts

@@ -6,6 +6,7 @@
 // rejected by name, never read as the default or as text.
 import fs from 'node:fs'
 import path from 'node:path'
+import { compileAndroidStringValue } from './android-string-value'
 import { decodeXmlText } from './android-xml'
 
 // one resource's value per locale: '' for values, then a language or a
@@ -123,41 +124,9 @@ const sorted = <Value>(
     .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
     .map(([name, values]) => ({ name, values }))
 
-// aapt2's StringBuilder over the decoded text: outside double quotes a run of
-// whitespace is one space and the ends are trimmed, an unescaped apostrophe is
-// an error; a double quote toggles quoting and is dropped; a backslash escapes
-// the next character (\n, \t and \uXXXX, any other character as itself). a
-// value beginning with @ or ? is a reference aapt2 resolves, which Peach does
-// not yet
 function compileString(raw: string, where: string): string {
-  const text = decodeXmlText(raw.replace(/<[^>]*>/g, ''), where)
-  if (/^\s*[@?]/.test(text))
-    throw new Error(`${where} is a resource reference, not resolved by peach kotlin yet`)
-  const out: { char: string; soft: boolean }[] = []
-  let quoted = false
-  for (let index = 0; index < text.length; index++) {
-    const char = text[index] ?? ''
-    if (char === '\\') {
-      const next = text[index + 1]
-      if (next === undefined) break
-      index++
-      if (next === 'n') out.push({ char: '\n', soft: false })
-      else if (next === 't') out.push({ char: '\t', soft: false })
-      else if (next === 'u') {
-        const hex = text.slice(index + 1, index + 5)
-        if (!/^[0-9a-fA-F]{4}$/.test(hex))
-          throw new Error(`${where} has an invalid unicode escape \\u${hex}`)
-        out.push({ char: String.fromCharCode(Number.parseInt(hex, 16)), soft: false })
-        index += 4
-      } else out.push({ char: next, soft: false })
-    } else if (char === '"') quoted = !quoted
-    else if (char === "'" && !quoted)
-      throw new Error(`${where} has an unescaped apostrophe`)
-    else if (!quoted && /\s/.test(char)) {
-      if (out.at(-1)?.soft !== true) out.push({ char: ' ', soft: true })
-    } else out.push({ char, soft: false })
-  }
-  while (out[0]?.soft) out.shift()
-  while (out.at(-1)?.soft) out.pop()
-  return out.map((part) => part.char).join('')
+  return compileAndroidStringValue(
+    decodeXmlText(raw.replace(/<[^>]*>/g, ''), where),
+    where,
+  )
 }

package/src/androidAutolinkingContract.ts

@@ -0,0 +1,40 @@
+import {
+  detachBundleGlobalFooter,
+  insertBundleGlobalFooter,
+  readBundleGlobalFooter,
+} from './bundleGlobalFooter'
+
+const FOOTER = '__peachAndroidAutolinkedPackages'
+
+export function readAndroidAutolinkedPackages(value: unknown): string[] {
+  if (
+    !Array.isArray(value) ||
+    !value.every((name) => typeof name === 'string' && name.length > 0)
+  )
+    throw new Error('invalid Android autolinked packages')
+  return [...new Set(value)].sort((left, right) => left.localeCompare(right))
+}
+
+export function readAndroidAutolinkingFooter(source: string): string[] | null {
+  const value = readBundleGlobalFooter(source, FOOTER)
+  return value === null ? null : readAndroidAutolinkedPackages(value)
+}
+
+export function insertAndroidAutolinkingFooter(
+  source: string,
+  packages: readonly string[],
+): string {
+  return insertBundleGlobalFooter(source, FOOTER, readAndroidAutolinkedPackages(packages))
+}
+
+export function detachAndroidAutolinkingFooter(source: string): {
+  source: string
+  packages: string[] | null
+} {
+  const detached = detachBundleGlobalFooter(source, FOOTER)
+  return {
+    source: detached.source,
+    packages:
+      detached.value === null ? null : readAndroidAutolinkedPackages(detached.value),
+  }
+}

package/src/bundleGlobalFooter.ts

@@ -14,18 +14,37 @@ export function findBundleFooter(source: string, prefix: string): number {
     if (newline < 0) return -1
     const line = newline + 1
     if (source.startsWith(prefix, line)) return newline
-    if (
-      line !== end &&
-      !source.startsWith('globalThis.', line) &&
-      !source.startsWith('//', line)
-    ) {
-      return -1
-    }
+    if (!isFooterBlockLine(source, line, end)) return -1
     end = newline
   }
   return -1
 }
 
+function isFooterBlockLine(source: string, line: number, end: number): boolean {
+  return (
+    line === end ||
+    source.startsWith('globalThis.', line) ||
+    source.startsWith('//', line)
+  )
+}
+
+// the whole trailing block the readers above walk, split from the code before
+// it. a rewrite of the code (minification) must leave the block as written:
+// a minifier reprints each footer's JSON as an object literal and moves legal
+// comments after it, so no reader would find the footer again.
+export function splitBundleFooterBlock(source: string): {
+  code: string
+  footers: string
+} {
+  let end = source.length
+  while (end > 0) {
+    const newline = source.lastIndexOf('\n', end - 1)
+    if (newline < 0 || !isFooterBlockLine(source, newline + 1, end)) break
+    end = newline
+  }
+  return { code: source.slice(0, end), footers: source.slice(end) }
+}
+
 function readFooter(
   source: string,
   prefix: string,

package/src/codex-client.ts

@@ -9,6 +9,7 @@
 
 import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process'
 import readline from 'node:readline'
+import { terminateProcessGroup } from './process-group'
 
 export interface CodexClientOptions {
   /** resolved path to the codex binary (via `which codex` or user override). */
@@ -211,10 +212,10 @@ export function spawnCodexClient(options: CodexClientOptions): CodexClient {
       try {
         child.stdin.end()
       } catch {}
-      const t = setTimeout(() => {
+      const t = setTimeout(async () => {
         if (!closed) {
           try {
-            child.kill('SIGTERM')
+            await terminateProcessGroup(child, 'SIGTERM')
           } catch {}
         }
       }, timeoutMs)

package/src/dev-bundle-resolution.ts

@@ -159,11 +159,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 +177,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)
   } 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 +329,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-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 }