@ricsam/isolate 0.0.1 → 0.1.0

package/dist/mjs/internal/module-loader/index.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/module-loader/index.ts"],
+  "sourcesContent": [
+    "import fs from \"node:fs\";\nimport path from \"node:path\";\nimport { createRequire } from \"node:module\";\nimport type {\n  ModuleLoaderCallback,\n  ModuleLoaderResult,\n} from \"../protocol/index.mjs\";\nimport {\n  parseMappings,\n  virtualToHost,\n  findNodeModulesMapping,\n  findModuleAlias,\n  type MappingConfig,\n  type PathMapping,\n} from \"./mappings.mjs\";\nimport {\n  resolveFilePath,\n  parseSpecifier,\n  isBareSpecifier,\n} from \"./resolve.mjs\";\nimport { bundleSpecifier, bundleHostFile } from \"./bundle.mjs\";\nimport { isTypeScriptFile, processTypeScript } from \"./strip-types.mjs\";\n\nexport { parseMappings, virtualToHost, findNodeModulesMapping, findModuleAlias } from \"./mappings.mjs\";\nexport type { MappingConfig, PathMapping } from \"./mappings.mjs\";\nexport { resolveFilePath, detectFormat, parseSpecifier, isBareSpecifier } from \"./resolve.mjs\";\nexport { bundleSpecifier, bundleHostFile, clearBundleCache } from \"./bundle.mjs\";\nexport { isTypeScriptFile, processTypeScript } from \"./strip-types.mjs\";\n\n/**\n * Create a module loader callback that handles common patterns:\n * - Mapping host filesystem paths to virtual isolate paths\n * - Bundling npm packages with Rollup (ESM-first, browser conditions)\n * - Reading user files directly from the host filesystem\n *\n * Each npm package subpath is bundled independently and cached as static.\n *\n * @example\n * ```typescript\n * import { defaultModuleLoader } from './index.mjs';\n *\n * const loader = defaultModuleLoader(\n *   { from: '/host/project/node_modules', to: '/node_modules' },\n *   { from: '/host/project/src/entry.ts', to: '/app/entry.ts' }\n * );\n *\n * const runtime = await createRuntime({\n *   moduleLoader: loader,\n * });\n * ```\n */\nexport function defaultModuleLoader(\n  ...paths: MappingConfig[]\n): ModuleLoaderCallback {\n  const mappings = parseMappings(paths);\n  const nodeModulesMapping = findNodeModulesMapping(mappings);\n  const importerHostPathByVirtualPath = new Map<string, string>();\n\n  const loader: ModuleLoaderCallback = async (\n    moduleName: string,\n    importer: { path: string; resolveDir: string },\n  ): Promise<ModuleLoaderResult> => {\n    // A. Bare specifiers: module aliases or npm packages\n    if (isBareSpecifier(moduleName)) {\n      const alias = findModuleAlias(moduleName, mappings);\n      if (alias) {\n        return handleModuleAlias(alias, importerHostPathByVirtualPath);\n      }\n      return handleBareSpecifier(\n        moduleName,\n        importer,\n        nodeModulesMapping,\n        mappings,\n        importerHostPathByVirtualPath,\n      );\n    }\n\n    // B. Relative/absolute paths: user files or intra-package files\n    return handlePathSpecifier(\n      moduleName,\n      importer,\n      mappings,\n      importerHostPathByVirtualPath,\n    );\n  };\n\n  return loader;\n}\n\n/**\n * Handle bare specifiers (npm packages) by bundling with Rollup.\n */\nasync function handleBareSpecifier(\n  specifier: string,\n  importer: { path: string; resolveDir: string },\n  nodeModulesMapping: PathMapping | undefined,\n  mappings: PathMapping[],\n  importerHostPathByVirtualPath: Map<string, string>,\n): Promise<ModuleLoaderResult> {\n  if (!nodeModulesMapping) {\n    throw new Error(\n      `Cannot resolve bare specifier \"${specifier}\": no node_modules mapping configured. ` +\n      `Add a mapping like { from: '/path/to/node_modules', to: '/node_modules' }.`\n    );\n  }\n\n  const importerHostPath = resolveImporterHostPath(\n    importer,\n    mappings,\n    importerHostPathByVirtualPath,\n  );\n  const fallbackImporterHostPath = path.join(\n    path.dirname(nodeModulesMapping.hostBase),\n    \"__isolate_module_loader__.js\",\n  );\n  const effectiveImporterHostPath = importerHostPath ?? fallbackImporterHostPath;\n  const importerResolutionPath = toRealPath(effectiveImporterHostPath);\n  const resolvedHostPath = resolveBareSpecifierWithNode(\n    specifier,\n    importerResolutionPath,\n  );\n\n  if (!resolvedHostPath) {\n    throw new Error(\n      `Cannot resolve bare specifier \"${specifier}\" from importer \"${importer.path}\" ` +\n      `(host importer: ${effectiveImporterHostPath}).`\n    );\n  }\n\n  const rootDir = path.dirname(importerResolutionPath);\n\n  const { code } = await bundleSpecifier(specifier, rootDir);\n\n  const { packageName, subpath } = parseSpecifier(specifier);\n  const filename = subpath\n    ? `${packageName}${subpath}.bundled.js`\n        .split(\"/\")\n        .pop()!\n    : `${packageName}.bundled.js`\n        .split(\"/\")\n        .pop()!;\n\n  const result: ModuleLoaderResult = {\n    code,\n    filename,\n    resolveDir: nodeModulesMapping.virtualMount,\n    static: true,\n  };\n\n  // Keep host importer context so transitive bare imports resolve like Node:\n  // from the importing package location (realpath by default).\n  registerImporterHostPath(result, toRealPath(resolvedHostPath), importerHostPathByVirtualPath);\n\n  return result;\n}\n\n/**\n * Handle module alias specifiers by bundling the host file with Rollup.\n */\nasync function handleModuleAlias(\n  alias: PathMapping,\n  importerHostPathByVirtualPath: Map<string, string>,\n): Promise<ModuleLoaderResult> {\n  const { code } = await bundleHostFile(alias.hostBase);\n\n  // Sanitize the alias name into a filename (e.g. \"@/custom-module\" -> \"custom-module.bundled.js\")\n  const filename = alias.to\n    .replace(/^@[^/]*\\//, \"\") // strip scope prefix\n    .replace(/[^a-zA-Z0-9_.-]/g, \"-\") // replace non-safe chars\n    + \".bundled.js\";\n\n  const result: ModuleLoaderResult = {\n    code,\n    filename,\n    resolveDir: \"/\",\n  };\n\n  registerImporterHostPath(result, toRealPath(alias.hostBase), importerHostPathByVirtualPath);\n\n  return result;\n}\n\n/**\n * Handle relative/absolute path specifiers by resolving to host files.\n */\nasync function handlePathSpecifier(\n  specifier: string,\n  importer: { path: string; resolveDir: string },\n  mappings: PathMapping[],\n  importerHostPathByVirtualPath: Map<string, string>,\n): Promise<ModuleLoaderResult> {\n  // Resolve virtual path relative to importer's resolveDir\n  let virtualPath: string;\n  if (specifier.startsWith(\"/\")) {\n    virtualPath = specifier;\n  } else {\n    virtualPath = path.posix.normalize(\n      path.posix.join(importer.resolveDir, specifier)\n    );\n  }\n\n  // Map virtual path -> host path\n  const hostBasePath = virtualToHost(virtualPath, mappings);\n  if (!hostBasePath) {\n    throw new Error(\n      `Cannot resolve \"${specifier}\" (virtual: ${virtualPath}): no mapping matches this path. ` +\n      `Importer: ${importer.path}`\n    );\n  }\n\n  // Probe extensions and index files\n  const resolvedHostPath = resolveFilePath(hostBasePath);\n  if (!resolvedHostPath) {\n    throw new Error(\n      `Cannot resolve \"${specifier}\" (host: ${hostBasePath}): file not found after extension probing. ` +\n      `Importer: ${importer.path}`\n    );\n  }\n\n  // Read the file\n  let code = fs.readFileSync(resolvedHostPath, \"utf-8\");\n\n  // Process TypeScript files: strip types, elide unused imports, add placeholders\n  let resolvedFilename = path.basename(resolvedHostPath);\n  if (isTypeScriptFile(resolvedHostPath)) {\n    code = processTypeScript(code, resolvedHostPath);\n    // Change extension to .js so V8 treats it as JavaScript\n    resolvedFilename = resolvedFilename.replace(/\\.(tsx?|mts|cts)$/, \".js\");\n  }\n  // The host file may have a different name (due to extension probing), so rebuild virtual path\n  const hostDir = path.dirname(resolvedHostPath);\n\n  // Map the resolved host directory back to a virtual path for resolveDir\n  // We need to find which mapping contains this host path\n  let virtualDir: string | null = null;\n  for (const mapping of mappings) {\n    if (mapping.isGlob) {\n      if (hostDir === mapping.hostBase || hostDir.startsWith(mapping.hostBase + \"/\")) {\n        const relativePart = hostDir.slice(mapping.hostBase.length);\n        virtualDir = mapping.virtualMount + relativePart;\n        break;\n      }\n    } else {\n      const mappedHostDir = path.dirname(mapping.hostBase);\n      if (hostDir === mappedHostDir) {\n        virtualDir = path.posix.dirname(mapping.virtualMount);\n        break;\n      }\n    }\n  }\n\n  if (!virtualDir) {\n    // Fallback: use the importer's resolveDir combined with the specifier's directory\n    virtualDir = path.posix.dirname(virtualPath);\n  }\n\n  const result: ModuleLoaderResult = {\n    code,\n    filename: resolvedFilename,\n    resolveDir: virtualDir,\n    // User files are NOT static — they can change between evaluations\n  };\n\n  registerImporterHostPath(result, toRealPath(resolvedHostPath), importerHostPathByVirtualPath);\n\n  return result;\n}\n\nfunction resolveImporterHostPath(\n  importer: { path: string; resolveDir: string },\n  mappings: PathMapping[],\n  importerHostPathByVirtualPath: Map<string, string>,\n): string | null {\n  const cached = importerHostPathByVirtualPath.get(importer.path);\n  if (cached) {\n    return cached;\n  }\n\n  const mappedHostPath = virtualToHost(importer.path, mappings);\n  if (!mappedHostPath) {\n    return null;\n  }\n\n  const resolvedMappedPath = resolveFilePath(mappedHostPath);\n  if (resolvedMappedPath) {\n    return resolvedMappedPath;\n  }\n\n  if (exists(mappedHostPath)) {\n    return mappedHostPath;\n  }\n\n  return null;\n}\n\nfunction resolveBareSpecifierWithNode(\n  specifier: string,\n  importerHostPath: string,\n): string | null {\n  try {\n    const req = createRequire(importerHostPath);\n    return req.resolve(specifier);\n  } catch {\n    return null;\n  }\n}\n\nfunction registerImporterHostPath(\n  moduleResult: ModuleLoaderResult,\n  hostPath: string,\n  importerHostPathByVirtualPath: Map<string, string>,\n): void {\n  const virtualModulePath = path.posix.join(\n    moduleResult.resolveDir,\n    moduleResult.filename,\n  );\n  importerHostPathByVirtualPath.set(virtualModulePath, hostPath);\n}\n\nfunction toRealPath(inputPath: string): string {\n  try {\n    return fs.realpathSync(inputPath);\n  } catch {\n    return inputPath;\n  }\n}\n\nfunction exists(filePath: string): boolean {\n  try {\n    fs.accessSync(filePath);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "703089DD6D245FDA64756E2164756E21",
+  "names": []
+}

