rnxsim 0.1.407 → 0.1.409

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.407 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.409 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __create = Object.create;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rnxsim",
-  "version": "0.1.407",
+  "version": "0.1.409",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for rnx.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",

package/src/agent-daemon-client.ts

@@ -365,12 +365,12 @@ export async function ensureDaemonRunning(
       'DEV_HOST_REFUSED',
     )
   }
-  const { cmd, prefixArgs } = resolveSootsimInvocation()
+  const { executable, prefixArgs } = resolveSootsimInvocation()
   const args = [...prefixArgs, 'serve', '--quiet']
   if (port !== DEFAULT_SOOTSIM_BRIDGE_PORT) {
     args.push('--port', String(port))
   }
-  const child = spawn(cmd, args, {
+  const child = spawn(executable, args, {
     detached: true,
     stdio: 'ignore',
     env: process.env,

package/src/agent-sessions.ts

@@ -11,6 +11,8 @@ import { randomUUID } from 'node:crypto'
 import fs, { constants as fsConstants } from 'node:fs'
 import path from 'node:path'
 import readline from 'node:readline'
+import { rnxSelfInvocation, type RnxSelfInvocation } from '../cli/self-invocation.ts'
+import { IS_STANDALONE } from '../cli/standalone.ts'
 import { parseAgentEventLine, type AgentEvent } from './agent-events.ts'
 import { encodeAgentPromptEnvelope, type AgentPromptEnvelope } from './agent-prompt.ts'
 import {
@@ -65,21 +67,27 @@ export function pidIsAlive(pid: number | undefined, sessionId?: string): boolean
 
 // --- invocation resolution ---
 
-/** figure out how to re-invoke the sootsim CLI to run `agent-wrapper`.
+/** locate the rnx CLI so this process can run a subcommand of it. callers
+ *  range from the CLI itself to electron main and the vite-plugin daemon.
  *  priority:
  *    1. RNX_BIN env var (explicit override)
- *    2. electron prod: bundled binary under process.resourcesPath/bin/
- *    3. workspace build artifacts (dist-bin/<binary> or dist-cli/bin.js)
+ *    2. this process already IS the CLI — `rnxSelfInvocation` owns that answer
+ *    3. electron prod: bundled binary under process.resourcesPath/bin/
+ *    4. workspace build artifacts (dist-bin/<binary> or dist-cli/bin.js)
  *       — shared between electron dev, the vite-plugin-hosted daemon, and
  *       any other node process that isn't launched with the CLI entry
  *       script directly (e.g. argv[1] = .../node_modules/.bin/vite).
- *    4. CLI dev (argv[1] points at the entry script): re-use argv[0] + argv[1]
- *    5. CLI standalone: argv[0] is the compiled binary, no prefix needed
+ *    5. CLI dev (argv[1] points at the entry script): re-use argv[0] + argv[1]
  */
-export function resolveSootsimInvocation(): { cmd: string; prefixArgs: string[] } {
+export function resolveSootsimInvocation(): RnxSelfInvocation {
   if (process.env.RNX_BIN) {
-    return { cmd: process.env.RNX_BIN, prefixArgs: [] }
+    return { executable: process.env.RNX_BIN, prefixArgs: [] }
   }
+  // the compiled standalone binary cannot be found through argv: bun reports
+  // argv[0] as the literal string "bun" and argv[1] as a path inside its
+  // virtual filesystem, so both fall through to spawning a `bun` that a
+  // shell-installed user does not have.
+  if (IS_STANDALONE) return rnxSelfInvocation()
   // electron prod: packaged binary lives under Resources/bin/.
   if (process.versions.electron) {
     const resourcesPath = (process as NodeJS.Process & { resourcesPath?: string })
@@ -90,7 +98,7 @@ export function resolveSootsimInvocation(): { cmd: string; prefixArgs: string[]
         path.join(resourcesPath, 'bin', `sootsim-${process.platform}-${process.arch}`),
       ]
       for (const c of candidates) {
-        if (fs.existsSync(c)) return { cmd: c, prefixArgs: [] }
+        if (fs.existsSync(c)) return { executable: c, prefixArgs: [] }
       }
     }
   }
@@ -108,23 +116,20 @@ export function resolveSootsimInvocation(): { cmd: string; prefixArgs: string[]
   // script — `.js`/`.ts`/`.mjs` etc. launching vite gives us argv[1] =
   // `…/node_modules/.bin/vite` (no extension), which would make us try
   // to run agent-wrapper under the vite shim and silently fail.
-  const argv0 = process.argv[0]
   const argv1 = process.argv[1]
   if (argv1 && /\.(ts|tsx|mjs|cjs|js)$/.test(argv1)) {
-    return { cmd: argv0, prefixArgs: [argv1] }
+    return { executable: process.argv[0], prefixArgs: [argv1] }
   }
-  if (!argv1 || argv1.includes('/.bin/')) {
-    // bin-shim case falls through to the error below instead of silently
-    // running `node` without args.
-    throw new Error(
-      'rnx CLI not found. set RNX_BIN to the path of the rnx binary, ' +
-        'or build the workspace CLI via `bun run --cwd packages/sootsim build:cli`.',
-    )
-  }
-  return { cmd: argv0, prefixArgs: [] }
+  // anything else — a bin shim such as `…/node_modules/.bin/vite`, or no
+  // argv[1] at all — names no rnx entry script, so say so instead of
+  // spawning the host runtime with no arguments.
+  throw new Error(
+    'rnx CLI not found. set RNX_BIN to the path of the rnx binary, ' +
+      'or build the workspace CLI via `bun run --cwd packages/sootsim build:cli`.',
+  )
 }
 
-function tryWorkspaceSootsim(): { cmd: string; prefixArgs: string[] } | null {
+function tryWorkspaceSootsim(): RnxSelfInvocation | null {
   try {
     const sootsimDir = resolveSootsimPackageDir()
     if (!sootsimDir) return null
@@ -132,7 +137,7 @@ function tryWorkspaceSootsim(): { cmd: string; prefixArgs: string[] } | null {
       process.platform === 'win32' ? 'windows' : process.platform
     }-${process.arch}${process.platform === 'win32' ? '.exe' : ''}`
     const distBinary = path.join(sootsimDir, 'dist-bin', binaryName)
-    if (fs.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] }
+    if (fs.existsSync(distBinary)) return { executable: distBinary, prefixArgs: [] }
     const distBin = path.join(sootsimDir, 'dist-cli', 'bin.js')
     if (fs.existsSync(distBin)) {
       try {
@@ -148,7 +153,7 @@ function tryWorkspaceSootsim(): { cmd: string; prefixArgs: string[] } | null {
           }
         }
       } catch {}
-      return { cmd: process.execPath, prefixArgs: [distBin] }
+      return { executable: process.execPath, prefixArgs: [distBin] }
     }
     return null
   } catch {
@@ -368,7 +373,7 @@ export async function startSession(opts: StartSessionOpts): Promise<StartSession
       fs.chmodSync(transcriptDir, 0o700)
     } catch {}
 
-    const { cmd, prefixArgs } = resolveSootsimInvocation()
+    const { executable, prefixArgs } = resolveSootsimInvocation()
     const wrapperArgs = [
       ...prefixArgs,
       'agent-wrapper',
@@ -394,7 +399,7 @@ export async function startSession(opts: StartSessionOpts): Promise<StartSession
       wrapperArgs.push('--claude-session-uuid', claudeSessionUuid)
     }
 
-    const child = spawn(cmd, wrapperArgs, {
+    const child = spawn(executable, wrapperArgs, {
       detached: true,
       stdio: 'ignore',
       env: {

package/src/capture-contract.ts

@@ -137,6 +137,8 @@ export interface RnxCaptureTree {
   viewport: { width: number; height: number }
   rootNodeId: number
   nodes: RnxCaptureNode[]
+  /** reconciler commit shared by semantic, layout, and visual evidence */
+  commitRevision?: number
 }
 
 export interface RnxCaptureVisualEvidence {
@@ -511,6 +513,7 @@ export function isRnxScreenCapture(value: unknown): value is RnxScreenCapture {
     captureInteger(tree.viewport.height) &&
     tree.viewport.height > 0 &&
     captureInteger(tree.rootNodeId) &&
+    (tree.commitRevision === undefined || captureInteger(tree.commitRevision)) &&
     Array.isArray(tree.nodes) &&
     tree.nodes.every(captureNode) &&
     (visual === undefined ||

package/src/cloud-contract.ts

@@ -1,7 +1,6 @@
 import type { BridgeCommandType } from './bridge-contract'
 
 export const RNX_CLOUD_MAX_ARTIFACT_BYTES = 20 * 1024 * 1024
-export const RNX_CLOUD_DESIGN_PARALLEL_JOB_LIMIT = 16
 export const RNX_CLOUD_DESIGN_MAX_STORAGE_ENTRIES = 256
 export const RNX_CLOUD_DESIGN_MAX_STORAGE_BYTES = 1024 * 1024
 

package/src/vite-plugin.ts

@@ -466,9 +466,71 @@ export function engineShellWorkerPlugins(): Plugin[] {
     keyboardControllerBindingsRedirect(),
     rnghUpstreamInternalResolvePlugin(),
     workletsBabelTransform(() => true),
+    workerBootChunkPlugin(ENGINE_WORKER_BOOT_CLOSURES),
   ]
 }
 
+// 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.
+export type WorkerBootClosure = {
+  // substring of the worker entry module id this applies to
+  entry: string
+  // byte cap on the rendered worker file; raise it in the same change that
+  // adds worker code, never silently
+  maxBytes: number
+}
+
+const ENGINE_WORKER_BOOT_CLOSURES: WorkerBootClosure[] = [
+  { entry: 'src/render-worker/shell-worker-entry.ts', maxBytes: 3_480_000 },
+  { entry: 'src/render-worker/compositor-worker-entry.ts', maxBytes: 1_255_000 },
+]
+
+export function workerBootChunkPlugin(closures: WorkerBootClosure[]): Plugin {
+  let closure: WorkerBootClosure | null = null
+  return {
+    name: 'sootsim-worker-boot-chunk',
+    apply: 'build',
+    options(inputOptions) {
+      const input = inputOptions.input
+      closure =
+        typeof input === 'string'
+          ? (closures.find((candidate) => input.includes(candidate.entry)) ?? null)
+          : null
+    },
+    outputOptions(options) {
+      if (!closure) return null
+      return { ...options, inlineDynamicImports: true }
+    },
+    generateBundle(_options, bundle) {
+      if (!closure) return
+      const chunks = Object.values(bundle).filter((output) => output.type === 'chunk')
+      if (chunks.length !== 1 || !chunks[0].isEntry) {
+        this.error(
+          `worker ${closure.entry}: expected one inlined chunk, got ${chunks.map((chunk) => chunk.fileName).join(', ')}`,
+        )
+      }
+      const bytes = Buffer.byteLength(chunks[0].code)
+      if (bytes > closure.maxBytes) {
+        this.error(
+          `worker ${closure.entry}: ${chunks[0].fileName} is ${bytes} bytes, over the ${closure.maxBytes} byte cap; raise the cap in the same change that grows the worker`,
+        )
+      }
+    },
+  }
+}
+
 // react-native-keyboard-controller is pure-JS for everything except its
 // native-event seam (`bindings.ts` / `bindings.native.ts`) and RN platform
 // `findNodeHandle` resolution. let upstream's components, hooks, animated