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

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

@@ -0,0 +1,115 @@
+import type { CpuInfo, NetworkInterfaceInfo } from 'node:os';
+/** Line ending of the virtual platform. */
+export declare const EOL = "\n";
+/**
+ * Temporary directory.
+ * @returns the VFS temp path.
+ */
+export declare function tmpdir(): string;
+/**
+ * Home directory.
+ * @returns `$DSH_HOME` inside the VFS.
+ */
+export declare function homedir(): string;
+/**
+ * Platform identity.
+ * @returns always 'linux'.
+ */
+export declare function platform(): NodeJS.Platform;
+/**
+ * Operating-system type.
+ * @returns always 'Linux'.
+ */
+export declare function type(): string;
+/**
+ * CPU architecture.
+ * @returns always 'x64'.
+ */
+export declare function arch(): string;
+/**
+ * Kernel release.
+ * @returns a synthetic release string.
+ */
+export declare function release(): string;
+/**
+ * Host name.
+ * @returns a synthetic name.
+ */
+export declare function hostname(): string;
+/**
+ * Usable parallelism.
+ * @returns the browser's hardware concurrency, at least 1.
+ */
+export declare function availableParallelism(): number;
+/**
+ * CPU inventory.
+ * @returns an empty list (no per-core facts inside a worker).
+ */
+export declare function cpus(): CpuInfo[];
+/**
+ * Network interfaces.
+ * @returns an empty record — the worker webserver binds the loopback literal, so
+ * no LAN address is ever derived.
+ */
+export declare function networkInterfaces(): NodeJS.Dict<NetworkInterfaceInfo[]>;
+/** OS constants: only the signal table is read (terminal signal name mapping). */
+export declare const constants: {
+    signals: {
+        SIGHUP: number;
+        SIGINT: number;
+        SIGQUIT: number;
+        SIGILL: number;
+        SIGTRAP: number;
+        SIGABRT: number;
+        SIGBUS: number;
+        SIGFPE: number;
+        SIGKILL: number;
+        SIGUSR1: number;
+        SIGSEGV: number;
+        SIGUSR2: number;
+        SIGPIPE: number;
+        SIGALRM: number;
+        SIGTERM: number;
+    };
+    errno: {};
+    priority: {};
+};
+/** 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: {
+    EOL: string;
+    tmpdir: typeof tmpdir;
+    homedir: typeof homedir;
+    platform: typeof platform;
+    type: typeof type;
+    arch: typeof arch;
+    release: typeof release;
+    hostname: typeof hostname;
+    availableParallelism: typeof availableParallelism;
+    cpus: typeof cpus;
+    networkInterfaces: typeof networkInterfaces;
+    constants: {
+        signals: {
+            SIGHUP: number;
+            SIGINT: number;
+            SIGQUIT: number;
+            SIGILL: number;
+            SIGTRAP: number;
+            SIGABRT: number;
+            SIGBUS: number;
+            SIGFPE: number;
+            SIGKILL: number;
+            SIGUSR1: number;
+            SIGSEGV: number;
+            SIGUSR2: number;
+            SIGPIPE: number;
+            SIGALRM: number;
+            SIGTERM: number;
+        };
+        errno: {};
+        priority: {};
+    };
+};
+export default _default;
+//# sourceMappingURL=os.d.ts.map

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

@@ -0,0 +1,138 @@
+/** Parsed path object returned by {@link parse}. */
+export interface ParsedPath {
+    root: string;
+    dir: string;
+    base: string;
+    ext: string;
+    name: string;
+}
+/**
+ * Resolve a sequence of paths into an absolute path.
+ * @param paths - path segments, right to left until an absolute one is found.
+ * @returns the absolute, normalized path.
+ */
+export declare function resolve(...paths: string[]): string;
+/**
+ * Normalize a path, resolving `.`, `..`, and duplicate separators.
+ * @param path - the path.
+ * @returns the normalized path.
+ */
+export declare function normalize(path: string): string;
+/**
+ * Whether the path is absolute.
+ * @param path - the path.
+ * @returns true when it starts at the root.
+ */
+export declare function isAbsolute(path: string): boolean;
+/**
+ * Join path segments with the separator, then normalize.
+ * @param paths - the segments.
+ * @returns the joined path.
+ */
+export declare function join(...paths: string[]): string;
+/**
+ * Relative path from one location to another.
+ * @param from - source path.
+ * @param to - target path.
+ * @returns the relative path, or '' when both resolve identically.
+ */
+export declare function relative(from: string, to: string): string;
+/**
+ * Directory portion of a path (lexical, as Node defines it: no normalization).
+ * @param path - the path.
+ * @returns the parent directory.
+ */
+export declare function dirname(path: string): string;
+/**
+ * Last portion of a path, optionally without a suffix (lexical, as in Node).
+ * @param path - the path.
+ * @param suffix - extension to strip when the base ends with it.
+ * @returns the base name.
+ */
+export declare function basename(path: string, suffix?: string): string;
+/**
+ * Extension of the last path segment, including the leading dot.
+ * @param path - the path.
+ * @returns the extension, or '' when there is none.
+ */
+export declare function extname(path: string): string;
+/**
+ * Build a path from its parsed parts.
+ * @param pathObject - dir/root/base/name/ext parts.
+ * @returns the assembled path.
+ */
+export declare function format(pathObject: Partial<ParsedPath>): string;
+/**
+ * Split a path into root/dir/base/ext/name (lexical, as in Node).
+ * @param path - the path.
+ * @returns the parsed parts.
+ */
+export declare function parse(path: string): ParsedPath;
+/** POSIX path separator. */
+export declare const sep: "/";
+/** POSIX path-list delimiter. */
+export declare const delimiter: ":";
+/**
+ * Windows namespace prefixes do not exist here.
+ * @param path - the path.
+ * @returns the path unchanged.
+ */
+export declare function toNamespacedPath(path: string): string;
+declare const posixFace: {
+    resolve: typeof resolve;
+    normalize: typeof normalize;
+    isAbsolute: typeof isAbsolute;
+    join: typeof join;
+    relative: typeof relative;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    format: typeof format;
+    parse: typeof parse;
+    sep: "/";
+    delimiter: ":";
+    toNamespacedPath: typeof toNamespacedPath;
+};
+/** POSIX member set: the module face, plus Node's self-referential namespaces. */
+export declare const posix: typeof posixFace & {
+    readonly posix: unknown;
+    readonly win32: unknown;
+};
+/** Windows member set: reaching it means a platform branch went the wrong way. */
+export declare const win32: {
+    resolve: () => never;
+    normalize: () => never;
+    isAbsolute: () => never;
+    join: () => never;
+    relative: () => never;
+    dirname: () => never;
+    basename: () => never;
+    extname: () => never;
+    format: () => never;
+    parse: () => never;
+    toNamespacedPath: () => never;
+    sep: string;
+    delimiter: string;
+};
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+declare const _default: {
+    resolve: typeof resolve;
+    normalize: typeof normalize;
+    isAbsolute: typeof isAbsolute;
+    join: typeof join;
+    relative: typeof relative;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    format: typeof format;
+    parse: typeof parse;
+    sep: "/";
+    delimiter: ":";
+    toNamespacedPath: typeof toNamespacedPath;
+} & {
+    readonly posix: unknown;
+    readonly win32: unknown;
+};
+export default _default;
+//# sourceMappingURL=path.d.ts.map

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

