@scelar/nodepod 1.0.0

package/src/polyfills/string_decoder.ts

@@ -0,0 +1,25 @@
+// StringDecoder for decoding Buffer/Uint8Array to strings
+
+
+export interface StringDecoder {
+  encoding: string;
+  write(buf: Uint8Array | Buffer): string;
+  end(buf?: Uint8Array | Buffer): string;
+}
+
+export const StringDecoder = function StringDecoder(this: any, encoding?: string) {
+  if (!this) return;
+  this.encoding = encoding || "utf8";
+} as unknown as { new(encoding?: string): StringDecoder; prototype: any };
+
+StringDecoder.prototype.write = function write(buf: Uint8Array | Buffer): string {
+  if (!buf || buf.length === 0) return "";
+  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+  return new TextDecoder(this.encoding).decode(bytes);
+};
+
+StringDecoder.prototype.end = function end(buf?: Uint8Array | Buffer): string {
+  return buf ? this.write(buf) : "";
+};
+
+export default { StringDecoder };

package/src/polyfills/tailwindcss-oxide.ts

@@ -0,0 +1,309 @@
+// Pure JS replacement for @tailwindcss/oxide (native Rust binaries can't load in browser).
+// Regex-based scanner that extracts Tailwind CSS utility class candidates from VFS files.
+
+// Intentionally broad to avoid false negatives -- Tailwind's compiler filters out non-matches
+const CANDIDATE_RE =
+  /[!\-]?(?:[a-z@][a-z0-9]*(?:-[a-z0-9/._]+)*(?:\[[^\]]+\])?(?:\/[a-z0-9._%-]+)?(?:\:[a-z@!][a-z0-9]*(?:-[a-z0-9/._]+)*(?:\[[^\]]+\])?(?:\/[a-z0-9._%-]+)?)*)/gi;
+
+const SPLIT_RE = /[\s'"`;{}()\[\]]+/;
+
+function extractCandidates(content: string): string[] {
+  const seen = new Set<string>();
+  const matches = content.match(CANDIDATE_RE);
+  if (matches) {
+    for (const m of matches) {
+      if (m.length >= 2 && m.length <= 200) seen.add(m);
+    }
+  }
+  // fallback: split on whitespace/quotes and keep plausible tokens
+  const tokens = content.split(SPLIT_RE);
+  for (const tok of tokens) {
+    const t = tok.trim();
+    if (t.length >= 2 && t.length <= 200 && /^[!@\-]?[a-z]/.test(t) && !t.includes("//") && !t.includes("/*")) {
+      seen.add(t);
+    }
+  }
+  return Array.from(seen);
+}
+
+// ---------------------------------------------------------------------------
+// Glob matching (minimal)
+// ---------------------------------------------------------------------------
+
+function matchGlob(pattern: string, path: string): boolean {
+  // Convert glob pattern to regex
+  let re = "^";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "*" && pattern[i + 1] === "*") {
+      re += ".*";
+      i += 2;
+      if (pattern[i] === "/") i++;
+    } else if (ch === "*") {
+      re += "[^/]*";
+      i++;
+    } else if (ch === "?") {
+      re += "[^/]";
+      i++;
+    } else if (ch === "{") {
+      re += "(";
+      i++;
+    } else if (ch === "}") {
+      re += ")";
+      i++;
+    } else if (ch === ",") {
+      re += "|";
+      i++;
+    } else if (".+^$|()[]\\".includes(ch)) {
+      re += "\\" + ch;
+      i++;
+    } else {
+      re += ch;
+      i++;
+    }
+  }
+  re += "$";
+  try {
+    return new RegExp(re).test(path);
+  } catch {
+    return false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// VFS access — try to use globalThis.__nodepod_volume or require('fs')
+// ---------------------------------------------------------------------------
+
+function getFs(): any {
+  // Access the VFS through globalThis.__nodepodVolume (set by script-engine.ts)
+  const g = globalThis as any;
+  if (g.__nodepodVolume) return g.__nodepodVolume;
+  return null;
+}
+
+function readDir(fs: any, dir: string): string[] {
+  try {
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
+function walkDir(fs: any, dir: string, results: string[]): void {
+  const entries = readDir(fs, dir);
+  for (const entry of entries) {
+    if (entry === "node_modules" || entry === ".git" || entry === ".next" || entry === "dist") continue;
+    const full = dir.endsWith("/") ? dir + entry : dir + "/" + entry;
+    try {
+      const stat = fs.statSync(full);
+      if (stat.isDirectory()) {
+        walkDir(fs, full, results);
+      } else {
+        results.push(full);
+      }
+    } catch {
+      // Skip unreadable entries
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Source entry type
+// ---------------------------------------------------------------------------
+
+interface SourceEntry {
+  base: string;
+  pattern: string;
+  negated?: boolean;
+}
+
+interface ChangedContent {
+  file?: string;
+  content?: string;
+  extension: string;
+}
+
+// File extensions that likely contain Tailwind class names
+const SCANNABLE_EXTENSIONS = new Set([
+  ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs",
+  ".html", ".vue", ".svelte", ".astro", ".mdx", ".md",
+  ".php", ".blade.php", ".erb", ".haml", ".slim",
+  ".twig", ".pug", ".jade", ".hbs", ".ejs",
+]);
+
+// ---------------------------------------------------------------------------
+// Scanner class
+// ---------------------------------------------------------------------------
+
+export interface Scanner {
+  _sources: SourceEntry[];
+  _fileList: string[] | null;
+  _scannedCandidates: string[] | null;
+  _collectFiles(): string[];
+  scan(): string[];
+  scanFiles(changedContent: ChangedContent[]): string[];
+  getCandidatesWithPositions(changedContent: ChangedContent[]): Array<{ candidate: string; position: number }>;
+  readonly files: string[];
+  readonly globs: Array<{ base: string; pattern: string }>;
+  readonly normalizedSources: SourceEntry[];
+}
+
+interface ScannerConstructor {
+  new (opts?: { sources?: SourceEntry[] }): Scanner;
+  (this: any, opts?: { sources?: SourceEntry[] }): void;
+  prototype: any;
+}
+
+export const Scanner = function Scanner(this: any, opts?: { sources?: SourceEntry[] }) {
+  if (!this) return;
+  this._sources = opts?.sources || [];
+  this._fileList = null;
+  this._scannedCandidates = null;
+} as unknown as ScannerConstructor;
+
+Scanner.prototype._collectFiles = function _collectFiles(this: any): string[] {
+  if (this._fileList) return this._fileList;
+
+  const fs = getFs();
+  if (!fs) {
+    this._fileList = [];
+    return this._fileList;
+  }
+
+  const files: string[] = [];
+  const negatedPatterns: string[] = [];
+
+  for (const source of this._sources) {
+    if (source.negated) {
+      negatedPatterns.push(source.pattern);
+      continue;
+    }
+
+    const base = source.base || ".";
+    const allFiles: string[] = [];
+    walkDir(fs, base, allFiles);
+
+    for (const file of allFiles) {
+      const relPath = file.startsWith(base) ? file.slice(base.length).replace(/^\//, "") : file;
+      const ext = file.substring(file.lastIndexOf("."));
+      if (!SCANNABLE_EXTENSIONS.has(ext)) continue;
+      if (source.pattern && !matchGlob(source.pattern, relPath)) continue;
+
+      // Check against negated patterns
+      let negated = false;
+      for (const neg of negatedPatterns) {
+        if (matchGlob(neg, relPath)) {
+          negated = true;
+          break;
+        }
+      }
+      if (!negated) files.push(file);
+    }
+  }
+
+  this._fileList = files;
+  return files;
+};
+
+Scanner.prototype.scan = function scan(this: any): string[] {
+  if (this._scannedCandidates) return this._scannedCandidates;
+
+  const fs = getFs();
+  if (!fs) {
+    this._scannedCandidates = [];
+    return this._scannedCandidates;
+  }
+
+  const files = this._collectFiles();
+  const allCandidates = new Set<string>();
+
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(file, "utf8");
+      const candidates = extractCandidates(content);
+      for (const c of candidates) allCandidates.add(c);
+    } catch {
+      // Skip unreadable files
+    }
+  }
+
+  this._scannedCandidates = Array.from(allCandidates);
+  return this._scannedCandidates;
+};
+
+Scanner.prototype.scanFiles = function scanFiles(this: any, changedContent: ChangedContent[]): string[] {
+  const allCandidates = new Set<string>();
+  const fs = getFs();
+
+  for (const entry of changedContent) {
+    let content = entry.content;
+    if (!content && entry.file && fs) {
+      try {
+        content = fs.readFileSync(entry.file, "utf8");
+      } catch {
+        continue;
+      }
+    }
+    if (content) {
+      const candidates = extractCandidates(content);
+      for (const c of candidates) allCandidates.add(c);
+    }
+  }
+
+  // Invalidate cached scan results since files changed
+  this._scannedCandidates = null;
+
+  return Array.from(allCandidates);
+};
+
+Scanner.prototype.getCandidatesWithPositions = function getCandidatesWithPositions(this: any, changedContent: ChangedContent[]): Array<{ candidate: string; position: number }> {
+  const results: Array<{ candidate: string; position: number }> = [];
+  const fs = getFs();
+
+  for (const entry of changedContent) {
+    let content = entry.content;
+    if (!content && entry.file && fs) {
+      try {
+        content = fs.readFileSync(entry.file, "utf8");
+      } catch {
+        continue;
+      }
+    }
+    if (!content) continue;
+
+    let match: RegExpExecArray | null;
+    CANDIDATE_RE.lastIndex = 0;
+    while ((match = CANDIDATE_RE.exec(content)) !== null) {
+      results.push({ candidate: match[0], position: match.index });
+    }
+  }
+
+  return results;
+};
+
+Object.defineProperty(Scanner.prototype, "files", {
+  get: function(this: any): string[] {
+    return this._collectFiles();
+  },
+  configurable: true,
+});
+
+Object.defineProperty(Scanner.prototype, "globs", {
+  get: function(this: any): Array<{ base: string; pattern: string }> {
+    return this._sources
+      .filter((s: SourceEntry) => !s.negated)
+      .map((s: SourceEntry) => ({ base: s.base, pattern: s.pattern }));
+  },
+  configurable: true,
+});
+
+Object.defineProperty(Scanner.prototype, "normalizedSources", {
+  get: function(this: any): SourceEntry[] {
+    return this._sources;
+  },
+  configurable: true,
+});
+
+export default { Scanner };

package/src/polyfills/test.ts

@@ -0,0 +1,197 @@
+// lightweight node:test polyfill with describe/it/test, hooks, and basic mocks
+
+export interface TestContext {
+  name: string;
+  signal: AbortSignal;
+  _controller: AbortController;
+  diagnostic(msg: string): void;
+  plan(_count: number): void;
+  todo(msg?: string): void;
+  skip(msg?: string): void;
+  abort(): void;
+}
+
+interface TestContextConstructor {
+  new (name: string): TestContext;
+  (this: any, name: string): void;
+  prototype: any;
+}
+
+export const TestContext = function TestContext(this: any, name: string) {
+  if (!this) return;
+  this.name = name;
+  this._controller = new AbortController();
+  this.signal = this._controller.signal;
+} as unknown as TestContextConstructor;
+
+TestContext.prototype.diagnostic = function diagnostic(this: any, msg: string): void {
+  globalThis.console.log(`# ${msg}`);
+};
+
+TestContext.prototype.plan = function plan(_count: number): void {
+};
+
+TestContext.prototype.todo = function todo(msg?: string): void {
+  globalThis.console.log(`# TODO${msg ? ": " + msg : ""}`);
+};
+
+TestContext.prototype.skip = function skip(msg?: string): void {
+  globalThis.console.log(`# SKIP${msg ? ": " + msg : ""}`);
+};
+
+TestContext.prototype.abort = function abort(this: any): void {
+  this._controller.abort();
+};
+
+type TestFn = (t: TestContext) => void | Promise<void>;
+type HookFn = () => void | Promise<void>;
+
+interface TestOpts {
+  name: string;
+  skip?: boolean;
+  todo?: boolean;
+  only?: boolean;
+}
+
+export function describe(name: string, fn: () => void | Promise<void>): void;
+export function describe(
+  options: TestOpts,
+  fn: () => void | Promise<void>,
+): void;
+export function describe(
+  nameOrOpts: string | TestOpts,
+  fn?: () => void | Promise<void>,
+): void {
+  const name = typeof nameOrOpts === "string" ? nameOrOpts : nameOrOpts.name;
+  const opts: TestOpts = typeof nameOrOpts === "object" ? nameOrOpts : { name };
+  const body = fn!;
+
+  if (opts.skip) {
+    globalThis.console.log(`# SKIP - ${name}`);
+    return;
+  }
+  if (opts.todo) {
+    globalThis.console.log(`# TODO - ${name}`);
+    return;
+  }
+
+  try {
+    const result = body();
+    if (result && typeof (result as Promise<void>).then === "function") {
+      (result as Promise<void>).catch((err) => {
+        globalThis.console.error(`Suite "${name}" failed:`, err);
+      });
+    }
+  } catch (err) {
+    globalThis.console.error(`Suite "${name}" failed:`, err);
+  }
+}
+
+export function it(name: string, fn?: TestFn): void;
+export function it(options: TestOpts, fn?: TestFn): void;
+export function it(nameOrOpts: string | TestOpts, fn?: TestFn): void {
+  const name = typeof nameOrOpts === "string" ? nameOrOpts : nameOrOpts.name;
+  const opts: TestOpts = typeof nameOrOpts === "object" ? nameOrOpts : { name };
+
+  if (opts.skip || !fn) {
+    globalThis.console.log(`# SKIP - ${name}`);
+    return;
+  }
+  if (opts.todo) {
+    globalThis.console.log(`# TODO - ${name}`);
+    return;
+  }
+
+  const ctx = new TestContext(name);
+  try {
+    const result = fn(ctx);
+    if (result && typeof (result as Promise<void>).then === "function") {
+      (result as Promise<void>).catch((err) => {
+        globalThis.console.error(`Test "${name}" failed:`, err);
+      });
+    }
+  } catch (err) {
+    globalThis.console.error(`Test "${name}" failed:`, err);
+  }
+}
+
+export { it as test };
+
+export function before(fn: HookFn): void {
+  try {
+    fn();
+  } catch {
+  }
+}
+
+export function after(fn: HookFn): void {
+  try {
+    fn();
+  } catch {
+  }
+}
+
+export function beforeEach(fn: HookFn): void {
+  try {
+    fn();
+  } catch {
+  }
+}
+
+export function afterEach(fn: HookFn): void {
+  try {
+    fn();
+  } catch {
+  }
+}
+
+export function skip(name?: string, _fn?: TestFn): void {
+  if (name) globalThis.console.log(`# SKIP - ${name}`);
+}
+
+export function todo(name?: string, _fn?: TestFn): void {
+  if (name) globalThis.console.log(`# TODO - ${name}`);
+}
+
+export const mock = {
+  fn(impl?: Function): Function {
+    const calls: unknown[][] = [];
+    const mockFn = (...args: unknown[]) => {
+      calls.push(args);
+      return impl ? impl(...args) : undefined;
+    };
+    (mockFn as any).mock = { calls, callCount: () => calls.length };
+    return mockFn;
+  },
+
+  method(
+    obj: Record<string, unknown>,
+    methodName: string,
+    impl?: Function,
+  ): Function {
+    const original = obj[methodName];
+    const mocked = mock.fn(impl || (original as Function));
+    obj[methodName] = mocked;
+    return mocked;
+  },
+
+  reset(): void {
+  },
+
+  restoreAll(): void {
+  },
+};
+
+export default {
+  describe,
+  it,
+  test: it,
+  before,
+  after,
+  beforeEach,
+  afterEach,
+  skip,
+  todo,
+  mock,
+  TestContext,
+};

package/src/polyfills/timers.ts

@@ -0,0 +1,32 @@
+// Timer functions mapped to browser equivalents, includes setImmediate polyfill
+
+
+export const setTimeout = globalThis.setTimeout;
+export const setInterval = globalThis.setInterval;
+export const setImmediate = (fn: (...args: unknown[]) => void, ...args: unknown[]) =>
+  globalThis.setTimeout(fn, 0, ...args);
+export const clearTimeout = globalThis.clearTimeout;
+export const clearInterval = globalThis.clearInterval;
+export const clearImmediate = globalThis.clearTimeout;
+
+// timers/promises API
+export const promises = {
+  setTimeout: (ms: number, value?: unknown) =>
+    new Promise((resolve) => globalThis.setTimeout(() => resolve(value), ms)),
+  setInterval: globalThis.setInterval,
+  setImmediate: (value?: unknown) =>
+    new Promise((resolve) => globalThis.setTimeout(() => resolve(value), 0)),
+  scheduler: {
+    wait: (ms: number) =>
+      new Promise((resolve) => globalThis.setTimeout(resolve, ms)),
+  },
+};
+
+export default {
+  setTimeout,
+  setInterval,
+  setImmediate,
+  clearTimeout,
+  clearInterval,
+  clearImmediate,
+};

package/src/polyfills/tls.ts

@@ -0,0 +1,105 @@
+// stub - not available in browser
+
+import { EventEmitter } from "./events";
+
+export interface TLSSocket extends EventEmitter {
+  authorized: boolean;
+  encrypted: boolean;
+  getPeerCertificate(_detailed?: boolean): object;
+  getCipher(): { name: string; version: string } | null;
+  getProtocol(): string | null;
+  setServername(_name: string): void;
+  renegotiate(_opts: unknown, _cb: (err: Error | null) => void): boolean;
+}
+
+export const TLSSocket = function TLSSocket(this: any, _sock?: unknown, _opts?: unknown) {
+  if (!this) return;
+  EventEmitter.call(this);
+  this.authorized = false;
+  this.encrypted = true;
+} as unknown as { new(_sock?: unknown, _opts?: unknown): TLSSocket; prototype: any };
+
+Object.setPrototypeOf(TLSSocket.prototype, EventEmitter.prototype);
+
+TLSSocket.prototype.getPeerCertificate = function getPeerCertificate(_detailed?: boolean): object {
+  return {};
+};
+TLSSocket.prototype.getCipher = function getCipher(): { name: string; version: string } | null {
+  return null;
+};
+TLSSocket.prototype.getProtocol = function getProtocol(): string | null {
+  return null;
+};
+TLSSocket.prototype.setServername = function setServername(_name: string): void {};
+TLSSocket.prototype.renegotiate = function renegotiate(_opts: unknown, _cb: (err: Error | null) => void): boolean {
+  return false;
+};
+
+export interface Server extends EventEmitter {
+  listen(..._args: unknown[]): this;
+  close(_cb?: (err?: Error) => void): this;
+  address(): { port: number; family: string; address: string } | string | null;
+  getTicketKeys(): Uint8Array;
+  setTicketKeys(_keys: Uint8Array): void;
+  setSecureContext(_opts: unknown): void;
+}
+
+export const Server = function Server(this: any, _opts?: unknown, _handler?: (sock: TLSSocket) => void) {
+  if (!this) return;
+  EventEmitter.call(this);
+} as unknown as { new(_opts?: unknown, _handler?: (sock: TLSSocket) => void): Server; prototype: any };
+
+Object.setPrototypeOf(Server.prototype, EventEmitter.prototype);
+
+Server.prototype.listen = function listen(..._args: unknown[]) { return this; };
+Server.prototype.close = function close(_cb?: (err?: Error) => void) { return this; };
+Server.prototype.address = function address(): { port: number; family: string; address: string } | string | null {
+  return null;
+};
+Server.prototype.getTicketKeys = function getTicketKeys(): Uint8Array {
+  return new Uint8Array(0);
+};
+Server.prototype.setTicketKeys = function setTicketKeys(_keys: Uint8Array): void {};
+Server.prototype.setSecureContext = function setSecureContext(_opts: unknown): void {};
+
+export function createServer(
+  _opts?: unknown,
+  _handler?: (sock: TLSSocket) => void,
+): Server {
+  return new Server(_opts, _handler);
+}
+
+export function connect(_opts: unknown, _cb?: () => void): TLSSocket {
+  const sock = new TLSSocket();
+  if (_cb) setTimeout(_cb, 0);
+  return sock;
+}
+
+export function createSecureContext(_opts?: unknown): object {
+  return {};
+}
+
+export type SecureContext = object;
+
+export const getCiphers = (): string[] => [
+  "TLS_AES_256_GCM_SHA384",
+  "TLS_AES_128_GCM_SHA256",
+];
+
+export const DEFAULT_ECDH_CURVE = "auto";
+export const DEFAULT_MAX_VERSION = "TLSv1.3";
+export const DEFAULT_MIN_VERSION = "TLSv1.2";
+export const rootCertificates: string[] = [];
+
+export default {
+  TLSSocket,
+  Server,
+  createServer,
+  connect,
+  createSecureContext,
+  getCiphers,
+  DEFAULT_ECDH_CURVE,
+  DEFAULT_MAX_VERSION,
+  DEFAULT_MIN_VERSION,
+  rootCertificates,
+};