package/dist/mjs/internal/module-loader/mappings.mjs

@@ -0,0 +1,80 @@
+// packages/isolate/src/internal/module-loader/mappings.ts
+function parseMappings(configs) {
+  return configs.map((config) => {
+    const isGlob = config.from.includes("*");
+    const isModuleAlias = !config.to.startsWith("/");
+    if (isModuleAlias && isGlob) {
+      throw new Error(`Module alias "${config.to}" cannot use a glob pattern in "from" ("${config.from}"). ` + `Module aliases must map a single host file.`);
+    }
+    let hostBase;
+    if (isGlob) {
+      const parts = config.from.split("/");
+      const baseSegments = [];
+      for (const part of parts) {
+        if (part.includes("*"))
+          break;
+        baseSegments.push(part);
+      }
+      hostBase = baseSegments.join("/");
+    } else {
+      hostBase = config.from;
+    }
+    hostBase = hostBase.replace(/\/+$/, "");
+    const virtualMount = isModuleAlias ? config.to : config.to.replace(/\/+$/, "");
+    const isNodeModules = hostBase.endsWith("/node_modules") || hostBase === "node_modules";
+    return {
+      from: config.from,
+      to: config.to,
+      isGlob,
+      hostBase,
+      virtualMount,
+      isNodeModules,
+      isModuleAlias
+    };
+  });
+}
+function virtualToHost(virtualPath, mappings) {
+  for (const mapping of mappings) {
+    if (mapping.isGlob) {
+      if (virtualPath === mapping.virtualMount || virtualPath.startsWith(mapping.virtualMount + "/")) {
+        const relativePart = virtualPath.slice(mapping.virtualMount.length);
+        return mapping.hostBase + relativePart;
+      }
+    } else {
+      if (virtualPath === mapping.virtualMount) {
+        return mapping.hostBase;
+      }
+    }
+  }
+  return null;
+}
+function hostToVirtual(hostPath, mappings) {
+  for (const mapping of mappings) {
+    if (mapping.isGlob) {
+      if (hostPath === mapping.hostBase || hostPath.startsWith(mapping.hostBase + "/")) {
+        const relativePart = hostPath.slice(mapping.hostBase.length);
+        return mapping.virtualMount + relativePart;
+      }
+    } else {
+      if (hostPath === mapping.hostBase) {
+        return mapping.virtualMount;
+      }
+    }
+  }
+  return null;
+}
+function findNodeModulesMapping(mappings) {
+  return mappings.find((m) => m.isNodeModules);
+}
+function findModuleAlias(specifier, mappings) {
+  return mappings.find((m) => m.isModuleAlias && m.to === specifier);
+}
+export {
+  virtualToHost,
+  parseMappings,
+  hostToVirtual,
+  findNodeModulesMapping,
+  findModuleAlias
+};
+
+//# debugId=8539B8CCFEFCAF4C64756E2164756E21

