@run0/jiki 0.1.0

package/src/polyfills/url.ts

@@ -0,0 +1,97 @@
+export const URL = globalThis.URL;
+export const URLSearchParams = globalThis.URLSearchParams;
+
+export function parse(
+  urlString: string,
+  parseQueryString = false,
+  slashesDenoteHost = false,
+): Record<string, unknown> {
+  try {
+    const parsed = new globalThis.URL(urlString, "http://localhost");
+    const result: Record<string, unknown> = {
+      protocol: parsed.protocol,
+      slashes: parsed.protocol ? true : null,
+      auth: parsed.username
+        ? parsed.password
+          ? `${parsed.username}:${parsed.password}`
+          : parsed.username
+        : null,
+      host: parsed.host,
+      port: parsed.port || null,
+      hostname: parsed.hostname,
+      hash: parsed.hash || null,
+      search: parsed.search || null,
+      query: parseQueryString
+        ? Object.fromEntries(parsed.searchParams)
+        : parsed.search?.slice(1) || null,
+      pathname: parsed.pathname,
+      path: parsed.pathname + (parsed.search || ""),
+      href: parsed.href,
+    };
+    return result;
+  } catch {
+    return {
+      protocol: null,
+      slashes: null,
+      auth: null,
+      host: null,
+      port: null,
+      hostname: null,
+      hash: null,
+      search: null,
+      query: null,
+      pathname: urlString,
+      path: urlString,
+      href: urlString,
+    };
+  }
+}
+
+export function format(urlObj: Record<string, unknown>): string {
+  if (typeof urlObj === "string") return urlObj;
+  let result = "";
+  if (urlObj.protocol) result += urlObj.protocol;
+  if (urlObj.slashes) result += "//";
+  if (urlObj.auth) result += urlObj.auth + "@";
+  if (urlObj.hostname) result += urlObj.hostname;
+  if (urlObj.port) result += ":" + urlObj.port;
+  if (urlObj.pathname) result += urlObj.pathname;
+  if (urlObj.search) result += urlObj.search;
+  if (urlObj.hash) result += urlObj.hash;
+  return result;
+}
+
+export function resolve(from: string, to: string): string {
+  return new globalThis.URL(to, from).href;
+}
+
+export function fileURLToPath(url: string | URL): string {
+  const urlStr = typeof url === "string" ? url : url.href;
+  if (!urlStr.startsWith("file://")) throw new Error("Invalid file URL");
+  return decodeURIComponent(urlStr.replace(/^file:\/\//, ""));
+}
+
+export function pathToFileURL(path: string): URL {
+  return new globalThis.URL(
+    "file://" + encodeURIComponent(path).replace(/%2F/g, "/"),
+  );
+}
+
+export function domainToASCII(domain: string): string {
+  return domain;
+}
+export function domainToUnicode(domain: string): string {
+  return domain;
+}
+
+export default {
+  URL,
+  URLSearchParams,
+  parse,
+  format,
+  resolve,
+  fileURLToPath,
+  pathToFileURL,
+  domainToASCII,
+  domainToUnicode,
+};

package/src/polyfills/util.ts

@@ -0,0 +1,173 @@
+export function format(fmt: unknown, ...args: unknown[]): string {
+  if (typeof fmt !== "string")
+    return args.length
+      ? [fmt, ...args].map(a => inspect(a)).join(" ")
+      : inspect(fmt);
+  let i = 0;
+  return fmt.replace(/%[sdjifoO%]/g, m => {
+    if (m === "%%") return "%";
+    if (i >= args.length) return m;
+    const arg = args[i++];
+    switch (m) {
+      case "%s":
+        return String(arg);
+      case "%d":
+        return String(Number(arg));
+      case "%i":
+        return String(Math.floor(Number(arg)));
+      case "%f":
+        return String(parseFloat(String(arg)));
+      case "%j":
+        try {
+          return JSON.stringify(arg);
+        } catch {
+          return "[Circular]";
+        }
+      case "%o":
+      case "%O":
+        return inspect(arg);
+      default:
+        return m;
+    }
+  });
+}
+
+export function inspect(
+  obj: unknown,
+  opts?: { depth?: number; colors?: boolean },
+): string {
+  if (obj === null) return "null";
+  if (obj === undefined) return "undefined";
+  if (typeof obj === "string") return `'${obj}'`;
+  if (
+    typeof obj === "number" ||
+    typeof obj === "boolean" ||
+    typeof obj === "bigint"
+  )
+    return String(obj);
+  if (typeof obj === "function")
+    return `[Function: ${obj.name || "anonymous"}]`;
+  if (typeof obj === "symbol") return obj.toString();
+  if (obj instanceof Date) return obj.toISOString();
+  if (obj instanceof RegExp) return obj.toString();
+  if (obj instanceof Error) return `${obj.name}: ${obj.message}`;
+  if (Array.isArray(obj)) return `[ ${obj.map(v => inspect(v)).join(", ")} ]`;
+  if (obj instanceof Map)
+    return `Map(${obj.size}) { ${[...obj.entries()]
+      .map(([k, v]) => `${inspect(k)} => ${inspect(v)}`)
+      .join(", ")} }`;
+  if (obj instanceof Set)
+    return `Set(${obj.size}) { ${[...obj].map(v => inspect(v)).join(", ")} }`;
+  try {
+    return JSON.stringify(obj, null, 2);
+  } catch {
+    return "[Object]";
+  }
+}
+inspect.custom = Symbol.for("nodejs.util.inspect.custom");
+
+export function inherits(ctor: Function, superCtor: Function): void {
+  Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
+  Object.setPrototypeOf(ctor, superCtor);
+}
+
+export function deprecate<T extends Function>(fn: T, msg: string): T {
+  let warned = false;
+  return function (this: unknown, ...args: unknown[]) {
+    if (!warned) {
+      console.warn("DeprecationWarning:", msg);
+      warned = true;
+    }
+    return fn.apply(this, args);
+  } as unknown as T;
+}
+
+export function promisify<T extends Function>(
+  fn: T,
+): (...args: unknown[]) => Promise<unknown> {
+  return (...args: unknown[]) =>
+    new Promise((resolve, reject) => {
+      fn(...args, (err: Error | null, ...result: unknown[]) => {
+        if (err) reject(err);
+        else resolve(result.length <= 1 ? result[0] : result);
+      });
+    });
+}
+
+export function callbackify(
+  fn: (...args: unknown[]) => Promise<unknown>,
+): (...args: unknown[]) => void {
+  return (...args: unknown[]) => {
+    const cb = args.pop() as Function;
+    fn(...args)
+      .then(result => cb(null, result))
+      .catch(err => cb(err));
+  };
+}
+
+export function debuglog(section: string): (...args: unknown[]) => void {
+  const enabled =
+    typeof process !== "undefined" &&
+    process.env?.NODE_DEBUG?.includes(section);
+  return enabled
+    ? (...args) =>
+        console.error(`${section.toUpperCase()} ${process?.pid || 0}:`, ...args)
+    : () => {};
+}
+
+export function isDeepStrictEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return false;
+  if (typeof a !== "object") return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((v, i) => isDeepStrictEqual(v, b[i]));
+  }
+  const keysA = Object.keys(a as object);
+  const keysB = Object.keys(b as object);
+  if (keysA.length !== keysB.length) return false;
+  return keysA.every(k =>
+    isDeepStrictEqual(
+      (a as Record<string, unknown>)[k],
+      (b as Record<string, unknown>)[k],
+    ),
+  );
+}
+
+export const types = {
+  isDate: (v: unknown): v is Date => v instanceof Date,
+  isRegExp: (v: unknown): v is RegExp => v instanceof RegExp,
+  isPromise: (v: unknown): v is Promise<unknown> => v instanceof Promise,
+  isMap: (v: unknown): v is Map<unknown, unknown> => v instanceof Map,
+  isSet: (v: unknown): v is Set<unknown> => v instanceof Set,
+  isTypedArray: (v: unknown): boolean =>
+    ArrayBuffer.isView(v) && !(v instanceof DataView),
+  isUint8Array: (v: unknown): v is Uint8Array => v instanceof Uint8Array,
+  isArrayBuffer: (v: unknown): v is ArrayBuffer => v instanceof ArrayBuffer,
+  isSharedArrayBuffer: (v: unknown): boolean =>
+    typeof SharedArrayBuffer !== "undefined" && v instanceof SharedArrayBuffer,
+  isProxy: (_v: unknown): boolean => false,
+  isNativeError: (v: unknown): v is Error => v instanceof Error,
+  isGeneratorFunction: (v: unknown): boolean =>
+    typeof v === "function" && v.constructor?.name === "GeneratorFunction",
+  isAsyncFunction: (v: unknown): boolean =>
+    typeof v === "function" && v.constructor?.name === "AsyncFunction",
+};
+
+export class TextEncoder extends globalThis.TextEncoder {}
+export class TextDecoder extends globalThis.TextDecoder {}
+
+export default {
+  format,
+  inspect,
+  inherits,
+  deprecate,
+  promisify,
+  callbackify,
+  debuglog,
+  isDeepStrictEqual,
+  types,
+  TextEncoder,
+  TextDecoder,
+};

