peachsim 0.1.527

package/dist-lib/vite.cjs

@@ -0,0 +1,1591 @@
+/*! 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/vite-plugin-one.ts
+var vite_plugin_one_exports = {};
+__export(vite_plugin_one_exports, {
+  default: () => vite_plugin_one_default,
+  rnxPlugin: () => rnxPlugin,
+  sootsimPlugin: () => sootsimPlugin,
+  swiftPlugin: () => swiftPlugin,
+  swiftRemotePlugin: () => swiftRemotePlugin
+});
+module.exports = __toCommonJS(vite_plugin_one_exports);
+var import_fs2 = __toESM(require("fs"), 1);
+var import_node_crypto3 = require("node:crypto");
+var import_path2 = __toESM(require("path"), 1);
+
+// src/bridge-constants.ts
+var DEFAULT_SOOTSIM_BRIDGE_PORT = 7668;
+var DEFAULT_SOOTSIM_BRIDGE_URL = `http://localhost:${DEFAULT_SOOTSIM_BRIDGE_PORT}/`;
+
+// src/dev-server-open.ts
+var import_node_child_process = require("node:child_process");
+var import_node_crypto = require("node:crypto");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+function resolveRnxDesktopAppName(open, projectRoot) {
+  if (!open) return null;
+  if (typeof open === "object") {
+    const appName = open.appName.trim();
+    if (!appName) throw new Error("rnx: open.appName must not be empty");
+    return appName;
+  }
+  const packageJsonPath = import_node_path.default.join(projectRoot, "package.json");
+  const packageJson = JSON.parse(import_node_fs.default.readFileSync(packageJsonPath, "utf8"));
+  const packageName = packageJson && typeof packageJson === "object" ? Reflect.get(packageJson, "name") : void 0;
+  if (typeof packageName !== "string" || !packageName.trim()) {
+    throw new Error(`rnx: ${packageJsonPath} must declare a package name`);
+  }
+  return packageName.trim();
+}
+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}`;
+}
+function resolveRnxDesktopLaunchTarget(port, bundleUrl) {
+  return new URL(bundleUrl, `http://localhost:${port}`).toString();
+}
+function buildRnxDesktopOpenArgs(bundleUrl) {
+  return ["open", bundleUrl, "--new", "--driver", "electron", "--no-describe"];
+}
+function observeRnxDesktopLaunch(child, appName) {
+  let stderr = "";
+  let spawnFailed = false;
+  child.stderr?.setEncoding("utf8");
+  child.stderr?.on("data", (chunk) => {
+    stderr = `${stderr}${chunk}`.slice(-16384);
+  });
+  child.once("error", (error) => {
+    spawnFailed = true;
+    console.error(`[rnx] could not open ${appName}: ${error.message}`);
+  });
+  child.once("close", (code, signal) => {
+    if (spawnFailed) return;
+    if (code === 0) {
+      console.log(`[rnx] opened ${appName} in the desktop simulator`);
+      return;
+    }
+    const detail = stderr.trim() || (signal ? `signal ${signal}` : `exit ${code}`);
+    console.error(`[rnx] could not open ${appName}: ${detail}`);
+  });
+}
+function launchRnxDesktop(bundleUrl, appName) {
+  const packageRoot = import_node_path.default.resolve(import_node_path.default.dirname((0, import_node_url.fileURLToPath)(__sootsim_import_meta_url)), "..");
+  const binPath = import_node_path.default.join(packageRoot, "dist-cli", "bin.js");
+  console.log(`[rnx] opening ${appName} in the desktop simulator`);
+  const child = (0, import_node_child_process.spawn)(
+    process.execPath,
+    [binPath, ...buildRnxDesktopOpenArgs(bundleUrl)],
+    {
+      stdio: ["ignore", "ignore", "pipe"],
+      windowsHide: true
+    }
+  );
+  observeRnxDesktopLaunch(child, appName);
+}
+
+// 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";
+var DAEMON_LOCKFILE = "daemon.json";
+var DAEMON_HEARTBEAT_STALE_MS = 3e4;
+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 daemonLockfilePath() {
+  return import_node_path2.default.join(rnxHomeDir(), DAEMON_LOCKFILE);
+}
+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;
+function readDaemonLockfile() {
+  try {
+    const fd = import_node_fs2.default.openSync(daemonLockfilePath(), "r");
+    try {
+      const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
+      const bytesRead = import_node_fs2.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
+      const raw = buf.subarray(0, bytesRead).toString("utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed && parsed.schema === 1 && typeof parsed.pid === "number" && typeof parsed.bridgePort === "number" && typeof parsed.runtimePort === "number" && typeof parsed.startedAt === "number" && typeof parsed.heartbeatAt === "number" && (parsed.servedRuntimes === void 0 || Array.isArray(parsed.servedRuntimes) && parsed.servedRuntimes.every((version) => typeof version === "string"))) {
+        return parsed;
+      }
+      return null;
+    } finally {
+      import_node_fs2.default.closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+function isDaemonLockfileFresh(lock, now = Date.now()) {
+  if (!lock) return false;
+  if (now - lock.heartbeatAt > DAEMON_HEARTBEAT_STALE_MS) return false;
+  try {
+    process.kill(lock.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/host/replacement-module-handler.ts
+var import_promises = __toESM(require("node:fs/promises"), 1);
+var import_node_path3 = __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);
+}
+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_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 ${REPLACEMENT_MODULE_EXTENSIONS.join(", ")}`);
+    return true;
+  }
+  if (!import_node_path3.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_path3.default.resolve(options.projectRoot);
+    resolvedProjectRoot = await import_promises.default.realpath(options.projectRoot);
+    const lexicalTarget = import_node_path3.default.relative(lexicalProjectRoot, targetPath);
+    if (lexicalTarget.startsWith("..") || import_node_path3.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_path3.default.relative(resolvedProjectRoot, resolvedTargetPath);
+    if (relativeTarget.startsWith("..") || import_node_path3.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/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/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/vite-plugin-swift.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_os2 = __toESM(require("node:os"), 1);
+var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_util = require("node:util");
+
+// ../sootsim-swift/src/bundleAssets.ts
+var RASTER_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".avif",
+  ".bmp",
+  ".gif",
+  ".ico",
+  ".jpeg",
+  ".jpg",
+  ".png",
+  ".webp"
+]);
+function extOf(file) {
+  const dot = file.lastIndexOf(".");
+  return dot < 0 ? "" : file.slice(dot).toLowerCase();
+}
+function baseOf(file) {
+  const slash = file.lastIndexOf("/");
+  return slash < 0 ? file : file.slice(slash + 1);
+}
+function pickImagesetFile(images) {
+  const rasters = images.filter(
+    (image) => typeof image.filename === "string" && RASTER_EXTENSIONS.has(extOf(image.filename))
+  );
+  if (rasters.length === 0) return null;
+  const rank = (scale) => scale === "2x" ? 0 : scale === "3x" ? 1 : scale === "1x" ? 2 : 3;
+  return [...rasters].sort((a, b) => rank(a.scale) - rank(b.scale))[0].filename;
+}
+function imagesetName(contentsPath) {
+  const dir = contentsPath.split("/").slice(0, -1).join("/");
+  const leaf = baseOf(dir);
+  if (!leaf.endsWith(".imageset")) return null;
+  return leaf.slice(0, -".imageset".length) || null;
+}
+function isFlatResourceImage(path8) {
+  return path8.split("/").includes("Resources") && RASTER_EXTENSIONS.has(extOf(path8));
+}
+function enumerateBundleImages(paths, readText) {
+  const table = [];
+  const seen = /* @__PURE__ */ new Set();
+  const catalogs = paths.filter((path8) => baseOf(path8) === "Contents.json");
+  for (const contentsPath of catalogs) {
+    const name = imagesetName(contentsPath);
+    if (name === null || seen.has(name)) continue;
+    let parsed;
+    try {
+      const text = readText(contentsPath);
+      if (text === null) continue;
+      parsed = JSON.parse(text);
+    } catch {
+      continue;
+    }
+    const images = parsed?.images;
+    if (!Array.isArray(images)) continue;
+    const dir = contentsPath.split("/").slice(0, -1).join("/");
+    const file = pickImagesetFile(images);
+    if (file === null || file.includes("/") || file.includes("\\")) continue;
+    seen.add(name);
+    table.push({ name, file: `${dir}/${file}` });
+  }
+  for (const path8 of paths) {
+    if (!isFlatResourceImage(path8)) continue;
+    const name = baseOf(path8).slice(0, -extOf(path8).length);
+    if (name === "" || seen.has(name)) continue;
+    seen.add(name);
+    table.push({ name, file: path8 });
+  }
+  return table;
+}
+function enumerateBundleJson(paths) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [...paths].filter(
+    (path8) => path8.split("/").includes("Resources") && path8.split("/").every((segment) => segment !== "" && segment !== "..") && extOf(path8) === ".json"
+  ).sort((a, b) => {
+    const aDepth = a.split("/").length;
+    const bDepth = b.split("/").length;
+    return aDepth - bDepth || (a < b ? -1 : a > b ? 1 : 0);
+  });
+  for (const file of ordered) {
+    const base = baseOf(file);
+    if (seen.has(base)) continue;
+    seen.add(base);
+    found.push({ base, file });
+  }
+  return found;
+}
+
+// ../sootsim-swift/toolchain.json
+var toolchain_default = {
+  release: "swift-6.3-RELEASE",
+  wasmSdkChecksum: "9fa4016ee632c7e9e906608ec3b55cf13dfc4dff44e47574c5af58064dc33fd9"
+};
+
+// src/vite-plugin-swift.ts
+var run = (0, import_node_util.promisify)(import_node_child_process2.execFile);
+var TOOLCHAIN_BIN = import_node_path4.default.join(
+  import_node_os2.default.homedir(),
+  `Library/Developer/Toolchains/${toolchain_default.release}.xctoolchain/usr/bin`
+);
+var WASM_SDK = `${toolchain_default.release}_wasm`;
+var WASM_TRIPLE = "wasm32-unknown-wasip1";
+var ARTIFACT_PATH = "/__rnx/swift/";
+var RESOURCE_PATH = "/__rnx/swift-res/";
+var VIRTUAL_PREFIX = "\0rnx-swift:";
+var projects = /* @__PURE__ */ new Map();
+var devServer;
+function projectFor(packagePath) {
+  const existing = projects.get(packagePath);
+  if (existing) return existing;
+  const created = {
+    packagePath,
+    artifact: null,
+    building: null,
+    resourceFiles: /* @__PURE__ */ new Map()
+  };
+  projects.set(packagePath, created);
+  return created;
+}
+function sourceFiles(root) {
+  const found = [];
+  const walk = (dir) => {
+    for (const entry of import_node_fs3.default.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const full = import_node_path4.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (full !== root && import_node_fs3.default.existsSync(import_node_path4.default.join(full, "Package.swift"))) continue;
+        walk(full);
+      } else if (entry.name.endsWith(".swift")) found.push(full);
+    }
+  };
+  walk(root);
+  return found;
+}
+function resourceCandidateFiles(root) {
+  const found = [];
+  const walk = (dir) => {
+    for (const entry of import_node_fs3.default.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === ".build")
+        continue;
+      const full = import_node_path4.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (full !== root && import_node_fs3.default.existsSync(import_node_path4.default.join(full, "Package.swift"))) continue;
+        walk(full);
+      } else {
+        found.push(full);
+      }
+    }
+  };
+  walk(root);
+  return found;
+}
+var RESOURCE_CONTENT_TYPES = {
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp"
+};
+function buildSwiftResourceTable(project, baseUrl) {
+  const absolute = resourceCandidateFiles(project.packagePath);
+  const relative2 = absolute.map(
+    (file) => import_node_path4.default.relative(project.packagePath, file).split(import_node_path4.default.sep).join(import_node_path4.default.posix.sep)
+  );
+  const byRelative = new Map(absolute.map((file, index) => [relative2[index], file]));
+  const found = enumerateBundleImages(relative2, (candidate) => {
+    const file = byRelative.get(candidate);
+    if (!file || import_node_path4.default.basename(file) !== "Contents.json") return null;
+    try {
+      return import_node_fs3.default.readFileSync(file, "utf8");
+    } catch {
+      return null;
+    }
+  });
+  const table = {};
+  const watched = [];
+  const registered = /* @__PURE__ */ new Map();
+  for (const { name, file } of found) {
+    const disk = byRelative.get(file);
+    if (!disk) continue;
+    let bytes;
+    try {
+      bytes = import_node_fs3.default.readFileSync(disk);
+    } catch {
+      continue;
+    }
+    const hash = (0, import_node_crypto2.createHash)("sha256").update(bytes).digest("hex").slice(0, 16);
+    const ext = import_node_path4.default.posix.extname(file).toLowerCase();
+    table[name] = `${baseUrl}${RESOURCE_PATH}${hash}${ext}`;
+    watched.push(file);
+    const contents = file.replace(/\/[^/]+$/, "/Contents.json");
+    if (byRelative.has(contents)) watched.push(contents);
+    registered.set(`${hash}${ext}`, disk);
+  }
+  project.resourceFiles = registered;
+  return { table, watched };
+}
+var BUNDLE_MAX_FILES = 128;
+var BUNDLE_MAX_FILE_BYTES = 2 * 1024 * 1024;
+var BUNDLE_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
+function buildSwiftBundleFiles(packagePath) {
+  const relative2 = resourceCandidateFiles(packagePath).map(
+    (file) => import_node_path4.default.relative(packagePath, file).split(import_node_path4.default.sep).join(import_node_path4.default.posix.sep)
+  );
+  const files = {};
+  const watched = [];
+  const skipped = [];
+  let total = 0;
+  for (const { base, file } of enumerateBundleJson(relative2)) {
+    watched.push(file);
+    let bytes;
+    try {
+      bytes = import_node_fs3.default.readFileSync(import_node_path4.default.join(packagePath, ...file.split("/")));
+    } catch {
+      continue;
+    }
+    if (bytes.length > BUNDLE_MAX_FILE_BYTES) {
+      skipped.push(`${file} (${bytes.length} bytes past the per-file cap)`);
+      continue;
+    }
+    if (Object.keys(files).length >= BUNDLE_MAX_FILES || total + bytes.length > BUNDLE_MAX_TOTAL_BYTES) {
+      skipped.push(
+        `${file} (pack caps: ${BUNDLE_MAX_FILES} files / ${BUNDLE_MAX_TOTAL_BYTES} bytes)`
+      );
+      continue;
+    }
+    files[base] = bytes.toString("base64");
+    total += bytes.length;
+  }
+  return { files, watched, skipped };
+}
+function serveSwiftResource(project, key) {
+  const disk = project.resourceFiles.get(key);
+  if (!disk) return null;
+  try {
+    return {
+      bytes: import_node_fs3.default.readFileSync(disk),
+      contentType: RESOURCE_CONTENT_TYPES[import_node_path4.default.extname(disk).toLowerCase()] ?? "application/octet-stream"
+    };
+  } catch {
+    return null;
+  }
+}
+function linkedModuleRoots(packagePath) {
+  let manifest;
+  try {
+    manifest = import_node_fs3.default.readFileSync(import_node_path4.default.join(packagePath, "Package.swift"), "utf8");
+  } catch {
+    return [];
+  }
+  const roots = /* @__PURE__ */ new Set();
+  const dependency = /\.package\(\s*path:\s*"([^"]+)"\s*\)/g;
+  for (const match of manifest.replace(/^\s*\/\/.*$/gm, "").matchAll(dependency)) {
+    const root = import_node_path4.default.resolve(packagePath, match[1]);
+    if (import_node_fs3.default.existsSync(import_node_path4.default.join(root, "Package.swift"))) roots.add(root);
+  }
+  return [...roots].sort();
+}
+function sourceStamp(packagePath) {
+  const hash = (0, import_node_crypto2.createHash)("sha256");
+  for (const root of [packagePath, ...linkedModuleRoots(packagePath)]) {
+    hash.update(root);
+    for (const file of sourceFiles(root).sort()) {
+      hash.update(import_node_path4.default.relative(root, file));
+      hash.update(String(import_node_fs3.default.statSync(file).mtimeMs));
+    }
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+function entryRootId(packagePath, file) {
+  const relative2 = import_node_path4.default.relative(packagePath, file).split(import_node_path4.default.sep).join(import_node_path4.default.posix.sep);
+  return `${import_node_path4.default.basename(packagePath)}${import_node_path4.default.posix.sep}${relative2}`;
+}
+function serverOrigin() {
+  const address = devServer?.httpServer?.address();
+  const port = address && typeof address === "object" ? address.port : devServer?.config.server.port;
+  if (!port) throw new Error("the swift urls need the dev server port");
+  return `http://localhost:${port}`;
+}
+function artifactUrl(project, artifact) {
+  return `${serverOrigin()}${ARTIFACT_PATH}${artifact.hash}.wasm`;
+}
+function builtArtifact(packagePath) {
+  const binDir = import_node_path4.default.join(packagePath, ".build", WASM_TRIPLE, "release");
+  const artifacts = import_node_fs3.default.existsSync(binDir) ? import_node_fs3.default.readdirSync(binDir).filter((name) => name.endsWith(".wasm")).sort() : [];
+  if (artifacts.length !== 1) {
+    throw new Error(
+      `swift project ${packagePath} built ${artifacts.length} wasm artifacts; exactly one executable is the app`
+    );
+  }
+  return import_node_path4.default.join(binDir, artifacts[0]);
+}
+function streamText(value) {
+  if (typeof value === "string") return value.trim();
+  if (Buffer.isBuffer(value)) return value.toString("utf8").trim();
+  return "";
+}
+async function compile(packagePath, stamp) {
+  const swift = import_node_path4.default.join(TOOLCHAIN_BIN, "swift");
+  if (!import_node_fs3.default.existsSync(swift)) {
+    throw new Error(
+      `no swift.org toolchain at ${TOOLCHAIN_BIN}. install it and the ${WASM_SDK} sdk; see packages/sootsim-swift/README.md`
+    );
+  }
+  try {
+    await run(
+      swift,
+      [
+        "build",
+        "--package-path",
+        packagePath,
+        "--swift-sdk",
+        WASM_SDK,
+        "-c",
+        "release",
+        "-Xswiftc",
+        "-Osize"
+      ],
+      { maxBuffer: 64 * 1024 * 1024 }
+    );
+  } catch (error) {
+    const streams = error && typeof error === "object" ? [
+      streamText(Reflect.get(error, "stdout")),
+      streamText(Reflect.get(error, "stderr"))
+    ].filter(Boolean) : [];
+    const detail = streams.length > 0 ? streams.join("\n") : error instanceof Error ? error.message : String(error);
+    throw new Error(`swift build failed for ${packagePath}
+${detail}`);
+  }
+  const bytes = import_node_fs3.default.readFileSync(builtArtifact(packagePath));
+  return {
+    hash: (0, import_node_crypto2.createHash)("sha256").update(bytes).digest("hex").slice(0, 16),
+    bytes,
+    stamp
+  };
+}
+function artifactFor(project) {
+  const stamp = sourceStamp(project.packagePath);
+  if (project.artifact?.stamp === stamp) return Promise.resolve(project.artifact);
+  if (project.building) {
+    const running = project.building;
+    if (running.stamp === stamp) return running.promise;
+    const again = () => artifactFor(project);
+    return running.promise.then(again, again);
+  }
+  const promise = compile(project.packagePath, stamp).then(
+    (artifact) => {
+      project.artifact = artifact;
+      project.building = null;
+      return artifact;
+    },
+    (error) => {
+      project.building = null;
+      throw error;
+    }
+  );
+  project.building = { stamp, promise };
+  return promise;
+}
+function packageFor(file) {
+  let dir = import_node_path4.default.dirname(file);
+  const stop = devServer?.config.root;
+  for (; ; ) {
+    if (import_node_fs3.default.existsSync(import_node_path4.default.join(dir, "Package.swift"))) return dir;
+    if (stop !== void 0 && dir === stop || import_node_path4.default.dirname(dir) === dir) break;
+    dir = import_node_path4.default.dirname(dir);
+  }
+  throw new Error(
+    `no Package.swift above ${file}${stop === void 0 ? "" : ` (searched up to ${stop})`}; a .swift import needs a swiftpm package like the one in packages/sootsim-swift/example`
+  );
+}
+function swiftPlugin(options = {}) {
+  return {
+    name: "rnx-swift",
+    enforce: "pre",
+    async resolveId(source, importer) {
+      if (source.startsWith(VIRTUAL_PREFIX)) return source;
+      if (source.startsWith("/@id/")) {
+        const decoded = source.slice("/@id/".length).replace(/^__x00__/, "\0");
+        return decoded.startsWith(VIRTUAL_PREFIX) ? decoded : null;
+      }
+      if (!source.endsWith(".swift")) return null;
+      const resolved = await this.resolve(source, importer, { skipSelf: true });
+      if (!resolved) throw new Error(`cannot resolve swift source ${source}`);
+      return VIRTUAL_PREFIX + resolved.id;
+    },
+    async load(id) {
+      if (!id.startsWith(VIRTUAL_PREFIX)) return null;
+      const file = id.slice(VIRTUAL_PREFIX.length);
+      if (!import_node_fs3.default.existsSync(file)) throw new Error(`swift source ${file} no longer exists`);
+      const packagePath = options.packagePath ?? packageFor(file);
+      const project = projectFor(packagePath);
+      for (const source of sourceFiles(packagePath)) this.addWatchFile(source);
+      for (const root of linkedModuleRoots(packagePath)) {
+        for (const source of sourceFiles(root)) this.addWatchFile(source);
+      }
+      let artifact;
+      try {
+        artifact = await artifactFor(project);
+      } catch (error) {
+        if (!project.artifact) throw error;
+        this.warn(error instanceof Error ? error.message : String(error));
+        artifact = project.artifact;
+      }
+      let resources = {};
+      try {
+        const built = buildSwiftResourceTable(project, serverOrigin());
+        resources = built.table;
+        for (const watched of built.watched) this.addWatchFile(watched);
+      } catch (error) {
+        this.warn(
+          `swift resources for ${packagePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      let bundleFiles = {};
+      try {
+        const packed = buildSwiftBundleFiles(packagePath);
+        bundleFiles = packed.files;
+        for (const watched of packed.watched) {
+          this.addWatchFile(import_node_path4.default.join(packagePath, ...watched.split(import_node_path4.default.posix.sep)));
+        }
+        if (packed.skipped.length > 0) {
+          this.warn(
+            `swift bundle files skipped for ${packagePath}: ${packed.skipped.join("; ")}`
+          );
+        }
+      } catch (error) {
+        this.warn(
+          `swift bundle files for ${packagePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      return [
+        `import { createSwiftEntry } from 'rnxsim/swift'`,
+        `export default createSwiftEntry({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)}, rootId: ${JSON.stringify(entryRootId(packagePath, file))}, resources: ${JSON.stringify(resources)}, bundleFiles: ${JSON.stringify(bundleFiles)} })`,
+        ""
+      ].join("\n");
+    },
+    configureServer(server) {
+      devServer = server;
+      server.middlewares.use((req, res, next) => {
+        const url = (req.url ?? "").split("?")[0];
+        if (url.startsWith(RESOURCE_PATH)) {
+          for (const project of projects.values()) {
+            const served = serveSwiftResource(project, url.slice(RESOURCE_PATH.length));
+            if (served) {
+              res.setHeader("access-control-allow-origin", "*");
+              res.setHeader("content-type", served.contentType);
+              res.end(served.bytes);
+              return;
+            }
+          }
+          res.statusCode = 404;
+          res.end("swift resource is stale");
+          return;
+        }
+        if (!url.startsWith(ARTIFACT_PATH)) {
+          next();
+          return;
+        }
+        for (const project of projects.values()) {
+          const artifact = project.artifact;
+          if (artifact && url === `${ARTIFACT_PATH}${artifact.hash}.wasm`) {
+            res.setHeader("access-control-allow-origin", "*");
+            res.setHeader("content-type", "application/wasm");
+            res.end(artifact.bytes);
+            return;
+          }
+        }
+        res.statusCode = 404;
+        res.end("swift artifact is stale");
+      });
+    }
+  };
+}
+
+// src/rolldown-plugin-swift.ts
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
+
+// src/swift-submit.ts
+var SWIFT_COMPILE_PATH = "/api/swift-compile";
+var POLL_INTERVAL_MS = 1500;
+function httpSwiftCompileSubmit(context) {
+  const { assetReadToken, endpoint } = context;
+  if (!assetReadToken) return void 0;
+  const url = endpoint ? `${endpoint.replace(/\/+$/, "")}${SWIFT_COMPILE_PATH}` : SWIFT_COMPILE_PATH;
+  return async (work) => {
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ ...work, token: assetReadToken })
+      });
+    } catch (error) {
+      throw new Error(
+        `contrast-bundler: fetch failed for ${url} while compiling ${work.entry}: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+    if (!response.ok) {
+      const detail = (await response.text()).trim();
+      throw new Error(
+        `contrast-bundler: the swift compile for ${work.entry} answered ${response.status}${detail ? `: ${detail}` : ""}`
+      );
+    }
+    return await response.json();
+  };
+}
+function resolveImageUrls(urls, origin) {
+  const resolved = {};
+  for (const [name, url] of Object.entries(urls)) {
+    resolved[name] = new URL(url, origin).href;
+  }
+  return resolved;
+}
+async function compileSwiftProject(submit, work, origin) {
+  while (true) {
+    const outcome = await submit(work);
+    switch (outcome.status) {
+      case "published":
+        return {
+          url: new URL(outcome.artifactUrl, origin).href,
+          hash: outcome.hash,
+          ...outcome.imageUrls === void 0 ? {} : { imageUrls: resolveImageUrls(outcome.imageUrls, origin) }
+        };
+      case "compiling":
+        await new Promise((resolve2) => setTimeout(resolve2, POLL_INTERVAL_MS));
+        continue;
+      case "refused":
+      case "failed":
+        throw new Error(
+          `contrast-bundler: the swift sources for ${work.entry} cannot be compiled: ${outcome.detail}`
+        );
+    }
+  }
+}
+
+// src/rolldown-plugin-swift.ts
+var VIRTUAL_PREFIX2 = "\0rnx-swift-remote:";
+var projects2 = /* @__PURE__ */ new Map();
+function projectFor2(packagePath) {
+  const existing = projects2.get(packagePath);
+  if (existing) return existing;
+  const created = { packagePath, address: null };
+  projects2.set(packagePath, created);
+  return created;
+}
+function packageFiles(root) {
+  const found = [];
+  const walk = (dir) => {
+    for (const entry of import_node_fs4.default.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === ".build")
+        continue;
+      const full = import_node_path5.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (full !== root && import_node_fs4.default.existsSync(import_node_path5.default.join(full, "Package.swift"))) continue;
+        walk(full);
+      } else {
+        found.push(import_node_path5.default.relative(root, full).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep));
+      }
+    }
+  };
+  walk(root);
+  return found;
+}
+function sourceFiles2(packagePath) {
+  const files = {};
+  for (const relative2 of packageFiles(packagePath)) {
+    if (!relative2.endsWith(".swift")) continue;
+    files[relative2] = import_node_fs4.default.readFileSync(
+      import_node_path5.default.join(packagePath, ...relative2.split("/")),
+      "utf8"
+    );
+  }
+  return files;
+}
+function bundlePack(packagePath) {
+  const relative2 = packageFiles(packagePath);
+  const disk = (file) => import_node_path5.default.join(packagePath, ...file.split("/"));
+  const resources = {};
+  const watched = [];
+  for (const { base, file } of enumerateBundleJson(relative2)) {
+    resources[base] = import_node_fs4.default.readFileSync(disk(file)).toString("base64");
+    watched.push(file);
+  }
+  const images = {};
+  const byRelative = new Map(relative2.map((file) => [file, disk(file)]));
+  for (const { name, file } of enumerateBundleImages(relative2, (candidate) => {
+    const absolute = byRelative.get(candidate);
+    if (!absolute || import_node_path5.default.basename(absolute) !== "Contents.json") return null;
+    try {
+      return import_node_fs4.default.readFileSync(absolute, "utf8");
+    } catch {
+      return null;
+    }
+  })) {
+    const absolute = byRelative.get(file);
+    if (!absolute) continue;
+    images[name] = {
+      file: import_node_path5.default.posix.basename(file),
+      data: import_node_fs4.default.readFileSync(absolute).toString("base64")
+    };
+    watched.push(file);
+  }
+  return { resources, images, watched };
+}
+function packageFor2(file, stop) {
+  let dir = import_node_path5.default.dirname(file);
+  for (; ; ) {
+    if (import_node_fs4.default.existsSync(import_node_path5.default.join(dir, "Package.swift"))) return dir;
+    if (stop !== void 0 && dir === stop || import_node_path5.default.dirname(dir) === dir) break;
+    dir = import_node_path5.default.dirname(dir);
+  }
+  throw new Error(
+    `no Package.swift above ${file}; a .swift import needs a swiftpm package like the one in packages/sootsim-swift/example`
+  );
+}
+function swiftRemotePlugin(options) {
+  const submit = httpSwiftCompileSubmit({
+    assetReadToken: options.assetReadToken,
+    endpoint: options.endpoint
+  });
+  if (!submit) {
+    throw new Error(
+      "swiftRemotePlugin needs an assetReadToken: a build without a compile credential cannot compile .swift sources"
+    );
+  }
+  return {
+    name: "rnx-swift-remote",
+    enforce: "pre",
+    async resolveId(source, importer) {
+      if (source.startsWith(VIRTUAL_PREFIX2)) return source;
+      if (!source.endsWith(".swift")) return null;
+      const resolved = await this.resolve(source, importer, { skipSelf: true });
+      if (!resolved) throw new Error(`cannot resolve swift source ${source}`);
+      return VIRTUAL_PREFIX2 + resolved.id;
+    },
+    async load(id) {
+      if (!id.startsWith(VIRTUAL_PREFIX2)) return null;
+      const file = id.slice(VIRTUAL_PREFIX2.length);
+      if (!import_node_fs4.default.existsSync(file)) throw new Error(`swift source ${file} no longer exists`);
+      const packagePath = options.packagePath ?? packageFor2(file);
+      const project = projectFor2(packagePath);
+      const files = sourceFiles2(packagePath);
+      const entry = import_node_path5.default.relative(packagePath, file).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep);
+      for (const source of Object.keys(files)) {
+        this.addWatchFile(import_node_path5.default.join(packagePath, ...source.split("/")));
+      }
+      const pack = bundlePack(packagePath);
+      for (const watched of pack.watched) {
+        this.addWatchFile(import_node_path5.default.join(packagePath, ...watched.split("/")));
+      }
+      try {
+        project.address = await compileSwiftProject(
+          submit,
+          { files, resources: pack.resources, images: pack.images, entry },
+          options.endpoint
+        );
+      } catch (error) {
+        if (!project.address) throw error;
+        this.warn(error instanceof Error ? error.message : String(error));
+      }
+      const address = project.address;
+      return [
+        `import { createSwiftEntry } from 'rnxsim/swift'`,
+        `export default createSwiftEntry({ url: ${JSON.stringify(address.url)}, hash: ${JSON.stringify(address.hash)}, rootId: ${JSON.stringify(entryRootId(packagePath, file))}, resources: ${JSON.stringify(address.imageUrls ?? {})}, bundleFiles: ${JSON.stringify(pack.resources)} })`,
+        ""
+      ].join("\n");
+    }
+  };
+}
+
+// src/vite-plugin-one.ts
+function rnxPlugin(options = {}) {
+  const prefix = options.prefix || "/__soot";
+  return {
+    name: "sootsim-one",
+    // use-latest-callback ships a CJS main (module.exports, no default) with
+    // an esm.mjs shim that re-imports it. react-native-bottom-tabs
+    // default-imports it from source served live, so vite hands the browser
+    // the raw CJS file and the import fails with 'does not provide an export
+    // named default' before anything mounts. forcing it through dep
+    // optimization lets esbuild's CJS interop answer the default import, and
+    // every bare import of it (including the nested copy's) resolves to the
+    // one pre-bundled instance.
+    config() {
+      return { optimizeDeps: { include: ["use-latest-callback"] } };
+    },
+    configureServer(server) {
+      if (options.enabled === false) return;
+      const bundleUrl = options.bundleUrl || "/node_modules/one/metro-entry.bundle?platform=ios&dev=true&minify=false";
+      const appName = resolveRnxDesktopAppName(options.open, server.config.root);
+      const replacementToken = (0, import_node_crypto3.randomUUID)();
+      const configuredPort = server.config.server.port || 8081;
+      const listeningPort = () => {
+        const address = server.httpServer?.address();
+        return address && typeof address === "object" ? address.port : configuredPort;
+      };
+      const bundleForPort = (port2) => tagRnxBundleForPlugin(
+        bundleUrl,
+        `http://localhost:${port2}`,
+        replacementToken,
+        server.config.root,
+        appName
+      );
+      const buildShellHtml = (runtimeRoot) => {
+        const html = import_fs2.default.readFileSync(import_path2.default.join(runtimeRoot, "index.html"), "utf8");
+        const lock = readDaemonLockfile();
+        const bridgePort = lock && isDaemonLockfileFresh(lock) && lock.bridgePort > 0 ? lock.bridgePort : DEFAULT_SOOTSIM_BRIDGE_PORT;
+        const inject = `<script>(function(){var u=new URL(location.href);if(!u.searchParams.has('bundle'))u.searchParams.set('bundle',${JSON.stringify(bundleForPort(listeningPort()))});window.__sootsimBridgePort=${bridgePort};history.replaceState(null,'','${prefix}/'+u.search)})()</script>`;
+        return html.replace("</head>", inject + "</head>");
+      };
+      server.middlewares.use((req, res, next) => {
+        const origWriteHead = res.writeHead.bind(res);
+        res.writeHead = function(statusCode, ...args) {
+          const setCookie = res.getHeader("set-cookie");
+          if (setCookie) {
+            const value = Array.isArray(setCookie) ? setCookie.join(", ") : String(setCookie);
+            res.setHeader("x-sootsim-set-cookie", value);
+            res.setHeader("access-control-expose-headers", "x-sootsim-set-cookie");
+          }
+          return origWriteHead(
+            statusCode,
+            ...args
+          );
+        };
+        next();
+      });
+      server.middlewares.use((req, res, next) => {
+        if ((req.url || "").split("?")[0] !== "/__server-scan") return next();
+        const scanPort = listeningPort();
+        const pluginBundleUrl = bundleForPort(scanPort);
+        const absoluteBundleUrl = pluginBundleUrl.startsWith("http") ? pluginBundleUrl : `http://localhost:${scanPort}${pluginBundleUrl}`;
+        res.setHeader("content-type", "application/json");
+        res.end(
+          JSON.stringify([
+            {
+              port: scanPort,
+              framework: "one",
+              bundleUrl: absoluteBundleUrl,
+              ...appName ? { projectName: appName } : {},
+              lastSeen: Date.now()
+            }
+          ])
+        );
+      });
+      server.middlewares.use((req, res, next) => {
+        void handleReplacementModuleRequest(req, res, {
+          projectRoot: server.config.root,
+          requestToken: replacementToken,
+          requireLoopbackOrigin: true
+        }).then((handled) => {
+          if (!handled) next();
+        });
+      });
+      server.middlewares.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 + "/" || pathname.startsWith(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 === prefix || pathname === prefix + "/") {
+          res.setHeader("content-type", "text/html");
+          res.end(buildShellHtml(runtimeRoot));
+          return;
+        }
+        if (pathname.startsWith(prefix + "/")) {
+          const fullPath = resolveRuntimeFilePath(
+            runtimeRoot,
+            pathname.slice(prefix.length)
+          );
+          if (fullPath) {
+            serveRuntimeFile(req, res, fullPath);
+            return;
+          }
+          const ext = import_path2.default.extname(pathname);
+          if (!ext) {
+            res.setHeader("content-type", "text/html");
+            res.end(buildShellHtml(runtimeRoot));
+            return;
+          }
+        }
+        next();
+      });
+      const port = configuredPort;
+      const sootsimUrl = `http://localhost:${port}${prefix}/`;
+      console.log(`[rnx] serving at ${sootsimUrl}`);
+      if (appName && !process.env.CI && !process.env.RNX_NO_OPEN) {
+        server.httpServer?.once("listening", () => {
+          const openPort = listeningPort();
+          launchRnxDesktop(
+            resolveRnxDesktopLaunchTarget(openPort, bundleForPort(openPort)),
+            appName
+          );
+        });
+      }
+    }
+  };
+}
+var sootsimPlugin = rnxPlugin;
+var vite_plugin_one_default = rnxPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rnxPlugin,
+  sootsimPlugin,
+  swiftPlugin,
+  swiftRemotePlugin
+});