@scelar/nodepod 1.0.3 → 1.0.4

package/src/index.ts

@@ -1,192 +1,192 @@
-// nodepod - browser-native Node.js runtime environment
-
-export { MemoryVolume } from "./memory-volume";
-export type {
-  VolumeNode,
-  FileStat,
-  FileWatchHandle,
-  WatchCallback,
-  WatchEventKind,
-  SystemError,
-} from "./memory-volume";
-export { ScriptEngine, executeCode } from "./script-engine";
-export type { ModuleRecord, EngineOptions, ResolverFn } from "./script-engine";
-export { spawnEngine, WorkerSandbox, IframeSandbox, spawnProcessWorkerEngine, ProcessWorkerAdapter } from "./engine-factory";
-export type {
-  IScriptEngine,
-  ExecutionOutcome,
-  SpawnEngineConfig,
-  EngineConfig,
-  VolumeSnapshot,
-} from "./engine-types";
-export {
-  generateSandboxDeployment,
-  getSandboxPageHtml,
-  getSandboxHostingConfig,
-  SANDBOX_DEPLOYMENT_GUIDE,
-} from "./isolation-helpers";
-export { buildFileSystemBridge } from "./polyfills/fs";
-export type { FsBridge } from "./polyfills/fs";
-export { buildProcessEnv } from "./polyfills/process";
-export type { ProcessObject, ProcessEnvVars } from "./polyfills/process";
-export * as path from "./polyfills/path";
-export * as http from "./polyfills/http";
-export * as net from "./polyfills/net";
-export * as events from "./polyfills/events";
-export * as stream from "./polyfills/stream";
-export * as url from "./polyfills/url";
-export * as querystring from "./polyfills/querystring";
-export * as util from "./polyfills/util";
-export * as npm from "./packages/installer";
-export { DependencyInstaller, install } from "./packages/installer";
-export { RequestProxy, getProxyInstance, resetProxy } from "./request-proxy";
-export type { ProxyOptions, ServiceWorkerConfig } from "./request-proxy";
-export * as chokidar from "./polyfills/chokidar";
-export * as ws from "./polyfills/ws";
-export * as fsevents from "./polyfills/fsevents";
-export * as readdirp from "./polyfills/readdirp";
-export * as module from "./polyfills/module";
-export * as perf_hooks from "./polyfills/perf_hooks";
-export * as worker_threads from "./polyfills/worker_threads";
-export * as esbuild from "./polyfills/esbuild";
-export * as rollup from "./polyfills/rollup";
-export * as assert from "./polyfills/assert";
-
-import { MemoryVolume } from "./memory-volume";
-import { ScriptEngine, EngineOptions } from "./script-engine";
-import { DependencyInstaller } from "./packages/installer";
-import { RequestProxy, getProxyInstance } from "./request-proxy";
-// lazy-load child_process to avoid pulling in the shell at module load time
-let _shellMod: typeof import("./polyfills/child_process") | null = null;
-async function getShellMod() {
-  if (!_shellMod) _shellMod = await import("./polyfills/child_process");
-  return _shellMod;
-}
-
-export interface CommandResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}
-
-export interface CommandOptions {
-  cwd?: string;
-  onStdout?: (data: string) => void;
-  onStderr?: (data: string) => void;
-  signal?: AbortSignal;
-}
-
-export interface WorkspaceConfig extends EngineOptions {
-  baseUrl?: string;
-  onServerReady?: (port: number, url: string) => void;
-}
-
-// create a fully-wired workspace (volume + engine + packages + proxy)
-export function createWorkspace(config?: WorkspaceConfig): {
-  volume: MemoryVolume;
-  engine: ScriptEngine;
-  packages: DependencyInstaller;
-  proxy: RequestProxy;
-  execute: (code: string, filename?: string) => { exports: unknown };
-  runFile: (filename: string) => { exports: unknown };
-  run: (command: string, options?: CommandOptions) => Promise<CommandResult>;
-  sendInput: (data: string) => Promise<void>;
-  createREPL: () => { eval: (code: string) => unknown };
-  on: (event: string, listener: (...args: unknown[]) => void) => void;
-} {
-  const volume = new MemoryVolume();
-  const engine = new ScriptEngine(volume, config);
-  const packages = new DependencyInstaller(volume);
-  const proxy = getProxyInstance({
-    baseUrl: config?.baseUrl,
-    onServerReady: config?.onServerReady,
-  });
-
-  // init shell lazily (SDK path uses Nodepod.boot() instead)
-  getShellMod().then((mod) => mod.initShellExec(volume, { cwd: config?.cwd }));
-
-  return {
-    volume,
-    engine,
-    packages,
-    proxy,
-    execute: (code: string, filename?: string) =>
-      engine.execute(code, filename),
-    runFile: (filename: string) => engine.runFile(filename),
-    run: async (
-      command: string,
-      runOpts?: CommandOptions,
-    ): Promise<CommandResult> => {
-      if (runOpts?.signal?.aborted) {
-        return { stdout: "", stderr: "", exitCode: 130 };
-      }
-
-      const shell = await getShellMod();
-      const hasStreaming =
-        runOpts?.onStdout || runOpts?.onStderr || runOpts?.signal;
-      if (hasStreaming) {
-        shell.setStreamingCallbacks({
-          onStdout: runOpts?.onStdout,
-          onStderr: runOpts?.onStderr,
-          signal: runOpts?.signal,
-        });
-      }
-
-      return new Promise((resolve) => {
-        shell.exec(command, { cwd: runOpts?.cwd }, (error, stdout, stderr) => {
-          if (hasStreaming) shell.clearStreamingCallbacks();
-          resolve({
-            stdout: String(stdout),
-            stderr: String(stderr),
-            exitCode: error ? ((error as any).code ?? 1) : 0,
-          });
-        });
-      });
-    },
-    sendInput: async (data: string) => {
-      const shell = await getShellMod();
-      shell.sendStdin(data);
-    },
-    createREPL: () => engine.createREPL(),
-    on: (event: string, listener: (...args: unknown[]) => void) => {
-      proxy.on(event, listener);
-    },
-  };
-}
-
-export default createWorkspace;
-
-/* ---- SDK (clean public API) ---- */
-
-export { Nodepod } from "./sdk/nodepod";
-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";
-
-/* ---- Threading / Worker Infrastructure ---- */
-
-export { ProcessManager } from "./threading/process-manager";
-export { ProcessHandle } from "./threading/process-handle";
-export type { ProcessState } from "./threading/process-handle";
-export { VFSBridge } from "./threading/vfs-bridge";
-export { WorkerVFS } from "./threading/worker-vfs";
-export { SyncChannelController, SyncChannelWorker } from "./threading/sync-channel";
-export { SharedVFSController, SharedVFSReader, isSharedArrayBufferAvailable } from "./threading/shared-vfs";
-export { createProcessContext, getActiveContext, setActiveContext } from "./threading/process-context";
-export type { ProcessContext, ProcessWriter, ProcessReader, OpenFileEntry } from "./threading/process-context";
-export type {
-  VFSBinarySnapshot,
-  VFSSnapshotEntry,
-  SpawnConfig,
-  ProcessInfo,
-  MainToWorkerMessage,
-  WorkerToMainMessage,
-} from "./threading/worker-protocol";
+// nodepod - browser-native Node.js runtime environment
+
+export { MemoryVolume } from "./memory-volume";
+export type {
+  VolumeNode,
+  FileStat,
+  FileWatchHandle,
+  WatchCallback,
+  WatchEventKind,
+  SystemError,
+} from "./memory-volume";
+export { ScriptEngine, executeCode } from "./script-engine";
+export type { ModuleRecord, EngineOptions, ResolverFn } from "./script-engine";
+export { spawnEngine, WorkerSandbox, IframeSandbox, spawnProcessWorkerEngine, ProcessWorkerAdapter } from "./engine-factory";
+export type {
+  IScriptEngine,
+  ExecutionOutcome,
+  SpawnEngineConfig,
+  EngineConfig,
+  VolumeSnapshot,
+} from "./engine-types";
+export {
+  generateSandboxDeployment,
+  getSandboxPageHtml,
+  getSandboxHostingConfig,
+  SANDBOX_DEPLOYMENT_GUIDE,
+} from "./isolation-helpers";
+export { buildFileSystemBridge } from "./polyfills/fs";
+export type { FsBridge } from "./polyfills/fs";
+export { buildProcessEnv } from "./polyfills/process";
+export type { ProcessObject, ProcessEnvVars } from "./polyfills/process";
+export * as path from "./polyfills/path";
+export * as http from "./polyfills/http";
+export * as net from "./polyfills/net";
+export * as events from "./polyfills/events";
+export * as stream from "./polyfills/stream";
+export * as url from "./polyfills/url";
+export * as querystring from "./polyfills/querystring";
+export * as util from "./polyfills/util";
+export * as npm from "./packages/installer";
+export { DependencyInstaller, install } from "./packages/installer";
+export { RequestProxy, getProxyInstance, resetProxy } from "./request-proxy";
+export type { ProxyOptions, ServiceWorkerConfig } from "./request-proxy";
+export * as chokidar from "./polyfills/chokidar";
+export * as ws from "./polyfills/ws";
+export * as fsevents from "./polyfills/fsevents";
+export * as readdirp from "./polyfills/readdirp";
+export * as module from "./polyfills/module";
+export * as perf_hooks from "./polyfills/perf_hooks";
+export * as worker_threads from "./polyfills/worker_threads";
+export * as esbuild from "./polyfills/esbuild";
+export * as rollup from "./polyfills/rollup";
+export * as assert from "./polyfills/assert";
+
+import { MemoryVolume } from "./memory-volume";
+import { ScriptEngine, EngineOptions } from "./script-engine";
+import { DependencyInstaller } from "./packages/installer";
+import { RequestProxy, getProxyInstance } from "./request-proxy";
+// lazy-load child_process to avoid pulling in the shell at module load time
+let _shellMod: typeof import("./polyfills/child_process") | null = null;
+async function getShellMod() {
+  if (!_shellMod) _shellMod = await import("./polyfills/child_process");
+  return _shellMod;
+}
+
+export interface CommandResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export interface CommandOptions {
+  cwd?: string;
+  onStdout?: (data: string) => void;
+  onStderr?: (data: string) => void;
+  signal?: AbortSignal;
+}
+
+export interface WorkspaceConfig extends EngineOptions {
+  baseUrl?: string;
+  onServerReady?: (port: number, url: string) => void;
+}
+
+// create a fully-wired workspace (volume + engine + packages + proxy)
+export function createWorkspace(config?: WorkspaceConfig): {
+  volume: MemoryVolume;
+  engine: ScriptEngine;
+  packages: DependencyInstaller;
+  proxy: RequestProxy;
+  execute: (code: string, filename?: string) => { exports: unknown };
+  runFile: (filename: string) => { exports: unknown };
+  run: (command: string, options?: CommandOptions) => Promise<CommandResult>;
+  sendInput: (data: string) => Promise<void>;
+  createREPL: () => { eval: (code: string) => unknown };
+  on: (event: string, listener: (...args: unknown[]) => void) => void;
+} {
+  const volume = new MemoryVolume();
+  const engine = new ScriptEngine(volume, config);
+  const packages = new DependencyInstaller(volume);
+  const proxy = getProxyInstance({
+    baseUrl: config?.baseUrl,
+    onServerReady: config?.onServerReady,
+  });
+
+  // init shell lazily (SDK path uses Nodepod.boot() instead)
+  getShellMod().then((mod) => mod.initShellExec(volume, { cwd: config?.cwd }));
+
+  return {
+    volume,
+    engine,
+    packages,
+    proxy,
+    execute: (code: string, filename?: string) =>
+      engine.execute(code, filename),
+    runFile: (filename: string) => engine.runFile(filename),
+    run: async (
+      command: string,
+      runOpts?: CommandOptions,
+    ): Promise<CommandResult> => {
+      if (runOpts?.signal?.aborted) {
+        return { stdout: "", stderr: "", exitCode: 130 };
+      }
+
+      const shell = await getShellMod();
+      const hasStreaming =
+        runOpts?.onStdout || runOpts?.onStderr || runOpts?.signal;
+      if (hasStreaming) {
+        shell.setStreamingCallbacks({
+          onStdout: runOpts?.onStdout,
+          onStderr: runOpts?.onStderr,
+          signal: runOpts?.signal,
+        });
+      }
+
+      return new Promise((resolve) => {
+        shell.exec(command, { cwd: runOpts?.cwd }, (error, stdout, stderr) => {
+          if (hasStreaming) shell.clearStreamingCallbacks();
+          resolve({
+            stdout: String(stdout),
+            stderr: String(stderr),
+            exitCode: error ? ((error as any).code ?? 1) : 0,
+          });
+        });
+      });
+    },
+    sendInput: async (data: string) => {
+      const shell = await getShellMod();
+      shell.sendStdin(data);
+    },
+    createREPL: () => engine.createREPL(),
+    on: (event: string, listener: (...args: unknown[]) => void) => {
+      proxy.on(event, listener);
+    },
+  };
+}
+
+export default createWorkspace;
+
+/* ---- SDK (clean public API) ---- */
+
+export { Nodepod } from "./sdk/nodepod";
+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";
+
+/* ---- Threading / Worker Infrastructure ---- */
+
+export { ProcessManager } from "./threading/process-manager";
+export { ProcessHandle } from "./threading/process-handle";
+export type { ProcessState } from "./threading/process-handle";
+export { VFSBridge } from "./threading/vfs-bridge";
+export { WorkerVFS } from "./threading/worker-vfs";
+export { SyncChannelController, SyncChannelWorker } from "./threading/sync-channel";
+export { SharedVFSController, SharedVFSReader, isSharedArrayBufferAvailable } from "./threading/shared-vfs";
+export { createProcessContext, getActiveContext, setActiveContext } from "./threading/process-context";
+export type { ProcessContext, ProcessWriter, ProcessReader, OpenFileEntry } from "./threading/process-context";
+export type {
+  VFSBinarySnapshot,
+  VFSSnapshotEntry,
+  SpawnConfig,
+  ProcessInfo,
+  MainToWorkerMessage,
+  WorkerToMainMessage,
+} from "./threading/worker-protocol";