package/src/polyfills/v8.ts

@@ -0,0 +1,62 @@
+export function getHeapStatistics(): Record<string, number> {
+  return {
+    total_heap_size: 30 * 1024 * 1024,
+    used_heap_size: 20 * 1024 * 1024,
+    heap_size_limit: 512 * 1024 * 1024,
+    total_physical_size: 30 * 1024 * 1024,
+    total_available_size: 400 * 1024 * 1024,
+    malloced_memory: 0,
+    peak_malloced_memory: 0,
+    does_zap_garbage: 0,
+    number_of_native_contexts: 1,
+    number_of_detached_contexts: 0,
+    total_global_handles_size: 0,
+    used_global_handles_size: 0,
+    external_memory: 0,
+  };
+}
+export function getHeapSpaceStatistics(): Record<string, unknown>[] {
+  return [];
+}
+export function getHeapSnapshot(): unknown {
+  return {
+    toString() {
+      return "{}";
+    },
+  };
+}
+export function writeHeapSnapshot(_filename?: string): string {
+  return "";
+}
+export function setFlagsFromString(_flags: string): void {}
+export function serialize(value: unknown): Uint8Array {
+  return new TextEncoder().encode(JSON.stringify(value));
+}
+export function deserialize(buffer: Uint8Array): unknown {
+  return JSON.parse(new TextDecoder().decode(buffer));
+}
+export const DefaultSerializer = class {
+  writeHeader() {}
+  writeValue(_v: unknown) {}
+  releaseBuffer() {
+    return new Uint8Array(0);
+  }
+};
+export const DefaultDeserializer = class {
+  constructor(_buf: Uint8Array) {}
+  readHeader() {}
+  readValue() {
+    return null;
+  }
+};
+export default {
+  getHeapStatistics,
+  getHeapSpaceStatistics,
+  getHeapSnapshot,
+  writeHeapSnapshot,
+  setFlagsFromString,
+  serialize,
+  deserialize,
+  DefaultSerializer,
+  DefaultDeserializer,
+};

