@run0/jiki 0.1.0

package/src/builtins.ts

@@ -0,0 +1,222 @@
+// Core polyfills loaded eagerly (used by almost every container).
+import * as _pathMod from "./polyfills/path";
+import _eventsMod from "./polyfills/events";
+import _streamMod, { bufferModule as _bufferMod } from "./polyfills/stream";
+
+export { _bufferMod as bufferPolyfill };
+
+// Secondary polyfills — statically imported but only evaluated via the
+// registry factory on first require(). The `loaded` cache in resolveBuiltin
+// ensures each factory runs at most once. While the modules themselves are
+// loaded at bundle time, no per-module initialization runs until first use.
+import * as _httpMod from "./polyfills/http";
+import * as _netMod from "./polyfills/net";
+import * as _urlMod from "./polyfills/url";
+import * as _qsMod from "./polyfills/querystring";
+import * as _utilMod from "./polyfills/util";
+import * as _ttyMod from "./polyfills/tty";
+import * as _osMod from "./polyfills/os";
+import * as _cryptoMod from "./polyfills/crypto";
+import * as _zlibMod from "./polyfills/zlib";
+import * as _cpMod from "./polyfills/child_process";
+import _assertMod from "./polyfills/assert";
+import * as _readlineMod from "./polyfills/readline";
+import * as _v8Mod from "./polyfills/v8";
+import * as _vmMod from "./polyfills/vm";
+import * as _moduleMod from "./polyfills/module";
+import * as _perfHooksMod from "./polyfills/perf_hooks";
+import * as _chokidarMod from "./polyfills/chokidar";
+import * as _wsMod from "./polyfills/ws";
+import * as _readdirpMod from "./polyfills/readdirp";
+
+// Stubs are imported but each stub is only constructed via its IIFE when
+// first accessed through the registry factory.
+import * as _stubsMod from "./polyfills/stubs";
+import _workerThreadsMod from "./polyfills/worker-threads";
+
+function cloneNamespace(ns: Record<string, unknown>): Record<string, unknown> {
+  const copy: Record<string, unknown> = {};
+  for (const k of Object.keys(ns)) copy[k] = ns[k];
+  return copy;
+}
+
+class StringDecoder {
+  private enc: string;
+  constructor(encoding?: string) {
+    this.enc = encoding || "utf8";
+  }
+  write(buf: Uint8Array): string {
+    return new TextDecoder(this.enc).decode(buf);
+  }
+  end(buf?: Uint8Array): string {
+    return buf ? this.write(buf) : "";
+  }
+}
+
+const FS_CONSTANTS = {
+  O_RDONLY: 0,
+  O_WRONLY: 1,
+  O_RDWR: 2,
+  O_CREAT: 64,
+  O_EXCL: 128,
+  O_TRUNC: 512,
+  O_APPEND: 1024,
+  O_DIRECTORY: 65536,
+  O_NOFOLLOW: 131072,
+  O_SYNC: 1052672,
+  F_OK: 0,
+  R_OK: 4,
+  W_OK: 2,
+  X_OK: 1,
+  S_IFMT: 61440,
+  S_IFREG: 32768,
+  S_IFDIR: 16384,
+  S_IFLNK: 40960,
+  S_IRWXU: 448,
+  S_IRUSR: 256,
+  S_IWUSR: 128,
+  S_IXUSR: 64,
+  UV_FS_COPYFILE_EXCL: 1,
+  COPYFILE_EXCL: 1,
+  UV_FS_COPYFILE_FICLONE: 2,
+} as const;
+
+type Loader = () => unknown;
+
+const registry: Record<string, Loader> = {
+  path: () => _pathMod,
+  events: () => _eventsMod,
+  stream: () => _streamMod,
+  buffer: () => _bufferMod,
+  http: () => cloneNamespace(_httpMod as unknown as Record<string, unknown>),
+  https: () => (_httpMod as any).httpsModule,
+  net: () => _netMod,
+  url: () => _urlMod,
+  querystring: () => _qsMod,
+  util: () => _utilMod,
+  tty: () => _ttyMod,
+  os: () => _osMod,
+  crypto: () => _cryptoMod,
+  zlib: () => _zlibMod,
+  child_process: () => _cpMod,
+  assert: () => _assertMod,
+  readline: () => _readlineMod,
+  v8: () => _v8Mod,
+  vm: () => _vmMod,
+  module: () => _moduleMod,
+  perf_hooks: () => _perfHooksMod,
+  chokidar: () => _chokidarMod,
+  ws: () => _wsMod,
+  readdirp: () => _readdirpMod,
+
+  async_hooks: () => _stubsMod.async_hooks,
+  cluster: () => _stubsMod.cluster,
+  dgram: () => _stubsMod.dgram,
+  diagnostics_channel: () => _stubsMod.diagnostics_channel,
+  dns: () => _stubsMod.dns,
+  domain: () => _stubsMod.domain,
+  esbuild: () => _stubsMod.esbuild,
+  fsevents: () => _stubsMod.fsevents,
+  http2: () => _stubsMod.http2,
+  inspector: () => _stubsMod.inspector,
+  "inspector/promises": () => _stubsMod.inspector,
+  rollup: () => _stubsMod.rollup_stub,
+  tls: () => _stubsMod.tls,
+  worker_threads: () => _workerThreadsMod,
+
+  constants: () => FS_CONSTANTS,
+  string_decoder: () => ({ StringDecoder }),
+  timers: () => ({
+    setTimeout: globalThis.setTimeout.bind(globalThis),
+    setInterval: globalThis.setInterval.bind(globalThis),
+    setImmediate: (fn: () => void) => setTimeout(fn, 0),
+    clearTimeout: globalThis.clearTimeout.bind(globalThis),
+    clearInterval: globalThis.clearInterval.bind(globalThis),
+    clearImmediate: globalThis.clearTimeout.bind(globalThis),
+  }),
+  _http_common: () => ({}),
+  _http_incoming: () => ({}),
+  _http_outgoing: () => ({}),
+  console: () => ({
+    ...console,
+    Console: class Console {
+      log(...a: unknown[]) {
+        console.log(...a);
+      }
+      error(...a: unknown[]) {
+        console.error(...a);
+      }
+      warn(...a: unknown[]) {
+        console.warn(...a);
+      }
+      info(...a: unknown[]) {
+        console.info(...a);
+      }
+    },
+  }),
+  "util/types": () => _utilMod.types,
+  "path/posix": () => _pathMod,
+  "path/win32": () => _pathMod.win32,
+  "timers/promises": () => ({
+    setTimeout: (ms: number) => new Promise(r => setTimeout(r, ms)),
+    setInterval: globalThis.setInterval,
+    setImmediate: (v?: unknown) => new Promise(r => setTimeout(() => r(v), 0)),
+    scheduler: { wait: (ms: number) => new Promise(r => setTimeout(r, ms)) },
+  }),
+};
+
+const loaded: Record<string, unknown> = {};
+
+export function resolveBuiltin(name: string): unknown | undefined {
+  if (loaded[name] !== undefined) return loaded[name];
+  const loader = registry[name];
+  if (!loader) return undefined;
+  const result = loader();
+  loaded[name] = result;
+  return result;
+}
+
+export function isBuiltinModule(name: string): boolean {
+  return (
+    name in registry ||
+    name === "fs" ||
+    name === "fs/promises" ||
+    name === "process"
+  );
+}
+
+/**
+ * Register a custom polyfill for a built-in module name.
+ * Replaces any existing polyfill for the same name.
+ * The factory is called lazily on first `require()`.
+ */
+export function registerBuiltin(name: string, factory: () => unknown): void {
+  registry[name] = factory;
+  // Clear loaded cache so the new factory takes effect on next require().
+  delete loaded[name];
+}
+
+/**
+ * Register multiple custom polyfills at once.
+ */
+export function registerBuiltins(map: Record<string, () => unknown>): void {
+  for (const [name, factory] of Object.entries(map)) {
+    registerBuiltin(name, factory);
+  }
+}
+
+/**
+ * Unregister a custom polyfill, reverting to the default (if any was
+ * overridden) or removing the module entirely.
+ */
+export function unregisterBuiltin(name: string): void {
+  delete registry[name];
+  delete loaded[name];
+}
+
+/** Return a list of all registered builtin module names. */
+export function listBuiltins(): string[] {
+  return Object.keys(registry);
+}
+
+export const builtinModules = loaded;

