@hakobu/hakobu 1.0.0

package/lib-es5/snapshot-fs-patch.js

@@ -0,0 +1,396 @@
+"use strict";
+/**
+ * Hakobu Snapshot Filesystem Patch
+ *
+ * Monkey-patches Node's `fs` module to intercept snapshot-owned paths
+ * and route them to SnapshotFS. Non-snapshot paths pass through to the
+ * real OS filesystem unchanged.
+ *
+ * This is the runtime integration layer. It follows the same pattern as
+ * the inherited pkg bootstrap.js but delegates to the clean SnapshotFS
+ * abstraction instead of the legacy VIRTUAL_FILESYSTEM.
+ *
+ * Usage (in the runtime bootstrap):
+ *   const { patchFS, unpatchFS } = require('./snapshot-fs-patch');
+ *   const sfs = new SnapshotFS(index, blob);
+ *   const restore = patchFS(sfs);
+ *   // ... app runs with patched fs ...
+ *   restore(); // optional cleanup
+ *
+ * Only sync operations are patched in this first slice.
+ * Async variants will be added when needed for the ESM loader.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchFS = void 0;
+const fs_1 = __importDefault(require("fs"));
+const module_1 = __importDefault(require("module"));
+const snapshot_fs_1 = require("./snapshot-fs");
+const snapshot_path_1 = require("./snapshot-path");
+const addon_extract_1 = require("./addon-extract");
+// ─────────────────────────────────────────────────────────────────────
+// Path coercion (Node passes string | Buffer | URL)
+// ─────────────────────────────────────────────────────────────────────
+function coercePath(p) {
+    if (typeof p === 'string')
+        return p;
+    if (Buffer.isBuffer(p))
+        return p.toString();
+    if (p instanceof URL) {
+        if (p.protocol === 'file:') {
+            // file:///snapshot/app/... → /snapshot/app/...
+            return process.platform === 'win32'
+                ? p.pathname.replace(/^\//, '')
+                : p.pathname;
+        }
+        return null; // non-file URL, let Node handle it
+    }
+    return null;
+}
+function isSnapshotArg(arg) {
+    const p = coercePath(arg);
+    return p !== null && (0, snapshot_fs_1.isSnapshotPath)(p);
+}
+// ─────────────────────────────────────────────────────────────────────
+// EROFS error for write operations
+// ─────────────────────────────────────────────────────────────────────
+function throwEROFS(syscall, arg) {
+    const p = coercePath(arg) ?? String(arg);
+    const err = new Error(`${syscall} EROFS: read-only file system, '${p}'`);
+    err.code = 'EROFS';
+    err.errno = -30;
+    err.syscall = syscall;
+    err.path = p;
+    throw err;
+}
+// ─────────────────────────────────────────────────────────────────────
+// Patch entry point
+// ─────────────────────────────────────────────────────────────────────
+/**
+ * Patch Node's `fs` module to route snapshot paths to the given
+ * SnapshotFS instance. Returns a restore function that undoes the patch.
+ */
+function patchFS(sfs) {
+    // Save originals
+    const orig = {
+        existsSync: fs_1.default.existsSync,
+        statSync: fs_1.default.statSync,
+        lstatSync: fs_1.default.lstatSync,
+        readFileSync: fs_1.default.readFileSync,
+        readdirSync: fs_1.default.readdirSync,
+        realpathSync: fs_1.default.realpathSync,
+        accessSync: fs_1.default.accessSync,
+        writeFileSync: fs_1.default.writeFileSync,
+        mkdirSync: fs_1.default.mkdirSync,
+        unlinkSync: fs_1.default.unlinkSync,
+        rmdirSync: fs_1.default.rmdirSync,
+        renameSync: fs_1.default.renameSync,
+        chmodSync: fs_1.default.chmodSync,
+        copyFileSync: fs_1.default.copyFileSync,
+    };
+    const origRealpathNative = fs_1.default.realpathSync.native;
+    // ── existsSync ──
+    fs_1.default.existsSync = function existsSync(path_) {
+        if (isSnapshotArg(path_)) {
+            return sfs.existsSync(coercePath(path_));
+        }
+        return orig.existsSync.call(fs_1.default, path_);
+    };
+    // ── statSync ──
+    fs_1.default.statSync = function statSync(path_, options) {
+        if (isSnapshotArg(path_)) {
+            try {
+                return sfs.statSync(coercePath(path_));
+            }
+            catch (e) {
+                if (options?.throwIfNoEntry === false && e.code === 'ENOENT') {
+                    return undefined;
+                }
+                throw e;
+            }
+        }
+        return orig.statSync.call(fs_1.default, path_, options);
+    };
+    // ── lstatSync ──
+    fs_1.default.lstatSync = function lstatSync(path_, options) {
+        if (isSnapshotArg(path_)) {
+            try {
+                return sfs.lstatSync(coercePath(path_));
+            }
+            catch (e) {
+                if (options?.throwIfNoEntry === false && e.code === 'ENOENT') {
+                    return undefined;
+                }
+                throw e;
+            }
+        }
+        return orig.lstatSync.call(fs_1.default, path_, options);
+    };
+    // ── readFileSync ──
+    fs_1.default.readFileSync = function readFileSync(path_, options_) {
+        if (isSnapshotArg(path_)) {
+            const p = coercePath(path_);
+            const buffer = sfs.readFileSync(p);
+            // Handle encoding option
+            const encoding = typeof options_ === 'string'
+                ? options_
+                : options_?.encoding ?? null;
+            if (encoding) {
+                return buffer.toString(encoding);
+            }
+            return buffer;
+        }
+        return orig.readFileSync.call(fs_1.default, path_, options_);
+    };
+    // ── readdirSync ──
+    fs_1.default.readdirSync = function readdirSync(path_, options_) {
+        if (isSnapshotArg(path_)) {
+            const entries = sfs.readdirSync(coercePath(path_));
+            // Handle withFileTypes option
+            if (options_?.withFileTypes) {
+                const p = coercePath(path_);
+                return entries.map((name) => {
+                    const fullPath = p.endsWith('/') ? p + name : p + '/' + name;
+                    const stat = sfs.existsSync(fullPath) ? sfs.statSync(fullPath) : null;
+                    return {
+                        name,
+                        isFile: () => stat?.isFile() ?? false,
+                        isDirectory: () => stat?.isDirectory() ?? false,
+                        isSymbolicLink: () => false,
+                        isBlockDevice: () => false,
+                        isCharacterDevice: () => false,
+                        isFIFO: () => false,
+                        isSocket: () => false,
+                    };
+                });
+            }
+            return entries;
+        }
+        return orig.readdirSync.call(fs_1.default, path_, options_);
+    };
+    // ── realpathSync ──
+    fs_1.default.realpathSync = function realpathSync(path_, options) {
+        if (isSnapshotArg(path_)) {
+            return sfs.realpathSync(coercePath(path_));
+        }
+        return orig.realpathSync.call(fs_1.default, path_, options);
+    };
+    // Preserve realpathSync.native
+    fs_1.default.realpathSync.native = function realpathSyncNative(path_, options) {
+        if (isSnapshotArg(path_)) {
+            return sfs.realpathSync(coercePath(path_));
+        }
+        return origRealpathNative.call(fs_1.default, path_, options);
+    };
+    // ── accessSync ──
+    fs_1.default.accessSync = function accessSync(path_, mode_) {
+        if (isSnapshotArg(path_)) {
+            const p = coercePath(path_);
+            // Read access always succeeds if the path exists
+            if (!sfs.existsSync(p)) {
+                const err = new Error(`ENOENT: no such file or directory, access '${p}'`);
+                err.code = 'ENOENT';
+                err.errno = -2;
+                err.syscall = 'access';
+                err.path = p;
+                throw err;
+            }
+            // Write access on snapshot paths fails
+            const W_OK = 2;
+            if (mode_ !== undefined && (mode_ & W_OK)) {
+                const err = new Error(`EROFS: read-only file system, access '${p}'`);
+                err.code = 'EROFS';
+                err.errno = -30;
+                err.syscall = 'access';
+                err.path = p;
+                throw err;
+            }
+            return; // read-only access OK
+        }
+        return orig.accessSync.call(fs_1.default, path_, mode_);
+    };
+    // ── Write operations → EROFS ──
+    fs_1.default.writeFileSync = function writeFileSync(path_, ...rest) {
+        if (isSnapshotArg(path_))
+            throwEROFS('write', path_);
+        return orig.writeFileSync.call(fs_1.default, path_, ...rest);
+    };
+    fs_1.default.mkdirSync = function mkdirSync(path_, ...rest) {
+        if (isSnapshotArg(path_))
+            throwEROFS('mkdir', path_);
+        return orig.mkdirSync.call(fs_1.default, path_, ...rest);
+    };
+    fs_1.default.unlinkSync = function unlinkSync(path_) {
+        if (isSnapshotArg(path_))
+            throwEROFS('unlink', path_);
+        return orig.unlinkSync.call(fs_1.default, path_);
+    };
+    fs_1.default.rmdirSync = function rmdirSync(path_, ...rest) {
+        if (isSnapshotArg(path_))
+            throwEROFS('rmdir', path_);
+        return orig.rmdirSync.call(fs_1.default, path_, ...rest);
+    };
+    fs_1.default.renameSync = function renameSync(oldPath, newPath) {
+        if (isSnapshotArg(oldPath) || isSnapshotArg(newPath)) {
+            throwEROFS('rename', isSnapshotArg(oldPath) ? oldPath : newPath);
+        }
+        return orig.renameSync.call(fs_1.default, oldPath, newPath);
+    };
+    fs_1.default.chmodSync = function chmodSync(path_, mode) {
+        if (isSnapshotArg(path_))
+            throwEROFS('chmod', path_);
+        return orig.chmodSync.call(fs_1.default, path_, mode);
+    };
+    fs_1.default.copyFileSync = function copyFileSync(src, dest, ...rest) {
+        if (isSnapshotArg(dest))
+            throwEROFS('copyfile', dest);
+        // Reading from snapshot is OK — write the data through host FS
+        if (isSnapshotArg(src)) {
+            const content = sfs.readFileSync(coercePath(src));
+            return orig.writeFileSync.call(fs_1.default, dest, content);
+        }
+        return orig.copyFileSync.call(fs_1.default, src, dest, ...rest);
+    };
+    // ── CJS Module resolution patch ──
+    // Node's require() uses Module._resolveFilename which calls internal
+    // C++ file operations that bypass our fs patches. We patch
+    // _resolveFilename to recognize snapshot paths directly.
+    const origResolveFilename = module_1.default._resolveFilename;
+    module_1.default._resolveFilename = function _resolveFilename(request, parent, isMain, options) {
+        let resolved = null;
+        // Absolute snapshot path
+        if (isSnapshotArg(request)) {
+            const p = coercePath(request);
+            if (sfs.existsSync(p))
+                resolved = p;
+        }
+        // Relative require from within snapshot (./foo, ../bar)
+        if (!resolved && (request.startsWith('.') || request.startsWith('/')) && parent?.filename && isSnapshotArg(parent.filename)) {
+            const parentDir = parent.filename.substring(0, parent.filename.lastIndexOf('/'));
+            const candidate = (0, snapshot_path_1.toCanonical)(parentDir + '/' + request);
+            resolved = tryResolveInSnapshot(candidate, sfs);
+        }
+        // Bare specifier from within snapshot (package name)
+        if (!resolved && parent?.filename && isSnapshotArg(parent.filename) && !request.startsWith('.') && !request.startsWith('/')) {
+            resolved = tryResolveBareInSnapshot(request, parent.filename, sfs);
+        }
+        if (resolved) {
+            // Native addons (.node) cannot be loaded from the snapshot via
+            // dlopen() — they must exist as real files. Extract to the
+            // deterministic cache and return the extracted path.
+            if (resolved.endsWith('.node') && (0, snapshot_fs_1.isSnapshotPath)(resolved)) {
+                const extracted = (0, addon_extract_1.extractAddon)(resolved, sfs);
+                return extracted.extractedPath;
+            }
+            return resolved;
+        }
+        return origResolveFilename.call(this, request, parent, isMain, options);
+    };
+    // (ensureSnapshotModuleCached removed — preloading is handled by bootstrap)
+    // Patch Module._compile to read snapshot source via SnapshotFS
+    // when the filename is a snapshot path.
+    const origCompile = module_1.default.prototype._compile;
+    module_1.default.prototype._compile = function _compile(content, filename) {
+        if (isSnapshotArg(filename)) {
+            // Read the real content from snapshot (the CJS loader may have
+            // passed empty or wrong content since the file doesn't exist
+            // on the real filesystem).
+            const p = coercePath(filename);
+            if (sfs.existsSync(p) && sfs.statSync(p).isFile()) {
+                content = sfs.readFileSync(p).toString('utf8');
+            }
+        }
+        return origCompile.call(this, content, filename);
+    };
+    // ── CJS resolution helpers ──
+    function tryResolveInSnapshot(candidate, sfsInst) {
+        const EXTS = ['.js', '.cjs', '.mjs', '.json', '.node'];
+        // Exact file
+        if (sfsInst.existsSync(candidate) && sfsInst.statSync(candidate).isFile())
+            return candidate;
+        // With extensions
+        for (const ext of EXTS) {
+            const withExt = candidate + ext;
+            if (sfsInst.existsSync(withExt) && sfsInst.statSync(withExt).isFile())
+                return withExt;
+        }
+        // Directory with index
+        if (sfsInst.existsSync(candidate) && sfsInst.statSync(candidate).isDirectory()) {
+            const pjPath = candidate + '/package.json';
+            if (sfsInst.existsSync(pjPath)) {
+                const pkg = sfsInst.getPackage(pjPath);
+                if (pkg?.main) {
+                    const mainPath = (0, snapshot_path_1.toCanonical)(candidate + '/' + pkg.main);
+                    const resolved = tryResolveInSnapshot(mainPath, sfsInst);
+                    if (resolved)
+                        return resolved;
+                }
+            }
+            for (const ext of EXTS) {
+                const indexPath = candidate + '/index' + ext;
+                if (sfsInst.existsSync(indexPath))
+                    return indexPath;
+            }
+        }
+        return null;
+    }
+    function tryResolveBareInSnapshot(specifier, parentFilename, sfsInst) {
+        const pkgName = specifier.startsWith('@')
+            ? specifier.split('/').slice(0, 2).join('/')
+            : specifier.split('/')[0];
+        const subpath = specifier.slice(pkgName.length);
+        const appId = sfsInst.getAppId();
+        const snapRoot = '/snapshot/' + appId;
+        let searchDir = parentFilename.substring(0, parentFilename.lastIndexOf('/'));
+        while (searchDir.startsWith(snapRoot)) {
+            const nmDir = searchDir + '/node_modules/' + pkgName;
+            if (sfsInst.existsSync(nmDir)) {
+                if (!subpath) {
+                    // Root import — check exports, then main, then index
+                    const pkgJsonPath = nmDir + '/package.json';
+                    const pkg = sfsInst.existsSync(pkgJsonPath) ? sfsInst.getPackage(pkgJsonPath) : null;
+                    if (pkg?.main) {
+                        const resolved = tryResolveInSnapshot((0, snapshot_path_1.toCanonical)(nmDir + '/' + pkg.main), sfsInst);
+                        if (resolved)
+                            return resolved;
+                    }
+                    const resolved = tryResolveInSnapshot(nmDir + '/index', sfsInst);
+                    if (resolved)
+                        return resolved;
+                }
+                else {
+                    const resolved = tryResolveInSnapshot((0, snapshot_path_1.toCanonical)(nmDir + subpath), sfsInst);
+                    if (resolved)
+                        return resolved;
+                }
+                return null;
+            }
+            searchDir = searchDir.substring(0, searchDir.lastIndexOf('/'));
+        }
+        return null;
+    }
+    // ── Restore function ──
+    return function unpatchFS() {
+        fs_1.default.existsSync = orig.existsSync;
+        fs_1.default.statSync = orig.statSync;
+        fs_1.default.lstatSync = orig.lstatSync;
+        fs_1.default.readFileSync = orig.readFileSync;
+        fs_1.default.readdirSync = orig.readdirSync;
+        fs_1.default.realpathSync = orig.realpathSync;
+        fs_1.default.realpathSync.native = origRealpathNative;
+        fs_1.default.accessSync = orig.accessSync;
+        fs_1.default.writeFileSync = orig.writeFileSync;
+        fs_1.default.mkdirSync = orig.mkdirSync;
+        fs_1.default.unlinkSync = orig.unlinkSync;
+        fs_1.default.rmdirSync = orig.rmdirSync;
+        fs_1.default.renameSync = orig.renameSync;
+        fs_1.default.chmodSync = orig.chmodSync;
+        fs_1.default.copyFileSync = orig.copyFileSync;
+        module_1.default._resolveFilename = origResolveFilename;
+        module_1.default.prototype._compile = origCompile;
+    };
+}
+exports.patchFS = patchFS;
+//# sourceMappingURL=snapshot-fs-patch.js.map

