peachsim 0.1.527

package/dist-lib/index.cjs

@@ -0,0 +1,4268 @@
+/*! 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 name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_SOOTSIM_BRIDGE_PORT: () => DEFAULT_SOOTSIM_BRIDGE_PORT,
+  DEFAULT_SOOTSIM_BRIDGE_URL: () => DEFAULT_SOOTSIM_BRIDGE_URL,
+  DEFAULT_SOOTSIM_SHELL_URL: () => DEFAULT_SOOTSIM_SHELL_URL,
+  RNX_SCREEN_CAPTURE_VERSION: () => RNX_SCREEN_CAPTURE_VERSION,
+  SimClient: () => SimClient,
+  SimClientError: () => SimClientError,
+  SimConnectError: () => SimConnectError,
+  SimKeyboardError: () => SimKeyboardError,
+  SimPerformError: () => SimPerformError,
+  SimReadyTimeoutError: () => SimReadyTimeoutError,
+  SimResetError: () => SimResetError,
+  SimTapError: () => SimTapError,
+  connect: () => connect,
+  isRnxCaptureRegionAtlas: () => isRnxCaptureRegionAtlas,
+  isRnxScreenCapture: () => isRnxScreenCapture,
+  jumpToSourceBabelPlugin: () => sootsimJumpToSourceBabelPlugin,
+  metroPlugin: () => metro_plugin_default,
+  rnxCaptureRasterRegions: () => rnxCaptureRasterRegions,
+  rnxPlugin: () => rnxPlugin,
+  rnxRasterFrames: () => rnxRasterFrames,
+  selectRnxRasterNodeIds: () => selectRnxRasterNodeIds
+});
+module.exports = __toCommonJS(src_exports);
+
+// cli/cloud-client.ts
+var import_node_crypto = require("node:crypto");
+
+// ../sootsim-engine/src/metro-fingerprint-registry-client.ts
+var import_metro_fingerprint_registry = require("rnxsim/metro-fingerprint-registry");
+
+// ../sootsim-engine/src/metro-fingerprint.ts
+var import_metro_production_bundle = require("rnxsim/metro-production-bundle");
+var import_react_native_host_modules = require("rnxsim/react-native-host-modules");
+
+// 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/cloud-contract.ts
+var RNX_CLOUD_MAX_ARTIFACT_BYTES = 20 * 1024 * 1024;
+var RNX_CLOUD_DESIGN_MAX_STORAGE_BYTES = 1024 * 1024;
+var RNX_CLOUD_COMMAND_SCOPES = {
+  state: "read",
+  tree: "read",
+  query: "read",
+  resolve: "read",
+  screenshot: "read",
+  capture: "read",
+  captureRegions: "read",
+  memory: "read",
+  diagnostics: "read",
+  storageSnapshot: "read",
+  perform: "drive",
+  waitFor: "drive",
+  tap: "drive",
+  longPress: "drive",
+  settle: "drive",
+  openUrl: "drive",
+  setAppearance: "drive",
+  keyboard: "drive",
+  focus: "drive",
+  flowStatus: "drive",
+  reset: "reset",
+  camera: "media",
+  // string evaluation and arbitrary bridge calls are maestro's boundary: the
+  // customer sdk never carries this scope, and the service grants it only to
+  // the account api key caller. close rides along, since ending the page ends
+  // the sim and belongs to the sim's owner rather than any driver.
+  evaluate: "debug",
+  call: "debug",
+  close: "debug"
+};
+function scopeTableKeys() {
+  return Object.keys(RNX_CLOUD_COMMAND_SCOPES).filter(
+    (key) => Object.prototype.hasOwnProperty.call(RNX_CLOUD_COMMAND_SCOPES, key)
+  );
+}
+var RNX_CLOUD_COMMAND_TYPES = Object.freeze(scopeTableKeys());
+var RNX_CLOUD_COMMAND_TYPE_SET = new Set(RNX_CLOUD_COMMAND_TYPES);
+function isRnxCloudCommandType(value) {
+  return RNX_CLOUD_COMMAND_TYPE_SET.has(value);
+}
+function rnxCloudCommandScope(type) {
+  return RNX_CLOUD_COMMAND_SCOPES[type];
+}
+var RNX_CLOUD_TOKEN_SCOPES = Object.freeze([
+  "read",
+  "drive",
+  "reset",
+  "media"
+]);
+var RNX_CLOUD_ALL_COMMAND_SCOPES = Object.freeze(["read", "drive", "reset", "media", "debug"]);
+function rnxCloudScopesAllowCommand(scopes, type) {
+  return scopes.includes(RNX_CLOUD_COMMAND_SCOPES[type]);
+}
+
+// src/metro-production-bundle.ts
+var RNXSIM_METRO_MODULE_PATHS_PREFIX = "globalThis.__sootsimModulePaths=";
+var RNX_METRO_MODULE_IDENTITY_VERSION = 2;
+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/public-brand.ts
+var name = "rnx";
+var rnxPublicBrand = Object.freeze({
+  name,
+  packageName: "rnxsim",
+  commandName: "rnx",
+  domain: "rnxsim.com",
+  origin: "https://rnxsim.com"
+});
+
+// src/home-paths.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"), 1);
+var RNX_HOME_ENV = "RNX_HOME";
+var ACTIVE_RUNTIME_FILE = "active";
+var DAEMON_LOCKFILE = "daemon.json";
+var DEV_BRIDGES_DIR = "dev-bridges";
+var DAEMON_HEARTBEAT_STALE_MS = 3e4;
+function rnxHomeDir() {
+  const override = process.env[RNX_HOME_ENV];
+  if (override && override.length > 0) return import_node_path.default.resolve(override);
+  return import_node_path.default.join((0, import_node_os.homedir)(), ".rnx");
+}
+function runtimesDir() {
+  return import_node_path.default.join(rnxHomeDir(), "runtimes");
+}
+function runtimeDir(version) {
+  return import_node_path.default.join(runtimesDir(), version);
+}
+function activeRuntimeFile() {
+  return import_node_path.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+}
+function daemonLockfilePath() {
+  return import_node_path.default.join(rnxHomeDir(), DAEMON_LOCKFILE);
+}
+function devBridgesDir() {
+  return import_node_path.default.join(rnxHomeDir(), DEV_BRIDGES_DIR);
+}
+function readActiveRuntime() {
+  try {
+    const value = import_node_fs.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+function readDaemonLockfile() {
+  try {
+    const fd = import_node_fs.default.openSync(daemonLockfilePath(), "r");
+    try {
+      const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
+      const bytesRead = import_node_fs.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_fs.default.closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+function parseDevBridgeLockfile(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && parsed.schema === 1 && parsed.source === "vite-dev" && typeof parsed.pid === "number" && typeof parsed.bridgePort === "number" && typeof parsed.runtimePort === "number" && typeof parsed.cwd === "string" && typeof parsed.startedAt === "number" && typeof parsed.heartbeatAt === "number" && (parsed.shellPort === void 0 || typeof parsed.shellPort === "number") && (parsed.servedRuntimes === void 0 || Array.isArray(parsed.servedRuntimes) && parsed.servedRuntimes.every((version) => typeof version === "string"))) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function readDevBridgeLockfiles() {
+  let entries;
+  try {
+    entries = import_node_fs.default.readdirSync(devBridgesDir(), { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const lockfiles = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !/^\d+\.json$/.test(entry.name)) continue;
+    try {
+      const filePath = import_node_path.default.join(devBridgesDir(), entry.name);
+      const fd = import_node_fs.default.openSync(filePath, "r");
+      try {
+        const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
+        const bytesRead = import_node_fs.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
+        const lockfile = parseDevBridgeLockfile(
+          buf.subarray(0, bytesRead).toString("utf8")
+        );
+        if (lockfile && entry.name === `${lockfile.bridgePort}.json`) {
+          lockfiles.push(lockfile);
+        }
+      } finally {
+        import_node_fs.default.closeSync(fd);
+      }
+    } catch {
+    }
+  }
+  return lockfiles.sort((left, right) => left.bridgePort - right.bridgePort);
+}
+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;
+  }
+}
+function isDevBridgeLockfileFresh(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;
+  }
+}
+
+// cli/run-rnx.ts
+var import_node_async_hooks = require("node:async_hooks");
+var sinks = new import_node_async_hooks.AsyncLocalStorage();
+
+// cli/auth.ts
+var CHOOSE_ACCOUNT_HINT = "this sign-in belongs to several accounts; run `rnx login --account <name>` to choose the one to bill";
+
+// cli/cloud-session.ts
+var CLOUD_SESSION_VERSION = 3;
+var MAX_ENCODED_SESSION_BYTES = 32 * 1024;
+var RNX_CLOUD_SESSION_ENV = "RNX_CLOUD_SESSION";
+var RNX_SHELL_UPDATE_PREFIX = "__RNX_SHELL_UPDATE_V1__";
+var RNX_SHELL_UPDATE_SET_PREFIX = `${RNX_SHELL_UPDATE_PREFIX}set:`;
+var RNX_SHELL_UPDATE_UNSET = `${RNX_SHELL_UPDATE_PREFIX}unset`;
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeCloudOrigin(source) {
+  let parsed;
+  try {
+    parsed = new URL(source);
+  } catch {
+    throw new Error(`invalid remote simulator origin: ${source}`);
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:" || parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+    throw new Error(`remote simulator origin must be an HTTP(S) origin: ${source}`);
+  }
+  if (parsed.protocol === "http:" && !isLoopbackHost(parsed.hostname)) {
+    throw new Error(`remote simulator origin requires HTTPS outside loopback: ${source}`);
+  }
+  return parsed.origin;
+}
+function createCloudSession(input) {
+  const boxId = input.boxId?.trim() ?? "";
+  const boxToken = input.boxToken ?? "";
+  if (boxId === "" !== (boxToken === "")) {
+    throw new Error("cloud session names a box with both its id and its token");
+  }
+  const session = {
+    version: CLOUD_SESSION_VERSION,
+    service: "sim",
+    simId: input.simId.trim(),
+    apiOrigin: normalizeCloudOrigin(input.apiOrigin.trim()),
+    claimId: input.claimId.trim(),
+    token: input.token,
+    ...input.streamUrl ? { streamUrl: input.streamUrl } : {},
+    ...input.platform ? { platform: input.platform } : {},
+    ...input.device?.trim() ? { device: input.device.trim() } : {},
+    ...input.artifact ? { artifact: input.artifact } : {},
+    ...boxId && boxToken ? { boxId, boxToken } : {}
+  };
+  if (!session.simId || !session.claimId || !session.token) {
+    throw new Error("cloud session requires a simulator, an origin, a claim, and a token");
+  }
+  return session;
+}
+function parseCloudSession(encoded) {
+  const value = encoded.trim();
+  if (!value || value.length > MAX_ENCODED_SESSION_BYTES || !/^[A-Za-z0-9_-]+$/.test(value)) {
+    throw new Error(`${RNX_CLOUD_SESSION_ENV} is invalid`);
+  }
+  let parsed;
+  try {
+    const bytes = Buffer.from(value, "base64url");
+    if (bytes.toString("base64url") !== value) {
+      throw new Error("non-canonical cloud session");
+    }
+    parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new Error(`${RNX_CLOUD_SESSION_ENV} is invalid`);
+  }
+  if (!isRecord(parsed) || parsed.version !== CLOUD_SESSION_VERSION) {
+    throw new Error(`${RNX_CLOUD_SESSION_ENV} is invalid`);
+  }
+  const apiOrigin = parsed.apiOrigin;
+  if (typeof apiOrigin !== "string") {
+    throw new Error(`${RNX_CLOUD_SESSION_ENV} is invalid`);
+  }
+  const platform = parsed.platform === "ios" || parsed.platform === "android" ? parsed.platform : void 0;
+  const device = typeof parsed.device === "string" ? parsed.device : void 0;
+  const artifact = isRecord(parsed.artifact) && typeof parsed.artifact.sha256 === "string" ? {
+    sha256: parsed.artifact.sha256,
+    bytes: typeof parsed.artifact.bytes === "number" ? parsed.artifact.bytes : void 0
+  } : void 0;
+  const streamUrl = typeof parsed.streamUrl === "string" ? parsed.streamUrl : void 0;
+  const boxId = typeof parsed.boxId === "string" ? parsed.boxId : void 0;
+  const boxToken = typeof parsed.boxToken === "string" ? parsed.boxToken : void 0;
+  try {
+    const simId = parsed.simId;
+    const claimId = parsed.claimId;
+    const token = parsed.token;
+    if (parsed.service !== "sim" || typeof simId !== "string" || typeof claimId !== "string" || typeof token !== "string") {
+      throw new Error("unreadable cloud session");
+    }
+    return createCloudSession({
+      simId,
+      apiOrigin,
+      claimId,
+      token,
+      streamUrl,
+      platform,
+      device,
+      artifact,
+      boxId,
+      boxToken
+    });
+  } catch {
+    throw new Error(`${RNX_CLOUD_SESSION_ENV} is invalid`);
+  }
+}
+function readCloudSession(environment = process.env) {
+  const encoded = environment[RNX_CLOUD_SESSION_ENV];
+  return encoded?.trim() ? parseCloudSession(encoded) : null;
+}
+
+// cli/cloud-client.ts
+var DEFAULT_RNX_CLOUD_ORIGIN = rnxPublicBrand.origin;
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function failureSentence(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!isRecord2(parsed)) return null;
+  if (isRecord2(parsed.error) && typeof parsed.error.message === "string") {
+    const code = typeof parsed.error.code === "string" && parsed.error.code ? ` [${parsed.error.code}]` : "";
+    return `${parsed.error.message}${code}`;
+  }
+  if (typeof parsed.message === "string") return parsed.message;
+  if (typeof parsed.error === "string") return parsed.error;
+  return null;
+}
+var ACCOUNT_CHOICE_REFUSALS = /* @__PURE__ */ new Set([
+  "accountId is required",
+  "you do not have access to this account"
+]);
+function responseError(status, text) {
+  const parsed = text ? failureSentence(text) : null;
+  const sentence = parsed && ACCOUNT_CHOICE_REFUSALS.has(parsed) ? CHOOSE_ACCOUNT_HINT : parsed;
+  return new Error(
+    `remote simulator request failed (${status})${sentence ? `: ${sentence}` : text.trim() ? `: ${text.trim()}` : ""}`
+  );
+}
+function resolveCloudSessionForParsed(parsed) {
+  const session = readCloudSession();
+  if (!session) return null;
+  if (parsed.simIdSource === "flag" && parsed.simId !== session.simId) {
+    throw new Error(
+      `this shell is connected to remote simulator ${session.simId}; ${parsed.simId ? `--sim ${parsed.simId}` : "the requested simulator"} is not available in this shell`
+    );
+  }
+  return session;
+}
+function cloudCommand(command) {
+  const clean = {};
+  for (const [key, value] of Object.entries(command)) {
+    if (key !== "id" && key !== "simId") clean[key] = value;
+  }
+  if (!isRnxCloudCommandType(command.type)) {
+    throw new Error(
+      `a remote simulator does not support bridge command type ${command.type}`
+    );
+  }
+  if (!rnxCloudScopesAllowCommand(RNX_CLOUD_TOKEN_SCOPES, command.type)) {
+    throw new Error(
+      `a remote simulator command ${command.type} requires the ${rnxCloudCommandScope(command.type)} scope`
+    );
+  }
+  return clean;
+}
+var CloudBridge = class {
+  constructor(session) {
+    this.session = session;
+  }
+  plane = "cloud";
+  async send(command, options) {
+    const body = {
+      id: (0, import_node_crypto.randomUUID)(),
+      claimId: this.session.claimId,
+      command: cloudCommand(command)
+    };
+    let response;
+    try {
+      response = await fetch(
+        `${this.session.apiOrigin}/v1/sims/${encodeURIComponent(this.session.simId)}/commands`,
+        {
+          method: "POST",
+          headers: {
+            authorization: `Bearer ${this.session.token}`,
+            "content-type": "application/json"
+          },
+          body: JSON.stringify(body),
+          ...options?.timeoutMs ? { signal: AbortSignal.timeout(options.timeoutMs) } : {}
+        }
+      );
+    } catch (error) {
+      throw new Error(
+        `could not reach the remote simulator at ${this.session.apiOrigin}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    const text = await response.text();
+    if (!response.ok) throw responseError(response.status, text);
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      throw new Error("remote simulator command returned unreadable JSON");
+    }
+    if (!isRecord2(parsed) || parsed.id !== body.id) {
+      throw new Error("remote simulator command returned an invalid command receipt");
+    }
+    if (typeof parsed.error === "string" && parsed.error) throw new Error(parsed.error);
+    if (!Object.hasOwn(parsed, "result")) {
+      throw new Error("remote simulator command receipt has no result");
+    }
+    return parsed.result;
+  }
+  listSims() {
+    return Promise.reject(
+      new Error("a remote simulator does not expose a local simulator list")
+    );
+  }
+  focusSim() {
+    return Promise.reject(new Error("remote simulators have no browser window to focus"));
+  }
+  resolveReloadedSim() {
+    return Promise.resolve(null);
+  }
+  closeSim() {
+    return Promise.reject(
+      new Error("remote simulator close uses the simulator DELETE route")
+    );
+  }
+  claim() {
+    return Promise.reject(
+      new Error("remote simulator claim uses the simulator claim route")
+    );
+  }
+  close() {
+  }
+};
+function createCloudBridgeForParsed(parsed) {
+  const session = resolveCloudSessionForParsed(parsed);
+  if (!session) return null;
+  return new CloudBridge(session);
+}
+
+// cli/current-sim.ts
+var import_fs2 = require("fs");
+var import_os = require("os");
+var import_path = require("path");
+
+// cli/parent-pid.ts
+var import_child_process = require("child_process");
+var import_fs = require("fs");
+var import_module = require("module");
+var cached = null;
+var cachedComm = null;
+function getParentPid(pid) {
+  if (!cached) cached = build();
+  try {
+    return cached(pid);
+  } catch {
+    return null;
+  }
+}
+function getProcessComm(pid) {
+  if (!cachedComm) cachedComm = buildComm();
+  try {
+    return cachedComm(pid);
+  } catch {
+    return null;
+  }
+}
+function buildComm() {
+  if (process.platform === "linux") {
+    return (pid) => {
+      try {
+        return (0, import_fs.readFileSync)(`/proc/${pid}/comm`, "utf8").trim() || null;
+      } catch {
+        return null;
+      }
+    };
+  }
+  if (process.platform === "darwin") {
+    const ffi = tryBuildDarwinCommFfi();
+    if (ffi) return ffi;
+    return (pid) => readProcessTable().get(pid)?.comm || null;
+  }
+  return () => null;
+}
+function build() {
+  const envPpid = Number(process.env.PPID);
+  if (Number.isFinite(envPpid) && envPpid > 1 && envPpid !== process.ppid) {
+    return () => envPpid;
+  }
+  if (process.platform === "linux") return buildLinux();
+  if (process.platform === "darwin") {
+    const ffi = tryBuildDarwinFfi();
+    if (ffi) return ffi;
+    return (pid) => {
+      const ppid = readProcessTable().get(pid)?.ppid;
+      return ppid !== void 0 && ppid > 0 ? ppid : null;
+    };
+  }
+  return () => null;
+}
+var PROCESS_TABLE_TTL_MS = 2e3;
+var processTable = { readAt: 0, rows: /* @__PURE__ */ new Map() };
+function readProcessTable() {
+  const now = Date.now();
+  if (processTable.readAt && now - processTable.readAt < PROCESS_TABLE_TTL_MS) {
+    return processTable.rows;
+  }
+  const rows = /* @__PURE__ */ new Map();
+  try {
+    const out = (0, import_child_process.execFileSync)("ps", ["-eo", "pid=,ppid=,comm="], {
+      encoding: "utf8",
+      timeout: 5e3,
+      maxBuffer: 8 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    for (const line of out.split("\n")) {
+      const parsed = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+      if (!parsed) continue;
+      rows.set(Number(parsed[1]), {
+        ppid: Number(parsed[2]),
+        comm: (parsed[3].split("/").at(-1) ?? "").slice(0, PBI_COMM_LEN)
+      });
+    }
+  } catch {
+  }
+  processTable = { readAt: now, rows };
+  return rows;
+}
+function buildLinux() {
+  return (pid) => {
+    try {
+      const raw = (0, import_fs.readFileSync)(`/proc/${pid}/stat`, "utf8");
+      const end = raw.lastIndexOf(")");
+      if (end < 0) return null;
+      const rest = raw.slice(end + 1).trim().split(/\s+/);
+      const ppid = Number(rest[1]);
+      return Number.isFinite(ppid) && ppid > 0 ? ppid : null;
+    } catch {
+      return null;
+    }
+  };
+}
+var PROC_PIDTBSDINFO = 3;
+var PROC_BSDINFO_SIZE = 216;
+var PBI_PPID_OFFSET = 16;
+var PBI_COMM_OFFSET = 48;
+var PBI_COMM_LEN = 16;
+function tryBuildDarwinFfi() {
+  if (!process.versions?.bun) return null;
+  try {
+    const r = (0, import_module.createRequire)(__sootsim_import_meta_url);
+    const { dlopen, FFIType } = r("bun:ffi");
+    const lib = dlopen("/usr/lib/libproc.dylib", {
+      proc_pidinfo: {
+        args: [FFIType.i32, FFIType.i32, FFIType.u64, FFIType.ptr, FFIType.i32],
+        returns: FFIType.i32
+      }
+    });
+    const buf = Buffer.alloc(PROC_BSDINFO_SIZE);
+    return (pid) => {
+      const ret = Number(
+        lib.symbols.proc_pidinfo(pid, PROC_PIDTBSDINFO, 0n, buf, PROC_BSDINFO_SIZE)
+      );
+      if (ret <= 0) return null;
+      const ppid = buf.readUInt32LE(PBI_PPID_OFFSET);
+      return ppid > 0 ? ppid : null;
+    };
+  } catch {
+    return null;
+  }
+}
+function tryBuildDarwinCommFfi() {
+  if (!process.versions?.bun) return null;
+  try {
+    const r = (0, import_module.createRequire)(__sootsim_import_meta_url);
+    const { dlopen, FFIType } = r("bun:ffi");
+    const lib = dlopen("/usr/lib/libproc.dylib", {
+      proc_pidinfo: {
+        args: [FFIType.i32, FFIType.i32, FFIType.u64, FFIType.ptr, FFIType.i32],
+        returns: FFIType.i32
+      }
+    });
+    const buf = Buffer.alloc(PROC_BSDINFO_SIZE);
+    return (pid) => {
+      const ret = Number(
+        lib.symbols.proc_pidinfo(pid, PROC_PIDTBSDINFO, 0n, buf, PROC_BSDINFO_SIZE)
+      );
+      if (ret <= 0) return null;
+      const raw = buf.subarray(PBI_COMM_OFFSET, PBI_COMM_OFFSET + PBI_COMM_LEN);
+      const end = raw.indexOf(0);
+      const comm = raw.subarray(0, end < 0 ? raw.length : end).toString("utf8");
+      return comm || null;
+    };
+  } catch {
+    return null;
+  }
+}
+
+// cli/secure-file.ts
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+function writeSecureJsonAtomic(filepath, value) {
+  (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(filepath), { recursive: true });
+  const temporary = `${filepath}.tmp-${process.pid}-${(0, import_node_crypto2.randomUUID)()}`;
+  let descriptor = null;
+  try {
+    descriptor = (0, import_node_fs2.openSync)(temporary, "wx", 384);
+    (0, import_node_fs2.fchmodSync)(descriptor, 384);
+    (0, import_node_fs2.writeFileSync)(descriptor, `${JSON.stringify(value, null, 2)}
+`);
+    (0, import_node_fs2.fsyncSync)(descriptor);
+    (0, import_node_fs2.closeSync)(descriptor);
+    descriptor = null;
+    (0, import_node_fs2.renameSync)(temporary, filepath);
+  } catch (error) {
+    if (descriptor !== null) (0, import_node_fs2.closeSync)(descriptor);
+    (0, import_node_fs2.rmSync)(temporary, { force: true });
+    throw error;
+  }
+}
+
+// cli/current-sim.ts
+var CURRENT_SIM_VERSION = 2;
+var CURRENT_SIM_PATH_ENV = "SOOTSIM_CLI_CURRENT_SIM_PATH";
+var IDENTITY_ENV_VARS = [
+  "RNX_CLI_IDENTITY",
+  // explicit override — fastest path, skips all pid lookups
+  "TM_SESSION",
+  // Team Machine session id; routes prompt-bar followups back to this agent
+  "CLAUDE_CODE_SESSION_ID",
+  // claude code, if ever set
+  "CODEX_THREAD_ID",
+  // codex / openai agent thread, stable across tool invocations
+  "TERM_SESSION_ID",
+  // macOS Terminal.app + iTerm2
+  "ITERM_SESSION_ID",
+  // iTerm2 (older variant)
+  "TMUX_PANE",
+  // tmux — stable per pane
+  "STY",
+  // GNU screen session
+  "KITTY_WINDOW_ID",
+  // kitty
+  "WEZTERM_PANE",
+  // wezterm
+  "ALACRITTY_WINDOW_ID",
+  // alacritty
+  "WINDOWID",
+  // X11 terminals
+  "VSCODE_INJECTION"
+  // vscode integrated terminal
+];
+var IMMORTAL_HOST_COMM_RE = /^(?:tmux|screen)|^tm$/i;
+function findTopAncestor(start, maxDepth = 20) {
+  let prev = start;
+  let pid = getParentPid(start);
+  if (!pid || pid <= 1) {
+    const comm = getProcessComm(start);
+    return start > 1 && comm && !IMMORTAL_HOST_COMM_RE.test(comm) ? start : null;
+  }
+  for (let i = 0; i < maxDepth; i++) {
+    const comm = getProcessComm(pid);
+    if (comm && IMMORTAL_HOST_COMM_RE.test(comm)) return prev;
+    const parent = getParentPid(pid);
+    if (!parent || parent <= 1) {
+      return comm ? pid : prev;
+    }
+    prev = pid;
+    pid = parent;
+  }
+  return pid;
+}
+function getCliIdentity() {
+  for (const name2 of IDENTITY_ENV_VARS) {
+    const value = process.env[name2];
+    if (value && value.trim()) {
+      return { key: `${name2}:${value.trim()}`, source: name2, stable: true };
+    }
+  }
+  const topPid = findTopAncestor(process.ppid);
+  if (topPid && topPid > 1) {
+    return { key: `gppid-${topPid}`, source: "grand-ppid", stable: true };
+  }
+  return { key: `pid-${process.ppid}`, source: "ppid", stable: false };
+}
+function getCliIdentityKey() {
+  return getCliIdentity().key;
+}
+function getCurrentSimPath() {
+  if (process.env[CURRENT_SIM_PATH_ENV]) {
+    return (0, import_path.resolve)(process.env[CURRENT_SIM_PATH_ENV]);
+  }
+  const key = getCliIdentityKey();
+  return (0, import_path.join)((0, import_os.tmpdir)(), `rnx-current-sim-${key}.json`);
+}
+function legacyCloudCredentialDirectory(filepath) {
+  return (0, import_path.join)((0, import_path.dirname)(filepath), `${(0, import_path.basename)(filepath)}.credentials`);
+}
+function readCurrentTarget() {
+  const filepath = getCurrentSimPath();
+  (0, import_fs2.rmSync)(legacyCloudCredentialDirectory(filepath), { recursive: true, force: true });
+  if (!(0, import_fs2.existsSync)(filepath)) return null;
+  try {
+    const parsed = JSON.parse((0, import_fs2.readFileSync)(filepath, "utf8"));
+    if (parsed === null || typeof parsed !== "object") {
+      (0, import_fs2.rmSync)(filepath, { force: true });
+      return null;
+    }
+    const version = Reflect.get(parsed, "version");
+    const plane = Reflect.get(parsed, "plane");
+    const simId = Reflect.get(parsed, "simId");
+    const updatedAt = Reflect.get(parsed, "updatedAt");
+    if (version !== 1 && version !== CURRENT_SIM_VERSION || version === CURRENT_SIM_VERSION && plane !== "local" || typeof simId !== "string" || !simId.trim() || typeof updatedAt !== "string") {
+      (0, import_fs2.rmSync)(filepath, { force: true });
+      return null;
+    }
+    const target = {
+      version: CURRENT_SIM_VERSION,
+      plane: "local",
+      simId: simId.trim(),
+      updatedAt
+    };
+    if (version === 1) writeSecureJsonAtomic(filepath, target);
+    return target;
+  } catch {
+    (0, import_fs2.rmSync)(filepath, { force: true });
+    return null;
+  }
+}
+function readCurrentSimId() {
+  return readCurrentTarget()?.simId ?? null;
+}
+function saveCurrentSimId(simId) {
+  const normalized = simId.trim();
+  if (!normalized) return;
+  writeSecureJsonAtomic(getCurrentSimPath(), {
+    version: CURRENT_SIM_VERSION,
+    plane: "local",
+    simId: normalized,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function clearCurrentSimId() {
+  (0, import_fs2.rmSync)(getCurrentSimPath(), { force: true });
+}
+
+// cli/ws-bridge.ts
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
+var import_ws = require("ws");
+
+// src/bridge-constants.ts
+var DEFAULT_SOOTSIM_BRIDGE_PORT = 7668;
+var DEFAULT_SOOTSIM_BRIDGE_URL = `http://localhost:${DEFAULT_SOOTSIM_BRIDGE_PORT}/`;
+function parsePort(value) {
+  if (typeof value === "number") {
+    return Number.isInteger(value) && value > 0 ? value : null;
+  }
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const parsed = Number(trimmed);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function parsePortOffset(value) {
+  const parsed = parsePort(value);
+  return parsed === null ? 0 : parsed;
+}
+function resolveSootsimBridgePort(input = {}) {
+  const explicitPort = parsePort(input.explicitPort);
+  if (explicitPort !== null) return explicitPort;
+  return DEFAULT_SOOTSIM_BRIDGE_PORT + parsePortOffset(input.portOffset);
+}
+
+// src/cli-constants.ts
+var DEFAULT_SOOTSIM_SHELL_URL = "http://localhost:5173/";
+
+// cli/ws-bridge.ts
+function bridgeWsUrl(wsPort) {
+  return `ws://127.0.0.1:${wsPort}`;
+}
+var resolvedWorld = null;
+function liveDevBridgeLockfiles() {
+  return readDevBridgeLockfiles().filter((lockfile) => isDevBridgeLockfileFresh(lockfile));
+}
+function checkoutRoot(cwd) {
+  let current = import_node_path3.default.resolve(cwd);
+  while (true) {
+    if (import_node_fs3.default.existsSync(import_node_path3.default.join(current, ".git"))) return current;
+    const parent = import_node_path3.default.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function pathContains(parent, child) {
+  const relative2 = import_node_path3.default.relative(parent, child);
+  return relative2 === "" || relative2 !== ".." && !relative2.startsWith(`..${import_node_path3.default.sep}`) && !import_node_path3.default.isAbsolute(relative2);
+}
+function resolveDefaultDevBridgeLockfile() {
+  const lockfiles = liveDevBridgeLockfiles();
+  if (lockfiles.length === 0) return null;
+  if (process.env.SOOTSIM_BRIDGE_PORT !== void 0 || process.env.PORT_OFFSET !== void 0) {
+    const requestedPort = resolveSootsimBridgePort({
+      explicitPort: process.env.SOOTSIM_BRIDGE_PORT,
+      portOffset: process.env.PORT_OFFSET
+    });
+    const requested = lockfiles.find((lockfile) => lockfile.bridgePort === requestedPort);
+    if (requested) return requested;
+  }
+  let cwd = null;
+  try {
+    cwd = process.cwd();
+  } catch {
+  }
+  if (cwd) {
+    const currentCheckout = checkoutRoot(cwd);
+    const sameCheckout = lockfiles.filter((lockfile) => {
+      const bridgeCheckout = checkoutRoot(lockfile.cwd);
+      if (currentCheckout && bridgeCheckout) return currentCheckout === bridgeCheckout;
+      return pathContains(cwd, lockfile.cwd) || pathContains(lockfile.cwd, cwd);
+    });
+    if (sameCheckout.length > 0) {
+      return sameCheckout.find(
+        (lockfile) => lockfile.bridgePort === DEFAULT_SOOTSIM_BRIDGE_PORT
+      ) ?? sameCheckout[0];
+    }
+  }
+  return lockfiles.find((lockfile) => lockfile.bridgePort === DEFAULT_SOOTSIM_BRIDGE_PORT) ?? lockfiles[0];
+}
+function resolveBridgeWorld() {
+  const homeDir = rnxHomeDir();
+  if (resolvedWorld?.homeDir === homeDir) return resolvedWorld.world;
+  const world = resolveBridgeWorldFresh();
+  resolvedWorld = { homeDir, world };
+  return world;
+}
+function resolveBridgeWorldFresh() {
+  const dev = resolveDefaultDevBridgeLockfile();
+  if (dev) {
+    return {
+      source: "dev-bridge",
+      bridgePort: dev.bridgePort,
+      // older lockfile writers don't record the vite http port; the default
+      // shell URL is the dev shell anyway, so the fallback stays coherent.
+      shellBaseUrl: dev.shellPort ? `http://localhost:${dev.shellPort}/` : DEFAULT_SOOTSIM_SHELL_URL
+    };
+  }
+  const lock = readDaemonLockfile();
+  if (lock && isDaemonLockfileFresh(lock)) {
+    return {
+      source: "daemon",
+      bridgePort: lock.bridgePort,
+      shellBaseUrl: lock.runtimePort > 0 ? `http://localhost:${lock.runtimePort}/` : DEFAULT_SOOTSIM_SHELL_URL
+    };
+  }
+  return {
+    source: "default",
+    bridgePort: DEFAULT_SOOTSIM_BRIDGE_PORT,
+    shellBaseUrl: DEFAULT_SOOTSIM_SHELL_URL
+  };
+}
+var BridgeSimLockedError = class extends Error {
+  lock;
+  constructor(message, lock) {
+    super(message);
+    this.name = "BridgeSimLockedError";
+    this.lock = lock;
+  }
+};
+function describeSimIdSource(source) {
+  if (source === "flag") return "via --sim";
+  if (source === "saved") return "saved via `rnx use`";
+  return "primary fallback \u2014 no sim pinned";
+}
+var BRIDGE_VALUE_FLAGS_TABLE = [
+  {
+    names: ["--port", "-p"],
+    // naming the flag pins the world even when the value is missing or junk,
+    // so a later --base-url cannot quietly retarget the run to another shell.
+    apply: (state, value) => {
+      state.explicitPort = true;
+      if (value !== void 0) state.wsPort = Number(value);
+    }
+  },
+  {
+    names: ["--timeout"],
+    apply: (state, value) => {
+      if (value !== void 0) state.commandTimeoutMs = Number(value);
+    }
+  },
+  {
+    // `--sim` is the canonical target flag; `--session` / `--tab` are
+    // documented aliases (CLAUDE.md, the rnx agent skills, and engine docs all
+    // say `--session <id>`). without these aliases an agent following the docs
+    // would have `--session ef` silently ignored and get the *currently
+    // pinned* sim's tree instead — wrong-app data with no error.
+    names: ["--sim", "--session", "--tab"],
+    apply: (state, value) => {
+      if (value === void 0) return;
+      state.simId = value.trim() || void 0;
+      state.simIdSource = "flag";
+    }
+  }
+];
+var BRIDGE_VALUE_FLAGS = BRIDGE_VALUE_FLAGS_TABLE.flatMap(
+  (flag) => [...flag.names]
+);
+function createBridge(wsPort, opts = {}) {
+  let nextId = 1;
+  const commandTimeoutMs = opts.commandTimeoutMs ?? 15e3;
+  const pending = /* @__PURE__ */ new Map();
+  const ws = new import_ws.WebSocket(bridgeWsUrl(wsPort));
+  const identity = getCliIdentity();
+  const ready = new Promise((resolve3, reject) => {
+    ws.on("open", () => {
+      try {
+        ws.send(
+          JSON.stringify({
+            type: "bridge:hello",
+            id: 0,
+            cliIdentityKey: identity.key,
+            cliIdentitySource: identity.source,
+            cliLabel: opts.cliLabel
+          })
+        );
+      } catch {
+      }
+      resolve3();
+    });
+    ws.on("error", (err) => {
+      const cause = err.message ? `: ${err.message}` : "";
+      reject(new Error(`could not connect to ${bridgeWsUrl(wsPort)}${cause}`));
+    });
+  });
+  ready.catch(() => {
+  });
+  let warnedAboutContention = false;
+  let noticedTarget = false;
+  const lineageBySimId = /* @__PURE__ */ new Map();
+  const lineageLookupBySimId = /* @__PURE__ */ new Map();
+  function pickReloadedTarget(sims, retiredSimId) {
+    const lineage = lineageBySimId.get(retiredSimId);
+    if (!lineage) return null;
+    const matches = (Array.isArray(sims) ? sims : []).filter(
+      (sim) => sim.readyState === "open" && sim.meta?.sootsimHostPid === lineage.hostPid && sim.connectedAt > lineage.connectedAt
+    );
+    const successor = matches.find((sim) => sim.id === retiredSimId) ?? (matches.length === 1 ? matches[0] : null);
+    if (!successor) return null;
+    lineageBySimId.set(successor.id, {
+      hostPid: lineage.hostPid,
+      connectedAt: successor.connectedAt
+    });
+    return successor.id;
+  }
+  function maybeNoticeTarget(cmdType, simId) {
+    if (noticedTarget) return;
+    if (process.env.SOOTSIM_QUIET_TARGET_NOTICE === "1") return;
+    if (cmdType.startsWith("bridge:") || cmdType === "focus" || cmdType === "close")
+      return;
+    noticedTarget = true;
+    const label = simId ?? "primary";
+    const source = describeSimIdSource(simId ? opts.simIdSource : "none");
+    process.stderr.write(`  \u2192 ${label} (${source})
+`);
+  }
+  ws.on("message", (data) => {
+    let msg;
+    try {
+      msg = JSON.parse(data.toString());
+    } catch {
+      return;
+    }
+    if (msg.id === 0) return;
+    const p = pending.get(msg.id);
+    if (!p) return;
+    pending.delete(msg.id);
+    if (msg._otherCliCount > 0 && !warnedAboutContention) {
+      warnedAboutContention = true;
+      process.stderr.write(
+        `
+  \u26A0 ${msg._otherCliCount} other CLI identity/identities are driving this sim
+  taps, scrolls, and keyboard input from multiple agents will collide on
+  the same screen state (this is not a bridge throughput limit).
+  use \`rnx open --new\` for an isolated sim per agent.
+
+`
+      );
+    }
+    if (msg.error) {
+      if (msg._locked) {
+        p.reject(new BridgeSimLockedError(msg.error, msg._locked));
+      } else {
+        p.reject(new Error(msg.error));
+      }
+    } else {
+      p.resolve(msg.result);
+    }
+  });
+  ws.on("close", (code, reason) => {
+    const msg = reason?.toString() || "connection closed";
+    for (const [id, p] of pending) {
+      pending.delete(id);
+      p.reject(new Error(`sim disconnected: ${msg} (code ${code})`));
+    }
+  });
+  return {
+    plane: "local",
+    async send(cmd, callOpts) {
+      const effectiveTimeoutMs = callOpts?.timeoutMs ?? commandTimeoutMs;
+      const sendOnce = async (defaultSimId, cmdOverride) => {
+        await ready;
+        const id = nextId++;
+        return new Promise((resolve3, reject) => {
+          const timeout = setTimeout(() => {
+            pending.delete(id);
+            reject(
+              new Error(
+                `command timed out after ${Math.round(effectiveTimeoutMs / 1e3)}s`
+              )
+            );
+          }, effectiveTimeoutMs);
+          pending.set(id, {
+            resolve: (v) => {
+              clearTimeout(timeout);
+              resolve3(v);
+            },
+            reject: (e) => {
+              clearTimeout(timeout);
+              reject(e);
+            }
+          });
+          const payload = { ...cmdOverride ?? cmd, id };
+          if (payload.simId === void 0 && defaultSimId) {
+            payload.simId = defaultSimId;
+          }
+          maybeNoticeTarget(payload.type ?? "", payload.simId);
+          ws.send(JSON.stringify(payload));
+        });
+      };
+      const sentSimId = opts.simIdSource === "flag" ? opts.simId : readCurrentSimId() ?? opts.simId;
+      const targetedSimId = typeof cmd.simId === "string" && cmd.simId ? cmd.simId : sentSimId;
+      try {
+        if (targetedSimId && cmd.type !== "bridge:list-sims" && !lineageBySimId.has(targetedSimId)) {
+          let lookup = lineageLookupBySimId.get(targetedSimId);
+          if (!lookup) {
+            lookup = (async () => {
+              try {
+                const sims = await sendOnce(void 0, { type: "bridge:list-sims" });
+                if (!Array.isArray(sims)) return;
+                const targeted = sims.find(
+                  (sim) => sim.id === targetedSimId
+                );
+                const hostPid = targeted?.meta?.sootsimHostPid;
+                if (targeted && typeof hostPid === "number") {
+                  lineageBySimId.set(targetedSimId, {
+                    hostPid,
+                    connectedAt: targeted.connectedAt
+                  });
+                }
+              } catch {
+              } finally {
+                lineageLookupBySimId.delete(targetedSimId);
+              }
+            })();
+            lineageLookupBySimId.set(targetedSimId, lookup);
+          }
+          await lookup;
+        }
+        return await sendOnce(sentSimId);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const missingSimMessage = `no sim connected with id ${sentSimId}`;
+        if (opts.simIdSource !== "flag" && sentSimId && cmd.simId === void 0 && (message === missingSimMessage || message.startsWith(`${missingSimMessage};`))) {
+          const successor = pickReloadedTarget(
+            await sendOnce(void 0, { type: "bridge:list-sims" }),
+            sentSimId
+          );
+          if (successor) {
+            saveCurrentSimId(successor);
+            process.stderr.write(
+              `  note: sim ${sentSimId} reloaded and reconnected as ${successor}; following it
+`
+            );
+            return sendOnce(successor);
+          }
+          clearCurrentSimId();
+          throw new Error(
+            `saved sim ${sentSimId} is gone${message.slice(missingSimMessage.length)}; run \`rnx list\` and \`rnx use <sim>\`, or open a fresh sim`
+          );
+        }
+        throw error;
+      }
+    },
+    async listSims() {
+      const sims = await this.send({ type: "bridge:list-sims" });
+      return Array.isArray(sims) ? sims : [];
+    },
+    // a caller holding its own pinned sim id (a flow runner sets simId on every
+    // command, so it never reaches the pin-following path in send) asks here
+    // after a reload retires its socket. the page can reconnect under a new id
+    // or restore the old id; null means no unique same-host target exists.
+    async resolveReloadedSim(retiredSimId) {
+      return pickReloadedTarget(await this.listSims(), retiredSimId);
+    },
+    async focusSim(simId) {
+      return this.send({ type: "focus", simId });
+    },
+    async closeSim(simId) {
+      return this.send({ type: "close", simId });
+    },
+    async claim(simId, claimOpts = {}) {
+      const result = await this.send({
+        type: "bridge:claim",
+        simId,
+        force: claimOpts.force === true
+      });
+      return result;
+    },
+    close() {
+      try {
+        if (ws.readyState === import_ws.WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: "bridge:bye", id: 0 }));
+        }
+      } catch {
+      }
+      ws.close();
+      const terminateGrace = setTimeout(() => {
+        if (ws.readyState !== import_ws.WebSocket.CLOSED) {
+          ws.terminate();
+        }
+      }, 250);
+      ws.once("close", () => clearTimeout(terminateGrace));
+    }
+  };
+}
+
+// src/bridge-contract.ts
+var PUBLIC_NO_NETWORK_MARKER = "public RNX Cloud simulators have no network";
+var HEADLESS_TENANT_FETCH_HUNG_MARKER = "headless tenant fetch hung";
+
+// cli/commands/inspect/core.ts
+async function inspectTree(bridge, depth = 5) {
+  const result = await bridge.send({
+    type: "query",
+    query: { kind: "tree", depth }
+  });
+  const tree = isSemanticQueryResult(result) ? result.nodes : [];
+  return { depth, tree };
+}
+async function inspectUrl(bridge) {
+  const url = await bridge.send({ type: "evaluate", code: "window.location.href" });
+  return { url: typeof url === "string" ? url : "" };
+}
+function isSemanticGeometry(value) {
+  return value !== null && typeof value === "object" && [
+    Reflect.get(value, "x"),
+    Reflect.get(value, "y"),
+    Reflect.get(value, "width"),
+    Reflect.get(value, "height")
+  ].every(
+    (coordinate) => typeof coordinate === "number" ? Number.isFinite(coordinate) : false
+  );
+}
+function isSimSemanticTree(value) {
+  if (!Array.isArray(value)) return false;
+  return value.every((node) => {
+    if (node === null || typeof node !== "object" || !Number.isInteger(Reflect.get(node, "nodeId")) || typeof Reflect.get(node, "type") !== "string" || !isSemanticGeometry(Reflect.get(node, "geometry"))) {
+      return false;
+    }
+    for (const key of ["testID", "text", "role", "label"]) {
+      const value2 = Reflect.get(node, key);
+      if (value2 !== void 0 && typeof value2 !== "string") return false;
+    }
+    const pressable = Reflect.get(node, "pressable");
+    if (pressable !== void 0 && pressable !== true) return false;
+    const children = Reflect.get(node, "children");
+    return children === void 0 || isSimSemanticTree(children);
+  });
+}
+function isSemanticQueryResult(value) {
+  const total = value !== null && typeof value === "object" ? Reflect.get(value, "total") : void 0;
+  return value !== null && typeof value === "object" && typeof total === "number" && Number.isInteger(total) && total >= 0 && isSimSemanticTree(Reflect.get(value, "nodes"));
+}
+function globRegex(glob) {
+  const escaped = glob.replace(/[.+^$(){}|[\]\\]/g, "\\$&");
+  return new RegExp(`^${escaped.replace(/\*/g, ".*").replace(/\?/g, ".")}$`, "i");
+}
+function formatSemanticTree(nodes, opts = {}) {
+  const filter = opts.filter?.toLowerCase() ?? "";
+  const testIDRegex = opts.testIdLike ? globRegex(opts.testIdLike) : null;
+  const onlyRegex = opts.onlyGlob ? globRegex(opts.onlyGlob) : null;
+  const lines = [];
+  const visit = (node, indent) => {
+    const joined = [node.role, node.label, node.text, node.testID].filter((value) => typeof value === "string").join(" ");
+    const matches = (!filter || joined.toLowerCase().includes(filter)) && (!testIDRegex || testIDRegex.test(node.testID ?? "")) && (!onlyRegex || onlyRegex.test(joined));
+    if (matches) {
+      const parts = [
+        node.role ? `[${node.role}]` : node.pressable ? "[tap]" : `<${node.type}>`
+      ];
+      if (node.text) {
+        const text = opts.fullText || node.text.length <= 50 ? node.text : `${node.text.slice(0, 49).trimEnd()}\u2026`;
+        parts.push(JSON.stringify(text));
+      }
+      if (node.testID) parts.push(`#${node.testID}`);
+      if (node.label && node.label !== node.text) {
+        parts.push(`label=${JSON.stringify(node.label)}`);
+      }
+      if (!opts.hideXy) {
+        const geometry = node.geometry;
+        parts.push(
+          `@(${Math.round(geometry.x)},${Math.round(geometry.y)}) ${Math.round(geometry.width)}x${Math.round(geometry.height)}`
+        );
+      }
+      if (node.pressable) parts.push("(tap)");
+      lines.push(`${"  ".repeat(indent + 1)}${parts.join(" ")}`);
+    }
+    for (const child of node.children ?? []) visit(child, indent + 1);
+  };
+  let roots = nodes;
+  if (opts.subtreeRoot) {
+    const pending = [...nodes];
+    let found;
+    while (pending.length > 0 && !found) {
+      const candidate = pending.shift();
+      if (!candidate) continue;
+      if (candidate.testID === opts.subtreeRoot) found = candidate;
+      else pending.push(...candidate.children ?? []);
+    }
+    if (!found) return `__SUBTREE_NOT_FOUND__:${opts.subtreeRoot}`;
+    roots = [found];
+  }
+  for (const root of roots) visit(root, 0);
+  return lines.join("\n");
+}
+async function inspectDescribe(bridge, dumpOpts) {
+  const dumpDepth = dumpOpts.maxDepth ?? 12;
+  const result = await bridge.send({
+    type: "query",
+    query: { kind: "tree", depth: dumpDepth }
+  });
+  if (!isSemanticQueryResult(result)) return {};
+  return {
+    tree: formatSemanticTree(result.nodes, dumpOpts),
+    nodeCount: result.total
+  };
+}
+function scoreLayoutTextContrast(input) {
+  const required = input.fontSize >= 18 || input.fontSize >= 14 && (input.fontWeight ?? 400) >= 700 ? 3 : 4.5;
+  const { normal, background } = input;
+  if (normal.width <= 0 || normal.height <= 0 || normal.width !== background.width || normal.height !== background.height) {
+    return { ratio: null, required, reason: "capture dimensions do not match" };
+  }
+  const left = Math.max(0, Math.floor(input.box.x));
+  const top = Math.max(0, Math.floor(input.box.y));
+  const right = Math.min(normal.width, Math.ceil(input.box.x + input.box.w));
+  const bottom = Math.min(normal.height, Math.ceil(input.box.y + input.box.h));
+  if (right <= left || bottom <= top) {
+    return { ratio: null, required, reason: "text is outside the captured frame" };
+  }
+  const linear = (value) => {
+    const channel = value / 255;
+    return channel <= 0.04045 ? channel / 12.92 : Math.pow((channel + 0.055) / 1.055, 2.4);
+  };
+  const ratioOf = (foreground, behind) => {
+    const foregroundLuminance = 0.2126 * linear(foreground[0]) + 0.7152 * linear(foreground[1]) + 0.0722 * linear(foreground[2]);
+    const backgroundLuminance = 0.2126 * linear(behind[0]) + 0.7152 * linear(behind[1]) + 0.0722 * linear(behind[2]);
+    return (Math.max(foregroundLuminance, backgroundLuminance) + 0.05) / (Math.min(foregroundLuminance, backgroundLuminance) + 0.05);
+  };
+  const hex = (color) => `#${color.slice(0, 3).map((value) => Math.round(value).toString(16).padStart(2, "0")).join("")}`;
+  const area = (right - left) * (bottom - top);
+  const step = Math.max(1, Math.floor(Math.sqrt(area / 12e3)));
+  const offsetAt = (x, y) => (y * normal.width + x) * 4;
+  const deltaAt = (offset) => Math.max(
+    Math.abs(normal.data[offset] - background.data[offset]),
+    Math.abs(normal.data[offset + 1] - background.data[offset + 1]),
+    Math.abs(normal.data[offset + 2] - background.data[offset + 2])
+  );
+  let strongestDelta = 0;
+  let strongestForeground = null;
+  let opaqueBackground = null;
+  for (let y = top; y < bottom; y += step) {
+    for (let x = left; x < right; x += step) {
+      const offset = offsetAt(x, y);
+      if (background.data[offset + 3] < 250) continue;
+      const behind = [
+        background.data[offset],
+        background.data[offset + 1],
+        background.data[offset + 2]
+      ];
+      opaqueBackground ??= behind;
+      const delta = deltaAt(offset);
+      if (delta <= strongestDelta) continue;
+      strongestDelta = delta;
+      strongestForeground = [
+        normal.data[offset],
+        normal.data[offset + 1],
+        normal.data[offset + 2]
+      ];
+    }
+  }
+  let bestRatio = Infinity;
+  let bestForeground = null;
+  let bestBackground = null;
+  const consider = (foreground, behind) => {
+    const ratio = ratioOf(foreground, behind);
+    if (ratio >= bestRatio) return;
+    bestRatio = ratio;
+    bestForeground = foreground;
+    bestBackground = behind;
+  };
+  if (strongestDelta >= 2 && strongestForeground) {
+    for (let y = top; y < bottom; y += step) {
+      for (let x = left; x < right; x += step) {
+        const offset = offsetAt(x, y);
+        if (background.data[offset + 3] < 250 || deltaAt(offset) < 2) {
+          continue;
+        }
+        consider(strongestForeground, [
+          background.data[offset],
+          background.data[offset + 1],
+          background.data[offset + 2]
+        ]);
+      }
+    }
+  } else if (opaqueBackground) {
+    consider(opaqueBackground, opaqueBackground);
+  }
+  if (!bestForeground || !bestBackground || !Number.isFinite(bestRatio)) {
+    return {
+      ratio: null,
+      required,
+      reason: "could not isolate opaque rendered text pixels"
+    };
+  }
+  return {
+    ratio: Math.round(bestRatio * 100) / 100,
+    required,
+    foreground: hex(bestForeground),
+    background: hex(bestBackground)
+  };
+}
+function layoutGetNativeEval(opts = {}) {
+  const includeStyle = opts.styling === true;
+  const filter = opts.filter?.trim().toLowerCase() ?? "";
+  return `(async () => {
+      const t = window.__sootsimTest
+      if (!t || typeof t.listInspectable !== 'function') return []
+      const list = await t.listInspectable({})
+      if (!Array.isArray(list)) return []
+      const includeStyle = ${JSON.stringify(includeStyle)}
+      const scoreContrast = ${scoreLayoutTextContrast.toString()}
+      // narrows by ELEMENT, not by style field: fewer rows, full detail on each.
+      const filter = ${JSON.stringify(filter)}
+      const matchesFilter = (n, text) => {
+        if (!filter) return true
+        const fields = [text, n.testID || n.testId, n.accessibilityRole || n.role, n.type]
+        return fields.some((f) => typeof f === 'string' && f.toLowerCase().includes(filter))
+      }
+
+      const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0)
+      const round = (v) => Math.round(num(v))
+
+      // borderRadius can be authored as a string ("12px") or split per-corner;
+      // prefer the uniform borderRadius, else the largest corner radius present.
+      const radiusOf = (style) => {
+        if (!style) return 0
+        const keys = ['borderRadius','borderTopLeftRadius','borderTopRightRadius','borderBottomLeftRadius','borderBottomRightRadius']
+        let max = 0
+        for (const k of keys) {
+          const raw = style[k]
+          const n = typeof raw === 'number' ? raw : (typeof raw === 'string' ? parseFloat(raw) : NaN)
+          if (Number.isFinite(n)) max = Math.max(max, n)
+        }
+        return Math.round(max)
+      }
+      const fontSizeOf = (style) => {
+        if (!style) return 0
+        const raw = style.fontSize
+        const n = typeof raw === 'number' ? raw : (typeof raw === 'string' ? parseFloat(raw) : NaN)
+        return Number.isFinite(n) ? Math.round(n) : 0
+      }
+      // styling extractors \u2014 omit boring defaults so the agent only sees notable
+      // styling (low opacity, struck text, clipping, a real border/color).
+      const colorStr = (v) => {
+        if (v == null) return undefined
+        const s = String(v).split(' ').join('')
+        return s && s !== 'transparent' && s !== 'rgba(0,0,0,0)' ? s : undefined
+      }
+      const opacityOf = (style) => {
+        const o = style && style.opacity
+        const n = typeof o === 'number' ? o : (typeof o === 'string' ? parseFloat(o) : NaN)
+        return Number.isFinite(n) && n < 1 ? Math.round(n * 100) / 100 : undefined
+      }
+      const weightOf = (style) => {
+        const w = style && style.fontWeight
+        const n = w === 'bold' ? 700 : (typeof w === 'number' ? w : (typeof w === 'string' ? parseInt(w, 10) : NaN))
+        return Number.isFinite(n) && n >= 600 ? n : undefined
+      }
+      const decoOf = (style) => {
+        const d = style && (style.textDecorationLine || style.textDecoration)
+        return d && d !== 'none' && d !== 'normal' ? String(d).split(' ')[0] : undefined
+      }
+      const overflowOf = (style) => (style && style.overflow === 'hidden' ? 'hidden' : undefined)
+      const borderWOf = (style) => {
+        if (!style) return undefined
+        const keys = ['borderWidth','borderTopWidth','borderBottomWidth','borderLeftWidth','borderRightWidth']
+        let max = 0
+        for (const k of keys) {
+          const r = style[k]
+          const n = typeof r === 'number' ? r : (typeof r === 'string' ? parseFloat(r) : NaN)
+          if (Number.isFinite(n)) max = Math.max(max, n)
+        }
+        return max > 0 ? Math.round(max) : undefined
+      }
+      // only meaningful alongside a real border width, so it is resolved by the
+      // caller below rather than on its own.
+      const borderColorOf = (style) => {
+        if (!style) return undefined
+        const keys = ['borderColor','borderTopColor','borderBottomColor','borderLeftColor','borderRightColor']
+        for (const k of keys) {
+          const c = colorStr(style[k])
+          if (c) return c
+        }
+        return undefined
+      }
+
+      const isVisible = (n) => {
+        const layout = n && n.layout
+        if (!layout || layout.width <= 0 || layout.height <= 0) return false
+        const abs = (n && (n.absolute || n.absolutePosition)) || null
+        if (!abs) return true
+        const device = (n && n.device) || {}
+        const screenW = Number(device.width) || window.innerWidth || 0
+        const screenH = Number(device.height) || window.innerHeight || 0
+        if (!screenW || !screenH) return true
+        return abs.x + layout.width > 0 && abs.y + layout.height > 0 && abs.x < screenW && abs.y < screenH
+      }
+
+      const elements = list.filter(isVisible).filter((n) => {
+        const t = typeof n.text === 'string' && n.text.trim() ? n.text.trim() : undefined
+        return matchesFilter(n, t)
+      }).map((n) => {
+        const layout = n.layout || { x: 0, y: 0, width: 0, height: 0 }
+        const abs = n.absolute || n.absolutePosition || { x: layout.x, y: layout.y }
+        const text = typeof n.text === 'string' && n.text.trim() ? n.text.trim() : undefined
+        const base = {
+          ...(typeof n.nodeId === 'number'
+            ? {
+                nodeId: n.nodeId,
+                ancestorIds: Array.isArray(n.ancestors)
+                  ? n.ancestors.map((ancestor) => ancestor && ancestor.nodeId).filter((id) => typeof id === 'number')
+                  : [],
+              }
+            : {}),
+          testID: n.testID || n.testId || undefined,
+          role: n.accessibilityRole || n.role || undefined,
+          type: typeof n.type === 'string' ? n.type : 'node',
+          text,
+          box: { x: round(abs.x), y: round(abs.y), w: round(layout.width), h: round(layout.height) },
+        }
+        if (!includeStyle) return base
+        // computedStyle has the resolved values; style is the curated subset \u2014
+        // fall back across both so radius/fontSize survive either shape.
+        const style = Object.assign({}, n.style || {}, n.computedStyle || {})
+        const pad = (n.boxModel && n.boxModel.padding) || {}
+        const borderWidth = borderWOf(style)
+        return {
+          ...base,
+          borderRadius: radiusOf(style),
+          padding: { t: round(pad.top), r: round(pad.right), b: round(pad.bottom), l: round(pad.left) },
+          fontSize: text ? (fontSizeOf(style) || 14) : 0,
+          color: text ? colorStr(style.color) : undefined,
+          bg: colorStr(style.backgroundColor),
+          opacity: opacityOf(style),
+          fontWeight: weightOf(style),
+          textDecoration: decoOf(style),
+          overflow: overflowOf(style),
+          borderWidth,
+          borderColor: borderWidth ? borderColorOf(style) : undefined,
+        }
+      })
+      const textElements = elements.filter((element) => element.text && element.fontSize > 0)
+      if (!includeStyle || textElements.length === 0) return elements
+
+      const screenshot = window.SootSim && window.SootSim.bridges && window.SootSim.bridges.screenshot
+      if (typeof screenshot !== 'function') {
+        throw new Error('styled native layout requires the rnx capture bridge')
+      }
+      const device = list.find((node) => node && node.device)?.device || {}
+      const width = Math.round(Number(device.width) || window.innerWidth || 0)
+      const height = Math.round(Number(device.height) || window.innerHeight || 0)
+      if (!width || !height) throw new Error('native layout has no capture dimensions')
+      const capture = async (suppressText) => {
+        const dataUrl = await screenshot({
+          format: 'png',
+          outputWidth: width,
+          outputHeight: height,
+          ...(suppressText ? { suppressText: true } : {}),
+        })
+        const image = await new Promise((resolve, reject) => {
+          const next = new Image()
+          next.onload = () => resolve(next)
+          next.onerror = () => reject(new Error('could not decode native layout pixels'))
+          next.src = dataUrl
+        })
+        const canvas = document.createElement('canvas')
+        canvas.width = image.naturalWidth
+        canvas.height = image.naturalHeight
+        const context = canvas.getContext('2d', { willReadFrequently: true })
+        if (!context) throw new Error('could not read native layout pixels')
+        context.drawImage(image, 0, 0)
+        return context.getImageData(0, 0, canvas.width, canvas.height)
+      }
+      const normal = await capture(false)
+      const background = await capture(true)
+      for (const element of textElements) {
+        element.contrast = scoreContrast({
+          normal,
+          background,
+          box: element.box,
+          fontSize: element.fontSize,
+          fontWeight: element.fontWeight,
+        })
+      }
+      return elements
+    })()`;
+}
+var LAYOUT_GET_NATIVE_EVAL = layoutGetNativeEval();
+async function inspectAccessibilityTree(bridge) {
+  const result = await bridge.send({
+    type: "query",
+    query: { kind: "find", selector: { visible: true } }
+  });
+  if (!isSemanticQueryResult(result)) return [];
+  return result.nodes.flatMap((node) => {
+    if (!node.role && !node.label && !node.text && !node.pressable) return [];
+    return [
+      {
+        role: node.role ?? (node.pressable ? "button" : node.type === "text" ? "statictext" : "none"),
+        label: node.label ?? node.text ?? null,
+        hint: null,
+        state: null,
+        testID: node.testID ?? null,
+        position: {
+          x: Math.round(node.geometry.x),
+          y: Math.round(node.geometry.y)
+        },
+        size: {
+          w: Math.round(node.geometry.width),
+          h: Math.round(node.geometry.height)
+        }
+      }
+    ];
+  });
+}
+function resolveFindMode(q) {
+  if (q.testId) {
+    return { mode: "testid", selector: { testID: q.testId } };
+  }
+  if (q.role) {
+    return { mode: "role", selector: { role: q.role } };
+  }
+  if (q.type) {
+    return { mode: "type", selector: { type: q.type } };
+  }
+  if (q.pressable) {
+    return { mode: "pressable", selector: { pressable: true } };
+  }
+  if (q.interactive) {
+    return { mode: "interactive-targets", selector: { pressable: true } };
+  }
+  if (q.visible) {
+    return { mode: "visible", selector: { visible: true } };
+  }
+  if (q.text) {
+    return { mode: "text", selector: { text: q.text } };
+  }
+  return null;
+}
+async function inspectFind(bridge, q) {
+  const resolved = resolveFindMode(q);
+  if (!resolved) return null;
+  const result = await bridge.send({
+    type: "query",
+    query: { kind: "find", selector: resolved.selector }
+  });
+  if (!isSemanticQueryResult(result)) return { mode: resolved.mode, result: [] };
+  const nodes = result.nodes.map(
+    (node) => ({
+      type: node.type,
+      nodeId: node.nodeId,
+      ...node.testID ? { testID: node.testID } : {},
+      ...node.text ? { text: node.text } : {},
+      ...node.pressable ? { pressable: true } : {},
+      ...node.role ? { accessibilityRole: node.role } : {},
+      ...node.label ? { accessibilityLabel: node.label } : {},
+      absolutePosition: { x: node.geometry.x, y: node.geometry.y },
+      layout: { width: node.geometry.width, height: node.geometry.height }
+    })
+  );
+  const resultValue = resolved.mode === "testid" || resolved.mode === "text" ? nodes[0] ?? null : nodes;
+  return { mode: resolved.mode, result: resultValue };
+}
+function waitReadyReason(status) {
+  if (status.bridgeError) {
+    if (status.bridgeError.includes(HEADLESS_TENANT_FETCH_HUNG_MARKER) || status.bridgeError.includes(PUBLIC_NO_NETWORK_MARKER)) {
+      return status.bridgeError;
+    }
+    return `sim unreachable: ${status.bridgeError} \u2014 the target tab is closed or no sim is connected (check \`rnx list\`, reopen with \`rnx open\`)`;
+  }
+  const waitingOnGuestFetch = status.externalReady === false && /https?:\/\//.test(status.externalStatus);
+  const base = status.externalError ? `guest app errored: ${status.externalError}` : waitingOnGuestFetch ? `waiting on a guest fetch: ${status.externalStatus}` : status.loadingText ? `still showing "${status.loadingText}"` : status.externalReady === false ? "guest app is still loading" : status.flag !== true && status.targets > 0 ? "native content is rendered but the ready signal has not settled" : status.flag !== true ? "guest app has not emitted sootsim:externalAppReady" : status.targets <= 0 ? "ready flag emitted but no visible app content is inspectable yet" : "node tree is still changing";
+  return !status.externalError && status.suppressedEntryError ? `${base} (suppressed entry error: ${status.suppressedEntryError})` : base;
+}
+async function inspectWaitReady(bridge, timeoutMs = 2e4, options = {}) {
+  const start = Date.now();
+  let result;
+  try {
+    result = await bridge.send(
+      {
+        type: "waitFor",
+        ...options.simId ? { simId: options.simId } : {},
+        waitForOptions: { condition: { type: "ready" }, timeoutMs }
+      },
+      { timeoutMs: timeoutMs + 1e3 }
+    );
+  } catch (error) {
+    const bridgeError = error instanceof Error ? error.message : String(error);
+    if (bridgeError.startsWith("multiple sims are connected:") || bridgeError.startsWith("saved sim ")) {
+      throw error;
+    }
+    result = {
+      matched: false,
+      elapsedMs: Date.now() - start,
+      polls: 0,
+      error: bridgeError
+    };
+  }
+  const probe = result.probe;
+  const externalError = probe?.externalError ?? "";
+  const status = {
+    ready: result.matched && !externalError,
+    elapsedMs: result.elapsedMs,
+    nodes: probe?.nodes ?? 0,
+    targets: probe?.targets ?? 0,
+    liveFrameActive: probe?.liveFrameActive ?? false,
+    liveFrameChannels: probe?.liveFrameChannels ?? 0,
+    liveFramePublishes: probe?.liveFramePublishes ?? 0,
+    flag: probe?.flag,
+    loadingText: probe?.loadingText ?? "",
+    externalReady: probe?.externalReady ?? null,
+    externalStatus: probe?.externalStatus ?? "",
+    externalError,
+    suppressedEntryError: probe?.suppressedEntryError ?? "",
+    errors: probe?.errors ?? 0,
+    bridgeError: result.error ?? ""
+  };
+  if (!status.ready && options.onProgress) options.onProgress(status);
+  return status;
+}
+function consoleEntriesEval(level, limit) {
+  const getter = level === "error" ? "getErrors" : "getWarnings";
+  return `(() => {
+    const out = []
+    const seen = new Set()
+    const norm = (s) => (typeof s === 'string' ? s : (() => { try { return JSON.stringify(s) } catch { return String(s) } })())
+    const key = (ts, args) => Math.round((ts || 0) / 250) + '|' + (Array.isArray(args) ? args.map(norm).join(' ') : norm(args))
+    const push = (e) => {
+      if (!e) return
+      const ts = typeof e.timestamp === 'number' ? e.timestamp : (typeof e.ts === 'number' ? e.ts : 0)
+      const k = key(ts, e.args)
+      if (seen.has(k)) return
+      seen.add(k)
+      out.push({ timestamp: ts, args: Array.isArray(e.args) ? e.args : [e.args], stack: e.stack || undefined, source: e.source || undefined })
+    }
+    // page-realm ws-bridge buffer first (richest stacks for page-origin errors)
+    try { for (const e of (window.__sootsimConsole?.${getter}(${limit}) || [])) push(e) } catch {}
+    // engine observability store \u2014 the always-on render-worker / forwarded path
+    try {
+      const obs = window.__sootsimObservability
+      const snap = obs && obs.logs && typeof obs.logs.getSnapshot === 'function' ? obs.logs.getSnapshot() : []
+      for (const e of snap) if (e && e.level === ${JSON.stringify(level)}) push(e)
+    } catch {}
+    return out.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0)).slice(-${limit})
+  })()`;
+}
+async function inspectErrors(bridge, limit = 20) {
+  const result = await bridge.send({
+    type: "evaluate",
+    code: consoleEntriesEval("error", limit)
+  });
+  return Array.isArray(result) ? result : [];
+}
+async function inspectWarnings(bridge, limit = 20) {
+  const result = await bridge.send({
+    type: "evaluate",
+    code: consoleEntriesEval("warn", limit)
+  });
+  return Array.isArray(result) ? result : [];
+}
+async function inspectLogs(bridge) {
+  if (bridge.plane === "cloud") {
+    const state = await bridge.send({
+      type: "state",
+      stateOptions: {
+        screenshot: false,
+        tree: false,
+        route: false,
+        errors: false,
+        logs: true,
+        logLimit: 100
+      }
+    });
+    const recentLogs = state && typeof state === "object" && Array.isArray(Reflect.get(state, "recentLogs")) ? Reflect.get(state, "recentLogs") : [];
+    return recentLogs.flatMap((entry, index) => {
+      if (!entry || typeof entry !== "object") return [];
+      const text = Reflect.get(entry, "text");
+      const rawLevel = Reflect.get(entry, "level");
+      if (typeof text !== "string") return [];
+      const level = rawLevel === "log" || rawLevel === "info" || rawLevel === "warn" || rawLevel === "error" || rawLevel === "debug" ? rawLevel : "error";
+      const at = Reflect.get(entry, "at");
+      const ts = typeof at === "number" && Number.isFinite(at) ? at : 0;
+      return [
+        {
+          id: `cloud-${ts}-${index}`,
+          source: "rnx-cloud",
+          level,
+          ts,
+          args: [text],
+          stack: null
+        }
+      ];
+    });
+  }
+  const res = await bridge.send({
+    type: "evaluate",
+    code: `(() => {
+      const obs = window.__sootsimObservability;
+      if (!obs) return { ok: false };
+      return { ok: true, entries: obs.logs.getSnapshot() };
+    })()`
+  });
+  if (!res || !res.ok) return [];
+  return res.entries ?? [];
+}
+function isForwardedWorkerLogTwin(a, b) {
+  if (a.source === b.source) return false;
+  if (a.level !== b.level) return false;
+  if (Math.abs(a.ts - b.ts) > 1e3) return false;
+  if (a.args.length !== b.args.length) return false;
+  const sources = /* @__PURE__ */ new Set([a.source, b.source]);
+  if (!sources.has("sootsim-worker")) return false;
+  if (!sources.has("render-worker") && !sources.has("forwarded-render-worker")) {
+    return false;
+  }
+  return a.args.every((arg, index) => arg === b.args[index]);
+}
+function filterLogEntries(entries, opts = {}) {
+  let out = [];
+  for (const entry of entries) {
+    if (out.some((candidate) => isForwardedWorkerLogTwin(candidate, entry))) {
+      continue;
+    }
+    out.push(entry);
+  }
+  if (!opts.showInternal) {
+    out = out.filter((e) => {
+      const first = e.args[0];
+      return !(typeof first === "string" && /^\[(?:rnx|sootsim)(?:\s[^\]]*)?\]/.test(first));
+    });
+  }
+  if (opts.level) out = out.filter((e) => opts.level.has(e.level));
+  if (opts.filter) {
+    const lf = opts.filter.toLowerCase();
+    out = out.filter((e) => e.args.join(" ").toLowerCase().includes(lf));
+  }
+  return out;
+}
+async function inspectKeyboard(bridge) {
+  const result = await bridge.send({
+    type: "evaluate",
+    code: `(() => {
+      const kb = window.__sootsimKeyboard
+      if (!kb || typeof kb.getLayout !== 'function') {
+        return { error: 'keyboard bridge getLayout() not available' }
+      }
+      return kb.getLayout()
+    })()`
+  });
+  return result ?? { error: "keyboard bridge returned no result" };
+}
+function isShellCommandUnavailable(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("call target not found: SootSim.bridges.mainShell") || message.includes("test bridge unavailable before app-in-worker boot");
+}
+async function getShellState(bridge, readyTimeoutMs = 0) {
+  const deadline = Date.now() + Math.max(0, readyTimeoutMs);
+  while (true) {
+    try {
+      return await bridge.send({
+        type: "call",
+        path: "SootSim.bridges.mainShell.getState",
+        args: []
+      });
+    } catch (error) {
+      if (!isShellCommandUnavailable(error) || Date.now() >= deadline) throw error;
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+}
+
+// cli/commands/inspect/resolve-target.ts
+async function resolveTargetCoords(bridge, target) {
+  const result = await bridge.send({
+    type: "resolve",
+    selector: target.mode === "testid" ? { testID: target.value } : { text: target.value }
+  });
+  if (result === null) return null;
+  if (typeof result !== "object") throw new Error("resolve returned an invalid result");
+  const match = Reflect.get(result, "match");
+  const resolvedTarget = Reflect.get(result, "target");
+  const semanticNodes = [match, resolvedTarget];
+  const point = Reflect.get(result, "point");
+  const x = point !== null && typeof point === "object" ? Reflect.get(point, "x") : void 0;
+  const y = point !== null && typeof point === "object" ? Reflect.get(point, "y") : void 0;
+  if (!isSimSemanticTree(semanticNodes) || typeof x !== "number" || !Number.isFinite(x) || typeof y !== "number" || !Number.isFinite(y)) {
+    throw new Error("resolve returned an invalid result");
+  }
+  const semanticMatch = semanticNodes[1];
+  if (!semanticMatch) throw new Error("resolve returned an invalid result");
+  return {
+    x,
+    y,
+    nodeId: semanticMatch.nodeId,
+    testID: semanticMatch.testID ?? null,
+    text: semanticMatch.text ?? (target.mode === "text" ? target.value : semanticMatch.label),
+    type: semanticMatch.type
+  };
+}
+
+// cli/commands/inspect/settling.ts
+async function waitForSootsimIdle({
+  bridge,
+  simId,
+  maxMs,
+  pollMs = 50,
+  stablePolls = 3,
+  strict = false
+}) {
+  const result = await bridge.send(
+    {
+      type: "evaluate",
+      simId,
+      code: `(async () => {
+      const start = Date.now()
+      const deadline = start + ${Math.max(0, Math.round(maxMs))}
+      const pollMs = ${Math.max(1, Math.round(pollMs))}
+      const requiredStablePolls = ${Math.max(1, Math.round(stablePolls))}
+      const strict = ${strict ? "true" : "false"}
+      const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+
+      // route-aware settle: a tap that pushes/pops a screen is async \u2014 the
+      // old screen still renders for a moment, then the new one mounts and
+      // its content loads. a pure layout-hash check reports "idle" on the
+      // outgoing screen or on the incoming skeleton, so a driver re-taps
+      // and stacks duplicate navigations. drain any in-flight screen
+      // transition FIRST, bounded by the overall budget. when no
+      // transition is happening this returns in ~80ms (startWindowMs), so
+      // a plain button tap barely pays for it.
+      try {
+        const wfst = window.__sootsimTest?.waitForScreenTransitions
+        if (typeof wfst === 'function') {
+          const remaining = deadline - Date.now()
+          if (remaining > 120) {
+            await wfst({
+              timeoutMs: Math.min(remaining - 80, 4000),
+              settleMs: 64,
+              startWindowMs: 80,
+            })
+          }
+        }
+      } catch {}
+
+      const readSnapshot = async () => {
+        let animating = false
+        let layoutDirty = false
+        let pendingFetches = 0
+        let requestTotal = 0
+        let requestInFlight = 0
+        let renderStatsAvailable = false
+        try {
+          const stats = await window.__sootsimRenderHost?.queryStats?.()
+          if (stats) {
+            renderStatsAvailable = true
+            animating =
+              stats.hasActiveAnims === true ||
+              stats.hasActiveNativeAnimations === true ||
+              stats.hasPendingAnimationFrames === true
+            layoutDirty =
+              stats.layoutDirty === true && stats.renderRequested === true
+            // a freshly-pushed screen showing a skeleton is layout-stable
+            // but not actually settled \u2014 its data/images are still in
+            // flight. treat bounded image-loader fetches as not-idle so
+            // settle waits for real content, capped by the budget.
+            const pf = stats.memory && stats.memory.imageLoader
+              ? stats.memory.imageLoader.pendingFetches
+              : 0
+            pendingFetches = typeof pf === 'number' ? pf : 0
+          }
+        } catch {}
+        try {
+          const counts = await window.__sootsimTest?.getRequestCounts?.()
+          requestTotal = typeof counts?.total === 'number' ? counts.total : 0
+          requestInFlight = typeof counts?.inFlight === 'number' ? counts.inFlight : 0
+        } catch {}
+        const root = window.__sootsimRoot
+        const nodes = []
+        if (root) {
+          const walk = (n) => {
+            if (n.layout && n.layout.width > 0) {
+              nodes.push(Math.round(n.layout.x) + ',' + Math.round(n.layout.y) + ',' + Math.round(n.layout.width))
+            }
+            for (const c of n.children || []) walk(c)
+          }
+          walk(root)
+        }
+        return { layout: nodes.join(';'), animating, layoutDirty, pendingFetches, renderStatsAvailable, requestTotal, requestInFlight }
+      }
+
+      // how long generic background network is allowed to keep us waiting AFTER
+      // the screen is otherwise visually settled. apps with continuous traffic
+      // (polling, realtime sockets, a tap that fires 20-50 fetches) never reach
+      // requestInFlight===0 / a stable requestTotal, so requiring full network
+      // quiet burns the ENTIRE budget on every command \u2014 the leading idle that
+      // failed PR-preview recordings for network-heavy apps (3pc fight-pulse).
+      // layout-stability + the image-loader already prove visible content
+      // loaded (a data load changes layout; an image load shows in the loader),
+      // so the generic request counters are a courtesy, not a gate: honor them
+      // only within this grace once the screen is visually still.
+      const networkQuietGraceMs = 1200
+      let lastLayout = ''
+      let lastRequestTotal = -1
+      let stable = 0
+      let visuallyStillSince = 0
+      // counts across the whole budget: a flag that is true on every poll is a
+      // different bug from one that is true intermittently, and the two need
+      // opposite fixes (engine vs budget).
+      let polls = 0
+      let dirtyPolls = 0
+      let animatingPolls = 0
+      let layoutChangedPolls = 0
+      while (Date.now() < deadline) {
+        const snapshot = await readSnapshot()
+        polls++
+        if (snapshot.layoutDirty) dirtyPolls++
+        if (snapshot.animating) animatingPolls++
+        if (polls > 1 && snapshot.layout !== lastLayout) layoutChangedPolls++
+        const strictOk =
+          !strict ||
+          (snapshot.renderStatsAvailable && !snapshot.animating && !snapshot.layoutDirty)
+        // visually settled: no animations, no image content loading, layout
+        // unchanged since the last poll.
+        const visuallyStill =
+          strictOk && snapshot.pendingFetches === 0 && snapshot.layout === lastLayout
+        // generic network quiet: nothing in flight and no new requests issued.
+        const networkQuiet =
+          snapshot.requestInFlight === 0 && snapshot.requestTotal === lastRequestTotal
+        if (visuallyStill) {
+          stable++
+          if (visuallyStillSince === 0) visuallyStillSince = Date.now()
+          // settle once the screen has held still long enough AND either the
+          // network is genuinely quiet OR it has refused to quiet within the
+          // grace (continuous background traffic must not block forever).
+          if (
+            stable >= requiredStablePolls &&
+            (networkQuiet || Date.now() - visuallyStillSince >= networkQuietGraceMs)
+          ) {
+            return { settled: true, elapsed: Date.now() - start, blockedBy: '' }
+          }
+        } else {
+          stable = 0
+          visuallyStillSince = 0
+        }
+        lastLayout = snapshot.layout
+        lastRequestTotal = snapshot.requestTotal
+        await sleep(pollMs)
+      }
+      const last = await readSnapshot()
+      const blockers = []
+      if (strict && !last.renderStatsAvailable) blockers.push('render stats unavailable')
+      if (last.animating) blockers.push('animations still running')
+      if (last.layoutDirty) blockers.push('layout still dirty')
+      if (last.pendingFetches > 0) blockers.push(last.pendingFetches + ' image fetches pending')
+      if (last.layout !== lastLayout) blockers.push('layout still changing')
+      if (last.requestInFlight > 0) blockers.push(last.requestInFlight + ' requests in flight')
+      return {
+        settled: false,
+        elapsed: Date.now() - start,
+        blockedBy:
+          (blockers.length ? blockers.join(', ') : 'unknown') +
+          ' over ' + polls + ' polls (layout changed ' + layoutChangedPolls +
+          'x, layoutDirty ' + dirtyPolls + 'x, animating ' + animatingPolls + 'x)',
+      }
+    })()`
+    },
+    {
+      timeoutMs: maxMs + 1e3
+    }
+  );
+  const { elapsed, settled, blockedBy } = result ?? {};
+  return {
+    elapsed: typeof elapsed === "number" ? elapsed : maxMs,
+    settled: settled === true,
+    blockedBy: typeof blockedBy === "string" ? blockedBy : "unknown"
+  };
+}
+
+// cli/commands/inspect/actions.ts
+function isScreenSize(value) {
+  if (value === null || typeof value !== "object") return false;
+  const width = Reflect.get(value, "width");
+  const height = Reflect.get(value, "height");
+  return typeof width === "number" && Number.isFinite(width) && width > 0 && typeof height === "number" && Number.isFinite(height) && height > 0;
+}
+function viewportFromCapture(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const tree = Reflect.get(value, "tree");
+  return tree !== null && typeof tree === "object" ? Reflect.get(tree, "viewport") : void 0;
+}
+async function readScreen(bridge) {
+  try {
+    const viewport = viewportFromCapture(
+      await bridge.send({ type: "capture", includeVisual: false })
+    );
+    return isScreenSize(viewport) ? { width: viewport.width, height: viewport.height } : null;
+  } catch {
+    return null;
+  }
+}
+function isOffscreen(cx, cy, screen) {
+  return !(cx >= 0 && cy >= 0 && cx <= screen.width && cy <= screen.height);
+}
+var DEFAULT_AGENT_TIMING = {
+  initialWaitMs: 3e3,
+  deadlineMs: 5e3,
+  retryWaitMs: 700
+};
+var DEFAULT_INTERACTIVE_TIMING = {
+  initialWaitMs: 1200,
+  deadlineMs: 2500,
+  retryWaitMs: 700
+};
+function tapTiming(agent, opts = {}) {
+  return {
+    ...agent ? DEFAULT_AGENT_TIMING : DEFAULT_INTERACTIVE_TIMING,
+    ...opts
+  };
+}
+function isTapSuccess(result) {
+  if (!result || result.hit === false || result.ok === false) return false;
+  if (result.handled === false) return false;
+  if (result.requestedTargetMatched === false) return false;
+  if (result.pointerTapHandled === false && !result.keyboardOpened && !result.isTextInput) {
+    return false;
+  }
+  return true;
+}
+function tapTargetFromPayload(payload, textFallback) {
+  const id = payload.target?.id ?? payload.match?.id ?? payload.node?.id;
+  return {
+    nodeId: payload.target?.nodeId ?? payload.match?.nodeId ?? payload.node?.nodeId ?? null,
+    id: typeof id === "string" ? id : null,
+    testID: payload.target?.testID ?? payload.match?.testID ?? payload.node?.testID ?? null,
+    text: payload.target?.text ?? payload.target?.accessibilityLabel ?? payload.match?.text ?? payload.match?.accessibilityLabel ?? payload.node?.text ?? textFallback ?? null,
+    type: payload.target?.type ?? payload.match?.type ?? payload.node?.type ?? null
+  };
+}
+async function tapResolvedTarget(bridge, args) {
+  const timing = tapTiming(!!args.agent, args.timing);
+  let attempts = 0;
+  let lastPayload = null;
+  let lastResult = null;
+  const settleCloud = async () => {
+    try {
+      await bridge.send({ type: "settle" });
+    } catch {
+    }
+  };
+  if (bridge.plane === "cloud") {
+    await settleCloud();
+  } else if (timing.initialWaitMs > 0) {
+    try {
+      await waitForSootsimIdle({
+        bridge,
+        maxMs: timing.initialWaitMs,
+        pollMs: 32,
+        stablePolls: 2
+      });
+    } catch {
+    }
+  }
+  const deadline = Date.now() + timing.deadlineMs;
+  let lastOffscreenAt = null;
+  const screen = bridge.plane === "cloud" ? null : await readScreen(bridge);
+  while (Date.now() <= deadline || attempts === 0) {
+    attempts++;
+    const resolved = await args.resolve();
+    const payload = resolved && typeof resolved.cx === "number" && typeof resolved.cy === "number" && screen && isOffscreen(resolved.cx, resolved.cy, screen) ? { ...resolved, offscreen: true, screen } : resolved;
+    lastPayload = payload;
+    if (payload?.error === "bridge-not-ready" || payload?.ambiguous || payload?.nthOutOfRange) {
+      return { payload, result: null, attempts, failure: "special" };
+    }
+    if (payload && typeof payload.cx === "number" && typeof payload.cy === "number") {
+      if (payload.offscreen) {
+        lastResult = {
+          hit: false,
+          reason: "offscreen",
+          x: payload.cx,
+          y: payload.cy,
+          screen: payload.screen
+        };
+        const at = `${Math.round(payload.cx)},${Math.round(payload.cy)}`;
+        if (lastOffscreenAt === at) {
+          return { payload, result: lastResult, attempts, failure: "missed" };
+        }
+        lastOffscreenAt = at;
+      } else {
+        lastOffscreenAt = null;
+        const requestedTarget = tapTargetFromPayload(payload, args.textFallback);
+        const result = await tapCoordinates(
+          bridge,
+          payload.cx,
+          payload.cy,
+          requestedTarget
+        );
+        lastResult = result?.reason === "offscreen" && result.diagnostics ? {
+          ...result,
+          hit: false,
+          x: result.diagnostics.point?.x ?? payload.cx,
+          y: result.diagnostics.point?.y ?? payload.cy,
+          screen: result.diagnostics.screen
+        } : result;
+        if (result?.requestedTargetMatched === false) {
+          return { payload, result, attempts, failure: "missed" };
+        }
+        if (isTapSuccess(result)) return { payload, result, attempts };
+      }
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    if (bridge.plane === "cloud") {
+      if (lastResult?.reason !== "target-moved" || attempts >= 3) break;
+      await settleCloud();
+      continue;
+    }
+    if (timing.retryWaitMs <= 0) break;
+    try {
+      await waitForSootsimIdle({
+        bridge,
+        maxMs: Math.min(remaining, timing.retryWaitMs),
+        pollMs: 32,
+        stablePolls: 2
+      });
+    } catch {
+      await new Promise((resolve3) => setTimeout(resolve3, Math.min(120, remaining)));
+    }
+  }
+  return {
+    payload: lastPayload,
+    result: lastResult,
+    attempts,
+    failure: lastPayload && typeof lastPayload.cx === "number" ? "missed" : "not-found"
+  };
+}
+async function tapCoordinates(bridge, x, y, target) {
+  return bridge.send({
+    type: "tap",
+    x,
+    y,
+    ...target ? { target } : {}
+  });
+}
+function payloadFromResolved(resolved, match, extra = {}) {
+  return {
+    cx: resolved.x,
+    cy: resolved.y,
+    match: {
+      nodeId: match.nodeId ?? null,
+      id: match.testID ?? null,
+      testID: match.testID ?? null,
+      text: match.text ?? null,
+      type: match.type ?? null
+    },
+    target: {
+      nodeId: resolved.nodeId ?? match.nodeId ?? null,
+      id: resolved.testID ?? match.testID ?? null,
+      testID: resolved.testID ?? match.testID ?? null,
+      text: resolved.text ?? match.text ?? null,
+      type: resolved.type ?? match.type ?? null
+    },
+    strategy: "matched-node",
+    ...extra
+  };
+}
+function collectTextCandidates(nodes, ancestors = [], pressableOwnerText = "") {
+  const out = [];
+  for (const node of nodes) {
+    const text = nodeText(node);
+    const caption = !!text && text === pressableOwnerText && !node.pressable;
+    if (!caption) out.push({ node, ancestorTestIDs: ancestors });
+    if (node.children?.length) {
+      const next = node.testID ? [...ancestors, node.testID] : ancestors;
+      const owner = text ? node.pressable ? text : "" : pressableOwnerText;
+      out.push(...collectTextCandidates(node.children, next, owner));
+    }
+  }
+  return out;
+}
+function nodeText(node) {
+  return node.text ?? node.label ?? "";
+}
+async function tapById(bridge, query, opts = {}) {
+  return tapResolvedTarget(bridge, {
+    agent: opts.agent,
+    timing: opts.timing,
+    resolve: async () => {
+      const resolved = await resolveTargetCoords(bridge, { mode: "testid", value: query });
+      if (!resolved) return { cx: null };
+      return payloadFromResolved(resolved, resolved);
+    }
+  });
+}
+async function tapByText(bridge, query, options = {}, opts = {}) {
+  return tapResolvedTarget(bridge, {
+    agent: opts.agent,
+    timing: opts.timing,
+    textFallback: query,
+    resolve: async () => {
+      const { tree } = await inspectTree(bridge, 50);
+      if (!Array.isArray(tree)) return { matched: 0, total: 0 };
+      const needle = options.exact ? query : query.toLowerCase();
+      let candidates = collectTextCandidates(tree).filter(({ node: node2, ancestorTestIDs }) => {
+        const text = nodeText(node2);
+        if (!text) return false;
+        if (options.exact ? text !== needle : !text.toLowerCase().includes(needle)) {
+          return false;
+        }
+        if (options.role && node2.role !== options.role) return false;
+        if (options.within && !ancestorTestIDs.includes(options.within)) return false;
+        const ax = node2.geometry.x;
+        const ay = node2.geometry.y;
+        if (options.minX != null && !(ax >= options.minX)) return false;
+        if (options.maxX != null && !(ax <= options.maxX)) return false;
+        if (options.minY != null && !(ay >= options.minY)) return false;
+        if (options.maxY != null && !(ay <= options.maxY)) return false;
+        return true;
+      });
+      if (options.near) {
+        const { x, y } = options.near;
+        candidates.sort(
+          (a, b) => Math.hypot(a.node.geometry.x - x, a.node.geometry.y - y) - Math.hypot(b.node.geometry.x - x, b.node.geometry.y - y)
+        );
+      } else {
+        candidates.sort((a, b) => {
+          if (Math.abs(a.node.geometry.y - b.node.geometry.y) > 2) {
+            return a.node.geometry.y - b.node.geometry.y;
+          }
+          return a.node.geometry.x - b.node.geometry.x;
+        });
+      }
+      const total = candidates.length;
+      if (total === 0) return { matched: 0, total: 0 };
+      let idx = 0;
+      if (options.nth != null) {
+        idx = options.nth < 0 ? total + options.nth : options.nth;
+        if (idx < 0 || idx >= total) {
+          return { matched: 0, total, nthOutOfRange: true, nth: options.nth };
+        }
+      } else if (total > 1 && !options.first && !options.near) {
+        return {
+          ambiguous: true,
+          total,
+          candidates: candidates.slice(0, 10).map((candidate, index) => ({
+            idx: index,
+            nodeId: candidate.node.nodeId,
+            type: candidate.node.type,
+            testID: candidate.node.testID ?? null,
+            text: nodeText(candidate.node).slice(0, 60),
+            abs: { x: candidate.node.geometry.x, y: candidate.node.geometry.y },
+            layout: {
+              width: Math.round(candidate.node.geometry.width),
+              height: Math.round(candidate.node.geometry.height)
+            },
+            ancestorTestIDs: candidate.ancestorTestIDs.slice(0, 5)
+          }))
+        };
+      }
+      const picked = candidates[idx];
+      if (!picked) return { matched: 0, total };
+      const node = picked.node;
+      let resolved = node.testID ? await resolveTargetCoords(bridge, { mode: "testid", value: node.testID }) : await resolveTargetCoords(bridge, {
+        mode: "text",
+        value: nodeText(node) || query
+      });
+      if (!resolved) {
+        resolved = {
+          x: node.geometry.x + node.geometry.width / 2,
+          y: node.geometry.y + node.geometry.height / 2,
+          testID: node.testID ?? null,
+          text: nodeText(node) || query,
+          type: node.type
+        };
+      }
+      return payloadFromResolved(resolved, node, { total, idx });
+    }
+  });
+}
+async function tapBest(bridge, query, opts = {}) {
+  return tapResolvedTarget(bridge, {
+    agent: opts.agent,
+    timing: opts.timing,
+    textFallback: query,
+    resolve: async () => {
+      const byId = await resolveTargetCoords(bridge, { mode: "testid", value: query });
+      if (byId) {
+        return {
+          ...payloadFromResolved(byId, byId),
+          strategy: "testid",
+          node: {
+            nodeId: byId.nodeId ?? null,
+            id: byId.testID ?? query,
+            testID: byId.testID ?? query,
+            type: byId.type ?? null,
+            text: byId.text ?? null
+          }
+        };
+      }
+      const byText = await resolveTargetCoords(bridge, { mode: "text", value: query });
+      if (byText) {
+        return {
+          ...payloadFromResolved(byText, byText),
+          strategy: "text",
+          node: {
+            nodeId: byText.nodeId ?? null,
+            id: byText.testID ?? null,
+            testID: byText.testID ?? null,
+            type: byText.type ?? null,
+            text: byText.text ?? query
+          }
+        };
+      }
+      return { strategy: "none" };
+    }
+  });
+}
+
+// src/app-url.ts
+var APP_URL_SCHEME_RE = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+function normalizeAppUrlTarget(target) {
+  const trimmed = target.trim();
+  if (!trimmed) {
+    throw new Error("expected <url-or-route>");
+  }
+  if (APP_URL_SCHEME_RE.test(trimmed) || trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  return `/${trimmed}`;
+}
+async function openAppUrl(bridge, target) {
+  const normalized = normalizeAppUrlTarget(target);
+  const result = await bridge.send({
+    type: "openUrl",
+    url: normalized
+  });
+  if (result !== null && typeof result === "object" && Reflect.get(result, "ok") === false) {
+    const error = Reflect.get(result, "error");
+    throw new Error(typeof error === "string" ? error : "deep-link dispatch failed");
+  }
+  return normalized;
+}
+
+// src/sim-client.ts
+var SimClientError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var SimConnectError = class extends SimClientError {
+};
+var SimReadyTimeoutError = class extends SimClientError {
+  status;
+  constructor(status) {
+    super(`sim not ready: ${waitReadyReason(status)}`);
+    this.status = status;
+  }
+};
+var SimTapError = class extends SimClientError {
+  outcome;
+  constructor(message, outcome = null) {
+    super(message);
+    this.outcome = outcome;
+  }
+};
+var SimKeyboardError = class extends SimClientError {
+};
+var SimPerformError = class extends SimClientError {
+  result;
+  constructor(result) {
+    const failed = result.steps.find((step) => !step.ok);
+    const at = failed ? `${failed.index} (${failed.type})` : String(result.completed);
+    const cause = failed?.error ?? result.error;
+    super(`perform failed at step ${at}${cause ? `: ${cause}` : ""}`);
+    this.result = result;
+  }
+};
+var SimResetError = class extends SimClientError {
+  result;
+  constructor(result) {
+    super(`reset (${result.strategy}) failed${result.error ? `: ${result.error}` : ""}`);
+    this.result = result;
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function decodePngDataUrl(dataUrl) {
+  if (typeof dataUrl !== "string" || !dataUrl.startsWith("data:image/png;base64,")) {
+    throw new SimClientError(
+      `screenshot bridge returned a non-png payload: ${JSON.stringify(
+        typeof dataUrl === "string" ? dataUrl.slice(0, 80) : dataUrl
+      )}`
+    );
+  }
+  const base64 = dataUrl.slice("data:image/png;base64,".length);
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return { dataUrl, bytes };
+}
+var TARGET_SEARCH_PARAMS = [
+  "bundle",
+  "demo",
+  "app",
+  "open",
+  "port",
+  "inspectOpen",
+  "appFonts",
+  "appSplash"
+];
+function buildSimOpenUrl(currentUrl, target) {
+  const url = new URL(currentUrl);
+  for (const param of TARGET_SEARCH_PARAMS) url.searchParams.delete(param);
+  const pathname = url.pathname.replace(/\/+$/, "") || "/";
+  const prefix2 = pathname === "/__soot" || pathname.startsWith("/__soot/") ? "/__soot" : "";
+  const normalized = String(target).trim();
+  if (/^\d+$/.test(normalized)) {
+    url.pathname = `${prefix2}/rn/${normalized}`;
+  } else {
+    url.pathname = `${prefix2}/rn`;
+    url.searchParams.set("open", normalized);
+  }
+  return url.toString();
+}
+function isTextTapTarget(target) {
+  return typeof target === "object" && "text" in target && typeof target.text === "string" && !("layout" in target) && !("absolutePosition" in target);
+}
+var SimClient = class {
+  simId;
+  bridge;
+  closed = false;
+  constructor(bridge, simId, _options = {}) {
+    this.bridge = bridge;
+    this.simId = simId;
+  }
+  get plane() {
+    return this.bridge.plane;
+  }
+  // --- transport (WsBridge/InspectBridge) ---
+  send(cmd, opts) {
+    if (this.closed) {
+      return Promise.reject(new SimConnectError("sim client is closed"));
+    }
+    const payload = cmd.simId === void 0 ? { ...cmd, simId: this.simId } : cmd;
+    return this.bridge.send(payload, opts);
+  }
+  listSims() {
+    return this.bridge.listSims();
+  }
+  resolveReloadedSim(retiredSimId) {
+    return this.bridge.resolveReloadedSim(retiredSimId);
+  }
+  focusSim(simId = this.simId) {
+    return this.bridge.focusSim(simId);
+  }
+  closeSim(simId = this.simId) {
+    return this.bridge.closeSim(simId);
+  }
+  claim(simId = this.simId, opts) {
+    return this.bridge.claim(simId, opts);
+  }
+  /** release the socket. a script that connected must close to exit cleanly. */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.bridge.close();
+  }
+  // --- navigation + readiness ---
+  /**
+   * point this sim at a dev target: a metro port (`8081`), or anything the
+   * shell's connect flow accepts (`localhost:8081`, an app slug…). resolves
+   * once the reloaded page answers on the new target route.
+   */
+  async open(target, opts = {}) {
+    const sims = await this.listSims();
+    const sim = sims.find((entry) => entry.id === this.simId);
+    if (!sim) {
+      throw new SimConnectError(`sim ${this.simId} is no longer connected`);
+    }
+    const currentUrl = sim.url ?? sim.origin;
+    if (!currentUrl) {
+      throw new SimConnectError(
+        `sim ${this.simId} reported no URL to derive the shell from`
+      );
+    }
+    const nextUrl = new URL(buildSimOpenUrl(currentUrl, target));
+    const token = `sim-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    nextUrl.searchParams.set("inspectOpen", token);
+    await this.send({
+      type: "evaluate",
+      code: `window.location.href = ${JSON.stringify(nextUrl.toString())}`
+    });
+    const deadline = Date.now() + (opts.timeoutMs ?? 3e4);
+    while (Date.now() < deadline) {
+      await sleep(250);
+      try {
+        const { url } = await inspectUrl(this);
+        if (new URL(url).searchParams.get("inspectOpen") === token) return;
+      } catch {
+      }
+    }
+    throw new SimConnectError(
+      `timed out waiting for sim ${this.simId} to load ${nextUrl}`
+    );
+  }
+  /** dispatch a route or app URL through React Native Linking in this guest. */
+  openUrl(target) {
+    return openAppUrl(this, target);
+  }
+  async setAppearance(appearance) {
+    await this.send({ type: "setAppearance", appearance });
+  }
+  /**
+   * block until the guest app has mounted and painted real content.
+   * throws SimReadyTimeoutError (with the last probe status) on timeout.
+   */
+  async waitReady(opts = {}) {
+    const status = await inspectWaitReady(this, opts.timeoutMs ?? 2e4, {
+      onProgress: opts.onProgress
+    });
+    if (!status.ready) throw new SimReadyTimeoutError(status);
+    return status;
+  }
+  /** wait for layout/animation/transition settle after an interaction. */
+  settle(opts = {}) {
+    return waitForSootsimIdle({
+      bridge: this,
+      maxMs: opts.maxMs ?? 3e3,
+      strict: opts.strict
+    });
+  }
+  // --- read verbs ---
+  /** first matching node, or null. query precedence matches the CLI's find. */
+  async find(query) {
+    const nodes = await this.findAll(query);
+    return nodes[0] ?? null;
+  }
+  async findAll(query) {
+    const mapped = {
+      testId: query.testId ?? null,
+      role: query.role ?? null,
+      type: query.type ?? null,
+      text: query.text ?? null,
+      pressable: query.pressable
+    };
+    const found = await inspectFind(this, mapped);
+    if (!found) {
+      throw new SimClientError(
+        "find() needs at least one of testId, text, role, type, or pressable"
+      );
+    }
+    const { result } = found;
+    if (Array.isArray(result)) return result;
+    return result ? [result] : [];
+  }
+  async tree(depth = 5) {
+    const { tree } = await inspectTree(this, depth);
+    return Array.isArray(tree) ? tree : [];
+  }
+  resolve(selector) {
+    return this.send({ type: "resolve", selector });
+  }
+  /** compact visible semantic tree, formatted as the CLI prints it. */
+  describe(opts = {}) {
+    return inspectDescribe(this, {
+      describe: true,
+      verbose: opts.verbose ?? false,
+      filter: opts.filter ?? "",
+      compact: !opts.verbose,
+      hideXy: false,
+      fullText: true
+    });
+  }
+  accessibilityTree() {
+    return inspectAccessibilityTree(this);
+  }
+  async logs(opts = {}) {
+    return filterLogEntries(await inspectLogs(this), opts);
+  }
+  errors(limit = 20) {
+    return inspectErrors(this, limit);
+  }
+  warnings(limit = 20) {
+    return inspectWarnings(this, limit);
+  }
+  keyboard() {
+    return inspectKeyboard(this);
+  }
+  shellState(readyTimeoutMs = 0) {
+    return getShellState(this, readyTimeoutMs);
+  }
+  async url() {
+    const { url } = await inspectUrl(this);
+    return url;
+  }
+  async screenshot(opts = {}) {
+    const result = await this.send({
+      type: "screenshot",
+      ...opts.layers ? { layers: opts.layers } : {},
+      ...opts.crop ? { crop: opts.crop } : {}
+    });
+    return decodePngDataUrl(result);
+  }
+  // --- input verbs ---
+  /**
+   * tap by testID, visible text, node, or coordinates. resolution, retry, and
+   * hit verification are the CLI's shared tap kernels. throws SimTapError when
+   * the target is missing, covered, offscreen, or the press missed.
+   */
+  async tap(target) {
+    if (typeof target === "string") {
+      return this.throwUnlessTapped(await tapBest(this, target), target);
+    }
+    if ("testId" in target && typeof target.testId === "string") {
+      return this.throwUnlessTapped(await tapById(this, target.testId), target.testId);
+    }
+    if (isTextTapTarget(target)) {
+      const { text, ...textOpts } = target;
+      return this.throwUnlessTapped(await tapByText(this, text, textOpts), text);
+    }
+    if ("testID" in target && typeof target.testID === "string" && typeof target.nodeId !== "number") {
+      return this.throwUnlessTapped(await tapById(this, target.testID), target.testID);
+    }
+    const coords = this.coordsForTapTarget(target);
+    const result = await this.send({
+      type: "tap",
+      x: coords.x,
+      y: coords.y,
+      ..."nodeId" in target && typeof target.nodeId === "number" ? { target: { nodeId: target.nodeId } } : {}
+    });
+    if (!isTapSuccess(result)) {
+      throw new SimTapError(
+        `tap at ${coords.x},${coords.y} missed: ${JSON.stringify(result)}`
+      );
+    }
+  }
+  async longPress(target, opts = {}) {
+    const coords = await this.resolveCoords(target);
+    const result = await this.send(
+      {
+        type: "longPress",
+        x: coords.x,
+        y: coords.y,
+        durationMs: opts.durationMs ?? 600
+      },
+      { timeoutMs: (opts.durationMs ?? 600) + 15e3 }
+    );
+    if (!result?.ok) {
+      throw new SimTapError(`longPress at ${coords.x},${coords.y} missed`);
+    }
+  }
+  /** type through the visual iOS keyboard. requires a focused input. */
+  async type(text) {
+    await this.requireVisibleKeyboard("type");
+    await this.send({ type: "keyboard", action: "type", text });
+  }
+  /** press a keyboard key ('return', 'delete', 'space', …). */
+  async press(key) {
+    await this.requireVisibleKeyboard("press");
+    await this.send({ type: "keyboard", action: "press", text: key });
+  }
+  async dismissKeyboard() {
+    await this.send({ type: "keyboard", action: "dismiss" });
+  }
+  // --- batched input, compound state, reset ---
+  /**
+   * execute an ordered step batch inside the page in ONE round-trip, so waits
+   * and gesture physics run on real wall-clock timing. `tapText` steps are
+   * resolved to coordinates client-side before the batch is sent. throws
+   * SimPerformError (carrying the per-step result) when the batch fails.
+   */
+  async perform(steps, options) {
+    const resolved = [];
+    for (const step of steps) {
+      if (step.type !== "tapText") {
+        resolved.push(step);
+        continue;
+      }
+      const target = await resolveTargetCoords(this, {
+        mode: "text",
+        value: step.text
+      });
+      if (!target) {
+        throw new SimTapError(
+          `perform tapText: no node with text ${JSON.stringify(step.text)}`
+        );
+      }
+      resolved.push({
+        type: "tap",
+        x: target.x,
+        y: target.y,
+        target: {
+          nodeId: target.nodeId,
+          testID: target.testID ?? void 0,
+          text: target.text ?? void 0,
+          type: target.type ?? void 0
+        }
+      });
+    }
+    const batchTimeoutMs = options?.timeoutMs ?? 3e4;
+    const result = await this.send(
+      {
+        type: "perform",
+        steps: resolved,
+        ...options ? { performOptions: options } : {}
+      },
+      { timeoutMs: batchTimeoutMs + 5e3 }
+    );
+    if (!result?.ok) throw new SimPerformError(result);
+    return result;
+  }
+  /** screenshot + tree + route + recent errors in one round-trip. */
+  state(options) {
+    return this.send({
+      type: "state",
+      ...options ? { stateOptions: options } : {}
+    });
+  }
+  /**
+   * two-tier app state wipe ('data' clears storage/caches, 'full' also clears
+   * keychain/permissions/native-module state). throws SimResetError on failure.
+   */
+  async reset(options) {
+    const result = await this.send(
+      { type: "reset", ...options ? { resetOptions: options } : {} },
+      { timeoutMs: 6e4 }
+    );
+    if (!result?.ok) throw new SimResetError(result);
+    return result;
+  }
+  // --- internals ---
+  throwUnlessTapped(outcome, label) {
+    if (!outcome.failure && isTapSuccess(outcome.result)) return;
+    const reason = outcome.failure === "not-found" ? "no matching node" : outcome.failure === "missed" ? outcome.result?.reason ?? "press missed" : outcome.payload?.ambiguous ? `ambiguous: ${outcome.payload.total} matches` : outcome.result?.reason ?? outcome.payload?.error ?? "tap failed";
+    throw new SimTapError(`tap ${JSON.stringify(label)} failed: ${reason}`, outcome);
+  }
+  coordsForTapTarget(target) {
+    if (typeof target === "object" && "x" in target && "y" in target && typeof target.x === "number" && typeof target.y === "number") {
+      return { x: target.x, y: target.y };
+    }
+    if (typeof target === "object" && "absolutePosition" in target && target.absolutePosition && target.layout) {
+      return {
+        x: target.absolutePosition.x + (target.layout.width ?? 0) / 2,
+        y: target.absolutePosition.y + (target.layout.height ?? 0) / 2
+      };
+    }
+    throw new SimClientError(
+      "tap target needs coordinates, a testId, text, or a node from find()"
+    );
+  }
+  async resolveCoords(target) {
+    if (typeof target === "string") {
+      const resolved = await resolveTargetCoords(this, { mode: "testid", value: target }) ?? await resolveTargetCoords(this, { mode: "text", value: target });
+      if (!resolved) throw new SimTapError(`no node matching ${JSON.stringify(target)}`);
+      return resolved;
+    }
+    if ("testId" in target && typeof target.testId === "string") {
+      const resolved = await resolveTargetCoords(this, {
+        mode: "testid",
+        value: target.testId
+      });
+      if (!resolved) {
+        throw new SimTapError(`no node with testID ${JSON.stringify(target.testId)}`);
+      }
+      return resolved;
+    }
+    if ("text" in target && typeof target.text === "string" && !("layout" in target)) {
+      const resolved = await resolveTargetCoords(this, {
+        mode: "text",
+        value: target.text
+      });
+      if (!resolved) {
+        throw new SimTapError(`no node with text ${JSON.stringify(target.text)}`);
+      }
+      return resolved;
+    }
+    return this.coordsForTapTarget(target);
+  }
+  async requireVisibleKeyboard(action) {
+    const deadline = Date.now() + 1500;
+    for (; ; ) {
+      const state = await inspectKeyboard(this);
+      if (!("error" in state) && state.visible) return;
+      if (Date.now() >= deadline) {
+        throw new SimKeyboardError(
+          `${action} requires the iOS keyboard to be visible \u2014 focus an input first (tap a TextInput)`
+        );
+      }
+      await sleep(150);
+    }
+  }
+};
+
+// src/connect.ts
+function pickSim(sims, wanted, port) {
+  const open = sims.filter((sim) => sim.readyState === "open");
+  if (wanted) {
+    const match = open.find((sim) => sim.id === wanted);
+    if (!match) {
+      throw new SimConnectError(
+        `no sim connected with id ${wanted} on bridge :${port}` + (open.length ? ` \u2014 connected: ${open.map((sim) => sim.id).join(", ")}` : " \u2014 no sims connected; open one with `rnx open <port>`")
+      );
+    }
+    return match;
+  }
+  const pinned = readCurrentSimId();
+  if (pinned) {
+    const match = open.find((sim) => sim.id === pinned);
+    if (match) return match;
+  }
+  const primary = open.find((sim) => sim.isPrimary) ?? open[0];
+  if (!primary) {
+    throw new SimConnectError(
+      `no sims connected on bridge :${port} \u2014 open one with \`rnx open <port>\``
+    );
+  }
+  return primary;
+}
+async function connect(options = {}) {
+  const target = {
+    simId: options.sim,
+    simIdSource: options.sim ? "flag" : "none"
+  };
+  const cloud = resolveCloudSessionForParsed(target);
+  if (cloud) {
+    const bridge2 = createCloudBridgeForParsed(target);
+    if (!bridge2)
+      throw new SimConnectError("remote simulator session disappeared while connecting");
+    return new SimClient(bridge2, cloud.simId, {
+      commandTimeoutMs: options.timeoutMs ?? 15e3
+    });
+  }
+  const port = options.port ?? resolveBridgeWorld().bridgePort;
+  const commandTimeoutMs = options.timeoutMs ?? 15e3;
+  const discovery = createBridge(port, { commandTimeoutMs, cliLabel: "sdk" });
+  let picked;
+  try {
+    picked = pickSim(await discovery.listSims(), options.sim, port);
+  } catch (error) {
+    discovery.close();
+    if (error instanceof SimConnectError) throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    throw new SimConnectError(`${message} \u2014 is the rnx daemon or dev shell running?`);
+  }
+  discovery.close();
+  const bridge = createBridge(port, {
+    commandTimeoutMs,
+    cliLabel: "sdk",
+    simId: picked.id,
+    simIdSource: "flag"
+  });
+  return new SimClient(bridge, picked.id, { commandTimeoutMs });
+}
+
+// src/capture-contract.ts
+var RNX_SCREEN_CAPTURE_VERSION = 1;
+function selectRnxRasterNodeIds(tree) {
+  const nodesById = new Map(tree.nodes.map((node) => [node.nodeId, node]));
+  const unsupported = /* @__PURE__ */ new Set();
+  for (const node of tree.nodes) {
+    const visibleFrame = node.visibleFrame ?? node.frame;
+    if (!visibleFrame || visibleFrame.width <= 0 || visibleFrame.height <= 0) continue;
+    if (node.type === "masked-view" || node.type === "text" && typeof node.text === "string" && (new RegExp("\\p{Emoji_Presentation}", "u").test(node.text) || new RegExp("\\uFE0F|\\u200D|\\u20E3|\\p{Emoji_Modifier}|\\p{Regional_Indicator}", "u").test(
+      node.text
+    )) || node.style._liquidGlass !== void 0 || node.style._liquidGlassEdge !== void 0) {
+      unsupported.add(node.nodeId);
+    }
+  }
+  for (const nodeId of [...unsupported]) {
+    let parentNodeId = nodesById.get(nodeId)?.parentNodeId ?? null;
+    while (parentNodeId !== null) {
+      if (unsupported.has(parentNodeId)) {
+        unsupported.delete(nodeId);
+        break;
+      }
+      parentNodeId = nodesById.get(parentNodeId)?.parentNodeId ?? null;
+    }
+  }
+  const screenArea = tree.width * tree.height;
+  const maxLayerArea = screenArea * 0.25;
+  const maxAtlasArea = screenArea * 0.5;
+  const candidates = [...unsupported].map((nodeId) => {
+    const node = nodesById.get(nodeId);
+    const frame = node?.visibleFrame ?? node?.frame;
+    return frame ? { nodeId, area: frame.width * frame.height } : null;
+  }).filter(
+    (candidate) => candidate !== null && candidate.area <= maxLayerArea
+  ).sort((left, right) => left.area - right.area || left.nodeId - right.nodeId);
+  const selected = /* @__PURE__ */ new Set();
+  let atlasArea = 0;
+  for (const candidate of candidates) {
+    if (atlasArea + candidate.area > maxAtlasArea) continue;
+    selected.add(candidate.nodeId);
+    atlasArea += candidate.area;
+  }
+  return selected;
+}
+function rnxRasterFrames(tree, nodeIds) {
+  const frames = /* @__PURE__ */ new Map();
+  for (const node of tree.nodes) {
+    if (!nodeIds.has(node.nodeId)) continue;
+    const frame = node.frame ?? {
+      x: node.absolutePosition.x,
+      y: node.absolutePosition.y,
+      width: node.layout.width,
+      height: node.layout.height
+    };
+    const liquidGlass = node.style._liquidGlass;
+    const capturePadding = liquidGlass && typeof liquidGlass === "object" && typeof Reflect.get(liquidGlass, "capturePadding") === "number" ? Reflect.get(liquidGlass, "capturePadding") : 0;
+    const shadowRadius = typeof node.style.shadowRadius === "number" ? node.style.shadowRadius : 0;
+    const shadowOffset = node.style.shadowOffset;
+    const shadowOffsetX = shadowOffset && typeof shadowOffset === "object" && typeof Reflect.get(shadowOffset, "width") === "number" ? Reflect.get(shadowOffset, "width") : 0;
+    const shadowOffsetY = shadowOffset && typeof shadowOffset === "object" && typeof Reflect.get(shadowOffset, "height") === "number" ? Reflect.get(shadowOffset, "height") : 0;
+    const left = Math.max(
+      0,
+      frame.x - Math.max(capturePadding, shadowRadius - shadowOffsetX)
+    );
+    const top = Math.max(
+      0,
+      frame.y - Math.max(capturePadding, shadowRadius - shadowOffsetY)
+    );
+    const right = Math.min(
+      tree.width,
+      frame.x + frame.width + Math.max(capturePadding, shadowRadius + shadowOffsetX)
+    );
+    const bottom = Math.min(
+      tree.height,
+      frame.y + frame.height + Math.max(capturePadding, shadowRadius + shadowOffsetY)
+    );
+    if (right > left && bottom > top) {
+      frames.set(node.nodeId, {
+        x: left,
+        y: top,
+        width: right - left,
+        height: bottom - top
+      });
+    }
+  }
+  return frames;
+}
+function rnxCaptureRasterRegions(capture) {
+  const tree = {
+    width: capture.tree.viewport.width,
+    height: capture.tree.viewport.height,
+    nodes: capture.tree.nodes.map((node) => ({
+      nodeId: node.nodeId,
+      parentNodeId: node.parentNodeId,
+      type: node.type,
+      text: node.text,
+      style: node.style.resolved,
+      layout: node.layout.local,
+      frame: node.layout.frame,
+      absolutePosition: node.layout.absolutePosition,
+      visibleFrame: node.layout.visibleFrame
+    }))
+  };
+  const nodeIds = selectRnxRasterNodeIds(tree);
+  const frames = rnxRasterFrames(tree, nodeIds);
+  return [...nodeIds].flatMap((nodeId) => {
+    const frame = frames.get(nodeId);
+    return frame ? [{ key: String(nodeId), nodeId, frame }] : [];
+  });
+}
+function captureRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function captureInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value);
+}
+function captureNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function captureNullableString(value) {
+  return value === null || typeof value === "string";
+}
+function captureRect(value) {
+  return captureRecord(value) && captureNumber(value.x) && captureNumber(value.y) && captureNumber(value.width) && captureNumber(value.height);
+}
+function captureOptionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function captureOptionalNullableString(value) {
+  return value === void 0 || captureNullableString(value);
+}
+function captureFontRegistration(value) {
+  return captureRecord(value) && typeof value.family === "string" && value.family.length > 0 && captureOptionalString(value.url) && captureOptionalString(value.sourceLabel) && captureOptionalNullableString(value.parsedFamily) && captureOptionalNullableString(value.parsedPostScript) && captureOptionalNullableString(value.fullName);
+}
+function capturePoint(value) {
+  return captureRecord(value) && captureNumber(value.x) && captureNumber(value.y);
+}
+function captureNode(value) {
+  if (!captureRecord(value) || !captureInteger(value.nodeId) || !(value.parentNodeId === null || captureInteger(value.parentNodeId)) || !Array.isArray(value.childNodeIds) || !value.childNodeIds.every(captureInteger) || !captureInteger(value.paintIndex) || typeof value.type !== "string" || !captureNullableString(value.id) || !captureNullableString(value.testID) || !captureNullableString(value.text) || !captureInteger(value.childCount) || !captureRecord(value.accessibility) || !captureRecord(value.interaction) || !captureRecord(value.layout) || !captureRecord(value.style) || !captureRecord(value.source) || !captureRecord(value.props) || !captureRecord(value.inspection)) {
+    return false;
+  }
+  const accessibility = value.accessibility;
+  if (typeof accessibility.accessible !== "boolean" || !captureNullableString(accessibility.label) || !captureNullableString(accessibility.role) || !captureNullableString(accessibility.hint) || !(accessibility.liveRegion === null || accessibility.liveRegion === "none" || accessibility.liveRegion === "polite" || accessibility.liveRegion === "assertive") || !(accessibility.state === null || captureRecord(accessibility.state)) || !(accessibility.value === null || captureRecord(accessibility.value))) {
+    return false;
+  }
+  const interaction = value.interaction;
+  if (typeof interaction.pressed !== "boolean" || typeof interaction.pressable !== "boolean" || typeof interaction.textInput !== "boolean" || !(interaction.textSelection === null || captureRecord(interaction.textSelection)) || typeof interaction.secureTextEntry !== "boolean" || !captureNullableString(interaction.placeholder) || !capturePoint(interaction.scrollOffset) || !(interaction.zoomScale === null || captureNumber(interaction.zoomScale)) || typeof interaction.nativePinchEnabled !== "boolean" || !(interaction.contentOffsetProp === null || captureRecord(interaction.contentOffsetProp)) || !(interaction.strokeDashoffsetProp === null || captureNumber(interaction.strokeDashoffsetProp))) {
+    return false;
+  }
+  const layout = value.layout;
+  if (!captureRect(layout.local) || !(layout.frame === null || captureRect(layout.frame)) || !capturePoint(layout.absolutePosition) || !(layout.visibleFrame === null || captureRect(layout.visibleFrame))) {
+    return false;
+  }
+  const style = value.style;
+  return captureRecord(style.resolved) && captureRecord(style.authored) && captureRecord(style.computed) && captureRecord(style.tokenBindings) && (value.textLines === void 0 || Array.isArray(value.textLines));
+}
+function isRnxScreenCapture(value) {
+  if (!captureRecord(value) || value.contractVersion !== RNX_SCREEN_CAPTURE_VERSION || !captureInteger(value.capturedAt) || !captureRecord(value.tree) || !(value.fonts === void 0 || Array.isArray(value.fonts) && value.fonts.length <= 200 && value.fonts.every(captureFontRegistration)) || !(value.visual === void 0 || captureRecord(value.visual))) {
+    return false;
+  }
+  const tree = value.tree;
+  const visual = value.visual;
+  return captureRecord(tree.viewport) && captureInteger(tree.viewport.width) && tree.viewport.width > 0 && captureInteger(tree.viewport.height) && tree.viewport.height > 0 && captureInteger(tree.rootNodeId) && (tree.commitRevision === void 0 || captureInteger(tree.commitRevision)) && Array.isArray(tree.nodes) && tree.nodes.every(captureNode) && (visual === void 0 || visual.kind === "png" && (visual.producer === "headless-cpu-app-surface" || visual.producer === "browser-compositor-app-surface") && typeof visual.dataUri === "string" && visual.dataUri.startsWith("data:image/png;base64,") && captureInteger(visual.pixelWidth) && visual.pixelWidth > 0 && captureInteger(visual.pixelHeight) && visual.pixelHeight > 0);
+}
+function isRnxCaptureRegionAtlas(value) {
+  if (!captureRecord(value) || value.kind !== "png-atlas" || value.producer !== "headless-cpu-app-surface" || typeof value.dataUri !== "string" || !value.dataUri.startsWith("data:image/png;base64,") || !captureNumber(value.width) || value.width <= 0 || !captureNumber(value.height) || value.height <= 0 || !captureInteger(value.pixelWidth) || value.pixelWidth <= 0 || !captureInteger(value.pixelHeight) || value.pixelHeight <= 0 || !Array.isArray(value.regions) || value.regions.length === 0 || value.regions.length > 256) {
+    return false;
+  }
+  const scale = value.pixelWidth / value.width;
+  if (!Number.isInteger(scale) || scale < 1 || scale > 4 || Math.abs(value.height * scale - value.pixelHeight) > 1e-6) {
+    return false;
+  }
+  const keys = /* @__PURE__ */ new Set();
+  for (const region of value.regions) {
+    if (!captureRecord(region) || typeof region.key !== "string" || region.key.length === 0 || keys.has(region.key) || !captureInteger(region.nodeId) || region.nodeId <= 0 || !captureRect(region.frame) || region.frame.width <= 0 || region.frame.height <= 0 || !captureRect(region.source) || region.source.x < 0 || region.source.y < 0 || region.source.width !== region.frame.width || region.source.height !== region.frame.height || region.source.x + region.source.width > value.width || region.source.y + region.source.height > value.height) {
+      return false;
+    }
+    keys.add(region.key);
+  }
+  return true;
+}
+
+// src/vite-plugin-one.ts
+var import_fs4 = __toESM(require("fs"), 1);
+var import_node_crypto4 = require("node:crypto");
+var import_path3 = __toESM(require("path"), 1);
+
+// src/dev-server-open.ts
+var import_node_child_process = require("node:child_process");
+var import_node_crypto3 = require("node:crypto");
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path4 = __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_path4.default.join(projectRoot, "package.json");
+  const packageJson = JSON.parse(import_node_fs4.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_crypto3.createHash)("sha256").update(import_node_fs4.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_path4.default.resolve(import_node_path4.default.dirname((0, import_node_url.fileURLToPath)(__sootsim_import_meta_url)), "..");
+  const binPath = import_node_path4.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/host/replacement-module-handler.ts
+var import_promises = __toESM(require("node:fs/promises"), 1);
+var import_node_path5 = __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 join2(...parts) {
+  const present = parts.filter((part) => part.length > 0);
+  if (present.length === 0) return ".";
+  return normalize(present.join("/"));
+}
+function resolve2(...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 dirname3(p) {
+  const idx = p.lastIndexOf("/");
+  if (idx < 0) return ".";
+  if (idx === 0) return "/";
+  return p.slice(0, idx);
+}
+function basename2(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 = basename2(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: join2,
+  resolve: resolve2,
+  dirname: dirname3,
+  basename: basename2,
+  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(name2, specifier) {
+  const notReady = (what) => JSON.stringify(`[rnx] replacement ${what} bridge is not ready`);
+  if (specifier === "react") {
+    return `const ${name2} = ${REACT_BRIDGE}; if (!${name2}) throw new Error(${notReady("React")});`;
+  }
+  if (specifier === "react-native") {
+    return `const ${name2} = ${REACT_NATIVE_BRIDGE}; if (!${name2}) throw new Error(${notReady("React Native")});`;
+  }
+  if (isContrastKitSpecifier(specifier)) {
+    return `const ${name2} = (globalThis.__contrast_kit_modules && globalThis.__contrast_kit_modules[${JSON.stringify(specifier)}]) || (${PACKAGE_BRIDGES} || {})[${JSON.stringify(specifier)}]; if (!${name2}) throw new Error(${JSON.stringify(`[rnx] replacement package bridge ${specifier} is not ready`)});`;
+  }
+  if (JSX_RUNTIME_SPECIFIERS.has(specifier)) {
+    return `const ${name2} = (() => { 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 ${name2} = (${PACKAGE_BRIDGES} || {})[${JSON.stringify(specifier)}]; if (!${name2}) 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 name2 = `__rnxReplacementBridge${bridgeNames.size}`;
+    bridgeNames.set(specifier, name2);
+    declarations.push(bridgeDeclaration(name2, specifier));
+    return name2;
+  };
+  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/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_path5.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_path5.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_path5.default.resolve(options.projectRoot);
+    resolvedProjectRoot = await import_promises.default.realpath(options.projectRoot);
+    const lexicalTarget = import_node_path5.default.relative(lexicalProjectRoot, targetPath);
+    if (lexicalTarget.startsWith("..") || import_node_path5.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_path5.default.relative(resolvedProjectRoot, resolvedTargetPath);
+    if (relativeTarget.startsWith("..") || import_node_path5.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_fs3 = __toESM(require("fs"), 1);
+var import_path2 = __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_path2.default.dirname((0, import_url.fileURLToPath)(__sootsim_import_meta_url));
+  for (let i = 0; i < 12 && dir !== import_path2.default.dirname(dir); i++) {
+    if (import_fs3.default.existsSync(import_path2.default.join(dir, "packages/sootsim-engine/package.json")) && import_fs3.default.existsSync(import_path2.default.join(dir, "public/sootsim"))) {
+      _monorepoRootCache = dir;
+      return dir;
+    }
+    dir = import_path2.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_path2.default.join(root, "public/sootsim");
+  if (import_fs3.default.existsSync(import_path2.default.join(devBuild, "index.html")) && import_fs3.default.existsSync(import_path2.default.join(devBuild, "engine/index.html")) && import_fs3.default.existsSync(import_path2.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_fs3.default.existsSync(import_path2.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_fs3.default.existsSync(import_path2.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_path2.default.resolve(runtimeRoot, pathname.replace(/^\/+/, ""));
+  const rootWithSep = runtimeRoot.endsWith(import_path2.default.sep) ? runtimeRoot : runtimeRoot + import_path2.default.sep;
+  if (!fullPath.startsWith(rootWithSep) && fullPath !== runtimeRoot) return null;
+  if (!import_fs3.default.existsSync(fullPath) || !import_fs3.default.statSync(fullPath).isFile()) return null;
+  return fullPath;
+}
+function serveRuntimeFile(req, res, fullPath) {
+  const ext = import_path2.default.extname(fullPath);
+  const stat = import_fs3.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_path2.default.basename(fullPath))) {
+    res.setHeader("cache-control", "public, max-age=31536000, immutable");
+    import_fs3.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_fs3.default.createReadStream(fullPath).pipe(res);
+}
+
+// src/vite-plugin-swift.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_os2 = __toESM(require("node:os"), 1);
+var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_util = require("node:util");
+
+// ../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_path6.default.join(
+  import_node_os2.default.homedir(),
+  `Library/Developer/Toolchains/${toolchain_default.release}.xctoolchain/usr/bin`
+);
+var WASM_SDK = `${toolchain_default.release}_wasm`;
+var BUNDLE_MAX_FILE_BYTES = 2 * 1024 * 1024;
+var BUNDLE_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
+
+// src/vite-plugin-one.ts
+function rnxPlugin(options = {}) {
+  const prefix2 = 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_crypto4.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_fs4.default.readFileSync(import_path3.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,'','${prefix2}/'+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 === prefix2 || pathname === prefix2 + "/" || pathname.startsWith(prefix2 + "/")) {
+            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 === prefix2 || pathname === prefix2 + "/") {
+          res.setHeader("content-type", "text/html");
+          res.end(buildShellHtml(runtimeRoot));
+          return;
+        }
+        if (pathname.startsWith(prefix2 + "/")) {
+          const fullPath = resolveRuntimeFilePath(
+            runtimeRoot,
+            pathname.slice(prefix2.length)
+          );
+          if (fullPath) {
+            serveRuntimeFile(req, res, fullPath);
+            return;
+          }
+          const ext = import_path3.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}${prefix2}/`;
+      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
+          );
+        });
+      }
+    }
+  };
+}
+
+// src/metro-plugin.ts
+var import_fs5 = __toESM(require("fs"), 1);
+var import_module2 = require("module");
+var import_node_crypto5 = require("node:crypto");
+var import_path4 = __toESM(require("path"), 1);
+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_module2.createRequire)(import_path4.default.join(projectRoot, "package.json"));
+  const metroRoot = import_path4.default.dirname(projectRequire.resolve("metro/package.json"));
+  const baseJSBundle = readCallableMetroExport(
+    projectRequire(import_path4.default.join(metroRoot, "src/DeltaBundler/Serializers/baseJSBundle.js")),
+    "baseJSBundle"
+  );
+  const bundleToString = readCallableMetroExport(
+    projectRequire(import_path4.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_path4.default.relative(projectRoot, module2.path).replaceAll(import_path4.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_crypto5.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 connect2;
+      try {
+        connect2 = require("connect");
+      } catch {
+        console.warn("[rnx] connect not available");
+        return middleware;
+      }
+      const server = connect2();
+      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_path4.default.extname(pathname);
+          if (!ext) {
+            const htmlPath = import_path4.default.join(runtimeRoot, "index.html");
+            let html = import_fs5.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;
+
+// src/jump-to-source-babel.ts
+function normalizeSourcePath(path9) {
+  const queryStart = path9.indexOf("?");
+  const clean = queryStart >= 0 ? path9.slice(0, queryStart) : path9;
+  return clean.replace(/\\/g, "/");
+}
+function matchesPath(path9, matcher) {
+  return typeof matcher === "string" ? path9.includes(matcher) : matcher.test(path9);
+}
+function shouldStampFile(filename, options) {
+  const normalized = normalizeSourcePath(filename);
+  if (normalized.includes("/node_modules/")) return false;
+  if (normalized.includes("/dist/") || normalized.includes("/build/")) return false;
+  if (options.exclude?.some((matcher) => matchesPath(normalized, matcher))) return false;
+  if (options.include?.length) {
+    return options.include.some((matcher) => matchesPath(normalized, matcher));
+  }
+  return true;
+}
+function getJSXName(node) {
+  if (!node) return null;
+  if (node.type === "JSXIdentifier" && node.name) return node.name;
+  if (node.type === "JSXMemberExpression") {
+    const object = getJSXName(node.object);
+    const property = getJSXName(node.property);
+    return object && property ? `${object}.${property}` : null;
+  }
+  return null;
+}
+function hasAttribute(node, attrName) {
+  return node.attributes?.some((attr) => {
+    if (attr.type !== "JSXAttribute") return false;
+    return attr.name?.type === "JSXIdentifier" && attr.name.name === attrName;
+  }) ?? false;
+}
+function sootsimJumpToSourceBabelPlugin(api, options = {}) {
+  const attrName = options.attrName || "srcloc";
+  return {
+    name: "sootsim-jump-to-source",
+    visitor: {
+      JSXOpeningElement(path9, state) {
+        if (options.enabled === false) return;
+        const filename = state.file?.opts?.filename;
+        if (!filename || !shouldStampFile(filename, options)) return;
+        const node = path9.node;
+        const tagName = getJSXName(node.name);
+        if (!tagName || tagName === "Fragment" || tagName.endsWith(".Fragment")) return;
+        if (hasAttribute(node, attrName)) return;
+        const loc = node.loc?.start;
+        if (!loc) return;
+        const source = `${normalizeSourcePath(filename)}:${loc.line}:${loc.column + 1}`;
+        node.attributes ??= [];
+        node.attributes.push(
+          api.types.jsxAttribute(
+            api.types.jsxIdentifier(attrName),
+            api.types.stringLiteral(source)
+          )
+        );
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SOOTSIM_BRIDGE_PORT,
+  DEFAULT_SOOTSIM_BRIDGE_URL,
+  DEFAULT_SOOTSIM_SHELL_URL,
+  RNX_SCREEN_CAPTURE_VERSION,
+  SimClient,
+  SimClientError,
+  SimConnectError,
+  SimKeyboardError,
+  SimPerformError,
+  SimReadyTimeoutError,
+  SimResetError,
+  SimTapError,
+  connect,
+  isRnxCaptureRegionAtlas,
+  isRnxScreenCapture,
+  jumpToSourceBabelPlugin,
+  metroPlugin,
+  rnxCaptureRasterRegions,
+  rnxPlugin,
+  rnxRasterFrames,
+  selectRnxRasterNodeIds
+});