@deepseek-ai/dsh-experimental-webworker-runtime 0.1.6-alpha.1

package/lib/types/node/builtin_modules/implemented/async_hooks.d.ts

@@ -0,0 +1,174 @@
+/** Node's AsyncLocalStorage face, restricted to the members the host tree uses. */
+export declare class AsyncLocalStorage<T> {
+    private readonly entries;
+    private overlay;
+    private readonly ambients;
+    private resumed;
+    constructor();
+    /**
+     * Run a callback with the store visible for the operation's whole lifetime:
+     * until it returns, or until the promise it returned settles.
+     * @param store - value {@link getStore} answers inside the boundary.
+     * @param callback - the operation.
+     * @param args - callback arguments.
+     * @returns the exact value the callback returned.
+     */
+    run<R>(store: T | undefined, callback: (...args: never[]) => R, ...args: never[]): R;
+    /**
+     * Current store, resolved through the slot order this module documents: the
+     * hook-restored overlay, then the ambient context a resume installed (or a
+     * boundary owns), then the folding stack's innermost entry.
+     * @returns the store, or undefined outside every boundary.
+     */
+    getStore(): T | undefined;
+    /**
+     * Run a callback with no store, folding over its lifetime like {@link run}.
+     * @param callback - the operation.
+     * @param args - callback arguments.
+     * @returns the exact value the callback returned.
+     */
+    exit<R>(callback: (...args: never[]) => R, ...args: never[]): R;
+    /**
+     * Enter a boundary that lasts until {@link disable}, as Node's `enterWith` does
+     * for the remainder of the current chain.
+     * @param store - value {@link getStore} answers from now on.
+     */
+    enterWith(store: T): void;
+    /** Drop every slot; teardown calls this unconditionally. */
+    disable(): void;
+    /**
+     * Copy every live instance's effective store, including the instances reading
+     * `undefined`: a resumed frame must see exactly what its pause point saw.
+     * @returns the ambient snapshot.
+     */
+    static snapshotAll(): AmbientSnapshot;
+    /**
+     * Install a snapshot as the ambient context of every instance it names.
+     * @param snapshot - a copy from {@link snapshotAll}.
+     * @returns a disposer that restores the previous ambients, identity-checked.
+     */
+    static restoreAll(snapshot: AmbientSnapshot): () => void;
+    /**
+     * Copy every live instance's current store. Not part of the Node face: this is
+     * the shim's own mechanism, kept in the class so the overlay stays private.
+     * @returns the snapshot, or undefined when no instance has a store.
+     */
+    static captureContext(): AsyncContextSnapshot | undefined;
+    /**
+     * Run a callback with a captured context restored into the overlay slots.
+     * @param snapshot - context copy, or undefined to run unchanged.
+     * @param callback - the callback.
+     * @returns the callback's return value.
+     */
+    static runWithContext<R>(snapshot: AsyncContextSnapshot | undefined, callback: () => R): R;
+    /**
+     * Every live instance, for {@link runAtAsyncContextRoot}.
+     * @returns The stores a snapshot must capture.
+     */
+    static liveInstances(): readonly AsyncLocalStorage<unknown>[];
+    /**
+     * Bind a callback to the current context.
+     * @param callback - the callback to bind.
+     * @returns a callback that restores this context when invoked.
+     */
+    static bind<F extends (...args: never[]) => unknown>(callback: F): F;
+    /**
+     * Snapshot helper matching Node's static: run a callback in the context
+     * captured now.
+     * @returns a function that runs its argument in the captured context.
+     */
+    static snapshot(): <R>(callback: () => R) => R;
+}
+/** One instance's captured store. */
+interface CapturedStore {
+    readonly instance: AsyncLocalStorage<unknown>;
+    readonly store: unknown;
+}
+/** Opaque context copy produced by {@link captureAsyncContext}. */
+export type AsyncContextSnapshot = readonly CapturedStore[];
+/** Opaque ambient copy produced by {@link __snapshotAll}; covers every live instance. */
+export type AmbientSnapshot = readonly CapturedStore[];
+/**
+ * Copy every live instance's current store.
+ * @returns the snapshot, or undefined when no instance has a store (the hook
+ * layer then wraps nothing and callbacks inherit the stack top).
+ */
+export declare function captureAsyncContext(): AsyncContextSnapshot | undefined;
+/**
+ * Run a callback with a captured context restored into the overlay slots.
+ * @param snapshot - context copy, or undefined to run unchanged.
+ * @param callback - the callback.
+ * @returns the callback's return value.
+ */
+export declare function runWithAsyncContext<R>(snapshot: AsyncContextSnapshot | undefined, callback: () => R): R;
+/**
+ * Capture the current context now and restore it around every later invocation.
+ * @param callback - the callback to bind.
+ * @returns the bound callback, or the original when no context is active.
+ */
+export declare function bindAsyncContext<F extends (...args: never[]) => unknown>(callback: F): F;
+/**
+ * Run a callback at the root: every instance reads `undefined`, whatever was open
+ * before. The tunnel's message entry uses this so a queued request never inherits
+ * a boundary from unrelated work that happened to run first.
+ * @param callback - the callback.
+ * @returns the callback's return value.
+ */
+export declare function runAtAsyncContextRoot<R>(callback: () => R): R;
+/**
+ * Pause point of the loader's `await` rewriting: copy the context every live
+ * instance currently reads.
+ *
+ * The transformed module reaches this through the module proxy table
+ * (`require('node:async_hooks').__snapshotAll()`), so the rewriter needs no
+ * additional plumbing.
+ * @returns the ambient snapshot to hand to {@link __restoreAll} after the await.
+ */
+export declare function __snapshotAll(): AmbientSnapshot;
+/**
+ * Resume point of the loader's `await` rewriting: publish a paused context as the
+ * ambient one, so reads after the await answer what the frame saw before it —
+ * even while another chain interleaves.
+ * @param snapshot - the copy {@link __snapshotAll} produced at the pause point.
+ * @returns a disposer that restores the previous ambient context, identity-checked;
+ * a rewriter that wraps a whole function body calls it in that body's `finally`.
+ */
+export declare function __restoreAll(snapshot: AmbientSnapshot): () => void;
+/**
+ * Snapshot face the module loader's `await` rewriting consumes (its `AlsCausality`):
+ * the same pair as {@link __snapshotAll}/{@link __restoreAll}, with `restore`
+ * narrowed to void because the rewritten code has no place to keep a disposer.
+ */
+export declare const alsCausality: {
+    snapshot: () => AmbientSnapshot;
+    restore: (snapshot: AmbientSnapshot) => void;
+};
+/**
+ * Async ids are not tracked; a stable id keeps callers that log it working.
+ * @returns Always 1.
+ */
+export declare function executionAsyncId(): number;
+/**
+ * Trigger ids are not tracked either.
+ * @returns Always 0.
+ */
+export declare function triggerAsyncId(): number;
+/**
+ * Async hooks cannot be created: no async resource tracking exists in the worker.
+ * @returns Never — it throws naming the unavailable member.
+ */
+export declare function createHook(): never;
+/** Resource construction is likewise unavailable. */
+export declare const AsyncResource: typeof import('node:async_hooks').AsyncResource;
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+/** CommonJS default export: the members `require()` hands a caller of this module. */
+declare const _default: {
+    AsyncLocalStorage: typeof AsyncLocalStorage;
+    AsyncResource: typeof import("async_hooks").AsyncResource;
+    executionAsyncId: typeof executionAsyncId;
+    triggerAsyncId: typeof triggerAsyncId;
+    createHook: typeof createHook;
+};
+export default _default;
+//# sourceMappingURL=async_hooks.d.ts.map

