peachsim 0.1.527

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

@@ -0,0 +1,1232 @@
+/*! rnx v0.1.527 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// scripts/dev-server-scanner.ts
+var dev_server_scanner_exports = {};
+__export(dev_server_scanner_exports, {
+  DevServerScanUnavailableError: () => DevServerScanUnavailableError,
+  __applyManifestForTests: () => __applyManifestForTests,
+  __attachAppSettingsBundleForTests: () => __attachAppSettingsBundleForTests,
+  __isSootSimSelfServerForTests: () => __isSootSimSelfServerForTests,
+  __resetScannerCache: () => __resetScannerCache,
+  __shouldReuseScannerCacheEntry: () => __shouldReuseScannerCacheEntry,
+  discoverListeningPorts: () => discoverListeningPorts,
+  discoverListeningProcesses: () => discoverListeningProcesses,
+  pidFromNetstat: () => pidFromNetstat,
+  probePort: () => probePort,
+  resolveListeningPid: () => resolveListeningPid,
+  resolveProcessCwd: () => resolveProcessCwd,
+  scanDevServers: () => scanDevServers,
+  scanListeningProcesses: () => scanListeningProcesses
+});
+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_fs2 = require("node:fs");
+var import_node_path3 = require("node:path");
+
+// src/backend-origin.ts
+var LOOPBACK_PROBE_HOSTNAMES = ["127.0.0.1", "::1"];
+function normalizeHostname(hostname) {
+  return hostname.replace(/^\[|\]$/g, "").toLowerCase();
+}
+function buildLoopbackProbeBaseUrl(protocol, hostname, port) {
+  const normalizedHostname = normalizeHostname(hostname);
+  const urlHost = normalizedHostname.includes(":") ? `[${normalizedHostname}]` : normalizedHostname;
+  return `${protocol}//${urlHost}:${port}`;
+}
+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/config.ts
+var RNX_CONFIG_QUERY_PARAM = "rnxConfig";
+function hasOwnKeys(value) {
+  return !!value && Object.keys(value).length > 0;
+}
+function hasRNXConfig(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 applyRNXConfigToUrl(url, config) {
+  const parsed = new URL(url);
+  if (hasRNXConfig(config)) {
+    parsed.searchParams.set(RNX_CONFIG_QUERY_PARAM, JSON.stringify(config));
+  } else {
+    parsed.searchParams.delete(RNX_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 alignLoopbackBundleUrlWithProbe(bundleUrl, probeBaseUrl) {
+  try {
+    const bundle = new URL(bundleUrl);
+    const probe = new URL(probeBaseUrl);
+    if (!isLoopbackHost(bundle.hostname) || !isLoopbackHost(probe.hostname)) {
+      return bundleUrl;
+    }
+    bundle.hostname = probe.hostname;
+    return bundle.toString();
+  } catch {
+    return bundleUrl;
+  }
+}
+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 EXEC_EXIT_GRACE_MS = 2e3;
+async function execGuarded(command, timeout, extra = {}) {
+  let child;
+  const ran = new Promise((resolve2, reject) => {
+    child = (0, import_child_process.exec)(command, { encoding: "utf8", timeout, ...extra }, (err, stdout) => {
+      if (err) reject(err);
+      else resolve2({ stdout });
+    });
+  });
+  let deadlineTimer;
+  const deadline = new Promise((_resolve, reject) => {
+    deadlineTimer = setTimeout(() => {
+      child?.kill("SIGKILL");
+      const err = new Error(`\`${command}\` did not exit within ${timeout}ms`);
+      Object.assign(err, { killed: true });
+      reject(err);
+    }, timeout + EXEC_EXIT_GRACE_MS);
+  });
+  try {
+    return await Promise.race([ran, deadline]);
+  } finally {
+    clearTimeout(deadlineTimer);
+  }
+}
+var TIMEOUT_MS = 250;
+var MANIFEST_TIMEOUT_MS = 1500;
+var TCP_GATE_MS = 120;
+var BODY_TIMEOUT_MS = 3e4;
+async function tcpPing(port, timeout = TCP_GATE_MS) {
+  try {
+    return await Promise.any(
+      LOOPBACK_PROBE_HOSTNAMES.map(
+        (hostname) => new Promise((resolve2, reject) => {
+          const sock = new import_net.default.Socket();
+          let settled = false;
+          const done = (reachable) => {
+            if (settled) return;
+            settled = true;
+            sock.destroy();
+            if (reachable) resolve2(hostname);
+            else reject(new Error(`unreachable loopback host ${hostname}`));
+          };
+          sock.setTimeout(timeout);
+          sock.once("connect", () => done(true));
+          sock.once("timeout", () => done(false));
+          sock.once("error", () => done(false));
+          sock.connect(port, hostname);
+        })
+      )
+    );
+  } catch {
+    return null;
+  }
+}
+function httpGet(hostname, port, path, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+  return new Promise((resolve2) => {
+    let settled = false;
+    const settle = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve2(value);
+    };
+    const req = import_http.default.request({ hostname, port, path, method, 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",
+        () => settle({
+          statusCode: res.statusCode || 0,
+          body,
+          contentType,
+          hostname
+        })
+      );
+    });
+    req.on("error", () => settle(null));
+    req.end();
+    const giveUp = setTimeout(() => {
+      settle(null);
+      req.socket?.unref();
+    }, timeout);
+    const abandon = setTimeout(() => req.destroy(), BODY_TIMEOUT_MS);
+    req.on("close", () => {
+      clearTimeout(giveUp);
+      clearTimeout(abandon);
+      setImmediate(() => settle(null));
+    });
+  });
+}
+var FALLBACK_PORTS = [
+  8081,
+  8082,
+  8083,
+  8084,
+  8085,
+  8086,
+  3e3,
+  3001,
+  19e3
+].map((port) => ({ port, pid: 0 }));
+var SELF_PORT_RANGE_START = 5170;
+var SELF_PORT_RANGE_END = 5200;
+function isOwnShellPort(port) {
+  const offset = Number(process.env.PORT_OFFSET) || 0;
+  if (port >= SELF_PORT_RANGE_START && port <= SELF_PORT_RANGE_END) return true;
+  return offset > 0 && port >= SELF_PORT_RANGE_START + offset && port <= SELF_PORT_RANGE_END + offset;
+}
+function acceptPort(port, excluded) {
+  if (port <= 0 || port >= 2e4) return false;
+  if (excluded.has(port)) return false;
+  if (isOwnShellPort(port)) return false;
+  return true;
+}
+var DevServerScanUnavailableError = class extends Error {
+  constructor() {
+    super("could not enumerate listening processes (lsof/ss unavailable or timed out)");
+    this.name = "DevServerScanUnavailableError";
+  }
+};
+var LISTING_TIMEOUT_MS = 1e4;
+function wasKilledByTimeout(err) {
+  return !!(err && typeof err === "object" && err.killed);
+}
+async function discoverListeningProcesses(excludePorts = []) {
+  const scan = await scanListeningProcesses(excludePorts);
+  return scan.state === "looked" ? scan.processes : [];
+}
+async function scanListeningProcesses(excludePorts = []) {
+  const excluded = new Set(excludePorts);
+  let timedOut = false;
+  try {
+    const { stdout } = await execGuarded(
+      `lsof -iTCP -sTCP:LISTEN -P -n 2>/dev/null | grep -E '^(node|bun)'`,
+      LISTING_TIMEOUT_MS
+    );
+    const seen = /* @__PURE__ */ new Map();
+    for (const line of stdout.trim() ? 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);
+    }
+    return {
+      state: "looked",
+      processes: [...seen.entries()].map(([port, pid]) => ({ port, pid }))
+    };
+  } catch (err) {
+    if (wasKilledByTimeout(err)) timedOut = true;
+  }
+  try {
+    const { stdout } = await execGuarded(
+      `ss -tlnp 2>/dev/null | grep -E '"(node|bun)"'`,
+      LISTING_TIMEOUT_MS
+    );
+    const seen = /* @__PURE__ */ new Map();
+    for (const line of stdout.trim() ? 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);
+    }
+    return {
+      state: "looked",
+      processes: [...seen.entries()].map(([port, pid]) => ({ port, pid }))
+    };
+  } catch (err) {
+    if (wasKilledByTimeout(err)) timedOut = true;
+  }
+  if (timedOut) return { state: "could-not-look" };
+  return {
+    state: "looked",
+    processes: 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 execGuarded("netstat -anv -p tcp 2>/dev/null", 8e3, {
+      maxBuffer: 16 * 1024 * 1024
+    });
+    const pid = pidFromNetstat(stdout, port);
+    if (pid !== null) return pid;
+  } catch {
+  }
+  try {
+    const { stdout } = await execGuarded(`ss -tlnp 2>/dev/null`, 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 execGuarded(
+      `lsof -b -w -p ${pid} -a -d cwd -Fn 2>/dev/null`,
+      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(hostname, port, framework, owner) {
+  return {
+    port,
+    framework,
+    bundleUrl: withRuntimeConfig(
+      port,
+      `${buildLoopbackProbeBaseUrl("http:", hostname, port)}/index.bundle?platform=ios&dev=true&hot=true&minify=false`,
+      owner.cwd
+    ),
+    hmrUrl: `${buildLoopbackProbeBaseUrl("ws:", hostname, port)}/hot`,
+    lastSeen: Date.now(),
+    ...owner
+  };
+}
+function withRuntimeConfig(port, bundleUrl, projectCwd) {
+  let physicalProjectCwd;
+  if (projectCwd) {
+    try {
+      physicalProjectCwd = (0, import_node_fs2.realpathSync)((0, import_node_path3.resolve)(projectCwd));
+    } catch {
+    }
+  }
+  const knownApps = physicalProjectCwd ? optionalDemoAppsSync().filter((app) => {
+    try {
+      return (0, import_node_fs2.realpathSync)((0, import_node_path3.resolve)(app.dir)) === physicalProjectCwd;
+    } catch {
+      return false;
+    }
+  }) : [];
+  const exactKnownApps = knownApps.filter((app) => app.preferredPort === port);
+  const knownApp = exactKnownApps.length === 1 ? exactKnownApps[0] : exactKnownApps.length === 0 && knownApps.length === 1 ? knownApps[0] : void 0;
+  const configured = knownApp?.runtimeConfig ? applyRNXConfigToUrl(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;
+  }
+}
+var localIconPathCache = /* @__PURE__ */ new Map();
+var localIconProbeInFlight = /* @__PURE__ */ new Set();
+function metroAssetPath(rawIcon) {
+  return `/assets/${rawIcon.replace(/^\.?\//, "")}`;
+}
+function staticAssetPath(rawIcon) {
+  return `/${rawIcon.replace(/^\.?\//, "")}`;
+}
+async function resolveLocalIconPath(hostname, port, rawIcon) {
+  const candidates = [metroAssetPath(rawIcon), staticAssetPath(rawIcon)];
+  for (const candidate of candidates) {
+    const res = await httpGet(hostname, port, candidate, "HEAD", ENRICH_TIMEOUT_MS);
+    if (res?.statusCode === 200) {
+      localIconPathCache.set(port, candidate);
+      portCache.delete(port);
+      return;
+    }
+  }
+}
+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 (typeof client.primaryColor === "string") result.primaryColor = client.primaryColor;
+    if (client.ios?.bundleIdentifier) result.bundleId = client.ios.bundleIdentifier;
+    if (result.framework === "metro" && client.sdkVersion) result.framework = "expo";
+    const rawLaunchUrl = manifest?.launchAsset?.url;
+    const launchUrl = typeof rawLaunchUrl === "string" ? alignLoopbackBundleUrlWithProbe(
+      rawLaunchUrl,
+      buildLoopbackProbeBaseUrl("http:", manifestRes.hostname, result.port)
+    ) : rawLaunchUrl;
+    if (launchUrl && !result.patched && !isDirectOneBundleUrl(result.bundleUrl)) {
+      result.bundleUrl = withRuntimeConfig(result.port, launchUrl, result.cwd);
+    }
+    const localIcon = client.icon || client.ios?.icon;
+    const remoteIcon = client.iconUrl || client.ios?.iconUrl;
+    const rawIcon = localIcon || remoteIcon;
+    if (rawIcon) {
+      result.iconPath = rawIcon;
+      let resolvedIconUrl;
+      if (rawIcon.startsWith("http://") || rawIcon.startsWith("https://")) {
+        let isLoopback = false;
+        try {
+          const parsed = new URL(rawIcon);
+          isLoopback = isLoopbackHost(parsed.hostname);
+        } catch {
+        }
+        if (buildIconProxyUrl) {
+          if (isLoopback) {
+            resolvedIconUrl = buildIconProxyUrl(rawIcon);
+          }
+        } else {
+          resolvedIconUrl = rawIcon;
+        }
+      } else {
+        const base = buildLoopbackProbeBaseUrl("http:", manifestRes.hostname, result.port);
+        const assetPath = localIconPathCache.get(result.port) ?? metroAssetPath(rawIcon);
+        const localUrl = `${base}${assetPath}`;
+        resolvedIconUrl = buildIconProxyUrl ? buildIconProxyUrl(localUrl) : localUrl;
+      }
+      if (resolvedIconUrl) {
+        result.iconUrl = resolvedIconUrl;
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+function __applyManifestForTests(result, manifestBody, buildIconProxyUrl) {
+  return applyManifest(
+    result,
+    {
+      statusCode: 200,
+      body: manifestBody,
+      hostname: new URL(result.bundleUrl).hostname
+    },
+    buildIconProxyUrl
+  );
+}
+var ENRICH_TIMEOUT_MS = 2e4;
+var enrichmentCache = /* @__PURE__ */ new Map();
+var enrichmentInFlight = /* @__PURE__ */ new Set();
+function ensureLocalIconPathResolved(result) {
+  const rawIcon = result.iconPath;
+  if (!rawIcon) return;
+  if (rawIcon.startsWith("http://") || rawIcon.startsWith("https://")) return;
+  if (localIconPathCache.has(result.port)) return;
+  if (localIconProbeInFlight.has(result.port)) return;
+  localIconProbeInFlight.add(result.port);
+  const hostname = normalizeHostname(new URL(result.bundleUrl).hostname);
+  void resolveLocalIconPath(hostname, result.port, rawIcon).finally(
+    () => localIconProbeInFlight.delete(result.port)
+  );
+}
+function enrichWithManifest(result, buildIconProxyUrl) {
+  ensureLocalIconPathResolved(result);
+  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);
+    void fetchManifestEnrichment(result, buildIconProxyUrl).finally(
+      () => enrichmentInFlight.delete(result.port)
+    );
+  }
+  return result;
+}
+async function fetchManifestEnrichment(result, buildIconProxyUrl) {
+  const hostname = normalizeHostname(new URL(result.bundleUrl).hostname);
+  const manifestRes = await httpGet(
+    hostname,
+    result.port,
+    "/",
+    "GET",
+    ENRICH_TIMEOUT_MS,
+    {
+      "expo-platform": "ios"
+    }
+  );
+  if (!manifestRes || manifestRes.statusCode !== 200) return;
+  const parsed = applyManifest(
+    {
+      port: result.port,
+      framework: "one",
+      bundleUrl: `${buildLoopbackProbeBaseUrl("http:", hostname, result.port)}/index.bundle`,
+      lastSeen: 0
+    },
+    manifestRes,
+    buildIconProxyUrl
+  );
+  if (!parsed.projectName && !parsed.iconUrl) return;
+  enrichmentCache.set(result.port, {
+    projectName: parsed.projectName,
+    iconUrl: parsed.iconUrl,
+    iconPath: parsed.iconPath,
+    bundleId: parsed.bundleId
+  });
+  portCache.delete(result.port);
+}
+var knownNonPatched = /* @__PURE__ */ new Set();
+var knownNonExpo = /* @__PURE__ */ new Set();
+var knownOne = /* @__PURE__ */ new Set();
+async function probePort(port, buildIconProxyUrl, listeningProcess) {
+  await loadOptionalDemoApps();
+  const probeHostname = await tcpPing(port);
+  if (!probeHostname) 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(probeHostname, port, "/__soot/"),
+    httpGet(probeHostname, port, "/status"),
+    knownOne.has(port) ? Promise.resolve(null) : httpGet(probeHostname, port, "/", "GET", MANIFEST_TIMEOUT_MS, {
+      "expo-platform": "ios"
+    }),
+    knownNonExpo.has(port) ? Promise.resolve(null) : httpGet(probeHostname, 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 || {};
+  const manifestState = !manifestRes ? "no-answer" : manifestParsed && (manifestLaunchUrl || typeof manifestClient.name === "string") ? "resolved" : "no-manifest";
+  if (manifestState === "resolved") {
+    knownNonPatched.add(port);
+    const launchUrl = manifestLaunchUrl || `${buildLoopbackProbeBaseUrl("http:", probeHostname, 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: `${buildLoopbackProbeBaseUrl("ws:", probeHostname, port)}/hot`,
+        lastSeen: Date.now(),
+        ...owner
+      },
+      manifestRes,
+      buildIconProxyUrl
+    );
+  }
+  if (statusRes && statusRes.body.includes("packager-status:running")) {
+    knownNonPatched.add(port);
+    const result = makeResult(
+      probeHostname,
+      port,
+      expoRes && expoRes.statusCode === 200 ? "expo" : "metro",
+      owner
+    );
+    if (manifestState === "no-answer") result.bundleUrlProvisional = true;
+    return enrichWithManifest(
+      applyManifest(result, 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,
+            `${buildLoopbackProbeBaseUrl("http:", probeHostname, port)}/__soot/bundle.js`,
+            owner.cwd
+          ),
+          hmrUrl: `${buildLoopbackProbeBaseUrl("ws:", probeHostname, 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(probeHostname, 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,
+            `${buildLoopbackProbeBaseUrl("http:", probeHostname, port)}${onePath}&minify=false`,
+            owner.cwd
+          ),
+          hmrUrl: `${buildLoopbackProbeBaseUrl("ws:", probeHostname, 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 scan = await scanListeningProcesses(opts.excludePorts);
+  if (scan.state === "could-not-look") throw new DevServerScanUnavailableError();
+  const processes = scan.processes;
+  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);
+  }
+  for (const p of [...localIconPathCache.keys()]) {
+    if (!currentPorts.has(p)) localIconPathCache.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);
+      localIconPathCache.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 = {
+  DevServerScanUnavailableError,
+  __applyManifestForTests,
+  __attachAppSettingsBundleForTests,
+  __isSootSimSelfServerForTests,
+  __resetScannerCache,
+  __shouldReuseScannerCacheEntry,
+  discoverListeningPorts,
+  discoverListeningProcesses,
+  pidFromNetstat,
+  probePort,
+  resolveListeningPid,
+  resolveProcessCwd,
+  scanDevServers,
+  scanListeningProcesses
+});