peachsim 0.1.527

package/dist-lib/metro.cjs

@@ -0,0 +1,904 @@
+/*! rnx v0.1.527 | (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,
+  toRNXDevelopmentBundleUrl: () => toRNXDevelopmentBundleUrl,
+  toRNXProductionBundleUrl: () => toRNXProductionBundleUrl,
+  withRNX: () => withRNX
+});
+module.exports = __toCommonJS(metro_plugin_exports);
+var import_fs2 = __toESM(require("fs"), 1);
+var import_module = require("module");
+var import_node_crypto2 = require("node:crypto");
+var import_path2 = __toESM(require("path"), 1);
+
+// src/dev-server-open.ts
+var import_node_crypto = require("node:crypto");
+var import_node_fs = __toESM(require("node:fs"), 1);
+function tagRnxBundleForPlugin(bundleUrl, replacementOrigin, replacementToken, projectRoot, appName) {
+  const absolute = /^[a-z][a-z\d+.-]*:\/\//i.test(bundleUrl);
+  const url = new URL(bundleUrl, absolute ? void 0 : "http://rnx.local");
+  if (appName) {
+    url.searchParams.set("rnxAppName", appName);
+    url.searchParams.set(
+      "rnxProjectId",
+      (0, import_node_crypto.createHash)("sha256").update(import_node_fs.default.realpathSync(projectRoot)).digest("hex").slice(0, 32)
+    );
+  }
+  url.searchParams.set("rnxReplacementOrigin", replacementOrigin);
+  url.searchParams.set("rnxReplacementToken", replacementToken);
+  return absolute ? url.toString() : `${url.pathname}${url.search}${url.hash}`;
+}
+
+// src/host/replacement-module-handler.ts
+var import_promises = __toESM(require("node:fs/promises"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+
+// ../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 isContrastKitSpecifier(specifier) {
+  return specifier === "contrast-kit" || specifier.startsWith("contrast-kit/");
+}
+function unsupportedSpecifier(specifier) {
+  return new Error(
+    `replacement modules may only import react, react-native, contrast-kit, 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 (isContrastKitSpecifier(specifier)) {
+    return `const ${name} = (globalThis.__contrast_kit_modules && globalThis.__contrast_kit_modules[${JSON.stringify(specifier)}]) || (${PACKAGE_BRIDGES} || {})[${JSON.stringify(specifier)}]; if (!${name}) throw new Error(${JSON.stringify(`[rnx] replacement package bridge ${specifier} is not ready`)});`;
+  }
+  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) && !isContrastKitSpecifier(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) {
+  return hostname.replace(/^\[|\]$/g, "").toLowerCase();
+}
+function isLoopbackHost(hostname) {
+  const normalized = normalizeHostname(hostname);
+  return normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "0.0.0.0" || normalized === "::1" || /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}
+
+// src/host/replacement-module-handler.ts
+var REPLACEMENT_MODULE_ROUTE = "/__sootsim-replacement-module";
+function sendJavaScript(req, res, source) {
+  const origin = req.headers.origin;
+  let allowedOrigin;
+  if (origin) {
+    try {
+      if (isLoopbackHost(new URL(origin).hostname)) allowedOrigin = origin;
+    } catch {
+    }
+  }
+  res.writeHead(200, {
+    "Content-Type": "application/javascript; charset=utf-8",
+    "Cache-Control": "no-cache",
+    ...allowedOrigin ? { "Access-Control-Allow-Origin": allowedOrigin, Vary: "Origin" } : {}
+  });
+  res.end(req.method === "HEAD" ? void 0 : source);
+}
+function isReplacementModuleRequestUrl(rawUrl) {
+  if (!rawUrl) return false;
+  try {
+    const pathname = new URL(rawUrl, "http://rnx.local").pathname;
+    return pathname === REPLACEMENT_MODULE_ROUTE;
+  } catch {
+    return false;
+  }
+}
+async function handleReplacementModuleRequest(req, res, options = {}) {
+  const rawUrl = req.url || "";
+  let url;
+  try {
+    url = new URL(rawUrl, "http://rnx.local");
+  } catch {
+    return false;
+  }
+  if (options.requireLoopbackOrigin) {
+    const origin = req.headers.origin;
+    const remoteAddress = req.socket.remoteAddress?.replace(/^::ffff:/, "");
+    let allowed = Boolean(remoteAddress && isLoopbackHost(remoteAddress));
+    if (allowed && origin) {
+      try {
+        allowed = isLoopbackHost(new URL(origin).hostname);
+      } catch {
+        allowed = false;
+      }
+    }
+    if (!allowed) {
+      res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("replacement modules are available only to loopback origins");
+      return true;
+    }
+  }
+  if (url.pathname !== REPLACEMENT_MODULE_ROUTE) return false;
+  if (options.requestToken && url.searchParams.get("token") !== options.requestToken) {
+    res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("replacement module request token is invalid");
+    return true;
+  }
+  const targetPath = url.searchParams.get("path");
+  if (!targetPath) {
+    res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("missing path param");
+    return true;
+  }
+  const extension = import_node_path.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 ${REPLACEMENT_MODULE_EXTENSIONS.join(", ")}`);
+    return true;
+  }
+  if (!import_node_path.default.isAbsolute(targetPath)) {
+    res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("replacement file path must be absolute");
+    return true;
+  }
+  const runtimePackages = new Set(url.searchParams.getAll("runtimePackage"));
+  let resolvedProjectRoot;
+  if (options.projectRoot) {
+    const lexicalProjectRoot = import_node_path.default.resolve(options.projectRoot);
+    resolvedProjectRoot = await import_promises.default.realpath(options.projectRoot);
+    const lexicalTarget = import_node_path.default.relative(lexicalProjectRoot, targetPath);
+    if (lexicalTarget.startsWith("..") || import_node_path.default.isAbsolute(lexicalTarget)) {
+      res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("replacement file must be inside the project root");
+      return true;
+    }
+  }
+  let resolvedTargetPath;
+  try {
+    resolvedTargetPath = await import_promises.default.realpath(targetPath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end(`replacement file not found: ${message}`);
+    return true;
+  }
+  if (resolvedProjectRoot) {
+    const relativeTarget = import_node_path.default.relative(resolvedProjectRoot, resolvedTargetPath);
+    if (relativeTarget.startsWith("..") || import_node_path.default.isAbsolute(relativeTarget)) {
+      res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("replacement file must be inside the project root");
+      return true;
+    }
+  }
+  try {
+    const compiled = compileReplacementModule({
+      filePath: resolvedTargetPath,
+      source: await import_promises.default.readFile(resolvedTargetPath, "utf8"),
+      runtimePackages
+    });
+    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 compile failed: ${message}`);
+  }
+  return true;
+}
+
+// src/metro-production-bundle.ts
+var RNXSIM_METRO_MODULE_PATHS_PREFIX = "globalThis.__sootsimModulePaths=";
+var RNX_METRO_MODULE_IDENTITY_VERSION = 2;
+function toRNXProductionBundleUrl(bundleUrl) {
+  const relative2 = bundleUrl.startsWith("/");
+  const url = new URL(bundleUrl, "http://rnxsim.local");
+  url.searchParams.set("dev", "false");
+  url.searchParams.set("hot", "false");
+  url.searchParams.set("minify", "true");
+  return relative2 ? `${url.pathname}${url.search}${url.hash}` : url.toString();
+}
+function toRNXDevelopmentBundleUrl(bundleUrl) {
+  const relative2 = bundleUrl.startsWith("/");
+  const url = new URL(bundleUrl, "http://rnxsim.local");
+  url.searchParams.set("dev", "true");
+  url.searchParams.set("hot", "false");
+  url.searchParams.set("minify", "false");
+  return relative2 ? `${url.pathname}${url.search}${url.hash}` : url.toString();
+}
+var RNXSIM_METRO_SOURCE_MAP_COMMENT = "//# sourceMappingURL=";
+function detachRNXMetroSourceMapUrl(bundleText) {
+  const trimmedEnd = bundleText.replace(/\s+$/, "");
+  const commentStart = trimmedEnd.lastIndexOf(`
+${RNXSIM_METRO_SOURCE_MAP_COMMENT}`);
+  if (commentStart < 0) return { source: bundleText, sourceMappingUrl: null };
+  const url = trimmedEnd.slice(commentStart + 1 + RNXSIM_METRO_SOURCE_MAP_COMMENT.length);
+  if (url.includes("\n")) return { source: bundleText, sourceMappingUrl: null };
+  return { source: trimmedEnd.slice(0, commentStart), sourceMappingUrl: url };
+}
+function createRNXMetroModuleIdentityFooter(identity) {
+  const payload = JSON.stringify(identity).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029").replace(/<\//g, "<\\/");
+  return `
+${RNXSIM_METRO_MODULE_PATHS_PREFIX}${payload};`;
+}
+function appendRNXMetroModuleIdentityFooter(bundleText, identity) {
+  const footer = createRNXMetroModuleIdentityFooter(identity);
+  const detached = detachRNXMetroSourceMapUrl(bundleText);
+  return detached.sourceMappingUrl === null ? bundleText + footer : `${detached.source}${footer}
+${RNXSIM_METRO_SOURCE_MAP_COMMENT}${detached.sourceMappingUrl}`;
+}
+
+// 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_fs2 = __toESM(require("node:fs"), 1);
+var import_node_os = require("node:os");
+var import_node_path2 = __toESM(require("node:path"), 1);
+var RNX_HOME_ENV = "RNX_HOME";
+var ACTIVE_RUNTIME_FILE = "active";
+function rnxHomeDir() {
+  const override = process.env[RNX_HOME_ENV];
+  if (override && override.length > 0) return import_node_path2.default.resolve(override);
+  return import_node_path2.default.join((0, import_node_os.homedir)(), ".rnx");
+}
+function runtimesDir() {
+  return import_node_path2.default.join(rnxHomeDir(), "runtimes");
+}
+function runtimeDir(version) {
+  return import_node_path2.default.join(runtimesDir(), version);
+}
+function activeRuntimeFile() {
+  return import_node_path2.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+}
+function readActiveRuntime() {
+  try {
+    const value = import_node_fs2.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. run `rnx 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.RNX_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");
+  if (/^canvaskit-graphite-pipelines-[0-9a-f]{8}\.bin$/.test(import_path.default.basename(fullPath))) {
+    res.setHeader("cache-control", "public, max-age=31536000, immutable");
+    import_fs.default.createReadStream(fullPath).pipe(res);
+    return;
+  }
+  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 readCallableMetroExport(moduleValue, label) {
+  const callable = typeof moduleValue === "function" ? moduleValue : typeof moduleValue === "object" && moduleValue !== null ? Reflect.get(moduleValue, "default") : void 0;
+  if (typeof callable !== "function") {
+    throw new Error(`rnxsim: Metro ${label} module did not export a function`);
+  }
+  return (...args) => Reflect.apply(callable, void 0, args);
+}
+function createMetroDefaultSerializer(projectRoot) {
+  const projectRequire = (0, import_module.createRequire)(import_path2.default.join(projectRoot, "package.json"));
+  const metroRoot = import_path2.default.dirname(projectRequire.resolve("metro/package.json"));
+  const baseJSBundle = readCallableMetroExport(
+    projectRequire(import_path2.default.join(metroRoot, "src/DeltaBundler/Serializers/baseJSBundle.js")),
+    "baseJSBundle"
+  );
+  const bundleToString = readCallableMetroExport(
+    projectRequire(import_path2.default.join(metroRoot, "src/lib/bundleToString.js")),
+    "bundleToString"
+  );
+  return (entryPoint, preModules, graph, options) => {
+    const serialized = bundleToString(
+      baseJSBundle(entryPoint, preModules, graph, options)
+    );
+    const code = typeof serialized === "object" && serialized !== null ? Reflect.get(serialized, "code") : void 0;
+    if (typeof code !== "string") {
+      throw new Error("rnxsim: Metro bundleToString did not return bundle code");
+    }
+    return code;
+  };
+}
+function appendRNXModulePaths(result, graph, options, projectRoot) {
+  const dependencies = graph.dependencies;
+  const createModuleId = options.createModuleId;
+  if (!dependencies || !createModuleId) {
+    return result;
+  }
+  const modulePaths = {};
+  for (const module2 of dependencies.values()) {
+    modulePaths[String(createModuleId(module2.path))] = import_path2.default.relative(projectRoot, module2.path).replaceAll(import_path2.default.sep, "/");
+  }
+  if (Object.keys(modulePaths).length !== dependencies.size) {
+    throw new Error("rnxsim: bundle module IDs were not unique");
+  }
+  const specifiersByModuleId = /* @__PURE__ */ new Map();
+  for (const module2 of dependencies.values()) {
+    for (const [dependencyKey, dependency] of module2.dependencies ?? []) {
+      const specifier = dependency.data?.name ?? dependencyKey;
+      if (specifier.length === 0 || specifier.startsWith(".") || specifier.startsWith("/") || typeof dependency.absolutePath !== "string") {
+        continue;
+      }
+      const moduleId = String(createModuleId(dependency.absolutePath));
+      if (!Object.prototype.hasOwnProperty.call(modulePaths, moduleId)) continue;
+      const found = specifiersByModuleId.get(moduleId);
+      if (found) found.add(specifier);
+      else specifiersByModuleId.set(moduleId, /* @__PURE__ */ new Set([specifier]));
+    }
+  }
+  const logicalSpecifiers = Object.fromEntries(
+    [...specifiersByModuleId].sort(([left], [right]) => Number(left) - Number(right)).map(([moduleId, specifiers]) => [moduleId, [...specifiers].sort()])
+  );
+  const identity = {
+    version: RNX_METRO_MODULE_IDENTITY_VERSION,
+    identitySource: "rnx-plugin",
+    modulePaths,
+    logicalSpecifiers
+  };
+  return typeof result === "string" ? appendRNXMetroModuleIdentityFooter(result, identity) : { ...result, code: appendRNXMetroModuleIdentityFooter(result.code, identity) };
+}
+function withRNX(config) {
+  const cfgProjectRoot = config.projectRoot || process.cwd();
+  const configuredBundleUrl = "/index.bundle?platform=ios&dev=true&hot=true&minify=false";
+  const cfgServer = config.server;
+  const port = resolveMetroPort(cfgServer);
+  const metroServerId = (0, import_node_crypto2.randomUUID)();
+  const bundleUrl = tagRnxBundleForPlugin(
+    configuredBundleUrl,
+    `http://localhost:${port}`,
+    metroServerId,
+    cfgProjectRoot
+  );
+  const cfgSerializer = config.serializer;
+  const existingEnhance = cfgServer?.enhanceMiddleware;
+  const existingSerializer = cfgSerializer?.customSerializer;
+  let defaultSerializer;
+  const serializerConfig = {
+    serializer: {
+      ...cfgSerializer,
+      customSerializer: async (entryPoint, preModules, graph, serializerOptions) => {
+        const serializer = existingSerializer || (defaultSerializer ||= createMetroDefaultSerializer(cfgProjectRoot));
+        const result = await serializer(entryPoint, preModules, graph, serializerOptions);
+        return appendRNXModulePaths(result, graph, serializerOptions, cfgProjectRoot);
+      }
+    }
+  };
+  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) => {
+        if (isReplacementModuleRequestUrl(req.url)) {
+          void handleReplacementModuleRequest(req, res, {
+            projectRoot: cfgProjectRoot,
+            requestToken: metroServerId,
+            requireLoopbackOrigin: true
+          }).then((handled) => {
+            if (!handled) next();
+          });
+          return;
+        }
+        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");
+            const script = `<script>(function(){var u=new URL(location.href);if(!u.searchParams.has('bundle'))u.searchParams.set('bundle',${JSON.stringify(bundleUrl)});history.replaceState(null,'','${prefix}/'+u.search)})()</script>`;
+            html = html.includes("</head>") ? html.replace("</head>", `${script}</head>`) : `${html}${script}`;
+            res.setHeader("content-type", "text/html");
+            res.end(html);
+            return;
+          }
+        }
+        next();
+      });
+      server.use(middleware);
+      console.log(`[rnx] serving at ${prefix}/`);
+      return server;
+    }
+  };
+  return {
+    ...config,
+    ...serializerConfig,
+    server: serverConfig
+  };
+}
+function resolveMetroPort(server) {
+  const inlinePort = process.argv.find((arg) => arg.startsWith("--port="))?.slice(7);
+  const portIndex = process.argv.indexOf("--port");
+  const splitPort = portIndex >= 0 ? process.argv[portIndex + 1] : void 0;
+  const rawPort = inlinePort || splitPort || process.env.RCT_METRO_PORT || server?.port || 8081;
+  const port = Number(rawPort);
+  if (!Number.isInteger(port) || port <= 0) {
+    throw new Error(`rnx: Metro port must be a positive integer, got ${rawPort}`);
+  }
+  return port;
+}
+var metro_plugin_default = withRNX;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toRNXDevelopmentBundleUrl,
+  toRNXProductionBundleUrl,
+  withRNX
+});