package/src/memory-volume.ts

@@ -218,13 +218,19 @@ export class MemoryVolume {
 
   // ---- Snapshot serialization ----
 
-  toSnapshot(): VolumeSnapshot {
+  toSnapshot(excludePrefixes?: string[]): VolumeSnapshot {
     const entries: VolumeEntry[] = [];
-    this.collectEntries('/', this.tree, entries);
+    this.collectEntries('/', this.tree, entries, excludePrefixes);
     return { entries };
   }
 
-  private collectEntries(currentPath: string, node: VolumeNode, result: VolumeEntry[]): void {
+  private collectEntries(currentPath: string, node: VolumeNode, result: VolumeEntry[], excludePrefixes?: 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) {
@@ -238,7 +244,7 @@ export class MemoryVolume {
       if (node.children) {
         for (const [name, child] of node.children) {
           const childPath = currentPath === '/' ? `/${name}` : `${currentPath}/${name}`;
-          this.collectEntries(childPath, child, result);
+          this.collectEntries(childPath, child, result, excludePrefixes);
         }
       }
     }

package/src/packages/version-resolver.ts

@@ -375,8 +375,18 @@ async function walkDependency(
       Object.assign(edges, versionInfo.dependencies);
     }
 
-    if (config.optionalDependencies && versionInfo.optionalDependencies) {
-      Object.assign(edges, versionInfo.optionalDependencies);
+    if (versionInfo.optionalDependencies) {
+      if (config.optionalDependencies) {
+        Object.assign(edges, versionInfo.optionalDependencies);
+      } else {
+        // Always include wasm32-wasi optional deps — they're WASM alternatives
+        // to native bindings and are the only variant that can run in-browser
+        for (const [optName, optRange] of Object.entries(versionInfo.optionalDependencies)) {
+          if (optName.includes("wasm32-wasi")) {
+            edges[optName] = optRange as string;
+          }
+        }
+      }
     }
 
     const edgeList = Object.entries(edges);