@run0/jiki 0.1.0

package/dist/polyfills/tty.d.ts

@@ -0,0 +1,25 @@
+import { Readable, Writable } from "./stream";
+export declare class ReadStream extends Readable {
+    isTTY: boolean;
+    isRaw: boolean;
+    setRawMode(mode: boolean): this;
+}
+export declare class WriteStream extends Writable {
+    isTTY: boolean;
+    columns: number;
+    rows: number;
+    getColorDepth(): number;
+    hasColors(count?: number): boolean;
+    getWindowSize(): [number, number];
+    clearLine(_dir: number, _cb?: () => void): boolean;
+    clearScreenDown(_cb?: () => void): boolean;
+    cursorTo(_x: number, _y?: number, _cb?: () => void): boolean;
+    moveCursor(_dx: number, _dy: number, _cb?: () => void): boolean;
+}
+export declare function isatty(_fd: number): boolean;
+declare const _default: {
+    ReadStream: typeof ReadStream;
+    WriteStream: typeof WriteStream;
+    isatty: typeof isatty;
+};
+export default _default;

package/dist/polyfills/url.d.ts

@@ -0,0 +1,41 @@
+export declare const URL: {
+    new (url: string | URL, base?: string | URL): URL;
+    prototype: URL;
+    canParse(url: string | URL, base?: string | URL): boolean;
+    createObjectURL(obj: Blob | MediaSource): string;
+    parse(url: string | URL, base?: string | URL): URL | null;
+    revokeObjectURL(url: string): void;
+};
+export declare const URLSearchParams: {
+    new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+    prototype: URLSearchParams;
+};
+export declare function parse(urlString: string, parseQueryString?: boolean, slashesDenoteHost?: boolean): Record<string, unknown>;
+export declare function format(urlObj: Record<string, unknown>): string;
+export declare function resolve(from: string, to: string): string;
+export declare function fileURLToPath(url: string | URL): string;
+export declare function pathToFileURL(path: string): URL;
+export declare function domainToASCII(domain: string): string;
+export declare function domainToUnicode(domain: string): string;
+declare const _default: {
+    URL: {
+        new (url: string | URL, base?: string | URL): URL;
+        prototype: URL;
+        canParse(url: string | URL, base?: string | URL): boolean;
+        createObjectURL(obj: Blob | MediaSource): string;
+        parse(url: string | URL, base?: string | URL): URL | null;
+        revokeObjectURL(url: string): void;
+    };
+    URLSearchParams: {
+        new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+        prototype: URLSearchParams;
+    };
+    parse: typeof parse;
+    format: typeof format;
+    resolve: typeof resolve;
+    fileURLToPath: typeof fileURLToPath;
+    pathToFileURL: typeof pathToFileURL;
+    domainToASCII: typeof domainToASCII;
+    domainToUnicode: typeof domainToUnicode;
+};
+export default _default;

package/dist/polyfills/util.d.ts

