rnxsim 0.0.0 → 0.1.312

package/dist-lib/scripts/dev-server-scanner.cjs

@@ -0,0 +1,1034 @@
+/*! rnx v0.1.312 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// scripts/dev-server-scanner.ts
+var dev_server_scanner_exports = {};
+__export(dev_server_scanner_exports, {
+  __applyManifestForTests: () => __applyManifestForTests,
+  __attachAppSettingsBundleForTests: () => __attachAppSettingsBundleForTests,
+  __isSootSimSelfServerForTests: () => __isSootSimSelfServerForTests,
+  __resetScannerCache: () => __resetScannerCache,
+  __shouldReuseScannerCacheEntry: () => __shouldReuseScannerCacheEntry,
+  discoverListeningPorts: () => discoverListeningPorts,
+  discoverListeningProcesses: () => discoverListeningProcesses,
+  pidFromNetstat: () => pidFromNetstat,
+  probePort: () => probePort,
+  resolveListeningPid: () => resolveListeningPid,
+  resolveProcessCwd: () => resolveProcessCwd,
+  scanDevServers: () => scanDevServers
+});
+module.exports = __toCommonJS(dev_server_scanner_exports);
+var import_child_process = require("child_process");
+var import_promises2 = require("fs/promises");
+var import_http = __toESM(require("http"), 1);
+var import_net = __toESM(require("net"), 1);
+var import_node_path3 = require("node:path");
+var import_util = require("util");
+
+// src/config.ts
+var SOOTSIM_CONFIG_QUERY_PARAM = "sootsimConfig";
+function hasOwnKeys(value) {
+  return !!value && Object.keys(value).length > 0;
+}
+function hasSootSimConfig(config) {
+  if (!config) return false;
+  return typeof config.runtimeVersion === "string" && config.runtimeVersion.length > 0 || hasOwnKeys(config.modules) || hasOwnKeys(config.turboModules) || hasOwnKeys(config.nativeModules) || hasOwnKeys(config.env) || hasOwnKeys(config.network?.remap) || hasOwnKeys(config.settings) || hasOwnKeys(config.initialState);
+}
+function applySootSimConfigToUrl(url, config) {
+  const parsed = new URL(url);
+  if (hasSootSimConfig(config)) {
+    parsed.searchParams.set(SOOTSIM_CONFIG_QUERY_PARAM, JSON.stringify(config));
+  } else {
+    parsed.searchParams.delete(SOOTSIM_CONFIG_QUERY_PARAM);
+  }
+  return parsed.toString();
+}
+
+// src/native-dev-bundle-url.ts
+function isAbsoluteHttpUrl(url) {
+  return /^https?:\/\//i.test(url);
+}
+function isNativeDevBundlePath(pathname) {
+  return pathname.endsWith(".bundle");
+}
+function applyPreviewProdBundle(parsed) {
+  if (!process.env.SOOTSIM_PREVIEW_PROD_BUNDLE) return;
+  parsed.searchParams.set("dev", "false");
+  parsed.searchParams.set("minify", "true");
+  if (parsed.searchParams.has("hot")) parsed.searchParams.set("hot", "false");
+}
+function normalizeNativeDevBundleUrl(bundleUrl) {
+  try {
+    const isAbsolute = isAbsoluteHttpUrl(bundleUrl);
+    const parsed = new URL(bundleUrl, "http://sootsim.local");
+    parsed.pathname = parsed.pathname.replace(/\.\.bundle$/, ".bundle");
+    if (!isNativeDevBundlePath(parsed.pathname)) return bundleUrl;
+    parsed.searchParams.delete("transform.bytecode");
+    if (parsed.searchParams.get("lazy") === "true") {
+      parsed.searchParams.set("lazy", "false");
+    }
+    applyPreviewProdBundle(parsed);
+    if (isAbsolute) return parsed.toString();
+    return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+  } catch {
+    return bundleUrl;
+  }
+}
+
+// src/settings-bundle.ts
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+
+// src/plist.ts
+var import_plist = __toESM(require("@expo/plist"), 1);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolvePlistParser(value) {
+  if (!isRecord(value)) return null;
+  const direct = value.parse;
+  if (typeof direct === "function") {
+    return (source) => Reflect.apply(direct, value, [source]);
+  }
+  const nested = value.default;
+  if (!isRecord(nested)) return null;
+  const nestedParse = nested.parse;
+  return typeof nestedParse === "function" ? (source) => Reflect.apply(nestedParse, nested, [source]) : null;
+}
+var parsePlist = resolvePlistParser(import_plist.default);
+function parsePlistSource(source) {
+  return parsePlist?.(source) ?? null;
+}
+
+// src/settings-bundle.ts
+var MAX_PLIST_BYTES = 1048576;
+var MAX_CHILD_DEPTH = 8;
+var MAX_PLIST_FILES = 32;
+var MAX_SPECIFIERS = 512;
+var settingsBundleCache = /* @__PURE__ */ new Map();
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function requiredString(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized ? normalized : null;
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function preferenceValue(value) {
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  return finiteNumber(value);
+}
+function keyboardType(value) {
+  if (typeof value !== "string") return void 0;
+  switch (value.replaceAll(/[-_\s]/g, "").toLowerCase()) {
+    case "alphabet":
+      return "alphabet";
+    case "numbersandpunctuation":
+      return "numbers-and-punctuation";
+    case "numberpad":
+      return "number-pad";
+    case "url":
+      return "url";
+    case "emailaddress":
+      return "email-address";
+    case "namephonepad":
+      return "name-phone-pad";
+    case "asciicapable":
+      return "ascii-capable";
+    default:
+      return void 0;
+  }
+}
+function autocapitalization(value) {
+  if (typeof value !== "string") return void 0;
+  switch (value.replaceAll(/[-_\s]/g, "").toLowerCase()) {
+    case "none":
+      return "none";
+    case "sentences":
+      return "sentences";
+    case "words":
+      return "words";
+    case "allcharacters":
+      return "all-characters";
+    default:
+      return void 0;
+  }
+}
+function autocorrection(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value !== "string") return void 0;
+  switch (value.trim().toLowerCase()) {
+    case "yes":
+      return true;
+    case "no":
+      return false;
+    default:
+      return void 0;
+  }
+}
+function safeChildPlistName(value) {
+  const file = requiredString(value);
+  if (!file || file.includes("/") || file.includes("\\") || file.includes("..")) {
+    return null;
+  }
+  return {
+    file,
+    name: file.toLowerCase().endsWith(".plist") ? file : `${file}.plist`
+  };
+}
+async function readableSettingsBundle(path) {
+  try {
+    const root = await (0, import_promises.stat)((0, import_node_path.join)(path, "Root.plist"));
+    return root.isFile() && root.size <= MAX_PLIST_BYTES;
+  } catch {
+    return false;
+  }
+}
+async function findSettingsBundle(projectRoot) {
+  const directCandidates = [
+    (0, import_node_path.join)(projectRoot, "Settings.bundle"),
+    (0, import_node_path.join)(projectRoot, "ios", "Settings.bundle")
+  ];
+  for (const candidate of directCandidates) {
+    if (await readableSettingsBundle(candidate)) return candidate;
+  }
+  try {
+    const iosRoot = (0, import_node_path.join)(projectRoot, "ios");
+    const children = await (0, import_promises.readdir)(iosRoot, { withFileTypes: true });
+    const candidates = children.filter(
+      (entry) => entry.isDirectory() && entry.name !== "Pods" && entry.name !== "build" && !entry.name.startsWith(".")
+    ).map((entry) => (0, import_node_path.join)(iosRoot, entry.name, "Settings.bundle")).sort();
+    for (const candidate of candidates) {
+      if (await readableSettingsBundle(candidate)) return candidate;
+    }
+  } catch {
+  }
+  return null;
+}
+async function settingsBundleFingerprint(bundlePath) {
+  try {
+    const entries = await (0, import_promises.readdir)(bundlePath, { withFileTypes: true });
+    const names = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".plist")).map((entry) => entry.name).sort().slice(0, MAX_PLIST_FILES + 1);
+    if (names.length === 0 || names.length > MAX_PLIST_FILES) return null;
+    const parts = await Promise.all(
+      names.map(async (name) => {
+        const metadata = await (0, import_promises.stat)((0, import_node_path.join)(bundlePath, name));
+        if (!metadata.isFile() || metadata.size > MAX_PLIST_BYTES) return null;
+        return `${name}:${metadata.size}:${metadata.mtimeMs}:${metadata.ctimeMs}`;
+      })
+    );
+    if (parts.some((part) => part === null)) return null;
+    return parts.join("|");
+  } catch {
+    return null;
+  }
+}
+async function parsePlistRecord(path) {
+  try {
+    const metadata = await (0, import_promises.stat)(path);
+    if (!metadata.isFile() || metadata.size > MAX_PLIST_BYTES) return null;
+    const source = await (0, import_promises.readFile)(path, "utf8");
+    const parsed = parsePlistSource(source);
+    return isRecord2(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeMultiValue(raw, key, title) {
+  if (!Array.isArray(raw.Values) || !Array.isArray(raw.Titles)) return null;
+  const values = [];
+  const titles = [];
+  let optionType;
+  const pairCount = Math.min(raw.Values.length, raw.Titles.length);
+  for (let index = 0; index < pairCount; index++) {
+    const value = preferenceValue(raw.Values[index]);
+    const optionTitle = optionalString(raw.Titles[index]);
+    if (value === null || optionTitle === void 0) continue;
+    const valueType = typeof value === "string" ? "string" : typeof value === "number" ? "number" : "boolean";
+    if (optionType !== void 0 && valueType !== optionType) continue;
+    optionType = valueType;
+    values.push(value);
+    titles.push(optionTitle);
+  }
+  const firstValue = values[0];
+  if (firstValue === void 0) return null;
+  const declaredDefault = preferenceValue(raw.DefaultValue);
+  const defaultValue = declaredDefault !== null && values.includes(declaredDefault) ? declaredDefault : firstValue;
+  return {
+    type: "multi-value",
+    key,
+    title,
+    defaultValue,
+    currentValue: defaultValue,
+    values,
+    titles
+  };
+}
+async function normalizeSpecifier(raw, context) {
+  if (!isRecord2(raw)) return null;
+  if (context.budget.specifiers >= MAX_SPECIFIERS) return null;
+  const type = requiredString(raw.Type);
+  if (!type) return null;
+  context.budget.specifiers += 1;
+  if (type === "PSGroupSpecifier") {
+    const title2 = optionalString(raw.Title);
+    const footer = optionalString(raw.FooterText);
+    return {
+      type: "group",
+      ...title2 !== void 0 ? { title: title2 } : null,
+      ...footer !== void 0 ? { footer } : null
+    };
+  }
+  const key = requiredString(raw.Key);
+  if (type === "PSSliderSpecifier") {
+    if (!key) return null;
+    const minimumValue = finiteNumber(raw.MinimumValue);
+    const maximumValue = finiteNumber(raw.MaximumValue);
+    if (minimumValue === null || maximumValue === null || maximumValue <= minimumValue) {
+      return null;
+    }
+    const declaredDefault = finiteNumber(raw.DefaultValue);
+    const defaultValue = Math.min(
+      maximumValue,
+      Math.max(minimumValue, declaredDefault ?? minimumValue)
+    );
+    const title2 = optionalString(raw.Title);
+    const minimumValueImage = optionalString(raw.MinimumValueImage);
+    const maximumValueImage = optionalString(raw.MaximumValueImage);
+    return {
+      type: "slider",
+      key,
+      defaultValue,
+      currentValue: defaultValue,
+      minimumValue,
+      maximumValue,
+      ...title2 !== void 0 ? { title: title2 } : null,
+      ...minimumValueImage !== void 0 ? { minimumValueImage } : null,
+      ...maximumValueImage !== void 0 ? { maximumValueImage } : null
+    };
+  }
+  if (type === "PSChildPaneSpecifier") {
+    const title2 = requiredString(raw.Title);
+    const child = safeChildPlistName(raw.File);
+    if (!title2 || !child || context.depth >= MAX_CHILD_DEPTH) return null;
+    const childSpecifiers = await parseSpecifierFile(child.name, {
+      ...context,
+      depth: context.depth + 1
+    });
+    if (!childSpecifiers || childSpecifiers.length === 0) return null;
+    return {
+      type: "child-pane",
+      title: title2,
+      file: child.file,
+      specifiers: childSpecifiers
+    };
+  }
+  if (!key) return null;
+  const title = requiredString(raw.Title) ?? key;
+  if (type === "PSToggleSwitchSpecifier") {
+    const defaultValue = typeof raw.DefaultValue === "boolean" ? raw.DefaultValue : false;
+    return {
+      type: "toggle",
+      key,
+      title,
+      defaultValue,
+      currentValue: defaultValue
+    };
+  }
+  if (type === "PSTextFieldSpecifier") {
+    const defaultValue = optionalString(raw.DefaultValue) ?? "";
+    const placeholder = optionalString(raw.Placeholder);
+    const resolvedKeyboardType = keyboardType(raw.KeyboardType);
+    const resolvedAutocapitalization = autocapitalization(raw.AutocapitalizationType);
+    const resolvedAutocorrection = autocorrection(raw.AutocorrectionType);
+    return {
+      type: "text",
+      key,
+      title,
+      defaultValue,
+      currentValue: defaultValue,
+      ...placeholder !== void 0 ? { placeholder } : null,
+      ...typeof raw.IsSecure === "boolean" ? { secure: raw.IsSecure } : null,
+      ...resolvedKeyboardType ? { keyboardType: resolvedKeyboardType } : null,
+      ...resolvedAutocapitalization ? { autocapitalization: resolvedAutocapitalization } : null,
+      ...resolvedAutocorrection !== void 0 ? { autocorrection: resolvedAutocorrection } : null
+    };
+  }
+  if (type === "PSMultiValueSpecifier" || type === "PSRadioGroupSpecifier") {
+    return normalizeMultiValue(raw, key, title);
+  }
+  if (type === "PSTitleValueSpecifier") {
+    const defaultValue = preferenceValue(raw.DefaultValue) ?? "";
+    return {
+      type: "title-value",
+      key,
+      title,
+      defaultValue,
+      currentValue: defaultValue
+    };
+  }
+  return null;
+}
+async function parseSpecifierFile(fileName, context) {
+  const cached2 = context.fileCache.get(fileName);
+  if (cached2 !== void 0) return cached2;
+  if (context.stack.has(fileName) || context.budget.files >= MAX_PLIST_FILES) {
+    return null;
+  }
+  context.budget.files += 1;
+  const root = await parsePlistRecord((0, import_node_path.join)(context.bundlePath, fileName));
+  if (!root || !Array.isArray(root.PreferenceSpecifiers)) {
+    context.fileCache.set(fileName, null);
+    return null;
+  }
+  const stack = new Set(context.stack);
+  stack.add(fileName);
+  const specifiers = [];
+  for (const raw of root.PreferenceSpecifiers) {
+    if (context.budget.specifiers >= MAX_SPECIFIERS) break;
+    const specifier = await normalizeSpecifier(raw, { ...context, stack });
+    if (specifier) specifiers.push(specifier);
+  }
+  context.fileCache.set(fileName, specifiers);
+  return specifiers;
+}
+async function readAppSettingsBundle(projectRoot) {
+  const bundlePath = await findSettingsBundle(projectRoot);
+  if (!bundlePath) return null;
+  const fingerprint = await settingsBundleFingerprint(bundlePath);
+  if (!fingerprint) return null;
+  const cached2 = settingsBundleCache.get(bundlePath);
+  if (cached2?.fingerprint === fingerprint) return cached2.specifiers;
+  const specifiers = await parseSpecifierFile("Root.plist", {
+    bundlePath,
+    depth: 0,
+    budget: { files: 0, specifiers: 0 },
+    stack: /* @__PURE__ */ new Set(),
+    fileCache: /* @__PURE__ */ new Map()
+  });
+  const normalized = specifiers && specifiers.length > 0 ? specifiers : null;
+  settingsBundleCache.set(bundlePath, { fingerprint, specifiers: normalized });
+  return normalized;
+}
+function __resetAppSettingsBundleCacheForTests() {
+  settingsBundleCache.clear();
+}
+
+// scripts/optional-demo-registry.ts
+var import_node_fs = require("node:fs");
+var import_node_path2 = require("node:path");
+var import_node_url = require("node:url");
+var REGISTRY_REPO_PATH = "packages/sootsim/scripts/demo-app-registry.ts";
+var MAX_ANCESTOR_STEPS = 8;
+function findInternalDemoRegistry(startDir) {
+  let dir = startDir;
+  for (let step = 0; step < MAX_ANCESTOR_STEPS; step++) {
+    if ((0, import_node_path2.basename)(dir) === "node_modules") return null;
+    const candidate = (0, import_node_path2.join)(dir, REGISTRY_REPO_PATH);
+    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
+    const parent = (0, import_node_path2.dirname)(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+var cached = null;
+async function loadOptionalDemoApps() {
+  if (cached) return cached;
+  const registryPath = findInternalDemoRegistry((0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(__sootsim_import_meta_url)));
+  if (!registryPath) {
+    cached = [];
+    return cached;
+  }
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      (0, import_node_url.pathToFileURL)(registryPath).href
+    );
+    cached = Array.isArray(mod.APPS) ? mod.APPS : [];
+  } catch {
+    cached = [];
+  }
+  return cached;
+}
+function optionalDemoAppsSync() {
+  return cached ?? [];
+}
+
+// scripts/dev-server-scanner.ts
+var execP = (0, import_util.promisify)(import_child_process.exec);
+var TIMEOUT_MS = 250;
+var MANIFEST_TIMEOUT_MS = 1500;
+var TCP_GATE_MS = 120;
+function tcpPing(port, timeout = TCP_GATE_MS) {
+  return new Promise((resolve2) => {
+    const sock = new import_net.default.Socket();
+    let settled = false;
+    const done = (ok) => {
+      if (settled) return;
+      settled = true;
+      sock.destroy();
+      resolve2(ok);
+    };
+    sock.setTimeout(timeout);
+    sock.once("connect", () => done(true));
+    sock.once("timeout", () => done(false));
+    sock.once("error", () => done(false));
+    sock.connect(port, "localhost");
+  });
+}
+function httpGet(port, path, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+  return new Promise((resolve2) => {
+    const req = import_http.default.request(
+      { hostname: "localhost", port, path, method, timeout, headers },
+      (res) => {
+        let body = "";
+        res.on("data", (c) => body += c.toString());
+        const contentType = (() => {
+          const raw = res.headers["content-type"];
+          if (typeof raw === "string") return raw;
+          if (Array.isArray(raw)) return raw[0];
+          return void 0;
+        })();
+        res.on(
+          "end",
+          () => resolve2({ statusCode: res.statusCode || 0, body, contentType })
+        );
+      }
+    );
+    req.on("error", () => resolve2(null));
+    req.setTimeout(timeout, () => {
+      req.destroy();
+      resolve2(null);
+    });
+    req.end();
+  });
+}
+var FALLBACK_PORTS = [
+  8081,
+  8082,
+  8083,
+  8084,
+  8085,
+  8086,
+  3e3,
+  3001,
+  19e3
+].map((port) => ({ port, pid: 0 }));
+function acceptPort(port, excluded) {
+  if (port <= 0 || port >= 2e4) return false;
+  if (excluded.has(port)) return false;
+  if (port >= 5170 && port <= 5200) return false;
+  return true;
+}
+async function discoverListeningProcesses(excludePorts = []) {
+  const excluded = new Set(excludePorts);
+  try {
+    const { stdout } = await execP(
+      `lsof -iTCP -sTCP:LISTEN -P -n 2>/dev/null | grep -E '^(node|bun)'`,
+      { encoding: "utf8", timeout: 2e3 }
+    );
+    if (stdout.trim()) {
+      const seen = /* @__PURE__ */ new Map();
+      for (const line of stdout.trim().split("\n")) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 9) continue;
+        const pid = Number(parts[1]);
+        const addr = parts[8];
+        const m = addr.match(/:(\d+)$/);
+        if (!m) continue;
+        const port = Number(m[1]);
+        if (!acceptPort(port, excluded)) continue;
+        if (!seen.has(port)) seen.set(port, pid);
+      }
+      if (seen.size > 0) {
+        return [...seen.entries()].map(([port, pid]) => ({ port, pid }));
+      }
+    }
+  } catch {
+  }
+  try {
+    const { stdout } = await execP(`ss -tlnp 2>/dev/null | grep -E '"(node|bun)"'`, {
+      encoding: "utf8",
+      timeout: 2e3
+    });
+    if (stdout.trim()) {
+      const seen = /* @__PURE__ */ new Map();
+      for (const line of stdout.trim().split("\n")) {
+        const portMatch = line.match(/:(\d+)\s/);
+        const pidMatch = line.match(/pid=(\d+)/);
+        if (!portMatch) continue;
+        const port = Number(portMatch[1]);
+        const pid = pidMatch ? Number(pidMatch[1]) : 0;
+        if (!acceptPort(port, excluded)) continue;
+        if (!seen.has(port)) seen.set(port, pid);
+      }
+      if (seen.size > 0) {
+        return [...seen.entries()].map(([port, pid]) => ({ port, pid }));
+      }
+    }
+  } catch {
+  }
+  return FALLBACK_PORTS.filter((p) => acceptPort(p.port, excluded));
+}
+async function discoverListeningPorts(excludePorts = []) {
+  const processes = await discoverListeningProcesses(excludePorts);
+  return processes.map((p) => p.port);
+}
+function pidFromNetstat(stdout, port) {
+  for (const line of stdout.split("\n")) {
+    if (!line.includes("LISTEN")) continue;
+    const parts = line.trim().split(/\s+/);
+    if (!parts[3]?.endsWith(`.${port}`)) continue;
+    for (const token of parts) {
+      const owner = token.match(/^\S+:(\d+)$/);
+      if (owner) {
+        const pid = Number(owner[1]);
+        if (pid > 0) return pid;
+      }
+    }
+  }
+  return null;
+}
+async function resolveListeningPid(port) {
+  if (!Number.isInteger(port) || port <= 0) return null;
+  try {
+    const { stdout } = await execP("netstat -anv -p tcp 2>/dev/null", {
+      encoding: "utf8",
+      timeout: 8e3,
+      maxBuffer: 16 * 1024 * 1024
+    });
+    const pid = pidFromNetstat(stdout, port);
+    if (pid !== null) return pid;
+  } catch {
+  }
+  try {
+    const { stdout } = await execP(`ss -tlnp 2>/dev/null`, {
+      encoding: "utf8",
+      timeout: 8e3,
+      maxBuffer: 16 * 1024 * 1024
+    });
+    for (const line of stdout.split("\n")) {
+      if (!new RegExp(`:${port}\\s`).test(line)) continue;
+      const pid = Number(line.match(/pid=(\d+)/)?.[1]);
+      if (pid > 0) return pid;
+    }
+  } catch {
+  }
+  return null;
+}
+var cwdByPid = /* @__PURE__ */ new Map();
+async function resolveProcessCwd(pid) {
+  if (pid <= 0) return null;
+  const cached2 = cwdByPid.get(pid);
+  if (cached2) return cached2;
+  try {
+    const cwd = await (0, import_promises2.readlink)(`/proc/${pid}/cwd`);
+    if (cwd) {
+      cwdByPid.set(pid, cwd);
+      return cwd;
+    }
+  } catch {
+  }
+  try {
+    const { stdout } = await execP(`lsof -b -w -p ${pid} -a -d cwd -Fn 2>/dev/null`, {
+      encoding: "utf8",
+      timeout: 8e3
+    });
+    for (const line of stdout.split("\n")) {
+      if (line.startsWith("n") && line.length > 1) {
+        const cwd = line.slice(1).trim();
+        if (cwd) {
+          cwdByPid.set(pid, cwd);
+          return cwd;
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function makeResult(port, framework, owner) {
+  return {
+    port,
+    framework,
+    bundleUrl: withRuntimeConfig(
+      port,
+      `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`,
+      owner.cwd
+    ),
+    hmrUrl: `ws://localhost:${port}/hot`,
+    lastSeen: Date.now(),
+    ...owner
+  };
+}
+function withRuntimeConfig(port, bundleUrl, projectCwd) {
+  const knownApp = projectCwd ? optionalDemoAppsSync().find(
+    (app) => app.preferredPort === port && (0, import_node_path3.resolve)(app.dir) === (0, import_node_path3.resolve)(projectCwd)
+  ) : void 0;
+  const configured = knownApp?.runtimeConfig ? applySootSimConfigToUrl(bundleUrl, knownApp.runtimeConfig) : bundleUrl;
+  return normalizeNativeDevBundleUrl(configured);
+}
+function isDirectOneBundleUrl(bundleUrl) {
+  return bundleUrl.includes("/node_modules/one/metro-entry.bundle");
+}
+function safeParseManifest(body) {
+  try {
+    const parsed = JSON.parse(body);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function applyManifest(result, manifestRes, buildIconProxyUrl) {
+  if (!manifestRes) return result;
+  try {
+    const manifest = JSON.parse(manifestRes.body);
+    const client = manifest?.extra?.expoClient || manifest?.extra || {};
+    if (client.name) result.projectName = client.name;
+    if (client.ios?.bundleIdentifier) result.bundleId = client.ios.bundleIdentifier;
+    if (result.framework === "metro" && client.sdkVersion) result.framework = "expo";
+    const launchUrl = manifest?.launchAsset?.url;
+    if (launchUrl && !result.patched && !isDirectOneBundleUrl(result.bundleUrl)) {
+      result.bundleUrl = withRuntimeConfig(result.port, launchUrl, result.cwd);
+    }
+    const rawIconUrl = client.iconUrl || client.ios?.iconUrl || client.icon || client.ios?.icon;
+    if (rawIconUrl) {
+      result.iconPath = rawIconUrl;
+      if (buildIconProxyUrl) {
+        if (rawIconUrl.startsWith("http")) {
+          result.iconUrl = buildIconProxyUrl(rawIconUrl);
+        } else {
+          const cleanPath = rawIconUrl.replace(/^\.\//, "");
+          result.iconUrl = buildIconProxyUrl(
+            `http://localhost:${result.port}/assets/${cleanPath}`
+          );
+        }
+      } else {
+        result.iconUrl = rawIconUrl.startsWith("http") ? rawIconUrl : `http://localhost:${result.port}/assets/${rawIconUrl.replace(/^\.\//, "")}`;
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+function __applyManifestForTests(result, manifestBody) {
+  return applyManifest(result, { statusCode: 200, body: manifestBody });
+}
+var ENRICH_TIMEOUT_MS = 2e4;
+var enrichmentCache = /* @__PURE__ */ new Map();
+var enrichmentInFlight = /* @__PURE__ */ new Set();
+function enrichWithManifest(result, buildIconProxyUrl) {
+  if (result.projectName) return result;
+  const cached2 = enrichmentCache.get(result.port);
+  if (cached2) {
+    if (cached2.projectName) result.projectName = cached2.projectName;
+    if (cached2.iconUrl && !result.iconUrl) {
+      result.iconUrl = cached2.iconUrl;
+      result.iconPath = cached2.iconPath;
+    }
+    if (cached2.bundleId && !result.bundleId) result.bundleId = cached2.bundleId;
+    return result;
+  }
+  if (!enrichmentInFlight.has(result.port)) {
+    enrichmentInFlight.add(result.port);
+    const port = result.port;
+    void fetchManifestEnrichment(port, buildIconProxyUrl).finally(
+      () => enrichmentInFlight.delete(port)
+    );
+  }
+  return result;
+}
+async function fetchManifestEnrichment(port, buildIconProxyUrl) {
+  const manifestRes = await httpGet(port, "/", "GET", ENRICH_TIMEOUT_MS, {
+    "expo-platform": "ios"
+  });
+  if (!manifestRes || manifestRes.statusCode !== 200) return;
+  const parsed = applyManifest(
+    { port, framework: "one", bundleUrl: "", lastSeen: 0 },
+    manifestRes,
+    buildIconProxyUrl
+  );
+  if (!parsed.projectName && !parsed.iconUrl) return;
+  enrichmentCache.set(port, {
+    projectName: parsed.projectName,
+    iconUrl: parsed.iconUrl,
+    iconPath: parsed.iconPath,
+    bundleId: parsed.bundleId
+  });
+  portCache.delete(port);
+}
+var knownNonPatched = /* @__PURE__ */ new Set();
+var knownNonExpo = /* @__PURE__ */ new Set();
+var knownOne = /* @__PURE__ */ new Set();
+async function probePort(port, buildIconProxyUrl, listeningProcess) {
+  await loadOptionalDemoApps();
+  if (!await tcpPing(port)) return null;
+  const suppliedPid = listeningProcess?.pid;
+  const ownerPid = suppliedPid && suppliedPid > 0 ? suppliedPid : await resolveListeningPid(port);
+  const ownerCwd = ownerPid ? await resolveProcessCwd(ownerPid) : null;
+  const owner = {
+    ...ownerPid ? { pid: ownerPid } : {},
+    ...ownerCwd ? { cwd: ownerCwd } : {}
+  };
+  const onePath = `/node_modules/one/metro-entry.bundle?platform=ios&dev=true`;
+  const [sootsimRes, statusRes, manifestRes, expoRes] = await Promise.all([
+    knownNonPatched.has(port) ? Promise.resolve(null) : httpGet(port, "/__soot/"),
+    httpGet(port, "/status"),
+    knownOne.has(port) ? Promise.resolve(null) : httpGet(port, "/", "GET", MANIFEST_TIMEOUT_MS, { "expo-platform": "ios" }),
+    knownNonExpo.has(port) ? Promise.resolve(null) : httpGet(port, "/_expo/status")
+  ]);
+  if (expoRes && expoRes.statusCode === 200) {
+    knownNonExpo.delete(port);
+  } else if (!knownNonExpo.has(port)) {
+    knownNonExpo.add(port);
+  }
+  const manifestParsed = manifestRes ? safeParseManifest(manifestRes.body) : null;
+  const manifestLaunchUrl = typeof manifestParsed?.launchAsset?.url === "string" ? manifestParsed.launchAsset.url : null;
+  const manifestClient = manifestParsed?.extra?.expoClient || manifestParsed?.extra || {};
+  if (manifestParsed && (manifestLaunchUrl || typeof manifestClient.name === "string")) {
+    knownNonPatched.add(port);
+    const launchUrl = manifestLaunchUrl || `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`;
+    const framework = launchUrl.includes(
+      "/one/metro-entry.bundle"
+    ) ? "one" : "expo";
+    return applyManifest(
+      {
+        port,
+        framework,
+        bundleUrl: withRuntimeConfig(port, launchUrl, owner.cwd),
+        hmrUrl: `ws://localhost:${port}/hot`,
+        lastSeen: Date.now(),
+        ...owner
+      },
+      manifestRes,
+      buildIconProxyUrl
+    );
+  }
+  if (statusRes && statusRes.body.includes("packager-status:running")) {
+    knownNonPatched.add(port);
+    return enrichWithManifest(
+      applyManifest(
+        makeResult(port, expoRes && expoRes.statusCode === 200 ? "expo" : "metro", owner),
+        manifestRes,
+        buildIconProxyUrl
+      ),
+      buildIconProxyUrl
+    );
+  }
+  if (sootsimRes && sootsimRes.statusCode === 200 && sootsimRes.body.includes("sootsim-patched")) {
+    knownNonPatched.delete(port);
+    return enrichWithManifest(
+      applyManifest(
+        {
+          port,
+          framework: "one",
+          bundleUrl: withRuntimeConfig(
+            port,
+            `http://localhost:${port}/__soot/bundle.js`,
+            owner.cwd
+          ),
+          hmrUrl: `ws://localhost:${port}/hot`,
+          lastSeen: Date.now(),
+          patched: true,
+          ...owner
+        },
+        manifestRes,
+        buildIconProxyUrl
+      ),
+      buildIconProxyUrl
+    );
+  }
+  const looksLikeMetroPackager = statusRes && statusRes.statusCode === 200 || expoRes && expoRes.statusCode === 200 || manifestRes && manifestRes.statusCode === 200 && manifestParsed != null;
+  if (looksLikeMetroPackager) {
+    return null;
+  }
+  const oneRes = await httpGet(port, onePath, "HEAD");
+  if (oneRes && oneRes.statusCode > 0 && oneRes.statusCode < 400 && /application\/javascript/i.test(oneRes.contentType || "")) {
+    knownNonPatched.add(port);
+    knownOne.add(port);
+    return enrichWithManifest(
+      applyManifest(
+        {
+          port,
+          framework: "one",
+          bundleUrl: withRuntimeConfig(
+            port,
+            `http://localhost:${port}${onePath}&minify=false`,
+            owner.cwd
+          ),
+          hmrUrl: `ws://localhost:${port}/hot`,
+          lastSeen: Date.now(),
+          ...owner
+        },
+        manifestRes,
+        buildIconProxyUrl
+      ),
+      buildIconProxyUrl
+    );
+  }
+  knownNonPatched.add(port);
+  return null;
+}
+function isSootSimSelfServer(server) {
+  const bundleId = server.bundleId?.trim().toLowerCase();
+  if (bundleId?.startsWith("dev.sootsim.")) return true;
+  return false;
+}
+var __isSootSimSelfServerForTests = isSootSimSelfServer;
+var portCache = /* @__PURE__ */ new Map();
+var NEGATIVE_CACHE_TTL_MS = 3e4;
+var WEAK_RESULT_CACHE_TTL_MS = 1500;
+function isWeakCachedResult(result) {
+  if (!result) return true;
+  if (result.framework === "metro" || result.framework === "unknown") return true;
+  return false;
+}
+function hasCurrentRuntimeConfig(result) {
+  if (!result) return true;
+  return withRuntimeConfig(result.port, result.bundleUrl, result.cwd) === result.bundleUrl;
+}
+function __shouldReuseScannerCacheEntry(entry, pid, now = Date.now()) {
+  if (pid === 0) return false;
+  if (entry.pid !== pid) return false;
+  if (!hasCurrentRuntimeConfig(entry.result)) return false;
+  const ageMs = now - entry.cachedAt;
+  if (entry.result === null && ageMs >= NEGATIVE_CACHE_TTL_MS) return false;
+  if (isWeakCachedResult(entry.result) && ageMs >= WEAK_RESULT_CACHE_TTL_MS) return false;
+  return true;
+}
+function __resetScannerCache() {
+  portCache.clear();
+  knownNonPatched.clear();
+  knownNonExpo.clear();
+  knownOne.clear();
+  enrichmentCache.clear();
+  enrichmentInFlight.clear();
+  __resetAppSettingsBundleCacheForTests();
+}
+async function attachAppSettingsBundle(result, projectRoot) {
+  const settingsBundle = await readAppSettingsBundle(projectRoot);
+  if (settingsBundle) {
+    result.settingsBundle = settingsBundle;
+    result.settingsStorageScopeUrl = result.bundleUrl;
+  } else {
+    delete result.settingsBundle;
+    delete result.settingsStorageScopeUrl;
+  }
+}
+var __attachAppSettingsBundleForTests = attachAppSettingsBundle;
+async function scanDevServers(opts = {}) {
+  await loadOptionalDemoApps();
+  const processes = await discoverListeningProcesses(opts.excludePorts);
+  const currentPorts = new Set(processes.map((p) => p.port));
+  for (const p of [...portCache.keys()]) {
+    if (!currentPorts.has(p)) portCache.delete(p);
+  }
+  for (const p of [...knownNonPatched]) {
+    if (!currentPorts.has(p)) knownNonPatched.delete(p);
+  }
+  for (const p of [...knownNonExpo]) {
+    if (!currentPorts.has(p)) knownNonExpo.delete(p);
+  }
+  for (const p of [...knownOne]) {
+    if (!currentPorts.has(p)) knownOne.delete(p);
+  }
+  for (const p of [...enrichmentCache.keys()]) {
+    if (!currentPorts.has(p)) enrichmentCache.delete(p);
+  }
+  const results = [];
+  const toProbe = [];
+  for (const { port, pid } of processes) {
+    const cached2 = portCache.get(port);
+    if (cached2 && __shouldReuseScannerCacheEntry(cached2, pid)) {
+      if (cached2.result) results.push(cached2.result);
+      continue;
+    }
+    if (cached2 && cached2.pid !== pid) {
+      knownNonPatched.delete(port);
+      knownNonExpo.delete(port);
+      knownOne.delete(port);
+      enrichmentCache.delete(port);
+    }
+    toProbe.push({ port, pid });
+  }
+  if (toProbe.length > 0) {
+    const probed = await Promise.all(
+      toProbe.map((p) => probePort(p.port, opts.buildIconProxyUrl, p))
+    );
+    probed.forEach((result, i) => {
+      const { port, pid } = toProbe[i];
+      if (pid !== 0) portCache.set(port, { pid, result, cachedAt: Date.now() });
+      if (result) results.push(result);
+    });
+  }
+  const pidByPort = /* @__PURE__ */ new Map();
+  for (const { port, pid } of processes) {
+    if (pid > 0) pidByPort.set(port, pid);
+  }
+  await Promise.all(
+    results.map(async (result) => {
+      const pid = pidByPort.get(result.port);
+      if (!pid) return;
+      result.pid = pid;
+      const cwd = await resolveProcessCwd(pid);
+      if (!cwd) return;
+      result.cwd = cwd;
+      await attachAppSettingsBundle(result, cwd);
+    })
+  );
+  const livePids = new Set(pidByPort.values());
+  for (const pid of [...cwdByPid.keys()]) {
+    if (!livePids.has(pid)) cwdByPid.delete(pid);
+  }
+  return results.filter((r) => !isSootSimSelfServer(r));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __applyManifestForTests,
+  __attachAppSettingsBundleForTests,
+  __isSootSimSelfServerForTests,
+  __resetScannerCache,
+  __shouldReuseScannerCacheEntry,
+  discoverListeningPorts,
+  discoverListeningProcesses,
+  pidFromNetstat,
+  probePort,
+  resolveListeningPid,
+  resolveProcessCwd,
+  scanDevServers
+});