@scelar/nodepod 1.0.0

package/src/polyfills/chokidar.ts

@@ -0,0 +1,336 @@
+// Chokidar-compatible file watcher on top of MemoryVolume.watch()
+
+
+import type { MemoryVolume, FileWatchHandle, FileStat } from "../memory-volume";
+import { setSharedVolume, getSharedVolume } from "./volume-registry";
+
+
+export function setVolume(vol: MemoryVolume): void {
+  setSharedVolume(vol);
+}
+
+
+type Listener = (...args: unknown[]) => void;
+
+interface MiniEmitter {
+  handlers: Map<string, Set<Listener>>;
+  on(name: string, fn: Listener): this;
+  off(name: string, fn: Listener): this;
+  fire(name: string, ...args: unknown[]): void;
+}
+
+interface MiniEmitterConstructor {
+  new (): MiniEmitter;
+  (this: any): void;
+  prototype: any;
+}
+
+const MiniEmitter = function MiniEmitter(this: any) {
+  if (!this) return;
+  this.handlers = new Map<string, Set<Listener>>();
+} as unknown as MiniEmitterConstructor;
+
+MiniEmitter.prototype.on = function on(this: any, name: string, fn: Listener): any {
+  if (!this.handlers.has(name)) this.handlers.set(name, new Set());
+  this.handlers.get(name)!.add(fn);
+  return this;
+};
+
+MiniEmitter.prototype.off = function off(this: any, name: string, fn: Listener): any {
+  this.handlers.get(name)?.delete(fn);
+  return this;
+};
+
+MiniEmitter.prototype.fire = function fire(this: any, name: string, ...args: unknown[]): void {
+  const set = this.handlers.get(name);
+  if (!set) return;
+  for (const fn of set) {
+    try {
+      fn(...args);
+    } catch {
+      /* swallow listener errors */
+    }
+  }
+};
+
+
+export interface WatcherConfig {
+  persistent?: boolean;
+  ignored?:
+    | string
+    | RegExp
+    | ((p: string) => boolean)
+    | Array<string | RegExp | ((p: string) => boolean)>;
+  ignoreInitial?: boolean;
+  followSymlinks?: boolean;
+  cwd?: string;
+  disableGlobbing?: boolean;
+  usePolling?: boolean;
+  interval?: number;
+  binaryInterval?: number;
+  alwaysStat?: boolean;
+  depth?: number;
+  awaitWriteFinish?:
+    | boolean
+    | { stabilityThreshold?: number; pollInterval?: number };
+  ignorePermissionErrors?: boolean;
+  atomic?: boolean | number;
+}
+
+
+export interface PathWatcher extends MiniEmitter {
+  vol: MemoryVolume;
+  cfg: WatcherConfig;
+  handles: Map<string, FileWatchHandle>;
+  terminated: boolean;
+  initialised: boolean;
+  add(targets: string | readonly string[]): this;
+  unwatch(targets: string | readonly string[]): this;
+  close(): Promise<void>;
+  getWatched(): Record<string, string[]>;
+  resolvePath(raw: string): string;
+  isExcluded(target: string): boolean;
+  gatherInitial(dir: string, queue: Array<() => void>): void;
+  attachWatcher(target: string, filterFor?: string): void;
+  watchSubtree(dir: string, level?: number): void;
+}
+
+interface PathWatcherConstructor {
+  new (cfg?: WatcherConfig): PathWatcher;
+  (this: any, cfg?: WatcherConfig): void;
+  prototype: any;
+}
+
+export const PathWatcher = function PathWatcher(this: any, cfg: WatcherConfig = {}) {
+  if (!this) return;
+  MiniEmitter.call(this);
+  const vol = getSharedVolume();
+  if (!vol) {
+    throw new Error(
+      "chokidar: MemoryVolume not set. Call setVolume() first.",
+    );
+  }
+  this.vol = vol;
+  this.cfg = cfg;
+  this.handles = new Map<string, FileWatchHandle>();
+  this.terminated = false;
+  this.initialised = false;
+} as unknown as PathWatcherConstructor;
+
+Object.setPrototypeOf(PathWatcher.prototype, MiniEmitter.prototype);
+
+PathWatcher.prototype.add = function add(this: any, targets: string | readonly string[]): any {
+  if (this.terminated) return this;
+
+  const list = Array.isArray(targets) ? targets : [targets];
+  const deferred: Array<() => void> = [];
+
+  for (const raw of list) {
+    const absolute = this.resolvePath(raw);
+    if (this.isExcluded(absolute) || this.handles.has(absolute)) continue;
+
+    try {
+      if (!this.vol.existsSync(absolute)) {
+        // Path does not exist yet -- watch its parent so we detect creation
+        const parentDir =
+          absolute.substring(0, absolute.lastIndexOf("/")) || "/";
+        if (this.vol.existsSync(parentDir)) {
+          this.attachWatcher(parentDir, absolute);
+        }
+        continue;
+      }
+
+      const info = this.vol.statSync(absolute);
+
+      if (!this.cfg.ignoreInitial) {
+        if (info.isDirectory()) {
+          this.gatherInitial(absolute, deferred);
+        } else {
+          deferred.push(() => this.fire("add", absolute, info));
+        }
+      }
+
+      this.attachWatcher(absolute);
+
+      if (info.isDirectory()) {
+        this.watchSubtree(absolute);
+      }
+    } catch (err) {
+      this.fire("error", err);
+    }
+  }
+
+  if (!this.initialised) {
+    this.initialised = true;
+    setTimeout(() => {
+      for (const emit of deferred) emit();
+      this.fire("ready");
+    }, 0);
+  }
+
+  return this;
+};
+
+PathWatcher.prototype.unwatch = function unwatch(this: any, targets: string | readonly string[]): any {
+  const list = Array.isArray(targets) ? targets : [targets];
+  for (const raw of list) {
+    const absolute = this.resolvePath(raw);
+    const h = this.handles.get(absolute);
+    if (h) {
+      h.close();
+      this.handles.delete(absolute);
+    }
+  }
+  return this;
+};
+
+PathWatcher.prototype.close = function close(this: any): Promise<void> {
+  this.terminated = true;
+  for (const h of this.handles.values()) h.close();
+  this.handles.clear();
+  this.fire("close");
+  return Promise.resolve();
+};
+
+PathWatcher.prototype.getWatched = function getWatched(this: any): Record<string, string[]> {
+  const result: Record<string, string[]> = {};
+  for (const p of this.handles.keys()) {
+    const dir = p.substring(0, p.lastIndexOf("/")) || "/";
+    const base = p.substring(p.lastIndexOf("/") + 1);
+    if (!result[dir]) result[dir] = [];
+    result[dir].push(base);
+  }
+  return result;
+};
+
+PathWatcher.prototype.resolvePath = function resolvePath(this: any, raw: string): string {
+  let p = raw;
+  if (this.cfg.cwd && !p.startsWith("/")) {
+    p = this.cfg.cwd + "/" + p;
+  }
+  if (!p.startsWith("/")) p = "/" + p;
+  return p;
+};
+
+PathWatcher.prototype.isExcluded = function isExcluded(this: any, target: string): boolean {
+  const { ignored } = this.cfg;
+  if (!ignored) return false;
+
+  const rules = Array.isArray(ignored) ? ignored : [ignored];
+  for (const rule of rules) {
+    if (typeof rule === "string") {
+      if (target === rule || target.startsWith(rule + "/")) return true;
+    } else if (rule instanceof RegExp) {
+      if (rule.test(target)) return true;
+    } else if (typeof rule === "function") {
+      if (rule(target)) return true;
+    }
+  }
+  return false;
+};
+
+PathWatcher.prototype.gatherInitial = function gatherInitial(this: any, dir: string, queue: Array<() => void>): void {
+  try {
+    const children = this.vol.readdirSync(dir);
+    for (const child of children) {
+      const full = dir === "/" ? "/" + child : dir + "/" + child;
+      if (this.isExcluded(full)) continue;
+      const st = this.vol.statSync(full);
+      if (st.isDirectory()) {
+        queue.push(() => this.fire("addDir", full, st));
+        this.gatherInitial(full, queue);
+      } else {
+        queue.push(() => this.fire("add", full, st));
+      }
+    }
+  } catch {
+    /* swallow read errors during initial scan */
+  }
+};
+
+PathWatcher.prototype.attachWatcher = function attachWatcher(this: any, target: string, filterFor?: string): void {
+  if (this.handles.has(target)) return;
+
+  const self = this;
+  const handle = this.vol.watch(
+    target,
+    { recursive: true },
+    (kind: string, filename: string | null) => {
+      if (self.terminated) return;
+
+      let resolved: string;
+      if (filename) {
+        resolved = target === "/" ? "/" + filename : target + "/" + filename;
+      } else {
+        resolved = target;
+      }
+
+      if (
+        filterFor &&
+        resolved !== filterFor &&
+        !resolved.startsWith(filterFor + "/")
+      )
+        return;
+      if (self.isExcluded(resolved)) return;
+
+      if (kind === "rename") {
+        if (self.vol.existsSync(resolved)) {
+          try {
+            const st = self.vol.statSync(resolved);
+            const eventName = st.isDirectory() ? "addDir" : "add";
+            self.fire(eventName, resolved, st);
+            self.fire("all", eventName, resolved, st);
+          } catch {
+            /* vanished between check and stat */
+          }
+        } else {
+          self.fire("unlink", resolved);
+          self.fire("all", "unlink", resolved);
+        }
+      } else if (kind === "change") {
+        try {
+          const st = self.vol.statSync(resolved);
+          self.fire("change", resolved, st);
+          self.fire("all", "change", resolved, st);
+        } catch {
+          self.fire("unlink", resolved);
+          self.fire("all", "unlink", resolved);
+        }
+      }
+    },
+  );
+
+  this.handles.set(target, handle);
+};
+
+PathWatcher.prototype.watchSubtree = function watchSubtree(this: any, dir: string, level: number = 0): void {
+  if (this.cfg.depth !== undefined && level > this.cfg.depth) return;
+  try {
+    const children = this.vol.readdirSync(dir);
+    for (const name of children) {
+      const full = dir === "/" ? "/" + name : dir + "/" + name;
+      if (this.isExcluded(full)) continue;
+      try {
+        if (this.vol.statSync(full).isDirectory()) {
+          this.attachWatcher(full);
+          this.watchSubtree(full, level + 1);
+        }
+      } catch {
+        /* skip */
+      }
+    }
+  } catch {
+    /* skip */
+  }
+};
+
+export function watch(
+  targets: string | readonly string[],
+  options?: WatcherConfig,
+): PathWatcher {
+  const watcher = new PathWatcher(options);
+  watcher.add(targets);
+  return watcher;
+}
+
+export default { watch, PathWatcher, setVolume };

