peachsim 0.1.527

package/dist-lib/detox/jest-preset.cjs

@@ -0,0 +1,29 @@
+// jest preset for running existing detox suites against sootsim.
+//
+// users drop `preset: 'rnxsim/detox'` into their jest config
+// (or `rnx-detox.config.cjs`) and their `import { by, device, element,
+// expect, waitFor } from 'detox'` calls resolve to the sootsim driver.
+
+const path = require('path')
+
+// resolve the published driver entry so the mapping works from any cwd.
+// `require.resolve('sootsim/detox')` honours the subpath export in the
+// sootsim package.json.
+const DRIVER_ENTRY = require.resolve('rnxsim/detox')
+const PACKAGE_ROOT = path.dirname(require.resolve('rnxsim/package.json'))
+
+/** @type {import('@jest/types').Config.InitialOptions} */
+module.exports = {
+  testTimeout: 180000,
+  maxWorkers: 1,
+  watchman: false,
+  verbose: true,
+  testEnvironment: 'node',
+  setupFilesAfterEnv: [path.join(PACKAGE_ROOT, 'detox', 'jest-setup-after-env.cjs')],
+  transform: {
+    '^.+\\.[jt]sx?$': ['@sucrase/jest-plugin', { jsxRuntime: 'automatic' }],
+  },
+  moduleNameMapper: {
+    '^detox$': DRIVER_ENTRY,
+  },
+}

package/dist-lib/dev-bundle-resolution.cjs