package/lib/types/node/builtin_modules/implemented/buffer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `node:buffer` for the worker, backed by the `buffer` npm package (feross), and
+ * the matching `globalThis.Buffer` install. Node code treats Buffer as ambient,
+ * so the global must exist before any host module evaluates.
+ */
+import { Buffer, kMaxLength } from 'buffer';
+export { Buffer, kMaxLength };
+/**
+ * Size limits, as `node:buffer` publishes them. The npm package exposes only
+ * `kMaxLength`, so the string bound is Node's own value for a 64-bit build.
+ */
+export declare const constants: {
+    MAX_LENGTH: number;
+    MAX_STRING_LENGTH: number;
+};
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+/** CommonJS default export: the members `require()` hands a caller of this module. */
+declare const _default: {
+    Buffer: BufferConstructor;
+    constants: {
+        MAX_LENGTH: number;
+        MAX_STRING_LENGTH: number;
+    };
+    kMaxLength: number;
+};
+export default _default;
+//# sourceMappingURL=buffer.d.ts.map

package/lib/types/node/builtin_modules/implemented/child_process.d.ts

@@ -0,0 +1,178 @@
+/**
+ * `node:child_process` over the worker's own shell.
+ *
+ * A browser worker cannot fork, so this module IS the machine's process layer:
+ * `spawn` starts the argv as a shell process (`src/shell/process/`) — its own
+ * Web Worker, off this thread — and reports it through the `ChildProcess`
+ * surface the subprocess service consumes: pipes, `exit`/`close`, pid, and
+ * signals, with `SIGKILL` terminating the worker for real. Worker-owned
+ * executable wrappers resolve before the shell's command table; anything in
+ * neither set fails with `ENOENT`, exactly as a missing binary does on a real
+ * host.
+ *
+ * What stays impossible is what needs a real process: synchronous execution
+ * (`execSync`, and `spawnSync` for a known program) and `fork`.
+ * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/node/builtin_modules/implemented/child_process
+ */
+import { Buffer } from 'buffer';
+import { EventEmitter } from './events.ts';
+/** Per-stream disposition, as Node's `stdio` array spells it. */
+type StdioSetting = 'pipe' | 'ignore' | 'inherit';
+/** The spawn options this shim reads; Node accepts more, none of which apply here. */
+export interface WorkerSpawnOptions {
+    cwd?: string | undefined;
+    env?: Record<string, string | undefined> | undefined;
+    stdio?: StdioSetting | readonly StdioSetting[] | undefined;
+    /** Accepted and ignored: process groups do not exist, so there is no group to detach into. */
+    detached?: boolean | undefined;
+}
+/**
+ * The readable half of a pipe: `data` events carrying Buffers, `end`, and a
+ * `destroy` that stops delivery.
+ *
+ * The stream-shaping members below are no-ops rather than omissions. A caller
+ * that configures the pipe before reading it (the browser launcher calls
+ * `setEncoding`) would otherwise die of a TypeError on the configuration line,
+ * hiding the real outcome — which for an unknown program is the `ENOENT` this
+ * shim is about to emit.
+ */
+declare class WorkerReadable extends EventEmitter {
+    private destroyed;
+    /**
+     * Accept an encoding (chunks are always UTF-8 text carried as Buffers).
+     * @returns this stream.
+     */
+    setEncoding(): this;
+    /**
+     * Accept a flow-control request; delivery is driven by the command, which
+     * has already produced whatever it produced.
+     * @returns this stream.
+     */
+    pause(): this;
+    /** @returns this stream; see {@link pause}. */
+    resume(): this;
+    /**
+     * Deliver one chunk to the `data` listeners.
+     * @param text - the text written by the command.
+     */
+    push(text: string): void;
+    /** Signal end of stream. */
+    finish(): void;
+    /** Stop delivering; the collector calls this once the process settles. */
+    destroy(): void;
+}
+/** The writable half of stdin: the batch write the subprocess service performs. */
+declare class WorkerWritable extends EventEmitter {
+    private text;
+    /**
+     * Buffer one write.
+     * @param chunk - text or bytes to add to standard input.
+     * @returns true, since nothing here applies backpressure.
+     */
+    write(chunk: string | Uint8Array): boolean;
+    /**
+     * Finish standard input.
+     * @param chunk - optional final write.
+     */
+    end(chunk?: string | Uint8Array): void;
+    /** @returns everything written so far. */
+    contents(): string;
+}
+/**
+ * One running command, wearing the parts of `ChildProcess` its consumers read.
+ */
+export declare class WorkerChildProcess extends EventEmitter {
+    /** The worker's own process id for this command, from the process table. */
+    readonly pid: number;
+    /** Standard input, when the caller asked for a pipe; null otherwise. */
+    readonly stdin: WorkerWritable | null;
+    /** Standard output, when the caller asked for a pipe; null otherwise. */
+    readonly stdout: WorkerReadable | null;
+    /** Standard error, when the caller asked for a pipe; null otherwise. */
+    readonly stderr: WorkerReadable | null;
+    /** Exit status once settled; null while running and after a signal. */
+    exitCode: number | null;
+    /** The signal that ended the command, or null when it exited on its own. */
+    signalCode: NodeJS.Signals | null;
+    constructor(pid: number, stdio: readonly StdioSetting[]);
+    /**
+     * Deliver a signal to this command.
+     * @param signal - signal name; every one of them terminates.
+     * @returns true when the command was still running.
+     */
+    kill(signal?: NodeJS.Signals): boolean;
+}
+/**
+ * Run one command in the worker.
+ *
+ * The call returns immediately with a handle; the command runs in its own
+ * worker (or inline where no `Worker` exists) and reports back through the
+ * handle's pipes and events.
+ * @param program - the program name, as argv[0].
+ * @param args - its arguments.
+ * @param options - working directory, environment, and stdio dispositions.
+ * @returns the running command's handle.
+ */
+export declare function spawn(program: string, args?: readonly string[], options?: WorkerSpawnOptions): WorkerChildProcess;
+/** The result shape `spawnSync` returns, holding only the members consumers read. */
+export interface WorkerSpawnSyncResult {
+    pid: number;
+    status: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: Buffer;
+    stderr: Buffer;
+    output: (Buffer | null)[];
+    /** Why the run did not happen; carries `code` for the callers that classify by it. */
+    error?: NodeJS.ErrnoException;
+}
+/**
+ * Report that a command cannot run synchronously.
+ *
+ * Callers use `spawnSync` to probe for a binary (the sandbox runner probes do)
+ * and Node answers a missing one with an `error` rather than a throw, so this
+ * answers in the same shape: absent programs report `ENOENT`, and a program
+ * this shell *does* have reports that only the asynchronous path can run it.
+ * @param program - the program name.
+ * @param args - arguments passed to the virtual launcher probe.
+ * @returns the Node-shaped synchronous result carrying the failure.
+ */
+export declare function spawnSync(program: string, args?: readonly string[]): WorkerSpawnSyncResult;
+/** Callback `exec` and `execFile` report through. */
+type ExecCallback = (error: Error | null, stdout: string, stderr: string) => void;
+/**
+ * Run a command line and report its output through a callback.
+ * @param command - the shell source to run.
+ * @param options - working directory and environment, or the callback.
+ * @param callback - receives the failure (nonzero status included), stdout, and stderr.
+ * @returns the running command's handle.
+ */
+export declare function exec(command: string, options?: WorkerSpawnOptions | ExecCallback, callback?: ExecCallback): WorkerChildProcess;
+/**
+ * Run one program with an explicit argv and report its output through a callback.
+ * @param program - the program name.
+ * @param args - its arguments, or the options, or the callback.
+ * @param options - working directory and environment, or the callback.
+ * @param callback - receives the failure (nonzero status included), stdout, and stderr.
+ * @returns the running command's handle.
+ */
+export declare function execFile(program: string, args?: readonly string[] | WorkerSpawnOptions | ExecCallback, options?: WorkerSpawnOptions | ExecCallback, callback?: ExecCallback): WorkerChildProcess;
+/** Run a command line synchronously (unavailable: the interpreter is asynchronous). */
+export declare const execSync: typeof import('node:child_process').execSync;
+/** Run one program synchronously (unavailable: the interpreter is asynchronous). */
+export declare const execFileSync: typeof import('node:child_process').execFileSync;
+/** Start a Node child (unavailable: the worker cannot create another Node runtime). */
+export declare const fork: typeof import('node:child_process').fork;
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ../../builtins.ts). */
+export declare const __esModule = true;
+/** CommonJS default export: the members `require()` hands a caller of this module. */
+declare const _default: {
+    spawn: typeof spawn;
+    spawnSync: typeof spawnSync;
+    exec: typeof exec;
+    execFile: typeof execFile;
+    execFileSync: typeof import("child_process").execFileSync;
+    execSync: typeof import("child_process").execSync;
+    fork: typeof import("child_process").fork;
+};
+export default _default;
+//# sourceMappingURL=child_process.d.ts.map

