@code-yeongyu/senpi 2026.6.4 → 2026.6.10-2

package/node_modules/@types/node/wasi.d.ts

@@ -1,75 +1,4 @@
-/**
- * **The `node:wasi` module does not currently provide the**
- * **comprehensive file system security properties provided by some WASI runtimes.**
- * **Full support for secure file system sandboxing may or may not be implemented in**
- * **future. In the mean time, do not rely on it to run untrusted code.**
- *
- * The WASI API provides an implementation of the [WebAssembly System Interface](https://wasi.dev/) specification. WASI gives WebAssembly applications access to the underlying
- * operating system via a collection of POSIX-like functions.
- *
- * ```js
- * import { readFile } from 'node:fs/promises';
- * import { WASI } from 'node:wasi';
- * import { argv, env } from 'node:process';
- *
- * const wasi = new WASI({
- *   version: 'preview1',
- *   args: argv,
- *   env,
- *   preopens: {
- *     '/local': '/some/real/path/that/wasm/can/access',
- *   },
- * });
- *
- * const wasm = await WebAssembly.compile(
- *   await readFile(new URL('./demo.wasm', import.meta.url)),
- * );
- * const instance = await WebAssembly.instantiate(wasm, wasi.getImportObject());
- *
- * wasi.start(instance);
- * ```
- *
- * To run the above example, create a new WebAssembly text format file named `demo.wat`:
- *
- * ```text
- * (module
- *     ;; Import the required fd_write WASI function which will write the given io vectors to stdout
- *     ;; The function signature for fd_write is:
- *     ;; (File Descriptor, *iovs, iovs_len, nwritten) -> Returns number of bytes written
- *     (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))
- *
- *     (memory 1)
- *     (export "memory" (memory 0))
- *
- *     ;; Write 'hello world\n' to memory at an offset of 8 bytes
- *     ;; Note the trailing newline which is required for the text to appear
- *     (data (i32.const 8) "hello world\n")
- *
- *     (func $main (export "_start")
- *         ;; Creating a new io vector within linear memory
- *         (i32.store (i32.const 0) (i32.const 8))  ;; iov.iov_base - This is a pointer to the start of the 'hello world\n' string
- *         (i32.store (i32.const 4) (i32.const 12))  ;; iov.iov_len - The length of the 'hello world\n' string
- *
- *         (call $fd_write
- *             (i32.const 1) ;; file_descriptor - 1 for stdout
- *             (i32.const 0) ;; *iovs - The pointer to the iov array, which is stored at memory location 0
- *             (i32.const 1) ;; iovs_len - We're printing 1 string stored in an iov - so one.
- *             (i32.const 20) ;; nwritten - A place in memory to store the number of bytes written
- *         )
- *         drop ;; Discard the number of bytes written from the top of the stack
- *     )
- * )
- * ```
- *
- * Use [wabt](https://github.com/WebAssembly/wabt) to compile `.wat` to `.wasm`
- *
- * ```bash
- * wat2wasm demo.wat
- * ```
- * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/wasi.js)
- */
-declare module "wasi" {
+declare module "node:wasi" {
     interface WASIOptions {
         /**
          * An array of strings that the WebAssembly application will
@@ -121,6 +50,12 @@ declare module "wasi" {
          */
         version: "unstable" | "preview1";
     }
+    interface FinalizeBindingsOptions {
+        /**
+         * @default instance.exports.memory
+         */
+        memory?: object | undefined;
+    }
     /**
      * The `WASI` class provides the WASI system call API and additional convenience
      * methods for working with WASI-based applications. Each `WASI` instance
@@ -167,6 +102,21 @@ declare module "wasi" {
          * @since v14.6.0, v12.19.0
          */
         initialize(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
+        /**
+         * Set up WASI host bindings to `instance` without calling `initialize()`
+         * or `start()`. This method is useful when the WASI module is instantiated in
+         * child threads for sharing the memory across threads.
+         *
+         * `finalizeBindings()` requires that either `instance` exports a
+         * [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named `memory` or user specify a
+         * [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) object in `options.memory`. If the `memory` is invalid
+         * an exception is thrown.
+         *
+         * `start()` and `initialize()` will call `finalizeBindings()` internally.
+         * If `finalizeBindings()` is called more than once, an exception is thrown.
+         * @since v24.4.0
+         */
+        finalizeBindings(instance: object, options?: FinalizeBindingsOptions): void;
         /**
          * `wasiImport` is an object that implements the WASI system call API. This object
          * should be passed as the `wasi_snapshot_preview1` import during the instantiation
@@ -176,6 +126,6 @@ declare module "wasi" {
         readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types
     }
 }
-declare module "node:wasi" {
-    export * from "wasi";
+declare module "wasi" {
+    export * from "node:wasi";
 }

package/node_modules/@types/node/web-globals/abortcontroller.d.ts

@@ -1,17 +1,42 @@
 export {};
 
+import { InternalEventTargetEventProperties } from "node:events";
+
 type _AbortController = typeof globalThis extends { onmessage: any } ? {} : AbortController;
 interface AbortController {
     readonly signal: AbortSignal;
     abort(reason?: any): void;
 }
 
+interface AbortSignalEventMap {
+    "abort": Event;
+}
+
 type _AbortSignal = typeof globalThis extends { onmessage: any } ? {} : AbortSignal;
-interface AbortSignal extends EventTarget {
+interface AbortSignal extends EventTarget, InternalEventTargetEventProperties<AbortSignalEventMap> {
     readonly aborted: boolean;
-    onabort: ((this: AbortSignal, ev: Event) => any) | null;
     readonly reason: any;
     throwIfAborted(): void;
+    addEventListener<K extends keyof AbortSignalEventMap>(
+        type: K,
+        listener: (ev: AbortSignalEventMap[K]) => void,
+        options?: AddEventListenerOptions | boolean,
+    ): void;
+    addEventListener(
+        type: string,
+        listener: EventListener | EventListenerObject,
+        options?: AddEventListenerOptions | boolean,
+    ): void;
+    removeEventListener<K extends keyof AbortSignalEventMap>(
+        type: K,
+        listener: (ev: AbortSignalEventMap[K]) => void,
+        options?: EventListenerOptions | boolean,
+    ): void;
+    removeEventListener(
+        type: string,
+        listener: EventListener | EventListenerObject,
+        options?: EventListenerOptions | boolean,
+    ): void;
 }
 
 declare global {

package/node_modules/@types/node/web-globals/blob.d.ts

@@ -0,0 +1,23 @@
+export {};
+
+import * as buffer from "node:buffer";
+
+type _Blob = typeof globalThis extends { onmessage: any } ? {} : buffer.Blob;
+type _BlobPropertyBag = typeof globalThis extends { onmessage: any } ? {} : buffer.BlobPropertyBag;
+type _File = typeof globalThis extends { onmessage: any } ? {} : buffer.File;
+type _FilePropertyBag = typeof globalThis extends { onmessage: any } ? {} : buffer.FilePropertyBag;
+
+declare global {
+    interface Blob extends _Blob {}
+    var Blob: typeof globalThis extends { onmessage: any; Blob: infer T } ? T : typeof buffer.Blob;
+
+    interface BlobPropertyBag extends _BlobPropertyBag {}
+
+    interface File extends _File {}
+    var File: typeof globalThis extends { onmessage: any; File: infer T } ? T : typeof buffer.File;
+
+    interface FilePropertyBag extends _FilePropertyBag {}
+
+    function atob(data: string): string;
+    function btoa(data: string): string;
+}

package/node_modules/@types/node/web-globals/console.d.ts

@@ -0,0 +1,9 @@
+export {};
+
+import * as console from "node:console";
+
+declare global {
+    interface Console extends console.Console {}
+
+    var console: Console;
+}

package/node_modules/@types/node/web-globals/crypto.d.ts

@@ -0,0 +1,39 @@
+export {};
+
+import { webcrypto } from "crypto";
+
+type _Crypto = typeof globalThis extends { onmessage: any } ? {} : webcrypto.Crypto;
+type _CryptoKey = typeof globalThis extends { onmessage: any } ? {} : webcrypto.CryptoKey;
+type _SubtleCrypto = typeof globalThis extends { onmessage: any } ? {} : webcrypto.SubtleCrypto;
+
+declare global {
+    interface Crypto extends _Crypto {}
+    var Crypto: typeof globalThis extends { onmessage: any; Crypto: infer T } ? T : {
+        prototype: webcrypto.Crypto;
+        new(): webcrypto.Crypto;
+    };
+
+    interface CryptoKey extends _CryptoKey {}
+    var CryptoKey: typeof globalThis extends { onmessage: any; CryptoKey: infer T } ? T : {
+        prototype: webcrypto.CryptoKey;
+        new(): webcrypto.CryptoKey;
+    };
+
+    interface SubtleCrypto extends _SubtleCrypto {}
+    var SubtleCrypto: typeof globalThis extends { onmessage: any; SubtleCrypto: infer T } ? T : {
+        prototype: webcrypto.SubtleCrypto;
+        new(): webcrypto.SubtleCrypto;
+        supports(
+            operation: string,
+            algorithm: webcrypto.AlgorithmIdentifier,
+            length?: number,
+        ): boolean;
+        supports(
+            operation: string,
+            algorithm: webcrypto.AlgorithmIdentifier,
+            additionalAlgorithm: webcrypto.AlgorithmIdentifier,
+        ): boolean;
+    };
+
+    var crypto: typeof globalThis extends { onmessage: any; crypto: infer T } ? T : webcrypto.Crypto;
+}

package/node_modules/@types/node/web-globals/encoding.d.ts

@@ -0,0 +1,11 @@
+export {};
+
+import * as util from "node:util";
+
+declare global {
+    interface TextDecoder extends util.TextDecoder {}
+    var TextDecoder: typeof globalThis extends { onmessage: any; TextDecoder: infer T } ? T : typeof util.TextDecoder;
+
+    interface TextEncoder extends util.TextEncoder {}
+    var TextEncoder: typeof globalThis extends { onmessage: any; TextEncoder: infer T } ? T : typeof util.TextEncoder;
+}

package/node_modules/@types/node/web-globals/events.d.ts

@@ -1,5 +1,6 @@
 export {};
 
+type _AddEventListenerOptions = typeof globalThis extends { onmessage: any } ? {} : AddEventListenerOptions;
 interface AddEventListenerOptions extends EventListenerOptions {
     once?: boolean;
     passive?: boolean;
@@ -43,10 +44,12 @@ interface EventInit {
     composed?: boolean;
 }
 
+type _EventListener = typeof globalThis extends { onmessage: any } ? {} : EventListener;
 interface EventListener {
     (evt: Event): void;
 }
 
+type _EventListenerObject = typeof globalThis extends { onmessage: any } ? {} : EventListenerObject;
 interface EventListenerObject {
     handleEvent(object: Event): void;
 }
@@ -72,6 +75,8 @@ interface EventTarget {
 }
 
 declare global {
+    interface AddEventListenerOptions extends _AddEventListenerOptions {}
+
     interface CustomEvent<T = any> extends _CustomEvent<T> {}
     var CustomEvent: typeof globalThis extends { onmessage: any; CustomEvent: infer T } ? T
         : {
@@ -86,6 +91,10 @@ declare global {
             new(type: string, eventInitDict?: EventInit): Event;
         };
 
+    interface EventListener extends _EventListener {}
+
+    interface EventListenerObject extends _EventListenerObject {}
+
     interface EventListenerOptions extends _EventListenerOptions {}
 
     interface EventTarget extends _EventTarget {}

package/node_modules/@types/node/web-globals/fetch.d.ts

@@ -2,6 +2,10 @@ export {};
 
 import * as undici from "undici-types";
 
+type _CloseEvent = typeof globalThis extends { onmessage: any } ? {} : undici.CloseEvent;
+type _CloseEventInit = typeof globalThis extends { onmessage: any } ? {} : undici.CloseEventInit;
+type _ErrorEvent = typeof globalThis extends { onmessage: any } ? {} : undici.ErrorEvent;
+type _ErrorEventInit = typeof globalThis extends { onmessage: any } ? {} : undici.ErrorEventInit;
 type _EventSource = typeof globalThis extends { onmessage: any } ? {} : undici.EventSource;
 type _EventSourceInit = typeof globalThis extends { onmessage: any } ? {} : undici.EventSourceInit;
 type _FormData = typeof globalThis extends { onmessage: any } ? {} : undici.FormData;
@@ -21,6 +25,16 @@ declare global {
         init?: RequestInit,
     ): Promise<Response>;
 
+    interface CloseEvent extends _CloseEvent {}
+    var CloseEvent: typeof globalThis extends { onmessage: any; CloseEvent: infer T } ? T : typeof undici.CloseEvent;
+
+    interface CloseEventInit extends _CloseEventInit {}
+
+    interface ErrorEvent extends _ErrorEvent {}
+    var ErrorEvent: typeof globalThis extends { onmessage: any; ErrorEvent: infer T } ? T : typeof undici.ErrorEvent;
+
+    interface ErrorEventInit extends _ErrorEventInit {}
+
     interface EventSource extends _EventSource {}
     var EventSource: typeof globalThis extends { onmessage: any; EventSource: infer T } ? T : typeof undici.EventSource;
 

package/node_modules/@types/node/web-globals/importmeta.d.ts

@@ -0,0 +1,13 @@
+export {};
+
+import { URL } from "node:url";
+
+declare global {
+    interface ImportMeta {
+        dirname: string;
+        filename: string;
+        main: boolean;
+        url: string;
+        resolve(specifier: string, parent?: string | URL): string;
+    }
+}

package/node_modules/@types/node/web-globals/messaging.d.ts

@@ -0,0 +1,23 @@
+export {};
+
+import * as worker_threads from "node:worker_threads";
+
+type _BroadcastChannel = typeof globalThis extends { onmessage: any } ? {} : worker_threads.BroadcastChannel;
+type _MessageChannel = typeof globalThis extends { onmessage: any } ? {} : worker_threads.MessageChannel;
+type _MessagePort = typeof globalThis extends { onmessage: any } ? {} : worker_threads.MessagePort;
+
+declare global {
+    function structuredClone<T = any>(value: T, options?: worker_threads.StructuredSerializeOptions): T;
+
+    interface BroadcastChannel extends _BroadcastChannel {}
+    var BroadcastChannel: typeof globalThis extends { onmessage: any; BroadcastChannel: infer T } ? T
+        : typeof worker_threads.BroadcastChannel;
+
+    interface MessageChannel extends _MessageChannel {}
+    var MessageChannel: typeof globalThis extends { onmessage: any; MessageChannel: infer T } ? T
+        : typeof worker_threads.MessageChannel;
+
+    interface MessagePort extends _MessagePort {}
+    var MessagePort: typeof globalThis extends { onmessage: any; MessagePort: infer T } ? T
+        : typeof worker_threads.MessagePort;
+}

package/node_modules/@types/node/web-globals/navigator.d.ts

@@ -1,11 +1,14 @@
 export {};
 
+import { LockManager } from "worker_threads";
+
 // lib.webworker has `WorkerNavigator` rather than `Navigator`, so conditionals use `onabort` instead of `onmessage`
 type _Navigator = typeof globalThis extends { onabort: any } ? {} : Navigator;
 interface Navigator {
     readonly hardwareConcurrency: number;
     readonly language: string;
     readonly languages: readonly string[];
+    readonly locks: LockManager;
     readonly platform: string;
     readonly userAgent: string;
 }

package/node_modules/@types/node/web-globals/performance.d.ts

@@ -0,0 +1,45 @@
+export {};
+
+import * as perf_hooks from "node:perf_hooks";
+
+type _Performance = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.Performance;
+type _PerformanceEntry = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.PerformanceEntry;
+type _PerformanceMark = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.PerformanceMark;
+type _PerformanceMeasure = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.PerformanceMeasure;
+type _PerformanceObserver = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.PerformanceObserver;
+type _PerformanceObserverEntryList = typeof globalThis extends { onmessage: any } ? {}
+    : perf_hooks.PerformanceObserverEntryList;
+type _PerformanceResourceTiming = typeof globalThis extends { onmessage: any } ? {}
+    : perf_hooks.PerformanceResourceTiming;
+
+declare global {
+    interface Performance extends _Performance {}
+    var Performance: typeof globalThis extends { onmessage: any; Performance: infer T } ? T
+        : typeof perf_hooks.Performance;
+
+    interface PerformanceEntry extends _PerformanceEntry {}
+    var PerformanceEntry: typeof globalThis extends { onmessage: any; PerformanceEntry: infer T } ? T
+        : typeof perf_hooks.PerformanceEntry;
+
+    interface PerformanceMark extends _PerformanceMark {}
+    var PerformanceMark: typeof globalThis extends { onmessage: any; PerformanceMark: infer T } ? T
+        : typeof perf_hooks.PerformanceMark;
+
+    interface PerformanceMeasure extends _PerformanceMeasure {}
+    var PerformanceMeasure: typeof globalThis extends { onmessage: any; PerformanceMeasure: infer T } ? T
+        : typeof perf_hooks.PerformanceMeasure;
+
+    interface PerformanceObserver extends _PerformanceObserver {}
+    var PerformanceObserver: typeof globalThis extends { onmessage: any; PerformanceObserver: infer T } ? T
+        : typeof perf_hooks.PerformanceObserver;
+
+    interface PerformanceObserverEntryList extends _PerformanceObserverEntryList {}
+    var PerformanceObserverEntryList: typeof globalThis extends
+        { onmessage: any; PerformanceObserverEntryList: infer T } ? T : typeof perf_hooks.PerformanceObserverEntryList;
+
+    interface PerformanceResourceTiming extends _PerformanceResourceTiming {}
+    var PerformanceResourceTiming: typeof globalThis extends { onmessage: any; PerformanceResourceTiming: infer T } ? T
+        : typeof perf_hooks.PerformanceResourceTiming;
+
+    var performance: typeof globalThis extends { onmessage: any; performance: infer T } ? T : perf_hooks.Performance;
+}

package/node_modules/@types/node/web-globals/streams.d.ts

@@ -0,0 +1,115 @@
+export {};
+
+import * as webstreams from "stream/web";
+
+type _ByteLengthQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ByteLengthQueuingStrategy;
+type _CompressionStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.CompressionStream;
+type _CountQueuingStrategy = typeof globalThis extends { onmessage: any } ? {} : webstreams.CountQueuingStrategy;
+type _DecompressionStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.DecompressionStream;
+type _QueuingStrategy<T = any> = typeof globalThis extends { onmessage: any } ? {} : webstreams.QueuingStrategy<T>;
+type _ReadableByteStreamController = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ReadableByteStreamController;
+type _ReadableStream<R = any> = typeof globalThis extends { onmessage: any } ? {} : webstreams.ReadableStream<R>;
+type _ReadableStreamBYOBReader = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ReadableStreamBYOBReader;
+type _ReadableStreamBYOBRequest = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ReadableStreamBYOBRequest;
+type _ReadableStreamDefaultController<R = any> = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ReadableStreamDefaultController<R>;
+type _ReadableStreamDefaultReader<R = any> = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ReadableStreamDefaultReader<R>;
+type _TextDecoderStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.TextDecoderStream;
+type _TextEncoderStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.TextEncoderStream;
+type _TransformStream<I = any, O = any> = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.TransformStream<I, O>;
+type _TransformStreamDefaultController<O = any> = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.TransformStreamDefaultController<O>;
+type _WritableStream<W = any> = typeof globalThis extends { onmessage: any } ? {} : webstreams.WritableStream<W>;
+type _WritableStreamDefaultController = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.WritableStreamDefaultController;
+type _WritableStreamDefaultWriter<W = any> = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.WritableStreamDefaultWriter<W>;
+
+declare global {
+    interface ByteLengthQueuingStrategy extends _ByteLengthQueuingStrategy {}
+    var ByteLengthQueuingStrategy: typeof globalThis extends { onmessage: any; ByteLengthQueuingStrategy: infer T } ? T
+        : typeof webstreams.ByteLengthQueuingStrategy;
+
+    interface CompressionStream extends _CompressionStream {}
+    var CompressionStream: typeof globalThis extends {
+        onmessage: any;
+        CompressionStream: infer T;
+    } ? T
+        : typeof webstreams.CompressionStream;
+
+    interface CountQueuingStrategy extends _CountQueuingStrategy {}
+    var CountQueuingStrategy: typeof globalThis extends { onmessage: any; CountQueuingStrategy: infer T } ? T
+        : typeof webstreams.CountQueuingStrategy;
+
+    interface DecompressionStream extends _DecompressionStream {}
+    var DecompressionStream: typeof globalThis extends {
+        onmessage: any;
+        DecompressionStream: infer T;
+    } ? T
+        : typeof webstreams.DecompressionStream;
+
+    interface QueuingStrategy<T = any> extends _QueuingStrategy<T> {}
+
+    interface ReadableByteStreamController extends _ReadableByteStreamController {}
+    var ReadableByteStreamController: typeof globalThis extends
+        { onmessage: any; ReadableByteStreamController: infer T } ? T : typeof webstreams.ReadableByteStreamController;
+
+    interface ReadableStream<R = any> extends _ReadableStream<R> {}
+    var ReadableStream: typeof globalThis extends { onmessage: any; ReadableStream: infer T } ? T
+        : typeof webstreams.ReadableStream;
+
+    interface ReadableStreamBYOBReader extends _ReadableStreamBYOBReader {}
+    var ReadableStreamBYOBReader: typeof globalThis extends { onmessage: any; ReadableStreamBYOBReader: infer T } ? T
+        : typeof webstreams.ReadableStreamBYOBReader;
+
+    interface ReadableStreamBYOBRequest extends _ReadableStreamBYOBRequest {}
+    var ReadableStreamBYOBRequest: typeof globalThis extends { onmessage: any; ReadableStreamBYOBRequest: infer T } ? T
+        : typeof webstreams.ReadableStreamBYOBRequest;
+
+    interface ReadableStreamDefaultController<R = any> extends _ReadableStreamDefaultController<R> {}
+    var ReadableStreamDefaultController: typeof globalThis extends
+        { onmessage: any; ReadableStreamDefaultController: infer T } ? T
+        : typeof webstreams.ReadableStreamDefaultController;
+
+    interface ReadableStreamDefaultReader<R = any> extends _ReadableStreamDefaultReader<R> {}
+    var ReadableStreamDefaultReader: typeof globalThis extends { onmessage: any; ReadableStreamDefaultReader: infer T }
+        ? T
+        : typeof webstreams.ReadableStreamDefaultReader;
+
+    interface TextDecoderStream extends _TextDecoderStream {}
+    var TextDecoderStream: typeof globalThis extends { onmessage: any; TextDecoderStream: infer T } ? T
+        : typeof webstreams.TextDecoderStream;
+
+    interface TextEncoderStream extends _TextEncoderStream {}
+    var TextEncoderStream: typeof globalThis extends { onmessage: any; TextEncoderStream: infer T } ? T
+        : typeof webstreams.TextEncoderStream;
+
+    interface TransformStream<I = any, O = any> extends _TransformStream<I, O> {}
+    var TransformStream: typeof globalThis extends { onmessage: any; TransformStream: infer T } ? T
+        : typeof webstreams.TransformStream;
+
+    interface TransformStreamDefaultController<O = any> extends _TransformStreamDefaultController<O> {}
+    var TransformStreamDefaultController: typeof globalThis extends
+        { onmessage: any; TransformStreamDefaultController: infer T } ? T
+        : typeof webstreams.TransformStreamDefaultController;
+
+    interface WritableStream<W = any> extends _WritableStream<W> {}
+    var WritableStream: typeof globalThis extends { onmessage: any; WritableStream: infer T } ? T
+        : typeof webstreams.WritableStream;
+
+    interface WritableStreamDefaultController extends _WritableStreamDefaultController {}
+    var WritableStreamDefaultController: typeof globalThis extends
+        { onmessage: any; WritableStreamDefaultController: infer T } ? T
+        : typeof webstreams.WritableStreamDefaultController;
+
+    interface WritableStreamDefaultWriter<W = any> extends _WritableStreamDefaultWriter<W> {}
+    var WritableStreamDefaultWriter: typeof globalThis extends { onmessage: any; WritableStreamDefaultWriter: infer T }
+        ? T
+        : typeof webstreams.WritableStreamDefaultWriter;
+}

package/node_modules/@types/node/web-globals/timers.d.ts

@@ -0,0 +1,44 @@
+export {};
+
+import * as promises from "node:timers/promises";
+
+// Note: The timer function definitions allow a single void-accepting argument
+// to be optional in arguments lists. This allows usage such as
+// `new Promise(resolve => setTimeout(resolve, ms))` (#54258)
+// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+type MakeVoidParameterOptional<TArgs extends any[]> = [void] extends TArgs ? Partial<TArgs> : TArgs;
+
+declare global {
+    function setImmediate<TArgs extends any[]>(
+        callback: (...args: TArgs) => void,
+        ...args: MakeVoidParameterOptional<TArgs>
+    ): NodeJS.Immediate;
+    namespace setImmediate {
+        import __promisify__ = promises.setImmediate;
+        export { __promisify__ };
+    }
+
+    function setInterval<TArgs extends any[]>(
+        callback: (...args: TArgs) => void,
+        delay?: number,
+        ...args: MakeVoidParameterOptional<TArgs>
+    ): NodeJS.Timeout;
+
+    function setTimeout<TArgs extends any[]>(
+        callback: (...args: TArgs) => void,
+        delay?: number,
+        ...args: MakeVoidParameterOptional<TArgs>
+    ): NodeJS.Timeout;
+    namespace setTimeout {
+        import __promisify__ = promises.setTimeout;
+        export { __promisify__ };
+    }
+
+    function clearImmediate(immediate: NodeJS.Immediate | undefined): void;
+
+    function clearInterval(timeout: NodeJS.Timeout | string | number | undefined): void;
+
+    function clearTimeout(timeout: NodeJS.Timeout | string | number | undefined): void;
+
+    function queueMicrotask(callback: () => void): void;
+}

package/node_modules/@types/node/web-globals/url.d.ts

@@ -0,0 +1,24 @@
+export {};
+
+import * as url from "node:url";
+
+declare global {
+    interface URL extends url.URL {}
+    var URL: typeof globalThis extends { onmessage: any; URL: infer T } ? T : typeof url.URL;
+
+    interface URLPattern extends url.URLPattern {}
+    var URLPattern: typeof globalThis extends {
+        onmessage: any;
+        scheduler: any; // Must be a var introduced at the same time as URLPattern.
+        URLPattern: infer T;
+    } ? T
+        : typeof url.URLPattern;
+
+    interface URLPatternInit extends url.URLPatternInit {}
+
+    interface URLPatternResult extends url.URLPatternResult {}
+
+    interface URLSearchParams extends url.URLSearchParams {}
+    var URLSearchParams: typeof globalThis extends { onmessage: any; URLSearchParams: infer T } ? T
+        : typeof url.URLSearchParams;
+}