@run0/jiki 0.1.0

package/dist/npm/sync-installer.d.ts

@@ -0,0 +1,18 @@
+import { MemFS } from "../memfs";
+import type { AutoInstallProvider } from "../module-resolver";
+import type { LayoutStrategy } from "./index";
+export declare class SyncAutoInstaller implements AutoInstallProvider {
+    private vfs;
+    private registryUrl;
+    private cwd;
+    private layout;
+    private manifestCache;
+    private installed;
+    constructor(vfs: MemFS, layout: LayoutStrategy, options?: {
+        cwd?: string;
+        registry?: string;
+    });
+    installSync(name: string): void;
+    private installPackageSync;
+    private fetchManifestSync;
+}

package/dist/npm/tarball.d.ts

@@ -0,0 +1,4 @@
+import { MemFS } from "../memfs";
+import type { PackageCache } from "./cache";
+export declare function downloadAndExtract(url: string, vfs: MemFS, destDir: string, stripComponents?: number, cache?: PackageCache): Promise<void>;
+export declare function extractTarball(data: Uint8Array, vfs: MemFS, destDir: string, stripComponents?: number): Promise<void>;

package/dist/npm/workspaces.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Monorepo workspace support.
+ *
+ * Parses `workspaces` field from package.json or `pnpm-workspace.yaml`
+ * and resolves `workspace:*` version specifiers to local packages.
+ *
+ * @example
+ * ```ts
+ * const workspaces = discoverWorkspaces(vfs, '/');
+ * // [{ name: '@myapp/utils', path: '/packages/utils', version: '1.0.0' }]
+ * ```
+ */
+import type { MemFS } from "../memfs";
+export interface WorkspacePackage {
+    /** Package name from its package.json. */
+    name: string;
+    /** Absolute path to the workspace package directory. */
+    path: string;
+    /** Version from its package.json. */
+    version: string;
+}
+/**
+ * Discover all workspace packages in a monorepo.
+ *
+ * Checks for:
+ * 1. `workspaces` field in root package.json (npm/yarn format)
+ * 2. `pnpm-workspace.yaml` (pnpm format)
+ *
+ * Returns an array of discovered workspace packages with their names,
+ * paths, and versions.
+ */
+export declare function discoverWorkspaces(vfs: MemFS, cwd: string): WorkspacePackage[];
+/**
+ * Resolve a `workspace:*` version specifier to the local package path.
+ * Returns the workspace package if found, or `null` if not a workspace dep.
+ */
+export declare function resolveWorkspaceDep(specifier: string, workspaces: WorkspacePackage[]): WorkspacePackage | null;
+/**
+ * Check if a version string is a workspace protocol specifier.
+ */
+export declare function isWorkspaceProtocol(version: string): boolean;
+/**
+ * Create symlinks in node_modules for workspace packages, similar to
+ * how pnpm/yarn link local packages.
+ */
+export declare function linkWorkspaces(vfs: MemFS, cwd: string, workspaces: WorkspacePackage[]): void;

