@run0/jiki 0.1.0

package/src/polyfills/os.ts

@@ -0,0 +1,108 @@
+export function hostname(): string {
+  return "localhost";
+}
+export function type(): string {
+  return "Linux";
+}
+export function platform(): string {
+  return "linux";
+}
+export function arch(): string {
+  return "x64";
+}
+export function release(): string {
+  return "5.15.0";
+}
+export function tmpdir(): string {
+  return "/tmp";
+}
+export function homedir(): string {
+  return "/";
+}
+export function userInfo(): {
+  username: string;
+  uid: number;
+  gid: number;
+  shell: string;
+  homedir: string;
+} {
+  return {
+    username: "user",
+    uid: 1000,
+    gid: 1000,
+    shell: "/bin/sh",
+    homedir: "/",
+  };
+}
+export function cpus(): {
+  model: string;
+  speed: number;
+  times: { user: number; nice: number; sys: number; idle: number; irq: number };
+}[] {
+  const count =
+    typeof navigator !== "undefined" ? navigator.hardwareConcurrency || 4 : 4;
+  return Array.from({ length: count }, () => ({
+    model: "Browser CPU",
+    speed: 2400,
+    times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 },
+  }));
+}
+export function totalmem(): number {
+  return 8 * 1024 * 1024 * 1024;
+}
+export function freemem(): number {
+  return 4 * 1024 * 1024 * 1024;
+}
+export function uptime(): number {
+  return performance.now() / 1000;
+}
+export function loadavg(): [number, number, number] {
+  return [0, 0, 0];
+}
+export function networkInterfaces(): Record<string, unknown[]> {
+  return {};
+}
+export function endianness(): "BE" | "LE" {
+  return new Uint8Array(new Uint16Array([1]).buffer)[0] === 1 ? "LE" : "BE";
+}
+export const EOL = "\n";
+export const constants = {
+  signals: { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGTERM: 15, SIGKILL: 9 },
+  errno: {},
+  priority: {
+    PRIORITY_LOW: 19,
+    PRIORITY_BELOW_NORMAL: 10,
+    PRIORITY_NORMAL: 0,
+    PRIORITY_ABOVE_NORMAL: -7,
+    PRIORITY_HIGH: -14,
+    PRIORITY_HIGHEST: -20,
+  },
+};
+export function version(): string {
+  return "v20.0.0";
+}
+export function machine(): string {
+  return "x86_64";
+}
+
+export default {
+  hostname,
+  type,
+  platform,
+  arch,
+  release,
+  tmpdir,
+  homedir,
+  userInfo,
+  cpus,
+  totalmem,
+  freemem,
+  uptime,
+  loadavg,
+  networkInterfaces,
+  endianness,
+  EOL,
+  constants,
+  version,
+  machine,
+};

package/src/polyfills/path.ts