package/dist/mjs/internal/module-loader/mappings.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/module-loader/mappings.ts"],
+  "sourcesContent": [
+    "import path from \"node:path\";\n\nexport interface PathMapping {\n  /** Original 'from' path (host) */\n  from: string;\n  /** Original 'to' path (virtual) */\n  to: string;\n  /** Whether this is a glob pattern */\n  isGlob: boolean;\n  /** For globs: the base path before the glob (host-side) */\n  hostBase: string;\n  /** For globs: the virtual mount point */\n  virtualMount: string;\n  /** Whether the host base ends with node_modules */\n  isNodeModules: boolean;\n  /** Whether this mapping is a module alias (to doesn't start with '/') */\n  isModuleAlias: boolean;\n}\n\nexport interface MappingConfig {\n  from: string;\n  to: string;\n}\n\n/**\n * Parse {from, to} pairs into structured PathMapping objects.\n *\n * - Glob patterns (contain `*`): extract base path before glob -> prefix mapping\n * - Direct file paths (no glob): 1:1 mapping\n * - Node modules detection: if base path ends with `node_modules`, flag as isNodeModules\n */\nexport function parseMappings(configs: MappingConfig[]): PathMapping[] {\n  return configs.map((config) => {\n    const isGlob = config.from.includes(\"*\");\n    const isModuleAlias = !config.to.startsWith(\"/\");\n\n    if (isModuleAlias && isGlob) {\n      throw new Error(\n        `Module alias \"${config.to}\" cannot use a glob pattern in \"from\" (\"${config.from}\"). ` +\n        `Module aliases must map a single host file.`\n      );\n    }\n\n    let hostBase: string;\n    if (isGlob) {\n      // Extract base path before the first glob segment\n      const parts = config.from.split(\"/\");\n      const baseSegments: string[] = [];\n      for (const part of parts) {\n        if (part.includes(\"*\")) break;\n        baseSegments.push(part);\n      }\n      hostBase = baseSegments.join(\"/\");\n    } else {\n      hostBase = config.from;\n    }\n\n    // Normalize trailing slashes\n    hostBase = hostBase.replace(/\\/+$/, \"\");\n    const virtualMount = isModuleAlias ? config.to : config.to.replace(/\\/+$/, \"\");\n\n    const isNodeModules = hostBase.endsWith(\"/node_modules\") || hostBase === \"node_modules\";\n\n    return {\n      from: config.from,\n      to: config.to,\n      isGlob,\n      hostBase,\n      virtualMount,\n      isNodeModules,\n      isModuleAlias,\n    };\n  });\n}\n\n/**\n * Map a virtual path to a host path using the configured mappings.\n * Returns null if no mapping matches.\n */\nexport function virtualToHost(virtualPath: string, mappings: PathMapping[]): string | null {\n  for (const mapping of mappings) {\n    if (mapping.isGlob) {\n      // Prefix matching: virtual path must start with the virtual mount\n      if (virtualPath === mapping.virtualMount || virtualPath.startsWith(mapping.virtualMount + \"/\")) {\n        const relativePart = virtualPath.slice(mapping.virtualMount.length);\n        return mapping.hostBase + relativePart;\n      }\n    } else {\n      // Direct file mapping\n      if (virtualPath === mapping.virtualMount) {\n        return mapping.hostBase;\n      }\n    }\n  }\n  return null;\n}\n\n/**\n * Map a host path to a virtual path using the configured mappings.\n * Returns null if no mapping matches.\n */\nexport function hostToVirtual(hostPath: string, mappings: PathMapping[]): string | null {\n  for (const mapping of mappings) {\n    if (mapping.isGlob) {\n      if (hostPath === mapping.hostBase || hostPath.startsWith(mapping.hostBase + \"/\")) {\n        const relativePart = hostPath.slice(mapping.hostBase.length);\n        return mapping.virtualMount + relativePart;\n      }\n    } else {\n      if (hostPath === mapping.hostBase) {\n        return mapping.virtualMount;\n      }\n    }\n  }\n  return null;\n}\n\n/**\n * Find the node_modules mapping (if any).\n */\nexport function findNodeModulesMapping(mappings: PathMapping[]): PathMapping | undefined {\n  return mappings.find((m) => m.isNodeModules);\n}\n\n/**\n * Find a module alias mapping that matches the given bare specifier.\n * Returns undefined if no module alias matches.\n */\nexport function findModuleAlias(specifier: string, mappings: PathMapping[]): PathMapping | undefined {\n  return mappings.find((m) => m.isModuleAlias && m.to === specifier);\n}\n"
+  ],
+  "mappings": ";AA+BO,SAAS,aAAa,CAAC,SAAyC;AAAA,EACrE,OAAO,QAAQ,IAAI,CAAC,WAAW;AAAA,IAC7B,MAAM,SAAS,OAAO,KAAK,SAAS,GAAG;AAAA,IACvC,MAAM,gBAAgB,CAAC,OAAO,GAAG,WAAW,GAAG;AAAA,IAE/C,IAAI,iBAAiB,QAAQ;AAAA,MAC3B,MAAM,IAAI,MACR,iBAAiB,OAAO,6CAA6C,OAAO,aAC5E,6CACF;AAAA,IACF;AAAA,IAEA,IAAI;AAAA,IACJ,IAAI,QAAQ;AAAA,MAEV,MAAM,QAAQ,OAAO,KAAK,MAAM,GAAG;AAAA,MACnC,MAAM,eAAyB,CAAC;AAAA,MAChC,WAAW,QAAQ,OAAO;AAAA,QACxB,IAAI,KAAK,SAAS,GAAG;AAAA,UAAG;AAAA,QACxB,aAAa,KAAK,IAAI;AAAA,MACxB;AAAA,MACA,WAAW,aAAa,KAAK,GAAG;AAAA,IAClC,EAAO;AAAA,MACL,WAAW,OAAO;AAAA;AAAA,IAIpB,WAAW,SAAS,QAAQ,QAAQ,EAAE;AAAA,IACtC,MAAM,eAAe,gBAAgB,OAAO,KAAK,OAAO,GAAG,QAAQ,QAAQ,EAAE;AAAA,IAE7E,MAAM,gBAAgB,SAAS,SAAS,eAAe,KAAK,aAAa;AAAA,IAEzE,OAAO;AAAA,MACL,MAAM,OAAO;AAAA,MACb,IAAI,OAAO;AAAA,MACX;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,GACD;AAAA;AAOI,SAAS,aAAa,CAAC,aAAqB,UAAwC;AAAA,EACzF,WAAW,WAAW,UAAU;AAAA,IAC9B,IAAI,QAAQ,QAAQ;AAAA,MAElB,IAAI,gBAAgB,QAAQ,gBAAgB,YAAY,WAAW,QAAQ,eAAe,GAAG,GAAG;AAAA,QAC9F,MAAM,eAAe,YAAY,MAAM,QAAQ,aAAa,MAAM;AAAA,QAClE,OAAO,QAAQ,WAAW;AAAA,MAC5B;AAAA,IACF,EAAO;AAAA,MAEL,IAAI,gBAAgB,QAAQ,cAAc;AAAA,QACxC,OAAO,QAAQ;AAAA,MACjB;AAAA;AAAA,EAEJ;AAAA,EACA,OAAO;AAAA;AAOF,SAAS,aAAa,CAAC,UAAkB,UAAwC;AAAA,EACtF,WAAW,WAAW,UAAU;AAAA,IAC9B,IAAI,QAAQ,QAAQ;AAAA,MAClB,IAAI,aAAa,QAAQ,YAAY,SAAS,WAAW,QAAQ,WAAW,GAAG,GAAG;AAAA,QAChF,MAAM,eAAe,SAAS,MAAM,QAAQ,SAAS,MAAM;AAAA,QAC3D,OAAO,QAAQ,eAAe;AAAA,MAChC;AAAA,IACF,EAAO;AAAA,MACL,IAAI,aAAa,QAAQ,UAAU;AAAA,QACjC,OAAO,QAAQ;AAAA,MACjB;AAAA;AAAA,EAEJ;AAAA,EACA,OAAO;AAAA;AAMF,SAAS,sBAAsB,CAAC,UAAkD;AAAA,EACvF,OAAO,SAAS,KAAK,CAAC,MAAM,EAAE,aAAa;AAAA;AAOtC,SAAS,eAAe,CAAC,WAAmB,UAAkD;AAAA,EACnG,OAAO,SAAS,KAAK,CAAC,MAAM,EAAE,iBAAiB,EAAE,OAAO,SAAS;AAAA;",
+  "debugId": "8539B8CCFEFCAF4C64756E2164756E21",
+  "names": []
+}