@@ -0,0 +1,61 @@
+export declare function format(fmt: unknown, ...args: unknown[]): string;
+export declare function inspect(obj: unknown, opts?: {
+    depth?: number;
+    colors?: boolean;
+}): string;
+export declare namespace inspect {
+    var custom: symbol;
+}
+export declare function inherits(ctor: Function, superCtor: Function): void;
+export declare function deprecate<T extends Function>(fn: T, msg: string): T;
+export declare function promisify<T extends Function>(fn: T): (...args: unknown[]) => Promise<unknown>;
+export declare function callbackify(fn: (...args: unknown[]) => Promise<unknown>): (...args: unknown[]) => void;
+export declare function debuglog(section: string): (...args: unknown[]) => void;
+export declare function isDeepStrictEqual(a: unknown, b: unknown): boolean;
+export declare const types: {
+    isDate: (v: unknown) => v is Date;
+    isRegExp: (v: unknown) => v is RegExp;
+    isPromise: (v: unknown) => v is Promise<unknown>;
+    isMap: (v: unknown) => v is Map<unknown, unknown>;
+    isSet: (v: unknown) => v is Set<unknown>;
+    isTypedArray: (v: unknown) => boolean;
+    isUint8Array: (v: unknown) => v is Uint8Array;
+    isArrayBuffer: (v: unknown) => v is ArrayBuffer;
+    isSharedArrayBuffer: (v: unknown) => boolean;
+    isProxy: (_v: unknown) => boolean;
+    isNativeError: (v: unknown) => v is Error;
+    isGeneratorFunction: (v: unknown) => boolean;
+    isAsyncFunction: (v: unknown) => boolean;
+};
+export declare class TextEncoder extends globalThis.TextEncoder {
+}
+export declare class TextDecoder extends globalThis.TextDecoder {
+}
+declare const _default: {
+    format: typeof format;
+    inspect: typeof inspect;
+    inherits: typeof inherits;
+    deprecate: typeof deprecate;
+    promisify: typeof promisify;
+    callbackify: typeof callbackify;
+    debuglog: typeof debuglog;
+    isDeepStrictEqual: typeof isDeepStrictEqual;
+    types: {
+        isDate: (v: unknown) => v is Date;
+        isRegExp: (v: unknown) => v is RegExp;
+        isPromise: (v: unknown) => v is Promise<unknown>;
+        isMap: (v: unknown) => v is Map<unknown, unknown>;
+        isSet: (v: unknown) => v is Set<unknown>;
+        isTypedArray: (v: unknown) => boolean;
+        isUint8Array: (v: unknown) => v is Uint8Array;
+        isArrayBuffer: (v: unknown) => v is ArrayBuffer;
+        isSharedArrayBuffer: (v: unknown) => boolean;
+        isProxy: (_v: unknown) => boolean;
+        isNativeError: (v: unknown) => v is Error;
+        isGeneratorFunction: (v: unknown) => boolean;
+        isAsyncFunction: (v: unknown) => boolean;
+    };
+    TextEncoder: typeof TextEncoder;
+    TextDecoder: typeof TextDecoder;
+};
+export default _default;

package/dist/polyfills/v8.d.ts

@@ -0,0 +1,43 @@
+export declare function getHeapStatistics(): Record<string, number>;
+export declare function getHeapSpaceStatistics(): Record<string, unknown>[];
+export declare function getHeapSnapshot(): unknown;
+export declare function writeHeapSnapshot(_filename?: string): string;
+export declare function setFlagsFromString(_flags: string): void;
+export declare function serialize(value: unknown): Uint8Array;
+export declare function deserialize(buffer: Uint8Array): unknown;
+export declare const DefaultSerializer: {
+    new (): {
+        writeHeader(): void;
+        writeValue(_v: unknown): void;
+        releaseBuffer(): Uint8Array<ArrayBuffer>;
+    };
+};
+export declare const DefaultDeserializer: {
+    new (_buf: Uint8Array): {
+        readHeader(): void;
+        readValue(): null;
+    };
+};
+declare const _default: {
+    getHeapStatistics: typeof getHeapStatistics;
+    getHeapSpaceStatistics: typeof getHeapSpaceStatistics;
+    getHeapSnapshot: typeof getHeapSnapshot;
+    writeHeapSnapshot: typeof writeHeapSnapshot;
+    setFlagsFromString: typeof setFlagsFromString;
+    serialize: typeof serialize;
+    deserialize: typeof deserialize;
+    DefaultSerializer: {
+        new (): {
+            writeHeader(): void;
+            writeValue(_v: unknown): void;
+            releaseBuffer(): Uint8Array<ArrayBuffer>;
+        };
+    };
+    DefaultDeserializer: {
+        new (_buf: Uint8Array): {
+            readHeader(): void;
+            readValue(): null;
+        };
+    };
+};
+export default _default;

package/dist/polyfills/vm.d.ts