@@ -0,0 +1,290 @@
+/*! 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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dev-bundle-resolution.ts
+var dev_bundle_resolution_exports = {};
+__export(dev_bundle_resolution_exports, {
+  DEFAULT_TEST_DRIVE_PORT: () => DEFAULT_TEST_DRIVE_PORT,
+  inferManifestFramework: () => inferManifestFramework,
+  probePortBundle: () => probePortBundle,
+  resolveConnectionInput: () => resolveConnectionInput
+});
+module.exports = __toCommonJS(dev_bundle_resolution_exports);
+
+// 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/native-dev-bundle-url.ts
+var METRO_BUNDLE_PATH = "/index.bundle?platform=ios&dev=true&hot=true&minify=false";
+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/dev-bundle-resolution.ts
+var DEFAULT_TEST_DRIVE_PORT = 8081;
+function buildUnresolvedTargetError(targetLabel) {
+  return new Error(
+    `could not resolve a native bundle for ${targetLabel}. pass an explicit bundle URL or open Connect and choose the app there.`
+  );
+}
+function inferManifestFramework(launchUrl, sdkVersion) {
+  if (launchUrl?.includes("/one/metro-entry.bundle")) return "one";
+  if (typeof sdkVersion === "string" && sdkVersion) return "expo";
+  return "unknown";
+}
+function buildBaseUrl(protocol, host, port) {
+  return `${protocol}//${host}:${port}`;
+}
+function shouldProxyLoopbackProbe(targetUrl) {
+  if (typeof window === "undefined") return false;
+  try {
+    const parsed = new URL(targetUrl);
+    return isLoopbackHost(parsed.hostname) && isLoopbackHost(window.location.hostname) && parsed.origin !== window.location.origin;
+  } catch {
+    return false;
+  }
+}
+async function fetchDevProbe(targetUrl, init) {
+  const requestInit = {
+    ...init,
+    cache: init?.cache ?? "no-store"
+  };
+  if (!shouldProxyLoopbackProbe(targetUrl)) {
+    return fetch(targetUrl, requestInit);
+  }
+  return fetch(`/__fetch-proxy?url=${encodeURIComponent(targetUrl)}`, requestInit);
+}
+function getDefaultPortForProtocol(protocol) {
+  return protocol === "https:" ? 443 : 80;
+}
+function isBaseServerUrl(url) {
+  const path = url.pathname || "/";
+  return (path === "/" || path === "") && !url.search && !url.hash;
+}
+async function resolvePortViaServerScan(port) {
+  try {
+    const res = await fetch("/__server-scan", { cache: "no-store" });
+    if (!res.ok) return null;
+    if (!(res.headers.get("content-type") || "").toLowerCase().includes("json"))
+      return null;
+    const servers = await res.json();
+    if (!Array.isArray(servers)) return null;
+    const match = servers.find(
+      (s) => !!s && typeof s === "object" && s.port === port && typeof s.bundleUrl === "string"
+    );
+    if (!match) return null;
+    if (match.bundleUrlProvisional) return null;
+    return {
+      // normalize exactly like the manifest-probe branch below — the scan
+      // returns metro's manifest launchAsset url (lazy=true for code-split
+      // one/vxrn apps), but sootsim loads ONE self-contained bundle into the tenant
+      // worker, so a deferred React.lazy chunk throws "Requiring unknown module
+      // <id>". normalizeNativeDevBundleUrl forces lazy=false + strips bytecode.
+      bundleUrl: normalizeNativeDevBundleUrl(match.bundleUrl),
+      port,
+      framework: typeof match.framework === "string" ? match.framework : "unknown",
+      projectName: typeof match.projectName === "string" ? match.projectName : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+var MANIFEST_PROBE_TIMEOUT_MS = 5e3;
+var MANIFEST_BOOT_BUDGET_MS = 3e4;
+var MANIFEST_BOOT_RETRY_MS = 1e3;
+async function probeExpoManifest(normalizedBaseUrl, port) {
+  let body;
+  const pending = fetchDevProbe(`${normalizedBaseUrl}/`, {
+    headers: { "expo-platform": "ios" }
+  }).then(
+    async (res) => res.ok ? { ok: true, body: await res.text() } : null,
+    () => void 0
+  );
+  let probeDeadline;
+  const answered = await Promise.race([
+    pending,
+    new Promise((resolve) => {
+      probeDeadline = setTimeout(() => resolve("timeout"), MANIFEST_PROBE_TIMEOUT_MS);
+    })
+  ]);
+  clearTimeout(probeDeadline);
+  if (answered === "timeout" || answered === void 0) return { state: "no-answer" };
+  if (answered === null) return { state: "no-manifest" };
+  body = answered.body;
+  if (!body.trim()) return { state: "no-answer" };
+  let manifest;
+  try {
+    manifest = JSON.parse(body);
+  } catch {
+    return { state: "no-manifest" };
+  }
+  const client = manifest?.extra?.expoClient || manifest?.extra || {};
+  const rawLaunchUrl = typeof manifest?.launchAsset?.url === "string" ? manifest.launchAsset.url : void 0;
+  const launchUrl = rawLaunchUrl ? alignLoopbackBundleUrlWithProbe(rawLaunchUrl, normalizedBaseUrl) : void 0;
+  if (!launchUrl && !client.name) return { state: "no-manifest" };
+  return {
+    state: "resolved",
+    bundle: {
+      bundleUrl: normalizeNativeDevBundleUrl(
+        launchUrl || `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`
+      ),
+      port,
+      framework: inferManifestFramework(launchUrl, client.sdkVersion),
+      projectName: client.name
+    }
+  };
+}
+async function isPackagerRunning(normalizedBaseUrl) {
+  try {
+    const res = await fetchDevProbe(`${normalizedBaseUrl}/status`);
+    if (!res.ok) return false;
+    return (await res.text()).includes("packager-status:running");
+  } catch {
+    return false;
+  }
+}
+async function probeBaseUrlBundleDirect(baseUrl, port) {
+  const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+  let manifest = await probeExpoManifest(normalizedBaseUrl, port);
+  let packagerConfirmed = false;
+  if (manifest.state === "no-answer") {
+    packagerConfirmed = await isPackagerRunning(normalizedBaseUrl);
+    if (!packagerConfirmed) return null;
+    const deadline = Date.now() + MANIFEST_BOOT_BUDGET_MS;
+    while (manifest.state === "no-answer" && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, MANIFEST_BOOT_RETRY_MS));
+      manifest = await probeExpoManifest(normalizedBaseUrl, port);
+    }
+  }
+  if (manifest.state === "resolved") return manifest.bundle;
+  if (manifest.state === "no-answer") return null;
+  if (!packagerConfirmed && !await isPackagerRunning(normalizedBaseUrl)) return null;
+  return {
+    bundleUrl: `${normalizedBaseUrl}${METRO_BUNDLE_PATH}`,
+    port,
+    framework: "metro"
+  };
+}
+async function probeBaseUrlBundle(baseUrl, port) {
+  try {
+    if (isLoopbackHost(new URL(baseUrl).hostname)) {
+      const viaScan = await resolvePortViaServerScan(port);
+      if (viaScan) return viaScan;
+    }
+  } catch {
+  }
+  return probeBaseUrlBundleDirect(baseUrl, port);
+}
+async function probePortBundle(port) {
+  const viaScan = await resolvePortViaServerScan(port);
+  if (viaScan) return viaScan;
+  const candidates = await Promise.all(
+    LOOPBACK_PROBE_HOSTNAMES.map(
+      (hostname) => probeBaseUrlBundleDirect(buildLoopbackProbeBaseUrl("http:", hostname, port), port)
+    )
+  );
+  return candidates.find((candidate) => candidate !== null) ?? null;
+}
+async function resolveConnectionInput(input) {
+  const trimmed = input.trim();
+  if (/^\d+$/.test(trimmed)) {
+    const port2 = parseInt(trimmed, 10);
+    const resolved = await probePortBundle(port2);
+    if (resolved) return resolved;
+    throw buildUnresolvedTargetError(`localhost:${port2}`);
+  }
+  const bundleUrl = trimmed.startsWith("http") ? trimmed : `http://${trimmed}`;
+  let parsed;
+  try {
+    parsed = new URL(bundleUrl);
+  } catch {
+    throw new Error(
+      `could not parse "${input}". pass a dev-server port, a dev-server base URL, or a full bundle URL.`
+    );
+  }
+  const protocol = parsed.protocol || "http:";
+  const port = parsed.port ? parseInt(parsed.port, 10) : getDefaultPortForProtocol(protocol);
+  const baseUrl = buildBaseUrl(protocol, parsed.hostname, port);
+  if (isBaseServerUrl(parsed)) {
+    const resolved = await probeBaseUrlBundle(baseUrl, port);
+    if (resolved) return resolved;
+    throw buildUnresolvedTargetError(baseUrl);
+  }
+  return { bundleUrl: parsed.toString(), port, framework: "unknown" };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_TEST_DRIVE_PORT,
+  inferManifestFramework,
+  probePortBundle,
+  resolveConnectionInput
+});