package/dist/mjs/internal/module-loader/resolve.mjs

@@ -0,0 +1,113 @@
+// packages/isolate/src/internal/module-loader/resolve.ts
+import fs from "node:fs";
+import path from "node:path";
+var EXTENSIONS = [
+  ".tsx",
+  ".jsx",
+  ".ts",
+  ".mjs",
+  ".js",
+  ".cjs",
+  ".json"
+];
+function resolveFilePath(basePath) {
+  if (isFile(basePath))
+    return basePath;
+  const dir = path.dirname(basePath);
+  const ext = path.extname(basePath);
+  const nameWithoutExt = path.basename(basePath, ext);
+  if (ext) {
+    const browserPath = path.join(dir, `${nameWithoutExt}.browser${ext}`);
+    if (isFile(browserPath))
+      return browserPath;
+    return null;
+  }
+  for (const probeExt of EXTENSIONS) {
+    const browserPath = path.join(dir, `${nameWithoutExt}.browser${probeExt}`);
+    if (isFile(browserPath))
+      return browserPath;
+    const probePath = basePath + probeExt;
+    if (isFile(probePath))
+      return probePath;
+  }
+  if (isDirectory(basePath)) {
+    for (const probeExt of EXTENSIONS) {
+      const browserIndex = path.join(basePath, `index.browser${probeExt}`);
+      if (isFile(browserIndex))
+        return browserIndex;
+      const indexPath = path.join(basePath, `index${probeExt}`);
+      if (isFile(indexPath))
+        return indexPath;
+    }
+  }
+  return null;
+}
+function detectFormat(filePath, code) {
+  const ext = path.extname(filePath);
+  if (ext === ".json")
+    return "json";
+  if (ext === ".cjs")
+    return "cjs";
+  if (ext === ".mjs")
+    return "esm";
+  if (hasESMSyntax(code))
+    return "esm";
+  if (hasCJSSyntax(code))
+    return "cjs";
+  return "esm";
+}
+function hasESMSyntax(code) {
+  return /\b(import\s+|export\s+(default\s+|{|const\s|let\s|var\s|function\s|class\s|async\s))/m.test(code);
+}
+function hasCJSSyntax(code) {
+  return /\b(module\.exports|exports\.\w+\s*=|require\s*\()/m.test(code);
+}
+function parseSpecifier(specifier) {
+  if (specifier.startsWith("@")) {
+    const slashIndex2 = specifier.indexOf("/");
+    if (slashIndex2 === -1) {
+      return { packageName: specifier, subpath: "" };
+    }
+    const secondSlash = specifier.indexOf("/", slashIndex2 + 1);
+    if (secondSlash === -1) {
+      return { packageName: specifier, subpath: "" };
+    }
+    return {
+      packageName: specifier.slice(0, secondSlash),
+      subpath: specifier.slice(secondSlash)
+    };
+  }
+  const slashIndex = specifier.indexOf("/");
+  if (slashIndex === -1) {
+    return { packageName: specifier, subpath: "" };
+  }
+  return {
+    packageName: specifier.slice(0, slashIndex),
+    subpath: specifier.slice(slashIndex)
+  };
+}
+function isBareSpecifier(specifier) {
+  return !specifier.startsWith(".") && !specifier.startsWith("/");
+}
+function isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function isDirectory(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+export {
+  resolveFilePath,
+  parseSpecifier,
+  isBareSpecifier,
+  detectFormat
+};
+
+//# debugId=7B11F9EF267E122A64756E2164756E21

package/dist/mjs/internal/module-loader/resolve.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/module-loader/resolve.ts"],
+  "sourcesContent": [
+    "import fs from \"node:fs\";\nimport path from \"node:path\";\n\n/**\n * Extensions to probe for module resolution, in order of priority.\n */\nconst EXTENSIONS = [\n  \".tsx\",\n  \".jsx\",\n  \".ts\",\n  \".mjs\",\n  \".js\",\n  \".cjs\",\n  \".json\",\n];\n\n/**\n * Resolve a file path with extension probing, index fallback, and browser variant probing.\n * Returns the resolved absolute path, or null if not found.\n */\nexport function resolveFilePath(basePath: string): string | null {\n  // Try exact path first\n  if (isFile(basePath)) return basePath;\n\n  // Try browser variant (e.g., file.browser.ts before file.ts)\n  const dir = path.dirname(basePath);\n  const ext = path.extname(basePath);\n  const nameWithoutExt = path.basename(basePath, ext);\n\n  if (ext) {\n    // Has extension — try browser variant\n    const browserPath = path.join(dir, `${nameWithoutExt}.browser${ext}`);\n    if (isFile(browserPath)) return browserPath;\n\n    // Exact extension didn't work and file doesn't exist\n    return null;\n  }\n\n  // No extension — probe extensions\n  for (const probeExt of EXTENSIONS) {\n    // Try browser variant first\n    const browserPath = path.join(dir, `${nameWithoutExt}.browser${probeExt}`);\n    if (isFile(browserPath)) return browserPath;\n\n    const probePath = basePath + probeExt;\n    if (isFile(probePath)) return probePath;\n  }\n\n  // Try as directory with index file\n  if (isDirectory(basePath)) {\n    for (const probeExt of EXTENSIONS) {\n      const browserIndex = path.join(basePath, `index.browser${probeExt}`);\n      if (isFile(browserIndex)) return browserIndex;\n\n      const indexPath = path.join(basePath, `index${probeExt}`);\n      if (isFile(indexPath)) return indexPath;\n    }\n  }\n\n  return null;\n}\n\n/**\n * Detect the format of a file based on its extension and content.\n */\nexport function detectFormat(filePath: string, code: string): \"cjs\" | \"esm\" | \"json\" {\n  const ext = path.extname(filePath);\n\n  if (ext === \".json\") return \"json\";\n  if (ext === \".cjs\") return \"cjs\";\n  if (ext === \".mjs\") return \"esm\";\n\n  // Heuristic: check for CJS patterns vs ESM patterns\n  if (hasESMSyntax(code)) return \"esm\";\n  if (hasCJSSyntax(code)) return \"cjs\";\n\n  // Default to ESM\n  return \"esm\";\n}\n\n/**\n * Check if code has ES module syntax.\n */\nfunction hasESMSyntax(code: string): boolean {\n  // import ... from or export ...\n  return /\\b(import\\s+|export\\s+(default\\s+|{|const\\s|let\\s|var\\s|function\\s|class\\s|async\\s))/m.test(code);\n}\n\n/**\n * Check if code has CommonJS syntax.\n */\nfunction hasCJSSyntax(code: string): boolean {\n  return /\\b(module\\.exports|exports\\.\\w+\\s*=|require\\s*\\()/m.test(code);\n}\n\n/**\n * Parse a bare specifier into package name and subpath.\n *\n * Examples:\n *   \"lodash\" -> { packageName: \"lodash\", subpath: \"\" }\n *   \"lodash/chunk\" -> { packageName: \"lodash\", subpath: \"/chunk\" }\n *   \"@scope/pkg\" -> { packageName: \"@scope/pkg\", subpath: \"\" }\n *   \"@scope/pkg/sub/path\" -> { packageName: \"@scope/pkg\", subpath: \"/sub/path\" }\n */\nexport function parseSpecifier(specifier: string): { packageName: string; subpath: string } {\n  if (specifier.startsWith(\"@\")) {\n    // Scoped package: @scope/name or @scope/name/subpath\n    const slashIndex = specifier.indexOf(\"/\");\n    if (slashIndex === -1) {\n      return { packageName: specifier, subpath: \"\" };\n    }\n    const secondSlash = specifier.indexOf(\"/\", slashIndex + 1);\n    if (secondSlash === -1) {\n      return { packageName: specifier, subpath: \"\" };\n    }\n    return {\n      packageName: specifier.slice(0, secondSlash),\n      subpath: specifier.slice(secondSlash),\n    };\n  }\n\n  // Non-scoped: name or name/subpath\n  const slashIndex = specifier.indexOf(\"/\");\n  if (slashIndex === -1) {\n    return { packageName: specifier, subpath: \"\" };\n  }\n  return {\n    packageName: specifier.slice(0, slashIndex),\n    subpath: specifier.slice(slashIndex),\n  };\n}\n\n/**\n * Check if a specifier is a bare specifier (npm package name, not relative/absolute).\n */\nexport function isBareSpecifier(specifier: string): boolean {\n  return !specifier.startsWith(\".\") && !specifier.startsWith(\"/\");\n}\n\nfunction isFile(p: string): boolean {\n  try {\n    return fs.statSync(p).isFile();\n  } catch {\n    return false;\n  }\n}\n\nfunction isDirectory(p: string): boolean {\n  try {\n    return fs.statSync(p).isDirectory();\n  } catch {\n    return false;\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "7B11F9EF267E122A64756E2164756E21",
+  "names": []
+}

package/dist/mjs/internal/module-loader/strip-types.mjs

@@ -0,0 +1,172 @@
+// packages/isolate/src/internal/module-loader/strip-types.ts
+import Module from "node:module";
+import path from "node:path";
+var _stripTypeScriptTypes;
+var bunTranspilerCache = {};
+function getStripTypeScriptTypes() {
+  const strip = Module.stripTypeScriptTypes;
+  if (typeof strip !== "function") {
+    _stripTypeScriptTypes = undefined;
+    return;
+  }
+  if (_stripTypeScriptTypes !== strip) {
+    _stripTypeScriptTypes = strip;
+  }
+  return _stripTypeScriptTypes;
+}
+function getBunTranspiler(loader) {
+  const cached = bunTranspilerCache[loader];
+  if (cached)
+    return cached;
+  const bunGlobal = globalThis.Bun;
+  if (!bunGlobal?.Transpiler) {
+    return;
+  }
+  const transpiler = new bunGlobal.Transpiler({ loader });
+  bunTranspilerCache[loader] = transpiler;
+  return transpiler;
+}
+function transpileWithBunFallback(code, filename) {
+  const loader = path.extname(filename) === ".tsx" ? "tsx" : "ts";
+  const transpiler = getBunTranspiler(loader);
+  if (!transpiler) {
+    return null;
+  }
+  return transpiler.transformSync(code, { loader });
+}
+var TS_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".cts"]);
+function isTypeScriptFile(filePath) {
+  return TS_EXTENSIONS.has(path.extname(filePath));
+}
+function processTypeScript(code, filename) {
+  const typeExportNames = findTypeOnlyExports(code);
+  const stripTypes = getStripTypeScriptTypes();
+  let stripped;
+  if (stripTypes) {
+    try {
+      stripped = stripTypes(code, {
+        mode: "transform",
+        sourceMap: false
+      });
+    } catch {
+      stripped = stripTypes(code, {
+        mode: "strip"
+      });
+    }
+  } else {
+    const bunTranspiled = transpileWithBunFallback(code, filename);
+    if (bunTranspiled === null) {
+      throw new Error("TypeScript processing is unavailable in this runtime. " + "Requires Node.js >= 22.7.0 (Module.stripTypeScriptTypes) " + "or Bun.Transpiler.");
+    }
+    stripped = bunTranspiled;
+  }
+  stripped = elideUnusedImports(stripped);
+  if (typeExportNames.length > 0) {
+    const needsPlaceholder = typeExportNames.filter((name) => !isValueExported(name, stripped));
+    if (needsPlaceholder.length > 0) {
+      const vars = needsPlaceholder.map((n) => `var ${n} = undefined;`).join(" ");
+      stripped += `
+` + vars + `
+export { ` + needsPlaceholder.join(", ") + ` };
+`;
+    }
+  }
+  return stripped;
+}
+var NAMED_IMPORT_RE = /import\s+([\w$]+\s*,\s*)?\{([\s\S]*?)\}\s*from\s*['"]([^'"]+)['"];?/g;
+function getImportedLocalName(specifier) {
+  const trimmed = specifier.trim();
+  const asMatch = trimmed.match(/^(.+?)\s+as\s+([A-Za-z_$][\w$]*)$/);
+  return asMatch ? asMatch[2] : trimmed;
+}
+function createImportedNameReferenceRegex(localName) {
+  const escaped = escapeRegExp(localName);
+  return new RegExp(`(?<![\\w$])${escaped}(?![\\w$])`);
+}
+function elideUnusedImports(code) {
+  const entries = [];
+  NAMED_IMPORT_RE.lastIndex = 0;
+  let m;
+  while ((m = NAMED_IMPORT_RE.exec(code)) !== null) {
+    entries.push({
+      fullMatch: m[0],
+      start: m.index,
+      end: m.index + m[0].length,
+      defaultPart: m[1] ?? "",
+      specifiers: m[2].split(",").map((s) => s.trim()).filter((s) => s.length > 0),
+      modulePath: m[3]
+    });
+  }
+  if (entries.length === 0)
+    return code;
+  let body = code;
+  for (let i = entries.length - 1;i >= 0; i--) {
+    const { start, end } = entries[i];
+    body = body.slice(0, start) + " ".repeat(end - start) + body.slice(end);
+  }
+  let result = code;
+  for (let i = entries.length - 1;i >= 0; i--) {
+    const entry = entries[i];
+    const kept = [];
+    for (const spec of entry.specifiers) {
+      const localName = getImportedLocalName(spec);
+      if (createImportedNameReferenceRegex(localName).test(body)) {
+        kept.push(spec);
+      }
+    }
+    if (kept.length === entry.specifiers.length)
+      continue;
+    let replacement;
+    if (kept.length === 0 && !entry.defaultPart) {
+      replacement = "";
+    } else if (kept.length === 0) {
+      const def = entry.defaultPart.replace(/\s*,\s*$/, "").trim();
+      replacement = `import ${def} from '${entry.modulePath}';`;
+    } else {
+      replacement = `import ${entry.defaultPart}{ ${kept.join(", ")} } from '${entry.modulePath}';`;
+    }
+    result = result.slice(0, entry.start) + replacement + result.slice(entry.end);
+  }
+  return result;
+}
+function findTypeOnlyExports(code) {
+  const names = new Set;
+  let m;
+  const iface = /\bexport\s+interface\s+(\w+)/g;
+  while ((m = iface.exec(code)) !== null)
+    names.add(m[1]);
+  const alias = /\bexport\s+type\s+(\w+)\s*[=<]/g;
+  while ((m = alias.exec(code)) !== null)
+    names.add(m[1]);
+  const reExport = /\bexport\s+type\s*\{([^}]+)\}/g;
+  while ((m = reExport.exec(code)) !== null) {
+    for (const item of m[1].split(",")) {
+      const trimmed = item.trim();
+      const asMatch = trimmed.match(/\w+\s+as\s+(\w+)/);
+      if (asMatch)
+        names.add(asMatch[1]);
+      else if (/^\w+$/.test(trimmed))
+        names.add(trimmed);
+    }
+  }
+  return [...names];
+}
+function isValueExported(name, code) {
+  const e = escapeRegExp(name);
+  if (new RegExp(`\\bexport\\s+(?:var|let|const|function|class|async\\s+function)\\s+${e}\\b`).test(code))
+    return true;
+  if (new RegExp(`\\bexport\\s*\\{[^}]*\\b${e}\\b[^}]*\\}`).test(code))
+    return true;
+  if (name === "default" && /\bexport\s+default\b/.test(code))
+    return true;
+  return false;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export {
+  processTypeScript,
+  isTypeScriptFile
+};
+
+//# debugId=B176F605C44FE67E64756E2164756E21

package/dist/mjs/internal/module-loader/strip-types.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/module-loader/strip-types.ts"],
+  "sourcesContent": [
+    "import Module from \"node:module\";\nimport path from \"node:path\";\n\ntype StripTypeScriptTypesFn = NonNullable<typeof Module.stripTypeScriptTypes>;\ntype TsLoader = \"ts\" | \"tsx\";\ntype BunTranspilerLike = {\n  transformSync(code: string, options?: { loader?: TsLoader }): string;\n};\ntype BunGlobalLike = {\n  Transpiler?: new (options: { loader: TsLoader }) => BunTranspilerLike;\n};\n\nlet _stripTypeScriptTypes: StripTypeScriptTypesFn | undefined;\nconst bunTranspilerCache: Partial<Record<TsLoader, BunTranspilerLike>> = {};\n\nfunction getStripTypeScriptTypes(): StripTypeScriptTypesFn | undefined {\n  const strip = Module.stripTypeScriptTypes;\n  if (typeof strip !== \"function\") {\n    _stripTypeScriptTypes = undefined;\n    return undefined;\n  }\n\n  if (_stripTypeScriptTypes !== strip) {\n    _stripTypeScriptTypes = strip;\n  }\n\n  return _stripTypeScriptTypes;\n}\n\nfunction getBunTranspiler(loader: TsLoader): BunTranspilerLike | undefined {\n  const cached = bunTranspilerCache[loader];\n  if (cached) return cached;\n\n  const bunGlobal = (globalThis as { Bun?: BunGlobalLike }).Bun;\n  if (!bunGlobal?.Transpiler) {\n    return undefined;\n  }\n\n  const transpiler = new bunGlobal.Transpiler({ loader });\n  bunTranspilerCache[loader] = transpiler;\n  return transpiler;\n}\n\nfunction transpileWithBunFallback(code: string, filename: string): string | null {\n  const loader: TsLoader = path.extname(filename) === \".tsx\" ? \"tsx\" : \"ts\";\n  const transpiler = getBunTranspiler(loader);\n  if (!transpiler) {\n    return null;\n  }\n\n  return transpiler.transformSync(code, { loader });\n}\n\nconst TS_EXTENSIONS = new Set([\".ts\", \".tsx\", \".mts\", \".cts\"]);\n\n/**\n * Check if a file path is a TypeScript file that needs type processing.\n */\nexport function isTypeScriptFile(filePath: string): boolean {\n  return TS_EXTENSIONS.has(path.extname(filePath));\n}\n\n/**\n * Process a TypeScript file for isolate use:\n *\n * 1. Strip TypeScript types\n * 2. Elide import specifiers no longer referenced in the code body\n *    (handles: `import { SomeType } from 'pkg'` where SomeType was only\n *    used in type positions — the import survives stripping but the\n *    usage doesn't, so V8 demands an export that doesn't exist in the bundle)\n * 3. Add placeholder exports for type-only export names\n *    (handles: `export interface Foo {}` disappears after stripping,\n *    but other files may `import { Foo }` from this module)\n *\n * Returns valid JavaScript.\n */\nexport function processTypeScript(code: string, filename: string): string {\n  // Find type-only export names BEFORE stripping\n  const typeExportNames = findTypeOnlyExports(code);\n\n  // Prefer Node's native strip API when available.\n  // Fall back to Bun.Transpiler for Bun-hosted callbacks.\n  const stripTypes = getStripTypeScriptTypes();\n  let stripped: string;\n  if (stripTypes) {\n    try {\n      stripped = stripTypes(code, {\n        mode: \"transform\",\n        sourceMap: false,\n      });\n    } catch {\n      stripped = stripTypes(code, {\n        mode: \"strip\",\n      });\n    }\n  } else {\n    const bunTranspiled = transpileWithBunFallback(code, filename);\n    if (bunTranspiled === null) {\n      throw new Error(\n        \"TypeScript processing is unavailable in this runtime. \" +\n        \"Requires Node.js >= 22.7.0 (Module.stripTypeScriptTypes) \" +\n        \"or Bun.Transpiler.\"\n      );\n    }\n    stripped = bunTranspiled;\n  }\n\n  // Elide unused import specifiers\n  stripped = elideUnusedImports(stripped);\n\n  // Add placeholder exports for type-only names not already value-exported\n  if (typeExportNames.length > 0) {\n    const needsPlaceholder = typeExportNames.filter(\n      (name) => !isValueExported(name, stripped),\n    );\n    if (needsPlaceholder.length > 0) {\n      const vars = needsPlaceholder.map((n) => `var ${n} = undefined;`).join(\" \");\n      stripped += \"\\n\" + vars + \"\\nexport { \" + needsPlaceholder.join(\", \") + \" };\\n\";\n    }\n  }\n\n  return stripped;\n}\n\n// ─── Import elision ──────────────────────────────────────────────────────────\n\n/**\n * Named import regex (handles single-line and multi-line).\n * Captures: [1] optional default part, [2] specifier list, [3] module path\n */\nconst NAMED_IMPORT_RE =\n  /import\\s+([\\w$]+\\s*,\\s*)?\\{([\\s\\S]*?)\\}\\s*from\\s*['\"]([^'\"]+)['\"];?/g;\n\nfunction getImportedLocalName(specifier: string): string {\n  const trimmed = specifier.trim();\n  const asMatch = trimmed.match(/^(.+?)\\s+as\\s+([A-Za-z_$][\\w$]*)$/);\n  return asMatch ? asMatch[2]! : trimmed;\n}\n\nfunction createImportedNameReferenceRegex(localName: string): RegExp {\n  const escaped = escapeRegExp(localName);\n  return new RegExp(`(?<![\\\\w$])${escaped}(?![\\\\w$])`);\n}\n\n/**\n * After type stripping, imported names that were only used in type positions\n * are unreferenced in the code body. Remove them from import statements\n * so V8's module linker doesn't demand them from the resolved module.\n */\nfunction elideUnusedImports(code: string): string {\n  // Collect all named-import regions\n  const entries: Array<{\n    fullMatch: string;\n    start: number;\n    end: number;\n    defaultPart: string;\n    specifiers: string[];\n    modulePath: string;\n  }> = [];\n\n  NAMED_IMPORT_RE.lastIndex = 0;\n  let m: RegExpExecArray | null;\n  while ((m = NAMED_IMPORT_RE.exec(code)) !== null) {\n    entries.push({\n      fullMatch: m[0],\n      start: m.index,\n      end: m.index + m[0].length,\n      defaultPart: m[1] ?? \"\",\n      specifiers: m[2]!\n        .split(\",\")\n        .map((s) => s.trim())\n        .filter((s) => s.length > 0),\n      modulePath: m[3]!,\n    });\n  }\n\n  if (entries.length === 0) return code;\n\n  // Build \"body\" = code with all import declarations blanked out\n  let body = code;\n  for (let i = entries.length - 1; i >= 0; i--) {\n    const { start, end } = entries[i]!;\n    body = body.slice(0, start) + \" \".repeat(end - start) + body.slice(end);\n  }\n\n  // Process imports in reverse order to preserve string indices\n  let result = code;\n  for (let i = entries.length - 1; i >= 0; i--) {\n    const entry = entries[i]!;\n    const kept: string[] = [];\n\n    for (const spec of entry.specifiers) {\n      // \"A as B\" → local name is B; \"A\" → local name is A\n      const localName = getImportedLocalName(spec);\n\n      // Keep if referenced anywhere in the body as a whole word\n      if (createImportedNameReferenceRegex(localName).test(body)) {\n        kept.push(spec);\n      }\n    }\n\n    // Nothing changed for this import\n    if (kept.length === entry.specifiers.length) continue;\n\n    let replacement: string;\n    if (kept.length === 0 && !entry.defaultPart) {\n      // All named specifiers gone, no default → remove entire import\n      replacement = \"\";\n    } else if (kept.length === 0) {\n      // Default import survives, named specifiers all gone\n      const def = entry.defaultPart.replace(/\\s*,\\s*$/, \"\").trim();\n      replacement = `import ${def} from '${entry.modulePath}';`;\n    } else {\n      replacement = `import ${entry.defaultPart}{ ${kept.join(\", \")} } from '${entry.modulePath}';`;\n    }\n\n    result = result.slice(0, entry.start) + replacement + result.slice(entry.end);\n  }\n\n  return result;\n}\n\n// ─── Type-only export placeholders ───────────────────────────────────────────\n\n/**\n * Find export names that are type-only (will vanish after stripping).\n */\nfunction findTypeOnlyExports(code: string): string[] {\n  const names = new Set<string>();\n  let m: RegExpExecArray | null;\n\n  // export interface Name  /  export interface Name<T>\n  const iface = /\\bexport\\s+interface\\s+(\\w+)/g;\n  while ((m = iface.exec(code)) !== null) names.add(m[1]!);\n\n  // export type Name = ...  /  export type Name<T> = ...\n  // (but NOT `export type { ... }`)\n  const alias = /\\bexport\\s+type\\s+(\\w+)\\s*[=<]/g;\n  while ((m = alias.exec(code)) !== null) names.add(m[1]!);\n\n  // export type { A, B }  /  export type { A } from './mod.mjs'\n  const reExport = /\\bexport\\s+type\\s*\\{([^}]+)\\}/g;\n  while ((m = reExport.exec(code)) !== null) {\n    for (const item of m[1]!.split(\",\")) {\n      const trimmed = item.trim();\n      const asMatch = trimmed.match(/\\w+\\s+as\\s+(\\w+)/);\n      if (asMatch) names.add(asMatch[1]!);\n      else if (/^\\w+$/.test(trimmed)) names.add(trimmed);\n    }\n  }\n\n  return [...names];\n}\n\n/**\n * Check if a name is still exported as a runtime value in the stripped code.\n */\nfunction isValueExported(name: string, code: string): boolean {\n  const e = escapeRegExp(name);\n  if (new RegExp(`\\\\bexport\\\\s+(?:var|let|const|function|class|async\\\\s+function)\\\\s+${e}\\\\b`).test(code)) return true;\n  if (new RegExp(`\\\\bexport\\\\s*\\\\{[^}]*\\\\b${e}\\\\b[^}]*\\\\}`).test(code)) return true;\n  if (name === \"default\" && /\\bexport\\s+default\\b/.test(code)) return true;\n  return false;\n}\n\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "B176F605C44FE67E64756E2164756E21",
+  "names": []
+}