@scelar/nodepod 1.0.4 → 1.0.6

package/dist/index.cjs

@@ -1,65 +1,67 @@
-'use strict';
-
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
-
-const index = require('./index-C-TQIrdG.cjs');
-
-
-
-exports.DependencyInstaller = index.DependencyInstaller;
-exports.IframeSandbox = index.IframeSandbox;
-exports.MemoryVolume = index.MemoryVolume;
-exports.Nodepod = index.Nodepod;
-exports.NodepodFS = index.NodepodFS;
-exports.NodepodProcess = index.NodepodProcess;
-exports.NodepodTerminal = index.NodepodTerminal;
-exports.ProcessHandle = index.ProcessHandle;
-exports.ProcessManager = index.ProcessManager;
-exports.ProcessWorkerAdapter = index.ProcessWorkerAdapter;
-exports.RequestProxy = index.RequestProxy;
-exports.SANDBOX_DEPLOYMENT_GUIDE = index.SANDBOX_DEPLOYMENT_GUIDE;
-exports.ScriptEngine = index.ScriptEngine;
-exports.SharedVFSController = index.SharedVFSController;
-exports.SharedVFSReader = index.SharedVFSReader;
-exports.SyncChannelController = index.SyncChannelController;
-exports.SyncChannelWorker = index.SyncChannelWorker;
-exports.VFSBridge = index.VFSBridge;
-exports.WorkerSandbox = index.WorkerSandbox;
-exports.WorkerVFS = index.WorkerVFS;
-exports.assert = index.assert;
-exports.buildFileSystemBridge = index.buildFileSystemBridge;
-exports.buildProcessEnv = index.buildProcessEnv;
-exports.chokidar = index.watcherPolyfill;
-exports.createProcessContext = index.createProcessContext;
-exports.createWorkspace = index.createWorkspace;
-exports.default = index.createWorkspace;
-exports.esbuild = index.esbuildPolyfill;
-exports.events = index.events;
-exports.executeCode = index.executeCode;
-exports.fsevents = index.macEventsPolyfill;
-exports.generateSandboxDeployment = index.generateSandboxDeployment;
-exports.getActiveContext = index.getActiveContext;
-exports.getProxyInstance = index.getProxyInstance;
-exports.getSandboxHostingConfig = index.getSandboxHostingConfig;
-exports.getSandboxPageHtml = index.getSandboxPageHtml;
-exports.http = index.httpPolyfill;
-exports.install = index.install;
-exports.isSharedArrayBufferAvailable = index.isSharedArrayBufferAvailable;
-exports.module = index.module;
-exports.net = index.tcpPolyfill;
-exports.npm = index.installer;
-exports.path = index.pathPolyfill;
-exports.perf_hooks = index.perfPolyfill;
-exports.querystring = index.qsPolyfill;
-exports.readdirp = index.scannerPolyfill;
-exports.resetProxy = index.resetProxy;
-exports.rollup = index.rollupPolyfill;
-exports.setActiveContext = index.setActiveContext;
-exports.spawnEngine = index.spawnEngine;
-exports.spawnProcessWorkerEngine = index.spawnProcessWorkerEngine;
-exports.stream = index.stream;
-exports.url = index.urlPolyfill;
-exports.util = index.helpersPolyfill;
-exports.worker_threads = index.threadPoolPolyfill;
-exports.ws = index.wsPolyfill;
-//# sourceMappingURL=index.cjs.map
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const index = require('./index-DuYo2yDs.cjs');
+
+
+
+exports.DependencyInstaller = index.DependencyInstaller;
+exports.IframeSandbox = index.IframeSandbox;
+exports.LRUCache = index.LRUCache;
+exports.MemoryHandler = index.MemoryHandler;
+exports.MemoryVolume = index.MemoryVolume;
+exports.Nodepod = index.Nodepod;
+exports.NodepodFS = index.NodepodFS;
+exports.NodepodProcess = index.NodepodProcess;
+exports.NodepodTerminal = index.NodepodTerminal;
+exports.ProcessHandle = index.ProcessHandle;
+exports.ProcessManager = index.ProcessManager;
+exports.ProcessWorkerAdapter = index.ProcessWorkerAdapter;
+exports.RequestProxy = index.RequestProxy;
+exports.SANDBOX_DEPLOYMENT_GUIDE = index.SANDBOX_DEPLOYMENT_GUIDE;
+exports.ScriptEngine = index.ScriptEngine;
+exports.SharedVFSController = index.SharedVFSController;
+exports.SharedVFSReader = index.SharedVFSReader;
+exports.SyncChannelController = index.SyncChannelController;
+exports.SyncChannelWorker = index.SyncChannelWorker;
+exports.VFSBridge = index.VFSBridge;
+exports.WorkerSandbox = index.WorkerSandbox;
+exports.WorkerVFS = index.WorkerVFS;
+exports.assert = index.assert;
+exports.buildFileSystemBridge = index.buildFileSystemBridge;
+exports.buildProcessEnv = index.buildProcessEnv;
+exports.chokidar = index.watcherPolyfill;
+exports.createProcessContext = index.createProcessContext;
+exports.createWorkspace = index.createWorkspace;
+exports.default = index.createWorkspace;
+exports.esbuild = index.esbuildPolyfill;
+exports.events = index.events;
+exports.executeCode = index.executeCode;
+exports.fsevents = index.macEventsPolyfill;
+exports.generateSandboxDeployment = index.generateSandboxDeployment;
+exports.getActiveContext = index.getActiveContext;
+exports.getProxyInstance = index.getProxyInstance;
+exports.getSandboxHostingConfig = index.getSandboxHostingConfig;
+exports.getSandboxPageHtml = index.getSandboxPageHtml;
+exports.http = index.httpPolyfill;
+exports.install = index.install;
+exports.isSharedArrayBufferAvailable = index.isSharedArrayBufferAvailable;
+exports.module = index.module;
+exports.net = index.tcpPolyfill;
+exports.npm = index.installer;
+exports.path = index.pathPolyfill;
+exports.perf_hooks = index.perfPolyfill;
+exports.querystring = index.qsPolyfill;
+exports.readdirp = index.scannerPolyfill;
+exports.resetProxy = index.resetProxy;
+exports.rollup = index.rollupPolyfill;
+exports.setActiveContext = index.setActiveContext;
+exports.spawnEngine = index.spawnEngine;
+exports.spawnProcessWorkerEngine = index.spawnProcessWorkerEngine;
+exports.stream = index.stream;
+exports.url = index.urlPolyfill;
+exports.util = index.helpersPolyfill;
+exports.worker_threads = index.threadPoolPolyfill;
+exports.ws = index.wsPolyfill;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -74,6 +74,8 @@ export { NodepodTerminal } from "./sdk/nodepod-terminal";
 export { NodepodProcess } from "./sdk/nodepod-process";
 export { NodepodFS } from "./sdk/nodepod-fs";
 export type { NodepodOptions, TerminalOptions, TerminalTheme, StatResult, Snapshot, SpawnOptions, } from "./sdk/types";
