@run0/jiki 0.1.0

package/src/frameworks/vite-dev-server.ts

@@ -0,0 +1,370 @@
+/**
+ * Vite-compatible dev server for jiki.
+ *
+ * Serves files as ES modules with on-the-fly esbuild-wasm transpilation.
+ * Supports React, Vue, Svelte, and any Vite-compatible framework by
+ * transforming files before serving.
+ *
+ * Features:
+ * - ESM-based module serving (no bundling, fast per-module transforms)
+ * - `/@modules/<pkg>` for bare import resolution from node_modules
+ * - CSS → JS module injection (injects `<style>` tags at runtime)
+ * - HMR update emission on file changes
+ * - HTML generation with module script tags
+ */
+
+import {
+  DevServer,
+  type DevServerOptions,
+  type ResponseData,
+  type HMRUpdate,
+} from "../dev-server";
+import { MemFS } from "../memfs";
+import { BufferImpl as Buffer } from "../polyfills/stream";
+import * as pathShim from "../polyfills/path";
+import { processSource, transformEsmToCjs } from "../code-transform";
+
+// ---------------------------------------------------------------------------
+// Options
+// ---------------------------------------------------------------------------
+
+export interface ViteDevServerOptions extends DevServerOptions {
+  /** Entry HTML file (default: `/index.html`). */
+  entry?: string;
+  /** Framework preset for transform hints. */
+  framework?: "react" | "vue" | "svelte" | "solid" | "vanilla";
+  /** JSX import source (default: `react` for react, `solid-js` for solid). */
+  jsxImportSource?: string;
+}
+
+// ---------------------------------------------------------------------------
+// ViteDevServer
+// ---------------------------------------------------------------------------
+
+export class ViteDevServer extends DevServer {
+  private entry: string;
+  private framework: string;
+  private jsxImportSource: string;
+
+  constructor(vfs: MemFS, options: ViteDevServerOptions) {
+    super(vfs, options);
+    this.entry = options.entry || "/index.html";
+    this.framework = options.framework || "react";
+    this.jsxImportSource =
+      options.jsxImportSource ||
+      (this.framework === "solid" ? "solid-js" : "react");
+  }
+
+  async handleRequest(
+    method: string,
+    url: string,
+    headers: Record<string, string>,
+    body?: Buffer,
+  ): Promise<ResponseData> {
+    if (method === "OPTIONS") return this.handleOptionsRequest();
+
+    const parsed = new URL(url, "http://localhost");
+    const pathname = decodeURIComponent(parsed.pathname);
+
+    // Serve HMR client
+    if (pathname === "/@vite/client") {
+      return this.addCorsHeaders(this.serveHmrClient());
+    }
+
+    // Resolve bare imports: /@modules/react → node_modules/react
+    if (pathname.startsWith("/@modules/")) {
+      const pkgPath = pathname.slice("/@modules/".length);
+      return this.addCorsHeaders(await this.serveBareImport(pkgPath));
+    }
+
+    // Serve HTML
+    if (pathname === "/" || pathname.endsWith(".html")) {
+      const htmlPath =
+        pathname === "/" ? this.entry : pathShim.join(this.root, pathname);
+      return this.addCorsHeaders(this.serveHtml(htmlPath));
+    }
+
+    // Serve and transform JS/TS/JSX/TSX
+    if (this.isTransformable(pathname)) {
+      return this.addCorsHeaders(await this.serveTransformed(pathname));
+    }
+
+    // Serve CSS as JS module
+    if (pathname.endsWith(".css")) {
+      return this.addCorsHeaders(this.serveCssAsModule(pathname));
+    }
+
+    // Serve static files as-is
+    return this.addCorsHeaders(this.serveFile(pathname));
+  }
+
+  startWatching(): void {
+    this.vfs.on("change", (path: string) => {
+      if (this.isTransformable(path) || path.endsWith(".css")) {
+        this.broadcastChange({
+          type: "update",
+          path,
+          timestamp: Date.now(),
+        });
+      } else if (path.endsWith(".html")) {
+        this.broadcastChange({
+          type: "full-reload",
+          path,
+          timestamp: Date.now(),
+        });
+      }
+    });
+  }
+
+  // -- HTML serving ---------------------------------------------------------
+
+  private serveHtml(htmlPath: string): ResponseData {
+    const resolved = this.resolvePath(htmlPath);
+    try {
+      let html = this.vfs.readFileSync(resolved, "utf8");
+      // Inject HMR client script
+      html = html.replace(
+        "</head>",
+        `<script type="module" src="/@vite/client"></script>\n</head>`,
+      );
+      const buf = Buffer.from(html);
+      return {
+        statusCode: 200,
+        statusMessage: "OK",
+        headers: {
+          "Content-Type": "text/html; charset=utf-8",
+          "Content-Length": String(buf.length),
+          "Cache-Control": "no-cache",
+        },
+        body: buf,
+      };
+    } catch {
+      // If no index.html, generate a minimal one
+      return this.generateDefaultHtml();
+    }
+  }
+
+  private generateDefaultHtml(): ResponseData {
+    const html = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Vite App</title>
+  <script type="module" src="/@vite/client"></script>
+</head>
+<body>
+  <div id="root"></div>
+  <div id="app"></div>
+  <script type="module" src="/src/main.tsx"></script>
+  <script type="module" src="/src/main.ts"></script>
+  <script type="module" src="/src/main.jsx"></script>
+  <script type="module" src="/src/main.js"></script>
+</body>
+</html>`;
+    const buf = Buffer.from(html);
+    return {
+      statusCode: 200,
+      statusMessage: "OK",
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        "Content-Length": String(buf.length),
+        "Cache-Control": "no-cache",
+      },
+      body: buf,
+    };
+  }
+
+  // -- Module transforms ----------------------------------------------------
+
+  private isTransformable(path: string): boolean {
+    return /\.(js|ts|tsx|jsx|mjs|cjs)$/.test(path);
+  }
+
+  private async serveTransformed(pathname: string): Promise<ResponseData> {
+    const filePath = this.resolvePath(pathname);
+    try {
+      const source = this.vfs.readFileSync(filePath, "utf8");
+      let code = this.transformModule(source, filePath);
+      // Rewrite bare imports to /@modules/ prefix
+      code = this.rewriteBareImports(code);
+      // Rewrite relative CSS imports to request path
+      code = this.rewriteCssImports(code, pathname);
+
+      const buf = Buffer.from(code);
+      return {
+        statusCode: 200,
+        statusMessage: "OK",
+        headers: {
+          "Content-Type": "application/javascript; charset=utf-8",
+          "Content-Length": String(buf.length),
+          "Cache-Control": "no-cache",
+        },
+        body: buf,
+      };
+    } catch (err) {
+      return this.serverError(err);
+    }
+  }
+
+  private transformModule(source: string, filePath: string): string {
+    try {
+      return processSource(source, filePath);
+    } catch {
+      // If processSource fails (e.g. transpiler not initialised),
+      // return the source with basic ESM-to-CJS conversion
+      try {
+        return transformEsmToCjs(source, filePath);
+      } catch {
+        return source;
+      }
+    }
+  }
+
+  /**
+   * Rewrite bare import specifiers to /@modules/ URLs.
+   * e.g. `import React from "react"` → `import React from "/@modules/react"`
+   */
+  private rewriteBareImports(code: string): string {
+    // Match: require("pkg"), require("@scope/pkg"), require("pkg/sub")
+    return code.replace(
+      /require\(["']([^./][^"']*)["']\)/g,
+      (match, specifier) => {
+        // Skip node: builtins
+        if (specifier.startsWith("node:")) return match;
+        return `require("/@modules/${specifier}")`;
+      },
+    );
+  }
+
+  /**
+   * Rewrite CSS imports to use absolute paths.
+   */
+  private rewriteCssImports(code: string, fromPath: string): string {
+    const dir = pathShim.dirname(fromPath);
+    return code.replace(
+      /require\(["'](\.\.?\/[^"']*\.css)["']\)/g,
+      (_match, relPath) => {
+        const abs = pathShim.resolve(dir, relPath);
+        return `require("${abs}")`;
+      },
+    );
+  }
+
+  // -- CSS as JS module -----------------------------------------------------
+
+  private serveCssAsModule(pathname: string): ResponseData {
+    const filePath = this.resolvePath(pathname);
+    try {
+      const css = this.vfs.readFileSync(filePath, "utf8");
+      // Wrap CSS in a JS module that injects a <style> tag
+      const escaped = css
+        .replace(/\\/g, "\\\\")
+        .replace(/`/g, "\\`")
+        .replace(/\$/g, "\\$");
+      const code = [
+        `const css = \`${escaped}\`;`,
+        `if (typeof document !== 'undefined') {`,
+        `  const style = document.createElement('style');`,
+        `  style.setAttribute('data-vite-css', '${pathname}');`,
+        `  style.textContent = css;`,
+        `  document.head.appendChild(style);`,
+        `}`,
+        `module.exports = {};`,
+      ].join("\n");
+
+      const buf = Buffer.from(code);
+      return {
+        statusCode: 200,
+        statusMessage: "OK",
+        headers: {
+          "Content-Type": "application/javascript; charset=utf-8",
+          "Content-Length": String(buf.length),
+          "Cache-Control": "no-cache",
+        },
+        body: buf,
+      };
+    } catch {
+      return this.notFound(pathname);
+    }
+  }
+
+  // -- Bare import resolution -----------------------------------------------
+
+  private async serveBareImport(pkgPath: string): Promise<ResponseData> {
+    // Resolve from node_modules
+    const nmPath = pathShim.join(this.root, "node_modules", pkgPath);
+
+    // Check if it's a direct file
+    if (this.exists(nmPath) && !this.isDirectory(nmPath)) {
+      return this.serveTransformed(`/node_modules/${pkgPath}`);
+    }
+
+    // Try to resolve via package.json main/module/exports
+    const pkgJsonPath = pathShim.join(nmPath, "package.json");
+    if (this.exists(pkgJsonPath)) {
+      try {
+        const pkg = JSON.parse(this.vfs.readFileSync(pkgJsonPath, "utf8"));
+        const entry = pkg.module || pkg.main || "index.js";
+        const entryPath = pathShim.join(nmPath, entry);
+        if (this.exists(entryPath)) {
+          return this.serveTransformed(`/node_modules/${pkgPath}/${entry}`);
+        }
+      } catch {}
+    }
+
+    // Try common index files
+    for (const idx of ["index.js", "index.mjs", "index.ts"]) {
+      const idxPath = pathShim.join(nmPath, idx);
+      if (this.exists(idxPath)) {
+        return this.serveTransformed(`/node_modules/${pkgPath}/${idx}`);
+      }
+    }
+
+    return this.notFound(`/@modules/${pkgPath}`);
+  }
+
+  // -- HMR client -----------------------------------------------------------
+
+  private serveHmrClient(): ResponseData {
+    const code = `
+// Minimal Vite HMR client for jiki
+const listeners = new Map();
+
+export function createHotContext(ownerPath) {
+  return {
+    accept(deps, callback) {
+      if (typeof deps === 'function') {
+        listeners.set(ownerPath, deps);
+      } else if (callback) {
+        listeners.set(ownerPath, callback);
+      }
+    },
+    dispose(cb) {},
+    prune(cb) {},
+    decline() {},
+    invalidate() {},
+    on(event, cb) {},
+  };
+}
+
+export const hot = createHotContext('/');
+
+// import.meta.hot compatibility
+if (typeof window !== 'undefined') {
+  window.__vite_hot__ = { createHotContext, listeners };
+}
+`;
+    const buf = Buffer.from(code);
+    return {
+      statusCode: 200,
+      statusMessage: "OK",
+      headers: {
+        "Content-Type": "application/javascript; charset=utf-8",
+        "Content-Length": String(buf.length),
+        "Cache-Control": "no-cache",
+      },
+      body: buf,
+    };
+  }
+}