package/lib/types/node/builtin_modules/implemented/crypto.d.ts

@@ -0,0 +1,53 @@
+import { Buffer } from 'buffer';
+/** Node's streaming Hash face, restricted to the update/digest pair in use. */
+export interface Hash {
+    update(data: string | Uint8Array | ArrayBuffer, encoding?: string): Hash;
+    digest(): Buffer;
+    digest(encoding: 'hex' | 'base64'): string;
+}
+/**
+ * Create a synchronous hash object.
+ * @param algorithm - digest name; only the algorithms the host tree uses exist.
+ * @returns the streaming hash face.
+ */
+export declare function createHash(algorithm: string): Hash;
+/**
+ * Random bytes.
+ * @param size - byte count.
+ * @returns a Buffer of cryptographically strong random bytes.
+ */
+export declare function randomBytes(size: number): Buffer<ArrayBuffer>;
+/**
+ * Random v4 UUID. Delegated to the repository's own mint rather than to
+ * `crypto.randomUUID`, which browsers expose only in secure contexts — a
+ * preview served over plain HTTP on a LAN address has no `randomUUID`.
+ * @returns the UUID string.
+ */
+export declare function randomUUID(): import('node:crypto').UUID;
+/**
+ * Fill a typed array with random bytes.
+ * @param target - the array to fill.
+ * @returns the same array.
+ */
+export declare function getRandomValues<T extends ArrayBufferView<ArrayBuffer>>(target: T): T;
+/**
+ * Random integer in `[0, max)`.
+ * @param max - exclusive upper bound.
+ * @returns the integer.
+ */
+export declare function randomInt(max: number): number;
+/** WebCrypto instance, as Node exposes it. */
+export declare const webcrypto: Crypto;
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+/** CommonJS default export: the members `require()` hands a caller of this module. */
+declare const _default: {
+    createHash: typeof createHash;
+    randomBytes: typeof randomBytes;
+    randomUUID: typeof randomUUID;
+    getRandomValues: typeof getRandomValues;
+    randomInt: typeof randomInt;
+    webcrypto: Crypto;
+};
+export default _default;
+//# sourceMappingURL=crypto.d.ts.map

