rnxsim 0.0.0 → 0.1.313

package/dist-lib/metro.cjs

@@ -0,0 +1,297 @@
+/*! rnx v0.1.313 | (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;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/metro-plugin.ts
+var metro_plugin_exports = {};
+__export(metro_plugin_exports, {
+  default: () => metro_plugin_default,
+  withSootsim: () => withSootsim
+});
+module.exports = __toCommonJS(metro_plugin_exports);
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+
+// src/runtime-assets.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_url = require("url");
+
+// ../contrast-runtime-delivery/src/product.ts
+function isValidRuntimeVersion(value) {
+  return value.length <= 100 && /^[0-9A-Za-z][0-9A-Za-z._+-]*$/.test(value);
+}
+
+// src/home-paths.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"), 1);
+var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
+var ACTIVE_RUNTIME_FILE = "active";
+function sootsimHomeDir() {
+  const override = process.env[SOOTSIM_HOME_ENV];
+  if (override && override.length > 0) return import_node_path.default.resolve(override);
+  return import_node_path.default.join((0, import_node_os.homedir)(), ".sootsim");
+}
+function runtimesDir() {
+  return import_node_path.default.join(sootsimHomeDir(), "runtimes");
+}
+function runtimeDir(version) {
+  return import_node_path.default.join(runtimesDir(), version);
+}
+function activeRuntimeFile() {
+  return import_node_path.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+}
+function readActiveRuntime() {
+  try {
+    const value = import_node_fs.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+
+// src/runtime-assets.ts
+var SOOTSIM_RUNTIME_MISSING_MESSAGE = "[rnx] no engine runtime installed \u2014 run `rnxsim setup`, or `rnxsim runtime install`";
+var _monorepoRootCache;
+function findMonorepoRoot() {
+  if (_monorepoRootCache !== void 0) return _monorepoRootCache;
+  let dir = import_path.default.dirname((0, import_url.fileURLToPath)(__sootsim_import_meta_url));
+  for (let i = 0; i < 12 && dir !== import_path.default.dirname(dir); i++) {
+    if (import_fs.default.existsSync(import_path.default.join(dir, "packages/sootsim-engine/package.json")) && import_fs.default.existsSync(import_path.default.join(dir, "public/sootsim"))) {
+      _monorepoRootCache = dir;
+      return dir;
+    }
+    dir = import_path.default.dirname(dir);
+  }
+  _monorepoRootCache = null;
+  return null;
+}
+function resolveDevCheckoutRuntimeRoot() {
+  if (process.env.SOOTSIM_HOME && readActiveRuntime()) return null;
+  const root = findMonorepoRoot();
+  if (!root) return null;
+  const devBuild = import_path.default.join(root, "public/sootsim");
+  if (import_fs.default.existsSync(import_path.default.join(devBuild, "index.html")) && import_fs.default.existsSync(import_path.default.join(devBuild, "engine/index.html")) && import_fs.default.existsSync(import_path.default.join(devBuild, "engine-tenant/worker.js"))) {
+    return devBuild;
+  }
+  return null;
+}
+var MIME_TYPES = {
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".css": "text/css",
+  ".html": "text/html",
+  ".wasm": "application/wasm",
+  ".json": "application/json",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".glb": "model/gltf-binary",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav"
+};
+var ROOT_RUNTIME_PATHS = [
+  "/assets/",
+  "/engine/",
+  "/engine-tenant/",
+  "/photos/",
+  "/three-mode/",
+  "/fonts/",
+  "/icons/",
+  "/sounds/",
+  "/spike/",
+  "/test-wallpaper.jpg",
+  "/preview-sw.js",
+  "/sootsim.svg"
+];
+function resolveActiveRuntimeRoot() {
+  const devRoot = resolveDevCheckoutRuntimeRoot();
+  if (devRoot) return devRoot;
+  const active = readActiveRuntime();
+  if (!active) return null;
+  const dir = runtimeDir(active);
+  if (!import_fs.default.existsSync(import_path.default.join(dir, "index.html"))) return null;
+  return dir;
+}
+var RUNTIME_VERSION_HOSTNAME_SUFFIX = ".runtime.localhost";
+function isRuntimeVersionHostname(hostname) {
+  return hostname.toLowerCase().endsWith(RUNTIME_VERSION_HOSTNAME_SUFFIX);
+}
+function runtimeVersionFromHostname(hostname) {
+  if (!isRuntimeVersionHostname(hostname)) return null;
+  const labels = hostname.slice(0, -RUNTIME_VERSION_HOSTNAME_SUFFIX.length).split(".");
+  if (labels.length === 0 || labels.some((label) => !/^[0-9a-f]{1,60}$/i.test(label))) {
+    return null;
+  }
+  const encoded = labels.join("");
+  if (encoded.length % 2 !== 0) return null;
+  try {
+    const version = Buffer.from(encoded, "hex").toString("utf8");
+    return isValidRuntimeVersion(version) ? version : null;
+  } catch {
+    return null;
+  }
+}
+function resolveInstalledRuntimeRoot(version) {
+  const dir = runtimeDir(version);
+  if (!import_fs.default.existsSync(import_path.default.join(dir, "index.html"))) return null;
+  return dir;
+}
+function resolveRuntimeRootForHostname(hostname) {
+  if (!isRuntimeVersionHostname(hostname)) return resolveActiveRuntimeRoot();
+  const version = runtimeVersionFromHostname(hostname);
+  return version ? resolveInstalledRuntimeRoot(version) : null;
+}
+function resolveRuntimeRootForRequestHost(host) {
+  if (!host) return resolveActiveRuntimeRoot();
+  try {
+    return resolveRuntimeRootForHostname(new URL(`http://${host}`).hostname);
+  } catch {
+    return null;
+  }
+}
+function isRootRuntimeAssetPath(pathname) {
+  return ROOT_RUNTIME_PATHS.some((p) => pathname === p || pathname.startsWith(p));
+}
+function resolveRuntimeFilePath(runtimeRoot, pathname) {
+  if (!pathname.startsWith("/")) return null;
+  if (pathname.includes("\0") || pathname.includes("\\")) return null;
+  for (const segment of pathname.split("/")) {
+    if (segment === "..") return null;
+  }
+  const fullPath = import_path.default.resolve(runtimeRoot, pathname.replace(/^\/+/, ""));
+  const rootWithSep = runtimeRoot.endsWith(import_path.default.sep) ? runtimeRoot : runtimeRoot + import_path.default.sep;
+  if (!fullPath.startsWith(rootWithSep) && fullPath !== runtimeRoot) return null;
+  if (!import_fs.default.existsSync(fullPath) || !import_fs.default.statSync(fullPath).isFile()) return null;
+  return fullPath;
+}
+function serveRuntimeFile(req, res, fullPath) {
+  const ext = import_path.default.extname(fullPath);
+  const stat = import_fs.default.statSync(fullPath);
+  const lastModified = stat.mtime.toUTCString();
+  res.setHeader("content-type", MIME_TYPES[ext] || "application/octet-stream");
+  res.setHeader("cache-control", "no-cache");
+  res.setHeader("last-modified", lastModified);
+  if (req?.headers?.["if-modified-since"] === lastModified) {
+    res.statusCode = 304;
+    res.end();
+    return;
+  }
+  import_fs.default.createReadStream(fullPath).pipe(res);
+}
+
+// src/metro-plugin.ts
+var prefix = "/__soot";
+function withSootsim(config, options = {}) {
+  if (options.enabled === false) return config;
+  const bundleUrl = options.bundleUrl || "/index.bundle?platform=ios&dev=true&hot=true&minify=false";
+  const cfgServer = config.server;
+  const existingEnhance = cfgServer?.enhanceMiddleware;
+  const serverConfig = {
+    ...cfgServer,
+    enhanceMiddleware: (metroMiddleware, metroServer) => {
+      let middleware = metroMiddleware;
+      if (existingEnhance) {
+        middleware = existingEnhance(metroMiddleware, metroServer);
+      }
+      let connect;
+      try {
+        connect = require("connect");
+      } catch {
+        console.warn("[rnx] connect not available");
+        return middleware;
+      }
+      const server = connect();
+      server.use((req, res, next) => {
+        const url = req.url || "";
+        const pathname = url.split("?")[0];
+        const runtimeRoot = resolveRuntimeRootForRequestHost(req.headers?.host);
+        if (!runtimeRoot) {
+          if (pathname === prefix || pathname === prefix + "/") {
+            res.statusCode = 500;
+            res.end(SOOTSIM_RUNTIME_MISSING_MESSAGE);
+            return;
+          }
+          next();
+          return;
+        }
+        if (isRootRuntimeAssetPath(pathname)) {
+          const fullPath = resolveRuntimeFilePath(runtimeRoot, pathname);
+          if (fullPath) {
+            serveRuntimeFile(req, res, fullPath);
+            return;
+          }
+        }
+        if (pathname.startsWith(prefix + "/")) {
+          const fullPath = resolveRuntimeFilePath(
+            runtimeRoot,
+            pathname.slice(prefix.length)
+          );
+          if (fullPath) {
+            serveRuntimeFile(req, res, fullPath);
+            return;
+          }
+        }
+        if (pathname === prefix || pathname === prefix + "/" || pathname.startsWith(prefix + "/")) {
+          const ext = import_path2.default.extname(pathname);
+          if (!ext) {
+            const htmlPath = import_path2.default.join(runtimeRoot, "index.html");
+            let html = import_fs2.default.readFileSync(htmlPath, "utf8");
+            html = html.replace(
+              "</head>",
+              `<script>history.replaceState(null,'','${prefix}/?bundle=${encodeURIComponent(bundleUrl)}')</script></head>`
+            );
+            res.setHeader("content-type", "text/html");
+            res.end(html);
+            return;
+          }
+        }
+        next();
+      });
+      server.use(middleware);
+      console.log(`[rnx] serving at ${prefix}/`);
+      return server;
+    }
+  };
+  return { ...config, server: serverConfig };
+}
+var metro_plugin_default = withSootsim;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withSootsim
+});

package/dist-lib/profiles.cjs

@@ -0,0 +1,246 @@
+/*! rnx v0.1.313 | (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;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/profiles.ts
+var profiles_exports = {};
+__export(profiles_exports, {
+  DEFAULT_PROFILE_ID: () => DEFAULT_PROFILE_ID,
+  clearProfileStorage: () => clearProfileStorage,
+  createProfile: () => createProfile,
+  deleteProfile: () => deleteProfile,
+  electronProfilePartition: () => electronProfilePartition,
+  electronProfilePartitionDir: () => electronProfilePartitionDir,
+  electronProfilePartitionName: () => electronProfilePartitionName,
+  ensureProfile: () => ensureProfile,
+  getProfile: () => getProfile,
+  listProfiles: () => listProfiles,
+  nextGeneratedProfileId: () => nextGeneratedProfileId,
+  normalizeProfileId: () => normalizeProfileId,
+  playwrightProfileUserDataDir: () => playwrightProfileUserDataDir,
+  profileIndexPath: () => profileIndexPath
+});
+module.exports = __toCommonJS(profiles_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+
+// src/home-paths.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"), 1);
+var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
+function sootsimHomeDir() {
+  const override = process.env[SOOTSIM_HOME_ENV];
+  if (override && override.length > 0) return import_node_path.default.resolve(override);
+  return import_node_path.default.join((0, import_node_os.homedir)(), ".sootsim");
+}
+function runtimesDir() {
+  return import_node_path.default.join(sootsimHomeDir(), "runtimes");
+}
+function electronDir() {
+  return import_node_path.default.join(sootsimHomeDir(), "electron");
+}
+function electronUserDataDir() {
+  return import_node_path.default.join(electronDir(), "userData");
+}
+function profilesDir() {
+  return import_node_path.default.join(sootsimHomeDir(), "profiles");
+}
+function cacheDir() {
+  return import_node_path.default.join(sootsimHomeDir(), "cache");
+}
+function ensureSootsimHome() {
+  import_node_fs.default.mkdirSync(sootsimHomeDir(), { recursive: true });
+  import_node_fs.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs.default.mkdirSync(electronDir(), { recursive: true });
+  import_node_fs.default.mkdirSync(profilesDir(), { recursive: true });
+  import_node_fs.default.mkdirSync(cacheDir(), { recursive: true });
+}
+var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+
+// src/profiles.ts
+var DEFAULT_PROFILE_ID = "default";
+var PROFILE_INDEX_FILE = "profiles.json";
+var PROFILE_INDEX_VERSION = 1;
+function normalizeProfileId(input) {
+  const id = input.trim();
+  if (!id) throw new Error("profile id is required");
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(id)) {
+    throw new Error(
+      "profile ids must start with a letter or number and contain only letters, numbers, dot, dash, or underscore"
+    );
+  }
+  if (id === "." || id === "..") throw new Error(`invalid profile id: ${id}`);
+  return id;
+}
+function profileIndexPath() {
+  return import_path.default.join(profilesDir(), PROFILE_INDEX_FILE);
+}
+function electronProfilePartitionName(profileId) {
+  return `sootsim-profile-${normalizeProfileId(profileId)}`;
+}
+function electronProfilePartition(profileId) {
+  return `persist:${electronProfilePartitionName(profileId)}`;
+}
+function electronProfilePartitionDir(profileId) {
+  return import_path.default.join(
+    electronUserDataDir(),
+    "Partitions",
+    electronProfilePartitionName(profileId)
+  );
+}
+function playwrightProfileUserDataDir(profileId) {
+  return import_path.default.join(profilesDir(), "playwright", normalizeProfileId(profileId));
+}
+function readIndexRaw() {
+  try {
+    const parsed = JSON.parse(
+      import_fs.default.readFileSync(profileIndexPath(), "utf8")
+    );
+    if (!parsed || parsed.version !== PROFILE_INDEX_VERSION) {
+      return { version: PROFILE_INDEX_VERSION, profiles: [] };
+    }
+    const profiles = Array.isArray(parsed.profiles) ? parsed.profiles.filter(
+      (profile) => !!profile && typeof profile.id === "string" && typeof profile.createdAt === "string" && typeof profile.updatedAt === "string"
+    ).map((profile) => ({
+      id: normalizeProfileId(profile.id),
+      createdAt: profile.createdAt,
+      updatedAt: profile.updatedAt
+    })) : [];
+    return { version: PROFILE_INDEX_VERSION, profiles };
+  } catch {
+    return { version: PROFILE_INDEX_VERSION, profiles: [] };
+  }
+}
+function sortProfiles(profiles) {
+  return [...profiles].sort((a, b) => {
+    if (a.id === DEFAULT_PROFILE_ID) return -1;
+    if (b.id === DEFAULT_PROFILE_ID) return 1;
+    return a.id.localeCompare(b.id);
+  });
+}
+function withDefault(index) {
+  if (index.profiles.some((profile) => profile.id === DEFAULT_PROFILE_ID)) {
+    return { ...index, profiles: sortProfiles(index.profiles) };
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: PROFILE_INDEX_VERSION,
+    profiles: sortProfiles([
+      { id: DEFAULT_PROFILE_ID, createdAt: now, updatedAt: now },
+      ...index.profiles
+    ])
+  };
+}
+function writeIndex(index) {
+  ensureSootsimHome();
+  const next = withDefault(index);
+  const tmp = `${profileIndexPath()}.tmp`;
+  import_fs.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  import_fs.default.renameSync(tmp, profileIndexPath());
+  return next;
+}
+function listProfiles() {
+  return writeIndex(readIndexRaw()).profiles;
+}
+function getProfile(id) {
+  const normalized = normalizeProfileId(id);
+  return listProfiles().find((profile) => profile.id === normalized) ?? null;
+}
+function ensureProfile(id = DEFAULT_PROFILE_ID) {
+  const normalized = normalizeProfileId(id);
+  const existing = getProfile(normalized);
+  if (existing) return existing;
+  return createProfile(normalized);
+}
+function createProfile(id) {
+  const normalized = normalizeProfileId(id);
+  const index = withDefault(readIndexRaw());
+  if (index.profiles.some((profile2) => profile2.id === normalized)) {
+    throw new Error(`profile already exists: ${normalized}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const profile = { id: normalized, createdAt: now, updatedAt: now };
+  writeIndex({ version: PROFILE_INDEX_VERSION, profiles: [...index.profiles, profile] });
+  return profile;
+}
+function nextGeneratedProfileId() {
+  const existing = new Set(listProfiles().map((profile) => profile.id));
+  for (let i = 1; i < 1e4; i++) {
+    const id = `profile-${i}`;
+    if (!existing.has(id)) return id;
+  }
+  throw new Error("could not allocate a new profile id");
+}
+function deleteProfile(id) {
+  const normalized = normalizeProfileId(id);
+  if (normalized === DEFAULT_PROFILE_ID) {
+    throw new Error("the default profile cannot be deleted; clear it instead");
+  }
+  const index = withDefault(readIndexRaw());
+  const profile = index.profiles.find((entry) => entry.id === normalized);
+  if (!profile) throw new Error(`profile not found: ${normalized}`);
+  writeIndex({
+    version: PROFILE_INDEX_VERSION,
+    profiles: index.profiles.filter((entry) => entry.id !== normalized)
+  });
+  clearProfileStorage(normalized);
+  return profile;
+}
+function clearProfileStorage(id) {
+  const normalized = normalizeProfileId(id);
+  for (const dir of [
+    electronProfilePartitionDir(normalized),
+    playwrightProfileUserDataDir(normalized)
+  ]) {
+    try {
+      import_fs.default.rmSync(dir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PROFILE_ID,
+  clearProfileStorage,
+  createProfile,
+  deleteProfile,
+  electronProfilePartition,
+  electronProfilePartitionDir,
+  electronProfilePartitionName,
+  ensureProfile,
+  getProfile,
+  listProfiles,
+  nextGeneratedProfileId,
+  normalizeProfileId,
+  playwrightProfileUserDataDir,
+  profileIndexPath
+});

package/dist-lib/public-brand.cjs

@@ -0,0 +1,39 @@
+/*! rnx v0.1.313 | (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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/public-brand.ts
+var public_brand_exports = {};
+__export(public_brand_exports, {
+  rnxPublicBrand: () => rnxPublicBrand
+});
+module.exports = __toCommonJS(public_brand_exports);
+var name = "rnx";
+var rnxPublicBrand = Object.freeze({
+  name,
+  packageName: "rnxsim",
+  commandName: "rnxsim",
+  domain: "rnxsim.com",
+  origin: "https://rnxsim.com"
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rnxPublicBrand
+});

package/dist-lib/render-mode.cjs

@@ -0,0 +1,54 @@
+/*! rnx v0.1.313 | (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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/render-mode.ts
+var render_mode_exports = {};
+__export(render_mode_exports, {
+  getRenderMode: () => getRenderMode,
+  hasRenderWorkerBootstrap: () => hasRenderWorkerBootstrap,
+  isRenderMainMode: () => isRenderMainMode,
+  isRenderWorkerMode: () => isRenderWorkerMode,
+  shouldEnableRenderWorker: () => shouldEnableRenderWorker
+});
+module.exports = __toCommonJS(render_mode_exports);
+function getRenderMode(_searchParams) {
+  return "worker";
+}
+function isRenderWorkerMode(_searchParams) {
+  return true;
+}
+function isRenderMainMode(_searchParams) {
+  return false;
+}
+function hasRenderWorkerBootstrap(workerModuleBaseUrl) {
+  return typeof workerModuleBaseUrl === "string" && workerModuleBaseUrl.length > 0;
+}
+function shouldEnableRenderWorker(_searchParams, workerModuleBaseUrl) {
+  return hasRenderWorkerBootstrap(workerModuleBaseUrl);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRenderMode,
+  hasRenderWorkerBootstrap,
+  isRenderMainMode,
+  isRenderWorkerMode,
+  shouldEnableRenderWorker
+});