package/src/fs-errors.ts

@@ -0,0 +1,118 @@
+export interface NodeError extends Error {
+  code: string;
+  errno: number;
+  syscall: string;
+  path?: string;
+}
+
+export type ErrorCode =
+  | "ENOENT"
+  | "ENOTDIR"
+  | "EISDIR"
+  | "EEXIST"
+  | "ENOTEMPTY"
+  | "ELOOP"
+  | "EINVAL"
+  | "EPERM";
+
+const ERRORS: Record<string, { errno: number; text: string }> = {
+  ENOENT: { errno: -2, text: "no such file or directory" },
+  ENOTDIR: { errno: -20, text: "not a directory" },
+  EISDIR: { errno: -21, text: "is a directory" },
+  EEXIST: { errno: -17, text: "file already exists" },
+  ENOTEMPTY: { errno: -39, text: "directory not empty" },
+  ELOOP: { errno: -40, text: "too many levels of symbolic links" },
+  EINVAL: { errno: -22, text: "invalid argument" },
+  EPERM: { errno: -1, text: "operation not permitted" },
+};
+
+export function createNodeError(
+  code: ErrorCode,
+  syscall: string,
+  path: string,
+  message?: string,
+): NodeError {
+  const info = ERRORS[code];
+  const e = new Error(
+    message || `[${code}] ${syscall}: ${info.text} (${path})`,
+  ) as NodeError;
+  e.code = code;
+  e.errno = info.errno;
+  e.syscall = syscall;
+  e.path = path;
+  return e;
+}
+
+export interface Stats {
+  isFile(): boolean;
+  isDirectory(): boolean;
+  isSymbolicLink(): boolean;
+  isBlockDevice(): boolean;
+  isCharacterDevice(): boolean;
+  isFIFO(): boolean;
+  isSocket(): boolean;
+  size: number;
+  mode: number;
+  mtime: Date;
+  atime: Date;
+  ctime: Date;
+  birthtime: Date;
+  mtimeMs: number;
+  atimeMs: number;
+  ctimeMs: number;
+  birthtimeMs: number;
+  nlink: number;
+  uid: number;
+  gid: number;
+  dev: number;
+  ino: number;
+  rdev: number;
+  blksize: number;
+  blocks: number;
+}
+
+let inoSeq = 1;
+
+function modeForType(type: "file" | "directory" | "symlink"): number {
+  if (type === "directory") return 0o755;
+  if (type === "symlink") return 0o777;
+  return 0o644;
+}
+
+export function buildStats(
+  type: "file" | "directory" | "symlink",
+  size: number,
+  mtime: number,
+  ino?: number,
+): Stats {
+  const ts = mtime;
+  const id = ino ?? inoSeq++;
+  const m = modeForType(type);
+  return {
+    isFile: () => type === "file",
+    isDirectory: () => type === "directory",
+    isSymbolicLink: () => type === "symlink",
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    size,
+    mode: m,
+    mtime: new Date(ts),
+    atime: new Date(ts),
+    ctime: new Date(ts),
+    birthtime: new Date(ts),
+    mtimeMs: ts,
+    atimeMs: ts,
+    ctimeMs: ts,
+    birthtimeMs: ts,
+    nlink: 1,
+    uid: 1000,
+    gid: 1000,
+    dev: 0,
+    ino: id,
+    rdev: 0,
+    blksize: 4096,
+    blocks: Math.ceil(size / 512),
+  };
+}