@@ -0,0 +1,169 @@
+export const sep = "/";
+export const delimiter = ":";
+
+export function normalize(path: string): string {
+  if (!path) return ".";
+  const isAbs = path.startsWith("/");
+  const parts = path.split("/").filter(Boolean);
+  const resolved: string[] = [];
+  for (const part of parts) {
+    if (part === "..") {
+      if (resolved.length > 0 && resolved[resolved.length - 1] !== "..")
+        resolved.pop();
+      else if (!isAbs) resolved.push("..");
+    } else if (part !== ".") {
+      resolved.push(part);
+    }
+  }
+  let result = resolved.join("/");
+  if (isAbs) result = "/" + result;
+  return result || ".";
+}
+
+export function join(...paths: string[]): string {
+  if (paths.length === 0) return ".";
+  return normalize(paths.filter(Boolean).join("/"));
+}
+
+export function resolve(...paths: string[]): string {
+  let resolvedPath = "";
+  for (let i = paths.length - 1; i >= 0 && !resolvedPath.startsWith("/"); i--) {
+    const p = paths[i];
+    if (!p) continue;
+    resolvedPath = p + (resolvedPath ? "/" + resolvedPath : "");
+  }
+  if (!resolvedPath.startsWith("/")) {
+    const cwd =
+      (typeof globalThis !== "undefined" && globalThis.process?.cwd?.()) || "/";
+    resolvedPath = cwd + (resolvedPath ? "/" + resolvedPath : "");
+  }
+  return normalize(resolvedPath);
+}
+
+export function isAbsolute(path: string): boolean {
+  return path.startsWith("/");
+}
+
+export function dirname(path: string): string {
+  if (!path) return ".";
+  const n = normalize(path);
+  const last = n.lastIndexOf("/");
+  if (last === -1) return ".";
+  if (last === 0) return "/";
+  return n.slice(0, last);
+}
+
+export function basename(path: string, ext?: string): string {
+  if (!path) return "";
+  const n = normalize(path);
+  let base = n.slice(n.lastIndexOf("/") + 1);
+  if (ext && base.endsWith(ext)) base = base.slice(0, -ext.length);
+  return base;
+}
+
+export function extname(path: string): string {
+  const base = basename(path);
+  const dotIndex = base.lastIndexOf(".");
+  if (dotIndex <= 0) return "";
+  return base.slice(dotIndex);
+}
+
+export function relative(from: string, to: string): string {
+  from = resolve(from);
+  to = resolve(to);
+  if (from === to) return "";
+  const fromParts = from.split("/").filter(Boolean);
+  const toParts = to.split("/").filter(Boolean);
+  let common = 0;
+  for (let i = 0; i < Math.min(fromParts.length, toParts.length); i++) {
+    if (fromParts[i] !== toParts[i]) break;
+    common++;
+  }
+  return (
+    [
+      ...Array(fromParts.length - common).fill(".."),
+      ...toParts.slice(common),
+    ].join("/") || "."
+  );
+}
+
+export function parse(path: string): {
+  root: string;
+  dir: string;
+  base: string;
+  ext: string;
+  name: string;
+} {
+  const n = normalize(path);
+  const dir = dirname(n);
+  const base = basename(n);
+  const ext = extname(n);
+  return {
+    root: isAbsolute(n) ? "/" : "",
+    dir,
+    base,
+    ext,
+    name: base.slice(0, base.length - ext.length),
+  };
+}
+
+export function format(obj: {
+  root?: string;
+  dir?: string;
+  base?: string;
+  ext?: string;
+  name?: string;
+}): string {
+  const dir = obj.dir || obj.root || "";
+  const base = obj.base || (obj.name || "") + (obj.ext || "");
+  if (!dir) return base;
+  if (dir === obj.root) return dir + base;
+  return dir + "/" + base;
+}
+
+export const posix = {
+  sep,
+  delimiter,
+  normalize,
+  join,
+  resolve,
+  isAbsolute,
+  dirname,
+  basename,
+  extname,
+  relative,
+  parse,
+  format,
+};
+/** @note win32 uses posix implementation — Windows paths not supported in browser */
+export const win32 = {
+  sep: "\\",
+  delimiter: ";",
+  normalize,
+  join,
+  resolve,
+  isAbsolute,
+  dirname,
+  basename,
+  extname,
+  relative,
+  parse,
+  format,
+};
+
+export default {
+  sep,
+  delimiter,
+  normalize,
+  join,
+  resolve,
+  isAbsolute,
+  dirname,
+  basename,
+  extname,
+  relative,
+  parse,
+  format,
+  posix,
+  win32,
+};

package/src/polyfills/perf_hooks.ts

@@ -0,0 +1,30 @@
+export const performance = globalThis.performance;
+
+export class PerformanceObserver {
+  private callback: (list: unknown) => void;
+  constructor(callback: (list: unknown) => void) {
+    this.callback = callback;
+  }
+  observe(_options?: unknown): void {}
+  disconnect(): void {}
+}
+
+export function monitorEventLoopDelay(_options?: unknown): {
+  enable(): void;
+  disable(): void;
+  min: number;
+  max: number;
+  mean: number;
+  percentile(p: number): number;
+} {
+  return {
+    enable() {},
+    disable() {},
+    min: 0,
+    max: 0,
+    mean: 0,
+    percentile: () => 0,
+  };
+}
+
+export default { performance, PerformanceObserver, monitorEventLoopDelay };

package/src/polyfills/process.ts