@@ -0,0 +1,76 @@
+/**
+ * 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 declare function createContext(sandbox?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Execute code in the given context.
+ * Uses `new Function()` — does NOT provide true V8 context isolation.
+ * @see Module-level JSDoc for security limitations.
+ */
+export declare function runInContext(code: string, context: Record<string, unknown>): unknown;
+/**
+ * Execute code in a new context created from the sandbox.
+ * Equivalent to `runInContext(code, createContext(sandbox))`.
+ * @see Module-level JSDoc for security limitations.
+ */
+export declare function runInNewContext(code: string, sandbox?: Record<string, unknown>): unknown;
+/**
+ * Execute code in the current global context via `new Function()`.
+ * @see Module-level JSDoc for security limitations.
+ */
+export declare function runInThisContext(code: string): unknown;
+/** Always returns true since we cannot distinguish real V8 contexts in the browser. */
+export declare function isContext(_sandbox: unknown): boolean;
+/**
+ * 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 declare class Script {
+    private code;
+    constructor(code: string, _options?: unknown);
+    runInContext(context: Record<string, unknown>): unknown;
+    runInNewContext(sandbox?: Record<string, unknown>): unknown;
+    runInThisContext(): unknown;
+}
+declare const _default: {
+    createContext: typeof createContext;
+    runInContext: typeof runInContext;
+    runInNewContext: typeof runInNewContext;
+    runInThisContext: typeof runInThisContext;
+    isContext: typeof isContext;
+    Script: typeof Script;
+};
+export default _default;

package/dist/polyfills/worker-threads.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 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";
+export declare class MessagePort extends EventEmitter {
+    private _partner;
+    private _started;
+    private _closed;
+    private _queue;
+    postMessage(value: unknown): void;
+    start(): void;
+    close(): void;
+    ref(): this;
+    unref(): this;
+    /** @internal Connect two ports as partners. */
+    static _pair(): [MessagePort, MessagePort];
+}
+export declare class MessageChannel {
+    port1: MessagePort;
+    port2: MessagePort;
+    constructor();
+}
+export declare class Worker extends EventEmitter {
+    readonly threadId: number;
+    private _port;
+    private _workerPort;
+    constructor(_filename: string, options?: {
+        workerData?: unknown;
+        eval?: boolean;
+    });
+    postMessage(value: unknown): void;
+    terminate(): Promise<number>;
+    ref(): this;
+    unref(): this;
+}
+/** Whether the current context is the main thread. */
+export declare const isMainThread = true;
+/** Thread ID of the current thread. */
+export declare const threadId = 0;
+/** Parent port (only available inside a worker thread). */
+export declare const parentPort: MessagePort | null;
+/** Data passed to the worker via `workerData` option. */
+export declare const workerData: unknown;
+/**
+ * Get the last created worker's port (for testing).
+ * @internal
+ */
+export declare function _getLastWorkerPort(): MessagePort | null;
+/**
+ * Get the last created worker's data (for testing).
+ * @internal
+ */
+export declare function _getLastWorkerData(): unknown;
+/** Default export matching Node.js worker_threads module shape. */
+declare const _default: {
+    Worker: typeof Worker;
+    isMainThread: boolean;
+    parentPort: null;
+    workerData: unknown;
+    threadId: number;
+    MessageChannel: typeof MessageChannel;
+    MessagePort: typeof MessagePort;
+};
+export default _default;

package/dist/polyfills/ws.d.ts

@@ -0,0 +1,32 @@
+import { EventEmitter } from "./events";
+export declare class WebSocketShim extends EventEmitter {
+    readyState: number;
+    url: string;
+    static CONNECTING: number;
+    static OPEN: number;
+    static CLOSING: number;
+    static CLOSED: number;
+    CONNECTING: number;
+    OPEN: number;
+    CLOSING: number;
+    CLOSED: number;
+    private _ws;
+    constructor(url: string, _protocols?: string | string[], _options?: unknown);
+    send(data: unknown, _options?: unknown, cb?: (err?: Error) => void): void;
+    close(code?: number, reason?: string): void;
+    ping(_data?: unknown, _mask?: boolean, _cb?: () => void): void;
+    pong(_data?: unknown, _mask?: boolean, _cb?: () => void): void;
+    terminate(): void;
+}
+export declare class WebSocketServer extends EventEmitter {
+    clients: Set<WebSocketShim>;
+    constructor(_options?: unknown);
+    close(_cb?: () => void): void;
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    };
+}
+export { WebSocketShim as WebSocket };
+export default WebSocketShim;

