@scelar/nodepod 1.0.2 → 1.0.4

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 
-const index = require('./index-cnitc68U.cjs');
+const index = require('./index-C-TQIrdG.cjs');
 
 
 

package/dist/index.mjs

@@ -1,4 +1,4 @@
-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--Qr8LVpQ.js";
+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,

package/dist/memory-volume.d.ts

@@ -72,7 +72,7 @@ export declare class MemoryVolume {
     off(event: 'change', handler: FileChangeHandler): this;
     off(event: 'delete', handler: FileDeleteHandler): this;
     private broadcast;
-    toSnapshot(): VolumeSnapshot;
+    toSnapshot(excludePrefixes?: string[]): VolumeSnapshot;
     private collectEntries;
     static fromBinarySnapshot(snapshot: {
         manifest: Array<{

package/dist/polyfills/wasi.d.ts

@@ -1,12 +1,53 @@
+interface WasiFileStat {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+    size: number;
+    mtimeMs: number;
+    atimeMs: number;
+    ctimeMs: number;
+    ino?: number;
+    nlink?: number;
+}
+interface WasiFS {
+    readFileSync(p: string): Uint8Array;
+    writeFileSync(p: string, data: string | Uint8Array): void;
+    mkdirSync(p: string, options?: {
+        recursive?: boolean;
+    }): void;
+    statSync(p: string): WasiFileStat;
+    readdirSync(p: string): string[];
+    unlinkSync(p: string): void;
+    rmdirSync(p: string): void;
+    renameSync(from: string, to: string): void;
+    existsSync(p: string): boolean;
+    symlinkSync?(target: string, linkPath: string): void;
+    readlinkSync?(p: string): string;
+}
+export declare class ExitStatus extends Error {
+    readonly code: number;
+    constructor(code: number);
+}
+export interface WASIOptions {
+    version?: "preview1" | "unstable";
+    args?: string[];
+    env?: Record<string, string>;
+    preopens?: Record<string, string>;
+    returnOnExit?: boolean;
+    stdin?: number;
+    stdout?: number;
+    stderr?: number;
+    fs?: WasiFS;
+}
 export interface WASI {
     readonly wasiImport: Record<string, Function>;
-    start(_instance: object): number;
-    initialize(_instance: object): void;
+    start(instance: object): number;
+    initialize(instance: object): void;
     getImportObject(): Record<string, Record<string, Function>>;
 }
 interface WASIConstructor {
-    new (_options?: object): WASI;
-    (this: any, _options?: object): void;
+    new (options?: WASIOptions): WASI;
+    (this: any, options?: WASIOptions): void;
     prototype: any;
 }
 export declare const WASI: WASIConstructor;

package/dist/script-engine.d.ts

@@ -9,6 +9,7 @@ export interface ModuleRecord {
     loaded: boolean;
     children: ModuleRecord[];
     paths: string[];
+    parent: ModuleRecord | null;
 }
 export interface EngineOptions {
     cwd?: string;
@@ -31,6 +32,7 @@ export interface ResolverFn {
     cache: Record<string, ModuleRecord>;
     extensions: Record<string, unknown>;
     main: ModuleRecord | null;
+    _ownerRecord?: ModuleRecord;
 }
 export declare class ScriptEngine {
     private vol;

package/dist/sdk/nodepod.d.ts

@@ -2,7 +2,7 @@ import { MemoryVolume } from "../memory-volume";
 import { ScriptEngine } from "../script-engine";
 import { DependencyInstaller } from "../packages/installer";
 import { RequestProxy } from "../request-proxy";
-import type { NodepodOptions, TerminalOptions, Snapshot, SpawnOptions } from "./types";
+import type { NodepodOptions, TerminalOptions, Snapshot, SnapshotOptions, SpawnOptions } from "./types";
 import { NodepodFS } from "./nodepod-fs";
 import { NodepodProcess } from "./nodepod-process";
 import { NodepodTerminal } from "./nodepod-terminal";
@@ -27,8 +27,9 @@ export declare class Nodepod {
     setPreviewScript(script: string): Promise<void>;
     clearPreviewScript(): Promise<void>;
     port(num: number): string | null;
-    snapshot(): Snapshot;
-    restore(snapshot: Snapshot): void;
+    private static readonly SHALLOW_EXCLUDE;
+    snapshot(opts?: SnapshotOptions): Snapshot;
+    restore(snapshot: Snapshot, opts?: SnapshotOptions): Promise<void>;
     teardown(): void;
     get volume(): MemoryVolume;
     get engine(): ScriptEngine;

package/dist/sdk/types.d.ts

@@ -46,6 +46,12 @@ export interface StatResult {
     mtime: number;
 }
 export type Snapshot = VolumeSnapshot;
+export interface SnapshotOptions {
+    /** Exclude node_modules and other auto-installable dirs. Default: true */
+    shallow?: boolean;
+    /** Auto-install deps from package.json after restoring a shallow snapshot. Default: true */
+    autoInstall?: boolean;
+}
 export interface SpawnOptions {
     cwd?: string;
     env?: Record<string, string>;

package/dist/syntax-transforms.d.ts

@@ -1,3 +1,4 @@
 export declare function esmToCjs(code: string): string;
+export declare function collectEsmCjsPatches(ast: any, code: string, patches: Array<[number, number, string]>): void;
 export declare function hasTopLevelAwait(code: string): boolean;
 export declare function stripTopLevelAwait(code: string, mode?: "topLevelOnly" | "full"): string;

package/dist/threading/process-manager.d.ts

@@ -39,7 +39,7 @@ export declare class ProcessManager extends EventEmitter {
         statusCode: number;
         statusMessage: string;
         headers: Record<string, string>;
-        body: string;
+        body: string | ArrayBuffer;
     }>;
     dispatchWsUpgrade(port: number, uid: string, path: string, headers: Record<string, string>): number;
     dispatchWsData(pid: number, uid: string, frame: number[]): void;

package/dist/threading/worker-protocol.d.ts

@@ -216,7 +216,7 @@ export interface WorkerToMain_HttpResponse {
     statusCode: number;
     statusMessage: string;
     headers: Record<string, string>;
-    body: string;
+    body: string | ArrayBuffer;
 }
 export interface WorkerToMain_IPC {
     type: "ipc-message";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scelar/nodepod",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Browser-native Node.js runtime environment",
   "type": "module",
   "license": "MIT WITH Commons-Clause",
@@ -49,12 +49,14 @@
   ],
   "sideEffects": false,
   "scripts": {
-    "build:lib": "vite build --config vite.lib.config.js && cp static/__sw__.js dist/__sw__.js",
+    "build:lib": "vite build --config vite.lib.config.js && node -e \"require('fs').copyFileSync('static/__sw__.js','dist/__sw__.js')\"",
     "build:types": "tsc --project tsconfig.build.json",
     "build:publish": "npm run build:lib && npm run build:types",
     "type-check": "tsc --noEmit",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "bench": "vitest bench",
+    "bench:run": "vitest bench --run"
   },
   "dependencies": {
     "acorn": "^8.15.0",

package/src/__tests__/bench/integration.bench.ts

@@ -0,0 +1,117 @@
+import { describe, bench } from "vitest";
+import { MemoryVolume } from "../../memory-volume";
+import { ScriptEngine } from "../../script-engine";
+
+describe("Integration - end to end", () => {
+  bench("volume + engine + write + execute", () => {
+    const vol = new MemoryVolume();
+    vol.mkdirSync("/app", { recursive: true });
+    vol.writeFileSync(
+      "/app/index.js",
+      `
+      const path = require('path');
+      const result = path.join('/home', 'user', 'project');
+      module.exports = result;
+    `,
+    );
+    const engine = new ScriptEngine(vol, { cwd: "/app" });
+    engine.runFile("/app/index.js");
+  });
+
+  bench("5-module project with require chain", () => {
+    const vol = new MemoryVolume();
+    vol.mkdirSync("/app/src", { recursive: true });
+
+    vol.writeFileSync(
+      "/app/src/config.js",
+      "module.exports = { port: 3000, host: 'localhost' };",
+    );
+    vol.writeFileSync(
+      "/app/src/utils.js",
+      `
+      const path = require('path');
+      module.exports = {
+        resolve: (...args) => path.resolve(...args),
+        join: (...args) => path.join(...args),
+      };
+    `,
+    );
+    vol.writeFileSync(
+      "/app/src/logger.js",
+      `
+      const util = require('util');
+      module.exports = {
+        info: (...args) => util.format(...args),
+        error: (...args) => util.format('ERROR:', ...args),
+      };
+    `,
+    );
+    vol.writeFileSync(
+      "/app/src/router.js",
+      `
+      const { EventEmitter } = require('events');
+      class Router extends EventEmitter {
+        constructor() { super(); this.routes = []; }
+        add(method, path, handler) { this.routes.push({ method, path, handler }); }
+      }
+      module.exports = Router;
+    `,
+    );
+    vol.writeFileSync(
+      "/app/src/index.js",
+      `
+      const config = require('./config');
+      const utils = require('./utils');
+      const logger = require('./logger');
+      const Router = require('./router');
+
+      const router = new Router();
+      router.add('GET', '/', () => 'hello');
+      module.exports = { config, utils, logger, router };
+    `,
+    );
+
+    const engine = new ScriptEngine(vol, { cwd: "/app" });
+    engine.runFile("/app/src/index.js");
+  });
+
+  bench("ESM project with import/export conversion", () => {
+    const vol = new MemoryVolume();
+    vol.mkdirSync("/esm", { recursive: true });
+
+    vol.writeFileSync(
+      "/esm/math.js",
+      `
+      export function add(a, b) { return a + b; }
+      export function multiply(a, b) { return a * b; }
+      export default { add, multiply };
+    `,
+    );
+    vol.writeFileSync(
+      "/esm/index.js",
+      `
+      import math, { add, multiply } from './math.js';
+      const result = add(multiply(3, 4), 5);
+      export default result;
+    `,
+    );
+
+    const engine = new ScriptEngine(vol, { cwd: "/esm" });
+    engine.runFile("/esm/index.js");
+  });
+
+  bench("snapshot round-trip: 100 files + save + restore + verify", () => {
+    const vol = new MemoryVolume();
+    vol.mkdirSync("/proj/src", { recursive: true });
+    for (let i = 0; i < 100; i++) {
+      vol.writeFileSync(
+        `/proj/src/mod${i}.js`,
+        `module.exports = { id: ${i} };`,
+      );
+    }
+
+    const snapshot = vol.toSnapshot();
+    const restored = MemoryVolume.fromSnapshot(snapshot);
+    restored.readFileSync("/proj/src/mod50.js", "utf8");
+  });
+});

package/src/__tests__/bench/memory-volume.bench.ts

@@ -0,0 +1,115 @@
+import { describe, bench, beforeEach } from "vitest";
+import { MemoryVolume } from "../../memory-volume";
+
+function populatedVolume(fileCount: number, fileSize: number): MemoryVolume {
+  const vol = new MemoryVolume();
+  vol.mkdirSync("/project", { recursive: true });
+  const content = "x".repeat(fileSize);
+  for (let i = 0; i < fileCount; i++) {
+    vol.writeFileSync(`/project/file-${i}.txt`, content);
+  }
+  return vol;
+}
+
+describe("MemoryVolume - write", () => {
+  let vol: MemoryVolume;
+  beforeEach(() => { vol = new MemoryVolume(); });
+
+  bench("writeFileSync - 100 bytes", () => {
+    vol.writeFileSync("/test.txt", "a".repeat(100));
+  });
+
+  bench("writeFileSync - 10KB", () => {
+    vol.writeFileSync("/test.txt", "a".repeat(10_000));
+  });
+
+  bench("writeFileSync - 1MB", () => {
+    vol.writeFileSync("/test.txt", "a".repeat(1_000_000));
+  });
+
+  bench("writeFileSync - binary Uint8Array 10KB", () => {
+    vol.writeFileSync("/test.bin", new Uint8Array(10_000));
+  });
+
+  bench("writeFileSync - deep path (6 levels)", () => {
+    vol.writeFileSync("/a/b/c/d/e/f/file.txt", "data");
+  });
+});
+
+describe("MemoryVolume - read", () => {
+  let vol: MemoryVolume;
+  beforeEach(() => { vol = populatedVolume(100, 1000); });
+
+  bench("readFileSync - utf8", () => {
+    vol.readFileSync("/project/file-50.txt", "utf8");
+  });
+
+  bench("readFileSync - binary", () => {
+    vol.readFileSync("/project/file-50.txt");
+  });
+
+  bench("existsSync - hit", () => {
+    vol.existsSync("/project/file-50.txt");
+  });
+
+  bench("existsSync - miss", () => {
+    vol.existsSync("/project/nonexistent.txt");
+  });
+
+  bench("statSync", () => {
+    vol.statSync("/project/file-50.txt");
+  });
+});
+
+describe("MemoryVolume - directories", () => {
+  let vol: MemoryVolume;
+  beforeEach(() => { vol = populatedVolume(200, 100); });
+
+  bench("readdirSync - 200 entries", () => {
+    vol.readdirSync("/project");
+  });
+
+  bench("mkdirSync recursive - 5 levels", () => {
+    vol.mkdirSync("/new/a/b/c/d", { recursive: true });
+  });
+});
+
+describe("MemoryVolume - snapshot", () => {
+  bench("toSnapshot - 100 files", () => {
+    const vol = populatedVolume(100, 500);
+    vol.toSnapshot();
+  });
+
+  bench("fromSnapshot - 100 files", () => {
+    const vol = populatedVolume(100, 500);
+    const snap = vol.toSnapshot();
+    MemoryVolume.fromSnapshot(snap);
+  });
+
+  bench("toSnapshot - 500 files", () => {
+    const vol = populatedVolume(500, 200);
+    vol.toSnapshot();
+  });
+
+  bench("fromSnapshot - 500 files", () => {
+    const vol = populatedVolume(500, 200);
+    const snap = vol.toSnapshot();
+    MemoryVolume.fromSnapshot(snap);
+  });
+});
+
+describe("MemoryVolume - mixed workload", () => {
+  bench("create 50 files + read all + delete all", () => {
+    const vol = new MemoryVolume();
+    vol.mkdirSync("/work", { recursive: true });
+    for (let i = 0; i < 50; i++) {
+      vol.writeFileSync(`/work/f${i}.js`, `const x = ${i};`);
+    }
+    for (let i = 0; i < 50; i++) {
+      vol.readFileSync(`/work/f${i}.js`, "utf8");
+    }
+    for (let i = 0; i < 50; i++) {
+      vol.unlinkSync(`/work/f${i}.js`);
+    }
+  });
+});

package/src/__tests__/bench/polyfills.bench.ts

@@ -0,0 +1,147 @@
+import { describe, bench } from "vitest";
+import { EventEmitter } from "../../polyfills/events";
+import { Buffer } from "../../polyfills/buffer";
+import * as pathPolyfill from "../../polyfills/path";
+import {
+  bytesToBase64,
+  base64ToBytes,
+  bytesToHex,
+} from "../../helpers/byte-encoding";
+import { quickDigest } from "../../helpers/digest";
+
+describe("EventEmitter", () => {
+  bench("on + emit (1 listener, 100 emits)", () => {
+    const ee = new EventEmitter();
+    ee.on("data", () => {});
+    for (let i = 0; i < 100; i++) ee.emit("data", i);
+  });
+
+  bench("on + emit (10 listeners, 100 emits)", () => {
+    const ee = new EventEmitter();
+    for (let i = 0; i < 10; i++) ee.on("data", () => {});
+    for (let i = 0; i < 100; i++) ee.emit("data", i);
+  });
+
+  bench("once + emit (100 cycles)", () => {
+    const ee = new EventEmitter();
+    for (let i = 0; i < 100; i++) {
+      ee.once("event", () => {});
+      ee.emit("event");
+    }
+  });
+
+  bench("removeListener (10 listeners)", () => {
+    const ee = new EventEmitter();
+    const handlers = Array.from({ length: 10 }, () => () => {});
+    handlers.forEach((h) => ee.on("data", h));
+    handlers.forEach((h) => ee.removeListener("data", h));
+  });
+});
+
+describe("Buffer", () => {
+  bench("Buffer.from(string, 'utf8') - 1KB", () => {
+    Buffer.from("x".repeat(1024));
+  });
+
+  bench("Buffer.from(string, 'base64') - 1KB", () => {
+    const b64 = bytesToBase64(new Uint8Array(768));
+    Buffer.from(b64, "base64");
+  });
+
+  bench("Buffer.from(string, 'hex') - 1KB", () => {
+    const hex = bytesToHex(new Uint8Array(512));
+    Buffer.from(hex, "hex");
+  });
+
+  bench("Buffer.alloc(4096)", () => {
+    Buffer.alloc(4096);
+  });
+
+  bench("Buffer.concat (10 x 1KB)", () => {
+    const chunks = Array.from({ length: 10 }, () => Buffer.alloc(1024));
+    Buffer.concat(chunks);
+  });
+
+  bench("Buffer.toString('utf8') - 4KB", () => {
+    const buf = Buffer.alloc(4096, 0x61);
+    buf.toString("utf8");
+  });
+
+  bench("Buffer.toString('base64') - 4KB", () => {
+    const buf = Buffer.alloc(4096, 0x61);
+    buf.toString("base64");
+  });
+});
+
+describe("path polyfill", () => {
+  bench("join (3 segments)", () => {
+    pathPolyfill.join("/usr", "local", "bin");
+  });
+
+  bench("resolve (relative)", () => {
+    pathPolyfill.resolve("src", "index.ts");
+  });
+
+  bench("resolve (absolute)", () => {
+    pathPolyfill.resolve("/home/user", "project", "src");
+  });
+
+  bench("dirname", () => {
+    pathPolyfill.dirname("/home/user/project/src/index.ts");
+  });
+
+  bench("basename", () => {
+    pathPolyfill.basename("/home/user/project/src/index.ts");
+  });
+
+  bench("extname", () => {
+    pathPolyfill.extname("/home/user/project/src/index.ts");
+  });
+
+  bench("normalize (complex)", () => {
+    pathPolyfill.normalize("/home/user/../user/./project//src/./index.ts");
+  });
+
+  bench("parse", () => {
+    pathPolyfill.parse("/home/user/project/src/index.ts");
+  });
+});
+
+describe("Byte encoding", () => {
+  const small = new Uint8Array(256);
+  const medium = new Uint8Array(10_000);
+  const large = new Uint8Array(100_000);
+
+  bench("bytesToBase64 - 256B", () => {
+    bytesToBase64(small);
+  });
+  bench("bytesToBase64 - 10KB", () => {
+    bytesToBase64(medium);
+  });
+  bench("bytesToBase64 - 100KB", () => {
+    bytesToBase64(large);
+  });
+
+  bench("base64ToBytes - 10KB", () => {
+    const encoded = bytesToBase64(medium);
+    base64ToBytes(encoded);
+  });
+
+  bench("bytesToHex - 10KB", () => {
+    bytesToHex(medium);
+  });
+});
+
+describe("quickDigest", () => {
+  bench("short string (50 chars)", () => {
+    quickDigest("a".repeat(50));
+  });
+
+  bench("medium string (5KB)", () => {
+    quickDigest("a".repeat(5_000));
+  });
+
+  bench("long string (50KB)", () => {
+    quickDigest("a".repeat(50_000));
+  });
+});

package/src/__tests__/bench/script-engine.bench.ts

@@ -0,0 +1,104 @@
+import { describe, bench } from "vitest";
+import { MemoryVolume } from "../../memory-volume";
+import { ScriptEngine } from "../../script-engine";
+
+function createEngine(files?: Record<string, string>): ScriptEngine {
+  const vol = new MemoryVolume();
+  vol.mkdirSync("/project", { recursive: true });
+  if (files) {
+    for (const [path, content] of Object.entries(files)) {
+      const dir = path.substring(0, path.lastIndexOf("/")) || "/";
+      if (dir !== "/") vol.mkdirSync(dir, { recursive: true });
+      vol.writeFileSync(path, content);
+    }
+  }
+  return new ScriptEngine(vol, { cwd: "/project" });
+}
+
+describe("ScriptEngine - execute", () => {
+  bench("simple expression", () => {
+    const engine = createEngine();
+    engine.execute("module.exports = 1 + 1;", "/index.js");
+  });
+
+  bench("console.log", () => {
+    const engine = createEngine();
+    engine.execute('console.log("hello");', "/index.js");
+  });
+
+  bench("require('path')", () => {
+    const engine = createEngine();
+    engine.execute(
+      'const path = require("path"); module.exports = path.join("/a", "b");',
+      "/index.js",
+    );
+  });
+
+  bench("require('events') + use", () => {
+    const engine = createEngine();
+    engine.execute(
+      'const { EventEmitter } = require("events"); const ee = new EventEmitter(); ee.on("x", () => {}); ee.emit("x");',
+      "/index.js",
+    );
+  });
+});
+
+describe("ScriptEngine - module resolution", () => {
+  bench("require local file", () => {
+    const engine = createEngine({
+      "/project/lib.js": "module.exports = { value: 42 };",
+      "/project/index.js":
+        'const lib = require("./lib"); module.exports = lib.value;',
+    });
+    engine.runFile("/project/index.js");
+  });
+
+  bench("require chain - 3 modules deep", () => {
+    const engine = createEngine({
+      "/project/a.js": "module.exports = { a: 1 };",
+      "/project/b.js":
+        'const a = require("./a"); module.exports = { ...a, b: 2 };',
+      "/project/c.js":
+        'const b = require("./b"); module.exports = { ...b, c: 3 };',
+    });
+    engine.runFile("/project/c.js");
+  });
+
+  bench("require with index.js resolution", () => {
+    const engine = createEngine({
+      "/project/mylib/index.js": "module.exports = { ok: true };",
+      "/project/index.js": 'module.exports = require("./mylib");',
+    });
+    engine.runFile("/project/index.js");
+  });
+
+  bench("require 10 builtins", () => {
+    const engine = createEngine();
+    engine.execute(
+      [
+        'require("path");',
+        'require("fs");',
+        'require("events");',
+        'require("util");',
+        'require("os");',
+        'require("url");',
+        'require("querystring");',
+        'require("buffer");',
+        'require("stream");',
+        'require("crypto");',
+      ].join("\n"),
+      "/index.js",
+    );
+  });
+});
+
+describe("ScriptEngine - cache", () => {
+  bench("execute + clearCache + re-execute", () => {
+    const engine = createEngine({
+      "/project/mod.js": "module.exports = Date.now();",
+    });
+    engine.runFile("/project/mod.js");
+    engine.clearCache();
+    engine.runFile("/project/mod.js");
+  });
+});