@scelar/nodepod 1.0.0

package/src/types/fs-streams.ts

@@ -0,0 +1,142 @@
+// Types for fs ReadStream/WriteStream. These are old-style function constructors
+// (not classes) because graceful-fs uses .apply(this, arguments) which breaks classes.
+
+/* ---- ReadableState ---- */
+
+export interface FsReadableState {
+  readonly objectMode: boolean;
+  readonly highWaterMark: number;
+  readonly ended: boolean;
+  endEmitted: boolean;
+  flowing: boolean | null;
+  readonly reading: boolean;
+  readonly length: number;
+  readonly destroyed: boolean;
+  readonly errored: Error | null;
+  readonly closed: boolean;
+  pipes: unknown[];
+  awaitDrainWriters: unknown;
+  multiAwaitDrain: boolean;
+  readableListening: boolean;
+  resumeScheduled: boolean;
+  paused: boolean;
+  emitClose: boolean;
+  readonly autoDestroy: boolean;
+  defaultEncoding: string;
+  needReadable: boolean;
+  emittedReadable: boolean;
+  readingMore: boolean;
+  dataEmitted: boolean;
+}
+
+/* ---- WritableState ---- */
+
+export interface FsWritableState {
+  readonly objectMode: boolean;
+  readonly highWaterMark: number;
+  finished: boolean;
+  ended: boolean;
+  readonly destroyed: boolean;
+  readonly errored: Error | null;
+  readonly closed: boolean;
+  readonly corked: number;
+  readonly length: number;
+  readonly needDrain: boolean;
+  writing: boolean;
+  errorEmitted: boolean;
+  emitClose: boolean;
+  readonly autoDestroy: boolean;
+  defaultEncoding: string;
+  finalCalled: boolean;
+  ending: boolean;
+  bufferedIndex: number;
+}
+
+/* ---- FsReadStream ---- */
+
+export interface FsReadStreamInstance {
+  _queue: Array<Buffer | null>;
+  _active: boolean;
+  _terminated: boolean;
+  _endFired: boolean;
+  _endEmitted: boolean;
+  _objectMode: boolean;
+  _reading: boolean;
+  _highWaterMark: number;
+  _autoDestroy: boolean;
+  _encoding: string | null;
+  _readableByteLength: number;
+  _draining: boolean;
+
+  readable: boolean;
+  readableEnded: boolean;
+  readableFlowing: boolean | null;
+  destroyed: boolean;
+  closed: boolean;
+  errored: Error | null;
+  readableObjectMode: boolean;
+  readableHighWaterMark: number;
+  readableDidRead: boolean;
+  readableAborted: boolean;
+
+  _readableState: FsReadableState;
+
+  path: string;
+  fd: number | null;
+  flags: string;
+  mode: number;
+  autoClose: boolean;
+
+  open(): void;
+  _read(): void;
+  close(cb?: (err?: Error | null) => void): void;
+
+  push(chunk: unknown): boolean;
+  destroy(err?: unknown): void;
+  emit(event: string, ...args: unknown[]): boolean;
+  on(event: string, fn: (...args: unknown[]) => void): this;
+  pipe(dest: unknown): unknown;
+}
+
+/* ---- FsWriteStream ---- */
+
+export interface FsWriteStreamInstance {
+  _parts: Uint8Array[];
+  _closed: boolean;
+  _objectMode: boolean;
+  _highWaterMark: number;
+  _autoDestroy: boolean;
+  _corked: number;
+  _corkedWrites: Array<{ chunk: unknown; encoding: string; cb: (err?: Error | null) => void }>;
+  _writableByteLength: number;
+
+  writable: boolean;
+  writableEnded: boolean;
+  writableFinished: boolean;
+  writableNeedDrain: boolean;
+  destroyed: boolean;
+  closed: boolean;
+  errored: Error | null;
+  writableObjectMode: boolean;
+  writableHighWaterMark: number;
+  writableCorked: number;
+
+  _writableState: FsWritableState;
+
+  path: string;
+  fd: number | null;
+  flags: string;
+  mode: number;
+  autoClose: boolean;
+  bytesWritten: number;
+  _chunks: Uint8Array[];
+  _enc: TextEncoder;
+
+  open(): void;
+  close(cb?: (err?: Error | null) => void): void;
+
+  destroy(err?: unknown): void;
+  emit(event: string, ...args: unknown[]): boolean;
+  end(chunk?: unknown, encoding?: string, cb?: () => void): void;
+  write(chunk: unknown, encoding?: string, cb?: (err?: Error | null) => void): boolean;
+}