package/dist/polyfills/zlib.d.ts

@@ -0,0 +1,87 @@
+import pako from "pako";
+import { BufferImpl, Transform } from "./stream";
+export declare function gzipSync(data: string | Uint8Array): BufferImpl;
+export declare function gunzipSync(data: Uint8Array): BufferImpl;
+export declare function deflateSync(data: string | Uint8Array): BufferImpl;
+export declare function inflateSync(data: Uint8Array): BufferImpl;
+export declare function deflateRawSync(data: string | Uint8Array): BufferImpl;
+export declare function inflateRawSync(data: Uint8Array): BufferImpl;
+export declare function gzip(data: string | Uint8Array, cb: (err: Error | null, result?: BufferImpl) => void): void;
+export declare function gunzip(data: Uint8Array, cb: (err: Error | null, result?: BufferImpl) => void): void;
+export declare function deflate(data: string | Uint8Array, cb: (err: Error | null, result?: BufferImpl) => void): void;
+export declare function inflate(data: Uint8Array, cb: (err: Error | null, result?: BufferImpl) => void): void;
+export declare function unzipSync(data: Uint8Array): BufferImpl;
+export declare function unzip(data: Uint8Array, cb: (err: Error | null, result?: BufferImpl) => void): void;
+declare class ZlibTransform extends Transform {
+    private processor;
+    private _chunks;
+    constructor(processor: pako.Deflate | pako.Inflate);
+    _transform(chunk: unknown, _encoding: string, callback: (err?: Error | null, data?: unknown) => void): void;
+    _flush(callback: (err?: Error | null, data?: unknown) => void): void;
+    end(chunkOrCb?: unknown, encodingOrCb?: string | (() => void), cb?: () => void): this;
+}
+export declare function createGzip(): ZlibTransform;
+export declare function createGunzip(): ZlibTransform;
+export declare function createDeflate(): ZlibTransform;
+export declare function createInflate(): ZlibTransform;
+export declare function brotliCompressSync(data: string | Uint8Array): BufferImpl;
+export declare function brotliDecompressSync(data: Uint8Array): BufferImpl;
+export declare const constants: {
+    Z_NO_FLUSH: number;
+    Z_PARTIAL_FLUSH: number;
+    Z_SYNC_FLUSH: number;
+    Z_FULL_FLUSH: number;
+    Z_FINISH: number;
+    Z_OK: number;
+    Z_STREAM_END: number;
+    Z_NEED_DICT: number;
+    Z_ERRNO: number;
+    Z_STREAM_ERROR: number;
+    Z_DEFAULT_COMPRESSION: number;
+    Z_BEST_SPEED: number;
+    Z_BEST_COMPRESSION: number;
+    Z_NO_COMPRESSION: number;
+    BROTLI_OPERATION_PROCESS: number;
+    BROTLI_OPERATION_FLUSH: number;
+    BROTLI_OPERATION_FINISH: number;
+};
+declare const _default: {
+    gzip: typeof gzip;
+    gzipSync: typeof gzipSync;
+    gunzip: typeof gunzip;
+    gunzipSync: typeof gunzipSync;
+    deflate: typeof deflate;
+    deflateSync: typeof deflateSync;
+    inflate: typeof inflate;
+    inflateSync: typeof inflateSync;
+    deflateRawSync: typeof deflateRawSync;
+    inflateRawSync: typeof inflateRawSync;
+    unzip: typeof unzip;
+    unzipSync: typeof unzipSync;
+    brotliCompressSync: typeof brotliCompressSync;
+    brotliDecompressSync: typeof brotliDecompressSync;
+    createGzip: typeof createGzip;
+    createGunzip: typeof createGunzip;
+    createDeflate: typeof createDeflate;
+    createInflate: typeof createInflate;
+    constants: {
+        Z_NO_FLUSH: number;
+        Z_PARTIAL_FLUSH: number;
+        Z_SYNC_FLUSH: number;
+        Z_FULL_FLUSH: number;
+        Z_FINISH: number;
+        Z_OK: number;
+        Z_STREAM_END: number;
+        Z_NEED_DICT: number;
+        Z_ERRNO: number;
+        Z_STREAM_ERROR: number;
+        Z_DEFAULT_COMPRESSION: number;
+        Z_BEST_SPEED: number;
+        Z_BEST_COMPRESSION: number;
+        Z_NO_COMPRESSION: number;
+        BROTLI_OPERATION_PROCESS: number;
+        BROTLI_OPERATION_FLUSH: number;
+        BROTLI_OPERATION_FINISH: number;
+    };
+};
+export default _default;

