@ricsam/isolate 0.0.1 → 0.1.1

package/dist/cjs/internal/module-loader/index.cjs

@@ -0,0 +1,240 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/internal/module-loader/index.ts
+var exports_module_loader = {};
+__export(exports_module_loader, {
+  virtualToHost: () => import_mappings2.virtualToHost,
+  resolveFilePath: () => import_resolve2.resolveFilePath,
+  processTypeScript: () => import_strip_types2.processTypeScript,
+  parseSpecifier: () => import_resolve2.parseSpecifier,
+  parseMappings: () => import_mappings2.parseMappings,
+  isTypeScriptFile: () => import_strip_types2.isTypeScriptFile,
+  isBareSpecifier: () => import_resolve2.isBareSpecifier,
+  findNodeModulesMapping: () => import_mappings2.findNodeModulesMapping,
+  findModuleAlias: () => import_mappings2.findModuleAlias,
+  detectFormat: () => import_resolve2.detectFormat,
+  defaultModuleLoader: () => defaultModuleLoader,
+  clearBundleCache: () => import_bundle2.clearBundleCache,
+  bundleSpecifier: () => import_bundle2.bundleSpecifier,
+  bundleHostFile: () => import_bundle2.bundleHostFile
+});
+module.exports = __toCommonJS(exports_module_loader);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_module = require("node:module");
+var import_mappings = require("./mappings.cjs");
+var import_resolve = require("./resolve.cjs");
+var import_bundle = require("./bundle.cjs");
+var import_strip_types = require("./strip-types.cjs");
+var import_mappings2 = require("./mappings.cjs");
+var import_resolve2 = require("./resolve.cjs");
+var import_bundle2 = require("./bundle.cjs");
+var import_strip_types2 = require("./strip-types.cjs");
+function defaultModuleLoader(...paths) {
+  const mappings = import_mappings.parseMappings(paths);
+  const nodeModulesMapping = import_mappings.findNodeModulesMapping(mappings);
+  const importerHostPathByVirtualPath = new Map;
+  const loader = async (moduleName, importer) => {
+    if (import_resolve.isBareSpecifier(moduleName)) {
+      const alias = import_mappings.findModuleAlias(moduleName, mappings);
+      if (alias) {
+        return handleModuleAlias(alias, importerHostPathByVirtualPath);
+      }
+      return handleBareSpecifier(moduleName, importer, nodeModulesMapping, mappings, importerHostPathByVirtualPath);
+    }
+    return handlePathSpecifier(moduleName, importer, mappings, importerHostPathByVirtualPath);
+  };
+  return loader;
+}
+async function handleBareSpecifier(specifier, importer, nodeModulesMapping, mappings, importerHostPathByVirtualPath) {
+  if (!nodeModulesMapping) {
+    throw new Error(`Cannot resolve bare specifier "${specifier}": no node_modules mapping configured. ` + `Add a mapping like { from: '/path/to/node_modules', to: '/node_modules' }.`);
+  }
+  const importerHostPath = resolveImporterHostPath(importer, mappings, importerHostPathByVirtualPath);
+  const fallbackImporterHostPath = import_node_path.default.join(import_node_path.default.dirname(nodeModulesMapping.hostBase), "__isolate_module_loader__.js");
+  const effectiveImporterHostPath = importerHostPath ?? fallbackImporterHostPath;
+  const importerResolutionPath = toRealPath(effectiveImporterHostPath);
+  const resolvedHostPath = resolveBareSpecifierWithNode(specifier, importerResolutionPath);
+  if (!resolvedHostPath) {
+    throw new Error(`Cannot resolve bare specifier "${specifier}" from importer "${importer.path}" ` + `(host importer: ${effectiveImporterHostPath}).`);
+  }
+  const rootDir = import_node_path.default.dirname(importerResolutionPath);
+  const { code } = await import_bundle.bundleSpecifier(specifier, rootDir);
+  const { packageName, subpath } = import_resolve.parseSpecifier(specifier);
+  const filename = subpath ? `${packageName}${subpath}.bundled.js`.split("/").pop() : `${packageName}.bundled.js`.split("/").pop();
+  const result = {
+    code,
+    filename,
+    resolveDir: nodeModulesMapping.virtualMount,
+    static: true
+  };
+  registerImporterHostPath(result, toRealPath(resolvedHostPath), importerHostPathByVirtualPath);
+  return result;
+}
+async function handleModuleAlias(alias, importerHostPathByVirtualPath) {
+  const { code } = await import_bundle.bundleHostFile(alias.hostBase);
+  const filename = alias.to.replace(/^@[^/]*\//, "").replace(/[^a-zA-Z0-9_.-]/g, "-") + ".bundled.js";
+  const result = {
+    code,
+    filename,
+    resolveDir: "/"
+  };
+  registerImporterHostPath(result, toRealPath(alias.hostBase), importerHostPathByVirtualPath);
+  return result;
+}
+async function handlePathSpecifier(specifier, importer, mappings, importerHostPathByVirtualPath) {
+  let virtualPath;
+  if (specifier.startsWith("/")) {
+    virtualPath = specifier;
+  } else {
+    virtualPath = import_node_path.default.posix.normalize(import_node_path.default.posix.join(importer.resolveDir, specifier));
+  }
+  const hostBasePath = import_mappings.virtualToHost(virtualPath, mappings);
+  if (!hostBasePath) {
+    throw new Error(`Cannot resolve "${specifier}" (virtual: ${virtualPath}): no mapping matches this path. ` + `Importer: ${importer.path}`);
+  }
+  const resolvedHostPath = import_resolve.resolveFilePath(hostBasePath);
+  if (!resolvedHostPath) {
+    throw new Error(`Cannot resolve "${specifier}" (host: ${hostBasePath}): file not found after extension probing. ` + `Importer: ${importer.path}`);
+  }
+  let code = import_node_fs.default.readFileSync(resolvedHostPath, "utf-8");
+  let resolvedFilename = import_node_path.default.basename(resolvedHostPath);
+  if (import_strip_types.isTypeScriptFile(resolvedHostPath)) {
+    code = import_strip_types.processTypeScript(code, resolvedHostPath);
+    resolvedFilename = resolvedFilename.replace(/\.(tsx?|mts|cts)$/, ".js");
+  }
+  const hostDir = import_node_path.default.dirname(resolvedHostPath);
+  let virtualDir = null;
+  for (const mapping of mappings) {
+    if (mapping.isGlob) {
+      if (hostDir === mapping.hostBase || hostDir.startsWith(mapping.hostBase + "/")) {
+        const relativePart = hostDir.slice(mapping.hostBase.length);
+        virtualDir = mapping.virtualMount + relativePart;
+        break;
+      }
+    } else {
+      const mappedHostDir = import_node_path.default.dirname(mapping.hostBase);
+      if (hostDir === mappedHostDir) {
+        virtualDir = import_node_path.default.posix.dirname(mapping.virtualMount);
+        break;
+      }
+    }
+  }
+  if (!virtualDir) {
+    virtualDir = import_node_path.default.posix.dirname(virtualPath);
+  }
+  const result = {
+    code,
+    filename: resolvedFilename,
+    resolveDir: virtualDir
+  };
+  registerImporterHostPath(result, toRealPath(resolvedHostPath), importerHostPathByVirtualPath);
+  return result;
+}
+function resolveImporterHostPath(importer, mappings, importerHostPathByVirtualPath) {
+  const cached = importerHostPathByVirtualPath.get(importer.path);
+  if (cached) {
+    return cached;
+  }
+  const mappedHostPath = import_mappings.virtualToHost(importer.path, mappings);
+  if (!mappedHostPath) {
+    return null;
+  }
+  const resolvedMappedPath = import_resolve.resolveFilePath(mappedHostPath);
+  if (resolvedMappedPath) {
+    return resolvedMappedPath;
+  }
+  if (exists(mappedHostPath)) {
+    return mappedHostPath;
+  }
+  return null;
+}
+function resolveBareSpecifierWithNode(specifier, importerHostPath) {
+  try {
+    const req = import_node_module.createRequire(importerHostPath);
+    return req.resolve(specifier);
+  } catch {
+    return null;
+  }
+}
+function registerImporterHostPath(moduleResult, hostPath, importerHostPathByVirtualPath) {
+  const virtualModulePath = import_node_path.default.posix.join(moduleResult.resolveDir, moduleResult.filename);
+  importerHostPathByVirtualPath.set(virtualModulePath, hostPath);
+}
+function toRealPath(inputPath) {
+  try {
+    return import_node_fs.default.realpathSync(inputPath);
+  } catch {
+    return inputPath;
+  }
+}
+function exists(filePath) {
+  try {
+    import_node_fs.default.accessSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+//# debugId=46F8055BE16B42FB64756E2164756E21

package/dist/cjs/internal/module-loader/index.cjs.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.cjs\";\nimport {\n  parseMappings,\n  virtualToHost,\n  findNodeModulesMapping,\n  findModuleAlias,\n  type MappingConfig,\n  type PathMapping,\n} from \"./mappings.cjs\";\nimport {\n  resolveFilePath,\n  parseSpecifier,\n  isBareSpecifier,\n} from \"./resolve.cjs\";\nimport { bundleSpecifier, bundleHostFile } from \"./bundle.cjs\";\nimport { isTypeScriptFile, processTypeScript } from \"./strip-types.cjs\";\n\nexport { parseMappings, virtualToHost, findNodeModulesMapping, findModuleAlias } from \"./mappings.cjs\";\nexport type { MappingConfig, PathMapping } from \"./mappings.cjs\";\nexport { resolveFilePath, detectFormat, parseSpecifier, isBareSpecifier } from \"./resolve.cjs\";\nexport { bundleSpecifier, bundleHostFile, clearBundleCache } from \"./bundle.cjs\";\nexport { isTypeScriptFile, processTypeScript } from \"./strip-types.cjs\";\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.cjs';\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": "46F8055BE16B42FB64756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,120 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/internal/module-loader/mappings.ts
+var exports_mappings = {};
+__export(exports_mappings, {
+  virtualToHost: () => virtualToHost,
+  parseMappings: () => parseMappings,
+  hostToVirtual: () => hostToVirtual,
+  findNodeModulesMapping: () => findNodeModulesMapping,
+  findModuleAlias: () => findModuleAlias
+});
+module.exports = __toCommonJS(exports_mappings);
+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);
+}
+
+//# debugId=EF2971DD05B91B6464756E2164756E21

package/dist/cjs/internal/module-loader/mappings.cjs.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": "EF2971DD05B91B6464756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,177 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/internal/module-loader/resolve.ts
+var exports_resolve = {};
+__export(exports_resolve, {
+  resolveFilePath: () => resolveFilePath,
+  parseSpecifier: () => parseSpecifier,
+  isBareSpecifier: () => isBareSpecifier,
+  detectFormat: () => detectFormat
+});
+module.exports = __toCommonJS(exports_resolve);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var EXTENSIONS = [
+  ".tsx",
+  ".jsx",
+  ".ts",
+  ".mjs",
+  ".js",
+  ".cjs",
+  ".json"
+];
+function resolveFilePath(basePath) {
+  if (isFile(basePath))
+    return basePath;
+  const dir = import_node_path.default.dirname(basePath);
+  const ext = import_node_path.default.extname(basePath);
+  const nameWithoutExt = import_node_path.default.basename(basePath, ext);
+  if (ext) {
+    const browserPath = import_node_path.default.join(dir, `${nameWithoutExt}.browser${ext}`);
+    if (isFile(browserPath))
+      return browserPath;
+    return null;
+  }
+  for (const probeExt of EXTENSIONS) {
+    const browserPath = import_node_path.default.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 = import_node_path.default.join(basePath, `index.browser${probeExt}`);
+      if (isFile(browserIndex))
+        return browserIndex;
+      const indexPath = import_node_path.default.join(basePath, `index${probeExt}`);
+      if (isFile(indexPath))
+        return indexPath;
+    }
+  }
+  return null;
+}
+function detectFormat(filePath, code) {
+  const ext = import_node_path.default.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 import_node_fs.default.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function isDirectory(p) {
+  try {
+    return import_node_fs.default.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+//# debugId=A471F9C1EDA796C564756E2164756E21

package/dist/cjs/internal/module-loader/resolve.cjs.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": "A471F9C1EDA796C564756E2164756E21",
+  "names": []
+}