package/lib-es5/snapshot-fs.js

@@ -0,0 +1,255 @@
+"use strict";
+/**
+ * Hakobu Snapshot Filesystem
+ *
+ * A read-only virtual filesystem backed by a SnapshotIndex and a flat
+ * content blob. This is the runtime abstraction that sits between the
+ * Node fs patches and the actual snapshot data.
+ *
+ * The SnapshotFS:
+ * - serves file content from the blob
+ * - provides stat/lstat metadata
+ * - supports readdir for snapshot directories
+ * - resolves canonical (real) paths within the snapshot
+ * - detects whether a path is inside the snapshot
+ * - rejects all write operations with EROFS
+ *
+ * It does NOT:
+ * - monkey-patch Node's fs module (that's the runtime bootstrap's job)
+ * - implement ESM/CJS loading (that's Task 6)
+ * - handle native addon extraction (that's Task 9)
+ *
+ * All paths passed to this layer must be in the platform-native form
+ * that the runtime receives from Node (e.g., /snapshot/app/... on POSIX,
+ * C:\snapshot\app\... on Windows). The layer normalizes to POSIX
+ * internally for index lookup.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotFS = exports.toFileUrl = exports.toCanonical = exports.toNative = exports.isSnapshotPath = void 0;
+// Re-export path utilities from the canonical module
+var snapshot_path_1 = require("./snapshot-path");
+Object.defineProperty(exports, "isSnapshotPath", { enumerable: true, get: function () { return snapshot_path_1.isSnapshotPath; } });
+Object.defineProperty(exports, "toNative", { enumerable: true, get: function () { return snapshot_path_1.toNative; } });
+Object.defineProperty(exports, "toCanonical", { enumerable: true, get: function () { return snapshot_path_1.toCanonical; } });
+Object.defineProperty(exports, "toFileUrl", { enumerable: true, get: function () { return snapshot_path_1.toFileUrl; } });
+const snapshot_path_2 = require("./snapshot-path");
+// ─────────────────────────────────────────────────────────────────────
+// Error factories (match Node's error codes)
+// ─────────────────────────────────────────────────────────────────────
+function enoent(syscall, path) {
+    const err = new Error(`${syscall} ENOENT: no such file or directory, '${path}'`);
+    err.code = 'ENOENT';
+    err.errno = -2;
+    err.syscall = syscall;
+    err.path = path;
+    return err;
+}
+function enotdir(syscall, path) {
+    const err = new Error(`${syscall} ENOTDIR: not a directory, '${path}'`);
+    err.code = 'ENOTDIR';
+    err.errno = -20;
+    err.syscall = syscall;
+    err.path = path;
+    return err;
+}
+function erofs(syscall, path) {
+    const err = new Error(`${syscall} EROFS: read-only file system, '${path}'`);
+    err.code = 'EROFS';
+    err.errno = -30;
+    err.syscall = syscall;
+    err.path = path;
+    return err;
+}
+function eisdir(syscall, path) {
+    const err = new Error(`${syscall} EISDIR: illegal operation on a directory, '${path}'`);
+    err.code = 'EISDIR';
+    err.errno = -21;
+    err.syscall = syscall;
+    err.path = path;
+    return err;
+}
+// Fixed epoch for deterministic stat timestamps
+const EPOCH = new Date('2026-01-01T00:00:00Z');
+const EPOCH_MS = EPOCH.getTime();
+function fileStat(size) {
+    return {
+        isFile: () => true,
+        isDirectory: () => false,
+        isSymbolicLink: () => false,
+        size,
+        mode: 0o100644,
+        mtime: EPOCH, mtimeMs: EPOCH_MS,
+        atime: EPOCH, atimeMs: EPOCH_MS,
+        ctime: EPOCH, ctimeMs: EPOCH_MS,
+        birthtime: EPOCH, birthtimeMs: EPOCH_MS,
+    };
+}
+function dirStat() {
+    return {
+        isFile: () => false,
+        isDirectory: () => true,
+        isSymbolicLink: () => false,
+        size: 0,
+        mode: 0o40755,
+        mtime: EPOCH, mtimeMs: EPOCH_MS,
+        atime: EPOCH, atimeMs: EPOCH_MS,
+        ctime: EPOCH, ctimeMs: EPOCH_MS,
+        birthtime: EPOCH, birthtimeMs: EPOCH_MS,
+    };
+}
+// ─────────────────────────────────────────────────────────────────────
+// SnapshotFS
+// ─────────────────────────────────────────────────────────────────────
+class SnapshotFS {
+    index;
+    blob;
+    /** Entries keyed by POSIX snapshot path for O(1) lookup. */
+    entryMap;
+    constructor(index, blob) {
+        this.index = index;
+        this.blob = blob;
+        // Build O(1) entry map from the sorted array
+        this.entryMap = new Map();
+        for (const entry of index.entries) {
+            this.entryMap.set(entry.path, entry);
+        }
+    }
+    // ── Path classification ──
+    /** Check if a platform-native path is inside the snapshot. */
+    isSnapshot(nativePath) {
+        return (0, snapshot_path_2.isSnapshotPath)(nativePath);
+    }
+    // ── Existence ──
+    /** Check if a path exists in the snapshot (file or directory). */
+    existsSync(nativePath) {
+        const p = (0, snapshot_path_2.toCanonical)(nativePath);
+        return this.entryMap.has(p) || p in this.index.directories;
+    }
+    // ── Stat ──
+    /** Get file/directory metadata. Throws ENOENT if not found. */
+    statSync(nativePath) {
+        const p = (0, snapshot_path_2.toCanonical)(nativePath);
+        const entry = this.entryMap.get(p);
+        if (entry)
+            return fileStat(entry.size);
+        if (p in this.index.directories)
+            return dirStat();
+        throw enoent('stat', nativePath);
+    }
+    /** lstat is identical to stat — the snapshot has no symlinks. */
+    lstatSync(nativePath) {
+        return this.statSync(nativePath);
+    }
+    // ── Read file ──
+    /**
+     * Read file content from the blob.
+     * Returns a Buffer. Throws ENOENT or EISDIR.
+     */
+    readFileSync(nativePath) {
+        const p = (0, snapshot_path_2.toCanonical)(nativePath);
+        if (p in this.index.directories) {
+            throw eisdir('read', nativePath);
+        }
+        const entry = this.entryMap.get(p);
+        if (!entry)
+            throw enoent('open', nativePath);
+        return this.blob.subarray(entry.offset, entry.offset + entry.size);
+    }
+    // ── Read directory ──
+    /**
+     * List directory contents. Returns file and directory names (not paths).
+     * Throws ENOENT or ENOTDIR.
+     */
+    readdirSync(nativePath) {
+        const p = (0, snapshot_path_2.toCanonical)(nativePath);
+        // Check if it's a file, not a directory
+        if (this.entryMap.has(p)) {
+            throw enotdir('scandir', nativePath);
+        }
+        const dir = this.index.directories[p];
+        if (!dir)
+            throw enoent('scandir', nativePath);
+        return [...dir.files, ...dir.directories].sort();
+    }
+    // ── Realpath ──
+    /**
+     * Resolve canonical path within the snapshot.
+     * The snapshot has no symlinks, so this is just normalization.
+     * Returns the platform-native normalized path.
+     */
+    realpathSync(nativePath) {
+        const p = (0, snapshot_path_2.toCanonical)(nativePath);
+        if (!this.entryMap.has(p) && !(p in this.index.directories)) {
+            throw enoent('realpath', nativePath);
+        }
+        return (0, snapshot_path_2.toNative)(p);
+    }
+    // ── Write rejection ──
+    /** All write operations throw EROFS. */
+    writeFileSync(nativePath) {
+        throw erofs('write', nativePath);
+    }
+    mkdirSync(nativePath) {
+        throw erofs('mkdir', nativePath);
+    }
+    unlinkSync(nativePath) {
+        throw erofs('unlink', nativePath);
+    }
+    // ── Module metadata (for ESM/CJS loader integration) ──
+    /**
+     * Get the module format of a snapshot file.
+     * Returns null if the file is not a script or not found.
+     */
+    getModuleFormat(nativePath) {
+        const p = (0, snapshot_path_2.toCanonical)(nativePath);
+        const entry = this.entryMap.get(p);
+        return entry?.format ?? null;
+    }
+    /**
+     * Get the file kind of a snapshot file.
+     * Returns null if not found.
+     */
+    getFileKind(nativePath) {
+        const p = (0, snapshot_path_2.toCanonical)(nativePath);
+        const entry = this.entryMap.get(p);
+        return entry?.kind ?? null;
+    }
+    /**
+     * Get the package boundary (package.json) that governs a file.
+     * Returns the SnapshotPackageBoundary or null.
+     */
+    getPackageBoundary(nativePath) {
+        const p = (0, snapshot_path_2.toCanonical)(nativePath);
+        const entry = this.entryMap.get(p);
+        if (!entry?.packageBoundary)
+            return null;
+        return this.index.packages[entry.packageBoundary] ?? null;
+    }
+    /**
+     * Look up a package boundary by its package.json snapshot path.
+     */
+    getPackage(packageJsonPath) {
+        const p = (0, snapshot_path_2.toCanonical)(packageJsonPath);
+        return this.index.packages[p] ?? null;
+    }
+    // ── Index access ──
+    /** Get the snapshot entry for a path. */
+    getEntry(nativePath) {
+        const p = (0, snapshot_path_2.toCanonical)(nativePath);
+        return this.entryMap.get(p) ?? null;
+    }
+    /** Get the entrypoint path in platform-native form. */
+    getEntrypoint() {
+        return (0, snapshot_path_2.toNative)(this.index.entrypoint);
+    }
+    /** Get the entrypoint module format. */
+    getEntrypointFormat() {
+        return this.index.entrypointFormat;
+    }
+    /** Get the application ID. */
+    getAppId() {
+        return this.index.appId;
+    }
+}
+exports.SnapshotFS = SnapshotFS;
+//# sourceMappingURL=snapshot-fs.js.map