package/src/code-transform.ts

@@ -0,0 +1,183 @@
+import * as acorn from "acorn";
+import acornJsx from "acorn-jsx";
+import * as pathShim from "./polyfills/path";
+import { transformEsmToCjsSimple } from "./frameworks/code-transforms";
+import { simpleHash } from "./utils/hash";
+
+const jsxParser = acorn.Parser.extend(acornJsx());
+import {
+  needsTranspilation,
+  transpileSync,
+  transpile,
+  isInitialized,
+  hasSyncSupport,
+} from "./transpiler";
+
+const tsCache = new Map<string, string>();
+
+export { tsCache as transpileCache };
+
+export function removeShebang(source: string): string {
+  return source.charCodeAt(0) === 0x23 && source.charCodeAt(1) === 0x21
+    ? source.slice(source.indexOf("\n") + 1)
+    : source;
+}
+
+function rewriteDynamicImports(source: string): string {
+  return source.replace(/(?<![.$\w])import\s*\(/g, "__dynamicImport(");
+}
+
+function visitAstNodes(root: any, fn: (n: any) => void): void {
+  if (!root || typeof root !== "object") return;
+  if (typeof root.type === "string") fn(root);
+  const skip = new Set(["type", "start", "end", "loc", "range"]);
+  for (const prop of Object.keys(root)) {
+    if (skip.has(prop)) continue;
+    const val = root[prop];
+    if (!val || typeof val !== "object") continue;
+    if (Array.isArray(val)) {
+      for (const el of val) {
+        if (el && typeof el === "object" && typeof el.type === "string") {
+          visitAstNodes(el, fn);
+        }
+      }
+    } else if (typeof val.type === "string") {
+      visitAstNodes(val, fn);
+    }
+  }
+}
+
+function esmToCjsViaAst(source: string, _file: string): string {
+  const tree = jsxParser.parse(source, {
+    ecmaVersion: "latest",
+    sourceType: "module",
+  }) as any;
+
+  const patches: { from: number; to: number; text: string }[] = [];
+
+  visitAstNodes(tree, (node: any) => {
+    if (
+      node.type === "MetaProperty" &&
+      node.meta?.name === "import" &&
+      node.property?.name === "meta"
+    ) {
+      patches.push({ from: node.start, to: node.end, text: "import_meta" });
+    }
+    if (node.type === "ImportExpression") {
+      patches.push({
+        from: node.start,
+        to: node.start + 6,
+        text: "__dynamicImport",
+      });
+    }
+  });
+
+  const usesImportDecl = tree.body.some(
+    (n: any) => n.type === "ImportDeclaration",
+  );
+  const usesExportDecl = tree.body.some((n: any) =>
+    n.type?.startsWith("Export"),
+  );
+
+  let result = source;
+  patches.sort((a, b) => b.from - a.from);
+  for (const { from, to, text } of patches) {
+    result = result.slice(0, from) + text + result.slice(to);
+  }
+
+  if (usesImportDecl || usesExportDecl) {
+    result = transformEsmToCjsSimple(result);
+    if (usesExportDecl) {
+      result =
+        'Object.defineProperty(exports, "__esModule", { value: true });\n' +
+        result;
+    }
+  }
+  return result;
+}
+
+function esmToCjsViaRegex(source: string, file: string): string {
+  let out = source;
+  const dir = pathShim.dirname(file);
+  out = out.replace(/\bimport\.meta\.url\b/g, `import_meta.url`);
+  out = out.replace(/\bimport\.meta\.dirname\b/g, `import_meta.dirname`);
+  out = out.replace(/\bimport\.meta\.filename\b/g, `import_meta.filename`);
+  out = out.replace(/\bimport\.meta\b/g, `import_meta`);
+  out = rewriteDynamicImports(out);
+  const hasImport = /\bimport\s+[\w{*'"]/m.test(source);
+  const hasExport =
+    /\bexport\s+(?:default|const|let|var|function|class|{|\*)/m.test(source);
+  if (hasImport || hasExport) {
+    out = transformEsmToCjsSimple(out);
+    if (hasExport) {
+      out =
+        'Object.defineProperty(exports, "__esModule", { value: true });\n' +
+        out;
+    }
+  }
+  return out;
+}
+
+export function transformEsmToCjs(source: string, file: string): string {
+  if (!/\bimport\b|\bexport\b/.test(source)) return source;
+  try {
+    return esmToCjsViaAst(source, file);
+  } catch {
+    return esmToCjsViaRegex(source, file);
+  }
+}
+
+export function processSource(
+  source: string,
+  file: string,
+  sourceMaps?: boolean,
+): string {
+  if (needsTranspilation(file)) {
+    const key = `${file}:${simpleHash(source)}`;
+    const hit = tsCache.get(key);
+    if (hit !== undefined) return hit;
+    if (!isInitialized()) {
+      throw new Error(
+        `Transpiler not initialized. Call kernel.init() before loading TypeScript files (${file}).`,
+      );
+    }
+    if (hasSyncSupport()) {
+      const compiled = transpileSync(source, file, { sourcemap: sourceMaps });
+      const result = transformEsmToCjs(compiled, file);
+      tsCache.set(key, result);
+      return result;
+    }
+    throw new Error(
+      `File "${file}" has not been pre-transpiled. Call kernel.prepareFile("${file}") before running TypeScript in the browser.`,
+    );
+  }
+  return transformEsmToCjs(source, file);
+}
+
+export function getProcessedSource(
+  rawSource: string,
+  filepath: string,
+  cache: Map<string, string>,
+  sourceMaps?: boolean,
+): string {
+  let source = removeShebang(rawSource);
+  const hash = simpleHash(source);
+  const key = `${filepath}:${hash}`;
+  const cached = cache.get(key);
+  if (cached !== undefined) return cached;
+  const result = processSource(source, filepath, sourceMaps);
+  cache.set(key, result);
+  return result;
+}
+
+export async function ensureTranspiled(
+  file: string,
+  source: string,
+): Promise<void> {
+  if (!needsTranspilation(file)) return;
+  const key = `${file}:${simpleHash(source)}`;
+  if (tsCache.has(key)) return;
+  const compiled = await transpile(source, file);
+  const result = transformEsmToCjs(compiled, file);
+  tsCache.set(key, result);
+}

package/src/config/cdn.ts

@@ -0,0 +1,17 @@
+/**
+ * Centralized CDN version pins and URLs.
+ * Change versions here to update them across the entire platform.
+ */
+
+export const REACT_VERSION = "18.2.0";
+export const ESBUILD_WASM_VERSION = "0.20.0";
+export const REACT_REFRESH_VERSION = "0.14.0";
+
+export const REACT_CDN = `https://esm.sh/react@${REACT_VERSION}`;
+export const REACT_DOM_CDN = `https://esm.sh/react-dom@${REACT_VERSION}`;
+export const REACT_REFRESH_CDN = `https://esm.sh/react-refresh@${REACT_REFRESH_VERSION}/runtime`;
+
+export const ESBUILD_WASM_ESM_CDN = `https://esm.sh/esbuild-wasm@${ESBUILD_WASM_VERSION}`;
+export const ESBUILD_WASM_BINARY_CDN = `https://unpkg.com/esbuild-wasm@${ESBUILD_WASM_VERSION}/esbuild.wasm`;
+
+export const TAILWIND_CDN_URL = "https://cdn.tailwindcss.com";