package/dist/persistence.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Persistence layer for MemFS.
+ *
+ * Provides a `PersistenceAdapter` interface and an `IndexedDBAdapter`
+ * implementation that synchronises the in-memory filesystem to IndexedDB.
+ *
+ * Writes are fire-and-forget — they never block the synchronous VFS API.
+ * Mutations are batched and flushed via microtask debounce (~100 ms) so
+ * rapid consecutive writes result in a single IndexedDB transaction.
+ *
+ * @example
+ * ```ts
+ * const adapter = new IndexedDBAdapter('my-project');
+ * const vfs = new MemFS({ persistence: adapter });
+ * await vfs.hydrate(); // load persisted state
+ * vfs.writeFileSync('/hello.txt', 'world'); // auto-persisted
+ * ```
+ */
+import type { FSNode } from "./memfs";
+/** Serialised form of a single filesystem entry stored in the adapter. */
+export interface PersistedEntry {
+    path: string;
+    type: "file" | "directory" | "symlink";
+    /** File content as Uint8Array. Only set for type === "file". */
+    content?: Uint8Array;
+    /** Symlink target. Only set for type === "symlink". */
+    target?: string;
+    mtime: number;
+}
+/**
+ * Backend-agnostic interface for persisting MemFS state.
+ * Implement this to plug in any storage backend (IndexedDB, OPFS,
+ * localStorage, etc.).
+ */
+export interface PersistenceAdapter {
+    /** Persist a single entry (upsert by path). */
+    save(entry: PersistedEntry): void;
+    /** Delete a persisted entry by path. */
+    delete(path: string): void;
+    /** Load all persisted entries. */
+    loadAll(): Promise<PersistedEntry[]>;
+    /** Delete all persisted entries. */
+    clear(): Promise<void>;
+    /** Flush any pending writes immediately. Returns when the flush completes. */
+    flush(): Promise<void>;
+}
+/** Options for the IndexedDB adapter. */
+export interface IndexedDBAdapterOptions {
+    /** IndexedDB database name. Defaults to `"jiki-vfs"`. */
+    dbName?: string;
+    /** Object store name. Defaults to `"files"`. */
+    storeName?: string;
+    /** Batch flush interval in milliseconds. Defaults to 100. */
+    flushIntervalMs?: number;
+}
+/**
+ * Persists MemFS entries to IndexedDB.
+ *
+ * Mutations are batched into a queue and flushed periodically (default
+ * every 100 ms) in a single readwrite transaction for performance.
+ */
+export declare class IndexedDBAdapter implements PersistenceAdapter {
+    private dbName;
+    private storeName;
+    private flushIntervalMs;
+    private db;
+    private queue;
+    private flushTimer;
+    private flushPromise;
+    constructor(options?: IndexedDBAdapterOptions);
+    private openDB;
+    save(entry: PersistedEntry): void;
+    delete(path: string): void;
+    loadAll(): Promise<PersistedEntry[]>;
+    clear(): Promise<void>;
+    flush(): Promise<void>;
+    private scheduleFlush;
+}
+/**
+ * In-memory adapter that stores entries in a `Map`.
+ * Useful for tests and server-side usage where IndexedDB is unavailable.
+ */
+export declare class InMemoryAdapter implements PersistenceAdapter {
+    private store;
+    save(entry: PersistedEntry): void;
+    delete(path: string): void;
+    loadAll(): Promise<PersistedEntry[]>;
+    clear(): Promise<void>;
+    flush(): Promise<void>;
+    /** Return the number of stored entries (test helper). */
+    get size(): number;
+}
+/** Convert an FSNode at the given path to a PersistedEntry. */
+export declare function nodeToEntry(path: string, node: FSNode): PersistedEntry;