package/src/polyfills/cluster.ts

@@ -0,0 +1,106 @@
+// stub - not available in browser, always reports as primary
+
+import { EventEmitter } from "./events";
+
+/* ------------------------------------------------------------------ */
+/*  Flags                                                              */
+/* ------------------------------------------------------------------ */
+
+export const isMaster = true;
+export const isPrimary = true;
+export const isWorker = false;
+
+/* ------------------------------------------------------------------ */
+/*  Worker                                                             */
+/* ------------------------------------------------------------------ */
+
+export interface Worker extends EventEmitter {
+  id: number;
+  process: null;
+  send(_msg: unknown, _cb?: (err: Error | null) => void): boolean;
+  kill(_sig?: string): void;
+  disconnect(): void;
+  isDead(): boolean;
+  isConnected(): boolean;
+}
+
+export const Worker = function Worker(this: any) {
+  if (!this) return;
+  EventEmitter.call(this);
+  this.id = 0;
+  this.process = null;
+} as unknown as { new(): Worker; prototype: any };
+
+Object.setPrototypeOf(Worker.prototype, EventEmitter.prototype);
+
+Worker.prototype.send = function send(_msg: unknown, _cb?: (err: Error | null) => void): boolean { return false; };
+Worker.prototype.kill = function kill(_sig?: string): void {};
+Worker.prototype.disconnect = function disconnect(): void {};
+Worker.prototype.isDead = function isDead(): boolean { return false; };
+Worker.prototype.isConnected = function isConnected(): boolean { return false; };
+
+/* ------------------------------------------------------------------ */
+/*  Singletons                                                         */
+/* ------------------------------------------------------------------ */
+
+export const worker: Worker | null = null;
+export const workers: Record<number, Worker> = {};
+export const settings: Record<string, unknown> = {};
+
+/* ------------------------------------------------------------------ */
+/*  Scheduling                                                         */
+/* ------------------------------------------------------------------ */
+
+export const SCHED_NONE = 1;
+export const SCHED_RR = 2;
+export let schedulingPolicy = SCHED_RR;
+
+/* ------------------------------------------------------------------ */
+/*  Functions                                                          */
+/* ------------------------------------------------------------------ */
+
+export function fork(_env?: object): Worker {
+  return new Worker();
+}
+
+export function disconnect(done?: () => void): void {
+  if (done) setTimeout(done, 0);
+}
+
+export function setupMaster(_cfg?: object): void {}
+export function setupPrimary(_cfg?: object): void {}
+
+/* ------------------------------------------------------------------ */
+/*  Event emitter delegation                                           */
+/* ------------------------------------------------------------------ */
+
+const _bus = new EventEmitter();
+export const on = _bus.on.bind(_bus);
+export const once = _bus.once.bind(_bus);
+export const emit = _bus.emit.bind(_bus);
+export const removeListener = _bus.removeListener.bind(_bus);
+
+/* ------------------------------------------------------------------ */
+/*  Default export                                                     */
+/* ------------------------------------------------------------------ */
+
+export default {
+  isMaster,
+  isPrimary,
+  isWorker,
+  Worker,
+  worker,
+  workers,
+  fork,
+  disconnect,
+  settings,
+  SCHED_NONE,
+  SCHED_RR,
+  schedulingPolicy,
+  setupMaster,
+  setupPrimary,
+  on,
+  once,
+  emit,
+  removeListener,
+};