@@ -0,0 +1,349 @@
+import { EventEmitter, EventListener } from "./events";
+
+export interface ProcessEnv {
+  [key: string]: string | undefined;
+}
+
+interface ProcessStream {
+  isTTY: boolean;
+  on: (event: string, listener: EventListener) => ProcessStream;
+  once: (event: string, listener: EventListener) => ProcessStream;
+  off: (event: string, listener: EventListener) => ProcessStream;
+  emit: (event: string, ...args: unknown[]) => boolean;
+  addListener: (event: string, listener: EventListener) => ProcessStream;
+  removeListener: (event: string, listener: EventListener) => ProcessStream;
+  removeAllListeners: (event?: string) => ProcessStream;
+  setMaxListeners: (n: number) => ProcessStream;
+  getMaxListeners: () => number;
+  listenerCount: (event: string) => number;
+  listeners: (event: string) => EventListener[];
+  rawListeners: (event: string) => EventListener[];
+  prependListener: (event: string, listener: EventListener) => ProcessStream;
+  prependOnceListener: (
+    event: string,
+    listener: EventListener,
+  ) => ProcessStream;
+  eventNames: () => string[];
+  pause?: () => ProcessStream;
+  resume?: () => ProcessStream;
+  setEncoding?: (encoding: string) => ProcessStream;
+}
+
+interface ProcessWritableStream extends ProcessStream {
+  write: (
+    data: string | Buffer,
+    encoding?: string,
+    callback?: () => void,
+  ) => boolean;
+  end?: (data?: string, callback?: () => void) => void;
+}
+
+interface ProcessReadableStream extends ProcessStream {
+  read?: (size?: number) => string | Buffer | null;
+  setRawMode?: (mode: boolean) => ProcessReadableStream;
+}
+
+export interface Process {
+  env: ProcessEnv;
+  cwd: () => string;
+  chdir: (directory: string) => void;
+  platform: string;
+  arch: string;
+  version: string;
+  versions: { node: string; v8: string; uv: string };
+  argv: string[];
+  argv0: string;
+  execPath: string;
+  execArgv: string[];
+  pid: number;
+  ppid: number;
+  exit: (code?: number) => never;
+  nextTick: (
+    callback: (...args: unknown[]) => void,
+    ...args: unknown[]
+  ) => void;
+  stdout: ProcessWritableStream;
+  stderr: ProcessWritableStream;
+  stdin: ProcessReadableStream;
+  hrtime: { (time?: [number, number]): [number, number]; bigint: () => bigint };
+  memoryUsage: () => {
+    rss: number;
+    heapTotal: number;
+    heapUsed: number;
+    external: number;
+    arrayBuffers: number;
+  };
+  uptime: () => number;
+  cpuUsage: () => { user: number; system: number };
+  on: (event: string, listener: EventListener) => Process;
+  once: (event: string, listener: EventListener) => Process;
+  off: (event: string, listener: EventListener) => Process;
+  emit: (event: string, ...args: unknown[]) => boolean;
+  addListener: (event: string, listener: EventListener) => Process;
+  removeListener: (event: string, listener: EventListener) => Process;
+  removeAllListeners: (event?: string) => Process;
+  listeners: (event: string) => EventListener[];
+  listenerCount: (event: string) => number;
+  prependListener: (event: string, listener: EventListener) => Process;
+  prependOnceListener: (event: string, listener: EventListener) => Process;
+  eventNames: () => string[];
+  setMaxListeners: (n: number) => Process;
+  getMaxListeners: () => number;
+  send?: (
+    message: unknown,
+    callback?: (error: Error | null) => void,
+  ) => boolean;
+  connected?: boolean;
+  _cwdCallCount?: number;
+}
+
+function createProcessStream(
+  isWritable: boolean,
+  writeImpl?: (data: string) => boolean,
+): ProcessWritableStream & ProcessReadableStream {
+  const emitter = new EventEmitter();
+  const stream: ProcessWritableStream & ProcessReadableStream = {
+    isTTY: false,
+    on(event, listener) {
+      emitter.on(event, listener);
+      return stream;
+    },
+    once(event, listener) {
+      emitter.once(event, listener);
+      return stream;
+    },
+    off(event, listener) {
+      emitter.off(event, listener);
+      return stream;
+    },
+    emit(event, ...args) {
+      return emitter.emit(event, ...args);
+    },
+    addListener(event, listener) {
+      emitter.addListener(event, listener);
+      return stream;
+    },
+    removeListener(event, listener) {
+      emitter.removeListener(event, listener);
+      return stream;
+    },
+    removeAllListeners(event?) {
+      emitter.removeAllListeners(event);
+      return stream;
+    },
+    setMaxListeners(n) {
+      emitter.setMaxListeners(n);
+      return stream;
+    },
+    getMaxListeners() {
+      return emitter.getMaxListeners();
+    },
+    listenerCount(event) {
+      return emitter.listenerCount(event);
+    },
+    listeners(event) {
+      return emitter.listeners(event);
+    },
+    rawListeners(event) {
+      return emitter.rawListeners(event);
+    },
+    prependListener(event, listener) {
+      emitter.prependListener(event, listener);
+      return stream;
+    },
+    prependOnceListener(event, listener) {
+      emitter.prependOnceListener(event, listener);
+      return stream;
+    },
+    eventNames() {
+      return emitter.eventNames();
+    },
+    pause() {
+      return stream;
+    },
+    resume() {
+      return stream;
+    },
+    setEncoding() {
+      return stream;
+    },
+    write(data, _encoding?, callback?) {
+      if (callback) queueMicrotask(callback);
+      return true;
+    },
+    end(_data?, callback?) {
+      if (callback) queueMicrotask(callback);
+    },
+    read() {
+      return null;
+    },
+    setRawMode() {
+      return stream;
+    },
+  };
+  if (isWritable && writeImpl) {
+    stream.write = (data, _encoding?, callback?) => {
+      const result = writeImpl(
+        typeof data === "string" ? data : data.toString(),
+      );
+      if (callback) queueMicrotask(callback);
+      return result;
+    };
+  }
+  return stream;
+}
+
+export function createProcess(options?: {
+  cwd?: string;
+  env?: ProcessEnv;
+  onExit?: (code: number) => void;
+  onStdout?: (data: string) => void;
+  onStderr?: (data: string) => void;
+}): Process {
+  let currentDir = options?.cwd || "/";
+  const env: ProcessEnv = {
+    NODE_ENV: "development",
+    PATH: "/usr/local/bin:/usr/bin:/bin:/node_modules/.bin",
+    HOME: "/",
+    ...options?.env,
+  };
+  const emitter = new EventEmitter();
+  const startTime = Date.now();
+
+  const proc: Process = {
+    env,
+    cwd() {
+      return currentDir;
+    },
+    chdir(dir) {
+      currentDir = dir.startsWith("/") ? dir : currentDir + "/" + dir;
+    },
+    platform: "linux",
+    /** Set to 'wasm32' to indicate browser-based WebAssembly runtime */
+    arch: "wasm32",
+    version: "v20.0.0",
+    versions: { node: "20.0.0", v8: "11.3.244.8", uv: "1.44.2" },
+    argv: ["node", "/index.js"],
+    argv0: "node",
+    execPath: "/usr/local/bin/node",
+    execArgv: [],
+    pid: 1,
+    ppid: 0,
+    // process.exit() emits 'beforeExit' and 'exit' events before throwing
+    // to halt execution. In a real Node.js process, 'beforeExit' fires when
+    // the event loop drains. In the browser runtime, we emit it synchronously
+    // before 'exit' as a best-effort approximation. The throw after events
+    // is intentional — it stops execution in the browser environment where
+    // we cannot actually terminate the process.
+    exit(code = 0) {
+      if (!(proc as any)._exiting) {
+        (proc as any)._exiting = true;
+        emitter.emit("beforeExit", code);
+        emitter.emit("exit", code);
+        options?.onExit?.(code);
+      }
+      throw new Error(`Process exited with code ${code}`);
+    },
+    nextTick(cb, ...args) {
+      queueMicrotask(() => cb(...args));
+    },
+    stdout: createProcessStream(true, d => {
+      options?.onStdout?.(d) ?? console.log(d);
+      return true;
+    }) as ProcessWritableStream,
+    stderr: createProcessStream(true, d => {
+      options?.onStderr?.(d) ?? console.error(d);
+      return true;
+    }) as ProcessWritableStream,
+    stdin: Object.assign(createProcessStream(false), {
+      /** Buffer for pending input data. */
+      _buffer: [] as string[],
+      /** Push data into stdin (called by Container.sendInput). */
+      _push(data: string): void {
+        (proc.stdin as any)._buffer.push(data);
+        proc.stdin.emit("data", data);
+      },
+      read(): string | null {
+        const buf = (proc.stdin as any)._buffer;
+        return buf.length > 0 ? buf.shift() : null;
+      },
+    }) as ProcessReadableStream,
+    hrtime: Object.assign(
+      function hrtime(time?: [number, number]): [number, number] {
+        const now = performance.now();
+        const s = Math.floor(now / 1000);
+        const ns = Math.floor((now % 1000) * 1e6);
+        if (time) return [s - time[0], ns - time[1]];
+        return [s, ns];
+      },
+      { bigint: (): bigint => BigInt(Math.floor(performance.now() * 1e6)) },
+    ),
+    connected: false,
+    send: (_message: unknown, _callback?: (error: Error | null) => void) =>
+      false,
+    memoryUsage: () => ({
+      rss: 50 * 1024 * 1024,
+      heapTotal: 30 * 1024 * 1024,
+      heapUsed: 20 * 1024 * 1024,
+      external: 1024 * 1024,
+      arrayBuffers: 0,
+    }),
+    uptime: () => (Date.now() - startTime) / 1000,
+    cpuUsage: () => ({ user: 0, system: 0 }),
+    on(event, listener) {
+      emitter.on(event, listener);
+      return proc;
+    },
+    once(event, listener) {
+      emitter.once(event, listener);
+      return proc;
+    },
+    off(event, listener) {
+      emitter.off(event, listener);
+      return proc;
+    },
+    emit(event, ...args) {
+      return emitter.emit(event, ...args);
+    },
+    addListener(event, listener) {
+      emitter.addListener(event, listener);
+      return proc;
+    },
+    removeListener(event, listener) {
+      emitter.removeListener(event, listener);
+      return proc;
+    },
+    removeAllListeners(event?) {
+      emitter.removeAllListeners(event);
+      return proc;
+    },
+    listeners(event) {
+      return emitter.listeners(event);
+    },
+    listenerCount(event) {
+      return emitter.listenerCount(event);
+    },
+    prependListener(event, listener) {
+      emitter.prependListener(event, listener);
+      return proc;
+    },
+    prependOnceListener(event, listener) {
+      emitter.prependOnceListener(event, listener);
+      return proc;
+    },
+    eventNames() {
+      return emitter.eventNames();
+    },
+    setMaxListeners(n) {
+      emitter.setMaxListeners(n);
+      return proc;
+    },
+    getMaxListeners() {
+      return emitter.getMaxListeners();
+    },
+  };
+  return proc;
+}
+
+export const process = createProcess();
+export default process;

