peachsim 0.1.527 → 0.1.571

package/src/capture-contract.ts

@@ -188,7 +188,8 @@ export function selectRnxRasterNodeIds(tree: RnxRasterRegionTree): Set<number> {
             node.text,
           ))) ||
       node.style._liquidGlass !== undefined ||
-      node.style._liquidGlassEdge !== undefined
+      node.style._liquidGlassEdge !== undefined ||
+      node.style._liquidGlassMaterialTint !== undefined
     ) {
       unsupported.add(node.nodeId)
     }
@@ -318,6 +319,146 @@ export function rnxCaptureRasterRegions(
   })
 }
 
+/** a region request snapped to the surface pixel grid and placed in the atlas */
+export interface RnxPackedCaptureRegion extends RnxCaptureRegionRequest {
+  /** top-left of the region on the app surface, in pixels */
+  sourceX: number
+  sourceY: number
+  pixelWidth: number
+  pixelHeight: number
+  /** top-left of the region inside the atlas, in pixels */
+  atlasX: number
+  atlasY: number
+}
+
+export interface RnxPackedCaptureAtlas {
+  /** logical atlas dimensions; pixel dimensions are these times the pixel ratio */
+  width: number
+  height: number
+  pixelWidth: number
+  pixelHeight: number
+  regions: RnxPackedCaptureRegion[]
+  /** the wire regions a producer publishes beside the encoded atlas */
+  atlasRegions: RnxCaptureAtlasRegion[]
+}
+
+// the bounded selective-layer atlas every producer ships: regions snapped to
+// whole surface pixels, shelf-packed into the smallest of a few candidate
+// widths, and mapped back to logical atlas coordinates. one packer for the
+// headless renderer (which draws isolated subtrees into the slots) and the
+// browser producer (which crops them out of a screen-sized screenshot), so a
+// consumer never learns which one made the artifact from the layout.
+export function packRnxCaptureRegions(
+  regions: readonly RnxCaptureRegionRequest[],
+  pixelRatio: number,
+  surface: { pixelWidth: number; pixelHeight: number },
+): RnxPackedCaptureAtlas {
+  const physical = regions.map((region) => {
+    const left = Math.floor(region.frame.x * pixelRatio)
+    const top = Math.floor(region.frame.y * pixelRatio)
+    const right = Math.ceil((region.frame.x + region.frame.width) * pixelRatio)
+    const bottom = Math.ceil((region.frame.y + region.frame.height) * pixelRatio)
+    if (
+      left < 0 ||
+      top < 0 ||
+      right > surface.pixelWidth ||
+      bottom > surface.pixelHeight ||
+      right <= left ||
+      bottom <= top
+    ) {
+      throw new Error(`capture region ${region.key} is outside the app surface`)
+    }
+    return {
+      key: region.key,
+      nodeId: region.nodeId,
+      frame: {
+        x: left / pixelRatio,
+        y: top / pixelRatio,
+        width: (right - left) / pixelRatio,
+        height: (bottom - top) / pixelRatio,
+      },
+      sourceX: left,
+      sourceY: top,
+      pixelWidth: right - left,
+      pixelHeight: bottom - top,
+    }
+  })
+  const largestWidth = Math.max(...physical.map((region) => region.pixelWidth))
+  const totalArea = physical.reduce(
+    (area, region) => area + region.pixelWidth * region.pixelHeight,
+    0,
+  )
+  if (totalArea > 4_194_304) {
+    throw new Error('capture region pixels exceed the atlas budget')
+  }
+  const candidates = [
+    largestWidth,
+    Math.max(largestWidth, Math.ceil(Math.sqrt(totalArea))),
+    Math.max(largestWidth, surface.pixelWidth),
+    4_096,
+  ]
+  const ordered = [...physical].sort(
+    (left, right) =>
+      right.pixelHeight - left.pixelHeight ||
+      right.pixelWidth - left.pixelWidth ||
+      left.key.localeCompare(right.key),
+  )
+  let best: { width: number; height: number; regions: RnxPackedCaptureRegion[] } | null =
+    null
+  for (const candidate of [...new Set(candidates)]) {
+    if (candidate > 4_096) continue
+    let x = 0
+    let y = 0
+    let rowHeight = 0
+    let usedWidth = 0
+    const packed: RnxPackedCaptureRegion[] = []
+    for (const region of ordered) {
+      if (x > 0 && x + region.pixelWidth > candidate) {
+        y += rowHeight
+        x = 0
+        rowHeight = 0
+      }
+      packed.push({ ...region, atlasX: x, atlasY: y })
+      x += region.pixelWidth
+      rowHeight = Math.max(rowHeight, region.pixelHeight)
+      usedWidth = Math.max(usedWidth, x)
+    }
+    const height = y + rowHeight
+    if (height > 4_096 || usedWidth * height > 4_194_304) continue
+    const result = { width: usedWidth, height, regions: packed }
+    if (!best || result.width * result.height < best.width * best.height) best = result
+  }
+  if (!best) throw new Error('capture regions cannot fit in one bounded atlas')
+  const width = best.width / pixelRatio
+  const height = best.height / pixelRatio
+  return {
+    width,
+    height,
+    pixelWidth: best.width,
+    pixelHeight: best.height,
+    regions: best.regions,
+    atlasRegions: best.regions.map((region) => ({
+      key: region.key,
+      nodeId: region.nodeId,
+      frame: region.frame,
+      // a region flush with the far edge is anchored to the logical edge so
+      // its source never runs past the atlas by a rounding hair
+      source: {
+        x:
+          region.atlasX + region.pixelWidth === best.width
+            ? width - region.frame.width
+            : region.atlasX / pixelRatio,
+        y:
+          region.atlasY + region.pixelHeight === best.height
+            ? height - region.frame.height
+            : region.atlasY / pixelRatio,
+        width: region.frame.width,
+        height: region.frame.height,
+      },
+    })),
+  }
+}
+
 export interface RnxCaptureAtlasRegion extends RnxCaptureRegionRequest {
   /** source rectangle inside the packed atlas, in logical atlas coordinates */
   source: RnxCaptureRect
@@ -325,7 +466,7 @@ export interface RnxCaptureAtlasRegion extends RnxCaptureRegionRequest {
 
 export interface RnxCaptureRegionAtlas {
   kind: 'png-atlas'
-  producer: 'headless-cpu-app-surface'
+  producer: 'headless-cpu-app-surface' | 'browser-compositor-app-surface'
   dataUri: string
   /** logical atlas dimensions; the encoded PNG uses pixelWidth × pixelHeight */
   width: number
@@ -533,7 +674,8 @@ export function isRnxCaptureRegionAtlas(value: unknown): value is RnxCaptureRegi
   if (
     !captureRecord(value) ||
     value.kind !== 'png-atlas' ||
-    value.producer !== 'headless-cpu-app-surface' ||
+    (value.producer !== 'headless-cpu-app-surface' &&
+      value.producer !== 'browser-compositor-app-surface') ||
     typeof value.dataUri !== 'string' ||
     !value.dataUri.startsWith('data:image/png;base64,') ||
     !captureNumber(value.width) ||

package/src/cloud-test-args.ts

@@ -0,0 +1,100 @@
+// hosted `rnx test` selection args: the argv slice a cloud submitter
+// forwards and the recorder appends verbatim to its executor invocation.
+//
+// selection only. the flags below choose WHICH tests run; everything
+// about HOW they run (workers, timeouts, shards, devices, environment)
+// stays with the recorder that owns the execution environment, and
+// everything about WHERE they run (app, origin, tunnel) is consumed by
+// the submitter. a flag outside this list never reaches the executor:
+// the submitter warns and the server refuses, so a filter is never
+// silently dropped. pure: the gpu recorder daemon imports this too, so
+// no ~/ aliases, no server-only, no node builtins.
+export const CLOUD_TEST_ARGS_MAX_COUNT = 32
+export const CLOUD_TEST_ARG_MAX_LENGTH = 1000
+export const CLOUD_TEST_ARGS_MAX_BYTES = 16 * 1024
+
+// every flag a hosted job honors from the submitting command line. each
+// takes exactly one value, as a separate token or --flag=value.
+export const CLOUD_TEST_VALUE_FLAGS: readonly string[] = [
+  '-t',
+  '--testNamePattern',
+  '--testPathPattern',
+  '--include-tags',
+  '--exclude-tags',
+  '--grep',
+]
+
+const CLOUD_TEST_VALUE_FLAG_SET = new Set<string>(CLOUD_TEST_VALUE_FLAGS)
+
+export function isCloudTestValueFlag(name: string): boolean {
+  return CLOUD_TEST_VALUE_FLAG_SET.has(name)
+}
+
+export type CloudTestArgsVerdict =
+  | { ok: true; args: string[] }
+  | { ok: false; message: string }
+
+// the submit payload's testArgs field, or null when the submission
+// carries no selection. every violation names the offending arg.
+export function parseCloudTestArgs(value: unknown): CloudTestArgsVerdict {
+  if (value === undefined || value === null) return { ok: true, args: [] }
+  if (!Array.isArray(value)) {
+    return { ok: false, message: 'testArgs must be an array of strings' }
+  }
+  if (value.length > CLOUD_TEST_ARGS_MAX_COUNT) {
+    return {
+      ok: false,
+      message: `testArgs may contain at most ${CLOUD_TEST_ARGS_MAX_COUNT} entries`,
+    }
+  }
+  // utf-8 bytes, not utf-16 code units: the bound names bytes, and a
+  // multibyte pattern must not slip twice its size past the gate.
+  const encoder = new TextEncoder()
+  let bytes = 0
+  const entries: string[] = []
+  for (const entry of value) {
+    if (typeof entry !== 'string' || entry.length === 0) {
+      return { ok: false, message: 'testArgs entries must be non-empty strings' }
+    }
+    if (entry.length > CLOUD_TEST_ARG_MAX_LENGTH || entry.includes('\0')) {
+      return { ok: false, message: `testArgs entry is too long or carries a NUL byte: ${entry.slice(0, 60)}` }
+    }
+    bytes += encoder.encode(entry).length
+    if (bytes > CLOUD_TEST_ARGS_MAX_BYTES) {
+      return {
+        ok: false,
+        message: `testArgs may contain at most ${CLOUD_TEST_ARGS_MAX_BYTES} bytes`,
+      }
+    }
+    entries.push(entry)
+  }
+  const args: string[] = []
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i]
+    if (!entry.startsWith('-')) {
+      return {
+        ok: false,
+        message: `testArgs carries a positional argument (selection flags only): ${entry.slice(0, 60)}`,
+      }
+    }
+    const eq = entry.indexOf('=')
+    const head = eq > 0 ? entry.slice(0, eq) : entry
+    if (!isCloudTestValueFlag(head)) {
+      return { ok: false, message: `testArgs carries an unknown flag: ${head.slice(0, 60)}` }
+    }
+    if (eq > 0) {
+      if (!entry.slice(eq + 1)) {
+        return { ok: false, message: `${head} expects a value` }
+      }
+      args.push(entry)
+      continue
+    }
+    const val = entries[i + 1]
+    if (val === undefined || val.startsWith('-')) {
+      return { ok: false, message: `${head} expects a value` }
+    }
+    args.push(entry, val)
+    i += 1
+  }
+  return { ok: true, args }
+}

package/src/config.ts

@@ -1,10 +1,10 @@
 // rnx.config.ts — per-app module resolution, turbo modules, env, state, and settings.
 //
 // usage:
-//   import { defineConfig } from 'rnxsim/config'
+//   import { defineConfig } from 'peachsim/config'
 //   export default defineConfig({ modules: { ... }, env: { ... } })
 
-import type { RevenueCatTestStoreConfig } from '@sootsim/compat/revenuecat-test-store'
+import type { RevenueCatTestStoreConfig } from '@peach/compat/revenuecat-test-store'
 
 export type ModuleResolution =
   // an empty module under `modules`; under `nativeModules` / `turboModules` a

package/src/connect.ts

@@ -1,4 +1,4 @@
-// `connect()` — the node entrypoint of the rnxsim SDK. resolves the running
+// `connect()` — the node entrypoint of the peachsim SDK. resolves the running
 // bridge world the same way the CLI does (development bridge registry, then
 // daemon, then default port), picks a sim, and returns a connected SimClient
 // over the shared ws transport. node-only by design: sim-client.ts stays
@@ -67,7 +67,7 @@ export async function connect(options: ConnectOptions = {}): Promise<SimClient>
     const bridge = createCloudBridgeForParsed(target)
     if (!bridge)
       throw new SimConnectError('remote simulator session disappeared while connecting')
-    return new SimClient(bridge, cloud.simId, {
+    return new SimClient(bridge, cloud.service === 'sim' ? cloud.simId : cloud.boxId, {
       commandTimeoutMs: options.timeoutMs ?? 15_000,
     })
   }

package/src/home-paths.ts

@@ -56,10 +56,10 @@ export function rnxHomeDir(): string {
 //                                           checkout, for exercising the
 //                                           install path from this repo
 //
-// signal: realpath of process.argv[1] lands inside a `packages/sootsim/`
+// signal: realpath of process.argv[1] lands inside a `packages/peachsim/`
 // directory. workspace bin symlinks (`node_modules/.bin/sootsim` →
-// `packages/sootsim/dist-cli/bin.js`) and bun-direct invocations
-// (`bun packages/sootsim/cli/bin.ts ...`) both match; published installs
+// `packages/peachsim/dist-cli/bin.js`) and bun-direct invocations
+// (`bun packages/peachsim/cli/bin.ts ...`) both match; published installs
 // resolve under `node_modules/sootsim/` instead.
 export function isSootsimDevCheckout(): boolean {
   if (process.env.SOOTSIM_FORCE_DAEMON_INSTALL === '1') return false

package/src/host/bridge-host.ts

@@ -228,7 +228,7 @@ export interface BridgeHostOptions {
   port?: number
   openUrl?: (url: string, options?: OpenUrlOptions) => Promise<void> | void
   /** Contrast-specific excludes for the agent host's dev-server scan. passed
-   *  through to AgentHost; see packages/sootsim-engine/src/dev-scan-excludes.ts
+   *  through to AgentHost; see packages/peach-engine/src/dev-scan-excludes.ts
    *  for the canonical list. when omitted, AgentHost reads env vars directly. */
   agentScanExcludes?: AgentHostOptions['getExcludePorts']
   /** try preferred port, then port+1, port+2, …, up to this many attempts
@@ -1769,7 +1769,7 @@ export class SootSimBridgeHost {
 
     // /__server-scan — list local metro/expo/vxrn/one dev servers. tenant
     // worker ConnectRN polls this every few seconds to populate the device
-    // picker. mirrors packages/sootsim-shell/src/dev-middleware.ts so both
+    // picker. mirrors packages/peach-shell/src/dev-middleware.ts so both
     // host environments (vite dev and the prod CLI daemon) return identical
     // JSON. icon URLs are rewritten through /__bundle-proxy so the browser
     // doesn't hit cross-origin loads against the discovered dev server.

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

@@ -1,6 +1,6 @@
 // shared fetch-proxy + app-api handlers for the sootsim dev/daemon HTTP
-// surface. both the vite dev middleware (packages/sootsim-shell/src/
-// dev-middleware.ts) and the daemon bridge (packages/sootsim/src/host/
+// surface. both the vite dev middleware (packages/peach-shell/src/
+// dev-middleware.ts) and the daemon bridge (packages/peachsim/src/host/
 // bridge-host.ts) mount these on their respective servers so guest bundle
 // fetches resolve the same way regardless of which surface the sim is
 // loaded through.
@@ -30,6 +30,7 @@ import { isLoopbackHost, normalizeHostname } from '../backend-origin.ts'
 import {
   FETCH_PROXY_BROWSER_USER_AGENT,
   getFetchProxyTargetHeaders,
+  resolveFetchProxyTargetUrl,
 } from './fetch-proxy-overrides.ts'
 
 const STRIP_FETCH_PROXY_HEADERS = new Set([
@@ -184,7 +185,7 @@ export async function handleFetchProxyRequest(
 
   let upstreamUrl: URL
   try {
-    upstreamUrl = new URL(targetUrl)
+    upstreamUrl = resolveFetchProxyTargetUrl(new URL(targetUrl))
   } catch {
     applyFetchProxyCors(res)
     res.writeHead(400, { 'Content-Type': 'text/plain' })

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

@@ -39,6 +39,47 @@ function headerOverridesFor(hostname: string):
   return undefined
 }
 
+// an app that builds its rpc provider hostname out of a per-tenant key cannot be
+// pointed at another node by configuration alone. demo tooling injects this
+// tenant name when a checkout carries no usable provider credentials, and the
+// proxy resolves it to a public node for the chain. a real tenant never matches.
+export const PUBLIC_RPC_TENANT = 'rnx-public-rpc'
+
+const QUICKNODE_HOST_SUFFIX = '.quiknode.pro'
+
+// quicknode encodes the chain in the subdomain and leaves mainnet off entirely.
+const PUBLIC_RPC_BY_QUICKNODE_CHAIN: Record<string, string> = {
+  '': 'https://ethereum-rpc.publicnode.com',
+  'arbitrum-mainnet': 'https://arbitrum-one-rpc.publicnode.com',
+  'avalanche-mainnet': 'https://avalanche-c-chain-rpc.publicnode.com',
+  'base-mainnet': 'https://base-rpc.publicnode.com',
+  'blast-mainnet': 'https://blast-rpc.publicnode.com',
+  bsc: 'https://bsc-rpc.publicnode.com',
+  'celo-mainnet': 'https://celo-rpc.publicnode.com',
+  matic: 'https://polygon-bor-rpc.publicnode.com',
+  optimism: 'https://optimism-rpc.publicnode.com',
+  'soneium-mainnet': 'https://soneium-rpc.publicnode.com',
+  'unichain-mainnet': 'https://unichain-rpc.publicnode.com',
+}
+
+// the url the proxy should actually fetch, which differs from the requested one
+// only for the sentinel tenant above
+export function resolveFetchProxyTargetUrl(requested: URL): URL {
+  const host = requested.hostname.toLowerCase()
+  if (!host.endsWith(QUICKNODE_HOST_SUFFIX)) return requested
+
+  const tenant = host.slice(0, -QUICKNODE_HOST_SUFFIX.length)
+  if (tenant !== PUBLIC_RPC_TENANT && !tenant.startsWith(`${PUBLIC_RPC_TENANT}.`)) {
+    return requested
+  }
+
+  const chain =
+    tenant === PUBLIC_RPC_TENANT ? '' : tenant.slice(PUBLIC_RPC_TENANT.length + 1)
+  const replacement = PUBLIC_RPC_BY_QUICKNODE_CHAIN[chain]
+  // the tenant token rides in the path, which a public node does not want
+  return replacement ? new URL(replacement) : requested
+}
+
 export function getFetchProxyTargetHeaders(targetUrl: URL): Record<string, string> {
   const hostOverrides = headerOverridesFor(targetUrl.hostname)
   return {

package/src/host/plane-host.ts

@@ -17,9 +17,9 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
-import { dispatchPlaneCommand, indexVersion } from '@rnx/box/plane'
+import { dispatchPlaneCommand, indexVersion } from '@peach/box/plane'
 import { CheckoutFilePlane } from '../../cli/commands/box/checkout-plane.ts'
-import type { ProjectFilePlane } from '@rnx/box/plane'
+import type { ProjectFilePlane } from '@peach/box/plane'
 import type { WebSocket } from 'ws'
 
 const WS_OPEN = 1

package/src/index.ts

@@ -39,6 +39,7 @@ export {
   isRnxCaptureRegionAtlas,
   isRnxScreenCapture,
   rnxCaptureRasterRegions,
+  packRnxCaptureRegions,
   rnxRasterFrames,
   RNX_SCREEN_CAPTURE_VERSION,
   selectRnxRasterNodeIds,
@@ -54,6 +55,8 @@ export {
   type RnxCaptureSource,
   type RnxCaptureStyleTokenBinding,
   type RnxCaptureTextLine,
+  type RnxPackedCaptureAtlas,
+  type RnxPackedCaptureRegion,
   type RnxCaptureTextSegment,
   type RnxCaptureTree,
   type RnxCaptureVisualEvidence,

package/src/metro-plugin.ts

@@ -5,7 +5,7 @@
 // when active changes, so one loaded shell cannot mix runtime chunk trees.
 //
 // usage in metro.config.js:
-//   const { withRNX } = require('rnxsim/metro')
+//   const { withRNX } = require('peachsim/metro')
 //   module.exports = withRNX(getDefaultConfig(__dirname))
 
 import fs from 'fs'
@@ -89,7 +89,7 @@ function readCallableMetroExport(
         ? Reflect.get(moduleValue, 'default')
         : undefined
   if (typeof callable !== 'function') {
-    throw new Error(`rnxsim: Metro ${label} module did not export a function`)
+    throw new Error(`peachsim: Metro ${label} module did not export a function`)
   }
   return (...args) => Reflect.apply(callable, undefined, args)
 }
@@ -115,7 +115,7 @@ function createMetroDefaultSerializer(projectRoot: string): MetroSerializer {
         ? Reflect.get(serialized, 'code')
         : undefined
     if (typeof code !== 'string') {
-      throw new Error('rnxsim: Metro bundleToString did not return bundle code')
+      throw new Error('peachsim: Metro bundleToString did not return bundle code')
     }
     return code
   }
@@ -144,7 +144,7 @@ function appendRNXModulePaths(
       .replaceAll(path.sep, '/')
   }
   if (Object.keys(modulePaths).length !== dependencies.size) {
-    throw new Error('rnxsim: bundle module IDs were not unique')
+    throw new Error('peachsim: bundle module IDs were not unique')
   }
 
   const specifiersByModuleId = new Map<string, Set<string>>()

package/src/metro-production-bundle.ts

@@ -30,7 +30,7 @@ export interface RNXMetroModuleIdentity extends RNXMetroModuleIdentityMetadata {
 // from the identity footer the plugin's serializer appends.
 export function toRNXProductionBundleUrl(bundleUrl: string): string {
   const relative = bundleUrl.startsWith('/')
-  const url = new URL(bundleUrl, 'http://rnxsim.local')
+  const url = new URL(bundleUrl, 'http://peachsim.local')
   url.searchParams.set('dev', 'false')
   url.searchParams.set('hot', 'false')
   url.searchParams.set('minify', 'true')
@@ -44,7 +44,7 @@ export function toRNXProductionBundleUrl(bundleUrl: string): string {
  */
 export function toRNXDevelopmentBundleUrl(bundleUrl: string): string {
   const relative = bundleUrl.startsWith('/')
-  const url = new URL(bundleUrl, 'http://rnxsim.local')
+  const url = new URL(bundleUrl, 'http://peachsim.local')
   url.searchParams.set('dev', 'true')
   url.searchParams.set('hot', 'false')
   url.searchParams.set('minify', 'false')

package/src/native-seam-manifest.ts

@@ -10,13 +10,13 @@
 //   1. identify upstream's native-module file (look for files calling
 //      `requireNativeModule`, `TurboModuleRegistry.getEnforced`,
 //      `requireNativeComponent`, or in `src/specs/Native*Module.ts`)
-//   2. write a thin stub at `packages/compat/src/stubs/native-seams/<pkg>.ts`
+//   2. write a thin stub at `packages/peach-compat/src/stubs/native-seams/<pkg>.ts`
 //      that exports the same default + named exports upstream's seam file
 //      exports — except the implementation calls into sootsim's engine.
 //   3. append an entry below. the plugin handles the rest.
 //
 // canonical example: react-native-reanimated. see
-//   - `packages/compat/src/stubs/react-native-reanimated.ts` (the seam stub)
+//   - `packages/peach-compat/src/stubs/react-native-reanimated.ts` (the seam stub)
 //   - `reanimatedNativeSeamRedirect` in vite-plugin.ts (still hard-coded
 //     because it has package-specific edge cases — fabricUtils,
 //     validate-worklets-version. new entries should use this manifest path
@@ -41,7 +41,7 @@ export interface NativeSeamEntry {
   seamBasenames: string[]
   /**
    * absolute path to the seam stub. typically
-   * `packages/compat/src/stubs/native-seams/<pkg>.ts` — but a single stub
+   * `packages/peach-compat/src/stubs/native-seams/<pkg>.ts` — but a single stub
    * file may export every native module the package exposes, so the same
    * `target` can appear in multiple entries if a package has multiple native
    * modules that share an implementation file.
@@ -61,9 +61,9 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 const HERE = path.dirname(fileURLToPath(import.meta.url))
-const NATIVE_SEAMS_DIR = path.resolve(HERE, '../../compat/src/stubs/native-seams')
+const NATIVE_SEAMS_DIR = path.resolve(HERE, '../../peach-compat/src/stubs/native-seams')
 
-/** resolve a stub path under `packages/compat/src/stubs/native-seams/`.
+/** resolve a stub path under `packages/peach-compat/src/stubs/native-seams/`.
  * resolves to `.tsx` when only that exists (JSX-bearing seams like
  * expo-image, react-native-webview). preferred order: `.ts`, `.tsx`. */
 export function seamPath(basename: string): string {
@@ -217,7 +217,7 @@ export const NATIVE_SEAM_MANIFEST: NativeSeamEntry[] = [
   // onto the class-based seam, whose methods throw.
   //
   // registering by module NAME instead is what keeps old and new package
-  // versions both working: ../../compat/src/stubs/expo-{calendar,contacts}-register.ts
+  // versions both working: ../../peach-compat/src/stubs/expo-{calendar,contacts}-register.ts
   // installs every id either version asks for, and upstream's own
   // `requireNativeModule` picks the right one per entry point. a file
   // redirect can only match one layout, so it breaks the versions it was

package/src/public-brand.ts

@@ -2,7 +2,7 @@ const name = 'rnx'
 
 export const rnxPublicBrand = Object.freeze({
   name,
-  packageName: 'rnxsim',
+  packageName: 'peachsim',
   commandName: 'rnx',
   domain: 'rnxsim.com',
   origin: 'https://rnxsim.com',

package/src/rolldown-plugin-swift.ts

@@ -2,13 +2,14 @@
 // swiftpm package to `/api/swift-compile` and answer every `.swift` import
 // with the module that mounts the published artifact.
 //
-// this is the remote twin of `vite-plugin-swift.ts`. that plugin runs the
-// local toolchain and serves the artifact from dev-server middleware; the
-// native engine is its own rolldown instance with no middleware seam, so
-// this plugin compiles nothing in-process and serves nothing. the artifact
-// url the service answers is absolute (compile-cdn), so there is nothing to
-// serve. same compiler, same store, same hash, same credential as the
-// browser worker — one path, no second toolchain to install for `one dev`.
+// this is the remote twin of `vite-plugin-swift.ts`. that plugin calls the
+// shared project-unit compiler and serves the artifact from dev-server
+// middleware. the native engine is its own rolldown instance with no
+// middleware seam, so this plugin compiles nothing in-process and serves
+// nothing. the artifact url the service answers is absolute (compile-cdn), so
+// there is nothing to serve. same compiler, same store, same hash, same
+// credential as the browser worker — one path, no second toolchain to install
+// for `one dev`.
 //
 // an app registers it through One's native plugin seam, not `config.plugins`
 // (which never reach the native engine):
@@ -39,6 +40,7 @@ import {
   enumerateBundleImages,
   enumerateBundleJson,
 } from '../../sootsim-swift/src/bundleAssets'
+import { swiftEntryModuleEsm } from '../../sootsim-swift/src/entryModule'
 import { compileSwiftProject, httpSwiftCompileSubmit } from './swift-submit'
 import { entryRootId } from './vite-plugin-swift'
 import type { SwiftModuleAddress } from './swift-submit'
@@ -230,11 +232,13 @@ export function swiftRemotePlugin(options: SwiftRemotePluginOptions): Plugin {
       // every import mounts through the one entry: the artifact answers
       // whether it is a view or an app root at runtime, so the transform
       // never re-derives the conformance from source.
-      return [
-        `import { createSwiftEntry } from 'rnxsim/swift'`,
-        `export default createSwiftEntry({ url: ${JSON.stringify(address.url)}, hash: ${JSON.stringify(address.hash)}, rootId: ${JSON.stringify(entryRootId(packagePath, file))}, resources: ${JSON.stringify(address.imageUrls ?? {})}, bundleFiles: ${JSON.stringify(pack.resources)} })`,
-        '',
-      ].join('\n')
+      return swiftEntryModuleEsm({
+        url: address.url,
+        hash: address.hash,
+        rootId: entryRootId(packagePath, file),
+        resources: address.imageUrls ?? {},
+        bundleFiles: pack.resources,
+      })
     },
   }
 }

package/src/runtime-assets.ts

@@ -34,11 +34,11 @@ let _monorepoRootCache: string | null | undefined
 function findMonorepoRoot(): string | null {
   if (_monorepoRootCache !== undefined) return _monorepoRootCache
   let dir = path.dirname(fileURLToPath(import.meta.url))
-  // walk up until we find the Contrast monorepo: it has packages/sootsim-engine and
+  // walk up until we find the Contrast monorepo: it has packages/peach-engine and
   // a public/sootsim dev-build output slot. bounded by the filesystem root.
   for (let i = 0; i < 12 && dir !== path.dirname(dir); i++) {
     if (
-      fs.existsSync(path.join(dir, 'packages/sootsim-engine/package.json')) &&
+      fs.existsSync(path.join(dir, 'packages/peach-engine/package.json')) &&
       fs.existsSync(path.join(dir, 'public/sootsim'))
     ) {
       _monorepoRootCache = dir
@@ -66,11 +66,12 @@ export function resolveDevCheckoutRuntimeRoot(): string | null {
   if (!root) return null
   const devBuild = path.join(root, 'public/sootsim')
   // require the runtime shape the installed runtime also has, so serving it is
-  // a drop-in (index.html shell + engine/ + engine-tenant/worker.js tenant).
+  // a drop-in (index.html shell + engine/ + both engine-tenant workers).
   if (
     fs.existsSync(path.join(devBuild, 'index.html')) &&
     fs.existsSync(path.join(devBuild, 'engine/index.html')) &&
-    fs.existsSync(path.join(devBuild, 'engine-tenant/worker.js'))
+    fs.existsSync(path.join(devBuild, 'engine-tenant/worker.js')) &&
+    fs.existsSync(path.join(devBuild, 'engine-tenant/worker.prod.js'))
   ) {
     return devBuild
   }
@@ -217,9 +218,10 @@ export function serveRuntimeFile(req: any, res: any, fullPath: string) {
     return
   }
   // these urls are STABLE across dev rebuilds and runtime version switches
-  // (worker.js, canvaskit-graphite.wasm, the html shells are unhashed), so the
+  // (both worker entries, canvaskit-graphite.wasm, and the html shells are
+  // unhashed), so the
   // browser must revalidate every load — the old year-long immutable here made every
-  // new tab run a stale cached engine-tenant worker.js against a fresh engine,
+  // new tab run a stale cached tenant entry against a fresh engine,
   // which also broke `do reload` ("bridge never reconnected"). no-cache +
   // last-modified keeps repeat loads cheap 304s on localhost.
   res.setHeader('cache-control', 'no-cache')