@@ -0,0 +1,13 @@
+/** Same clock object the worker global exposes. */
+export declare const performance: Performance;
+/** Observation of performance entries has no consumer here. */
+export declare const PerformanceObserver: typeof import('node:perf_hooks').PerformanceObserver;
+/** 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: {
+    performance: Performance;
+    PerformanceObserver: typeof import("perf_hooks").PerformanceObserver;
+};
+export default _default;
+//# sourceMappingURL=perf_hooks.d.ts.map

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

@@ -0,0 +1,22 @@
+declare const Duplex: typeof import("stream").Duplex, PassThrough: typeof import("stream").PassThrough, Readable: typeof import("stream").Readable, StreamBase: typeof import("stream"), Transform: typeof import("stream").Transform, Writable: typeof import("stream").Writable, addAbortSignal: typeof import("stream").addAbortSignal, compose: (...streams: unknown[]) => unknown, destroy: (stream: unknown, error?: Error) => void, finished: typeof import("stream").finished, isDisturbed: (stream: unknown) => boolean, isErrored: typeof import("stream").isErrored, isReadable: typeof import("stream").isReadable, pipeline: typeof import("stream").pipeline, promises: typeof import("node:stream/promises");
+declare const getDefaultHighWaterMark: typeof import("stream").getDefaultHighWaterMark & ((objectMode: boolean) => number), isDestroyed: (stream: unknown) => boolean | null, isWritable: typeof import("stream").isWritable & ((stream: unknown) => boolean | null), setDefaultHighWaterMark: typeof import("stream").setDefaultHighWaterMark & ((objectMode: boolean, value: number) => void);
+/**
+ * Test whether a value is an ArrayBuffer view.
+ * @param value - Candidate value.
+ * @returns Whether the value is a typed-array or DataView instance.
+ */
+declare const _isArrayBufferView: (value: unknown) => value is ArrayBufferView;
+/** Default-import namespace carrying Node's stream class and static helpers. */
+declare const streamDefault: typeof import("stream") & {
+    _isArrayBufferView: (value: unknown) => value is ArrayBufferView;
+    getDefaultHighWaterMark: typeof import("stream").getDefaultHighWaterMark & ((objectMode: boolean) => number);
+    isDestroyed: (stream: unknown) => boolean | null;
+    isWritable: typeof import("stream").isWritable & ((stream: unknown) => boolean | null);
+    setDefaultHighWaterMark: typeof import("stream").setDefaultHighWaterMark & ((objectMode: boolean, value: number) => void);
+};
+export { Duplex, PassThrough, Readable, StreamBase as Stream, Transform, Writable, addAbortSignal, compose, destroy, finished, getDefaultHighWaterMark, _isArrayBufferView, isDestroyed, isDisturbed, isErrored, isReadable, isWritable, pipeline, promises, setDefaultHighWaterMark, };
+/** CommonJS interop marker consumed by the worker module loader. */
+export declare const __esModule = true;
+/** CommonJS-compatible namespace for default imports. */
+export default streamDefault;
+//# sourceMappingURL=stream.d.ts.map

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