package/lib/types/node/builtin_modules/implemented/events.d.ts

@@ -0,0 +1,84 @@
+/**
+ * `node:events`: a minimal EventEmitter with the members harness code uses.
+ * Emission order and listener identity follow Node; anything beyond the basic
+ * on/once/off/emit set throws.
+ */
+type Listener = (...args: unknown[]) => void;
+/** The `node:events` subset the harness registers on: add, remove, and emit. */
+export declare class EventEmitter {
+    private readonly registry;
+    /**
+     * Register a listener.
+     * @param event - event name.
+     * @param listener - the listener.
+     * @returns this emitter.
+     */
+    on(event: string, listener: Listener): this;
+    /**
+     * Register a listener removed after its first call.
+     * @param event - event name.
+     * @param listener - the listener.
+     * @returns this emitter.
+     */
+    once(event: string, listener: Listener): this;
+    /**
+     * Register a listener ahead of the existing ones.
+     * @param event - event name.
+     * @param listener - the listener.
+     * @returns this emitter.
+     */
+    prependListener(event: string, listener: Listener): this;
+    /**
+     * Remove a listener, by the function that was registered or by the one a
+     * `once` wrapper stands for.
+     * @param event - event name.
+     * @param listener - the listener.
+     * @returns this emitter.
+     */
+    off(event: string, listener: Listener): this;
+    /**
+     * Alias of {@link off}.
+     * @param event - event name.
+     * @param listener - the listener.
+     * @returns this emitter.
+     */
+    removeListener(event: string, listener: Listener): this;
+    /**
+     * Drop listeners for one event, or all of them.
+     * @param event - event name; omitted clears every event.
+     * @returns this emitter.
+     */
+    removeAllListeners(event?: string): this;
+    /**
+     * Emit an event.
+     * @param event - event name.
+     * @param args - listener arguments.
+     * @returns whether any listener ran.
+     */
+    emit(event: string, ...args: unknown[]): boolean;
+    /**
+     * Listeners of one event.
+     * @param event - event name.
+     * @returns a copy of the listener list.
+     */
+    listeners(event: string): Listener[];
+    /**
+     * Listener count of one event.
+     * @param event - event name.
+     * @returns the count.
+     */
+    listenerCount(event: string): number;
+    /**
+     * Node's max-listener knob has no effect here.
+     * @returns This emitter, for chaining.
+     */
+    setMaxListeners(): this;
+}
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+/** CommonJS default export: the members `require()` hands a caller of this module. */
+declare const _default: {
+    EventEmitter: typeof EventEmitter;
+};
+export default _default;
+//# sourceMappingURL=events.d.ts.map