package/dist/plugin.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Plugin system for jiki.
+ *
+ * Provides lifecycle hooks that let external code intercept and extend
+ * jiki's behaviour at key points: module resolution, module loading,
+ * code transformation, shell command registration, package installation,
+ * and container boot.
+ *
+ * The API mirrors esbuild's plugin conventions so it feels familiar to
+ * most JavaScript developers.
+ *
+ * @example
+ * ```ts
+ * const myPlugin: JikiPlugin = {
+ *   name: 'my-plugin',
+ *   setup(hooks) {
+ *     hooks.onResolve(/^virtual:/, (args) => ({
+ *       path: `/virtual/${args.path.slice(8)}`,
+ *     }));
+ *     hooks.onLoad(/^\/virtual\//, (args) => ({
+ *       contents: `module.exports = "hello from ${args.path}";`,
+ *     }));
+ *   },
+ * };
+ *
+ * const container = boot({ plugins: [myPlugin] });
+ * ```
+ */
+/** Arguments passed to an `onResolve` callback. */
+export interface OnResolveArgs {
+    /** The raw module specifier (e.g. `"virtual:config"` or `"./foo"`). */
+    path: string;
+    /** Directory the import originates from. */
+    resolveDir: string;
+}
+/** Return value from an `onResolve` callback. */
+export interface OnResolveResult {
+    /** Resolved absolute path. Returning this skips the default resolver. */
+    path: string;
+}
+/** Arguments passed to an `onLoad` callback. */
+export interface OnLoadArgs {
+    /** The fully-resolved module path. */
+    path: string;
+}
+/** Return value from an `onLoad` callback. */
+export interface OnLoadResult {
+    /** Source code to use instead of reading from the VFS. */
+    contents: string;
+}
+/** Arguments passed to an `onTransform` callback. */
+export interface OnTransformArgs {
+    /** The fully-resolved file path. */
+    path: string;
+    /** Source code *after* previous transforms in the pipeline. */
+    contents: string;
+}
+/** Return value from an `onTransform` callback. */
+export interface OnTransformResult {
+    /** Transformed source code. */
+    contents: string;
+}
+/** Callback types for lifecycle hooks. */
+export type OnResolveCallback = (args: OnResolveArgs) => OnResolveResult | null | undefined | void;
+export type OnLoadCallback = (args: OnLoadArgs) => OnLoadResult | null | undefined | void;
+export type OnTransformCallback = (args: OnTransformArgs) => OnTransformResult | null | undefined | void;
+export type OnInstallCallback = (packages: string[]) => void;
+export type OnBootCallback = () => void;
+import type { CommandHandler } from "./shell";
+/** Hook registration API handed to {@link JikiPlugin.setup}. */
+export interface PluginHooks {
+    /**
+     * Intercept module resolution.  The first callback whose `filter` matches
+     * **and** returns a non-null result wins — later callbacks are skipped.
+     */
+    onResolve(filter: RegExp, callback: OnResolveCallback): void;
+    /**
+     * Intercept module loading.  The first callback whose `filter` matches
+     * **and** returns a non-null result wins — later callbacks are skipped.
+     */
+    onLoad(filter: RegExp, callback: OnLoadCallback): void;
+    /**
+     * Intercept code transformation.  Unlike resolve/load, this is a
+     * **pipeline**: every matching callback runs in registration order,
+     * each receiving the output of the previous one.
+     */
+    onTransform(filter: RegExp, callback: OnTransformCallback): void;
+    /** Register a custom shell command. */
+    onCommand(name: string, handler: CommandHandler): void;
+    /** Called after packages are installed. */
+    onInstall(callback: OnInstallCallback): void;
+    /** Called after the container is fully initialised. */
+    onBoot(callback: OnBootCallback): void;
+}
+/** A jiki plugin. */
+export interface JikiPlugin {
+    /** Human-readable name (used in error messages and debugging). */
+    name: string;
+    /** Called once during container construction. Register hooks here. */
+    setup(hooks: PluginHooks): void;
+}
+interface CommandEntry {
+    name: string;
+    handler: CommandHandler;
+    plugin: string;
+}
+/**
+ * Central registry that collects hooks from all plugins and exposes
+ * methods for the runtime to invoke them.
+ *
+ * Intentionally not a singleton — each {@link Container} gets its own
+ * `PluginRegistry` so plugins cannot leak between containers.
+ */
+export declare class PluginRegistry {
+    private resolveHooks;
+    private loadHooks;
+    private transformHooks;
+    private commandHooks;
+    private installHooks;
+    private bootHooks;
+    /** True if at least one plugin has been registered. */
+    get hasPlugins(): boolean;
+    /** Number of registered resolve hooks. */
+    get resolveHookCount(): number;
+    /** Number of registered load hooks. */
+    get loadHookCount(): number;
+    /** Number of registered transform hooks. */
+    get transformHookCount(): number;
+    /** Number of registered command hooks. */
+    get commandHookCount(): number;
+    /** Register all hooks from a single plugin. */
+    register(plugin: JikiPlugin): void;
+    /**
+     * Run resolve hooks.  First matching callback that returns a result wins.
+     * Returns `null` if no plugin handled the specifier.
+     */
+    runResolve(path: string, resolveDir: string): OnResolveResult | null;
+    /**
+     * Run load hooks.  First matching callback that returns a result wins.
+     * Returns `null` if no plugin provided contents.
+     */
+    runLoad(path: string): OnLoadResult | null;
+    /**
+     * Run transform hooks as a pipeline.
+     * Every matching callback runs in order, each receiving the output of the
+     * previous one.  Returns the final transformed source.
+     */
+    runTransform(path: string, contents: string): string;
+    /** Return all command hooks so the shell can register them. */
+    getCommandHooks(): CommandEntry[];
+    /** Notify all install hooks. */
+    runInstall(packages: string[]): void;
+    /** Notify all boot hooks. */
+    runBoot(): void;
+}
+export {};

