@hakobu/hakobu 1.0.0

package/lib-es5/esm-hooks.js

@@ -0,0 +1,366 @@
+"use strict";
+/**
+ * Hakobu ESM Loader Hooks — hook code generator
+ *
+ * Generates the self-contained JavaScript code that runs inside Node's
+ * loader thread via module.register(). The code is passed as a data: URL
+ * because the loader thread cannot import from the main thread's modules.
+ *
+ * The hook code receives snapshot data via initialize() and serves
+ * resolve/load for snapshot-owned modules.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHookSource = void 0;
+/**
+ * Returns the self-contained ESM hook source code as a string.
+ * This code will be registered via module.register('data:text/javascript,...')
+ */
+function getHookSource() {
+    return HOOK_SOURCE;
+}
+exports.getHookSource = getHookSource;
+// The actual hook source code. This is a self-contained ES module
+// that runs in Node's loader worker thread.
+const HOOK_SOURCE = `
+// ── Snapshot data (populated by initialize) ──
+let entries;     // Map<path, {offset, size, format}>
+let packages;    // Map<path, {type, main, directory}>
+let blob;        // Uint8Array
+let appId;
+let dirSet;      // Set<path> for directory existence
+
+const BUILTINS = new Set([
+  'assert','assert/strict','async_hooks','buffer','child_process',
+  'cluster','console','constants','crypto','dgram',
+  'diagnostics_channel','dns','dns/promises','domain','events',
+  'fs','fs/promises','http','http2','https','inspector',
+  'inspector/promises','module','net','os','path','path/posix',
+  'path/win32','perf_hooks','process','punycode','querystring',
+  'readline','readline/promises','repl','stream','stream/consumers',
+  'stream/promises','stream/web','string_decoder','sys','test',
+  'timers','timers/promises','tls','trace_events','tty','url',
+  'util','util/types','v8','vm','wasi','worker_threads','zlib',
+  'sqlite',
+]);
+
+function isBuiltin(s) {
+  if (s.startsWith('node:')) return true;
+  return BUILTINS.has(s);
+}
+
+function isSnapshotUrl(url) {
+  return url.startsWith('file:///snapshot/');
+}
+
+function urlToPath(url) {
+  if (!url.startsWith('file:///snapshot/')) return null;
+  return '/snapshot/' + url.slice('file:///snapshot/'.length);
+}
+
+function pathToUrl(p) {
+  return 'file://' + p;
+}
+
+function canonicalize(p) {
+  const parts = p.split('/');
+  const result = [];
+  for (const part of parts) {
+    if (part === '' || part === '.') continue;
+    if (part === '..') { result.pop(); continue; }
+    result.push(part);
+  }
+  return '/' + result.join('/');
+}
+
+function extname(p) {
+  const dot = p.lastIndexOf('.');
+  const slash = p.lastIndexOf('/');
+  if (dot <= slash) return '';
+  return p.slice(dot);
+}
+
+function dirname(p) {
+  return p.substring(0, p.lastIndexOf('/')) || '/';
+}
+
+const RESOLVE_EXTS = ['.js','.mjs','.cjs','.json','.node'];
+
+function exists(p) {
+  return entries.has(p) || dirSet.has(p);
+}
+
+function isFile(p) {
+  return entries.has(p);
+}
+
+function isDir(p) {
+  return dirSet.has(p);
+}
+
+function tryFile(p) {
+  if (isFile(p)) return p;
+  for (const ext of RESOLVE_EXTS) {
+    if (isFile(p + ext)) return p + ext;
+  }
+  if (isDir(p)) {
+    const pjPath = p + '/package.json';
+    if (isFile(pjPath) && packages.has(pjPath)) {
+      const pkg = packages.get(pjPath);
+      if (pkg.main) {
+        const mainPath = canonicalize(p + '/' + pkg.main);
+        const resolved = tryFile(mainPath);
+        if (resolved) return resolved;
+      }
+    }
+    for (const ext of RESOLVE_EXTS) {
+      if (isFile(p + '/index' + ext)) return p + '/index' + ext;
+    }
+  }
+  return null;
+}
+
+function getFormat(p) {
+  const ext = extname(p);
+  if (ext === '.mjs') return 'module';
+  if (ext === '.cjs') return 'commonjs';
+  if (ext === '.json') return 'json';
+  if (ext === '.wasm') return 'wasm';
+  const entry = entries.get(p);
+  if (entry?.format === 'esm') return 'module';
+  if (entry?.format === 'cjs') return 'commonjs';
+  return 'commonjs';
+}
+
+// ── exports/imports resolution (Node algorithm) ──
+
+const ESM_CONDS = ['import', 'node', 'default'];
+
+function resolveTarget(target, conds) {
+  if (typeof target === 'string') return target;
+  if (target === null) return null;
+  if (Array.isArray(target)) {
+    for (const t of target) { const r = resolveTarget(t, conds); if (r) return r; }
+    return null;
+  }
+  if (typeof target === 'object') {
+    for (const c of conds) { if (c in target) return resolveTarget(target[c], conds); }
+    return null;
+  }
+  return null;
+}
+
+function resolveExportsMap(exportsVal, subpath, conds) {
+  if (exportsVal == null) return null;
+  if (typeof exportsVal === 'string') return subpath === '.' ? exportsVal : null;
+  if (Array.isArray(exportsVal)) return resolveTarget(exportsVal, conds);
+  if (typeof exportsVal !== 'object') return null;
+  const keys = Object.keys(exportsVal);
+  const isCondObj = keys.length > 0 && !keys[0].startsWith('.');
+  if (isCondObj) return subpath === '.' ? resolveTarget(exportsVal, conds) : null;
+  if (subpath in exportsVal) return resolveTarget(exportsVal[subpath], conds);
+  for (const key of keys) {
+    if (!key.includes('*')) continue;
+    const si = key.indexOf('*'), pre = key.slice(0, si), suf = key.slice(si + 1);
+    if (subpath.startsWith(pre) && subpath.endsWith(suf)) {
+      const matched = subpath.slice(pre.length, subpath.length - (suf.length || Infinity));
+      const t = resolveTarget(exportsVal[key], conds);
+      if (t && typeof t === 'string') return t.replace('*', matched);
+    }
+  }
+  return null;
+}
+
+function resolveImportsMap(importsVal, spec, conds) {
+  if (!importsVal || typeof importsVal !== 'object' || !spec.startsWith('#')) return null;
+  if (spec in importsVal) return resolveTarget(importsVal[spec], conds);
+  for (const key of Object.keys(importsVal)) {
+    if (!key.includes('*')) continue;
+    const si = key.indexOf('*'), pre = key.slice(0, si), suf = key.slice(si + 1);
+    if (spec.startsWith(pre) && spec.endsWith(suf)) {
+      const matched = spec.slice(pre.length, spec.length - (suf.length || Infinity));
+      const t = resolveTarget(importsVal[key], conds);
+      if (t && typeof t === 'string') return t.replace('*', matched);
+    }
+  }
+  return null;
+}
+
+function findPackageDir(filePath) {
+  let dir = dirname(filePath);
+  const root = '/snapshot/' + appId;
+  while (dir.startsWith(root)) {
+    const pj = dir + '/package.json';
+    if (packages.has(pj)) return packages.get(pj);
+    dir = dirname(dir);
+  }
+  return null;
+}
+
+export function initialize(data) {
+  entries = new Map(Object.entries(data.entries));
+  packages = new Map(Object.entries(data.packages));
+  blob = new Uint8Array(data.blob);
+  appId = data.appId;
+  dirSet = new Set(data.directories);
+}
+
+// In Node 24+, hooks handle both ESM and CJS resolution.
+// For ESM: shortCircuit and let the load hook provide source.
+// For CJS nested requires (context.conditions includes 'require'):
+//   let nextResolve fall through to Module._resolveFilename + _compile
+//   patches on the main thread, which can read from the snapshot.
+// For CJS imported by ESM (top-level): shortCircuit so the load hook
+//   provides the source to the ESM translator.
+function maybeShortCircuit(url, format, nextResolve, specifier, context) {
+  if (format === 'commonjs' && context.conditions && context.conditions.includes('require')) {
+    // Nested CJS require — let the main thread's _resolveFilename handle it
+    return nextResolve(specifier, context);
+  }
+  return { url, shortCircuit: true, format };
+}
+
+export function resolve(specifier, context, nextResolve) {
+  if (isBuiltin(specifier)) {
+    return nextResolve(specifier, context);
+  }
+
+  const parentUrl = context.parentURL;
+
+  // Only handle snapshot-parented resolution
+  if (!parentUrl || !isSnapshotUrl(parentUrl)) {
+    // Entry point or non-snapshot parent
+    if (specifier.startsWith('file:///snapshot/')) {
+      const snapPath = urlToPath(specifier);
+      if (snapPath && isFile(snapPath)) {
+        return maybeShortCircuit(specifier, getFormat(snapPath), nextResolve, specifier, context);
+      }
+    }
+    return nextResolve(specifier, context);
+  }
+
+  const parentPath = urlToPath(parentUrl);
+  if (!parentPath) return nextResolve(specifier, context);
+
+  // #-prefixed package imports
+  if (specifier.startsWith('#')) {
+    const pkg = findPackageDir(parentPath);
+    if (pkg) {
+      // Read full package.json to get imports field
+      const pjEntry = entries.get(pkg.directory + '/package.json');
+      if (pjEntry) {
+        const pjSource = new TextDecoder().decode(blob.slice(pjEntry.offset, pjEntry.offset + pjEntry.size));
+        const pjData = JSON.parse(pjSource);
+        if (pjData.imports) {
+          const resolved = resolveImportsMap(pjData.imports, specifier, ESM_CONDS);
+          if (resolved) {
+            const fullPath = canonicalize(pkg.directory + '/' + resolved);
+            const fileResolved = tryFile(fullPath);
+            if (fileResolved) {
+              return maybeShortCircuit(pathToUrl(fileResolved), getFormat(fileResolved), nextResolve, specifier, context);
+            }
+          }
+        }
+      }
+    }
+    return nextResolve(specifier, context);
+  }
+
+  // Relative specifier
+  if (specifier.startsWith('.') || specifier.startsWith('/')) {
+    const parentDir = dirname(parentPath);
+    const target = canonicalize(parentDir + '/' + specifier);
+    if (!target.startsWith('/snapshot/')) return nextResolve(specifier, context);
+    const resolved = tryFile(target);
+    if (resolved) {
+      return maybeShortCircuit(pathToUrl(resolved), getFormat(resolved), nextResolve, specifier, context);
+    }
+    throw new Error(
+      'Cannot find module \\'' + specifier + '\\' imported from ' + parentUrl
+    );
+  }
+
+  // Bare specifier — walk node_modules
+  const pkgName = specifier.startsWith('@')
+    ? specifier.split('/').slice(0, 2).join('/')
+    : specifier.split('/')[0];
+  const subpath = '.' + specifier.slice(pkgName.length);
+
+  let searchDir = dirname(parentPath);
+  const snapRoot = '/snapshot/' + appId;
+
+  while (searchDir.startsWith(snapRoot)) {
+    const nmDir = searchDir + '/node_modules/' + pkgName;
+    if (isDir(nmDir)) {
+      const pkgPjPath = nmDir + '/package.json';
+      const pkgPj = packages.get(pkgPjPath);
+
+      // Read full package.json for exports
+      const pjEntry = entries.get(pkgPjPath);
+      let exportsVal = null;
+      if (pjEntry) {
+        try {
+          const pjSource = new TextDecoder().decode(blob.slice(pjEntry.offset, pjEntry.offset + pjEntry.size));
+          const pjData = JSON.parse(pjSource);
+          exportsVal = pjData.exports;
+        } catch {}
+      }
+
+      // If exports is present, use it exclusively (Node semantics)
+      if (exportsVal != null) {
+        const resolved = resolveExportsMap(exportsVal, subpath, ESM_CONDS);
+        if (resolved && typeof resolved === 'string') {
+          const fullPath = canonicalize(nmDir + '/' + resolved);
+          const fileResolved = tryFile(fullPath);
+          if (fileResolved) {
+            return maybeShortCircuit(pathToUrl(fileResolved), getFormat(fileResolved), nextResolve, specifier, context);
+          }
+        }
+        // exports present but couldn't resolve — do NOT fall back
+        return nextResolve(specifier, context);
+      }
+
+      // Legacy resolution (no exports)
+      if (subpath === '.') {
+        if (pkgPj?.main) {
+          const resolved = tryFile(canonicalize(nmDir + '/' + pkgPj.main));
+          if (resolved) {
+            return maybeShortCircuit(pathToUrl(resolved), getFormat(resolved), nextResolve, specifier, context);
+          }
+        }
+        const resolved = tryFile(nmDir + '/index');
+        if (resolved) {
+          return maybeShortCircuit(pathToUrl(resolved), getFormat(resolved), nextResolve, specifier, context);
+        }
+      } else {
+        const resolved = tryFile(canonicalize(nmDir + '/' + subpath.slice(2)));
+        if (resolved) {
+          return maybeShortCircuit(pathToUrl(resolved), getFormat(resolved), nextResolve, specifier, context);
+        }
+      }
+      return nextResolve(specifier, context);
+    }
+    searchDir = dirname(searchDir);
+  }
+
+  return nextResolve(specifier, context);
+}
+
+export function load(url, context, nextLoad) {
+  if (!isSnapshotUrl(url)) {
+    return nextLoad(url, context);
+  }
+
+  const snapPath = urlToPath(url);
+  if (!snapPath) return nextLoad(url, context);
+
+  const entry = entries.get(snapPath);
+  if (!entry) return nextLoad(url, context);
+
+  const sourceBytes = blob.slice(entry.offset, entry.offset + entry.size);
+  const source = new TextDecoder().decode(sourceBytes);
+  const format = getFormat(snapPath);
+
+  return { source, format, shortCircuit: true };
+}
+`;
+//# sourceMappingURL=esm-hooks.js.map