@@ -0,0 +1,36 @@
+/**
+ * `node:timers/promises`: real implementations over the worker's timer globals.
+ */
+import type { TimerOptions } from 'node:timers';
+/**
+ * Resolve after a delay.
+ * @param delayMs - milliseconds to wait.
+ * @param value - value to resolve with; Node resolves undefined when none is handed in.
+ * @param options - abort support, as Node provides.
+ * @returns the value after the delay, or a rejection when the signal aborts.
+ */
+export declare function setTimeout<T = void>(delayMs?: number, value?: T, options?: TimerOptions): Promise<T>;
+/**
+ * Resolve on the next macrotask.
+ * @param value - resolution value handed back after the timer.
+ * @returns a promise resolved after a zero-delay timer.
+ */
+export declare function setImmediate<T = void>(value?: T): Promise<T>;
+/** Cooperative scheduling helpers Node exposes on this module. */
+export declare const scheduler: {
+    wait: (delayMs?: number, options?: TimerOptions) => Promise<void>;
+    yield: () => Promise<void>;
+};
+/** 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: {
+    setTimeout: typeof setTimeout;
+    setImmediate: typeof setImmediate;
+    scheduler: {
+        wait: (delayMs?: number, options?: TimerOptions) => Promise<void>;
+        yield: () => Promise<void>;
+    };
+};
+export default _default;
+//# sourceMappingURL=promises.d.ts.map

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

@@ -0,0 +1,18 @@
+/**
+ * `node:tty` for the browser worker. The host has no terminal-backed file
+ * descriptors, so terminal detection is always false.
+ */
+/**
+ * Test whether a numeric file descriptor refers to a terminal.
+ * @param _fd - File descriptor to inspect.
+ * @returns Always false in the browser worker.
+ */
+export declare function isatty(_fd: number): boolean;
+/** 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: {
+    isatty: typeof isatty;
+};
+export default _default;
+//# sourceMappingURL=tty.d.ts.map

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

@@ -0,0 +1,61 @@
+/**
+ * `node:url` for the worker: the two conversions the host tree uses, plus the
+ * WHATWG classes the browser already provides. VFS paths are POSIX, so the
+ * file-URL mapping is the simple percent-encoding pair.
+ */
+/**
+ * Filesystem path of a `file:` URL.
+ * @param url - file URL or its string form.
+ * @returns the decoded POSIX path.
+ */
+export declare function fileURLToPath(url: string | URL): string;
+/**
+ * `file:` URL of a filesystem path.
+ * @param path - absolute or relative POSIX path.
+ * @returns the URL.
+ */
+export declare function pathToFileURL(path: string): URL;
+/**
+ * Absolute URL from a specifier and its base.
+ * @param specifier - relative or absolute specifier.
+ * @param base - base URL.
+ * @returns the resolved URL string.
+ */
+export declare function resolve(specifier: string, base: string): string;
+/** WHATWG URL class, as `node:url` re-exports it. */
+declare const UrlClass: {
+    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;
+};
+/** WHATWG URLSearchParams class, as `node:url` re-exports it. */
+declare const UrlSearchParamsClass: {
+    new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+    prototype: URLSearchParams;
+};
+export { UrlClass as URL, UrlSearchParamsClass as URLSearchParams };
+/** 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: {
+    fileURLToPath: typeof fileURLToPath;
+    pathToFileURL: typeof pathToFileURL;
+    resolve: typeof resolve;
+    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;
+    };
+};
+export default _default;
+//# sourceMappingURL=url.d.ts.map

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

@@ -0,0 +1,12 @@
+/**
+ * `node:util/types` face: the predicate subset, re-exported from the util shim so
+ * both specifiers share one implementation. The predicates are checked against
+ * Node where they are built, on `types` in `../util.ts`.
+ */
+import { types } from '../util.ts';
+/** The `node:util/types` predicates the harness reads, shared with the util shim. */
+export declare const isPromise: (value: unknown) => value is Promise<unknown>, isDate: (value: unknown) => value is Date, isRegExp: (value: unknown) => value is RegExp, isTypedArray: (value: unknown) => value is NodeJS.TypedArray;
+/** CommonJS interop marker: the worker loader hands `default` to default imports (see ./builtins.ts). */
+export declare const __esModule = true;
+export default types;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,95 @@
+/**
+ * `node:util` for the worker: the members harness code actually imports. Node's
+ * inspect output is only used in diagnostics, so a JSON-shaped rendering is
+ * enough; `promisify` follows Node's error-first callback convention exactly
+ * because zlib-style APIs are wrapped with it at module scope.
+ */
+/**
+ * Wrap an error-first callback function as a promise-returning one.
+ * @param fn - callback-style function.
+ * @returns the promise-returning wrapper.
+ */
+export declare function promisify<A extends unknown[], R>(fn: (...args: [...A, (error: unknown, value: R) => void]) => void): (...args: A) => Promise<R>;
+/**
+ * Wrap a promise-returning function as an error-first callback one.
+ * @param fn - promise-returning function.
+ * @returns the callback-style wrapper.
+ */
+export declare function callbackify<A extends unknown[], R>(fn: (...args: A) => Promise<R>): (...args: [...A, (error: unknown, value?: R) => void]) => void;
+/**
+ * Diagnostic rendering of a value.
+ * @param value - the value.
+ * @returns a readable one-line rendering.
+ */
+export declare function inspect(value: unknown): string;
+/**
+ * printf-style formatting for the `%s`/`%d`/`%j`/`%o` placeholders Node supports.
+ * @param template - format string, or any value when used without placeholders.
+ * @param args - substitution values.
+ * @returns the formatted string.
+ */
+export declare function format(template: unknown, ...args: unknown[]): string;
+/**
+ * Structural deep equality, as `isDeepStrictEqual` defines it for plain data.
+ * @param left - first value.
+ * @param right - second value.
+ * @returns true when both sides are structurally identical.
+ */
+export declare function isDeepStrictEqual(left: unknown, right: unknown): boolean;
+/** Runtime type predicates (`node:util/types`), checked against the Node module of that name. */
+export declare const types: {
+    isPromise: (value: unknown) => value is Promise<unknown>;
+    isDate: (value: unknown) => value is Date;
+    isRegExp: (value: unknown) => value is RegExp;
+    isTypedArray: (value: unknown) => value is NodeJS.TypedArray;
+};
+/**
+ * CLI argument parsing has no caller inside the worker host.
+ * @returns Never — it throws naming the unavailable member.
+ */
+export declare function parseArgs(): never;
+/**
+ * Deprecation wrappers pass the function through unchanged.
+ * @param fn - the function a caller wanted wrapped.
+ * @returns The same function, unwrapped.
+ */
+export declare function deprecate<F>(fn: F): F;
+/** Text decoder class, as `node:util` re-exports it. */
+declare const TextDecoderClass: {
+    new (label?: string, options?: TextDecoderOptions): TextDecoder;
+    prototype: TextDecoder;
+};
+/** Text encoder class, as `node:util` re-exports it. */
+declare const TextEncoderClass: {
+    new (): TextEncoder;
+    prototype: TextEncoder;
+};
+export { TextDecoderClass as TextDecoder, TextEncoderClass as TextEncoder };
+/** 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: {
+    promisify: typeof promisify;
+    callbackify: typeof callbackify;
+    inspect: typeof inspect;
+    format: typeof format;
+    isDeepStrictEqual: typeof isDeepStrictEqual;
+    types: {
+        isPromise: (value: unknown) => value is Promise<unknown>;
+        isDate: (value: unknown) => value is Date;
+        isRegExp: (value: unknown) => value is RegExp;
+        isTypedArray: (value: unknown) => value is NodeJS.TypedArray;
+    };
+    parseArgs: typeof parseArgs;
+    deprecate: typeof deprecate;
+    TextDecoder: {
+        new (label?: string, options?: TextDecoderOptions): TextDecoder;
+        prototype: TextDecoder;
+    };
+    TextEncoder: {
+        new (): TextEncoder;
+        prototype: TextEncoder;
+    };
+};
+export default _default;
+//# sourceMappingURL=util.d.ts.map

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

@@ -0,0 +1,65 @@
+/** Zstandard parameter/flush constants read at module scope by the JSONL backend. */
+export declare const constants: {
+    ZSTD_c_compressionLevel: number;
+    ZSTD_c_checksumFlag: number;
+    ZSTD_e_continue: number;
+    ZSTD_e_flush: number;
+    ZSTD_e_end: number;
+    ZSTD_CLEVEL_DEFAULT: number;
+    Z_NO_FLUSH: number;
+    Z_SYNC_FLUSH: number;
+    Z_FINISH: number;
+};
+/** One-shot Zstandard compression (unavailable; the composition writes plaintext logs). */
+export declare const zstdCompressSync: typeof import('node:zlib').zstdCompressSync;
+/** One-shot Zstandard decompression (unavailable; the worker never reads compressed logs). */
+export declare const zstdDecompressSync: typeof import('node:zlib').zstdDecompressSync;
+/** Callback form of {@link zstdCompressSync} (`promisify`'d at module scope by the backend). */
+export declare const zstdCompress: typeof import('node:zlib').zstdCompress;
+/** Callback form of {@link zstdDecompressSync}. */
+export declare const zstdDecompress: typeof import('node:zlib').zstdDecompress;
+/**
+ * Streaming Zstandard decoder placeholder: the returned object deliberately
+ * lacks Node's private `_handle`/`_writeState` members, which is the signal the
+ * backend's private-shape probe checks before choosing that path.
+ * @returns the incompatible placeholder stream.
+ */
+export declare function createZstdDecompress(): Record<string, unknown>;
+/** Streaming Zstandard encoder (unavailable; the backend only needs one-shot). */
+export declare const createZstdCompress: typeof import('node:zlib').createZstdCompress;
+/** gzip family (unavailable; no consumer in the reachable tree). */
+export declare const gzip: typeof import('node:zlib').gzip;
+/** gzip sync counterpart. */
+export declare const gzipSync: typeof import('node:zlib').gzipSync;
+/** gunzip counterpart. */
+export declare const gunzip: typeof import('node:zlib').gunzip;
+/** gunzip sync counterpart. */
+export declare const gunzipSync: typeof import('node:zlib').gunzipSync;
+/** 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: {
+    constants: {
+        ZSTD_c_compressionLevel: number;
+        ZSTD_c_checksumFlag: number;
+        ZSTD_e_continue: number;
+        ZSTD_e_flush: number;
+        ZSTD_e_end: number;
+        ZSTD_CLEVEL_DEFAULT: number;
+        Z_NO_FLUSH: number;
+        Z_SYNC_FLUSH: number;
+        Z_FINISH: number;
+    };
+    zstdCompress: typeof import("zlib").zstdCompress;
+    zstdCompressSync: typeof import("zlib").zstdCompressSync;
+    zstdDecompress: typeof import("zlib").zstdDecompress;
+    zstdDecompressSync: typeof import("zlib").zstdDecompressSync;
+    createZstdCompress: typeof import("zlib").createZstdCompress;
+    createZstdDecompress: typeof createZstdDecompress;
+    gzip: typeof import("zlib").gzip;
+    gzipSync: typeof import("zlib").gzipSync;
+    gunzip: typeof import("zlib").gunzip;
+    gunzipSync: typeof import("zlib").gunzipSync;
+};
+export default _default;
+//# sourceMappingURL=zlib.d.ts.map

package/lib/types/node/builtin_modules/mock/dns/promises.d.ts

@@ -0,0 +1,10 @@
+/** DNS lookup (unavailable in the worker host). */
+export declare const lookup: typeof import('node:dns/promises').lookup;
+/** CommonJS interop marker: the worker loader hands `default` to default imports. */
+export declare const __esModule = true;
+/** CommonJS default export: the members `require()` hands a caller of this module. */
+declare const _default: {
+    lookup: typeof import("dns/promises").lookup;
+};
+export default _default;
+//# sourceMappingURL=promises.d.ts.map

