@scelar/nodepod 1.0.0

package/src/polyfills/vm.ts

@@ -0,0 +1,132 @@
+// VM polyfill using eval/Function since no V8 isolate API in browser
+
+
+/* ------------------------------------------------------------------ */
+/*  Script                                                             */
+/* ------------------------------------------------------------------ */
+
+export interface Script {
+  runInThisContext(_opts?: object): unknown;
+  runInNewContext(ctx?: object, _opts?: object): unknown;
+  runInContext(ctx: object, _opts?: object): unknown;
+  createCachedData(): Uint8Array;
+}
+
+export const Script = function Script(this: any, src: string, _opts?: object) {
+  if (!this) return;
+  this._src = src;
+} as unknown as { new(src: string, _opts?: object): Script; prototype: any };
+
+Script.prototype.runInThisContext = function runInThisContext(_opts?: object): unknown {
+  return (0, eval)(this._src);
+};
+
+Script.prototype.runInNewContext = function runInNewContext(ctx?: object, _opts?: object): unknown {
+  const names = ctx ? Object.keys(ctx) : [];
+  const vals = ctx ? Object.values(ctx) : [];
+  const wrapper = new Function(...names, `return eval(${JSON.stringify(this._src)})`);
+  return wrapper(...vals);
+};
+
+Script.prototype.runInContext = function runInContext(ctx: object, _opts?: object): unknown {
+  return this.runInNewContext(ctx, _opts);
+};
+
+Script.prototype.createCachedData = function createCachedData(): Uint8Array {
+  return new Uint8Array(0);
+};
+
+/* ------------------------------------------------------------------ */
+/*  Standalone helpers                                                 */
+/* ------------------------------------------------------------------ */
+
+export function createContext(sandbox?: object, _opts?: object): object {
+  return sandbox ?? {};
+}
+
+export function isContext(_box: object): boolean {
+  return true;
+}
+
+export function runInThisContext(code: string, _opts?: object): unknown {
+  return (0, eval)(code);
+}
+
+export function runInNewContext(code: string, ctx?: object, _opts?: object): unknown {
+  return new Script(code).runInNewContext(ctx);
+}
+
+export function runInContext(code: string, ctx: object, _opts?: object): unknown {
+  return runInNewContext(code, ctx);
+}
+
+export function compileFunction(
+  body: string,
+  params?: string[],
+  _opts?: object
+): Function {
+  return new Function(...(params ?? []), body);
+}
+
+/* ------------------------------------------------------------------ */
+/*  ESM Module stubs                                                   */
+/* ------------------------------------------------------------------ */
+
+export interface Module {
+  link(_linker: unknown): Promise<void>;
+  evaluate(_opts?: object): Promise<unknown>;
+  readonly status: string;
+  readonly identifier: string;
+  readonly context: object;
+  readonly namespace: object;
+}
+
+export const Module = function Module(this: any, _code: string, _opts?: object) {
+  if (!this) return;
+} as unknown as { new(_code: string, _opts?: object): Module; prototype: any };
+
+Module.prototype.link = function link(_linker: unknown): Promise<void> { return Promise.resolve(); };
+Module.prototype.evaluate = function evaluate(_opts?: object): Promise<unknown> { return Promise.resolve(); };
+Object.defineProperty(Module.prototype, 'status', { get() { return 'unlinked'; }, configurable: true });
+Object.defineProperty(Module.prototype, 'identifier', { get() { return ''; }, configurable: true });
+Object.defineProperty(Module.prototype, 'context', { get() { return {}; }, configurable: true });
+Object.defineProperty(Module.prototype, 'namespace', { get() { return {}; }, configurable: true });
+
+export interface SourceTextModule extends Module {}
+
+export const SourceTextModule = function SourceTextModule(this: any, _code: string, _opts?: object) {
+  if (!this) return;
+  (Module as any).call(this, _code, _opts);
+} as unknown as { new(_code: string, _opts?: object): SourceTextModule; prototype: any };
+
+Object.setPrototypeOf(SourceTextModule.prototype, Module.prototype);
+
+export interface SyntheticModule extends Module {
+  setExport(_name: string, _value: unknown): void;
+}
+
+export const SyntheticModule = function SyntheticModule(this: any, _code: string, _opts?: object) {
+  if (!this) return;
+  (Module as any).call(this, _code, _opts);
+} as unknown as { new(_code: string, _opts?: object): SyntheticModule; prototype: any };
+
+Object.setPrototypeOf(SyntheticModule.prototype, Module.prototype);
+
+SyntheticModule.prototype.setExport = function setExport(_name: string, _value: unknown): void {};
+
+/* ------------------------------------------------------------------ */
+/*  Default export                                                     */
+/* ------------------------------------------------------------------ */
+
+export default {
+  Script,
+  createContext,
+  isContext,
+  runInThisContext,
+  runInNewContext,
+  runInContext,
+  compileFunction,
+  Module,
+  SourceTextModule,
+  SyntheticModule,
+};