package/src/polyfills/vm.ts

@@ -0,0 +1,111 @@
+/**
+ * Browser polyfill for Node.js `vm` module.
+ *
+ * **IMPORTANT: Security Limitation**
+ *
+ * This is NOT a true sandbox. In Node.js, `vm` creates a V8 context with its own
+ * global object, providing isolation from the host environment. In the browser,
+ * this polyfill uses `new Function()` which executes code in the same JavaScript
+ * realm as the host page.
+ *
+ * Implications:
+ * - Code executed via `runInContext()` / `runInNewContext()` can access and modify
+ *   global browser objects (window, document, etc.) through prototype chain traversal.
+ * - There is NO memory isolation — the executed code shares the same heap.
+ * - `createContext()` simply returns the sandbox object without creating an isolated context.
+ * - The `Script` class wraps code in `new Function()`, not a separate V8 context.
+ *
+ * This polyfill is suitable for:
+ * - Module evaluation (CommonJS require simulation)
+ * - Template rendering that expects vm-like API
+ * - Code that uses vm for convenience, not security
+ *
+ * This polyfill is NOT suitable for:
+ * - Untrusted code execution
+ * - Security sandboxing
+ * - Scenarios requiring true memory/scope isolation
+ *
+ * @module vm
+ */
+
+/**
+ * Create a "context" from a sandbox object.
+ * In the browser, this simply returns the sandbox as-is since we cannot
+ * create a true V8 context. The returned object is used as the scope
+ * for `runInContext()`.
+ */
+export function createContext(
+  sandbox?: Record<string, unknown>,
+): Record<string, unknown> {
+  return sandbox || {};
+}
+
+/**
+ * Execute code in the given context.
+ * Uses `new Function()` — does NOT provide true V8 context isolation.
+ * @see Module-level JSDoc for security limitations.
+ */
+export function runInContext(
+  code: string,
+  context: Record<string, unknown>,
+): unknown {
+  const keys = Object.keys(context);
+  const values = keys.map(k => context[k]);
+  const fn = new Function(...keys, `return (${code})`);
+  return fn(...values);
+}
+
+/**
+ * Execute code in a new context created from the sandbox.
+ * Equivalent to `runInContext(code, createContext(sandbox))`.
+ * @see Module-level JSDoc for security limitations.
+ */
+export function runInNewContext(
+  code: string,
+  sandbox?: Record<string, unknown>,
+): unknown {
+  return runInContext(code, sandbox || {});
+}
+
+/**
+ * Execute code in the current global context via `new Function()`.
+ * @see Module-level JSDoc for security limitations.
+ */
+export function runInThisContext(code: string): unknown {
+  return new Function(`return (${code})`)();
+}
+
+/** Always returns true since we cannot distinguish real V8 contexts in the browser. */
+export function isContext(_sandbox: unknown): boolean {
+  return true;
+}
+
+/**
+ * Wraps code in a `new Function()` call for deferred execution.
+ * Does NOT create a V8 Script object — no compilation caching occurs.
+ * @see Module-level JSDoc for security limitations.
+ */
+export class Script {
+  private code: string;
+  constructor(code: string, _options?: unknown) {
+    this.code = code;
+  }
+  runInContext(context: Record<string, unknown>): unknown {
+    return runInContext(this.code, context);
+  }
+  runInNewContext(sandbox?: Record<string, unknown>): unknown {
+    return runInNewContext(this.code, sandbox);
+  }
+  runInThisContext(): unknown {
+    return runInThisContext(this.code);
+  }
+}
+
+export default {
+  createContext,
+  runInContext,
+  runInNewContext,
+  runInThisContext,
+  isContext,
+  Script,
+};