package/src/polyfills/console.ts

@@ -0,0 +1,136 @@
+// Console class matching Node.js constructor (accepts stdout/stderr streams)
+
+
+/* ------------------------------------------------------------------ */
+/*  Console class                                                      */
+/* ------------------------------------------------------------------ */
+
+export interface Console {
+  _out: { write: (s: string) => void } | null;
+  _err: { write: (s: string) => void } | null;
+  _emit(target: "out" | "err", args: unknown[]): void;
+  log(...a: unknown[]): void;
+  error(...a: unknown[]): void;
+  warn(...a: unknown[]): void;
+  info(...a: unknown[]): void;
+  debug(...a: unknown[]): void;
+  trace(...a: unknown[]): void;
+  dir(o: unknown): void;
+  time(): void;
+  timeEnd(): void;
+  timeLog(): void;
+  assert(v: unknown, ...a: unknown[]): void;
+  clear(): void;
+  count(): void;
+  countReset(): void;
+  group(): void;
+  groupCollapsed(): void;
+  groupEnd(): void;
+  table(d: unknown): void;
+}
+
+interface ConsoleConstructor {
+  new (stdout?: unknown, stderr?: unknown): Console;
+  (this: any, stdout?: unknown, stderr?: unknown): void;
+  prototype: any;
+}
+
+export const Console = function Console(this: any, stdout?: unknown, stderr?: unknown) {
+  if (!this) return;
+  const o = stdout as Record<string, unknown> | undefined;
+  if (o && typeof o === "object" && "write" in o) {
+    // new Console(stream) or new Console(stdout, stderr)
+    this._out = o as unknown as { write: (s: string) => void };
+    this._err =
+      (stderr as { write: (s: string) => void }) || this._out;
+  } else if (o && typeof o === "object" && "stdout" in o) {
+    // new Console({ stdout, stderr })
+    this._out = (o.stdout as { write: (s: string) => void }) || null;
+    this._err = (o.stderr as { write: (s: string) => void }) || this._out;
+  } else {
+    this._out = null;
+    this._err = null;
+  }
+} as unknown as ConsoleConstructor;
+
+Console.prototype._emit = function _emit(this: any, target: "out" | "err", args: unknown[]) {
+  const text =
+    args
+      .map((a: unknown) => (typeof a === "string" ? a : JSON.stringify(a)))
+      .join(" ") + "\n";
+  const dest = target === "err" ? this._err : this._out;
+  if (dest) dest.write(text);
+  else if (target === "err") globalThis.console.error(...args);
+  else globalThis.console.log(...args);
+};
+
+Console.prototype.log = function log(this: any, ...a: unknown[]) { this._emit("out", a); };
+Console.prototype.error = function error(this: any, ...a: unknown[]) { this._emit("err", a); };
+Console.prototype.warn = function warn(this: any, ...a: unknown[]) { this._emit("err", a); };
+Console.prototype.info = function info(this: any, ...a: unknown[]) { this._emit("out", a); };
+Console.prototype.debug = function debug(this: any, ...a: unknown[]) { this._emit("out", a); };
+Console.prototype.trace = function trace(this: any, ...a: unknown[]) { this._emit("err", a); };
+Console.prototype.dir = function dir(this: any, o: unknown) { this._emit("out", [o]); };
+Console.prototype.time = function time() {};
+Console.prototype.timeEnd = function timeEnd() {};
+Console.prototype.timeLog = function timeLog() {};
+Console.prototype.assert = function assert(this: any, v: unknown, ...a: unknown[]) {
+  if (!v) this._emit("err", ["Assertion failed:", ...a]);
+};
+Console.prototype.clear = function clear() {};
+Console.prototype.count = function count() {};
+Console.prototype.countReset = function countReset() {};
+Console.prototype.group = function group() {};
+Console.prototype.groupCollapsed = function groupCollapsed() {};
+Console.prototype.groupEnd = function groupEnd() {};
+Console.prototype.table = function table(this: any, d: unknown) { this._emit("out", [d]); };
+
+/* ------------------------------------------------------------------ */
+/*  Named re-exports from global console                               */
+/* ------------------------------------------------------------------ */
+
+const _gc = globalThis.console;
+
+export const log = _gc.log.bind(_gc);
+export const error = _gc.error.bind(_gc);
+export const warn = _gc.warn.bind(_gc);
+export const info = _gc.info.bind(_gc);
+export const debug = _gc.debug.bind(_gc);
+export const trace = _gc.trace.bind(_gc);
+export const dir = _gc.dir.bind(_gc);
+export const time = _gc.time.bind(_gc);
+export const timeEnd = _gc.timeEnd.bind(_gc);
+export const timeLog = _gc.timeLog.bind(_gc);
+export const clear = _gc.clear.bind(_gc);
+export const count = _gc.count.bind(_gc);
+export const countReset = _gc.countReset.bind(_gc);
+export const group = _gc.group.bind(_gc);
+export const groupCollapsed = _gc.groupCollapsed.bind(_gc);
+export const groupEnd = _gc.groupEnd.bind(_gc);
+export const table = _gc.table.bind(_gc);
+
+/* ------------------------------------------------------------------ */
+/*  Default export                                                     */
+/* ------------------------------------------------------------------ */
+
+export default {
+  Console,
+  log,
+  error,
+  warn,
+  info,
+  debug,
+  trace,
+  dir,
+  time,
+  timeEnd,
+  timeLog,
+  assert: _gc.assert.bind(_gc),
+  clear,
+  count,
+  countReset,
+  group,
+  groupCollapsed,
+  groupEnd,
+  table,
+};

