peachsim 0.1.527

package/dist-lib/host/replacement-module-handler.cjs

@@ -0,0 +1,469 @@
+/*! 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/host/replacement-module-handler.ts
+var replacement_module_handler_exports = {};
+__export(replacement_module_handler_exports, {
+  REPLACEMENT_MODULE_ROUTE: () => REPLACEMENT_MODULE_ROUTE,
+  handleReplacementModuleRequest: () => handleReplacementModuleRequest,
+  isReplacementModuleRequestUrl: () => isReplacementModuleRequestUrl
+});
+module.exports = __toCommonJS(replacement_module_handler_exports);
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REPLACEMENT_MODULE_ROUTE,
+  handleReplacementModuleRequest,
+  isReplacementModuleRequestUrl
+});