package/dist/runtime-helpers.d.ts

@@ -0,0 +1,4 @@
+import type { RequireFunction } from "./kernel";
+export declare function wrapDynamicImport(localRequire: RequireFunction): (specifier: string) => Promise<unknown>;
+export declare function buildConsoleProxy(hook?: (method: string, args: unknown[]) => void): typeof console | Record<string, (...args: unknown[]) => void>;
+export declare function buildModuleWrapper(code: string, filename?: string): (exports: unknown, require: RequireFunction, mod: unknown, __filename: string, __dirname: string, process: unknown, console: unknown, import_meta: unknown, __dynamicImport: unknown) => void;

package/dist/runtime-interface.d.ts

@@ -0,0 +1,39 @@
+import type { MemFS } from "./memfs";
+export interface IRuntimeOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    onConsole?: (method: string, args: unknown[]) => void;
+}
+export interface IModule {
+    id: string;
+    filename: string;
+    exports: unknown;
+    loaded: boolean;
+    children: IModule[];
+    paths: string[];
+}
+export interface IExecuteResult {
+    exports: unknown;
+    module: IModule;
+}
+export interface IRuntime {
+    execute(code: string, filename?: string): Promise<IExecuteResult>;
+    runFile(filename: string): Promise<IExecuteResult>;
+    clearCache(): void;
+    getVFS?(): MemFS;
+    terminate?(): void;
+}
+export interface CreateRuntimeOptions extends IRuntimeOptions {
+    sandbox?: string;
+    dangerouslyAllowSameOrigin?: boolean;
+    useWorker?: boolean | "auto";
+}
+export interface VFSSnapshot {
+    files: VFSFileEntry[];
+}
+export interface VFSFileEntry {
+    path: string;
+    type: "file" | "directory" | "symlink";
+    content?: string;
+    target?: string;
+}

package/dist/sandbox.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Resource limits and sandboxing for jiki containers.
+ *
+ * Provides configurable limits for memory, execution time, file count,
+ * network access, and filesystem path boundaries. Essential for
+ * production deployments where untrusted code runs.
+ *
+ * @example
+ * ```ts
+ * const container = boot({
+ *   sandbox: {
+ *     limits: { maxMemoryMB: 256, maxExecutionMs: 30000, maxFileCount: 10000 },
+ *     network: { allowedHosts: ['registry.npmjs.org'] },
+ *     fs: { allowedPaths: ['/app', '/node_modules'] },
+ *   },
+ * });
+ * ```
+ */
+export interface SandboxLimits {
+    /** Maximum total VFS memory in megabytes. Default: unlimited. */
+    maxMemoryMB?: number;
+    /** Maximum execution time per run/execute call in milliseconds. Default: unlimited. */
+    maxExecutionMs?: number;
+    /** Maximum number of files in the VFS. Default: unlimited. */
+    maxFileCount?: number;
+    /** Maximum single file size in megabytes. Default: unlimited. */
+    maxFileSizeMB?: number;
+}
+export interface SandboxNetwork {
+    /** List of allowed hostnames for network requests. */
+    allowedHosts?: string[];
+    /** Block all network requests. */
+    blockAll?: boolean;
+}
+export interface SandboxFs {
+    /** List of allowed path prefixes. Writes outside these paths are rejected. */
+    allowedPaths?: string[];
+    /** Make the entire VFS read-only. */
+    readOnly?: boolean;
+}
+export interface SandboxOptions {
+    limits?: SandboxLimits;
+    network?: SandboxNetwork;
+    fs?: SandboxFs;
+}
+/**
+ * Enforces resource limits and access controls for a container.
+ */
+export declare class SandboxGuard {
+    private opts;
+    private fileCount;
+    private totalBytes;
+    constructor(options?: SandboxOptions);
+    /** Check if the sandbox has any restrictions configured. */
+    get isActive(): boolean;
+    /** Check if a file write is allowed by size and count limits. */
+    checkWrite(path: string, sizeBytes: number): void;
+    /** Track a file being added to the VFS. */
+    trackWrite(sizeBytes: number): void;
+    /** Track a file being removed from the VFS. */
+    trackDelete(sizeBytes: number): void;
+    /** Check if a network request to the given URL is allowed. */
+    checkNetwork(url: string): void;
+    /** Get the execution timeout in milliseconds, or `undefined` if unlimited. */
+    get executionTimeout(): number | undefined;
+    get currentFileCount(): number;
+    get currentMemoryBytes(): number;
+    get currentMemoryMB(): number;
+}

