rnxsim 0.1.433 → 0.1.434

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.433 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.434 | (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;
@@ -189,7 +189,287 @@ function isDaemonLockfileFresh(lock, now = Date.now()) {
 // src/host/replacement-module-handler.ts
 var import_promises = __toESM(require("node:fs/promises"), 1);
 var import_node_path3 = __toESM(require("node:path"), 1);
-var import_esbuild = require("esbuild");
+
+// ../contrast-bundler/src/replacementModule.ts
+var import_dist = require("sucrase/dist/index.js");
+var import_parser = require("sucrase/dist/parser/index.js");
+var import_types = require("sucrase/dist/parser/tokenizer/types.js");
+
+// ../contrast-bundler/src/posixPath.ts
+var sep = "/";
+var delimiter = ":";
+function isAbsolute(p) {
+  return p.charCodeAt(0) === 47;
+}
+function normalizeSegments(parts, allowAboveRoot) {
+  const out = [];
+  for (const part of parts) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      if (out.length > 0 && out[out.length - 1] !== "..") out.pop();
+      else if (allowAboveRoot) out.push("..");
+      continue;
+    }
+    out.push(part);
+  }
+  return out;
+}
+function normalize(p) {
+  if (p.length === 0) return ".";
+  const absolute = isAbsolute(p);
+  const trailingSlash = p.charCodeAt(p.length - 1) === 47;
+  const segments = normalizeSegments(p.split("/"), !absolute);
+  let joined = segments.join("/");
+  if (joined.length === 0) {
+    if (absolute) return "/";
+    return trailingSlash ? "./" : ".";
+  }
+  if (trailingSlash) joined += "/";
+  return absolute ? "/" + joined : joined;
+}
+function join(...parts) {
+  const present = parts.filter((part) => part.length > 0);
+  if (present.length === 0) return ".";
+  return normalize(present.join("/"));
+}
+function resolve(...parts) {
+  let resolved = "";
+  let absolute = false;
+  for (let i = parts.length - 1; i >= 0 && !absolute; i--) {
+    const part = parts[i];
+    if (part.length === 0) continue;
+    resolved = resolved.length > 0 ? `${part}/${resolved}` : part;
+    absolute = isAbsolute(part);
+  }
+  if (!absolute)
+    throw new Error(
+      `posixPath.resolve needs an absolute segment, got: ${parts.join(", ")}`
+    );
+  const normalized = normalizeSegments(resolved.split("/"), false).join("/");
+  return normalized.length > 0 ? "/" + normalized : "/";
+}
+function dirname(p) {
+  const idx = p.lastIndexOf("/");
+  if (idx < 0) return ".";
+  if (idx === 0) return "/";
+  return p.slice(0, idx);
+}
+function basename(p, ext) {
+  const idx = p.lastIndexOf("/");
+  const base = idx < 0 ? p : p.slice(idx + 1);
+  if (ext != null && ext.length < base.length && base.endsWith(ext)) {
+    return base.slice(0, base.length - ext.length);
+  }
+  return base;
+}
+function extname(p) {
+  const base = basename(p);
+  const idx = base.lastIndexOf(".");
+  if (idx <= 0) return "";
+  return base.slice(idx);
+}
+function relative(from, to) {
+  if (from === to) return "";
+  const fromParts = normalizeSegments(from.split("/"), false);
+  const toParts = normalizeSegments(to.split("/"), false);
+  let shared = 0;
+  while (shared < fromParts.length && shared < toParts.length && fromParts[shared] === toParts[shared]) {
+    shared++;
+  }
+  const up = new Array(fromParts.length - shared).fill("..");
+  return [...up, ...toParts.slice(shared)].join("/");
+}
+var posix = {
+  sep,
+  delimiter,
+  isAbsolute,
+  normalize,
+  join,
+  resolve,
+  dirname,
+  basename,
+  extname,
+  relative
+};
+var posixPath_default = { ...posix, posix };
+
+// ../contrast-bundler/src/replacementModule.ts
+var REPLACEMENT_MODULE_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx"];
+var IMPORT_KEYWORD = import_types.TokenType["_import"];
+var EXPORT_KEYWORD = import_types.TokenType["_export"];
+var REACT_BRIDGE = "globalThis.__sootsim_react_bridge";
+var REACT_NATIVE_BRIDGE = "globalThis.__sootsim_components__";
+var PACKAGE_BRIDGES = "globalThis.__sootsim_config_package_modules";
+var JSX_RUNTIME_SPECIFIERS = /* @__PURE__ */ new Set(["react/jsx-runtime", "react/jsx-dev-runtime"]);
+function transformsFor(filePath) {
+  switch (extname(filePath).toLowerCase()) {
+    case ".ts":
+      return ["typescript"];
+    case ".tsx":
+      return ["typescript", "jsx"];
+    case ".js":
+    case ".jsx":
+      return ["jsx"];
+    default:
+      throw new Error(
+        `replacement files must be ${REPLACEMENT_MODULE_EXTENSIONS.join(", ")}`
+      );
+  }
+}
+function unsupportedSpecifier(specifier) {
+  return new Error(
+    `replacement modules may only import react, react-native, and the packages rnx stubs for this app; '${specifier}' is none of those. vendor the code into the replacement file, or add the package to rnx.config so the simulator bridges it.`
+  );
+}
+function bridgeDeclaration(name, specifier) {
+  const notReady = (what) => JSON.stringify(`[rnx] replacement ${what} bridge is not ready`);
+  if (specifier === "react") {
+    return `const ${name} = ${REACT_BRIDGE}; if (!${name}) throw new Error(${notReady("React")});`;
+  }
+  if (specifier === "react-native") {
+    return `const ${name} = ${REACT_NATIVE_BRIDGE}; if (!${name}) throw new Error(${notReady("React Native")});`;
+  }
+  if (JSX_RUNTIME_SPECIFIERS.has(specifier)) {
+    return `const ${name} = (() => { const react = ${REACT_BRIDGE}; if (!react) throw new Error(${notReady("React")}); const jsx = (type, props, key) => react.createElement(type, key === undefined ? props : { ...props, key }); return { Fragment: react.Fragment, jsx, jsxs: jsx, jsxDEV: jsx }; })();`;
+  }
+  return `const ${name} = (${PACKAGE_BRIDGES} || {})[${JSON.stringify(specifier)}]; if (!${name}) throw new Error(${JSON.stringify(`[rnx] replacement package bridge ${specifier} is not ready`)});`;
+}
+var DEFAULT_INTEROP = "__rnxReplacementDefault";
+var DEFAULT_INTEROP_DECLARATION = `const ${DEFAULT_INTEROP} = (bridge) => (bridge && bridge.__esModule ? bridge.default : bridge);`;
+function compileReplacementModule(input) {
+  const transformed = (0, import_dist.transform)(input.source, {
+    transforms: transformsFor(input.filePath),
+    filePath: input.filePath,
+    // classic runtime, matching what the app's own Metro build does for a file
+    // that has no automatic-runtime pragma: the file imports React itself.
+    jsxRuntime: "classic",
+    jsxPragma: "React.createElement",
+    jsxFragmentPragma: "React.Fragment",
+    production: true,
+    sourceMapOptions: { compiledFilename: input.filePath }
+  });
+  const code = transformed.code;
+  const sourceMap = transformed.sourceMap;
+  if (!sourceMap) throw new Error("sucrase compiled the replacement with no source map");
+  const { tokens } = (0, import_parser.parse)(code, false, false, false);
+  const read = (token) => code.slice(token.start, token.end);
+  const readSpecifier = (token) => {
+    if (token.type !== import_types.TokenType.string) {
+      throw new Error("replacement module import has no string specifier");
+    }
+    return code.slice(token.start + 1, token.end - 1);
+  };
+  const bridgeNames = /* @__PURE__ */ new Map();
+  const declarations = [];
+  let needsDefaultInterop = false;
+  const bridgeFor = (specifier) => {
+    const existing = bridgeNames.get(specifier);
+    if (existing) return existing;
+    const name = `__rnxReplacementBridge${bridgeNames.size}`;
+    bridgeNames.set(specifier, name);
+    declarations.push(bridgeDeclaration(name, specifier));
+    return name;
+  };
+  const edits = [];
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token.type === EXPORT_KEYWORD) {
+      const after2 = tokens[index + 1];
+      let fromAt = -1;
+      if (after2?.type === import_types.TokenType.star) {
+        fromAt = read(tokens[index + 2]) === "from" ? index + 2 : index + 4;
+      } else if (after2?.type === import_types.TokenType.braceL) {
+        let depth = 1;
+        let cursor2 = index + 2;
+        while (cursor2 < tokens.length && depth > 0) {
+          if (tokens[cursor2].type === import_types.TokenType.braceL) depth++;
+          else if (tokens[cursor2].type === import_types.TokenType.braceR) depth--;
+          cursor2++;
+        }
+        fromAt = cursor2;
+      }
+      if (fromAt > 0 && tokens[fromAt] && read(tokens[fromAt]) === "from" && tokens[fromAt + 1]?.type === import_types.TokenType.string) {
+        const specifier2 = readSpecifier(tokens[fromAt + 1]);
+        throw new Error(
+          `a replacement module cannot re-export from another module, and this one re-exports from '${specifier2}'. import what you need and export the binding.`
+        );
+      }
+      continue;
+    }
+    if (token.type !== IMPORT_KEYWORD) continue;
+    const after = tokens[index + 1];
+    if (!after || after.type === import_types.TokenType.parenL || after.type === import_types.TokenType.dot) continue;
+    const bindings = [];
+    let cursor = index + 1;
+    if (after.type !== import_types.TokenType.string) {
+      while (cursor < tokens.length) {
+        const clause = tokens[cursor];
+        if (clause.type === import_types.TokenType.name && read(clause) === "from") break;
+        if (clause.type === import_types.TokenType.comma) {
+          cursor++;
+          continue;
+        }
+        if (clause.type === import_types.TokenType.star) {
+          bindings.push({ local: read(tokens[cursor + 2]), imported: null });
+          cursor += 3;
+          continue;
+        }
+        if (clause.type === import_types.TokenType.braceL) {
+          cursor++;
+          while (cursor < tokens.length && tokens[cursor].type !== import_types.TokenType.braceR) {
+            if (tokens[cursor].type === import_types.TokenType.comma) {
+              cursor++;
+              continue;
+            }
+            const nameToken = tokens[cursor];
+            const imported = nameToken.type === import_types.TokenType.string ? readSpecifier(nameToken) : read(nameToken);
+            let local = imported;
+            if (tokens[cursor + 1] && read(tokens[cursor + 1]) === "as") {
+              local = read(tokens[cursor + 2]);
+              cursor += 2;
+            }
+            bindings.push({ local, imported });
+            cursor++;
+          }
+          cursor++;
+          continue;
+        }
+        bindings.push({ local: read(clause), imported: "default" });
+        cursor++;
+      }
+      cursor++;
+    }
+    const specifierToken = tokens[cursor];
+    if (!specifierToken) throw new Error("replacement module import is unterminated");
+    const specifier = readSpecifier(specifierToken);
+    if (specifier !== "react" && specifier !== "react-native" && !JSX_RUNTIME_SPECIFIERS.has(specifier) && !input.runtimePackages.has(specifier)) {
+      throw unsupportedSpecifier(specifier);
+    }
+    const bridge = bindings.length > 0 ? bridgeFor(specifier) : null;
+    const replacement = bindings.map((binding) => {
+      if (binding.imported === null) return `const ${binding.local} = ${bridge};`;
+      if (binding.imported === "default") {
+        needsDefaultInterop = true;
+        return `const ${binding.local} = ${DEFAULT_INTEROP}(${bridge});`;
+      }
+      return `const ${binding.local} = ${bridge}[${JSON.stringify(binding.imported)}];`;
+    }).join(" ");
+    const start = token.start;
+    const end = specifierToken.end;
+    const newlines = code.slice(start, end).split("\n").length - 1;
+    edits.push({ start, end, text: replacement + "\n".repeat(newlines) });
+  }
+  let out = code;
+  for (const edit of edits.reverse()) {
+    out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+  }
+  if (needsDefaultInterop) declarations.unshift(DEFAULT_INTEROP_DECLARATION);
+  const preamble = declarations.join(" ");
+  return {
+    code: preamble ? `${preamble} ${out}` : out,
+    sourceMap: { ...sourceMap, sourcesContent: [input.source] }
+  };
+}
 
 // src/backend-origin.ts
 function normalizeHostname(hostname) {
@@ -202,21 +482,6 @@ function isLoopbackHost(hostname) {
 
 // src/host/replacement-module-handler.ts
 var REPLACEMENT_MODULE_ROUTE = "/__sootsim-replacement-module";
-function getReplacementLoader(filePath) {
-  const ext = import_node_path3.default.extname(filePath).toLowerCase();
-  switch (ext) {
-    case ".js":
-      return "js";
-    case ".jsx":
-      return "jsx";
-    case ".ts":
-      return "ts";
-    case ".tsx":
-      return "tsx";
-    default:
-      return null;
-  }
-}
 function sendJavaScript(req, res, source) {
   const origin = req.headers.origin;
   let allowedOrigin;
@@ -270,10 +535,10 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     res.end("missing path param");
     return true;
   }
-  const loader = getReplacementLoader(targetPath);
-  if (!loader) {
+  const extension = import_node_path3.default.extname(targetPath).toLowerCase();
+  if (!REPLACEMENT_MODULE_EXTENSIONS.some((allowed) => allowed === extension)) {
     res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
-    res.end("replacement files must be .js, .jsx, .ts, or .tsx");
+    res.end(`replacement files must be ${REPLACEMENT_MODULE_EXTENSIONS.join(", ")}`);
     return true;
   }
   if (!import_node_path3.default.isAbsolute(targetPath)) {
@@ -311,81 +576,23 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     }
   }
   try {
-    const result = await (0, import_esbuild.build)({
-      entryPoints: [resolvedTargetPath],
-      bundle: true,
-      write: false,
-      format: "esm",
-      platform: "browser",
-      target: "es2022",
-      jsx: "transform",
-      jsxFactory: "React.createElement",
-      jsxFragment: "React.Fragment",
-      tsconfigRaw: { compilerOptions: { jsx: "react" } },
-      sourcemap: "inline",
-      logLevel: "silent",
-      plugins: [
-        {
-          name: "sootsim-replacement-runtime",
-          setup(runtimeBuild) {
-            runtimeBuild.onResolve(
-              {
-                filter: /^(react|react-native|react\/jsx-runtime|react\/jsx-dev-runtime)$/
-              },
-              (args) => ({ path: args.path, namespace: "sootsim-replacement-runtime" })
-            );
-            runtimeBuild.onResolve(
-              { filter: /.*/ },
-              (args) => runtimePackages.has(args.path) ? { path: args.path, namespace: "sootsim-replacement-runtime" } : void 0
-            );
-            runtimeBuild.onLoad(
-              { filter: /.*/, namespace: "sootsim-replacement-runtime" },
-              (args) => {
-                if (args.path === "react-native") {
-                  return {
-                    contents: `const bridge = globalThis.__sootsim_components__
-if (!bridge) throw new Error('[rnx] replacement React Native bridge is not ready')
-module.exports = bridge`,
-                    loader: "js"
-                  };
-                }
-                if (args.path === "react") {
-                  return {
-                    contents: `const bridge = globalThis.__sootsim_react_bridge
-if (!bridge) throw new Error('[rnx] replacement React bridge is not ready')
-module.exports = bridge`,
-                    loader: "js"
-                  };
-                }
-                if (args.path !== "react/jsx-runtime" && args.path !== "react/jsx-dev-runtime") {
-                  return {
-                    contents: `const packages = globalThis.__sootsim_config_package_modules
-const bridge = packages?.[${JSON.stringify(args.path)}]
-if (!bridge) throw new Error(${JSON.stringify(`[rnx] replacement package bridge ${args.path} is not ready`)})
-module.exports = bridge`,
-                    loader: "js"
-                  };
-                }
-                return {
-                  contents: `const React = globalThis.__sootsim_react_bridge
-if (!React) throw new Error('[rnx] replacement React bridge is not ready')
-exports.Fragment = React.Fragment
-exports.jsx = (type, props, key) => React.createElement(type, key === undefined ? props : { ...props, key })
-exports.jsxs = exports.jsx
-exports.jsxDEV = exports.jsx`,
-                  loader: "js"
-                };
-              }
-            );
-          }
-        }
-      ]
+    const compiled = compileReplacementModule({
+      filePath: resolvedTargetPath,
+      source: await import_promises.default.readFile(resolvedTargetPath, "utf8"),
+      runtimePackages
     });
-    sendJavaScript(req, res, result.outputFiles[0]?.text ?? "");
+    const map = Buffer.from(JSON.stringify(compiled.sourceMap), "utf8").toString("base64");
+    sendJavaScript(
+      req,
+      res,
+      `${compiled.code}
+//# sourceMappingURL=data:application/json;base64,${map}
+`
+    );
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
-    res.end(`replacement bundle failed: ${message}`);
+    res.end(`replacement compile failed: ${message}`);
   }
   return true;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rnxsim",
-  "version": "0.1.433",
+  "version": "0.1.434",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for rnx.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",
@@ -231,9 +231,9 @@
   },
   "dependencies": {
     "@expo/plist": "^0.5.4",
-    "esbuild": "^0.25.0",
     "jiti": "2.7.0",
     "playwright-core": "1.61.0",
+    "sucrase": "3.35.1",
     "terser": "^5.49.0",
     "ws": "^8.18.0"
   },

package/src/bridge-contract.ts

@@ -38,6 +38,7 @@ export type BridgeCommandType =
   | 'reset'
   | 'camera'
   | 'diagnostics'
+  | 'storageSnapshot'
 
 export interface WsCommand {
   id: string | number
@@ -90,6 +91,11 @@ export interface WsCommand {
   // diagnostics — read-only engine debug state: channel recording, the sheet /
   // portal / boundary finders, and the recent event ring.
   diagnostics?: DiagnosticsOptions
+  // storageSnapshot — the running app's own storage and route, as
+  // `StorageSnapshot` from the engine's preview/storage-snapshot module. the
+  // default result is share-safe; `includeCredentials` carries the signed-in
+  // session and belongs only to a send to the owner's own box.
+  storageSnapshotOptions?: { includeCredentials?: boolean }
 }
 
 // ---------------------------------------------------------------------------

package/src/host/bridge-host.ts

@@ -33,6 +33,7 @@ import {
   type DevBridgeLockfile,
   type SharedConfig,
 } from '../home-paths.ts'
+import { rnxPublicBrand } from '../public-brand.ts'
 import {
   isRuntimeVersionHostname,
   resolveDevCheckoutRuntimeRoot,
@@ -1651,6 +1652,82 @@ export class SootSimBridgeHost {
       return
     }
 
+    // /__send-to-box — the rail button. the shell cannot create a cloud box
+    // itself: the account credential lives on this machine, not in the page.
+    // it sits above the read-only guard below because it is a POST.
+    if (url.pathname === '/__send-to-box') {
+      res.setHeader('Access-Control-Allow-Origin', '*')
+      res.setHeader('Access-Control-Allow-Headers', 'Content-Type')
+      res.setHeader('Cache-Control', 'no-store')
+      if (method === 'OPTIONS') {
+        res.writeHead(204, { Allow: 'POST, OPTIONS' })
+        res.end()
+        return
+      }
+      if (method !== 'POST') {
+        res.writeHead(405, { Allow: 'POST, OPTIONS' })
+        res.end('method not allowed')
+        return
+      }
+      void (async () => {
+        try {
+          const chunks: Buffer[] = []
+          for await (const chunk of req) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))
+          }
+          const text = Buffer.concat(chunks).toString('utf8').trim()
+          const parsed: unknown = text ? JSON.parse(text) : {}
+          if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('send to box needs a json object body')
+          }
+          const body: Record<string, unknown> = { ...parsed }
+          const { CHOOSE_ACCOUNT_HINT, resolveCliAuth, authHeaderValue } =
+            await import('../../cli/auth.ts')
+          const auth = resolveCliAuth()
+          if (!auth) {
+            res.writeHead(401, { 'Content-Type': 'application/json' })
+            res.end(
+              JSON.stringify({
+                error: `send to box needs an account: run \`${rnxPublicBrand.commandName} login\` in this checkout`,
+              }),
+            )
+            return
+          }
+          // the CLI would exit the process here; a daemon serving the rail
+          // answers the button instead.
+          const accountId = auth.kind === 'session' ? auth.accountId : null
+          if (auth.kind === 'session' && accountId === null) {
+            res.writeHead(400, { 'Content-Type': 'application/json' })
+            res.end(JSON.stringify({ error: CHOOSE_ACCOUNT_HINT }))
+            return
+          }
+          const { sendToBox } = await import('../../cli/send-to-box.ts')
+          const result = await sendToBox({
+            send: (command) =>
+              this.sendCommand({
+                ...command,
+                simId: typeof command.simId === 'string' ? command.simId : undefined,
+              }),
+            authorization: authHeaderValue(auth),
+            accountId,
+            carryAuth: body.carryAuth !== false,
+            boxName: typeof body.boxName === 'string' ? body.boxName : null,
+            simId: typeof body.simId === 'string' ? body.simId : undefined,
+          })
+          res.writeHead(200, { 'Content-Type': 'application/json' })
+          res.end(JSON.stringify(result))
+        } catch (error) {
+          res.writeHead(500, { 'Content-Type': 'application/json' })
+          res.end(
+            JSON.stringify({
+              error: error instanceof Error ? error.message : String(error),
+            }),
+          )
+        }
+      })()
+      return
+    }
+
     // /__camera-fixtures/<name> — the staged video behind `rnx camera play`.
     // the shell page is a different origin from this daemon (vite dev on 5173,
     // daemon on 7668+), and the camera pipeline draws the <video> to a canvas
@@ -2568,6 +2645,8 @@ export class SootSimBridgeHost {
         return msg?.action === 'type' ? 'typed text' : 'used keyboard'
       case 'tree':
         return 'dumped tree'
+      case 'storageSnapshot':
+        return 'dumped storage snapshot'
       case 'query':
         return 'queried semantic tree'
       case 'resolve':