sootsim 0.1.83 → 0.1.84

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

@@ -0,0 +1,1269 @@
+/*! sootsim v0.1.84 | (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,
+  __resetScannerCache: () => __resetScannerCache,
+  __shouldReuseScannerCacheEntry: () => __shouldReuseScannerCacheEntry,
+  discoverListeningPorts: () => discoverListeningPorts,
+  discoverListeningProcesses: () => discoverListeningProcesses,
+  probePort: () => probePort,
+  resolveProcessCwd: () => resolveProcessCwd,
+  scanDevServers: () => scanDevServers
+});
+module.exports = __toCommonJS(dev_server_scanner_exports);
+var import_child_process = require("child_process");
+var import_http = __toESM(require("http"), 1);
+var import_net = __toESM(require("net"), 1);
+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 hasOwnKeys(config.modules) || hasOwnKeys(config.turboModules) || hasOwnKeys(config.nativeModules) || hasOwnKeys(config.env) || 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://soot.local");
+    parsed.pathname = parsed.pathname.replace(/\.\.bundle$/, ".bundle");
+    if (!isNativeDevBundlePath(parsed.pathname)) return bundleUrl;
+    parsed.searchParams.delete("transform.bytecode");
+    applyPreviewProdBundle(parsed);
+    if (isAbsolute) return parsed.toString();
+    return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+  } catch {
+    return bundleUrl;
+  }
+}
+
+// scripts/demo-app-registry.ts
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var HOME = (0, import_node_os.homedir)();
+function findWorkspaceRoot(startDir) {
+  let dir = startDir;
+  while (true) {
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "pnpm-workspace.yaml")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "turbo.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "nx.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "lerna.json"))) {
+      return dir;
+    }
+    const packageJsonPath = (0, import_node_path.join)(dir, "package.json");
+    if ((0, import_node_fs.existsSync)(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse((0, import_node_fs.readFileSync)(packageJsonPath, "utf8"));
+        if (pkg.workspaces) return dir;
+      } catch {
+      }
+    }
+    const parent = (0, import_node_path.dirname)(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function resolveWorkspaceScriptPath(workspaceRelativePath, packageRelativePath) {
+  const workspaceRoot = findWorkspaceRoot(process.cwd());
+  const candidates = [
+    workspaceRoot ? (0, import_node_path.resolve)(workspaceRoot, workspaceRelativePath) : null,
+    (0, import_node_path.resolve)(process.cwd(), workspaceRelativePath),
+    (0, import_node_path.resolve)(process.cwd(), packageRelativePath)
+  ].filter((candidate) => Boolean(candidate));
+  for (const candidate of candidates) {
+    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
+  }
+  return candidates[0] ?? (0, import_node_path.resolve)(process.cwd(), workspaceRelativePath);
+}
+var getExpensifyProxyScript = () => resolveWorkspaceScriptPath(
+  "packages/sootsim-engine/scripts/expensify-web-proxy.ts",
+  "scripts/expensify-web-proxy.ts"
+);
+var getRainbowMetadataProxyScript = () => resolveWorkspaceScriptPath(
+  "packages/sootsim-engine/scripts/rainbow-metadata-proxy.ts",
+  "scripts/rainbow-metadata-proxy.ts"
+);
+var getMattermostRNUtilsNativeModule = () => resolveWorkspaceScriptPath(
+  "packages/compat/src/stubs/mattermost-rnutils-native.ts",
+  "../compat/src/stubs/mattermost-rnutils-native.ts"
+);
+var getMattermostKeychainNativeModule = () => resolveWorkspaceScriptPath(
+  "packages/compat/src/stubs/native-seams/react-native-keychain-manager.ts",
+  "../compat/src/stubs/native-seams/react-native-keychain-manager.ts"
+);
+var getMattermostNetworkClientNativeModule = () => resolveWorkspaceScriptPath(
+  "packages/compat/src/stubs/mattermost-network-client-native.ts",
+  "../compat/src/stubs/mattermost-network-client-native.ts"
+);
+var getMattermostPreviewServerScript = () => resolveWorkspaceScriptPath(
+  "packages/sootsim-engine/scripts/mattermost-preview-server.ts",
+  "scripts/mattermost-preview-server.ts"
+);
+var EXPENSIFY_NATIVE_PROXY_ENV = {
+  USE_NGROK: "true",
+  NGROK_URL: "http://localhost:9000/",
+  SECURE_NGROK_URL: "http://localhost:9000/"
+};
+var MATTERMOST_DIR = (0, import_node_path.join)(HOME, "github/mattermost-mobile");
+var UNISWAP_REPO_DIR = (0, import_node_path.join)(HOME, "github/uniswap-interface");
+var UNISWAP_APP_DIR = (0, import_node_path.join)(UNISWAP_REPO_DIR, "apps/mobile");
+var UNISWAP_ENV_LOCAL_FILE = (0, import_node_path.join)(UNISWAP_REPO_DIR, ".env.defaults.local");
+var UNISWAP_PLACEHOLDER = "stored-in-.env.local";
+var UNISWAP_DEMO_ENV_MARKER = "# sootsim demo env overrides";
+var UNISWAP_FORCE_UPGRADE_HOOK_FILE = (0, import_node_path.join)(
+  UNISWAP_REPO_DIR,
+  "packages/uniswap/src/features/forceUpgrade/hooks/useForceUpgradeStatus.ts"
+);
+var UNISWAP_FORCE_UPGRADE_NOTIFICATION_FILE = (0, import_node_path.join)(
+  UNISWAP_REPO_DIR,
+  "apps/mobile/src/notification-service/data-sources/createForceUpgradeNotificationDataSource.ts"
+);
+var UNISWAP_FORCE_UPGRADE_PATCH_MARKER = "SOOTSIM_DEMO_DISABLE_FORCE_UPGRADE";
+function parseEnvFile(filePath) {
+  if (!(0, import_node_fs.existsSync)(filePath)) return {};
+  const env = {};
+  const source = (0, import_node_fs.readFileSync)(filePath, "utf8");
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+    if (!match) continue;
+    let value = match[2].trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    env[match[1]] = value;
+  }
+  return env;
+}
+function isUsableUniswapEnvValue(value) {
+  if (!value) return false;
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  if (trimmed.includes(UNISWAP_PLACEHOLDER)) return false;
+  if (trimmed === "TRADING_API_KEY" || trimmed === "UNISWAP_API_KEY") return false;
+  return true;
+}
+function pickEnvValue(sources, keys) {
+  for (const source of sources) {
+    for (const key of keys) {
+      const value = source[key];
+      if (isUsableUniswapEnvValue(value)) return value.trim();
+    }
+  }
+  return void 0;
+}
+function resolveUniswapDemoEnv() {
+  const localEnv = parseEnvFile(UNISWAP_ENV_LOCAL_FILE);
+  const webEnv = parseEnvFile((0, import_node_path.join)(UNISWAP_REPO_DIR, "apps/web/.env"));
+  const sources = [
+    process.env,
+    localEnv,
+    webEnv
+  ];
+  const env = {};
+  const bindings = [
+    ["AMPLITUDE_PROXY_URL_OVERRIDE", ["REACT_APP_AMPLITUDE_PROXY_URL"]],
+    ["QUICKNODE_ENDPOINT_NAME", ["REACT_APP_QUICKNODE_ENDPOINT_NAME"]],
+    ["QUICKNODE_ENDPOINT_TOKEN", ["REACT_APP_QUICKNODE_ENDPOINT_TOKEN"]],
+    ["INFURA_KEY", ["REACT_APP_INFURA_KEY"]],
+    ["STATSIG_API_KEY", ["REACT_APP_STATSIG_API_KEY"]],
+    ["STATSIG_PROXY_URL_OVERRIDE", ["REACT_APP_STATSIG_PROXY_URL"]],
+    ["WALLETCONNECT_PROJECT_ID", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
+    ["WALLETCONNECT_PROJECT_ID_BETA", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
+    ["WALLETCONNECT_PROJECT_ID_DEV", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
+    ["TRADING_API_KEY", ["REACT_APP_TRADING_API_KEY"]],
+    ["UNISWAP_API_KEY", []]
+  ];
+  for (const [target, aliases] of bindings) {
+    const value = pickEnvValue(sources, [target, ...aliases]);
+    if (!value) continue;
+    env[target] = value;
+    for (const alias of aliases) {
+      env[alias] = value;
+    }
+  }
+  const hasPrivateGatewayKeys = isUsableUniswapEnvValue(env.TRADING_API_KEY) && isUsableUniswapEnvValue(env.UNISWAP_API_KEY);
+  if (!hasPrivateGatewayKeys) {
+    const publicGraphqlUrl = pickEnvValue(sources, ["GRAPHQL_URL_OVERRIDE", "REACT_APP_AWS_API_ENDPOINT"]) || "https://interface.gateway.uniswap.org/v1/graphql";
+    env.API_BASE_URL_OVERRIDE = "https://interface.gateway.uniswap.org";
+    env.API_BASE_URL_V2_OVERRIDE = "https://interface.gateway.uniswap.org/v2";
+    env.GRAPHQL_URL_OVERRIDE = publicGraphqlUrl;
+    env.TRADING_API_URL_OVERRIDE = "https://trading-api-labs.interface.gateway.uniswap.org";
+    env.FOR_API_URL_OVERRIDE = "https://for.interface.gateway.uniswap.org/v2/FOR.v1.FORService";
+  }
+  return env;
+}
+function ensureUniswapDemoEnvLocal() {
+  const existingSource = (0, import_node_fs.existsSync)(UNISWAP_ENV_LOCAL_FILE) ? (0, import_node_fs.readFileSync)(UNISWAP_ENV_LOCAL_FILE, "utf8") : "";
+  if (existingSource && !existingSource.includes(UNISWAP_DEMO_ENV_MARKER)) {
+    return;
+  }
+  const env = resolveUniswapDemoEnv();
+  const lines = [UNISWAP_DEMO_ENV_MARKER];
+  for (const [key, value] of Object.entries(env).sort(([a], [b]) => a.localeCompare(b))) {
+    lines.push(`${key}=${JSON.stringify(value)}`);
+  }
+  lines.push("");
+  (0, import_node_fs.writeFileSync)(UNISWAP_ENV_LOCAL_FILE, `${lines.join("\n")}
+`);
+}
+function ensureUniswapForceUpgradePatched() {
+  const hookNeedle = `export function useForceUpgradeStatus(): ForceUpgradeStatus {
+`;
+  const hookPatch = `  // sootsim demo: bypass the force-upgrade gate during local engine demos.
+  return 'not-required'
+
+`;
+  const hookLegacyPatch = `  // sootsim demo: bypass the force-upgrade gate during local engine demos.
+  if (process.env.${UNISWAP_FORCE_UPGRADE_PATCH_MARKER} === 'true') {
+    return 'not-required'
+  }
+
+`;
+  const notificationNeedle = `  const getForceUpgradeStatus = (): ForceUpgradeStatus => {
+`;
+  const notificationPatch = `    // sootsim demo: bypass the force-upgrade gate during local engine demos.
+    return 'not-required'
+
+`;
+  const notificationLegacyPatch = `    // sootsim demo: bypass the force-upgrade gate during local engine demos.
+    if (process.env.${UNISWAP_FORCE_UPGRADE_PATCH_MARKER} === 'true') {
+      return 'not-required'
+    }
+
+`;
+  const patchWithMigration = (filePath, needle, patch, legacyPatch) => {
+    const source = (0, import_node_fs.readFileSync)(filePath, "utf8");
+    if (source.includes(patch)) return;
+    if (source.includes(legacyPatch)) {
+      (0, import_node_fs.writeFileSync)(filePath, source.replace(legacyPatch, patch));
+      return;
+    }
+    if (!source.includes(needle)) {
+      throw new Error(
+        `uniswap demo patch failed: expected snippet not found in ${filePath}`
+      );
+    }
+    (0, import_node_fs.writeFileSync)(filePath, source.replace(needle, `${needle}${patch}`));
+  };
+  patchWithMigration(
+    UNISWAP_FORCE_UPGRADE_HOOK_FILE,
+    hookNeedle,
+    hookPatch,
+    hookLegacyPatch
+  );
+  patchWithMigration(
+    UNISWAP_FORCE_UPGRADE_NOTIFICATION_FILE,
+    notificationNeedle,
+    notificationPatch,
+    notificationLegacyPatch
+  );
+}
+var JOPLIN_DIR = (0, import_node_path.join)(HOME, "github/joplin");
+var JOPLIN_APP_DIR = (0, import_node_path.join)(JOPLIN_DIR, "packages/app-mobile");
+var JOPLIN_WATCH_ROOTS = [
+  "packages/lib",
+  "packages/renderer",
+  "packages/turndown",
+  "packages/turndown-plugin-gfm",
+  "packages/editor",
+  "packages/tools",
+  "packages/utils",
+  "packages/fork-htmlparser2",
+  "packages/fork-uslug",
+  "packages/fork-sax",
+  "packages/htmlpack",
+  "packages/react-native-saf-x",
+  "packages/react-native-alarm-notification"
+];
+function ensureJoplinWatchmanConfigs() {
+  if (!(0, import_node_fs.existsSync)(JOPLIN_DIR)) return;
+  for (const rel of JOPLIN_WATCH_ROOTS) {
+    const dir = (0, import_node_path.join)(JOPLIN_DIR, rel);
+    if (!(0, import_node_fs.existsSync)(dir)) continue;
+    const cfg = (0, import_node_path.join)(dir, ".watchmanconfig");
+    if (!(0, import_node_fs.existsSync)(cfg)) (0, import_node_fs.writeFileSync)(cfg, "{}\n");
+  }
+}
+var JOPLIN_BUILD_SENTINELS = [
+  "packages/lib/models/Setting.js",
+  "packages/turndown/lib/turndown.cjs.js",
+  "packages/app-mobile/pluginAssets/index.js"
+];
+function ensureJoplinBuilt() {
+  if (!(0, import_node_fs.existsSync)(JOPLIN_DIR)) return;
+  const missing = JOPLIN_BUILD_SENTINELS.filter(
+    (rel) => !(0, import_node_fs.existsSync)((0, import_node_path.join)(JOPLIN_DIR, rel))
+  );
+  if (missing.length === 0) return;
+  const { execSync } = require("node:child_process");
+  execSync("yarn buildParallel", {
+    cwd: JOPLIN_DIR,
+    stdio: "inherit",
+    env: { ...process.env, NO_FLIPPER: "1", CI: "" }
+  });
+  const stillMissing = JOPLIN_BUILD_SENTINELS.filter(
+    (rel) => !(0, import_node_fs.existsSync)((0, import_node_path.join)(JOPLIN_DIR, rel))
+  );
+  if (stillMissing.length > 0) {
+    throw new Error(
+      `joplin demo: yarn buildParallel did not produce: ${stillMissing.join(", ")}`
+    );
+  }
+}
+var RAINBOW_DIR = (0, import_node_path.join)(HOME, "github/rainbow");
+var RAINBOW_GRAPHQL_DIR = (0, import_node_path.join)(RAINBOW_DIR, "src/graphql");
+var RAINBOW_GRAPHQL_CONFIG_FILE = (0, import_node_path.join)(RAINBOW_GRAPHQL_DIR, "config.js");
+var RAINBOW_NETWORKS_FILE = (0, import_node_path.join)(RAINBOW_DIR, "src/references/networks.json");
+var RAINBOW_METADATA_BASE_URL = "https://metadata.p.rainbow.me";
+var RAINBOW_METADATA_PROXY_PORT = 9011;
+var RAINBOW_DEMO_METADATA_BASE_URL = `http://127.0.0.1:${RAINBOW_METADATA_PROXY_PORT}`;
+var RAINBOW_PUBLIC_ENS_GRAPHQL_URL = "https://api.thegraph.com/subgraphs/name/ensdomains/ens";
+var RAINBOW_DEMO_QUOTE_SIGNER = "0x0000000000000000000000000000000000000000";
+var RAINBOW_DEMO_RELAY_URL = "https://relay.rainbow.me";
+var RAINBOW_DEMO_MASTER_KEY = "sootsim-rainbow-demo-master-key-do-not-use-for-real-wallets";
+var RAINBOW_DEMO_RPC_PROXY_BASE_URL = "https://rpc.rainbow.me/v1";
+var RAINBOW_DEMO_RPC_API_KEY = "";
+var RAINBOW_DEMO_PUBLIC_RPC_URLS = {
+  "1": "https://ethereum-rpc.publicnode.com"
+};
+var RAINBOW_DEMO_SERVICE_API_KEY = "sootsim-rainbow-demo-api-key";
+var RAINBOW_DEMO_SECURE_WALLET_HASH_KEY = "0x736f6f7473696d2d7261696e626f772d64656d6f2d686173682d6b6579000000";
+var RAINBOW_GRAPHQL_SENTINELS = [
+  "src/graphql/__generated__/ens.ts",
+  "src/graphql/__generated__/metadata.ts",
+  "src/graphql/__generated__/metadataPOST.ts"
+];
+function runRainbowSetupCommand(command, cwd) {
+  const { execSync } = require("node:child_process");
+  execSync(command, {
+    cwd,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      METADATA_BASE_URL: RAINBOW_METADATA_BASE_URL,
+      RAINBOW_RELAY_QUOTE_SIGNER: process.env.RAINBOW_RELAY_QUOTE_SIGNER ?? RAINBOW_DEMO_QUOTE_SIGNER
+    }
+  });
+}
+function ensureRainbowGraphqlConfig() {
+  if (!(0, import_node_fs.existsSync)(RAINBOW_GRAPHQL_DIR)) return;
+  const source = (0, import_node_fs.existsSync)(RAINBOW_GRAPHQL_CONFIG_FILE) ? (0, import_node_fs.readFileSync)(RAINBOW_GRAPHQL_CONFIG_FILE, "utf8") : "";
+  if (source.includes(RAINBOW_PUBLIC_ENS_GRAPHQL_URL) && source.includes(RAINBOW_METADATA_BASE_URL)) {
+    return;
+  }
+  (0, import_node_fs.writeFileSync)(
+    RAINBOW_GRAPHQL_CONFIG_FILE,
+    `exports.config = {
+  ens: {
+    __name: 'ens',
+    document: './queries/ens.graphql',
+    schema: {
+      method: 'POST',
+      url: '${RAINBOW_PUBLIC_ENS_GRAPHQL_URL}',
+    },
+  },
+  metadata: {
+    __name: 'metadata',
+    document: './queries/metadata.graphql',
+    schema: { method: 'GET', url: '${RAINBOW_METADATA_BASE_URL}/v1/graph' },
+  },
+  metadataPOST: {
+    __name: 'metadataPOST',
+    document: './queries/metadata.graphql',
+    schema: { method: 'POST', url: '${RAINBOW_METADATA_BASE_URL}/v1/graph' },
+  },
+  arc: {
+    __name: 'arc',
+    document: './queries/arc.graphql',
+    schema: {
+      method: 'GET',
+      url: 'https://arc-graphql.rainbow.me/graphql',
+      headers: {
+        'x-api-key': 'ARC_GRAPHQL_API_KEY',
+      },
+    },
+  },
+  arcDev: {
+    __name: 'arcDev',
+    document: './queries/arc.graphql',
+    schema: {
+      method: 'GET',
+      url: 'https://arc-graphql.rainbowdotme.workers.dev/graphql',
+      headers: {},
+    },
+  },
+};
+`
+  );
+}
+function resolveRainbowDemoEnv() {
+  const env = {
+    ENABLE_DEV_MODE: "1",
+    IS_TESTING: "false",
+    METADATA_BASE_URL: process.env.RAINBOW_METADATA_BASE_URL ?? RAINBOW_DEMO_METADATA_BASE_URL,
+    ADDYS_API_KEY: process.env.ADDYS_API_KEY ?? RAINBOW_DEMO_SERVICE_API_KEY,
+    ADDYS_BASE_URL: process.env.ADDYS_BASE_URL ?? RAINBOW_DEMO_METADATA_BASE_URL,
+    PLATFORM_API_KEY: process.env.PLATFORM_API_KEY ?? RAINBOW_DEMO_SERVICE_API_KEY,
+    PLATFORM_BASE_URL: process.env.PLATFORM_BASE_URL ?? RAINBOW_DEMO_METADATA_BASE_URL,
+    RAINBOW_MASTER_KEY: process.env.RAINBOW_MASTER_KEY ?? RAINBOW_DEMO_MASTER_KEY,
+    RAINBOW_RELAY_QUOTE_SIGNER: process.env.RAINBOW_RELAY_QUOTE_SIGNER ?? RAINBOW_DEMO_QUOTE_SIGNER,
+    RAINBOW_RELAY_URL: process.env.RAINBOW_RELAY_URL ?? RAINBOW_DEMO_RELAY_URL,
+    RPC_PROXY_API_KEY_PROD: RAINBOW_DEMO_RPC_API_KEY,
+    RPC_PROXY_BASE_URL_PROD: process.env.RAINBOW_RPC_PROXY_BASE_URL ?? process.env.RPC_PROXY_BASE_URL_PROD ?? RAINBOW_DEMO_RPC_PROXY_BASE_URL,
+    SECURE_WALLET_HASH_KEY: process.env.SECURE_WALLET_HASH_KEY ?? RAINBOW_DEMO_SECURE_WALLET_HASH_KEY
+  };
+  const optionalEnvVars = [
+    "ADDYS_API_KEY",
+    "ADDYS_BASE_URL",
+    "IMGIX_DOMAIN",
+    "IMGIX_TOKEN",
+    "PLATFORM_API_KEY",
+    "PLATFORM_BASE_URL",
+    "RAINBOW_TEST_WALLET",
+    "RAINBOW_RELAY_API_KEY",
+    "RAINBOW_RELAY_URL",
+    "SECURE_WALLET_HASH_KEY",
+    "TOKEN_SEARCH_URL",
+    "WC_PROJECT_ID"
+  ];
+  for (const key of optionalEnvVars) {
+    const value = process.env[key];
+    if (value) env[key] = value;
+  }
+  if (!env.WC_PROJECT_ID && process.env.RAINBOW_WALLETCONNECT_PROJECT_ID) {
+    env.WC_PROJECT_ID = process.env.RAINBOW_WALLETCONNECT_PROJECT_ID;
+  }
+  return env;
+}
+function ensureRainbowDemoNetworks() {
+  if (!(0, import_node_fs.existsSync)(RAINBOW_NETWORKS_FILE)) return;
+  const payload = JSON.parse((0, import_node_fs.readFileSync)(RAINBOW_NETWORKS_FILE, "utf8"));
+  if (!Array.isArray(payload.networks)) return;
+  let changed = false;
+  for (const network of payload.networks) {
+    const url = network.id ? RAINBOW_DEMO_PUBLIC_RPC_URLS[network.id] : void 0;
+    if (!url || !network.defaultRPC) continue;
+    if (network.defaultRPC.url === url) continue;
+    network.defaultRPC.url = url;
+    changed = true;
+  }
+  if (changed) {
+    (0, import_node_fs.writeFileSync)(RAINBOW_NETWORKS_FILE, `${JSON.stringify(payload)}
+`);
+  }
+}
+function ensureRainbowSetup() {
+  if (!(0, import_node_fs.existsSync)(RAINBOW_DIR)) return;
+  ensureRainbowGraphqlConfig();
+  if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(RAINBOW_GRAPHQL_DIR, "node_modules/.bin/graphql-codegen"))) {
+    runRainbowSetupCommand("fnm exec --using=22 yarn install", RAINBOW_GRAPHQL_DIR);
+  }
+  const missingGraphql = RAINBOW_GRAPHQL_SENTINELS.some(
+    (rel) => !(0, import_node_fs.existsSync)((0, import_node_path.join)(RAINBOW_DIR, rel))
+  );
+  if (missingGraphql) {
+    runRainbowSetupCommand("fnm exec --using=22 yarn codegen", RAINBOW_GRAPHQL_DIR);
+  }
+  if (!(0, import_node_fs.existsSync)(RAINBOW_NETWORKS_FILE)) {
+    runRainbowSetupCommand("fnm exec --using=22 yarn fetch:networks", RAINBOW_DIR);
+  }
+  ensureRainbowDemoNetworks();
+}
+var ARTSY_DIR = (0, import_node_path.join)(HOME, "github/eigen");
+var ARTSY_KEYS_FILE = (0, import_node_path.join)(ARTSY_DIR, "keys.shared.json");
+var ARTSY_METAFLAGS_FILE = (0, import_node_path.join)(ARTSY_DIR, "metaflags.json");
+var ARTSY_RELAY_SENTINEL = (0, import_node_path.join)(ARTSY_DIR, "src/__generated__/.relay-complete");
+function readArtsyKeysPayload() {
+  if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE)) return void 0;
+  try {
+    const parsed = JSON.parse((0, import_node_fs.readFileSync)(ARTSY_KEYS_FILE, "utf8"));
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const secure = parsed.secure && typeof parsed.secure === "object" ? parsed.secure : void 0;
+    const publicKeys = parsed.public && typeof parsed.public === "object" ? parsed.public : void 0;
+    if (!secure && !publicKeys) return void 0;
+    return { secure, public: publicKeys };
+  } catch {
+    return void 0;
+  }
+}
+function resolveArtsyRuntimeConfig() {
+  const email = process.env.SOOTSIM_ARTSY_EMAIL ?? process.env.MAESTRO_TEST_EMAIL;
+  const password = process.env.SOOTSIM_ARTSY_PASSWORD ?? process.env.MAESTRO_TEST_PASSWORD;
+  const keys = readArtsyKeysPayload();
+  const env = {};
+  if (email && password) {
+    env.SOOTSIM_LAUNCH_ARGUMENTS = JSON.stringify({
+      email,
+      password,
+      useMaestroInit: true
+    });
+  }
+  if (keys) {
+    env.SOOTSIM_REACT_NATIVE_KEYS_JSON = JSON.stringify(keys);
+  }
+  if (Object.keys(env).length === 0) return void 0;
+  return {
+    env
+  };
+}
+function ensureArtsySetup() {
+  if (!(0, import_node_fs.existsSync)(ARTSY_DIR)) return;
+  const { execSync } = require("node:child_process");
+  const yarnRelease = (0, import_node_path.join)(ARTSY_DIR, ".yarn/releases/yarn-4.10.3.cjs");
+  if ((0, import_node_fs.existsSync)(yarnRelease)) {
+    const src = (0, import_node_fs.readFileSync)(yarnRelease, "utf8");
+    const needle = '["clone","-c core.autocrlf=false",';
+    if (src.includes(needle)) {
+      (0, import_node_fs.writeFileSync)(
+        yarnRelease,
+        src.replace(needle, '["clone","-c","core.autocrlf=false",')
+      );
+    }
+  }
+  if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(ARTSY_DIR, "node_modules/.yarn-state.yml"))) {
+    execSync("yarn install", {
+      cwd: ARTSY_DIR,
+      stdio: "inherit",
+      env: { ...process.env, YARN_CHECKSUM_BEHAVIOR: "update" }
+    });
+  }
+  if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE) || !(0, import_node_fs.existsSync)(ARTSY_METAFLAGS_FILE)) {
+    try {
+      execSync("yarn setup:oss", { cwd: ARTSY_DIR, stdio: "inherit" });
+    } catch {
+      if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE) || !(0, import_node_fs.existsSync)(ARTSY_METAFLAGS_FILE)) {
+        throw new Error("artsy demo: setup:oss did not create keys/metaflags");
+      }
+    }
+  }
+  const rnlaPkgJson = (0, import_node_path.join)(
+    ARTSY_DIR,
+    "node_modules/react-native-launch-arguments/package.json"
+  );
+  if ((0, import_node_fs.existsSync)(rnlaPkgJson)) {
+    const raw = (0, import_node_fs.readFileSync)(rnlaPkgJson, "utf8");
+    if (raw.includes('"dist/index.js"')) {
+      (0, import_node_fs.writeFileSync)(rnlaPkgJson, raw.replace('"dist/index.js"', '"src/index.ts"'));
+    }
+  }
+  if (!(0, import_node_fs.existsSync)(ARTSY_RELAY_SENTINEL)) {
+    execSync("yarn relay", { cwd: ARTSY_DIR, stdio: "inherit" });
+    (0, import_node_fs.writeFileSync)(ARTSY_RELAY_SENTINEL, "");
+  }
+}
+var APPS = [
+  {
+    name: "bluesky",
+    label: "Bluesky",
+    dir: (0, import_node_path.join)(HOME, "github/bluesky"),
+    preferredPort: 8082,
+    framework: "expo",
+    command: (p) => ({ cmd: `npx expo start --port ${p}` }),
+    credentials: {
+      envVars: ["SOOTSIM_BLUESKY_PASSWORD"],
+      known: { HANDLE: "natew.bsky.social" }
+    }
+  },
+  {
+    name: "3pc",
+    label: "3PunchConvo",
+    dir: (0, import_node_path.join)(HOME, "lightstrike-labs/three-punch-convo-app/apps/one"),
+    preferredPort: 8081,
+    framework: "one",
+    command: (p) => ({ cmd: "npx one dev", env: { ONE_PORT: String(p) } })
+  },
+  {
+    name: "uniswap",
+    label: "Uniswap",
+    dir: UNISWAP_APP_DIR,
+    preferredPort: 8085,
+    framework: "expo",
+    prepare: () => {
+      ensureUniswapDemoEnvLocal();
+      ensureUniswapForceUpgradePatched();
+    },
+    command: (p) => ({
+      cmd: `npx expo start --clear --port ${p}`,
+      // prefer the real local mobile env when present, otherwise fall back
+      // to Uniswap's checked-in public web RPC settings so demo boots cleanly.
+      env: resolveUniswapDemoEnv()
+    })
+  },
+  {
+    name: "takeout",
+    label: "Takeout",
+    dir: (0, import_node_path.join)(HOME, "takeout"),
+    preferredPort: 8086,
+    framework: "one",
+    // takeout needs more than Metro for the demo to actually work: better-auth
+    // (login), zero-cache (sync), and a postgres for both. `bun lite` brings
+    // up the orez-backed stack (PG + zero + s3 in one binary) plus the One
+    // dev server. takeout's env system shifts every port (web, pg, zero,
+    // minio) uniformly by PORT_OFFSET, so we derive offset = port - 8081
+    // (the base web port) to keep all backend ports clear of the default
+    // dev stack while pinning One to the demo slot. OREZ_DATA_DIR is isolated
+    // to a per-demo path so we don't fight a soot dev orez that may already
+    // be holding pglite locks on ~/takeout/.orez (soot can attach takeout as
+    // a project and spin up its own orez against the same data dir).
+    readyTimeoutMs: 24e4,
+    command: (p) => ({
+      cmd: "bun lite",
+      env: {
+        PORT_OFFSET: String(p - 8081),
+        OREZ_DATA_DIR: `${HOME}/.cache/sootsim-demo/takeout-orez`
+      }
+    })
+  },
+  {
+    name: "expensify",
+    label: "Expensify",
+    dir: (0, import_node_path.join)(HOME, "github/expensify"),
+    preferredPort: 8087,
+    framework: "rock",
+    runtimeConfig: {
+      env: EXPENSIFY_NATIVE_PROXY_ENV
+    },
+    sidecars: [
+      {
+        name: "web-proxy",
+        port: 9e3,
+        readyPath: "/api/Ping",
+        command: () => ({
+          cmd: `bun ${JSON.stringify(getExpensifyProxyScript())}`,
+          env: EXPENSIFY_NATIVE_PROXY_ENV
+        })
+      }
+    ],
+    command: (p) => ({
+      cmd: `fnm exec --using=20.20.0 npx rock start --port ${p} --no-interactive`,
+      env: EXPENSIFY_NATIVE_PROXY_ENV
+    })
+  },
+  {
+    name: "artsy",
+    label: "Artsy",
+    dir: ARTSY_DIR,
+    preferredPort: 8088,
+    framework: "expo",
+    runtimeConfig: resolveArtsyRuntimeConfig(),
+    prepare: () => {
+      ensureArtsySetup();
+    },
+    command: (p) => ({
+      // eigen's `yarn start` wraps `react-native start` with a relay watcher
+      // via concurrently; for the demo we run relay once in prepare and
+      // invoke the metro server directly so --port is respected.
+      cmd: `npx react-native start --port ${p}`
+    }),
+    credentials: {
+      envVars: ["SOOTSIM_ARTSY_EMAIL", "SOOTSIM_ARTSY_PASSWORD"],
+      note: "auto-login reuses Artsy\u2019s built-in Maestro launch-arguments hook"
+    }
+  },
+  {
+    name: "rainbow",
+    label: "Rainbow",
+    dir: RAINBOW_DIR,
+    preferredPort: 8089,
+    framework: "rock",
+    sidecars: [
+      {
+        name: "metadata-proxy",
+        port: RAINBOW_METADATA_PROXY_PORT,
+        readyPath: "/health",
+        command: () => ({
+          cmd: `bun ${JSON.stringify(getRainbowMetadataProxyScript())}`,
+          env: {
+            PORT: String(RAINBOW_METADATA_PROXY_PORT),
+            RAINBOW_PUBLIC_RPC_URLS: JSON.stringify(RAINBOW_DEMO_PUBLIC_RPC_URLS),
+            RAINBOW_UPSTREAM_METADATA_BASE_URL: RAINBOW_METADATA_BASE_URL
+          }
+        })
+      }
+    ],
+    prepare: () => {
+      ensureRainbowSetup();
+    },
+    command: (p) => ({
+      cmd: `fnm exec --using=22 yarn start --port ${p} --reset-cache`,
+      env: resolveRainbowDemoEnv()
+    }),
+    credentials: {
+      envVars: [
+        "RAINBOW_TEST_WALLET",
+        "RAINBOW_WALLETCONNECT_PROJECT_ID",
+        "WC_PROJECT_ID",
+        "IMGIX_DOMAIN",
+        "IMGIX_TOKEN"
+      ],
+      note: "launcher supplies a demo encryption key and public mainnet RPC; use only a public throwaway mnemonic for RAINBOW_TEST_WALLET"
+    }
+  },
+  {
+    name: "rocket-chat",
+    label: "Rocket.Chat",
+    dir: (0, import_node_path.join)(HOME, "github/Rocket.Chat.ReactNative"),
+    preferredPort: 8093,
+    framework: "expo",
+    command: (p) => ({
+      cmd: `npx react-native start --port ${p}`,
+      env: { RUNNING_E2E_TESTS: "true" }
+    }),
+    credentials: {
+      envVars: [
+        "ROCKET_CHAT_DEMO_SERVER",
+        "ROCKET_CHAT_DEMO_USERNAME",
+        "ROCKET_CHAT_DEMO_PASSWORD"
+      ],
+      known: { SERVER: "https://mobile.qa.rocket.chat" },
+      note: "use packages/sootsim-engine/scripts/rocket-chat-demo-auth.ts to create/login a disposable QA user and print the rocketchat://auth deep link"
+    }
+  },
+  {
+    name: "mattermost",
+    label: "Mattermost",
+    dir: MATTERMOST_DIR,
+    preferredPort: 8090,
+    framework: "expo",
+    sidecars: [
+      {
+        name: "preview-server",
+        port: 8065,
+        readyPath: "/api/v4/system/ping",
+        command: () => ({
+          cmd: `bun ${JSON.stringify(getMattermostPreviewServerScript())}`
+        })
+      }
+    ],
+    runtimeConfig: {
+      modules: {
+        // mattermost patches react-native-keychain's JS entry in its own
+        // repo; run that package and provide only the native manager seam.
+        "react-native-keychain": false,
+        "dist/assets/config.json": {
+          inline: {
+            AuthUrlScheme: "mmauth://",
+            AuthUrlSchemeDev: "mmauthbeta://",
+            DefaultServerUrl: "http://localhost:8065",
+            DefaultServerName: "Mattermost Demo",
+            TestServerUrl: "http://localhost:8065",
+            AutoSelectServerUrl: true,
+            WebsiteURL: "https://mattermost.com",
+            ServerNoticeURL: "https://github.com/mattermost/mattermost-server/blob/master/NOTICE.txt",
+            MobileNoticeURL: "https://github.com/mattermost/mattermost-mobile/blob/master/NOTICE.txt",
+            RudderApiKey: "",
+            SentryEnabled: false,
+            SentryDsnIos: "",
+            SentryDsnAndroid: "",
+            SentryOptions: {
+              deactivateStacktraceMerging: true,
+              autoBreadcrumbs: {
+                xhr: false,
+                console: true
+              },
+              severityLevelFilter: ["fatal"]
+            },
+            ShowReview: false,
+            ShowOnboarding: false,
+            ExperimentalNormalizeMarkdownLinks: false,
+            CustomRequestHeaders: {},
+            CollectNetworkMetrics: false
+          }
+        }
+      },
+      nativeModules: {
+        RNKeychainManager: { file: getMattermostKeychainNativeModule() },
+        RNUtils: { file: getMattermostRNUtilsNativeModule() },
+        GenericClient: { file: getMattermostNetworkClientNativeModule() },
+        ApiClient: { file: getMattermostNetworkClientNativeModule() },
+        WebSocketClient: { file: getMattermostNetworkClientNativeModule() }
+      }
+    },
+    command: (p) => ({
+      cmd: `npx react-native start --host 127.0.0.1 --port ${p}`
+    }),
+    credentials: {
+      known: {
+        SERVER: "http://localhost:8065",
+        USERNAME: "demo",
+        PASSWORD: "DemoPassword1!"
+      },
+      note: "local mattermost-preview seeded through the real REST API; no signup or OTP needed"
+    }
+  },
+  {
+    name: "joplin",
+    label: "Joplin",
+    dir: JOPLIN_APP_DIR,
+    preferredPort: 8084,
+    framework: "expo",
+    // joplin is local-first: sync.target defaults to 0 ("None") and the
+    // mobile startup runs WelcomeUtils.install() on first launch, which
+    // seeds a "Welcome!" folder + welcome notes. no login or external
+    // credentials are needed for a usable demo — just boot it. tenant
+    // bedrock SQLite (via react-native-sqlite-storage stub) carries the
+    // seeded notes across reloads.
+    prepare: () => {
+      ensureJoplinWatchmanConfigs();
+      ensureJoplinBuilt();
+    },
+    command: (p) => ({
+      cmd: `npx expo start --port ${p}`,
+      env: { BROWSERSLIST_IGNORE_OLD_DATA: "true" }
+    }),
+    credentials: {
+      note: "no login required \u2014 sync.target=0 (None), seed via WelcomeUtils"
+    }
+  }
+];
+
+// 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);
+}
+var cwdByPid = /* @__PURE__ */ new Map();
+async function resolveProcessCwd(pid) {
+  if (pid <= 0) return null;
+  const cached = cwdByPid.get(pid);
+  if (cached) return cached;
+  try {
+    const { stdout } = await execP(`lsof -p ${pid} -a -d cwd -Fn 2>/dev/null`, {
+      encoding: "utf8",
+      timeout: 1500
+    });
+    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) {
+  return {
+    port,
+    framework,
+    bundleUrl: withRuntimeConfig(
+      port,
+      `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`
+    ),
+    hmrUrl: `ws://localhost:${port}/hot`,
+    lastSeen: Date.now()
+  };
+}
+function withRuntimeConfig(port, bundleUrl) {
+  const knownApp = APPS.find((app) => app.preferredPort === port);
+  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);
+    }
+    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 knownNonPatched = /* @__PURE__ */ new Set();
+var knownNonExpo = /* @__PURE__ */ new Set();
+var knownOne = /* @__PURE__ */ new Set();
+async function probePort(port, buildIconProxyUrl) {
+  if (!await tcpPing(port)) return null;
+  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),
+        hmrUrl: `ws://localhost:${port}/hot`,
+        lastSeen: Date.now()
+      },
+      manifestRes,
+      buildIconProxyUrl
+    );
+  }
+  if (statusRes && statusRes.body.includes("packager-status:running")) {
+    knownNonPatched.add(port);
+    return applyManifest(
+      makeResult(port, expoRes && expoRes.statusCode === 200 ? "expo" : "metro"),
+      manifestRes,
+      buildIconProxyUrl
+    );
+  }
+  if (sootsimRes && sootsimRes.statusCode === 200 && sootsimRes.body.includes("sootsim-patched")) {
+    knownNonPatched.delete(port);
+    return applyManifest(
+      {
+        port,
+        framework: "one",
+        bundleUrl: withRuntimeConfig(port, `http://localhost:${port}/__soot/bundle.js`),
+        hmrUrl: `ws://localhost:${port}/hot`,
+        lastSeen: Date.now(),
+        patched: true
+      },
+      manifestRes,
+      buildIconProxyUrl
+    );
+  }
+  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 applyManifest(
+      {
+        port,
+        framework: "one",
+        bundleUrl: withRuntimeConfig(
+          port,
+          `http://localhost:${port}${onePath}&minify=false`
+        ),
+        hmrUrl: `ws://localhost:${port}/hot`,
+        lastSeen: Date.now()
+      },
+      manifestRes,
+      buildIconProxyUrl
+    );
+  }
+  knownNonPatched.add(port);
+  return null;
+}
+function isSootSelfServer(server) {
+  const projectName = server.projectName?.trim().toLowerCase();
+  if (projectName === "soot" || projectName === "sootsim") return true;
+  const bundleId = server.bundleId?.trim().toLowerCase();
+  if (bundleId?.startsWith("dev.soot")) return true;
+  return false;
+}
+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.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();
+}
+async function scanDevServers(opts = {}) {
+  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);
+  }
+  const results = [];
+  const toProbe = [];
+  for (const { port, pid } of processes) {
+    const cached = portCache.get(port);
+    if (cached && __shouldReuseScannerCacheEntry(cached, pid)) {
+      if (cached.result) results.push(cached.result);
+      continue;
+    }
+    if (cached && cached.pid !== pid) {
+      knownNonPatched.delete(port);
+      knownNonExpo.delete(port);
+      knownOne.delete(port);
+    }
+    toProbe.push({ port, pid });
+  }
+  if (toProbe.length > 0) {
+    const probed = await Promise.all(
+      toProbe.map((p) => probePort(p.port, opts.buildIconProxyUrl))
+    );
+    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) result.cwd = cwd;
+    })
+  );
+  const livePids = new Set(pidByPort.values());
+  for (const pid of [...cwdByPid.keys()]) {
+    if (!livePids.has(pid)) cwdByPid.delete(pid);
+  }
+  return results.filter((r) => !isSootSelfServer(r));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __applyManifestForTests,
+  __resetScannerCache,
+  __shouldReuseScannerCacheEntry,
+  discoverListeningPorts,
+  discoverListeningProcesses,
+  probePort,
+  resolveProcessCwd,
+  scanDevServers
+});