@scelar/nodepod 1.0.3 → 1.0.5

package/src/memory-volume.ts

@@ -3,6 +3,7 @@
 import type { VolumeSnapshot, VolumeEntry } from './engine-types';
 import { bytesToBase64, base64ToBytes } from './helpers/byte-encoding';
 import { MOCK_IDS, MOCK_FS } from './constants/config';
+import type { MemoryHandler } from './memory-handler';
 
 export interface VolumeNode {
   kind: 'file' | 'directory' | 'symlink';
@@ -172,8 +173,10 @@ export class MemoryVolume {
   private textDecoder = new TextDecoder();
   private activeWatchers = new Map<string, Set<ActiveWatcher>>();
   private subscribers = new Map<string, Set<VolumeEventHandler>>();
+  private _handler: MemoryHandler | null;
 
-  constructor() {
+  constructor(handler?: MemoryHandler | null) {
+    this._handler = handler ?? null;
     this.tree = {
       kind: 'directory',
       children: new Map(),
@@ -216,15 +219,61 @@ export class MemoryVolume {
     }
   }
 
+  // ---- Stats ----
+
+  getStats(): { fileCount: number; totalBytes: number; dirCount: number; watcherCount: number } {
+    let fileCount = 0;
+    let totalBytes = 0;
+    let dirCount = 0;
+    const walk = (node: VolumeNode) => {
+      if (node.kind === 'file') {
+        fileCount++;
+        totalBytes += node.content?.byteLength ?? 0;
+      } else if (node.kind === 'directory') {
+        dirCount++;
+        if (node.children) {
+          for (const child of node.children.values()) walk(child);
+        }
+      }
+    };
+    walk(this.tree);
+    let watcherCount = 0;
+    for (const set of this.activeWatchers.values()) watcherCount += set.size;
+    return { fileCount, totalBytes, dirCount, watcherCount };
+  }
+
+  /** Clean up all watchers, subscribers, and global listeners. */
+  dispose(): void {
+    this.activeWatchers.clear();
+    this.subscribers.clear();
+    this.globalChangeListeners.clear();
+    if (this._handler) {
+      this._handler.statCache.clear();
+      this._handler.pathNormCache.clear();
+    }
+  }
+
   // ---- Snapshot serialization ----
 
-  toSnapshot(): VolumeSnapshot {
+  toSnapshot(excludePrefixes?: string[], excludeDirNames?: Set<string>): VolumeSnapshot {
     const entries: VolumeEntry[] = [];
-    this.collectEntries('/', this.tree, entries);
+    this.collectEntries('/', this.tree, entries, excludePrefixes, excludeDirNames);
     return { entries };
   }
 
-  private collectEntries(currentPath: string, node: VolumeNode, result: VolumeEntry[]): void {
+  private collectEntries(
+    currentPath: string,
+    node: VolumeNode,
+    result: VolumeEntry[],
+    excludePrefixes?: string[],
+    excludeDirNames?: Set<string>,
+  ): void {
+    if (excludePrefixes) {
+      for (const prefix of excludePrefixes) {
+        if (currentPath === prefix || currentPath.startsWith(prefix + '/')) return;
+      }
+    }
+
     if (node.kind === 'file') {
       let data = '';
       if (node.content && node.content.length > 0) {
@@ -237,8 +286,10 @@ export class MemoryVolume {
       result.push({ path: currentPath, kind: 'directory' });
       if (node.children) {
         for (const [name, child] of node.children) {
+          // Skip excluded directory names at any depth (e.g. node_modules, .cache)
+          if (excludeDirNames && child.kind === 'directory' && excludeDirNames.has(name)) continue;
           const childPath = currentPath === '/' ? `/${name}` : `${currentPath}/${name}`;
-          this.collectEntries(childPath, child, result);
+          this.collectEntries(childPath, child, result, excludePrefixes, excludeDirNames);
         }
       }
     }
@@ -307,6 +358,10 @@ export class MemoryVolume {
   // ---- Path utilities ----
 
   private normalize(p: string): string {
+    if (this._handler) {
+      const cached = this._handler.pathNormCache.get(p);
+      if (cached !== undefined) return cached;
+    }
     if (!p.startsWith('/')) p = '/' + p;
     const parts = p.split('/').filter(Boolean);
     const resolved: string[] = [];
@@ -314,7 +369,9 @@ export class MemoryVolume {
       if (part === '..') resolved.pop();
       else if (part !== '.') resolved.push(part);
     }
-    return '/' + resolved.join('/');
+    const result = '/' + resolved.join('/');
+    if (this._handler) this._handler.pathNormCache.set(p, result);
+    return result;
   }
 
   // assumes pre-normalized input (starts with '/', no '..' or double slashes)
@@ -412,6 +469,8 @@ export class MemoryVolume {
       modified: Date.now(),
     });
 
+    if (this._handler) this._handler.invalidateStat(norm);
+
     if (notify) {
       this.triggerWatchers(norm, existed ? 'change' : 'rename');
       this.broadcast('change', norm, typeof data === 'string' ? data : this.textDecoder.decode(data));
@@ -427,13 +486,19 @@ export class MemoryVolume {
 
   statSync(p: string): FileStat {
     const norm = this.normalize(p);
+
+    if (this._handler) {
+      const cached = this._handler.statCache.get(norm);
+      if (cached !== undefined) return cached;
+    }
+
     const node = this.locate(norm);
     if (!node) throw makeSystemError('ENOENT', 'stat', p);
 
     const fileSize = node.kind === 'file' ? (node.content?.length || 0) : 0;
     const ts = node.modified;
 
-    return {
+    const result: FileStat = {
       isFile: () => node.kind === 'file',
       isDirectory: () => node.kind === 'directory',
       isSymbolicLink: () => false,
@@ -464,6 +529,9 @@ export class MemoryVolume {
       ctimeNs: BigInt(ts) * 1000000n,
       birthtimeNs: BigInt(ts) * 1000000n,
     };
+
+    if (this._handler) this._handler.statCache.set(norm, result);
+    return result;
   }
 
   lstatSync(p: string): FileStat {
@@ -573,6 +641,7 @@ export class MemoryVolume {
     if (target.kind !== 'file') throw makeSystemError('EISDIR', 'unlink', p);
 
     parent.children!.delete(name);
+    if (this._handler) this._handler.invalidateStat(norm);
     this.triggerWatchers(norm, 'rename');
     this.broadcast('delete', norm);
     this.notifyGlobalListeners(norm, 'unlink');
@@ -594,6 +663,7 @@ export class MemoryVolume {
     if (target.children!.size > 0) throw makeSystemError('ENOTEMPTY', 'rmdir', p);
 
     parent.children!.delete(name);
+    if (this._handler) this._handler.invalidateStat(norm);
   }
 
   renameSync(from: string, to: string): void {
@@ -932,7 +1002,7 @@ export class MemoryVolume {
     const self = this;
     const pending: Uint8Array[] = [];
     const handlers: Record<string, ((...args: unknown[]) => void)[]> = {};
-    const enc = new TextEncoder();
+    const enc = this.textEncoder;
 
     return {
       write(data: string | Uint8Array): boolean {

package/src/packages/installer.ts

@@ -13,6 +13,9 @@ import { downloadAndExtract } from "./archive-extractor";
 import { convertPackage, prepareTransformer } from "../module-transformer";
 import type { PackageManifest } from "../types/manifest";
 import * as path from "../polyfills/path";
+import type { IDBSnapshotCache } from "../persistence/idb-cache";
+import { quickDigest } from "../helpers/digest";
+import { base64ToBytes } from "../helpers/byte-encoding";
 
 // ---------------------------------------------------------------------------
 // Public types
@@ -87,11 +90,13 @@ export class DependencyInstaller {
   private vol: MemoryVolume;
   private registryClient: RegistryClient;
   private workingDir: string;
+  private _snapshotCache: IDBSnapshotCache | null;
 
-  constructor(vol: MemoryVolume, opts: { cwd?: string } & RegistryConfig = {}) {
+  constructor(vol: MemoryVolume, opts: { cwd?: string; snapshotCache?: IDBSnapshotCache | null } & RegistryConfig = {}) {
     this.vol = vol;
     this.registryClient = new RegistryClient(opts);
     this.workingDir = opts.cwd || "/";
+    this._snapshotCache = opts.snapshotCache ?? null;
   }
 
   // -----------------------------------------------------------------------
@@ -157,6 +162,37 @@ export class DependencyInstaller {
     const raw = this.vol.readFileSync(jsonPath, "utf8");
     const manifest: PackageManifest = JSON.parse(raw);
 
+    // Check IDB snapshot cache — skip full install if we have a cached node_modules
+    const cacheKey = this._snapshotCache ? quickDigest(raw) : null;
+    if (this._snapshotCache && cacheKey) {
+      try {
+        const cached = await this._snapshotCache.get(cacheKey);
+        if (cached) {
+          onProgress?.("Restoring cached node_modules...");
+          const { entries } = cached;
+          // Restore only node_modules entries from the snapshot
+          for (const entry of entries) {
+            if (!entry.path.includes('/node_modules/')) continue;
+            if (entry.kind === 'directory') {
+              if (!this.vol.existsSync(entry.path)) {
+                this.vol.mkdirSync(entry.path, { recursive: true });
+              }
+            } else if (entry.kind === 'file' && entry.data) {
+              const parentDir = entry.path.substring(0, entry.path.lastIndexOf('/')) || '/';
+              if (parentDir !== '/' && !this.vol.existsSync(parentDir)) {
+                this.vol.mkdirSync(parentDir, { recursive: true });
+              }
+              this.vol.writeFileSync(entry.path, base64ToBytes(entry.data));
+            }
+          }
+          onProgress?.(`Restored ${entries.length} cached entries`);
+          return { resolved: new Map(), newPackages: [] };
+        }
+      } catch {
+        // Cache miss or error — proceed with normal install
+      }
+    }
+
     onProgress?.("Resolving dependency tree...");
 
     const resolutionOpts: ResolutionConfig = {
@@ -170,6 +206,18 @@ export class DependencyInstaller {
 
     const newPkgs = await this.materializePackages(tree, flags);
 
+    // Cache the installed node_modules snapshot for future reuse
+    if (this._snapshotCache && cacheKey && newPkgs.length > 0) {
+      try {
+        const snapshot = this.vol.toSnapshot();
+        // Filter to only node_modules entries to keep cache lean
+        const nmSnapshot = {
+          entries: snapshot.entries.filter(e => e.path.includes('/node_modules/')),
+        };
+        await this._snapshotCache.set(cacheKey, nmSnapshot);
+      } catch { /* cache write failure is non-fatal */ }
+    }
+
     onProgress?.(`Installed ${tree.size} package(s)`);
 
     return { resolved: tree, newPackages: newPkgs };