peachsim 0.1.1641 → 0.1.1653

package/src/swift-root-lock.ts

@@ -1,67 +1,120 @@
-import { execFileSync } from 'node:child_process'
+import {
+  spawn,
+  spawnSync,
+  type ChildProcess,
+  type ChildProcessByStdio,
+  type SpawnOptions,
+} from 'node:child_process'
 import { createHash, randomUUID } from 'node:crypto'
 import {
   linkSync,
   mkdirSync,
+  readdirSync,
   readFileSync,
-  renameSync,
   rmSync,
   writeFileSync,
 } from 'node:fs'
 import path from 'node:path'
 import { rnxHomeDir } from './home-paths'
+import { terminateProcessGroup } from './process-group'
+import type { Readable, Writable } from 'node:stream'
 
 const POLL_MS = 250
+// ps derives a start time from the boot time, which drifts by a second or two
+// on linux; a reused pid starts later than this.
+const START_TOLERANCE_MS = 2_000
 
-interface Holder {
+interface ProcessRow {
   pid: number
-  start: string | null
+  pgid: number
+  zombie: boolean
+  start: number
 }
 
-// a pid alone is reused; the start time names the process that wrote the lock.
-function processStart(pid: number): string | null {
-  try {
-    return (
-      execFileSync('ps', ['-o', 'lstart=', '-p', String(pid)], {
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'ignore'],
-      }).trim() || null
+interface Identity {
+  pid: number
+  start: number
+}
+
+interface Generation {
+  number: number
+  holder: Identity
+  released: boolean
+}
+
+function errorCode(error: unknown): string | undefined {
+  return error instanceof Error && 'code' in error && typeof error.code === 'string'
+    ? error.code
+    : undefined
+}
+
+// ps prints start times without a zone, so every reader asks for utc: a
+// holder and a waiter then agree whatever their own time zones are.
+function parseStart(text: string): number {
+  const start = Date.parse(`${text} UTC`)
+  if (Number.isNaN(start)) throw new Error(`unreadable process start time "${text}"`)
+  return start
+}
+
+// the whole table in one read. an unreadable table throws: a lock that cannot
+// tell whether its holder is gone must not guess.
+function processTable(): ProcessRow[] {
+  const result = spawnSync('ps', ['-A', '-o', 'pid=,pgid=,stat=,lstart='], {
+    encoding: 'utf8',
+    env: { ...process.env, LC_ALL: 'C', TZ: 'UTC' },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 10_000,
+    killSignal: 'SIGKILL',
+  })
+  if (result.error || result.status !== 0) {
+    throw new Error(
+      `swift root lock cannot read the process table: ${
+        result.error?.message || result.stderr.trim() || `ps exited ${result.status}`
+      }`,
     )
-  } catch {
-    return null
   }
+  return result.stdout
+    .split('\n')
+    .filter((line) => line.trim())
+    .map((line) => {
+      const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+?)\s*$/.exec(line)
+      if (!match)
+        throw new Error(`swift root lock cannot parse a process table row: ${line}`)
+      return {
+        pid: Number(match[1]),
+        pgid: Number(match[2]),
+        zombie: match[3]!.startsWith('Z'),
+        start: parseStart(match[4]!),
+      }
+    })
 }
 
-function parseHolder(text: string): Holder | null {
-  try {
-    const value: unknown = JSON.parse(text)
-    if (
-      value &&
-      typeof value === 'object' &&
-      'pid' in value &&
-      typeof value.pid === 'number' &&
-      'start' in value &&
-      (typeof value.start === 'string' || value.start === null)
-    )
-      return { pid: value.pid, start: value.start }
-  } catch {}
-  return null
+function sameProcess(row: ProcessRow, identity: Identity): boolean {
+  return (
+    row.pid === identity.pid && Math.abs(row.start - identity.start) <= START_TOLERANCE_MS
+  )
 }
 
-function readLock(lock: string): string | null {
-  try {
-    return readFileSync(lock, 'utf8')
-  } catch (error) {
-    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return null
-    throw error
-  }
+function ownIdentity(pid: number): Identity {
+  const row = processTable().find(
+    (candidate) => candidate.pid === pid && !candidate.zombie,
+  )
+  if (!row) throw new Error(`swift root lock cannot find process ${pid}`)
+  return { pid, start: row.start }
 }
 
-function holderAlive(text: string): boolean {
-  const holder = parseHolder(text)
-  if (!holder) return false
-  const start = processStart(holder.pid)
-  return start !== null && start === holder.start
+function parseIdentity(text: string): Identity {
+  const value: unknown = JSON.parse(text)
+  if (
+    value &&
+    typeof value === 'object' &&
+    'pid' in value &&
+    typeof value.pid === 'number' &&
+    'start' in value &&
+    typeof value.start === 'number'
+  )
+    return { pid: value.pid, start: value.start }
+  throw new Error(`swift root lock record is not a process identity: ${text}`)
 }
 
 function pause(ms: number, signal?: AbortSignal): Promise<void> {
@@ -76,78 +129,174 @@ function pause(ms: number, signal?: AbortSignal): Promise<void> {
   })
 }
 
+const name = (number: number, suffix: string) =>
+  `${String(number).padStart(12, '0')}.${suffix}`
+
+function generationNumbers(directory: string): number[] {
+  const numbers = new Set<number>()
+  for (const entry of readdirSync(directory)) {
+    const match = /^(\d{12})\./.exec(entry)
+    if (match) numbers.add(Number(match[1]))
+  }
+  return [...numbers].sort((a, b) => a - b)
+}
+
+function readGeneration(directory: string, number: number): Generation | null {
+  let owner: string
+  try {
+    owner = readFileSync(path.join(directory, name(number, 'owner')), 'utf8')
+  } catch (error) {
+    // a newer holder cleaned this generation after it was listed.
+    if (errorCode(error) === 'ENOENT') return null
+    throw error
+  }
+  return {
+    number,
+    holder: parseIdentity(owner),
+    released: readdirSync(directory).includes(name(number, 'released')),
+  }
+}
+
+// children are registered before they run and only while the holder lives, so
+// reading them after the holder is seen dead lists every one it started.
+function readChildren(directory: string, number: number): Identity[] {
+  const prefix = name(number, 'child.')
+  return readdirSync(directory)
+    .filter((entry) => entry.startsWith(prefix))
+    .map((entry) => parseIdentity(readFileSync(path.join(directory, entry), 'utf8')))
+}
+
+// a child leads its own session, so its group is its pid; a group id stays
+// taken while any member lives, so a leader started later is another process.
+function groupAlive(table: ProcessRow[], leader: Identity): boolean {
+  const row = table.find((candidate) => candidate.pid === leader.pid)
+  if (row && !sameProcess(row, leader)) return false
+  return table.some((candidate) => candidate.pgid === leader.pid && !candidate.zombie)
+}
+
+/** compiler processes whose lifetime the root lock covers. */
+export interface SwiftRootLease {
+  /** starts `command` in its own process group, recorded under the lock before
+   *  it runs, so the root stays held while that group lives even if this
+   *  process dies. */
+  spawn(
+    command: string,
+    args: string[],
+    options: SpawnOptions,
+  ): ChildProcessByStdio<Writable, Readable, Readable>
+}
+
 /** runs `work` as the only process using a swift build root. the in-process
  *  queue orders one process's requests; two processes sharing a root each
  *  rewrite its sources and manifest, and swiftpm's own build lock only orders
  *  the builds, so a build can compile the other process's sources and then
- *  read back that process's executable. the lock lives beside the root's
- *  tree, never inside it: a write sweeps every file of the tree it does not
- *  name. a lock whose owner process is gone is taken over. */
+ *  read back that process's executable.
+ *
+ *  holders are numbered. the newest generation holds the root; claiming the
+ *  next number is one exclusive link, so exactly one claimant wins and no
+ *  record is ever moved or replaced. a generation is free once its holder
+ *  released it, or once its holder process and every compiler group it
+ *  recorded are gone. an unreadable process table or an unkillable compiler
+ *  keeps the root held. the lock lives beside the root's tree, never inside
+ *  it: a write sweeps every file of the tree it does not name. */
 export async function withSwiftRootLock<T>(
   root: string,
-  work: () => Promise<T>,
+  work: (lease: SwiftRootLease) => Promise<T>,
   signal?: AbortSignal,
 ): Promise<T> {
-  const directory = path.join(rnxHomeDir(), 'cache', 'swift-root-locks')
-  mkdirSync(directory, { recursive: true })
-  const lock = path.join(
-    directory,
-    `${createHash('sha256').update(root).digest('hex').slice(0, 32)}.lock`,
+  const directory = path.join(
+    rnxHomeDir(),
+    'cache',
+    'swift-root-locks',
+    createHash('sha256').update(root).digest('hex').slice(0, 32),
   )
+  mkdirSync(directory, { recursive: true })
   const token = randomUUID()
-  const owner = JSON.stringify({
-    pid: process.pid,
-    start: processStart(process.pid),
-    token,
-  })
-  const pending = `${lock}.${token}`
-  // the owner record is complete before the lock path exists, so a waiter
-  // never reads a half-written lock.
-  writeFileSync(pending, owner)
-  try {
-    for (;;) {
-      signal?.throwIfAborted()
-      try {
-        linkSync(pending, lock)
-        break
-      } catch (error) {
-        if (!(error instanceof Error && 'code' in error && error.code === 'EEXIST'))
-          throw error
+  const owner = JSON.stringify(ownIdentity(process.pid))
+  const pending = path.join(directory, `pending.${token}`)
+  let held = 0
+  for (;;) {
+    signal?.throwIfAborted()
+    const newest = generationNumbers(directory).at(-1) ?? 0
+    const current = newest > 0 ? readGeneration(directory, newest) : null
+    if (newest > 0 && !current) continue
+    if (current && !current.released) {
+      const table = processTable()
+      if (table.some((row) => !row.zombie && sameProcess(row, current.holder))) {
+        await pause(POLL_MS, signal)
+        continue
       }
-      const held = readLock(lock)
-      if (held === null) continue
-      if (holderAlive(held)) {
+      const children = readChildren(directory, newest)
+      if (children.some((child) => groupAlive(table, child))) {
         await pause(POLL_MS, signal)
         continue
       }
-      // take over by moving the dead record aside. a different record in the
-      // moved file means a new owner landed first; put it back.
-      const dead = `${lock}.dead-${token}`
+    }
+    // the record is complete before it takes the number, so a waiter never
+    // reads half a record.
+    writeFileSync(pending, owner)
+    try {
+      linkSync(pending, path.join(directory, name(newest + 1, 'owner')))
+    } catch (error) {
+      if (errorCode(error) === 'EEXIST') continue
+      throw error
+    } finally {
+      rmSync(pending, { force: true })
+    }
+    // a claimant that listed the directory before older generations were
+    // cleaned can take a number below the newest; it never held the root.
+    const numbers = generationNumbers(directory)
+    if (numbers.at(-1) !== newest + 1) {
+      rmSync(path.join(directory, name(newest + 1, 'owner')), { force: true })
+      continue
+    }
+    held = newest + 1
+    for (const number of numbers)
+      if (number < held)
+        for (const entry of readdirSync(directory))
+          if (entry.startsWith(name(number, '')))
+            rmSync(path.join(directory, entry), { force: true })
+    break
+  }
+  const children: ChildProcess[] = []
+  const lease: SwiftRootLease = {
+    spawn(command, args, options) {
+      // the child waits for its registration before it runs, and exits without
+      // running if this process dies first.
+      const child = spawn(
+        '/bin/sh',
+        ['-c', 'IFS= read -r go || exit 1; exec "$@" </dev/null', 'sh', command, ...args],
+        { ...options, detached: true, stdio: ['pipe', 'pipe', 'pipe'] },
+      )
+      child.stdin!.on('error', () => {})
+      children.push(child)
       try {
-        renameSync(lock, dead)
+        if (child.pid === undefined) {
+          child.once('error', () => {})
+          throw new Error(`could not start ${command}`)
+        }
+        const childPending = `${pending}.child.${child.pid}`
+        try {
+          // publish a complete identity before opening the compiler gate. a
+          // crash or failed write leaves only an ignored pending file.
+          writeFileSync(childPending, JSON.stringify(ownIdentity(child.pid)))
+          linkSync(childPending, path.join(directory, name(held, `child.${child.pid}`)))
+        } finally {
+          rmSync(childPending, { force: true })
+        }
       } catch (error) {
-        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') continue
+        child.stdin!.destroy()
         throw error
       }
-      try {
-        if (readLock(dead) !== held) {
-          try {
-            linkSync(dead, lock)
-          } catch (error) {
-            if (!(error instanceof Error && 'code' in error && error.code === 'EEXIST'))
-              throw error
-          }
-        }
-      } finally {
-        rmSync(dead, { force: true })
-      }
-    }
-  } finally {
-    rmSync(pending, { force: true })
+      child.stdin!.end('go\n')
+      return child
+    },
   }
   try {
-    return await work()
+    return await work(lease)
   } finally {
-    if (readLock(lock) === owner) rmSync(lock, { force: true })
+    // a compiler that outlives its caller would still read the root.
+    await Promise.all(children.map((child) => terminateProcessGroup(child, 'SIGKILL', 0)))
+    writeFileSync(path.join(directory, name(held, 'released')), '')
   }
 }

package/src/swift-submit.ts

@@ -25,6 +25,8 @@ import {
   isSwiftMetalLibrarySources,
   type SwiftMetalLibrarySource,
   type SwiftResourceBundle,
+  type SwiftNativeTarget,
+  type SwiftObjCPeerStartup,
 } from './swiftContract'
 
 export const SWIFT_COMPILE_PATH = '/api/swift-compile'
@@ -234,6 +236,8 @@ export interface SwiftCompileContext {
 
 export type SwiftCompileSubmit = (work: {
   files: Record<string, string>
+  nativeTargets?: SwiftNativeTarget[]
+  objcPeerStartup?: SwiftObjCPeerStartup
   metalSources?: Record<string, string>
   /** the bundle pack; absent means the project packs none. */
   resources?: Record<string, string>
@@ -399,6 +403,8 @@ export async function compileSwiftProject(
   submit: SwiftCompileSubmit,
   work: {
     files: Record<string, string>
+    nativeTargets?: SwiftNativeTarget[]
+    objcPeerStartup?: SwiftObjCPeerStartup
     metalSources?: Record<string, string>
     resources?: Record<string, string>
     /** project-relative resource paths used to associate implicit resources with targets. */

package/src/swiftContract.ts

@@ -22,6 +22,105 @@ export interface SwiftObjCPeerClass {
   header: string
 }
 
+/** generated registration source whose call must precede the application entry. */
+export interface SwiftObjCPeerStartup {
+  registration: string
+}
+
+export function isSwiftObjCPeerStartup(value: unknown): value is SwiftObjCPeerStartup {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    'registration' in value &&
+    isSwiftResourcePath(value.registration) &&
+    value.registration.endsWith('.swift') &&
+    Object.keys(value).length === 1
+  )
+}
+
+export const SWIFT_NATIVE_INPUT_ROOT = '$(PEACH_INPUT_ROOT)'
+export const SWIFT_NATIVE_SDK_INCLUDE = '$(PEACH_SDK_INCLUDE)'
+
+export interface SwiftObjCImplementationPlan {
+  owner: string
+  registeredClasses: string[]
+  units: string[]
+}
+
+export interface SwiftProjectPreparation {
+  headerProducers: string[]
+  objcImplementations?: SwiftObjCImplementationPlan
+}
+
+/** project-relative original clang inputs; no host paths cross the compile boundary. */
+export interface SwiftNativeTarget {
+  name: string
+  deploymentTarget: string | null
+  headers: string[]
+  publicHeaders: string[]
+  bridgingHeader: string | null
+  prefixHeader: string | null
+  headerSearchPaths: string[]
+  frameworkSearchPaths: string[]
+  flags: string[]
+  cxxFlags: string[]
+  fileFlags: Record<string, string[]>
+  sourceDirectories: Record<string, string>
+}
+
+export function isSwiftNativeTargets(value: unknown): value is SwiftNativeTarget[] {
+  const strings = (value: unknown): value is string[] =>
+    Array.isArray(value) &&
+    value.every((item: unknown) => typeof item === 'string' && !item.includes('\0'))
+  const paths = (value: unknown): value is string[] =>
+    strings(value) && value.every(isSwiftResourcePath)
+  return (
+    Array.isArray(value) &&
+    value.length <= 128 &&
+    value.every((target: unknown) => {
+      if (!target || typeof target !== 'object') return false
+      const field = (name: string): unknown => Reflect.get(target, name)
+      const nullablePath = (name: string) =>
+        field(name) === null || isSwiftResourcePath(field(name))
+      const perFile = field('fileFlags')
+      const directories = field('sourceDirectories')
+      const searches = field('headerSearchPaths')
+      const frameworks = field('frameworkSearchPaths')
+      const deployment = field('deploymentTarget')
+      return (
+        typeof field('name') === 'string' &&
+        /^[A-Za-z_]\w*$/.test(String(field('name'))) &&
+        (deployment === null ||
+          (typeof deployment === 'string' && /^\d+(?:\.\d+){0,2}$/.test(deployment))) &&
+        paths(field('headers')) &&
+        paths(field('publicHeaders')) &&
+        nullablePath('bridgingHeader') &&
+        nullablePath('prefixHeader') &&
+        strings(searches) &&
+        searches.every((item) => item === '.' || isSwiftResourcePath(item)) &&
+        strings(frameworks) &&
+        frameworks.every((item) => item === '.' || isSwiftResourcePath(item)) &&
+        strings(field('flags')) &&
+        strings(field('cxxFlags')) &&
+        !!perFile &&
+        typeof perFile === 'object' &&
+        !Array.isArray(perFile) &&
+        Object.entries(perFile).every(
+          ([file, flags]) => isSwiftResourcePath(file) && strings(flags),
+        ) &&
+        !!directories &&
+        typeof directories === 'object' &&
+        !Array.isArray(directories) &&
+        Object.entries(directories).every(
+          ([file, directory]) =>
+            isSwiftResourcePath(file) &&
+            (directory === '.' || isSwiftResourcePath(directory)),
+        )
+      )
+    })
+  )
+}
+
 export interface SwiftObjCImplementationPreparation {
   receipt: string
   objects: { target: string; source: string; file: string }[]

package/src/target-matcher.ts

@@ -43,7 +43,12 @@ export function filterTargetNodes<
     )
       return false
     if (!regex) return matcher.type !== 'text' || node.text === matcher.value
-    const matches = (value: unknown) => typeof value === 'string' && regex.test(value)
+    // detox iOS compares its first regex match's range with the entire value.
+    const matches = (value: unknown) => {
+      if (typeof value !== 'string') return false
+      const match = regex.exec(value)
+      return match !== null && match.index === 0 && match[0].length === value.length
+    }
     if (matcher.type === 'id') return matches(node.testID) || matches(node.id)
     if (matcher.type === 'text') return matches(node.text)
     return matches(node.accessibilityLabel || (node.accessible ? node.text : null))

package/src/vite-plugin.ts

@@ -1,3 +1,4 @@
+import crypto from 'crypto'
 // peach vite plugin — use in any vite project to get react-native resolution,
 // native dep stubbing, and external app support.
 //
@@ -7,8 +8,6 @@
 //
 //   // with external app:
 //   export default defineConfig({ plugins: [sootsim({ app: '~/my-rn-app' })] })
-
-import crypto from 'crypto'
 import fs from 'fs'
 import { createRequire } from 'module'
 import { runInNewContext, Script } from 'node:vm'
@@ -19,6 +18,12 @@ import { minifySync, transformSync } from 'rolldown/utils'
 import { type Plugin, transformWithOxc } from 'vite'
 import { resolveOneNativeBackend } from '../../contrast-bundler/src/oneFramework.ts'
 import { transformFlowSource } from '../../peach-compat/src/flow-strip.ts'
+import { getCliRuntime } from './cli-runtime.ts'
+import {
+  isEngineReactImporter,
+  isWorkerReactBridgeImporter,
+  keepsRealReact,
+} from './react-bridge-importers.ts'
 import { renderWorkerSystemChunk } from './worker-system-chunks.ts'
 
 declare module '@babel/core' {
@@ -41,12 +46,6 @@ import {
   compatStubsForBuildResolver,
   reactNativeDeepStubsForBuildResolver,
 } from '../../peach-compat/src/stub-manifest.ts'
-import { WEBVIEW_SAME_ORIGIN_BOOTSTRAP_SOURCE } from '../../peach-engine/src/components/native-ui/webview-frame-bridge.ts'
-import {
-  isExpoHostSocketModule,
-  isReactNativeEnvironmentSetupModule,
-} from '../../peach-engine/src/guest-module-overrides.ts'
-import { readPeachWarmManifest } from '../../peach-engine/src/peach-warm-manifest.ts'
 import {
   assertPeachPortEnvironment,
   resolveSootsimBridgePort,
@@ -420,9 +419,9 @@ export function sootsim(options: SootSimOptions = {}): Plugin[] {
 function hostEnvironmentBootstrapRedirect(): Plugin {
   const target = '\0peach:host-environment-bootstrap'
   const isHostBootstrap = (id: string) =>
-    isExpoHostSocketModule(id) ||
+    getCliRuntime().guest_module_overrides.isExpoHostSocketModule(id) ||
     ((id.startsWith('react-native/') || id.includes('/react-native/')) &&
-      isReactNativeEnvironmentSetupModule(id))
+      getCliRuntime().guest_module_overrides.isReactNativeEnvironmentSetupModule(id))
   return {
     name: 'peach-host-environment-bootstrap',
     enforce: 'pre',
@@ -546,7 +545,7 @@ function warmManifestJsonPlugin(): Plugin {
       const filename = id.slice(marker.length, -3)
       this.addWatchFile(filename)
       const value: unknown = JSON.parse(fs.readFileSync(filename, 'utf8'))
-      const manifest = readPeachWarmManifest(value)
+      const manifest = getCliRuntime().peach_warm_manifest.readPeachWarmManifest(value)
       const entries = [
         manifest.home,
         ...Object.values(manifest.launches),
@@ -1805,21 +1804,11 @@ function reactBridgePlugin(): Plugin {
         if ((options as { scan?: boolean })?.scan || options?.ssr) return null
 
         // only redirect imports from peachsim, peach-engine, peach-compat, and react-reconciler
-        const shouldRedirect =
-          importer.includes('/peachsim/src/') ||
-          importer.includes('/peach-engine/src/') ||
-          importer.includes('/peach-compat/src/') ||
-          importer.includes('/peach-compat/dist-pressability/') ||
-          importer.includes('/peach-kit/src/') ||
-          importer.includes('react-reconciler')
+        const shouldRedirect = isEngineReactImporter(importer)
 
         if (!shouldRedirect) return null
 
-        // don't redirect react-bridge's own import of react (avoid infinite loop)
-        if (importer.includes('react-bridge')) return null
-
-        // stub-registry needs the real React (with __CLIENT_INTERNALS) for bundle stubs
-        if (importer.includes('stub-registry')) return null
+        if (keepsRealReact(importer)) return null
 
         redirectCount++
         if (redirectCount <= 10) {
@@ -1851,28 +1840,13 @@ export function workerReactBridgePlugin(): Plugin {
         // skip during dep scanning / SSR
         if ((options as { scan?: boolean })?.scan || options?.ssr) return null
 
-        // don't redirect react-bridge's own import of react (avoid infinite loop)
-        if (importer.includes('react-bridge')) return null
-
-        // stub-registry needs the real React (with __CLIENT_INTERNALS) for bundle stubs
-        if (importer.includes('stub-registry')) return null
-
         // redirect react imports from peachsim, peach-engine, peach-compat, react-reconciler,
         // and any pure-JS RN-ecosystem package the bundle pulls in. without this
         // redirect, packages like react-native-drawer-layout / use-latest-callback
         // call into a separate React instance than the renderer/bridge does, so
         // their useRef/useEffect refs collide with the engine's hooks state and
         // we hit "Maximum update depth exceeded" infinite-loop renders.
-        const shouldRedirect =
-          importer.includes('/peachsim/src/') ||
-          importer.includes('/peach-engine/src/') ||
-          importer.includes('/peach-compat/src/') ||
-          importer.includes('/peach-compat/dist-pressability/') ||
-          importer.includes('/peach-kit/src/') ||
-          importer.includes('react-reconciler') ||
-          importer.includes('/node_modules/')
-
-        if (!shouldRedirect) return null
+        if (!isWorkerReactBridgeImporter(importer)) return null
 
         return { id: reactBridgePath, external: false }
       },
@@ -2719,7 +2693,7 @@ export function expoDomComponentsPlugin(
       window.process.env = window.process.env || {};
       window.process.env.NODE_ENV = window.process.env.NODE_ENV || 'development';
       window.process.env.EXPO_OS = 'web';
-      ${WEBVIEW_SAME_ORIGIN_BOOTSTRAP_SOURCE}
+      ${getCliRuntime().components_native_ui_webview_frame_bridge.WEBVIEW_SAME_ORIGIN_BOOTSTRAP_SOURCE}
       (function () {
         // metro-style require shim for expo's dom closure: classic scripts
         // run before module imports evaluate, so this covers eval-time

package/src/worker-system-chunks.ts

@@ -1,8 +1,8 @@
 import fs from 'node:fs'
 import { createRequire } from 'node:module'
 import { Worker } from 'node:worker_threads'
-import { PAGE_DELIVERED_CHUNKS_NAME_SUFFIX } from '../../peach-engine/src/render-worker/boot-worker-kickoff.ts'
 import { isRecord } from './is-record'
+import { PAGE_DELIVERED_CHUNKS_NAME_SUFFIX } from './workerChunkContract.ts'
 
 const require = createRequire(import.meta.url)
 const systemRuntime = fs.readFileSync(require.resolve('systemjs/dist/s.min.js'), 'utf8')

package/src/workerChunkContract.ts

@@ -0,0 +1,5 @@
+// the kickoff ends the name of each worker it starts with this suffix. that
+// worker's loader then links each Home chunk from the body the kickoff posts
+// (`peach-chunk-list`, then one `peach-chunk-body` per url) instead of
+// downloading it again (worker-system-chunks.ts).
+export const PAGE_DELIVERED_CHUNKS_NAME_SUFFIX = ':page-chunks'