package/src/types/manifest.ts

@@ -0,0 +1,17 @@
+export interface PackageManifest {
+  name?: string;
+  version?: string;
+  main?: string;
+  module?: string;
+  browser?: string | Record<string, string | false>;
+  types?: string;
+  exports?: Record<string, unknown> | string;
+  imports?: Record<string, unknown>;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
+  scripts?: Record<string, string>;
+  bin?: string | Record<string, string>;
+  [key: string]: unknown;
+}

package/src/worker-sandbox.ts

@@ -0,0 +1,90 @@
+// executes code in a dedicated Web Worker behind the IScriptEngine interface
+
+import { wrap, proxy, Remote } from 'comlink';
+import type { MemoryVolume } from './memory-volume';
+import type { IScriptEngine, ExecutionOutcome, EngineConfig, VolumeSnapshot } from './engine-types';
+
+interface WorkerEndpoint {
+  init(snapshot: VolumeSnapshot, config: EngineConfig): void;
+  setConsoleForwarder(cb: ((method: string, args: unknown[]) => void) | null): void;
+  syncFile(path: string, content: string | null): void;
+  execute(code: string, filename?: string): Promise<ExecutionOutcome>;
+  runFile(filename: string): Promise<ExecutionOutcome>;
+  clearCache(): void;
+  getSnapshot(): VolumeSnapshot | null;
+}
+
+// URL is built at runtime so bundlers can't statically resolve it
+function createWorker(): Worker {
+  const base = import.meta.url;
+  const path = './threading/engine-worker' + '.ts';
+  const url = new (globalThis.URL)(path, base);
+  return new (globalThis.Worker)(url, { type: 'module' });
+}
+
+export class WorkerSandbox implements IScriptEngine {
+  private thread: Worker;
+  private endpoint: Remote<WorkerEndpoint>;
+  private vol: MemoryVolume;
+  private cfg: EngineConfig;
+  private ready: Promise<void>;
+  private onFileChange: ((path: string, content: string) => void) | null = null;
+  private onFileDelete: ((path: string) => void) | null = null;
+
+  constructor(vol: MemoryVolume, cfg: EngineConfig = {}) {
+    this.vol = vol;
+    this.cfg = cfg;
+
+    this.thread = createWorker();
+
+    this.endpoint = wrap<WorkerEndpoint>(this.thread);
+    this.ready = this.bootstrap();
+    this.attachVolumeSync();
+  }
+
+  private async bootstrap(): Promise<void> {
+    const snapshot = this.vol.toSnapshot();
+    const workerCfg: EngineConfig = { cwd: this.cfg.cwd, env: this.cfg.env };
+    await this.endpoint.init(snapshot, workerCfg);
+
+    if (this.cfg.onConsole) {
+      await this.endpoint.setConsoleForwarder(proxy(this.cfg.onConsole));
+    }
+  }
+
+  private attachVolumeSync(): void {
+    this.onFileChange = (path: string, content: string) => {
+      this.endpoint.syncFile(path, content);
+    };
+    this.vol.on('change', this.onFileChange);
+
+    this.onFileDelete = (path: string) => {
+      this.endpoint.syncFile(path, null);
+    };
+    this.vol.on('delete', this.onFileDelete);
+  }
+
+  async execute(code: string, filename?: string): Promise<ExecutionOutcome> {
+    await this.ready;
+    return this.endpoint.execute(code, filename);
+  }
+
+  async runFile(filename: string): Promise<ExecutionOutcome> {
+    await this.ready;
+    return this.endpoint.runFile(filename);
+  }
+
+  clearCache(): void {
+    this.endpoint.clearCache();
+  }
+
+  getVolume(): MemoryVolume {
+    return this.vol;
+  }
+
+  terminate(): void {
+    if (this.onFileChange) this.vol.off('change', this.onFileChange);
+    if (this.onFileDelete) this.vol.off('delete', this.onFileDelete);
+    this.thread.terminate();
+  }
+}