package/lib/types/node/builtin_modules/mock/net.d.ts

@@ -0,0 +1,61 @@
+/**
+ * `node:net` for the worker. Nothing accepts or dials a socket here: the fake
+ * HTTP server never emits `upgrade`, so only the address predicates and a
+ * constructible-but-loud Socket are reachable.
+ */
+/** Constructible placeholder: the WebSocket upgrade path never runs in the worker. */
+export declare class Socket {
+    /**
+     * Sockets are never written to; reaching this means an upgrade path activated.
+     * @returns Never — it throws naming the unavailable member.
+     */
+    write(): never;
+    /**
+     * Counterpart of {@link write}.
+     * @returns Never — it throws naming the unavailable member.
+     */
+    end(): never;
+    /** Teardown is accepted so disposal paths stay quiet. */
+    destroy(): void;
+}
+/**
+ * Whether a string is an IPv4 literal.
+ * @param value - candidate.
+ * @returns true for dotted-quad literals.
+ */
+export declare function isIPv4(value: string): boolean;
+/**
+ * Whether a string is an IPv6 literal.
+ * @param value - candidate.
+ * @returns true for colon-hex literals.
+ */
+export declare function isIPv6(value: string): boolean;
+/**
+ * IP family of a literal.
+ * @param value - candidate.
+ * @returns 4, 6, or 0 when it is not an IP literal.
+ */
+export declare function isIP(value: string): number;
+/**
+ * TCP listening is the fake HTTP server's business; a bare net server is unreachable.
+ * @returns Never — it throws naming the unavailable member.
+ */
+export declare function createServer(): never;
+/**
+ * Outbound connections have no carrier in a worker.
+ * @returns Never — it throws naming the unavailable member.
+ */
+export declare function connect(): never;
+/** 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: {
+    Socket: typeof Socket;
+    isIP: typeof isIP;
+    isIPv4: typeof isIPv4;
+    isIPv6: typeof isIPv6;
+    createServer: typeof createServer;
+    connect: typeof connect;
+};
+export default _default;
+//# sourceMappingURL=net.d.ts.map

package/lib/types/node/builtin_modules/mock/sqlite.d.ts

@@ -0,0 +1,19 @@
+/** Synchronous database handle (unavailable). */
+export declare const DatabaseSync: typeof import('node:sqlite').DatabaseSync;
+/** Prepared statement handle (unavailable). */
+export declare const StatementSync: typeof import('node:sqlite').StatementSync;
+/**
+ * Backup helper (unavailable).
+ * @returns Never — it throws naming the unavailable member.
+ */
+export declare function backup(): never;
+/** 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: {
+    DatabaseSync: typeof import("node:sqlite").DatabaseSync;
+    StatementSync: typeof import("node:sqlite").StatementSync;
+    backup: typeof backup;
+};
+export default _default;
+//# sourceMappingURL=sqlite.d.ts.map