peachsim 0.1.939 → 0.1.1399

package/src/vite-plugin.ts

@@ -14,8 +14,10 @@ import { createRequire } from 'module'
 import { runInNewContext, Script } from 'node:vm'
 import path from 'path'
 import { fileURLToPath, pathToFileURL } from 'url'
-import { minify } from 'terser'
+import { parseSync } from 'oxc-parser'
+import { minifySync, transformSync } from 'rolldown/utils'
 import { type Plugin, transformWithOxc } from 'vite'
+import { renderWorkerSystemChunk } from './worker-system-chunks.ts'
 
 declare module '@babel/core' {
   interface TransformCaller {
@@ -34,7 +36,10 @@ import {
   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 } from '../../peach-engine/src/guest-module-overrides.ts'
+import {
+  isExpoHostSocketModule,
+  isReactNativeEnvironmentSetupModule,
+} from '../../peach-engine/src/guest-module-overrides.ts'
 import { readPeachWarmManifest } from '../../peach-engine/src/peach-warm-manifest.ts'
 import { resolveSootsimBridgePort } from './bridge-constants.ts'
 import { isRecord } from './is-record.ts'
@@ -91,6 +96,10 @@ const sootsimBrowserSourceAliases = [
     find: 'peachsim/bridge-constants',
     replacement: path.resolve(sootsimRoot, 'src/bridge-constants.ts'),
   },
+  {
+    find: 'peachsim/config',
+    replacement: path.resolve(sootsimRoot, 'src/config.ts'),
+  },
   {
     find: 'peachsim/dev-bundle-resolution',
     replacement: path.resolve(sootsimRoot, 'src/dev-bundle-resolution.ts'),
@@ -136,6 +145,19 @@ const rnLibraryStubs = Object.fromEntries(
   ]),
 )
 
+function resolveReactNativeLibraryStub(source: string, importer?: string) {
+  const candidate =
+    source.startsWith('.') && importer
+      ? path.resolve(path.dirname(stripViteQuery(importer)), stripViteQuery(source))
+      : stripViteQuery(source)
+  const match = /(?:^|\/)(react-native\/Libraries\/.+)$/.exec(candidate)
+  if (!match) return undefined
+  const specifier = match[1]
+    .replace(/\.(?:[cm]?[jt]sx?)$/, '')
+    .replace(/\.(?:native|web|ios|android)$/, '')
+  return rnLibraryStubs[specifier]
+}
+
 type PublishedBrowserPackage = {
   specifier: string
   packageDir: string
@@ -356,7 +378,7 @@ export function sootsim(options: SootSimOptions = {}): Plugin[] {
       },
     },
     sootsimConfigPlugin(appDir, extraSources, publishedBrowserPackages),
-    expoHostSocketBootstrapRedirect(),
+    hostEnvironmentBootstrapRedirect(),
     fixJsxRuntimeExports(),
     flowStripTransform(),
     nodeModulesJsxTransform(),
@@ -375,31 +397,56 @@ export function sootsim(options: SootSimOptions = {}): Plugin[] {
     metroNativeResolve(isAppSource),
     reactNativeRequirePlugin(isAppSource),
     ...(appDir ? [externalAppResolvePlugin(appDir, isAppSource, ownedPackages)] : []),
-    ...(appDir || extraSources.length > 0
-      ? [externalAppTransformPlugin(isAppSource)]
-      : []),
+    externalAppTransformPlugin(isAppSource),
     stubMissingNativeDeps(appDir),
     stubMissingImages(isAppSource),
   ]
 }
 