package/dist/polyfills/assert.d.ts

@@ -0,0 +1,30 @@
+declare class AssertionError extends Error {
+    actual: unknown;
+    expected: unknown;
+    operator: string;
+    constructor(message: string, actual?: unknown, expected?: unknown, operator?: string);
+}
+declare function assert(value: unknown, message?: string): asserts value;
+declare namespace assert {
+    var ok: typeof assert;
+    var equal: (actual: unknown, expected: unknown, message?: string) => void;
+    var notEqual: (actual: unknown, expected: unknown, message?: string) => void;
+    var strictEqual: (actual: unknown, expected: unknown, message?: string) => void;
+    var notStrictEqual: (actual: unknown, expected: unknown, message?: string) => void;
+    var deepEqual: (actual: unknown, expected: unknown, message?: string) => void;
+    var deepStrictEqual: (actual: unknown, expected: unknown, message?: string) => void;
+    var notDeepEqual: (actual: unknown, expected: unknown, message?: string) => void;
+    var notDeepStrictEqual: (actual: unknown, expected: unknown, message?: string) => void;
+    var throws: (fn: () => void, errorOrMessage?: unknown, message?: string) => void;
+    var doesNotThrow: (fn: () => void, message?: string) => void;
+    var rejects: (fn: (() => Promise<unknown>) | Promise<unknown>, message?: string) => Promise<void>;
+    var doesNotReject: (fn: (() => Promise<unknown>) | Promise<unknown>, message?: string) => Promise<void>;
+    var ifError: (value: unknown) => void;
+    var fail: (message?: string) => never;
+    var match: (string: string, regexp: RegExp, message?: string) => void;
+    var doesNotMatch: (string: string, regexp: RegExp, message?: string) => void;
+    var AssertionError: typeof import("./assert").AssertionError;
+    var strict: typeof assert;
+}
+export { AssertionError };
+export default assert;

package/dist/polyfills/child_process.d.ts