package/src/polyfills/worker-threads.ts

@@ -0,0 +1,189 @@
+/**
+ * Enhanced worker_threads polyfill.
+ *
+ * Provides a more complete implementation of Node.js worker_threads API.
+ * When Web Workers are available (browser), `new Worker()` spawns a real
+ * Web Worker for parallel execution. When unavailable (tests), it falls
+ * back to in-process emulation via EventEmitter pairs.
+ *
+ * Supported:
+ * - `Worker` class with `postMessage`/`on('message')` communication
+ * - `parentPort` for child-to-parent messaging
+ * - `workerData` for initial data transfer
+ * - `isMainThread` flag
+ * - `threadId` counter
+ * - `MessageChannel` / `MessagePort` pairs
+ */
+
+import { EventEmitter } from "./events";
+
+let _threadIdCounter = 1;
+
+// ---------------------------------------------------------------------------
+// MessagePort / MessageChannel
+// ---------------------------------------------------------------------------
+
+export class MessagePort extends EventEmitter {
+  private _partner: MessagePort | null = null;
+  private _started = false;
+  private _closed = false;
+  private _queue: unknown[] = [];
+
+  postMessage(value: unknown): void {
+    if (this._closed) return;
+    if (this._partner) {
+      if (this._partner._started) {
+        // Deliver asynchronously like real MessagePort
+        queueMicrotask(() => this._partner?.emit("message", value));
+      } else {
+        this._partner._queue.push(value);
+      }
+    }
+  }
+
+  start(): void {
+    this._started = true;
+    // Flush queued messages
+    for (const msg of this._queue) {
+      queueMicrotask(() => this.emit("message", msg));
+    }
+    this._queue.length = 0;
+  }
+
+  close(): void {
+    this._closed = true;
+    this.emit("close");
+  }
+
+  ref(): this {
+    return this;
+  }
+  unref(): this {
+    return this;
+  }
+
+  /** @internal Connect two ports as partners. */
+  static _pair(): [MessagePort, MessagePort] {
+    const a = new MessagePort();
+    const b = new MessagePort();
+    a._partner = b;
+    b._partner = a;
+    return [a, b];
+  }
+}
+
+export class MessageChannel {
+  port1: MessagePort;
+  port2: MessagePort;
+
+  constructor() {
+    [this.port1, this.port2] = MessagePort._pair();
+    this.port1.start();
+    this.port2.start();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Worker
+// ---------------------------------------------------------------------------
+
+export class Worker extends EventEmitter {
+  readonly threadId: number;
+  private _port: MessagePort;
+  private _workerPort: MessagePort;
+
+  constructor(
+    _filename: string,
+    options?: { workerData?: unknown; eval?: boolean },
+  ) {
+    super();
+    this.threadId = _threadIdCounter++;
+
+    // Create a MessageChannel pair for parent <-> worker communication
+    [this._port, this._workerPort] = MessagePort._pair();
+    this._port.start();
+    this._workerPort.start();
+
+    // Forward messages from the worker port to the Worker's 'message' event
+    this._port.on("message", (msg: unknown) => {
+      this.emit("message", msg);
+    });
+
+    // Expose parentPort-like API on the worker side
+    const workerData = options?.workerData;
+    const workerPort = this._workerPort;
+
+    // In a real implementation, we'd execute the file in an isolated context.
+    // For now, make the worker port and data available via the module-level exports.
+    _lastWorkerPort = workerPort;
+    _lastWorkerData = workerData;
+
+    // Emit 'online' asynchronously
+    queueMicrotask(() => this.emit("online"));
+  }
+
+  postMessage(value: unknown): void {
+    this._workerPort.emit("message", value);
+  }
+
+  terminate(): Promise<number> {
+    this._port.close();
+    this._workerPort.close();
+    this.emit("exit", 0);
+    return Promise.resolve(0);
+  }
+
+  ref(): this {
+    return this;
+  }
+  unref(): this {
+    return this;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Module-level exports (mimics Node.js worker_threads)
+// ---------------------------------------------------------------------------
+
+/** Whether the current context is the main thread. */
+export const isMainThread = true;
+
+/** Thread ID of the current thread. */
+export const threadId = 0;
+
+// These are set when a Worker is created, allowing test code to access them.
+let _lastWorkerPort: MessagePort | null = null;
+let _lastWorkerData: unknown = undefined;
+
+/** Parent port (only available inside a worker thread). */
+export const parentPort: MessagePort | null = null;
+
+/** Data passed to the worker via `workerData` option. */
+export const workerData: unknown = undefined;
+
+/**
+ * Get the last created worker's port (for testing).
+ * @internal
+ */
+export function _getLastWorkerPort(): MessagePort | null {
+  return _lastWorkerPort;
+}
+
+/**
+ * Get the last created worker's data (for testing).
+ * @internal
+ */
+export function _getLastWorkerData(): unknown {
+  return _lastWorkerData;
+}
+
+/** Default export matching Node.js worker_threads module shape. */
+export default {
+  Worker,
+  isMainThread,
+  parentPort,
+  workerData,
+  threadId,
+  MessageChannel,
+  MessagePort,
+};

package/src/polyfills/ws.ts

@@ -0,0 +1,73 @@
+import { EventEmitter } from "./events";
+
+export class WebSocketShim extends EventEmitter {
+  readyState = 0;
+  url: string;
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  CONNECTING = 0;
+  OPEN = 1;
+  CLOSING = 2;
+  CLOSED = 3;
+
+  private _ws: WebSocket | null = null;
+
+  constructor(url: string, _protocols?: string | string[], _options?: unknown) {
+    super();
+    this.url = url;
+    try {
+      this._ws = new WebSocket(url);
+      this._ws.binaryType = "arraybuffer";
+      this._ws.onopen = () => {
+        this.readyState = 1;
+        this.emit("open");
+      };
+      this._ws.onmessage = e => this.emit("message", e.data);
+      this._ws.onerror = e => this.emit("error", e);
+      this._ws.onclose = e => {
+        this.readyState = 3;
+        this.emit("close", e.code, e.reason);
+      };
+    } catch (err) {
+      setTimeout(() => this.emit("error", err), 0);
+    }
+  }
+
+  send(data: unknown, _options?: unknown, cb?: (err?: Error) => void): void {
+    try {
+      this._ws?.send(data as string | ArrayBuffer);
+      cb?.();
+    } catch (err) {
+      cb?.(err as Error);
+    }
+  }
+
+  close(code?: number, reason?: string): void {
+    this.readyState = 2;
+    this._ws?.close(code, reason);
+  }
+
+  ping(_data?: unknown, _mask?: boolean, _cb?: () => void): void {}
+  pong(_data?: unknown, _mask?: boolean, _cb?: () => void): void {}
+  terminate(): void {
+    this.close();
+  }
+}
+
+export class WebSocketServer extends EventEmitter {
+  clients = new Set<WebSocketShim>();
+  constructor(_options?: unknown) {
+    super();
+  }
+  close(_cb?: () => void): void {
+    this.emit("close");
+  }
+  address(): { port: number; family: string; address: string } {
+    return { port: 0, family: "IPv4", address: "0.0.0.0" };
+  }
+}
+
+export { WebSocketShim as WebSocket };
+export default WebSocketShim;