package/src/polyfills/constants.ts

@@ -0,0 +1,123 @@
+// OS/filesystem constants (deprecated in Node.js, use os.constants instead)
+
+
+export const SIGKILL = 9;
+export const SIGTERM = 15;
+export const SIGINT = 2;
+export const SIGHUP = 1;
+export const SIGQUIT = 3;
+export const SIGABRT = 6;
+export const SIGALRM = 14;
+export const SIGUSR1 = 10;
+export const SIGUSR2 = 12;
+export const SIGPIPE = 13;
+export const SIGCHLD = 17;
+export const SIGCONT = 18;
+export const SIGSTOP = 19;
+export const SIGTSTP = 20;
+
+// File access constants
+export const F_OK = 0;
+export const R_OK = 4;
+export const W_OK = 2;
+export const X_OK = 1;
+
+// File open constants
+export const O_RDONLY = 0;
+export const O_WRONLY = 1;
+export const O_RDWR = 2;
+export const O_CREAT = 64;
+export const O_EXCL = 128;
+export const O_TRUNC = 512;
+export const O_APPEND = 1024;
+export const O_DIRECTORY = 65536;
+export const O_NOFOLLOW = 131072;
+export const O_SYNC = 1052672;
+
+// File type constants
+export const S_IFMT = 61440;
+export const S_IFREG = 32768;
+export const S_IFDIR = 16384;
+export const S_IFCHR = 8192;
+export const S_IFBLK = 24576;
+export const S_IFIFO = 4096;
+export const S_IFLNK = 40960;
+export const S_IFSOCK = 49152;
+
+// Errno constants
+export const EACCES = -13;
+export const EEXIST = -17;
+export const EISDIR = -21;
+export const EMFILE = -24;
+export const ENOENT = -2;
+export const ENOTDIR = -20;
+export const ENOTEMPTY = -39;
+export const EPERM = -1;
+export const EBADF = -9;
+
+export const os = {
+  constants: {
+    signals: {
+      SIGKILL,
+      SIGTERM,
+      SIGINT,
+      SIGHUP,
+      SIGQUIT,
+      SIGABRT,
+      SIGALRM,
+      SIGUSR1,
+      SIGUSR2,
+      SIGPIPE,
+      SIGCHLD,
+      SIGCONT,
+      SIGSTOP,
+      SIGTSTP,
+    },
+    errno: {
+      EACCES,
+      EEXIST,
+      EISDIR,
+      EMFILE,
+      ENOENT,
+      ENOTDIR,
+      ENOTEMPTY,
+      EPERM,
+      EBADF,
+    },
+  },
+};
+
+export const fs = {
+  constants: {
+    F_OK,
+    R_OK,
+    W_OK,
+    X_OK,
+    O_RDONLY,
+    O_WRONLY,
+    O_RDWR,
+    O_CREAT,
+    O_EXCL,
+    O_TRUNC,
+    O_APPEND,
+    O_DIRECTORY,
+    O_NOFOLLOW,
+    O_SYNC,
+    S_IFMT,
+    S_IFREG,
+    S_IFDIR,
+    S_IFCHR,
+    S_IFBLK,
+    S_IFIFO,
+    S_IFLNK,
+    S_IFSOCK,
+  },
+};
+
+export default {
+  ...os.constants.signals,
+  ...os.constants.errno,
+  ...fs.constants,
+  os,
+  fs,
+};