package/lib-es5/esm-resolver.js

@@ -0,0 +1,292 @@
+"use strict";
+/**
+ * Hakobu ESM Resolver
+ *
+ * Resolves ESM specifiers against the snapshot filesystem and provides
+ * module source + format for loading. This is the core resolution logic
+ * used by the ESM loader hooks.
+ *
+ * Resolution follows Node 24 semantics:
+ *   1. Built-in modules (node:*) → passthrough
+ *   2. Absolute/relative specifiers → resolve within snapshot
+ *   3. Bare specifiers → resolve through snapshot node_modules
+ *   4. file: URLs → convert to snapshot path and resolve
+ *
+ * Format determination:
+ *   .mjs → 'module'
+ *   .cjs → 'commonjs'
+ *   .js  → determined by nearest package.json "type" field
+ *   .json → 'json'
+ *   .wasm → 'wasm'
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESMResolver = void 0;
+const path_1 = __importDefault(require("path"));
+const snapshot_path_1 = require("./snapshot-path");
+const exports_resolver_1 = require("./exports-resolver");
+// ─────────────────────────────────────────────────────────────────────
+// Built-in detection
+// ─────────────────────────────────────────────────────────────────────
+const BUILTINS = new Set([
+    'assert', 'assert/strict', 'async_hooks', 'buffer', 'child_process',
+    'cluster', 'console', 'constants', 'crypto', 'dgram',
+    'diagnostics_channel', 'dns', 'dns/promises', 'domain', 'events',
+    'fs', 'fs/promises', 'http', 'http2', 'https', 'inspector',
+    'inspector/promises', 'module', 'net', 'os', 'path', 'path/posix',
+    'path/win32', 'perf_hooks', 'process', 'punycode', 'querystring',
+    'readline', 'readline/promises', 'repl', 'stream', 'stream/consumers',
+    'stream/promises', 'stream/web', 'string_decoder', 'sys', 'test',
+    'timers', 'timers/promises', 'tls', 'trace_events', 'tty', 'url',
+    'util', 'util/types', 'v8', 'vm', 'wasi', 'worker_threads', 'zlib',
+    'sqlite',
+]);
+function isBuiltin(specifier) {
+    if (specifier.startsWith('node:'))
+        return true;
+    return BUILTINS.has(specifier);
+}
+// ─────────────────────────────────────────────────────────────────────
+// Format determination
+// ─────────────────────────────────────────────────────────────────────
+function determineFormat(snapshotPath, sfs) {
+    const ext = path_1.default.extname(snapshotPath);
+    // Extension-based (definitive)
+    if (ext === '.mjs')
+        return 'module';
+    if (ext === '.cjs')
+        return 'commonjs';
+    if (ext === '.json')
+        return 'json';
+    if (ext === '.wasm')
+        return 'wasm';
+    // .js — use pre-resolved format from snapshot index
+    const format = sfs.getModuleFormat(snapshotPath);
+    if (format === 'esm')
+        return 'module';
+    if (format === 'cjs')
+        return 'commonjs';
+    // Fallback: check package boundary type
+    const boundary = sfs.getPackageBoundary(snapshotPath);
+    if (boundary?.type === 'module')
+        return 'module';
+    return 'commonjs';
+}
+// ─────────────────────────────────────────────────────────────────────
+// Resolution extensions
+// ─────────────────────────────────────────────────────────────────────
+const RESOLVE_EXTENSIONS = ['.js', '.mjs', '.cjs', '.json', '.node'];
+function tryResolveFile(snapshotPath, sfs) {
+    // Exact match
+    if (sfs.existsSync(snapshotPath) && sfs.statSync(snapshotPath).isFile()) {
+        return snapshotPath;
+    }
+    // Try extensions
+    for (const ext of RESOLVE_EXTENSIONS) {
+        const withExt = snapshotPath + ext;
+        if (sfs.existsSync(withExt) && sfs.statSync(withExt).isFile()) {
+            return withExt;
+        }
+    }
+    // Directory with index
+    if (sfs.existsSync(snapshotPath) && sfs.statSync(snapshotPath).isDirectory()) {
+        // Check package.json main
+        const pjPath = snapshotPath + '/package.json';
+        if (sfs.existsSync(pjPath)) {
+            const pj = sfs.getPackage(pjPath);
+            if (pj?.main) {
+                const mainPath = (0, snapshot_path_1.toCanonical)(snapshotPath + '/' + pj.main);
+                const resolved = tryResolveFile(mainPath, sfs);
+                if (resolved)
+                    return resolved;
+            }
+        }
+        // Index file fallback
+        for (const ext of RESOLVE_EXTENSIONS) {
+            const indexPath = snapshotPath + '/index' + ext;
+            if (sfs.existsSync(indexPath))
+                return indexPath;
+        }
+    }
+    return null;
+}
+// ─────────────────────────────────────────────────────────────────────
+// ESM Resolver
+// ─────────────────────────────────────────────────────────────────────
+class ESMResolver {
+    sfs;
+    constructor(sfs) {
+        this.sfs = sfs;
+    }
+    /**
+     * Resolve a specifier to a snapshot file: URL and format.
+     *
+     * @param specifier - The import specifier (e.g., './helper.js', 'express', 'node:fs')
+     * @param parentUrl - The file: URL of the importing module
+     * @returns ResolveResult or null if the specifier should be handled by Node's default loader
+     */
+    resolve(specifier, parentUrl) {
+        // 1. Built-ins — let Node handle
+        if (isBuiltin(specifier))
+            return null;
+        // 2. file: URL specifier
+        if (specifier.startsWith('file://')) {
+            const snapshotPath = (0, snapshot_path_1.fromFileUrl)(specifier);
+            if (snapshotPath) {
+                return this.resolveSnapshotPath(snapshotPath, specifier);
+            }
+            return null; // non-snapshot file: URL → Node handles it
+        }
+        // 3. #-prefixed package imports
+        if (specifier.startsWith('#')) {
+            return this.resolvePackageImports(specifier, parentUrl);
+        }
+        // 4. Relative specifier (./foo, ../bar, /snapshot/...)
+        if (specifier.startsWith('.') || specifier.startsWith('/')) {
+            return this.resolveRelative(specifier, parentUrl);
+        }
+        // 5. Bare specifier (package name)
+        return this.resolveBare(specifier, parentUrl);
+    }
+    /**
+     * Load a snapshot module's source and format.
+     *
+     * @param url - The resolved file: URL
+     * @returns LoadResult or null if the URL is not a snapshot module
+     */
+    load(url) {
+        const snapshotPath = (0, snapshot_path_1.fromFileUrl)(url);
+        if (!snapshotPath)
+            return null;
+        if (!this.sfs.existsSync(snapshotPath))
+            return null;
+        const source = this.sfs.readFileSync(snapshotPath).toString('utf8');
+        const format = determineFormat(snapshotPath, this.sfs);
+        return { source, format };
+    }
+    // ── Internal resolution ──
+    resolveSnapshotPath(snapshotPath, originalSpecifier) {
+        const resolved = tryResolveFile(snapshotPath, this.sfs);
+        if (!resolved)
+            return null;
+        return {
+            url: (0, snapshot_path_1.toFileUrl)(resolved),
+            snapshotPath: resolved,
+            format: determineFormat(resolved, this.sfs),
+        };
+    }
+    resolveRelative(specifier, parentUrl) {
+        // Convert parent URL to snapshot path
+        const parentSnapshotPath = (0, snapshot_path_1.fromFileUrl)(parentUrl);
+        if (!parentSnapshotPath)
+            return null; // parent is not in snapshot
+        // Resolve relative to parent directory
+        const parentDir = parentSnapshotPath.substring(0, parentSnapshotPath.lastIndexOf('/'));
+        const targetPath = (0, snapshot_path_1.toCanonical)(parentDir + '/' + specifier);
+        // Only resolve within snapshot
+        if (!targetPath.startsWith('/snapshot/'))
+            return null;
+        return this.resolveSnapshotPath(targetPath, specifier);
+    }
+    resolveBare(specifier, parentUrl) {
+        const parentSnapshotPath = (0, snapshot_path_1.fromFileUrl)(parentUrl);
+        if (!parentSnapshotPath)
+            return null;
+        const pkgName = specifier.startsWith('@')
+            ? specifier.split('/').slice(0, 2).join('/')
+            : specifier.split('/')[0];
+        const subpath = '.' + specifier.slice(pkgName.length);
+        let searchDir = parentSnapshotPath.substring(0, parentSnapshotPath.lastIndexOf('/'));
+        const snapshotRoot = '/snapshot/' + this.sfs.getAppId();
+        while (searchDir.startsWith(snapshotRoot)) {
+            const nmDir = searchDir + '/node_modules/' + pkgName;
+            if (this.sfs.existsSync(nmDir)) {
+                const pkgJsonPath = nmDir + '/package.json';
+                const pkg = this.sfs.existsSync(pkgJsonPath) ? this.sfs.getPackage(pkgJsonPath) : null;
+                // ── exports map resolution ──
+                // When "exports" is present, Node ONLY uses the exports map
+                // for bare specifier resolution. "main" is ignored.
+                if (pkg?.exports != null) {
+                    const resolved = (0, exports_resolver_1.resolveExports)(pkg.exports, subpath, exports_resolver_1.ESM_CONDITIONS);
+                    if (resolved && typeof resolved === 'string') {
+                        const fullPath = (0, snapshot_path_1.toCanonical)(nmDir + '/' + resolved);
+                        const fileResolved = tryResolveFile(fullPath, this.sfs);
+                        if (fileResolved) {
+                            return {
+                                url: (0, snapshot_path_1.toFileUrl)(fileResolved),
+                                snapshotPath: fileResolved,
+                                format: determineFormat(fileResolved, this.sfs),
+                            };
+                        }
+                    }
+                    // exports map present but resolution failed — do NOT fall
+                    // back to main/index (Node doesn't). Return null so the
+                    // diagnostic layer can report the error.
+                    return null;
+                }
+                // ── Legacy resolution (no exports map) ──
+                if (subpath === '.') {
+                    if (pkg?.main) {
+                        const mainResolved = tryResolveFile((0, snapshot_path_1.toCanonical)(nmDir + '/' + pkg.main), this.sfs);
+                        if (mainResolved) {
+                            return {
+                                url: (0, snapshot_path_1.toFileUrl)(mainResolved),
+                                snapshotPath: mainResolved,
+                                format: determineFormat(mainResolved, this.sfs),
+                            };
+                        }
+                    }
+                    const indexResolved = tryResolveFile(nmDir + '/index', this.sfs);
+                    if (indexResolved) {
+                        return {
+                            url: (0, snapshot_path_1.toFileUrl)(indexResolved),
+                            snapshotPath: indexResolved,
+                            format: determineFormat(indexResolved, this.sfs),
+                        };
+                    }
+                }
+                else {
+                    const subResolved = tryResolveFile((0, snapshot_path_1.toCanonical)(nmDir + '/' + subpath.slice(2)), this.sfs);
+                    if (subResolved) {
+                        return {
+                            url: (0, snapshot_path_1.toFileUrl)(subResolved),
+                            snapshotPath: subResolved,
+                            format: determineFormat(subResolved, this.sfs),
+                        };
+                    }
+                }
+                return null;
+            }
+            searchDir = searchDir.substring(0, searchDir.lastIndexOf('/'));
+        }
+        return null;
+    }
+    // ── #imports resolution ──
+    resolvePackageImports(specifier, parentUrl) {
+        const parentSnapshotPath = (0, snapshot_path_1.fromFileUrl)(parentUrl);
+        if (!parentSnapshotPath)
+            return null;
+        // Find the package boundary for the importing file
+        const boundary = this.sfs.getPackageBoundary(parentSnapshotPath);
+        if (!boundary?.imports)
+            return null;
+        const resolved = (0, exports_resolver_1.resolveImports)(boundary.imports, specifier, exports_resolver_1.ESM_CONDITIONS);
+        if (!resolved)
+            return null;
+        // Resolved target is relative to the package directory
+        const fullPath = (0, snapshot_path_1.toCanonical)(boundary.directory + '/' + resolved);
+        const fileResolved = tryResolveFile(fullPath, this.sfs);
+        if (fileResolved) {
+            return {
+                url: (0, snapshot_path_1.toFileUrl)(fileResolved),
+                snapshotPath: fileResolved,
+                format: determineFormat(fileResolved, this.sfs),
+            };
+        }
+        return null;
+    }
+}
+exports.ESMResolver = ESMResolver;
+//# sourceMappingURL=esm-resolver.js.map