@@ -0,0 +1,116 @@
+import { EventEmitter } from "./events";
+import type { MemFS } from "../memfs";
+interface KernelLike {
+    runFile: (path: string) => unknown;
+    getProcess: () => ProcessLike;
+}
+interface ProcessLike {
+    argv: string[];
+    exit: (code?: number) => never;
+    connected?: boolean;
+    send?: (message: unknown, callback?: (error: Error | null) => void) => boolean;
+    stdout: {
+        isTTY?: boolean;
+        emit: (event: string, ...args: unknown[]) => void;
+    };
+    stderr: {
+        isTTY?: boolean;
+        emit: (event: string, ...args: unknown[]) => void;
+    };
+    stdin: {
+        isTTY?: boolean;
+        setRawMode?: (mode: boolean) => unknown;
+        emit: (event: string, ...args: unknown[]) => void;
+    };
+    on: (event: string, listener: (...args: unknown[]) => void) => unknown;
+    once: (event: string, listener: (...args: unknown[]) => void) => unknown;
+    emit: (event: string, ...args: unknown[]) => boolean;
+    listeners: (event: string) => ((...args: unknown[]) => void)[];
+}
+export declare function patchDefineProperty(): void;
+export declare function getActiveForkedChildren(): number;
+export declare function setOnForkedChildExit(cb: (() => void) | null): (() => void) | null;
+export declare function setStreamingCallbacks(opts: {
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+    signal?: AbortSignal;
+}): void;
+export declare function clearStreamingCallbacks(): void;
+export declare function getStreamingState(): {
+    streamStdout: ((data: string) => void) | null;
+    streamStderr: ((data: string) => void) | null;
+    abortSignal: AbortSignal | null;
+};
+export declare function sendStdin(data: string): void;
+export declare function setActiveProcessStdin(stdin: {
+    emit: (event: string, ...args: unknown[]) => void;
+} | null): void;
+export declare function initChildProcess(vfs: MemFS, runtimeFactory?: (vfs: MemFS, options?: Record<string, unknown>) => KernelLike): void;
+export declare class ChildProcess extends EventEmitter {
+    pid: number;
+    exitCode: number | null;
+    signalCode: string | null;
+    killed: boolean;
+    connected: boolean;
+    spawnargs: string[];
+    spawnfile: string;
+    stdout: EventEmitter | null;
+    stderr: EventEmitter | null;
+    stdin: EventEmitter | null;
+    constructor();
+    kill(signal?: string): boolean;
+    send(message: unknown, _cb?: (error: Error | null) => void): boolean;
+    disconnect(): void;
+    ref(): this;
+    unref(): this;
+}
+export interface ExecResult {
+    stdout: string;
+    stderr: string;
+}
+export declare function exec(command: string, optionsOrCb?: unknown | ((err: Error | null, result?: ExecResult) => void), cb?: (err: Error | null, result?: ExecResult) => void): ChildProcess;
+export declare function execSync(command: string, _options?: unknown): string;
+export interface SpawnOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    stdio?: "pipe" | "inherit" | "ignore" | Array<"pipe" | "inherit" | "ignore" | "ipc" | null>;
+    shell?: boolean | string;
+    detached?: boolean;
+    uid?: number;
+    gid?: number;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+export declare function spawn(command: string, args?: string[], options?: SpawnOptions | unknown): ChildProcess;
+export declare function execFile(file: string, args?: string[], optionsOrCb?: unknown, cb?: (err: Error | null, stdout?: string, stderr?: string) => void): ChildProcess;
+export declare function execFileSync(file: string, args?: string[], _options?: unknown): string;
+export declare function spawnSync(command: string, args?: string[], _options?: unknown): {
+    stdout: string;
+    stderr: string;
+    status: number;
+};
+/**
+ * Fork — runs a Node.js module in a simulated child process using a new Kernel.
+ * Creates bidirectional IPC between parent and child, with serialized message delivery.
+ */
+export declare function fork(modulePath: string, argsOrOptions?: string[] | Record<string, unknown>, options?: Record<string, unknown>): ChildProcess;
+declare const _default: {
+    ChildProcess: typeof ChildProcess;
+    exec: typeof exec;
+    execSync: typeof execSync;
+    spawn: typeof spawn;
+    execFile: typeof execFile;
+    execFileSync: typeof execFileSync;
+    fork: typeof fork;
+    spawnSync: typeof spawnSync;
+    initChildProcess: typeof initChildProcess;
+    setStreamingCallbacks: typeof setStreamingCallbacks;
+    clearStreamingCallbacks: typeof clearStreamingCallbacks;
+    sendStdin: typeof sendStdin;
+    setActiveProcessStdin: typeof setActiveProcessStdin;
+    getStreamingState: typeof getStreamingState;
+    getActiveForkedChildren: typeof getActiveForkedChildren;
+    setOnForkedChildExit: typeof setOnForkedChildExit;
+    patchDefineProperty: typeof patchDefineProperty;
+};
+export default _default;

package/dist/polyfills/chokidar.d.ts