package/lib/types/node/builtin_modules/implemented/fs/promises.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `node:fs/promises` face: the promise members of the VFS bridge, re-exported as
+ * named bindings so `import { readFile } from 'node:fs/promises'` resolves. The
+ * member set is checked against Node where it is built, on `promises` in
+ * `../fs.ts`.
+ */
+import { Dirent, promises } from '../fs.ts';
+/** The promise members of the VFS bridge, as `node:fs/promises` names them. */
+export declare const readFile: (path: string | URL | Uint8Array<ArrayBufferLike>, options?: BufferEncoding | {
+    encoding?: BufferEncoding | null;
+} | null | undefined) => Promise<Buffer | string>, writeFile: (path: string | URL | Uint8Array<ArrayBufferLike>, data: string | Uint8Array, options?: {
+    flag?: string;
+    mode?: number;
+} | BufferEncoding | null) => Promise<void>, appendFile: (path: string | URL | Uint8Array<ArrayBufferLike>, data: string | Uint8Array) => Promise<void>, mkdir: (path: string | URL | Uint8Array<ArrayBufferLike>, options?: {
+    recursive?: boolean;
+    mode?: number;
+}) => Promise<string | undefined>, mkdtemp: (prefix: string) => Promise<string>, readdir: (path: string | URL | Uint8Array<ArrayBufferLike>, options?: {
+    withFileTypes?: boolean;
+} | BufferEncoding) => Promise<string[] | Dirent[]>, stat: (path: string | URL | Uint8Array<ArrayBufferLike>, options?: import("../../../../storage/types.ts").VfsStatOptions) => Promise<import("../../../../index.ts").VfsStats | import("../../../../storage/types.ts").VfsBigIntStats>, lstat: (path: string | URL | Uint8Array<ArrayBufferLike>, options?: import("../../../../storage/types.ts").VfsStatOptions) => Promise<import("../../../../index.ts").VfsStats | import("../../../../storage/types.ts").VfsBigIntStats>, realpath: (path: string | URL | Uint8Array<ArrayBufferLike>) => Promise<string>, rm: (path: string | URL | Uint8Array<ArrayBufferLike>, options?: {
+    recursive?: boolean;
+    force?: boolean;
+}) => Promise<void>, unlink: (path: string | URL | Uint8Array<ArrayBufferLike>) => Promise<void>, rename: (from: string | URL | Uint8Array<ArrayBufferLike>, to: string | URL | Uint8Array<ArrayBufferLike>) => Promise<void>, access: (path: string | URL | Uint8Array<ArrayBufferLike>) => Promise<void>, chmod: (path: string | URL | Uint8Array<ArrayBufferLike>, mode: number | string) => Promise<void>, cp: (from: string | URL | Uint8Array<ArrayBufferLike>, to: string | URL | Uint8Array<ArrayBufferLike>) => Promise<void>, link: (from: string | URL | Uint8Array<ArrayBufferLike>, to: string | URL | Uint8Array<ArrayBufferLike>) => Promise<void>, open: (path: string | URL | Uint8Array<ArrayBufferLike>, flags?: string, mode?: number) => Promise<import("../fs.ts").FileHandle>, opendir: (path: string | URL | Uint8Array<ArrayBufferLike>) => Promise<import("../fs.ts").Dir>, truncate: (path: string | URL | Uint8Array<ArrayBufferLike>, length?: number) => Promise<void>, watch: typeof import("../fs-watch.ts").watchAsync, constants: {
+    F_OK: number;
+    R_OK: number;
+    W_OK: number;
+    X_OK: number;
+    COPYFILE_EXCL: number;
+    O_RDONLY: number;
+    O_WRONLY: number;
+    O_RDWR: number;
+    O_CREAT: number;
+    O_TRUNC: number;
+    O_APPEND: number;
+};
+export { Dirent };
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+export default promises;
+//# sourceMappingURL=promises.d.ts.map