-function expoHostSocketBootstrapRedirect(): Plugin {
-  const target = '\0sootsim:expo-host-socket-bootstrap'
+function hostEnvironmentBootstrapRedirect(): Plugin {
+  const target = '\0peach:host-environment-bootstrap'
+  const isHostBootstrap = (id: string) =>
+    isExpoHostSocketModule(id) ||
+    ((id.startsWith('react-native/') || id.includes('/react-native/')) &&
+      isReactNativeEnvironmentSetupModule(id))
   return {
-    name: 'sootsim-expo-host-socket-bootstrap',
+    name: 'peach-host-environment-bootstrap',
     enforce: 'pre',
     resolveId(source, importer) {
-      if (isExpoHostSocketModule(stripViteQuery(source))) return target
+      if (source === target || isHostBootstrap(stripViteQuery(source))) return target
       if (!importer || !source.startsWith('.')) return null
       const candidate = path.resolve(
         path.dirname(stripViteQuery(importer)),
         stripViteQuery(source),
       )
-      return isExpoHostSocketModule(candidate) ? target : null
+      return isHostBootstrap(candidate) ? target : null
     },
     load(id) {
       if (id !== target) return null
-      return 'export default function noopExpoHostSocketBootstrap() {}'
+      return 'export default function noopHostEnvironmentBootstrap() {}'
+    },
+    transform: {
+      filter: { id: /\/node_modules\//, code: /require\(/ },
+      handler(code, id) {
+        let changed = false
+        const rewritten = code.replace(
+          /\brequire\((['"])([^'"]+)\1\)/g,
+          (call, _quote, source: string) => {
+            const candidate = source.startsWith('.')
+              ? path.resolve(path.dirname(stripViteQuery(id)), source)
+              : source
+            if (!isHostBootstrap(candidate)) return call
+            changed = true
+            return '__peach_host_bootstrap__'
+          },
+        )
+        return changed
+          ? {
+              code: `import * as __peach_host_bootstrap__ from ${JSON.stringify(target)};\n${rewritten}`,
+              map: null,
+            }
+          : null
+      },
     },
   }
 }
@@ -575,24 +622,20 @@ function warmManifestJsonPlugin(): Plugin {
   }
 }
 
-// a worker cannot modulepreload, so every static level under its
-// implementation root and every dynamic import on its boot path is a serial
-// round trip before the worker is ready. this plugin bundles each declared
-// worker into one file and fails the build when that file grows past its byte
-// cap, so a worker feature cannot silently add startup bytes.
-//
-// the entries stay export-free and import-free so webkit keeps the one-way
-// dynamic boundary (see shell-worker-entry.ts); with every chunk inlined no
-// other file can import the worker script, so nothing can evaluate it twice.
-// inlined dynamic roots still evaluate at their `import()` (the reanimated
-// passthrough must install before upstream reanimated, the worklet runtime
-// must exist before shell-in-worker): with code splitting off rolldown wraps
-// every dynamic-import target in an init function that runs on first import.
-// shell-worker.ts throws at init if a bundle ever hoists one of them.
+// workers load feature chunks on demand through one script-compatible module
+// protocol. the entry owns its loader and remains a one-way bootstrap so lazy
+// chunks never re-evaluate a worker's message listeners. the boot byte cap
+// applies to that entry; cold Home proof also measures the downloaded startup
+// graph and serial requests, since moving bytes into chunks alone is no gain.
+// reanimated and shell-in-worker still evaluate at their original import()
+// boundaries after the worklet runtime installs.
 export type WorkerBootClosure = {
   // substring of the worker entry module id this applies to
   entry: string
-  // byte cap on the rendered worker file; fix excess boot dependencies and
+  // implementation roots loaded before Home; only their static dependencies
+  // share a chunk. other dynamic roots retain their first-use boundaries.
+  bootRoots?: readonly string[]
+  // byte cap on the rendered entry chunk; fix excess boot dependencies and
   // unneeded inclusions rather than raising the cap.
   // a cap failure in a worktree whose node_modules is symlinked from another
   // tree is suspect: workspace modules resolve into the other tree and bundle
@@ -600,31 +643,57 @@ export type WorkerBootClosure = {
   maxBytes: number
 }
 
+const SHELL_WORKER_BOOT_ROOTS = [
+  'src/render-worker/shell-worker-canvaskit.ts',
+  'src/render-worker/shell-worker.ts',
+  'src/render-worker/shell-reanimated-boot.ts',
+  'src/render-worker/shell-in-worker.tsx',
+  'src/render-worker/aux-roots.tsx',
+  'src/ios/HomeTreeRoot.tsx',
+  'src/ios/connect-app-icon.ts',
+]
+const COMPOSITOR_WORKER_BOOT_ROOTS = [
+  'src/render-worker/compositor-worker-adapter.ts',
+  'src/render-worker/compositor-worker.ts',
+  'src/render-worker/shell-tree-materializer.ts',
+]
+const GRAPHITE_WORKER_BOOT_ROOTS = [
+  'src/render-worker/canvaskit-webgpu.ts',
+  'src/render-worker/compositor-gpu-graphite.ts',
+  'vendor/canvaskit-graphite.js',
+]
+
 const ENGINE_WORKER_BOOT_CLOSURES: WorkerBootClosure[] = [
-  // these workers inline their dynamic imports, so anything reachable from the
-  // entry lands in the boot file whether or not it runs. that is why the font
-  // parser is not reachable from any of them: only the tenant reads a face's
-  // name table, and it sends the aliases and metrics it read on the wire
+  // only the tenant reads a face's name table, and it sends the aliases and
+  // metrics it read on the wire
   // (engine/app-font-registry.ts registerForwardedAppFonts). keep it that way
   // when adding font work here, or every cap takes the parser again.
-  // measured 3,406,869 bytes after the shell engine config split: the shell
-  // worker installs a slim config without the list, modal, slider, swipeable,
-  // and tab components nothing shell-side reads (compat-bridge composes the
-  // full config for main, tenant, headless, and external realms on top of
-  // it), and the gesture-handler stub imports TouchableNativeFeedback
-  // statically instead of require()ing the whole react-native namespace into
-  // the boot file. the shell worker is one file per compositor backend, so
-  // each carries only its own CanvasKit glue: 3,263,311 graphite and
-  // 3,256,832 ganesh bytes when the split landed, down from 3,386,929 with both.
-  { entry: 'src/render-worker/shell-worker-entry.ts', maxBytes: 3_310_000 },
+  // each entry selects one backend; its chunks retain only that backend's
+  // CanvasKit glue. feature imports keep their evaluation boundaries.
+  {
+    entry: 'src/render-worker/shell-worker-entry.ts',
+    maxBytes: 3_310_000,
+    bootRoots: [...SHELL_WORKER_BOOT_ROOTS, ...GRAPHITE_WORKER_BOOT_ROOTS],
+  },
   // nate, 2026-10-06: "we can increase Ganesh. We can increase that to like 3.6",
   // as work moves from the javascript into native code.
-  { entry: 'src/render-worker/shell-worker-ganesh-entry.ts', maxBytes: 3_600_000 },
-  { entry: 'src/render-worker/compositor-worker-entry.ts', maxBytes: 1_200_000 },
-  // both compositor entries boot the one compositor-worker.ts and differ only
-  // in their backend and CanvasKit glue (plans/peach/compositor-one-path.md):
-  // 1,123,002 ganesh bytes when the merge landed, against 1,173,302 graphite.
-  { entry: 'src/render-worker/compositor-worker-ganesh-entry.ts', maxBytes: 1_150_000 },
+  {
+    entry: 'src/render-worker/shell-worker-ganesh-entry.ts',
+    maxBytes: 3_600_000,
+    bootRoots: [...SHELL_WORKER_BOOT_ROOTS, 'vendor/canvaskit-ganesh.js'],
+  },
+  {
+    entry: 'src/render-worker/compositor-worker-entry.ts',
+    maxBytes: 1_200_000,
+    bootRoots: [...COMPOSITOR_WORKER_BOOT_ROOTS, ...GRAPHITE_WORKER_BOOT_ROOTS],
+  },
+  // both entries boot compositor-worker.ts with their backend and CanvasKit
+  // glue (plans/peach/compositor-one-path.md).
+  {
+    entry: 'src/render-worker/compositor-worker-ganesh-entry.ts',
+    maxBytes: 1_150_000,
+    bootRoots: [...COMPOSITOR_WORKER_BOOT_ROOTS, 'vendor/canvaskit-ganesh.js'],
+  },
 ]
 
 // packages whose manifests omit `sideEffects` (metro never tree-shakes, so
@@ -644,9 +713,64 @@ const WORKER_SIDE_EFFECT_FREE_PACKAGES = [
   },
 ]
 
+function collectStaticBootModules(
+  context: {
+    getModuleIds(): IterableIterator<string>
+    getModuleInfo(id: string): { importedIds: string[] } | null
+  },
+  roots: readonly string[],
+) {
+  const modules = new Set<string>()
+  const visit = (id: string) => {
+    if (modules.has(id)) return
+    modules.add(id)
+    for (const dependency of context.getModuleInfo(id)?.importedIds ?? [])
+      visit(dependency)
+  }
+  for (const id of context.getModuleIds())
+    if (roots.some((root) => id.endsWith(`/${root}`))) visit(id)
+  return modules
+}
+
+// the host's already-eager static closure shares one download. optional host
+// services keep their dynamic imports and ordered first-use evaluation.
+export function hostBootChunkPlugin(): Plugin {
+  let modules = new Set<string>()
+  return {
+    name: 'peach-host-boot-chunk',
+    apply: 'build',
+    buildEnd(error) {
+      if (!error) {
+        modules = collectStaticBootModules(this, ['src/main.tsx'])
+        // the entry must retain its filename and manifest identity.
+        for (const id of modules) if (id.endsWith('/src/main.tsx')) modules.delete(id)
+      }
+    },
+    outputOptions(options) {
+      return {
+        ...options,
+        // host resource urls are relative to the runtime root.
+        chunkFileNames: (chunk) =>
+          chunk.name === 'host-home' ? 'host-home-[hash].js' : 'assets/[name]-[hash].js',
+        strictExecutionOrder: true,
+        codeSplitting: {
+          groups: [
+            {
+              name: 'host-home',
+              test: (id) => modules.has(id),
+              includeDependenciesRecursively: false,
+            },
+          ],
+        },
+      }
+    },
+  }
+}
+
 export function workerBootChunkPlugin(closures: WorkerBootClosure[]): Plugin {
   let closure: WorkerBootClosure | null = null
   let isWorker = false
+  let bootModules = new Set<string>()
   return {
     name: 'sootsim-worker-boot-chunk',
     apply: 'build',
@@ -667,48 +791,59 @@ export function workerBootChunkPlugin(closures: WorkerBootClosure[]): Plugin {
         treeshake: { ...treeshake, moduleSideEffects: WORKER_SIDE_EFFECT_FREE_PACKAGES },
       }
     },
+    buildEnd(error) {
+      if (!isWorker || error || !closure?.bootRoots) return
+      bootModules = collectStaticBootModules(this, closure.bootRoots)
+    },
     outputOptions(options) {
       if (!isWorker) return null
-      return { ...options, codeSplitting: false, format: 'es', strict: true }
+      return {
+        ...options,
+        codeSplitting: closure?.bootRoots
+          ? {
+              groups: [
+                {
+                  name: 'worker-home',
+                  test: (id) => bootModules.has(id),
+                  includeDependenciesRecursively: false,
+                },
+              ],
+            }
+          : true,
+        strictExecutionOrder: true,
+        format: 'es',
+        strict: true,
+        // keep retained chunk source one-byte even when literals contain unicode.
+        minify: { codegen: { asciiOnly: true } },
+      }
     },
     renderChunk: {
       order: 'post',
       async handler(code, chunk) {
         if (!isWorker) return null
-        // vite introduces relative child-worker urls during rendering. resolve
-        // their module base after that pass, using syntax-aware replacement.
-        const transformed = await transformWithOxc(code, chunk.fileName, {
-          define: { 'import.meta.url': 'globalThis.location.href' },
-          sourcemap: true,
-        })
-        if (!transformed.map) this.error('worker transform produced no source map')
-        const compact = await minify(transformed.code, {
-          module: true,
-          compress: { passes: 4 },
-          mangle: true,
-          sourceMap: { content: JSON.stringify(transformed.map) },
-        })
-        if (!compact.code) this.error('worker minification produced no code')
-        if (typeof compact.map !== 'string')
-          this.error('worker minification produced no encoded source map')
-        return { code: compact.code, map: compact.map }
+        // lower vite's final module urls into the shared worker chunk protocol.
+        // each chunk retains its own module base rather than the entry's location.
+        return renderWorkerSystemChunk(code, chunk.isEntry)
       },
     },
     generateBundle(_options, bundle) {
       if (!isWorker) return
       const chunks = Object.values(bundle).filter((output) => output.type === 'chunk')
-      if (chunks.length !== 1 || !chunks[0].isEntry) {
+      const entries = chunks.filter((chunk) => chunk.isEntry)
+      if (entries.length !== 1) {
         this.error(
-          `worker ${closure?.entry ?? 'entry'}: expected one inlined chunk, got ${chunks.map((chunk) => chunk.fileName).join(', ')}`,
+          `worker ${closure?.entry ?? 'entry'}: expected one boot entry, got ${entries.map((chunk) => chunk.fileName).join(', ')}`,
         )
       }
       // the native host evaluates the same module body in an async strict closure.
       // reject remaining module syntax before it can reach JSContext.
-      new Script(`(async () => { 'use strict';\n${chunks[0].code}\n})()`)
+      for (const chunk of chunks)
+        new Script(`(async () => { 'use strict';\n${chunk.code}\n})()`)
       if (!closure) return
-      const bytes = Buffer.byteLength(chunks[0].code)
+      const bootChunk = entries[0]
+      const bytes = Buffer.byteLength(bootChunk.code)
       if (bytes > closure.maxBytes) {
-        const chunk = chunks[0]
+        const chunk = bootChunk
         const pkgs = new Map<string, Set<string>>()
         for (const id of chunk.moduleIds) {
           // a virtual `\0` id (the jsx-runtime re-export shim) names a
@@ -745,7 +880,7 @@ export function workerBootChunkPlugin(closures: WorkerBootClosure[]): Plugin {
               `${module.renderedLength} ${path.relative(process.cwd(), id)}`,
           )
         this.error(
-          `worker ${closure.entry}: ${chunks[0].fileName} is ${bytes} bytes, over the ${closure.maxBytes} byte cap; eliminate excess boot dependencies rather than raising the cap${dupDetail}\nlargest modules (rendered bytes):\n  ${largest.join('\n  ')}`,
+          `worker ${closure.entry}: ${bootChunk.fileName} is ${bytes} bytes, over the ${closure.maxBytes} byte cap; eliminate excess boot dependencies rather than raising the cap${dupDetail}\nlargest modules (rendered bytes):\n  ${largest.join('\n  ')}`,
         )
       }
     },
@@ -1021,10 +1156,12 @@ export function manifestNativeSeamRedirect(): Plugin {
   }
   const targets = new Set(NATIVE_SEAM_MANIFEST.map((entry) => entry.target))
   const sourceFilter = new RegExp(
-    `(?:^|/)(?:${[...byPkg.values()]
-      .flatMap((seams) => [...seams.keys()])
+    `(?:^|/)(?:${[
+      ...[...byPkg.values()].flatMap((seams) => [...seams.keys()]),
+      ...Object.keys(rnLibraryStubs).map((specifier) => path.posix.basename(specifier)),
+    ]
       .map((basename) => basename.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
-      .join('|')})(?:\\.(?:native|web|ios|android))?$`,
+      .join('|')})(?:\\.(?:native|web|ios|android))?(?:\\.[cm]?[jt]sx?)?$`,
   )
   return {
     name: 'sootsim-manifest-native-seam-redirect',
@@ -1032,24 +1169,27 @@ export function manifestNativeSeamRedirect(): Plugin {
     resolveId: {
       filter: { id: sourceFilter },
       handler(source, importer) {
+        const nativeLibraryStub = resolveReactNativeLibraryStub(source, importer)
+        if (nativeLibraryStub) return nativeLibraryStub
         if (!importer || byPkg.size === 0 || targets.has(importer)) return null
-        // find the package whose path appears in the importer. matches both
+        // find the innermost package whose path appears in the importer. matches both
         // `/<pkg>/` (unscoped) and `/@scope/<pkg>/` (scoped — the leading `@`
         // is part of the pkg name in the manifest, e.g. `@notifee/react-native`).
         let seams: Map<string, { target: string; notes?: string }> | undefined
         let matchedPkg: string | undefined
+        let matchedIndex = -1
         for (const [pkg, entry] of byPkg) {
-          if (importer.includes(`/${pkg}/`)) {
+          const index = importer.lastIndexOf(`/${pkg}/`)
+          if (index > matchedIndex) {
             seams = entry
             matchedPkg = pkg
-            break
+            matchedIndex = index
           }
         }
         if (!seams) return null
-        const basename = (source.split('/').pop() ?? '').replace(
-          /\.(native|web|ios|android)$/,
-          '',
-        )
+        const basename = (source.split('/').pop() ?? '')
+          .replace(/\.[cm]?[jt]sx?$/, '')
+          .replace(/\.(native|web|ios|android)$/, '')
         const seam = seams.get(basename)
         if (!seam) return null
         if (process.env.SOOTSIM_NATIVE_SEAM_DEBUG) {
@@ -1070,7 +1210,7 @@ export function manifestNativeSeamRedirect(): Plugin {
 }
 
 interface ViteBridgeProcessEntry {
-  boundPort: Promise<number | null>
+  boundPort: Promise<number>
   close: () => Promise<void>
   owners: Set<object>
   shellPort: { read: () => number | null }
@@ -1106,7 +1246,7 @@ export function wsBridgePlugin(options: { ownedBridgePort?: number } = {}): Plug
   // websocket console error during boot.
   // a parent that already owns a bridge supplies its receipt here. the shell
   // publishes that exact port and never starts a competing development bridge.
-  let boundPort: Promise<number | null> | null =
+  let boundPort: Promise<number> | null =
     options.ownedBridgePort === undefined
       ? null
       : Promise.resolve(options.ownedBridgePort)
@@ -1122,10 +1262,10 @@ export function wsBridgePlugin(options: { ownedBridgePort?: number } = {}): Plug
     async closeBundle() {
       await releaseBridge?.()
     },
-    configureServer(server) {
+    async configureServer(server) {
       if (!boundPort) {
         const preferredPort = resolveSootsimBridgePort({
-          explicitPort: process.env.SOOTSIM_BRIDGE_PORT,
+          explicitPort: process.env.PEACH_BRIDGE_PORT,
           portOffset: process.env.PORT_OFFSET,
         })
         const readShellPort = () => {
@@ -1141,8 +1281,7 @@ export function wsBridgePlugin(options: { ownedBridgePort?: number } = {}): Plug
         } else {
           // lazy import to avoid pulling ws into the main bundle.
           // note: the .ts extension is required on vite 8 / node ESM — without
-          // it, import() throws "Cannot find module" and the bridge silently
-          // never starts.
+          // it, import() throws "Cannot find module" before the bridge starts.
           const shellPort = { read: readShellPort }
           const host = import('./host/bridge-host.ts').then(({ SootSimBridgeHost }) => {
             return new SootSimBridgeHost({
@@ -1154,13 +1293,12 @@ export function wsBridgePlugin(options: { ownedBridgePort?: number } = {}): Plug
           let entry: ViteBridgeProcessEntry
           boundPort = host
             .then((bridgeHost) => bridgeHost.startAsync({ silent: true }))
-            .catch((err: unknown) => {
+            .catch(async (err: unknown) => {
               if (viteBridgeProcesses.get(preferredPort) === entry) {
                 viteBridgeProcesses.delete(preferredPort)
               }
-              const message = err instanceof Error ? err.message : String(err)
-              console.warn('[peach] ws bridge failed to start:', message)
-              return null
+              await entry.close()
+              throw err
             })
           entry = {
             boundPort,
@@ -1185,31 +1323,27 @@ export function wsBridgePlugin(options: { ownedBridgePort?: number } = {}): Plug
       }
 
       if (!boundPort) throw new Error('peach bridge identity was not initialized')
-      const identityPort = boundPort
+      // vite awaits this hook before it can listen. a failed bridge must also
+      // close vite's watchers and transports instead of publishing a ready shell.
+      let bridgePort: number
+      try {
+        bridgePort = await boundPort
+      } catch (err) {
+        await server.close()
+        throw err
+      }
       server.middlewares.use((req, res, next) => {
         if (req.url?.split('?')[0] !== SHELL_BRIDGE_IDENTITY_PATH) {
           next()
           return
         }
-        void identityPort
-          .then((bridgePort) => {
-            if (bridgePort === null) {
-              res.statusCode = 503
-              res.end('peach bridge unavailable')
-              return
-            }
-            const identity = {
-              schema: 1,
-              bridgePort,
-            } satisfies ShellBridgeIdentity
-            res.setHeader('Content-Type', 'application/json')
-            res.setHeader('Cache-Control', 'no-store')
-            res.end(JSON.stringify(identity))
-          })
-          .catch(() => {
-            res.statusCode = 503
-            res.end('peach bridge unavailable')
-          })
+        const identity = {
+          schema: 1,
+          bridgePort,
+        } satisfies ShellBridgeIdentity
+        res.setHeader('Content-Type', 'application/json')
+        res.setHeader('Cache-Control', 'no-store')
+        res.end(JSON.stringify(identity))
       })
     },
     // publish the bound port to the page. head-prepend so it lands before the
@@ -1274,7 +1408,13 @@ function sootsimConfigPlugin(
         }),
       )
 
-      const dedupe = ['react', 'react-dom', 'react/jsx-runtime', 'react/jsx-dev-runtime']
+      const dedupe = [
+        'react',
+        'react-dom',
+        'react/jsx-runtime',
+        'react/jsx-dev-runtime',
+        'expo-asset',
+      ]
 
       // internal sootsim builds must keep the entire Tamagui package family on a
       // single module graph. mixing raw @fs modules with prebundled .vite/deps
@@ -1330,10 +1470,18 @@ function sootsimConfigPlugin(
             'react-dom',
             'react-dom/client',
             'react-reconciler',
-            'react-reconciler/constants',
+            'react-reconciler/constants.js',
             'react/jsx-runtime',
             'react/jsx-dev-runtime',
             '@react-native/normalize-color',
+            '@react-native/normalize-colors',
+            // these upstream native entries contain CJS even after Flow is stripped.
+            // force interop for workers, whose imports dependency discovery cannot see.
+            'react-native/asset-registry',
+            '@react-native/assets-registry/registry',
+            '@peach-internal/react-native/BatchedBridge/BatchedBridge',
+            '@peach-internal/react-native/Components/View/ReactNativeStyleAttributes',
+            '@peach-internal/react-native/StyleSheet/processColor',
             // CJS deps transitively imported by @gorhom/bottom-sheet and
             // @gorhom/portal (both excluded above). vite's CJS→ESM interop
             // only kicks in via pre-bundle, so these must be pre-bundled even
@@ -1367,6 +1515,17 @@ function sootsimConfigPlugin(
               ],
             },
             plugins: [
+              flowStripTransform(),
+              {
+                name: 'peach-react-native-boundaries',
+                resolveId(source: string, importer: string | undefined) {
+                  const nativeLibraryStub = resolveReactNativeLibraryStub(
+                    source,
+                    importer,
+                  )
+                  return nativeLibraryStub ? { id: nativeLibraryStub } : null
+                },
+              },
               {
                 name: 'sootsim-published-browser-internals',
                 resolveId(source: string, importer: string | undefined) {
@@ -1429,8 +1588,31 @@ function sootsimConfigPlugin(
               find: /^@react-native\/assets-registry\/registry$/,
               replacement: rnAssetRegistryPath,
             },
+            // upstream virtualized-lists imports this private module by its bare
+            // path, which react-native's exports map hides. load the installed
+            // upstream javascript unchanged, including its native flag getters.
+            {
+              find: /^react-native\/src\/private\/featureflags\/ReactNativeFeatureFlags(?:\.js)?$/,
+              replacement: path.resolve(
+                workspaceNodeModules,
+                'react-native/src/private/featureflags/ReactNativeFeatureFlags.js',
+              ),
+            },
+            ...[
+              'BatchedBridge/BatchedBridge',
+              'Components/View/ReactNativeStyleAttributes',
+              'StyleSheet/processColor',
+            ].map((module) => ({
+              find: `@peach-internal/react-native/${module}`,
+              replacement: path.resolve(
+                workspaceNodeModules,
+                `react-native/Libraries/${module}.js`,
+              ),
+            })),
             ...Object.entries(rnLibraryStubs).map(([find, replacement]) => ({
-              find,
+              find: new RegExp(
+                `^${find.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\.[cm]?[jt]sx?)?$`,
+              ),
               replacement,
             })),
             { find: /^react-native\/Libraries\/.*/, replacement: rnDeepStubDefault },
@@ -1501,6 +1683,7 @@ function reactBridgePlugin(): Plugin {
           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')
 
@@ -1558,6 +1741,7 @@ export function workerReactBridgePlugin(): Plugin {
           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/')
@@ -1652,6 +1836,10 @@ function sootsimEsbuildPlugin(appDir: string) {
   return {
     name: 'sootsim-esbuild',
     setup(build: any) {
+      build.onResolve({ filter: /^(?:\.|\/)/ }, (args: any) => {
+        const nativeLibraryStub = resolveReactNativeLibraryStub(args.path, args.importer)
+        return nativeLibraryStub ? { path: nativeLibraryStub } : null
+      })
       // metro-style .ios > .native resolution
       build.onResolve({ filter: /^\./ }, (args: any) => {
         if (!args.importer.includes('node_modules') && !isAppSourceEsbuild(args.importer))
@@ -1687,16 +1875,8 @@ function sootsimEsbuildPlugin(appDir: string) {
       })
 
       // react-native deep path stubs
-      for (const [importPath, stubPath] of Object.entries(rnLibraryStubs)) {
-        build.onResolve(
-          { filter: new RegExp(`^${importPath.replace(/\//g, '\\/')}$`) },
-          () => ({
-            path: stubPath,
-          }),
-        )
-      }
       build.onResolve({ filter: /^react-native\/Libraries\// }, (args: any) => {
-        return { path: rnLibraryStubs[args.path] || rnDeepStubDefault }
+        return { path: resolveReactNativeLibraryStub(args.path) || rnDeepStubDefault }
       })
 
       // resolve builtin stubs (react-native-safe-area-context, expo-*, etc.)
@@ -1856,13 +2036,13 @@ function loadFlowBabel(): void {
     '@babel/plugin-syntax-jsx',
   ) as import('@babel/core').PluginItem
 }
-function flowStripTransform(): Plugin {
+function flowStripTransform() {
   return {
     name: 'sootsim-flow-strip',
     enforce: 'pre',
     transform: {
       filter: {
-        id: /\/node_modules\/.*\.[cm]?jsx?$/,
+        id: /\/node_modules\/.*\.[cm]?jsx?(?:\?.*)?$/,
         code: /@flow/,
       },
       handler(code, id) {
@@ -1879,7 +2059,7 @@ function flowStripTransform(): Plugin {
         return { code: result.code, map: result.map ?? null }
       },
     },
-  }
+  } satisfies Plugin
 }
 
 function nodeModulesJsxTransform(): Plugin {
@@ -1888,7 +2068,7 @@ function nodeModulesJsxTransform(): Plugin {
     enforce: 'pre',
     transform: {
       filter: {
-        id: /\/node_modules\/.*\.js$/,
+        id: /\/node_modules\/.*\.js(?:\?.*)?$/,
         code: /</,
       },
       async handler(code, id) {
@@ -2004,7 +2184,8 @@ function reactNativeRequirePlugin(isAppSource: (p: string) => boolean): Plugin {
           const importPath = match[1]
           if (!seenPaths.has(importPath)) {
             const varName = `__soot_rn_lib_${importCounter++}__`
-            const stubPath = rnLibraryStubs[importPath] || rnDeepStubDefault
+            const stubPath =
+              resolveReactNativeLibraryStub(importPath) || rnDeepStubDefault
             imports += `import * as ${varName} from ${JSON.stringify(stubPath)};\n`
             seenPaths.set(importPath, varName)
           }
@@ -2064,28 +2245,59 @@ function externalAppResolvePlugin(
 
 // convert require() calls and handle JSX in .js files from external app sources
 function externalAppTransformPlugin(isAppSource: (p: string) => boolean): Plugin {
+  const defines: Record<string, string> = {}
   return {
     name: 'sootsim-external-app-transform',
     enforce: 'pre',
+    configResolved(config) {
+      for (const [name, value] of Object.entries(config.define ?? {}))
+        defines[name] = typeof value === 'string' ? value : JSON.stringify(value)
+    },
     transform: {
       filter: { code: /require\(|</ },
       async handler(code, id) {
-        if (!isAppSource(id)) return null
+        // expo's winter polyfills use Metro-local requires in lazy getters.
+        // their module imports must never reach the host's native-package registry.
+        if (!isAppSource(id) && !/\/node_modules\/expo\/(?:src|build)\/winter\//.test(id))
+          return null
 
-        let result = code
+        // prune upstream's disabled native branches before lifting module imports.
+        let result = /\/node_modules\/expo\/(?:src|build)\/winter\//.test(id)
+          ? minifySync(
+              stripViteQuery(id),
+              transformSync(stripViteQuery(id), code, { define: defines }).code,
+              { mangle: false },
+            ).code
+          : code
         let imports = ''
         let importCounter = 0
         let hasChanges = false
 
         if (code.includes('require(')) {
-          const requireRegex = /require\(["']([^"']+)["']\)/g
-          const replacements: Array<{ full: string; varName: string }> = []
+          const replacements: Array<{ start: number; end: number; varName: string }> = []
           const seenPaths = new Map<string, string>()
-          let match
-
-          requireRegex.lastIndex = 0
-          while ((match = requireRegex.exec(result)) !== null) {
-            const reqPath = match[1]
+          const pending: unknown[] = [parseSync(stripViteQuery(id), result).program]
+          while (pending.length) {
+            const node = pending.pop()
+            if (!isRecord(node)) continue
+            for (const value of Object.values(node)) {
+              if (Array.isArray(value)) pending.push(...value)
+              else if (isRecord(value)) pending.push(value)
+            }
+            if (
+              node.type !== 'CallExpression' ||
+              !isRecord(node.callee) ||
+              node.callee.type !== 'Identifier' ||
+              node.callee.name !== 'require' ||
+              !Array.isArray(node.arguments) ||
+              node.arguments.length !== 1 ||
+              !isRecord(node.arguments[0]) ||
+              typeof node.arguments[0].value !== 'string' ||
+              typeof node.start !== 'number' ||
+              typeof node.end !== 'number'
+            )
+              continue
+            const reqPath = node.arguments[0].value
             if (reqPath === 'react-native' || reqPath.startsWith('react-native/'))
               continue
 
@@ -2094,12 +2306,16 @@ function externalAppTransformPlugin(isAppSource: (p: string) => boolean): Plugin
               imports += `import * as ${varName} from ${JSON.stringify(reqPath)};\n`
               seenPaths.set(reqPath, varName)
             }
-            replacements.push({ full: match[0], varName: seenPaths.get(reqPath)! })
+            replacements.push({
+              start: node.start,
+              end: node.end,
+              varName: seenPaths.get(reqPath)!,
+            })
           }
 
           if (replacements.length > 0) {
-            for (const rep of replacements) {
-              result = result.replace(rep.full, rep.varName)
+            for (const rep of replacements.sort((a, b) => b.start - a.start)) {
+              result = result.slice(0, rep.start) + rep.varName + result.slice(rep.end)
             }
             hasChanges = true
           }
@@ -2552,10 +2768,6 @@ export function expoDomComponentsPlugin(
           if (fs.existsSync(resolved)) {
             try {
               const stat = fs.statSync(resolved)
-              if (stat.isFile()) {
-                domWebModuleIds.add(resolved)
-                return resolved
-              }
               if (stat.isDirectory()) {
                 const indexCandidates = [
                   path.join(resolved, 'index.web.tsx'),
@@ -2596,6 +2808,10 @@ export function expoDomComponentsPlugin(
               return candidate
             }
           }
+          if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
+            domWebModuleIds.add(resolved)
+            return resolved
+          }
           const indexCandidates = [
             path.join(resolved, 'index.web.tsx'),
             path.join(resolved, 'index.web.ts'),