@@ -0,0 +1,18 @@
+import { EventEmitter } from "./events";
+import type { MemFS } from "../memfs";
+export declare function initChokidar(vfs: MemFS): void;
+export declare class FSWatcher extends EventEmitter {
+    closed: boolean;
+    private watchers;
+    add(paths: string | string[]): this;
+    unwatch(_paths: string | string[]): this;
+    close(): Promise<void>;
+    getWatched(): Record<string, string[]>;
+}
+export declare function watch(paths: string | string[], _options?: unknown): FSWatcher;
+declare const _default: {
+    watch: typeof watch;
+    FSWatcher: typeof FSWatcher;
+    initChokidar: typeof initChokidar;
+};
+export default _default;

package/dist/polyfills/crypto.d.ts

@@ -0,0 +1,49 @@
+import { BufferImpl } from "./stream";
+export declare function randomBytes(size: number): BufferImpl;
+export declare function randomUUID(): string;
+export declare function randomInt(min: number, max?: number): number;
+declare class HashImpl {
+    private algorithm;
+    private data;
+    constructor(algorithm: string);
+    update(data: string | Uint8Array, encoding?: string): this;
+    private _combine;
+    digestAsync(encoding?: string): Promise<string | Uint8Array>;
+    digest(encoding?: string): string | Uint8Array;
+}
+declare class HmacImpl {
+    private algorithm;
+    private key;
+    private chunks;
+    constructor(algorithm: string, key: string | Uint8Array);
+    update(data: string | Uint8Array, _encoding?: string): this;
+    digest(encoding?: string): string | Uint8Array;
+}
+export declare function createHash(algorithm: string): HashImpl;
+export declare function createHmac(algorithm: string, key: string | Uint8Array): HmacImpl;
+export declare function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean;
+export declare function getHashes(): string[];
+export declare function getCiphers(): string[];
+export declare function createSign(_algorithm: string): {
+    update(data: string | Uint8Array): /*elided*/ any;
+    sign(key: unknown, encoding?: string): string | BufferImpl;
+};
+export declare function createVerify(_algorithm: string): {
+    update(data: string | Uint8Array): /*elided*/ any;
+    verify(key: unknown, signature: unknown, encoding?: string): boolean;
+};
+export declare const webcrypto: Crypto;
+declare const _default: {
+    randomBytes: typeof randomBytes;
+    randomUUID: typeof randomUUID;
+    randomInt: typeof randomInt;
+    createHash: typeof createHash;
+    createHmac: typeof createHmac;
+    timingSafeEqual: typeof timingSafeEqual;
+    getHashes: typeof getHashes;
+    getCiphers: typeof getCiphers;
+    createSign: typeof createSign;
+    createVerify: typeof createVerify;
+    webcrypto: Crypto;
+};
+export default _default;

package/dist/polyfills/events.d.ts

@@ -0,0 +1,28 @@
+export type EventListener = (...args: any[]) => void;
+export declare class EventEmitter {
+    on(event: string, listener: EventListener): this;
+    addListener(event: string, listener: EventListener): this;
+    once(event: string, listener: EventListener): this;
+    off(event: string, listener: EventListener): this;
+    removeListener(event: string, listener: EventListener): this;
+    removeAllListeners(event?: string): this;
+    emit(event: string, ...args: unknown[]): boolean;
+    listeners(event: string): EventListener[];
+    rawListeners(event: string): EventListener[];
+    listenerCount(event: string): number;
+    eventNames(): string[];
+    setMaxListeners(n: number): this;
+    getMaxListeners(): number;
+    prependListener(event: string, listener: EventListener): this;
+    prependOnceListener(event: string, listener: EventListener): this;
+    static listenerCount(emitter: EventEmitter, event: string): number;
+    static once(emitter: EventEmitter, event: string): Promise<unknown[]>;
+}
+declare const events: typeof EventEmitter & {
+    EventEmitter: typeof EventEmitter;
+    once: (emitter: EventEmitter, event: string) => Promise<unknown[]>;
+    on: (emitter: EventEmitter, event: string) => AsyncIterable<unknown[]>;
+    getEventListeners: (emitter: EventEmitter, event: string) => EventListener[];
+    listenerCount: (emitter: EventEmitter, event: string) => number;
+};
+export default events;