package/src/polyfills/volume-registry.ts

@@ -0,0 +1,15 @@
+// Shared MemoryVolume reference for polyfills that need VFS access
+
+
+import type { MemoryVolume } from "../memory-volume";
+
+let sharedVolume: MemoryVolume | null = null;
+
+// must be called once during init before watchers/scanners are used
+export function setSharedVolume(vol: MemoryVolume): void {
+  sharedVolume = vol;
+}
+
+export function getSharedVolume(): MemoryVolume | null {
+  return sharedVolume;
+}

package/src/polyfills/wasi.ts

@@ -0,0 +1,44 @@
+// stub - not available in browser
+
+
+/* ------------------------------------------------------------------ */
+/*  WASI class                                                         */
+/* ------------------------------------------------------------------ */
+
+export interface WASI {
+  readonly wasiImport: Record<string, Function>;
+  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;
+  prototype: any;
+}
+
+export const WASI = function WASI(this: any, _options?: object) {
+  if (!this) return;
+  this.wasiImport = {};
+} as unknown as WASIConstructor;
+
+WASI.prototype.start = function start(_instance: object): number {
+  throw new Error("WASI is not supported in the browser environment");
+};
+
+WASI.prototype.initialize = function initialize(_instance: object): void {
+  throw new Error("WASI is not supported in the browser environment");
+};
+
+WASI.prototype.getImportObject = function getImportObject(this: any): Record<string, Record<string, Function>> {
+  return { wasi_snapshot_preview1: this.wasiImport };
+};
+
+/* ------------------------------------------------------------------ */
+/*  Default export                                                     */
+/* ------------------------------------------------------------------ */
+
+export default {
+  WASI,
+};

package/src/polyfills/worker_threads.ts