package/src/polyfills/querystring.ts

@@ -0,0 +1,66 @@
+export function stringify(
+  obj: Record<string, unknown>,
+  sep = "&",
+  eq = "=",
+): string {
+  if (!obj) return "";
+  return Object.entries(obj)
+    .filter(([, v]) => v !== undefined)
+    .map(([k, v]) => {
+      if (Array.isArray(v))
+        return v
+          .map(
+            item =>
+              encodeURIComponent(k) + eq + encodeURIComponent(String(item)),
+          )
+          .join(sep);
+      return encodeURIComponent(k) + eq + encodeURIComponent(String(v));
+    })
+    .join(sep);
+}
+
+export function parse(
+  str: string,
+  sep = "&",
+  eq = "=",
+): Record<string, string | string[]> {
+  const result: Record<string, string | string[]> = {};
+  if (!str) return result;
+  for (const part of str.split(sep)) {
+    const idx = part.indexOf(eq);
+    const key = decodeURIComponent(idx >= 0 ? part.slice(0, idx) : part);
+    const value =
+      idx >= 0 ? decodeURIComponent(part.slice(idx + eq.length)) : "";
+    if (key in result) {
+      const existing = result[key];
+      if (Array.isArray(existing)) existing.push(value);
+      else result[key] = [existing, value];
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export function escape(str: string): string {
+  return encodeURIComponent(str);
+}
+export function unescape(str: string): string {
+  return decodeURIComponent(str.replace(/\+/g, " "));
+}
+export function encode(
+  obj: Record<string, unknown>,
+  sep?: string,
+  eq?: string,
+): string {
+  return stringify(obj, sep, eq);
+}
+export function decode(
+  str: string,
+  sep?: string,
+  eq?: string,
+): Record<string, string | string[]> {
+  return parse(str, sep, eq);
+}
+
+export default { stringify, parse, escape, unescape, encode, decode };