package/dist/polyfills/fs.d.ts

@@ -0,0 +1,82 @@
+import type { MemFS, Stats } from "../memfs";
+export interface FsShim {
+    readFileSync: (path: string, encoding?: string | {
+        encoding?: string;
+    }) => string | Uint8Array;
+    writeFileSync: (path: string, data: string | Uint8Array) => void;
+    existsSync: (path: string) => boolean;
+    mkdirSync: (path: string, options?: {
+        recursive?: boolean;
+    }) => void;
+    readdirSync: (path: string, options?: {
+        withFileTypes?: boolean;
+    }) => unknown;
+    statSync: (path: string) => Stats;
+    lstatSync: (path: string) => Stats;
+    unlinkSync: (path: string) => void;
+    rmdirSync: (path: string, options?: {
+        recursive?: boolean;
+    }) => void;
+    rmSync: (path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }) => void;
+    renameSync: (old: string, n: string) => void;
+    copyFileSync: (src: string, dest: string) => void;
+    accessSync: (path: string, mode?: number) => void;
+    realpathSync: (path: string) => string;
+    symlinkSync: (target: string, linkPath: string) => void;
+    readlinkSync: (path: string) => string;
+    chmodSync: (path: string, mode: number) => void;
+    chownSync: (path: string, uid: number, gid: number) => void;
+    lchmodSync: (path: string, mode: number) => void;
+    lchownSync: (path: string, uid: number, gid: number) => void;
+    openSync: (path: string, flags?: string | number) => number;
+    closeSync: (fd: number) => void;
+    readSync: (fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null) => number;
+    writeSync: (fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null) => number;
+    fstatSync: (fd: number) => Stats;
+    watch: MemFS["watch"];
+    createReadStream: MemFS["createReadStream"];
+    createWriteStream: MemFS["createWriteStream"];
+    readFile: MemFS["readFile"];
+    stat: MemFS["stat"];
+    lstat: MemFS["lstat"];
+    readdir: MemFS["readdir"];
+    realpath: MemFS["realpath"];
+    access: MemFS["access"];
+    promises: {
+        readFile: (path: string, encoding?: string | {
+            encoding?: string;
+        }) => Promise<string | Uint8Array>;
+        writeFile: (path: string, data: string | Uint8Array) => Promise<void>;
+        mkdir: (path: string, options?: {
+            recursive?: boolean;
+        }) => Promise<void>;
+        readdir: (path: string, options?: {
+            withFileTypes?: boolean;
+        }) => Promise<unknown>;
+        stat: (path: string) => Promise<Stats>;
+        lstat: (path: string) => Promise<Stats>;
+        unlink: (path: string) => Promise<void>;
+        rmdir: (path: string, options?: {
+            recursive?: boolean;
+        }) => Promise<void>;
+        rm: (path: string, options?: {
+            recursive?: boolean;
+            force?: boolean;
+        }) => Promise<void>;
+        rename: (old: string, n: string) => Promise<void>;
+        access: (path: string, mode?: number) => Promise<void>;
+        realpath: (path: string) => Promise<string>;
+        copyFile: (src: string, dest: string) => Promise<void>;
+        symlink: (target: string, linkPath: string) => Promise<void>;
+        readlink: (path: string) => Promise<string>;
+        chmod: (path: string, mode: number) => Promise<void>;
+        chown: (path: string, uid: number, gid: number) => Promise<void>;
+        lchmod: (path: string, mode: number) => Promise<void>;
+        lchown: (path: string, uid: number, gid: number) => Promise<void>;
+    };
+    constants: Record<string, number>;
+}
+export declare function createFsShim(vfs: MemFS, getCwd: () => string): FsShim;