@@ -0,0 +1,326 @@
+// worker_threads polyfill using fork infrastructure for real Web Workers
+
+
+import { EventEmitter } from "./events";
+import { ref as eventLoopRef, unref as eventLoopUnref } from "../helpers/event-loop";
+
+// shared defaults for main thread; child workers get per-engine overrides via buildResolver
+export let isMainThread = true;
+export let parentPort: MessagePort | null = null;
+export let workerData: unknown = null;
+export let threadId = 0;
+
+// fork callback, set by process-worker-entry.ts
+
+export type WorkerThreadForkFn = (
+  modulePath: string,
+  opts: {
+    workerData: unknown;
+    threadId: number;
+    isEval?: boolean;
+    cwd: string;
+    env: Record<string, string>;
+    onMessage: (data: unknown) => void;
+    onError: (err: Error) => void;
+    onExit: (code: number) => void;
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+  },
+) => {
+  postMessage: (data: unknown) => void;
+  terminate: () => void;
+  requestId: number;
+};
+
+let _workerThreadForkFn: WorkerThreadForkFn | null = null;
+
+export function setWorkerThreadForkCallback(fn: WorkerThreadForkFn): void {
+  _workerThreadForkFn = fn;
+}
+
+let _nextThreadId = 1;
+
+
+export interface MessagePort extends EventEmitter {
+  postMessage(_val: unknown, _transfer?: unknown[]): void;
+  start(): void;
+  close(): void;
+  ref(): void;
+  unref(): void;
+}
+
+interface MessagePortConstructor {
+  new (): MessagePort;
+  (this: any): void;
+  prototype: any;
+}
+
+export const MessagePort = function MessagePort(this: any) {
+  if (!this) return;
+  EventEmitter.call(this);
+} as unknown as MessagePortConstructor;
+
+Object.setPrototypeOf(MessagePort.prototype, EventEmitter.prototype);
+
+MessagePort.prototype.postMessage = function postMessage(_val: unknown, _transfer?: unknown[]): void {};
+MessagePort.prototype.start = function start(): void {};
+MessagePort.prototype.close = function close(): void {};
+MessagePort.prototype.ref = function ref(): void {};
+MessagePort.prototype.unref = function unref(): void {};
+
+
+export interface MessageChannel {
+  port1: MessagePort;
+  port2: MessagePort;
+}
+
+interface MessageChannelConstructor {
+  new (): MessageChannel;
+  (this: any): void;
+  prototype: any;
+}
+
+export const MessageChannel = function MessageChannel(this: any) {
+  if (!this) return;
+  this.port1 = new MessagePort();
+  this.port2 = new MessagePort();
+
+  // wire the two ports together
+  const p1 = this.port1;
+  const p2 = this.port2;
+  p1.postMessage = (val: unknown) => {
+    queueMicrotask(() => p2.emit("message", val));
+  };
+  p2.postMessage = (val: unknown) => {
+    queueMicrotask(() => p1.emit("message", val));
+  };
+} as unknown as MessageChannelConstructor;
+
+
+export interface Worker extends EventEmitter {
+  threadId: number;
+  resourceLimits: object;
+  _handle: ReturnType<WorkerThreadForkFn> | null;
+  _terminated: boolean;
+  _isReffed: boolean;
+  postMessage(value: unknown, _transferListOrOptions?: unknown): void;
+  terminate(): Promise<number>;
+  ref(): this;
+  unref(): this;
+  getHeapSnapshot(): Promise<unknown>;
+}
+
+interface WorkerConstructor {
+  new (
+    script: string | URL,
+    opts?: {
+      workerData?: unknown;
+      eval?: boolean;
+      env?: Record<string, string> | symbol;
+      argv?: string[];
+      execArgv?: string[];
+      resourceLimits?: Record<string, number>;
+      name?: string;
+      transferList?: unknown[];
+    },
+  ): Worker;
+  (this: any, script: string | URL, opts?: any): void;
+  prototype: any;
+}
+
+export const Worker = function Worker(
+  this: any,
+  script: string | URL,
+  opts?: {
+    workerData?: unknown;
+    eval?: boolean;
+    env?: Record<string, string> | symbol;
+    argv?: string[];
+    execArgv?: string[];
+    resourceLimits?: Record<string, number>;
+    name?: string;
+    transferList?: unknown[];
+  },
+) {
+  if (!this) return;
+  EventEmitter.call(this);
+
+  this.threadId = _nextThreadId++;
+  this.resourceLimits = {};
+  this._handle = null;
+  this._terminated = false;
+  this._isReffed = false;
+
+  const scriptStr = typeof script === "string" ? script : script.href;
+  const self = this;
+
+  if (!_workerThreadForkFn) {
+    // no fork callback wired
+    queueMicrotask(() => {
+      self.emit(
+        "error",
+        new Error(
+          "[Nodepod] worker_threads.Worker requires worker mode. " +
+            "Ensure the process is running in a worker context.",
+        ),
+      );
+    });
+    return;
+  }
+
+  const workerDataVal = opts?.workerData ?? null;
+  const isEval = !!opts?.eval;
+  const env =
+    opts?.env && typeof opts.env !== "symbol"
+      ? (opts.env as Record<string, string>)
+      : {};
+
+  const handle = _workerThreadForkFn(scriptStr, {
+    workerData: workerDataVal,
+    threadId: this.threadId,
+    isEval,
+    cwd: (globalThis as any).process?.cwd?.() ?? "/",
+    env,
+    onMessage: (data: unknown) => {
+      self.emit("message", data);
+    },
+    onError: (err: Error) => {
+      self.emit("error", err);
+    },
+    onExit: (code: number) => {
+      if (self._isReffed) {
+        self._isReffed = false;
+        eventLoopUnref();
+      }
+      self._terminated = true;
+      self.emit("exit", code);
+    },
+    onStdout: (data: string) => {
+        const sink = (globalThis as any).process?.stdout?.write;
+      if (typeof sink === "function") sink.call((globalThis as any).process.stdout, data);
+    },
+    onStderr: (data: string) => {
+      const sink = (globalThis as any).process?.stderr?.write;
+      if (typeof sink === "function") sink.call((globalThis as any).process.stderr, data);
+    },
+  });
+
+  this._handle = handle;
+
+  // keep parent alive while worker runs (Node.js default)
+  this._isReffed = true;
+  eventLoopRef();
+
+  queueMicrotask(() => {
+    if (!self._terminated) self.emit("online");
+  });
+} as unknown as WorkerConstructor;
+
+Object.setPrototypeOf(Worker.prototype, EventEmitter.prototype);
+
+Worker.prototype.postMessage = function postMessage(this: any, value: unknown, _transferListOrOptions?: unknown): void {
+  if (this._handle && !this._terminated) {
+    this._handle.postMessage(value);
+  }
+};
+
+Worker.prototype.terminate = function terminate(this: any): Promise<number> {
+  if (this._handle && !this._terminated) {
+    if (this._isReffed) {
+      this._isReffed = false;
+      eventLoopUnref();
+    }
+    this._terminated = true;
+    this._handle.terminate();
+  }
+  return Promise.resolve(0);
+};
+
+Worker.prototype.ref = function ref(this: any): any {
+  if (!this._isReffed && !this._terminated) {
+    this._isReffed = true;
+    eventLoopRef();
+  }
+  return this;
+};
+
+Worker.prototype.unref = function unref(this: any): any {
+  if (this._isReffed) {
+    this._isReffed = false;
+    eventLoopUnref();
+  }
+  return this;
+};
+
+Worker.prototype.getHeapSnapshot = function getHeapSnapshot(): Promise<unknown> {
+  return Promise.resolve({});
+};
+
+
+export interface BroadcastChannel extends EventEmitter {
+  name: string;
+  postMessage(_msg: unknown): void;
+  close(): void;
+  ref(): void;
+  unref(): void;
+}
+
+interface BroadcastChannelConstructor {
+  new (label: string): BroadcastChannel;
+  (this: any, label: string): void;
+  prototype: any;
+}
+
+export const BroadcastChannel = function BroadcastChannel(this: any, label: string) {
+  if (!this) return;
+  EventEmitter.call(this);
+  this.name = label;
+} as unknown as BroadcastChannelConstructor;
+
+Object.setPrototypeOf(BroadcastChannel.prototype, EventEmitter.prototype);
+
+BroadcastChannel.prototype.postMessage = function postMessage(_msg: unknown): void {};
+BroadcastChannel.prototype.close = function close(): void {};
+BroadcastChannel.prototype.ref = function ref(): void {};
+BroadcastChannel.prototype.unref = function unref(): void {};
+
+
+export function moveMessagePortToContext(
+  port: MessagePort,
+  _ctx: unknown,
+): MessagePort {
+  return port;
+}
+
+export function receiveMessageOnPort(
+  _port: MessagePort,
+): { message: unknown } | undefined {
+  return undefined;
+}
+
+export const SHARE_ENV = Symbol.for("nodejs.worker_threads.SHARE_ENV");
+
+export function markAsUntransferable(_obj: unknown): void {}
+export function getEnvironmentData(_key: unknown): unknown {
+  return undefined;
+}
+export function setEnvironmentData(_key: unknown, _val: unknown): void {}
+
+
+export default {
+  isMainThread,
+  parentPort,
+  workerData,
+  threadId,
+  Worker,
+  MessageChannel,
+  MessagePort,
+  BroadcastChannel,
+  moveMessagePortToContext,
+  receiveMessageOnPort,
+  SHARE_ENV,
+  markAsUntransferable,
+  getEnvironmentData,
+  setEnvironmentData,
+  setWorkerThreadForkCallback,
+};