package/src/index.ts

@@ -0,0 +1,188 @@
+// jiki - Lightweight browser-based Node.js runtime (MIT)
+
+export { MemFS } from "./memfs";
+export { MemFS as VirtualFS } from "./memfs";
+export type {
+  FSNode,
+  Stats,
+  WatchEventType,
+  WatchListener,
+  FSWatcher,
+  NodeError,
+} from "./memfs";
+export { createNodeError } from "./memfs";
+
+export { Kernel, Runtime } from "./kernel";
+export type { Module, RuntimeOptions, RequireFunction } from "./kernel";
+export type { AutoInstallProvider } from "./module-resolver";
+export type {
+  IRuntime,
+  IExecuteResult,
+  IRuntimeOptions,
+  VFSSnapshot,
+  VFSFileEntry,
+} from "./runtime-interface";
+
+export { Container, boot, createContainer, registerPlugin } from "./container";
+export type { ContainerOptions, RunResult } from "./container";
+
+export {
+  registerBuiltin,
+  registerBuiltins,
+  unregisterBuiltin,
+  listBuiltins,
+} from "./builtins";
+
+export { PluginRegistry } from "./plugin";
+
+export { IndexedDBAdapter, InMemoryAdapter } from "./persistence";
+export type {
+  PersistenceAdapter,
+  PersistedEntry,
+  IndexedDBAdapterOptions,
+} from "./persistence";
+export type { MemFSOptions } from "./memfs";
+export type {
+  JikiPlugin,
+  PluginHooks,
+  OnResolveArgs,
+  OnResolveResult,
+  OnResolveCallback,
+  OnLoadArgs,
+  OnLoadResult,
+  OnLoadCallback,
+  OnTransformArgs,
+  OnTransformResult,
+  OnTransformCallback,
+  OnInstallCallback,
+  OnBootCallback,
+} from "./plugin";
+
+export { PackageManager, NpmLayout } from "./npm/index";
+export type {
+  LayoutStrategy,
+  InstallOptions,
+  InstallResult,
+} from "./npm/index";
+export { PnpmLayout } from "./npm/pnpm";
+
+export { PackageCache } from "./npm/cache";
+export type { PackageCacheOptions } from "./npm/cache";
+
+export { shouldUseWorker } from "./worker-runtime";
+export type { WorkerMode, WorkerRuntimeConfig } from "./worker-runtime";
+
+export { SandboxGuard } from "./sandbox";
+export type {
+  SandboxOptions,
+  SandboxLimits,
+  SandboxNetwork,
+  SandboxFs,
+} from "./sandbox";
+
+export { Metrics } from "./metrics";
+export type { MetricsSnapshot } from "./metrics";
+
+export {
+  NetworkInterceptor,
+  mockResponseToFetchResponse,
+} from "./network-interceptor";
+export type { MockResponse, FetchHandler } from "./network-interceptor";
+
+export {
+  discoverWorkspaces,
+  resolveWorkspaceDep,
+  isWorkspaceProtocol,
+  linkWorkspaces,
+} from "./npm/workspaces";
+export type { WorkspacePackage } from "./npm/workspaces";
+
+export { TypeChecker } from "./type-checker";
+export type { Diagnostic, TypeCheckerOptions } from "./type-checker";
+
+export {
+  Worker as WorkerThread,
+  MessageChannel,
+  MessagePort,
+} from "./polyfills/worker-threads";
+
+export { Shell, ShellHistory, createShell } from "./shell";
+export type {
+  ShellOptions,
+  ShellProcess,
+  ShellContext,
+  CommandHandler,
+  ShellResult,
+} from "./shell";
+
+export {
+  initTranspiler,
+  transpile,
+  transpileSync,
+  bundle,
+  stopTranspiler,
+  needsTranspilation,
+  setWasmURL,
+  hasSyncSupport,
+} from "./transpiler";
+export type {
+  TranspileOptions,
+  BundleOptions,
+  BundleResult,
+  InitOptions,
+} from "./transpiler";
+
+export { NextDevServer } from "./frameworks/next-dev-server";
+export type { NextDevServerOptions } from "./frameworks/next-dev-server";
+export { ViteDevServer } from "./frameworks/vite-dev-server";
+export type { ViteDevServerOptions } from "./frameworks/vite-dev-server";
+export { SvelteKitDevServer } from "./frameworks/sveltekit-dev-server";
+export type { SvelteKitDevServerOptions } from "./frameworks/sveltekit-dev-server";
+export { RemixDevServer } from "./frameworks/remix-dev-server";
+export type {
+  RemixDevServerOptions,
+  RemixRoute,
+} from "./frameworks/remix-dev-server";
+export { DevServer } from "./dev-server";
+export type { DevServerOptions, HMRUpdate, ResponseData } from "./dev-server";
+
+export {
+  ServerBridge,
+  getServerBridge,
+  resetServerBridge,
+} from "./server-bridge";
+export type {
+  IVirtualServer,
+  VirtualServer,
+  BridgeOptions,
+  InitServiceWorkerOptions,
+} from "./server-bridge";
+
+export {
+  setServerListenCallback,
+  setServerCloseCallback,
+} from "./polyfills/http";
+
+export {
+  bundlePackageForBrowser,
+  generateRequireScript,
+  scanBareImports,
+  preprocessImports,
+  extractPackageName,
+} from "./browser-bundle";
+export type { BrowserBundle, BundleError } from "./browser-bundle";
+
+export {
+  parseError,
+  formatErrorText,
+  formatErrorHtml,
+  errorOverlayScript,
+} from "./errors";
+export type { ContainerError, ErrorCategory } from "./errors";
+
+export * as pathShim from "./polyfills/path";
+export { EventEmitter } from "./polyfills/events";
+export { createProcess } from "./polyfills/process";
+export type { Process, ProcessEnv } from "./polyfills/process";
+export { createFsShim } from "./polyfills/fs";
+export type { FsShim } from "./polyfills/fs";