+export { MemoryHandler, LRUCache } from "./memory-handler";
+export type { MemoryHandlerOptions } from "./memory-handler";
 export { ProcessManager } from "./threading/process-manager";
 export { ProcessHandle } from "./threading/process-handle";
 export type { ProcessState } from "./threading/process-handle";

package/dist/index.mjs

@@ -1,59 +1,61 @@
-import { p, I, q, s, t, v, w, P, x, y, z, A, S, C, F, G, H, J, K, O, Q, U, X, Z, _, $, $ as $2, a0, a1, a2, a3, a4, l, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar } from "./index-B8lyh_ti.js";
-export {
-  p as DependencyInstaller,
-  I as IframeSandbox,
-  q as MemoryVolume,
-  s as Nodepod,
-  t as NodepodFS,
-  v as NodepodProcess,
-  w as NodepodTerminal,
-  P as ProcessHandle,
-  x as ProcessManager,
-  y as ProcessWorkerAdapter,
-  z as RequestProxy,
-  A as SANDBOX_DEPLOYMENT_GUIDE,
-  S as ScriptEngine,
-  C as SharedVFSController,
-  F as SharedVFSReader,
-  G as SyncChannelController,
-  H as SyncChannelWorker,
-  J as VFSBridge,
-  K as WorkerSandbox,
-  O as WorkerVFS,
-  Q as assert,
-  U as buildFileSystemBridge,
-  X as buildProcessEnv,
-  Z as chokidar,
-  _ as createProcessContext,
-  $ as createWorkspace,
-  $2 as default,
-  a0 as esbuild,
-  a1 as events,
-  a2 as executeCode,
-  a3 as fsevents,
-  a4 as generateSandboxDeployment,
-  l as getActiveContext,
-  a5 as getProxyInstance,
-  a6 as getSandboxHostingConfig,
-  a7 as getSandboxPageHtml,
-  a8 as http,
-  a9 as install,
-  aa as isSharedArrayBufferAvailable,
-  ab as module,
-  ac as net,
-  ad as npm,
-  ae as path,
-  af as perf_hooks,
-  ag as querystring,
-  ah as readdirp,
-  ai as resetProxy,
-  aj as rollup,
-  ak as setActiveContext,
-  al as spawnEngine,
-  am as spawnProcessWorkerEngine,
-  an as stream,
-  ao as url,
-  ap as util,
-  aq as worker_threads,
-  ar as ws
-};
+import { p, I, q, s, t, v, w, x, y, P, z, A, C, F, S, G, H, J, K, O, Q, U, X, Z, _, $, a0, a1, a1 as a12, a2, a3, a4, a5, a6, l, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar, as, at } from "./index-HkVqijtm.js";
+export {
+  p as DependencyInstaller,
+  I as IframeSandbox,
+  q as LRUCache,
+  s as MemoryHandler,
+  t as MemoryVolume,
+  v as Nodepod,
+  w as NodepodFS,
+  x as NodepodProcess,
+  y as NodepodTerminal,
+  P as ProcessHandle,
+  z as ProcessManager,
+  A as ProcessWorkerAdapter,
+  C as RequestProxy,
+  F as SANDBOX_DEPLOYMENT_GUIDE,
+  S as ScriptEngine,
+  G as SharedVFSController,
+  H as SharedVFSReader,
+  J as SyncChannelController,
+  K as SyncChannelWorker,
+  O as VFSBridge,
+  Q as WorkerSandbox,
+  U as WorkerVFS,
+  X as assert,
+  Z as buildFileSystemBridge,
+  _ as buildProcessEnv,
+  $ as chokidar,
+  a0 as createProcessContext,
+  a1 as createWorkspace,
+  a12 as default,
+  a2 as esbuild,
+  a3 as events,
+  a4 as executeCode,
+  a5 as fsevents,
+  a6 as generateSandboxDeployment,
+  l as getActiveContext,
+  a7 as getProxyInstance,
+  a8 as getSandboxHostingConfig,
+  a9 as getSandboxPageHtml,
+  aa as http,
+  ab as install,
+  ac as isSharedArrayBufferAvailable,
+  ad as module,
+  ae as net,
+  af as npm,
+  ag as path,
+  ah as perf_hooks,
+  ai as querystring,
+  aj as readdirp,
+  ak as resetProxy,
+  al as rollup,
+  am as setActiveContext,
+  an as spawnEngine,
+  ao as spawnProcessWorkerEngine,
+  ap as stream,
+  aq as url,
+  ar as util,
+  as as worker_threads,
+  at as ws
+};

