rnxsim 0.0.0 → 0.1.313

package/dist-lib/index.cjs

@@ -0,0 +1,513 @@
+/*! rnx v0.1.313 | (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);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_SOOTSIM_BRIDGE_PORT: () => DEFAULT_SOOTSIM_BRIDGE_PORT,
+  DEFAULT_SOOTSIM_BRIDGE_URL: () => DEFAULT_SOOTSIM_BRIDGE_URL,
+  DEFAULT_SOOTSIM_SHELL_URL: () => DEFAULT_SOOTSIM_SHELL_URL,
+  jumpToSourceBabelPlugin: () => sootsimJumpToSourceBabelPlugin,
+  metroPlugin: () => metro_plugin_default,
+  sootsimPlugin: () => sootsimPlugin
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/vite-plugin-one.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+
+// src/bridge-constants.ts
+var DEFAULT_SOOTSIM_BRIDGE_PORT = 7668;
+var DEFAULT_SOOTSIM_BRIDGE_URL = `http://localhost:${DEFAULT_SOOTSIM_BRIDGE_PORT}/`;
+
+// src/home-paths.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"), 1);
+var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
+var ACTIVE_RUNTIME_FILE = "active";
+var DAEMON_LOCKFILE = "daemon.json";
+var DAEMON_HEARTBEAT_STALE_MS = 3e4;
+function sootsimHomeDir() {
+  const override = process.env[SOOTSIM_HOME_ENV];
+  if (override && override.length > 0) return import_node_path.default.resolve(override);
+  return import_node_path.default.join((0, import_node_os.homedir)(), ".sootsim");
+}
+function runtimesDir() {
+  return import_node_path.default.join(sootsimHomeDir(), "runtimes");
+}
+function runtimeDir(version) {
+  return import_node_path.default.join(runtimesDir(), version);
+}
+function activeRuntimeFile() {
+  return import_node_path.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+}
+function daemonLockfilePath() {
+  return import_node_path.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
+}
+function readActiveRuntime() {
+  try {
+    const value = import_node_fs.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+function readDaemonLockfile() {
+  try {
+    const fd = import_node_fs.default.openSync(daemonLockfilePath(), "r");
+    try {
+      const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
+      const bytesRead = import_node_fs.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
+      const raw = buf.subarray(0, bytesRead).toString("utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed && parsed.schema === 1 && typeof parsed.pid === "number" && typeof parsed.bridgePort === "number" && typeof parsed.runtimePort === "number" && typeof parsed.startedAt === "number" && typeof parsed.heartbeatAt === "number" && (parsed.servedRuntimes === void 0 || Array.isArray(parsed.servedRuntimes) && parsed.servedRuntimes.every((version) => typeof version === "string"))) {
+        return parsed;
+      }
+      return null;
+    } finally {
+      import_node_fs.default.closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+function isDaemonLockfileFresh(lock, now = Date.now()) {
+  if (!lock) return false;
+  if (now - lock.heartbeatAt > DAEMON_HEARTBEAT_STALE_MS) return false;
+  try {
+    process.kill(lock.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/runtime-assets.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_url = require("url");
+
+// ../contrast-runtime-delivery/src/product.ts
+function isValidRuntimeVersion(value) {
+  return value.length <= 100 && /^[0-9A-Za-z][0-9A-Za-z._+-]*$/.test(value);
+}
+
+// src/runtime-assets.ts
+var SOOTSIM_RUNTIME_MISSING_MESSAGE = "[rnx] no engine runtime installed \u2014 run `rnxsim setup`, or `rnxsim runtime install`";
+var _monorepoRootCache;
+function findMonorepoRoot() {
+  if (_monorepoRootCache !== void 0) return _monorepoRootCache;
+  let dir = import_path.default.dirname((0, import_url.fileURLToPath)(__sootsim_import_meta_url));
+  for (let i = 0; i < 12 && dir !== import_path.default.dirname(dir); i++) {
+    if (import_fs.default.existsSync(import_path.default.join(dir, "packages/sootsim-engine/package.json")) && import_fs.default.existsSync(import_path.default.join(dir, "public/sootsim"))) {
+      _monorepoRootCache = dir;
+      return dir;
+    }
+    dir = import_path.default.dirname(dir);
+  }
+  _monorepoRootCache = null;
+  return null;
+}
+function resolveDevCheckoutRuntimeRoot() {
+  if (process.env.SOOTSIM_HOME && readActiveRuntime()) return null;
+  const root = findMonorepoRoot();
+  if (!root) return null;
+  const devBuild = import_path.default.join(root, "public/sootsim");
+  if (import_fs.default.existsSync(import_path.default.join(devBuild, "index.html")) && import_fs.default.existsSync(import_path.default.join(devBuild, "engine/index.html")) && import_fs.default.existsSync(import_path.default.join(devBuild, "engine-tenant/worker.js"))) {
+    return devBuild;
+  }
+  return null;
+}
+var MIME_TYPES = {
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".css": "text/css",
+  ".html": "text/html",
+  ".wasm": "application/wasm",
+  ".json": "application/json",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".glb": "model/gltf-binary",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav"
+};
+var ROOT_RUNTIME_PATHS = [
+  "/assets/",
+  "/engine/",
+  "/engine-tenant/",
+  "/photos/",
+  "/three-mode/",
+  "/fonts/",
+  "/icons/",
+  "/sounds/",
+  "/spike/",
+  "/test-wallpaper.jpg",
+  "/preview-sw.js",
+  "/sootsim.svg"
+];
+function resolveActiveRuntimeRoot() {
+  const devRoot = resolveDevCheckoutRuntimeRoot();
+  if (devRoot) return devRoot;
+  const active = readActiveRuntime();
+  if (!active) return null;
+  const dir = runtimeDir(active);
+  if (!import_fs.default.existsSync(import_path.default.join(dir, "index.html"))) return null;
+  return dir;
+}
+var RUNTIME_VERSION_HOSTNAME_SUFFIX = ".runtime.localhost";
+function isRuntimeVersionHostname(hostname) {
+  return hostname.toLowerCase().endsWith(RUNTIME_VERSION_HOSTNAME_SUFFIX);
+}
+function runtimeVersionFromHostname(hostname) {
+  if (!isRuntimeVersionHostname(hostname)) return null;
+  const labels = hostname.slice(0, -RUNTIME_VERSION_HOSTNAME_SUFFIX.length).split(".");
+  if (labels.length === 0 || labels.some((label) => !/^[0-9a-f]{1,60}$/i.test(label))) {
+    return null;
+  }
+  const encoded = labels.join("");
+  if (encoded.length % 2 !== 0) return null;
+  try {
+    const version = Buffer.from(encoded, "hex").toString("utf8");
+    return isValidRuntimeVersion(version) ? version : null;
+  } catch {
+    return null;
+  }
+}
+function resolveInstalledRuntimeRoot(version) {
+  const dir = runtimeDir(version);
+  if (!import_fs.default.existsSync(import_path.default.join(dir, "index.html"))) return null;
+  return dir;
+}
+function resolveRuntimeRootForHostname(hostname) {
+  if (!isRuntimeVersionHostname(hostname)) return resolveActiveRuntimeRoot();
+  const version = runtimeVersionFromHostname(hostname);
+  return version ? resolveInstalledRuntimeRoot(version) : null;
+}
+function resolveRuntimeRootForRequestHost(host) {
+  if (!host) return resolveActiveRuntimeRoot();
+  try {
+    return resolveRuntimeRootForHostname(new URL(`http://${host}`).hostname);
+  } catch {
+    return null;
+  }
+}
+function isRootRuntimeAssetPath(pathname) {
+  return ROOT_RUNTIME_PATHS.some((p) => pathname === p || pathname.startsWith(p));
+}
+function resolveRuntimeFilePath(runtimeRoot, pathname) {
+  if (!pathname.startsWith("/")) return null;
+  if (pathname.includes("\0") || pathname.includes("\\")) return null;
+  for (const segment of pathname.split("/")) {
+    if (segment === "..") return null;
+  }
+  const fullPath = import_path.default.resolve(runtimeRoot, pathname.replace(/^\/+/, ""));
+  const rootWithSep = runtimeRoot.endsWith(import_path.default.sep) ? runtimeRoot : runtimeRoot + import_path.default.sep;
+  if (!fullPath.startsWith(rootWithSep) && fullPath !== runtimeRoot) return null;
+  if (!import_fs.default.existsSync(fullPath) || !import_fs.default.statSync(fullPath).isFile()) return null;
+  return fullPath;
+}
+function serveRuntimeFile(req, res, fullPath) {
+  const ext = import_path.default.extname(fullPath);
+  const stat = import_fs.default.statSync(fullPath);
+  const lastModified = stat.mtime.toUTCString();
+  res.setHeader("content-type", MIME_TYPES[ext] || "application/octet-stream");
+  res.setHeader("cache-control", "no-cache");
+  res.setHeader("last-modified", lastModified);
+  if (req?.headers?.["if-modified-since"] === lastModified) {
+    res.statusCode = 304;
+    res.end();
+    return;
+  }
+  import_fs.default.createReadStream(fullPath).pipe(res);
+}
+
+// src/vite-plugin-one.ts
+function sootsimPlugin(options = {}) {
+  if (options.enabled === false) return [];
+  const prefix2 = options.prefix || "/__soot";
+  return [
+    {
+      name: "sootsim-one",
+      configureServer(server) {
+        const bundleUrl = options.bundleUrl || "/node_modules/one/metro-entry.bundle?platform=ios&dev=true&minify=false";
+        const buildShellHtml = (runtimeRoot) => {
+          const html = import_fs2.default.readFileSync(import_path2.default.join(runtimeRoot, "index.html"), "utf8");
+          const lock = readDaemonLockfile();
+          const bridgePort = lock && isDaemonLockfileFresh(lock) && lock.bridgePort > 0 ? lock.bridgePort : DEFAULT_SOOTSIM_BRIDGE_PORT;
+          const inject = `<script>(function(){var u=new URL(location.href);if(!u.searchParams.has('bundle'))u.searchParams.set('bundle',${JSON.stringify(bundleUrl)});window.__sootsimBridgePort=${bridgePort};history.replaceState(null,'','${prefix2}/'+u.search)})()</script>`;
+          return html.replace("</head>", inject + "</head>");
+        };
+        server.middlewares.use((req, res, next) => {
+          const origWriteHead = res.writeHead.bind(res);
+          res.writeHead = function(statusCode, ...args) {
+            const setCookie = res.getHeader("set-cookie");
+            if (setCookie) {
+              const value = Array.isArray(setCookie) ? setCookie.join(", ") : String(setCookie);
+              res.setHeader("x-sootsim-set-cookie", value);
+              res.setHeader("access-control-expose-headers", "x-sootsim-set-cookie");
+            }
+            return origWriteHead(
+              statusCode,
+              ...args
+            );
+          };
+          next();
+        });
+        server.middlewares.use((req, res, next) => {
+          if ((req.url || "").split("?")[0] !== "/__server-scan") return next();
+          const scanPort = server.config.server.port || 8081;
+          const absoluteBundleUrl = bundleUrl.startsWith("http") ? bundleUrl : `http://localhost:${scanPort}${bundleUrl}`;
+          res.setHeader("content-type", "application/json");
+          res.end(
+            JSON.stringify([
+              {
+                port: scanPort,
+                framework: "one",
+                bundleUrl: absoluteBundleUrl,
+                lastSeen: Date.now()
+              }
+            ])
+          );
+        });
+        server.middlewares.use((req, res, next) => {
+          const url = req.url || "";
+          const pathname = url.split("?")[0];
+          const runtimeRoot = resolveRuntimeRootForRequestHost(req.headers.host);
+          if (!runtimeRoot) {
+            if (pathname === prefix2 || pathname === prefix2 + "/" || pathname.startsWith(prefix2 + "/")) {
+              res.statusCode = 500;
+              res.end(SOOTSIM_RUNTIME_MISSING_MESSAGE);
+              return;
+            }
+            next();
+            return;
+          }
+          if (isRootRuntimeAssetPath(pathname)) {
+            const fullPath = resolveRuntimeFilePath(runtimeRoot, pathname);
+            if (fullPath) {
+              serveRuntimeFile(req, res, fullPath);
+              return;
+            }
+          }
+          if (pathname === prefix2 || pathname === prefix2 + "/") {
+            res.setHeader("content-type", "text/html");
+            res.end(buildShellHtml(runtimeRoot));
+            return;
+          }
+          if (pathname.startsWith(prefix2 + "/")) {
+            const fullPath = resolveRuntimeFilePath(
+              runtimeRoot,
+              pathname.slice(prefix2.length)
+            );
+            if (fullPath) {
+              serveRuntimeFile(req, res, fullPath);
+              return;
+            }
+            const ext = import_path2.default.extname(pathname);
+            if (!ext) {
+              res.setHeader("content-type", "text/html");
+              res.end(buildShellHtml(runtimeRoot));
+              return;
+            }
+          }
+          next();
+        });
+        const port = server.config.server.port || 8081;
+        const sootsimUrl = `http://localhost:${port}${prefix2}/`;
+        console.log(`[rnx] serving at ${sootsimUrl}`);
+      }
+    }
+  ];
+}
+
+// src/metro-plugin.ts
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var prefix = "/__soot";
+function withSootsim(config, options = {}) {
+  if (options.enabled === false) return config;
+  const bundleUrl = options.bundleUrl || "/index.bundle?platform=ios&dev=true&hot=true&minify=false";
+  const cfgServer = config.server;
+  const existingEnhance = cfgServer?.enhanceMiddleware;
+  const serverConfig = {
+    ...cfgServer,
+    enhanceMiddleware: (metroMiddleware, metroServer) => {
+      let middleware = metroMiddleware;
+      if (existingEnhance) {
+        middleware = existingEnhance(metroMiddleware, metroServer);
+      }
+      let connect;
+      try {
+        connect = require("connect");
+      } catch {
+        console.warn("[rnx] connect not available");
+        return middleware;
+      }
+      const server = connect();
+      server.use((req, res, next) => {
+        const url = req.url || "";
+        const pathname = url.split("?")[0];
+        const runtimeRoot = resolveRuntimeRootForRequestHost(req.headers?.host);
+        if (!runtimeRoot) {
+          if (pathname === prefix || pathname === prefix + "/") {
+            res.statusCode = 500;
+            res.end(SOOTSIM_RUNTIME_MISSING_MESSAGE);
+            return;
+          }
+          next();
+          return;
+        }
+        if (isRootRuntimeAssetPath(pathname)) {
+          const fullPath = resolveRuntimeFilePath(runtimeRoot, pathname);
+          if (fullPath) {
+            serveRuntimeFile(req, res, fullPath);
+            return;
+          }
+        }
+        if (pathname.startsWith(prefix + "/")) {
+          const fullPath = resolveRuntimeFilePath(
+            runtimeRoot,
+            pathname.slice(prefix.length)
+          );
+          if (fullPath) {
+            serveRuntimeFile(req, res, fullPath);
+            return;
+          }
+        }
+        if (pathname === prefix || pathname === prefix + "/" || pathname.startsWith(prefix + "/")) {
+          const ext = import_path3.default.extname(pathname);
+          if (!ext) {
+            const htmlPath = import_path3.default.join(runtimeRoot, "index.html");
+            let html = import_fs3.default.readFileSync(htmlPath, "utf8");
+            html = html.replace(
+              "</head>",
+              `<script>history.replaceState(null,'','${prefix}/?bundle=${encodeURIComponent(bundleUrl)}')</script></head>`
+            );
+            res.setHeader("content-type", "text/html");
+            res.end(html);
+            return;
+          }
+        }
+        next();
+      });
+      server.use(middleware);
+      console.log(`[rnx] serving at ${prefix}/`);
+      return server;
+    }
+  };
+  return { ...config, server: serverConfig };
+}
+var metro_plugin_default = withSootsim;
+
+// src/jump-to-source-babel.ts
+function normalizeSourcePath(path5) {
+  const queryStart = path5.indexOf("?");
+  const clean = queryStart >= 0 ? path5.slice(0, queryStart) : path5;
+  return clean.replace(/\\/g, "/");
+}
+function matchesPath(path5, matcher) {
+  return typeof matcher === "string" ? path5.includes(matcher) : matcher.test(path5);
+}
+function shouldStampFile(filename, options) {
+  const normalized = normalizeSourcePath(filename);
+  if (normalized.includes("/node_modules/")) return false;
+  if (normalized.includes("/dist/") || normalized.includes("/build/")) return false;
+  if (options.exclude?.some((matcher) => matchesPath(normalized, matcher))) return false;
+  if (options.include?.length) {
+    return options.include.some((matcher) => matchesPath(normalized, matcher));
+  }
+  return true;
+}
+function getJSXName(node) {
+  if (!node) return null;
+  if (node.type === "JSXIdentifier" && node.name) return node.name;
+  if (node.type === "JSXMemberExpression") {
+    const object = getJSXName(node.object);
+    const property = getJSXName(node.property);
+    return object && property ? `${object}.${property}` : null;
+  }
+  return null;
+}
+function hasAttribute(node, attrName) {
+  return node.attributes?.some((attr) => {
+    if (attr.type !== "JSXAttribute") return false;
+    return attr.name?.type === "JSXIdentifier" && attr.name.name === attrName;
+  }) ?? false;
+}
+function sootsimJumpToSourceBabelPlugin(api, options = {}) {
+  const attrName = options.attrName || "srcloc";
+  return {
+    name: "sootsim-jump-to-source",
+    visitor: {
+      JSXOpeningElement(path5, state) {
+        if (options.enabled === false) return;
+        const filename = state.file?.opts?.filename;
+        if (!filename || !shouldStampFile(filename, options)) return;
+        const node = path5.node;
+        const tagName = getJSXName(node.name);
+        if (!tagName || tagName === "Fragment" || tagName.endsWith(".Fragment")) return;
+        if (hasAttribute(node, attrName)) return;
+        const loc = node.loc?.start;
+        if (!loc) return;
+        const source = `${normalizeSourcePath(filename)}:${loc.line}:${loc.column + 1}`;
+        node.attributes ??= [];
+        node.attributes.push(
+          api.types.jsxAttribute(
+            api.types.jsxIdentifier(attrName),
+            api.types.stringLiteral(source)
+          )
+        );
+      }
+    }
+  };
+}
+
+// src/cli-constants.ts
+var DEFAULT_SOOTSIM_SHELL_URL = "http://localhost:5173/";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SOOTSIM_BRIDGE_PORT,
+  DEFAULT_SOOTSIM_BRIDGE_URL,
+  DEFAULT_SOOTSIM_SHELL_URL,
+  jumpToSourceBabelPlugin,
+  metroPlugin,
+  sootsimPlugin
+});

package/dist-lib/jump-to-source-babel.cjs

@@ -0,0 +1,93 @@
+/*! rnx v0.1.313 | (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/jump-to-source-babel.ts
+var jump_to_source_babel_exports = {};
+__export(jump_to_source_babel_exports, {
+  default: () => sootsimJumpToSourceBabelPlugin,
+  sootsimJumpToSourceBabelPlugin: () => sootsimJumpToSourceBabelPlugin
+});
+module.exports = __toCommonJS(jump_to_source_babel_exports);
+function normalizeSourcePath(path) {
+  const queryStart = path.indexOf("?");
+  const clean = queryStart >= 0 ? path.slice(0, queryStart) : path;
+  return clean.replace(/\\/g, "/");
+}
+function matchesPath(path, matcher) {
+  return typeof matcher === "string" ? path.includes(matcher) : matcher.test(path);
+}
+function shouldStampFile(filename, options) {
+  const normalized = normalizeSourcePath(filename);
+  if (normalized.includes("/node_modules/")) return false;
+  if (normalized.includes("/dist/") || normalized.includes("/build/")) return false;
+  if (options.exclude?.some((matcher) => matchesPath(normalized, matcher))) return false;
+  if (options.include?.length) {
+    return options.include.some((matcher) => matchesPath(normalized, matcher));
+  }
+  return true;
+}
+function getJSXName(node) {
+  if (!node) return null;
+  if (node.type === "JSXIdentifier" && node.name) return node.name;
+  if (node.type === "JSXMemberExpression") {
+    const object = getJSXName(node.object);
+    const property = getJSXName(node.property);
+    return object && property ? `${object}.${property}` : null;
+  }
+  return null;
+}
+function hasAttribute(node, attrName) {
+  return node.attributes?.some((attr) => {
+    if (attr.type !== "JSXAttribute") return false;
+    return attr.name?.type === "JSXIdentifier" && attr.name.name === attrName;
+  }) ?? false;
+}
+function sootsimJumpToSourceBabelPlugin(api, options = {}) {
+  const attrName = options.attrName || "srcloc";
+  return {
+    name: "sootsim-jump-to-source",
+    visitor: {
+      JSXOpeningElement(path, state) {
+        if (options.enabled === false) return;
+        const filename = state.file?.opts?.filename;
+        if (!filename || !shouldStampFile(filename, options)) return;
+        const node = path.node;
+        const tagName = getJSXName(node.name);
+        if (!tagName || tagName === "Fragment" || tagName.endsWith(".Fragment")) return;
+        if (hasAttribute(node, attrName)) return;
+        const loc = node.loc?.start;
+        if (!loc) return;
+        const source = `${normalizeSourcePath(filename)}:${loc.line}:${loc.column + 1}`;
+        node.attributes ??= [];
+        node.attributes.push(
+          api.types.jsxAttribute(
+            api.types.jsxIdentifier(attrName),
+            api.types.stringLiteral(source)
+          )
+        );
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sootsimJumpToSourceBabelPlugin
+});