package/lib/types/node/builtin_modules/implemented/fs-watch.d.ts

@@ -0,0 +1,119 @@
+/** Node filesystem watching over the active in-memory VFS. */
+import { Buffer } from 'buffer';
+import { EventEmitter } from './events.ts';
+import type { VfsBigIntStats, VfsStats } from '../../../storage/types.ts';
+type PathArg = string | URL | Uint8Array;
+type WatchListener = (eventType: 'rename' | 'change', filename: string | Buffer | null) => void;
+type WatchStats = VfsStats | VfsBigIntStats;
+type StatListener = (current: WatchStats, previous: WatchStats) => void;
+/** Options shared by the callback and promise watch faces. */
+export interface WatchOptions {
+    persistent?: boolean;
+    recursive?: boolean;
+    encoding?: BufferEncoding | 'buffer';
+    signal?: AbortSignal;
+}
+/** Poll-style watch options. */
+export interface WatchFileOptions {
+    persistent?: boolean;
+    interval?: number;
+    bigint?: boolean;
+}
+/** `fs.FSWatcher` over VFS mutations. */
+export declare class FSWatcher extends EventEmitter {
+    private readonly target;
+    private readonly directory;
+    private readonly options;
+    private readonly disposeMutation;
+    private readonly signal;
+    private readonly onAbort;
+    private closed;
+    private referenced;
+    constructor(target: string, directory: boolean, options: WatchOptions, listener?: WatchListener);
+    private matches;
+    private filename;
+    /** Stop observing and publish `close` once. */
+    close(): void;
+    /**
+     * Mark this watcher as process-liveness-bearing.
+     * @returns This watcher.
+     */
+    ref(): this;
+    /**
+     * Clear the process-liveness flag; dedicated Workers have no ref-counted event loop.
+     * @returns This watcher.
+     */
+    unref(): this;
+    /**
+     * Read the retained process-liveness flag.
+     * @returns Whether this watcher is marked as keeping its owner alive.
+     */
+    hasRef(): boolean;
+}
+/**
+ * Watch one path through the active VFS.
+ * @param path - File or directory path.
+ * @param optionsOrListener - Watch options, encoding, or the change listener.
+ * @param maybeListener - Change listener when the second argument carries options.
+ * @returns The closeable watcher.
+ */
+export declare function watch(path: PathArg, optionsOrListener?: WatchOptions | BufferEncoding | 'buffer' | WatchListener, maybeListener?: WatchListener): FSWatcher;
+/** `fs.StatWatcher` returned from `watchFile`. */
+export declare class StatWatcher extends EventEmitter {
+    readonly path: string;
+    private readonly disposeMutation;
+    private timer;
+    private previous;
+    private stopped;
+    private referenced;
+    private readonly context;
+    private readonly interval;
+    private readonly bigint;
+    constructor(path: string, options: WatchFileOptions);
+    private schedule;
+    /** Stop polling and release the VFS subscription. */
+    stop(): void;
+    /** Alias used by callers treating the watcher as a closeable handle. */
+    close(): void;
+    /**
+     * Mark this watcher as process-liveness-bearing.
+     * @returns This watcher.
+     */
+    ref(): this;
+    /**
+     * Mark this watcher as not keeping its owner alive.
+     * @returns This watcher.
+     */
+    unref(): this;
+    /**
+     * Read the retained process-liveness flag.
+     * @returns Whether this watcher is marked as keeping its owner alive.
+     */
+    hasRef(): boolean;
+}
+/**
+ * Register a stat-poll watcher for one path.
+ * @param path - File or directory path, including a currently missing path.
+ * @param optionsOrListener - Polling options or the change listener.
+ * @param maybeListener - Change listener when the second argument carries options.
+ * @returns The path's shared stat watcher.
+ */
+export declare function watchFile(path: PathArg, optionsOrListener: WatchFileOptions | StatListener, maybeListener?: StatListener): StatWatcher;
+/**
+ * Remove one listener or every listener for a path.
+ * @param path - Watched path.
+ * @param listener - Specific registration to remove; omission removes all registrations.
+ */
+export declare function unwatchFile(path: PathArg, listener?: StatListener): void;
+/**
+ * Create the promise-based watch iterator over the callback watcher.
+ * @param path - File or directory path.
+ * @param options - Watch options and cancellation signal.
+ * @returns An iterator of change records that closes its watcher on return or failure.
+ */
+export declare function watchAsync(path: PathArg, options?: WatchOptions): AsyncIterableIterator<{
+    eventType: 'rename' | 'change';
+    filename: string | Buffer | null;
+}>;
+export {};
+//# sourceMappingURL=fs-watch.d.ts.map