package/dist/memory-handler.d.ts

@@ -0,0 +1,57 @@
+import type { FileStat } from './memory-volume';
+export declare class LRUCache<K, V> {
+    private _map;
+    private _capacity;
+    constructor(capacity: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    get size(): number;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+}
+export interface MemoryHandlerOptions {
+    /** LRU capacity for path normalization cache. Default: 2048 */
+    pathNormCacheSize?: number;
+    /** LRU capacity for stat result cache. Default: 512 */
+    statCacheSize?: number;
+    /** LRU capacity for module resolve cache. Default: 4096 */
+    resolveCacheSize?: number;
+    /** LRU capacity for package.json manifest cache. Default: 256 */
+    manifestCacheSize?: number;
+    /** LRU capacity for source transform cache. Default: 512 */
+    transformCacheSize?: number;
+    /** Max modules before trimming node_modules entries. Default: 512 */
+    moduleSoftCacheSize?: number;
+    /** Heap usage threshold in MB to trigger pressure callbacks. Default: 350 */
+    heapWarnThresholdMB?: number;
+    /** Monitoring poll interval in ms. Default: 30000 */
+    monitorIntervalMs?: number;
+    /** Max process stdout/stderr accumulation in bytes. Default: 4194304 (4MB) */
+    maxProcessOutputBytes?: number;
+}
+export declare class MemoryHandler {
+    readonly options: Required<MemoryHandlerOptions>;
+    readonly pathNormCache: LRUCache<string, string>;
+    readonly statCache: LRUCache<string, FileStat>;
+    readonly transformCache: LRUCache<string, string>;
+    private _monitorTimer;
+    private _pressureCallbacks;
+    private _destroyed;
+    constructor(opts?: MemoryHandlerOptions);
+    /** Invalidate a cached stat entry (call on file write/delete). */
+    invalidateStat(normalizedPath: string): void;
+    /** Register a callback to be invoked when heap pressure is detected. Returns unsubscribe fn. */
+    onPressure(cb: () => void): () => void;
+    /** Start periodic heap monitoring. */
+    startMonitoring(): void;
+    /** Stop monitoring. */
+    stopMonitoring(): void;
+    /** Clear all owned caches. */
+    flush(): void;
+    /** Full cleanup — stop monitoring, flush caches. */
+    destroy(): void;
+    private _checkHeap;
+}

package/dist/memory-volume.d.ts

@@ -1,4 +1,5 @@
 import type { VolumeSnapshot } from './engine-types';
+import type { MemoryHandler } from './memory-handler';
 export interface VolumeNode {
     kind: 'file' | 'directory' | 'symlink';
     content?: Uint8Array;
@@ -66,13 +67,22 @@ export declare class MemoryVolume {
     private textDecoder;
     private activeWatchers;
     private subscribers;
-    constructor();
+    private _handler;
+    constructor(handler?: MemoryHandler | null);
     on(event: 'change', handler: FileChangeHandler): this;
     on(event: 'delete', handler: FileDeleteHandler): this;
     off(event: 'change', handler: FileChangeHandler): this;
     off(event: 'delete', handler: FileDeleteHandler): this;
     private broadcast;
-    toSnapshot(excludePrefixes?: string[]): VolumeSnapshot;
+    getStats(): {
+        fileCount: number;
+        totalBytes: number;
+        dirCount: number;
+        watcherCount: number;
+    };
+    /** Clean up all watchers, subscribers, and global listeners. */
+    dispose(): void;
+    toSnapshot(excludePrefixes?: string[], excludeDirNames?: Set<string>): VolumeSnapshot;
     private collectEntries;
     static fromBinarySnapshot(snapshot: {
         manifest: Array<{

package/dist/packages/installer.d.ts

@@ -1,6 +1,7 @@
 import { MemoryVolume } from "../memory-volume";
 import { RegistryConfig } from "./registry-client";
 import { ResolvedDependency } from "./version-resolver";
+import type { IDBSnapshotCache } from "../persistence/idb-cache";
 export interface InstallFlags {
     registry?: string;
     persist?: boolean;
@@ -22,8 +23,10 @@ export declare class DependencyInstaller {
     private vol;
     private registryClient;
     private workingDir;
+    private _snapshotCache;
     constructor(vol: MemoryVolume, opts?: {
         cwd?: string;
+        snapshotCache?: IDBSnapshotCache | null;
     } & RegistryConfig);
     install(packageName: string, version?: string, flags?: InstallFlags): Promise<InstallOutcome>;
     installFromManifest(manifestPath?: string, flags?: InstallFlags): Promise<InstallOutcome>;

package/dist/persistence/idb-cache.d.ts

@@ -0,0 +1,7 @@
+import type { VolumeSnapshot } from '../engine-types';
+export interface IDBSnapshotCache {
+    get(packageJsonHash: string): Promise<VolumeSnapshot | null>;
+    set(packageJsonHash: string, snapshot: VolumeSnapshot): Promise<void>;
+    close(): void;
+}
+export declare function openSnapshotCache(): Promise<IDBSnapshotCache | null>;

package/dist/polyfills/readline.d.ts

@@ -1,87 +1,108 @@
-import { EventEmitter } from "./events";
-export declare function getActiveInterfaceCount(): number;
-export declare function setActiveInterfaceCount(n: number): void;
-export declare function resetActiveInterfaceCount(): void;
-export interface InterfaceConfig {
-    input?: unknown;
-    output?: unknown;
-    terminal?: boolean;
-    prompt?: string;
-    historySize?: number;
-    completer?: (line: string) => [string[], string] | void;
-    crlfDelay?: number;
-    escapeCodeTimeout?: number;
-    tabSize?: number;
-}
-export declare function emitKeypressEvents(stream: unknown, _iface?: Interface): void;
-export interface Interface extends EventEmitter {
-    _promptStr: string;
-    _input: unknown;
-    _output: unknown;
-    _closed: boolean;
-    _lineBuffer: string;
-    _pendingQuestions: Array<{
-        query: string;
-        handler: (answer: string) => void;
-    }>;
-    terminal: boolean;
-    line: string;
-    cursor: number;
-    _refreshLine(): void;
-    _onKeypress(char: string | undefined, key: any): void;
-    _onData(text: string): void;
-    prompt(preserveCursor?: boolean): void;
-    setPrompt(text: string): void;
-    getPrompt(): string;
-    question(query: string, optsOrHandler?: unknown, handler?: (answer: string) => void): void;
-    pause(): this;
-    resume(): this;
-    close(): void;
-    write(data: string | null, _key?: {
-        ctrl?: boolean;
-        name?: string;
-        meta?: boolean;
-        shift?: boolean;
-        sequence?: string;
-    }): void;
-    getCursorPos(): {
-        rows: number;
-        cols: number;
-    };
-    [Symbol.asyncIterator](): AsyncGenerator<string, void, undefined>;
-}
-interface InterfaceConstructor {
-    new (cfg?: InterfaceConfig): Interface;
-    (this: any, cfg?: InterfaceConfig): void;
-    prototype: any;
-}
-export declare const Interface: InterfaceConstructor;
-export declare function createInterface(cfgOrInput?: InterfaceConfig | unknown, output?: unknown): Interface;
-export declare function clearLine(stream: unknown, dir: number, done?: () => void): boolean;
-export declare function clearScreenDown(stream: unknown, done?: () => void): boolean;
-export declare function cursorTo(stream: unknown, x: number, yOrDone?: number | (() => void), done?: () => void): boolean;
-export declare function moveCursor(stream: unknown, dx: number, dy: number, done?: () => void): boolean;
-export declare const promises: {
-    createInterface(cfg?: InterfaceConfig): {
-        question(query: string): Promise<string>;
-        close(): void;
-        [Symbol.asyncIterator](): AsyncGenerator<string, void, undefined>;
-    };
-};
-declare const _default: {
-    Interface: InterfaceConstructor;
-    createInterface: typeof createInterface;
-    clearLine: typeof clearLine;
-    clearScreenDown: typeof clearScreenDown;
-    cursorTo: typeof cursorTo;
-    moveCursor: typeof moveCursor;
-    emitKeypressEvents: typeof emitKeypressEvents;
-    promises: {
-        createInterface(cfg?: InterfaceConfig): {
-            question(query: string): Promise<string>;
-            close(): void;
-            [Symbol.asyncIterator](): AsyncGenerator<string, void, undefined>;
-        };
-    };
-};
-export default _default;
+import { EventEmitter } from "./events";
+export declare function getActiveInterfaceCount(): number;
+export declare function setActiveInterfaceCount(n: number): void;
+export declare function resetActiveInterfaceCount(): void;
+export interface InterfaceConfig {
+    input?: unknown;
+    output?: unknown;
+    terminal?: boolean;
+    prompt?: string;
+    historySize?: number;
+    history?: string[];
+    removeHistoryDuplicates?: boolean;
+    completer?: (line: string) => [string[], string] | void;
+    crlfDelay?: number;
+    escapeCodeTimeout?: number;
+    tabSize?: number;
+    signal?: AbortSignal;
+}
+export declare function emitKeypressEvents(stream: unknown, _iface?: Interface): void;
+export interface Interface extends EventEmitter {
+    _promptStr: string;
+    input: unknown;
+    output: unknown;
+    closed: boolean;
+    _lineBuffer: string;
+    _pendingQuestions: Array<{
+        query: string;
+        handler: (answer: string) => void;
+        signal?: AbortSignal;
+        abortListener?: () => void;
+    }>;
+    terminal: boolean;
+    line: string;
+    cursor: number;
+    history: string[];
+    _historyIndex: number;
+    _historySize: number;
+    _removeHistoryDuplicates: boolean;
+    _savedLine: string;
+    _killRing: string[];
+    _refreshLine(): void;
+    _onKeypress(char: string | undefined, key: any): void;
+    _onData(text: string): void;
+    _addToHistory(line: string): void;
+    prompt(preserveCursor?: boolean): void;
+    setPrompt(text: string): void;
+    getPrompt(): string;
+    question(query: string, optsOrHandler?: unknown, handler?: (answer: string) => void): void;
+    pause(): this;
+    resume(): this;
+    close(): void;
+    write(data: string | null, _key?: {
+        ctrl?: boolean;
+        name?: string;
+        meta?: boolean;
+        shift?: boolean;
+        sequence?: string;
+    }): void;
+    clearLine(dir?: number): void;
+    getCursorPos(): {
+        rows: number;
+        cols: number;
+    };
+    [Symbol.asyncIterator](): AsyncGenerator<string, void, undefined>;
+}
+interface InterfaceConstructor {
+    new (cfg?: InterfaceConfig): Interface;
+    (this: any, cfg?: InterfaceConfig): void;
+    prototype: any;
+}
+export declare const Interface: InterfaceConstructor;
+export declare function createInterface(cfgOrInput?: InterfaceConfig | unknown, output?: unknown): Interface;
+export declare function clearLine(stream: unknown, dir: number, done?: () => void): boolean;
+export declare function clearScreenDown(stream: unknown, done?: () => void): boolean;
+export declare function cursorTo(stream: unknown, x: number, yOrDone?: number | (() => void), done?: () => void): boolean;
+export declare function moveCursor(stream: unknown, dx: number, dy: number, done?: () => void): boolean;
+declare class ReadlineWriter {
+    private _stream;
+    private _buffer;
+    private _autoCommit;
+    constructor(stream: any, opts?: {
+        autoCommit?: boolean;
+    });
+    clearLine(dir: -1 | 0 | 1): this;
+    clearScreenDown(): this;
+    cursorTo(x: number, y?: number): this;
+    moveCursor(dx: number, dy: number): this;
+    commit(): Promise<void>;
+    rollback(): this;
+}
+export declare const promises: {
+    createInterface(cfg?: InterfaceConfig): any;
+    Readline: typeof ReadlineWriter;
+};
+declare const _default: {
+    Interface: InterfaceConstructor;
+    createInterface: typeof createInterface;
+    clearLine: typeof clearLine;
+    clearScreenDown: typeof clearScreenDown;
+    cursorTo: typeof cursorTo;
+    moveCursor: typeof moveCursor;
+    emitKeypressEvents: typeof emitKeypressEvents;
+    promises: {
+        createInterface(cfg?: InterfaceConfig): any;
+        Readline: typeof ReadlineWriter;
+    };
+};
+export default _default;

package/dist/script-engine.d.ts

@@ -23,6 +23,7 @@ export interface EngineOptions {
         workerData: unknown;
         threadId: number;
     };
+    handler?: import('./memory-handler').MemoryHandler;
 }
 export interface ResolverFn {
     (id: string): unknown;
@@ -67,6 +68,8 @@ export declare class ScriptEngine {
     }>;
     runFileAsync(filename: string): Promise<ExecutionOutcome>;
     clearCache(): void;
+    /** Evict one node_modules entry when module cache exceeds soft limit. */
+    private _trimModuleCache;
     getVolume(): MemoryVolume;
     getProcess(): ProcessObject;
     createREPL(): {

package/dist/sdk/nodepod-process.d.ts

@@ -7,12 +7,13 @@ export declare class NodepodProcess extends EventEmitter {
     private _exitCode;
     private _sendStdinFn;
     private _killFn;
+    private _maxOutputBytes;
     readonly completion: Promise<{
         stdout: string;
         stderr: string;
         exitCode: number;
     }>;
-    constructor();
+    constructor(maxOutputBytes?: number);
     _setSendStdin(fn: (data: string) => void): void;
     _setKillFn(fn: () => void): void;
     _pushStdout(chunk: string): void;