package/dist/server-bridge.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Server Bridge
+ * Connects Service Worker requests to virtual HTTP servers running in-memory.
+ * Provides the illusion of real HTTP by intercepting /__virtual__/{port}/* URLs.
+ */
+import { EventEmitter } from "./polyfills/events";
+import { BufferImpl as Buffer } from "./polyfills/stream";
+import type { ResponseData } from "./dev-server";
+export interface IVirtualServer {
+    handleRequest(method: string, url: string, headers: Record<string, string>, body?: Buffer | string): Promise<ResponseData>;
+    handleStreamingRequest?(method: string, url: string, headers: Record<string, string>, body: Buffer | undefined, onStart: (statusCode: number, statusMessage: string, headers: Record<string, string>) => void, onChunk: (chunk: string | Uint8Array) => void, onEnd: () => void): Promise<void>;
+}
+export interface VirtualServer {
+    server: IVirtualServer;
+    port: number;
+    hostname: string;
+}
+export interface BridgeOptions {
+    baseUrl?: string;
+    onServerReady?: (port: number, url: string) => void;
+}
+export interface InitServiceWorkerOptions {
+    swUrl?: string;
+}
+export declare class ServerBridge extends EventEmitter {
+    static DEBUG: boolean;
+    /** Maximum time (ms) a queued request will wait for a server to become available. */
+    static REQUEST_QUEUE_TIMEOUT: number;
+    private servers;
+    private baseUrl;
+    private options;
+    private messageChannel;
+    private serviceWorkerReady;
+    private keepaliveInterval;
+    /** Requests queued while waiting for a server to register on a given port. */
+    private requestQueue;
+    constructor(options?: BridgeOptions);
+    registerServer(server: IVirtualServer, port: number, hostname?: string): void;
+    /**
+     * Process any queued requests waiting for a server on the given port.
+     */
+    private drainQueue;
+    unregisterServer(port: number): void;
+    getServerUrl(port: number): string;
+    getServerPorts(): number[];
+    handleRequest(port: number, method: string, url: string, headers: Record<string, string>, body?: ArrayBuffer): Promise<ResponseData>;
+    initServiceWorker(options?: InitServiceWorkerOptions): Promise<void>;
+    private handleServiceWorkerMessage;
+    private handleStreamingBridge;
+    createFetchHandler(): (request: Request) => Promise<Response>;
+    private notifyServiceWorker;
+    dispose(): void;
+}
+export declare function getServerBridge(options?: BridgeOptions): ServerBridge;
+export declare function resetServerBridge(): void;

package/dist/shell-commands.d.ts

@@ -0,0 +1,2 @@
+import type { CommandHandler } from "./shell";
+export declare function createDefaultCommands(): Map<string, CommandHandler>;