@code-yeongyu/senpi 2026.6.4 → 2026.6.10-2

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

@@ -1,13 +1,7 @@
-/**
- * HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
- * separate module.
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/https.js)
- */
-declare module "https" {
-    import { NonSharedBuffer } from "node:buffer";
+declare module "node:https" {
+    import * as http from "node:http";
     import { Duplex } from "node:stream";
     import * as tls from "node:tls";
-    import * as http from "node:http";
     import { URL } from "node:url";
     interface ServerOptions<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
@@ -25,6 +19,12 @@ declare module "https" {
     }
     /**
      * An `Agent` object for HTTPS similar to `http.Agent`. See {@link request} for more information.
+     *
+     * Like `http.Agent`, the `createConnection(options[, callback])` method can be overridden
+     * to customize how TLS connections are established.
+     *
+     * > See `agent.createConnection()` for details on overriding this method,
+     * > including asynchronous socket creation with a callback.
      * @since v0.4.5
      */
     class Agent extends http.Agent {
@@ -36,10 +36,10 @@ declare module "https" {
         ): Duplex | null | undefined;
         getName(options?: RequestOptions): string;
     }
-    interface Server<
+    interface ServerEventMap<
         Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
         Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse,
-    > extends http.Server<Request, Response> {}
+    > extends http.ServerEventMap<Request, Response>, tls.ServerEventMap {}
     /**
      * See `http.Server` for more information.
      * @since v0.3.4
@@ -63,245 +63,66 @@ declare module "https" {
          * @since v18.2.0
          */
         closeIdleConnections(): void;
-        addListener(event: string, listener: (...args: any[]) => void): this;
-        addListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
-        addListener(
-            event: "newSession",
-            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
-        ): this;
-        addListener(
-            event: "OCSPRequest",
-            listener: (
-                certificate: NonSharedBuffer,
-                issuer: NonSharedBuffer,
-                callback: (err: Error | null, resp: Buffer | null) => void,
-            ) => void,
-        ): this;
-        addListener(
-            event: "resumeSession",
-            listener: (
-                sessionId: NonSharedBuffer,
-                callback: (err: Error | null, sessionData: Buffer | null) => void,
-            ) => void,
-        ): this;
-        addListener(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
-        addListener(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        addListener(event: "close", listener: () => void): this;
-        addListener(event: "connection", listener: (socket: Duplex) => void): this;
-        addListener(event: "error", listener: (err: Error) => void): this;
-        addListener(event: "listening", listener: () => void): this;
-        addListener(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
-        addListener(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
-        addListener(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
-        addListener(
-            event: "connect",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
-        ): this;
-        addListener(event: "request", listener: http.RequestListener<Request, Response>): this;
-        addListener(
-            event: "upgrade",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
-        ): this;
-        emit(event: string, ...args: any[]): boolean;
-        emit(event: "keylog", line: NonSharedBuffer, tlsSocket: tls.TLSSocket): boolean;
-        emit(
-            event: "newSession",
-            sessionId: NonSharedBuffer,
-            sessionData: NonSharedBuffer,
-            callback: () => void,
-        ): boolean;
-        emit(
-            event: "OCSPRequest",
-            certificate: NonSharedBuffer,
-            issuer: NonSharedBuffer,
-            callback: (err: Error | null, resp: Buffer | null) => void,
-        ): boolean;
-        emit(
-            event: "resumeSession",
-            sessionId: NonSharedBuffer,
-            callback: (err: Error | null, sessionData: Buffer | null) => void,
-        ): boolean;
-        emit(event: "secureConnection", tlsSocket: tls.TLSSocket): boolean;
-        emit(event: "tlsClientError", err: Error, tlsSocket: tls.TLSSocket): boolean;
-        emit(event: "close"): boolean;
-        emit(event: "connection", socket: Duplex): boolean;
-        emit(event: "error", err: Error): boolean;
-        emit(event: "listening"): boolean;
-        emit(
-            event: "checkContinue",
-            req: InstanceType<Request>,
-            res: InstanceType<Response>,
-        ): boolean;
-        emit(
-            event: "checkExpectation",
-            req: InstanceType<Request>,
-            res: InstanceType<Response>,
-        ): boolean;
-        emit(event: "clientError", err: Error, socket: Duplex): boolean;
-        emit(event: "connect", req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer): boolean;
-        emit(
-            event: "request",
-            req: InstanceType<Request>,
-            res: InstanceType<Response>,
-        ): boolean;
-        emit(event: "upgrade", req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer): boolean;
-        on(event: string, listener: (...args: any[]) => void): this;
-        on(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
-        on(
-            event: "newSession",
-            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
-        ): this;
-        on(
-            event: "OCSPRequest",
-            listener: (
-                certificate: NonSharedBuffer,
-                issuer: NonSharedBuffer,
-                callback: (err: Error | null, resp: Buffer | null) => void,
-            ) => void,
-        ): this;
-        on(
-            event: "resumeSession",
-            listener: (
-                sessionId: NonSharedBuffer,
-                callback: (err: Error | null, sessionData: Buffer | null) => void,
-            ) => void,
-        ): this;
-        on(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
-        on(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        on(event: "close", listener: () => void): this;
-        on(event: "connection", listener: (socket: Duplex) => void): this;
-        on(event: "error", listener: (err: Error) => void): this;
-        on(event: "listening", listener: () => void): this;
-        on(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
-        on(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
-        on(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
-        on(
-            event: "connect",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
+        // #region InternalEventEmitter
+        addListener<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
-        on(event: "request", listener: http.RequestListener<Request, Response>): this;
-        on(
-            event: "upgrade",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof ServerEventMap>(eventName: E, ...args: ServerEventMap<Request, Response>[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener?: (...args: ServerEventMap<Request, Response>[E]) => void,
+        ): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof ServerEventMap>(
+            eventName: E,
+        ): ((...args: ServerEventMap<Request, Response>[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
-        once(event: string, listener: (...args: any[]) => void): this;
-        once(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
-        once(
-            event: "newSession",
-            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
-        once(
-            event: "OCSPRequest",
-            listener: (
-                certificate: NonSharedBuffer,
-                issuer: NonSharedBuffer,
-                callback: (err: Error | null, resp: Buffer | null) => void,
-            ) => void,
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
-        once(
-            event: "resumeSession",
-            listener: (
-                sessionId: NonSharedBuffer,
-                callback: (err: Error | null, sessionData: Buffer | null) => void,
-            ) => void,
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
-        once(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
-        once(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        once(event: "close", listener: () => void): this;
-        once(event: "connection", listener: (socket: Duplex) => void): this;
-        once(event: "error", listener: (err: Error) => void): this;
-        once(event: "listening", listener: () => void): this;
-        once(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
-        once(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
-        once(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
-        once(
-            event: "connect",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
-        once(event: "request", listener: http.RequestListener<Request, Response>): this;
-        once(
-            event: "upgrade",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
-        ): this;
-        prependListener(event: string, listener: (...args: any[]) => void): this;
-        prependListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
-        prependListener(
-            event: "newSession",
-            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
-        ): this;
-        prependListener(
-            event: "OCSPRequest",
-            listener: (
-                certificate: NonSharedBuffer,
-                issuer: NonSharedBuffer,
-                callback: (err: Error | null, resp: Buffer | null) => void,
-            ) => void,
-        ): this;
-        prependListener(
-            event: "resumeSession",
-            listener: (
-                sessionId: NonSharedBuffer,
-                callback: (err: Error | null, sessionData: Buffer | null) => void,
-            ) => void,
-        ): this;
-        prependListener(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
-        prependListener(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        prependListener(event: "close", listener: () => void): this;
-        prependListener(event: "connection", listener: (socket: Duplex) => void): this;
-        prependListener(event: "error", listener: (err: Error) => void): this;
-        prependListener(event: "listening", listener: () => void): this;
-        prependListener(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
-        prependListener(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
-        prependListener(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
-        prependListener(
-            event: "connect",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
-        ): this;
-        prependListener(event: "request", listener: http.RequestListener<Request, Response>): this;
-        prependListener(
-            event: "upgrade",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
-        ): this;
-        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: tls.TLSSocket) => void): this;
-        prependOnceListener(
-            event: "newSession",
-            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
-        ): this;
-        prependOnceListener(
-            event: "OCSPRequest",
-            listener: (
-                certificate: NonSharedBuffer,
-                issuer: NonSharedBuffer,
-                callback: (err: Error | null, resp: Buffer | null) => void,
-            ) => void,
-        ): this;
-        prependOnceListener(
-            event: "resumeSession",
-            listener: (
-                sessionId: NonSharedBuffer,
-                callback: (err: Error | null, sessionData: Buffer | null) => void,
-            ) => void,
-        ): this;
-        prependOnceListener(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
-        prependOnceListener(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        prependOnceListener(event: "close", listener: () => void): this;
-        prependOnceListener(event: "connection", listener: (socket: Duplex) => void): this;
-        prependOnceListener(event: "error", listener: (err: Error) => void): this;
-        prependOnceListener(event: "listening", listener: () => void): this;
-        prependOnceListener(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
-        prependOnceListener(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
-        prependOnceListener(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
-        prependOnceListener(
-            event: "connect",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
-        ): this;
-        prependOnceListener(event: "request", listener: http.RequestListener<Request, Response>): this;
-        prependOnceListener(
-            event: "upgrade",
-            listener: (req: InstanceType<Request>, socket: Duplex, head: NonSharedBuffer) => void,
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof ServerEventMap>(
+            eventName: E,
+        ): ((...args: ServerEventMap<Request, Response>[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+        removeAllListeners<E extends keyof ServerEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof ServerEventMap>(
+            eventName: E,
+            listener: (...args: ServerEventMap<Request, Response>[E]) => void,
         ): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        // #endregion
     }
+    interface Server<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse<InstanceType<Request>> = typeof http.ServerResponse,
+    > extends http.Server<Request, Response> {}
     /**
      * ```js
      * // curl -k https://localhost:8000/
@@ -574,6 +395,6 @@ declare module "https" {
     ): http.ClientRequest;
     let globalAgent: Agent;
 }
-declare module "node:https" {
-    export * from "https";
+declare module "https" {
+    export * from "node:https";
 }

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

@@ -22,26 +22,38 @@
  * IN THE SOFTWARE.
  */
 
-// NOTE: These definitions support Node.js and TypeScript 5.7+.
+// NOTE: These definitions support Node.js and TypeScript 5.8+.
 
-// Reference required TypeScript libs:
+// Reference required TypeScript libraries:
 /// <reference lib="es2020" />
+/// <reference lib="esnext.disposable" />
+/// <reference lib="esnext.float16" />
 
-// TypeScript backwards-compatibility definitions:
-/// <reference path="compatibility/index.d.ts" />
+// Iterator definitions required for compatibility with TypeScript <5.6:
+/// <reference path="compatibility/iterators.d.ts" />
 
-// Definitions specific to TypeScript 5.7+:
+// Definitions for Node.js modules specific to TypeScript 5.7+:
 /// <reference path="globals.typedarray.d.ts" />
 /// <reference path="buffer.buffer.d.ts" />
 
 // Definitions for Node.js modules that are not specific to any version of TypeScript:
 /// <reference path="globals.d.ts" />
 /// <reference path="web-globals/abortcontroller.d.ts" />
+/// <reference path="web-globals/blob.d.ts" />
+/// <reference path="web-globals/console.d.ts" />
+/// <reference path="web-globals/crypto.d.ts" />
 /// <reference path="web-globals/domexception.d.ts" />
+/// <reference path="web-globals/encoding.d.ts" />
 /// <reference path="web-globals/events.d.ts" />
 /// <reference path="web-globals/fetch.d.ts" />
+/// <reference path="web-globals/importmeta.d.ts" />
+/// <reference path="web-globals/messaging.d.ts" />
 /// <reference path="web-globals/navigator.d.ts" />
+/// <reference path="web-globals/performance.d.ts" />
 /// <reference path="web-globals/storage.d.ts" />
+/// <reference path="web-globals/streams.d.ts" />
+/// <reference path="web-globals/timers.d.ts" />
+/// <reference path="web-globals/url.d.ts" />
 /// <reference path="assert.d.ts" />
 /// <reference path="assert/strict.d.ts" />
 /// <reference path="async_hooks.d.ts" />
@@ -64,25 +76,31 @@
 /// <reference path="https.d.ts" />
 /// <reference path="inspector.d.ts" />
 /// <reference path="inspector.generated.d.ts" />
+/// <reference path="inspector/promises.d.ts" />
 /// <reference path="module.d.ts" />
 /// <reference path="net.d.ts" />
 /// <reference path="os.d.ts" />
 /// <reference path="path.d.ts" />
+/// <reference path="path/posix.d.ts" />
+/// <reference path="path/win32.d.ts" />
 /// <reference path="perf_hooks.d.ts" />
 /// <reference path="process.d.ts" />
 /// <reference path="punycode.d.ts" />
 /// <reference path="querystring.d.ts" />
+/// <reference path="quic.d.ts" />
 /// <reference path="readline.d.ts" />
 /// <reference path="readline/promises.d.ts" />
 /// <reference path="repl.d.ts" />
 /// <reference path="sea.d.ts" />
 /// <reference path="sqlite.d.ts" />
 /// <reference path="stream.d.ts" />
-/// <reference path="stream/promises.d.ts" />
 /// <reference path="stream/consumers.d.ts" />
+/// <reference path="stream/iter.d.ts" />
+/// <reference path="stream/promises.d.ts" />
 /// <reference path="stream/web.d.ts" />
 /// <reference path="string_decoder.d.ts" />
 /// <reference path="test.d.ts" />
+/// <reference path="test/reporters.d.ts" />
 /// <reference path="timers.d.ts" />
 /// <reference path="timers/promises.d.ts" />
 /// <reference path="tls.d.ts" />
@@ -90,8 +108,10 @@
 /// <reference path="tty.d.ts" />
 /// <reference path="url.d.ts" />
 /// <reference path="util.d.ts" />
+/// <reference path="util/types.d.ts" />
 /// <reference path="v8.d.ts" />
 /// <reference path="vm.d.ts" />
 /// <reference path="wasi.d.ts" />
 /// <reference path="worker_threads.d.ts" />
 /// <reference path="zlib.d.ts" />
+/// <reference path="zlib/iter.d.ts" />

package/node_modules/@types/node/inspector/promises.d.ts

@@ -0,0 +1,35 @@
+declare module "node:inspector/promises" {
+    import { EventEmitter } from "node:events";
+    export { close, console, NetworkResources, open, url, waitForDebugger } from "node:inspector";
+    /**
+     * The `inspector.Session` is used for dispatching messages to the V8 inspector
+     * back-end and receiving message responses and notifications.
+     * @since v19.0.0
+     */
+    export class Session extends EventEmitter {
+        /**
+         * Create a new instance of the inspector.Session class.
+         * The inspector session needs to be connected through `session.connect()` before the messages can be dispatched to the inspector backend.
+         */
+        constructor();
+        /**
+         * Connects a session to the inspector back-end.
+         */
+        connect(): void;
+        /**
+         * Connects a session to the inspector back-end.
+         * An exception will be thrown if this API was not called on a Worker thread.
+         * @since v12.11.0
+         */
+        connectToMainThread(): void;
+        /**
+         * Immediately close the session. All pending message callbacks will be called with an error.
+         * `session.connect()` will need to be called to be able to send messages again.
+         * Reconnected session will lose all inspector state, such as enabled agents or configured breakpoints.
+         */
+        disconnect(): void;
+    }
+}
+declare module "inspector/promises" {
+    export * from "node:inspector/promises";
+}

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

@@ -1,10 +1,5 @@
-/**
- * The `node:inspector` module provides an API for interacting with the V8
- * inspector.
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/inspector.js)
- */
-declare module "inspector" {
-    import EventEmitter = require("node:events");
+declare module "node:inspector" {
+    import { EventEmitter } from "node:events";
     /**
      * The `inspector.Session` is used for dispatching messages to the V8 inspector
      * back-end and receiving message responses and notifications.
@@ -39,7 +34,7 @@ declare module "inspector" {
      * If wait is `true`, will block until a client has connected to the inspect port
      * and flow control has been passed to the debugger client.
      *
-     * See the [security warning](https://nodejs.org/docs/latest-v22.x/api/cli.html#warning-binding-inspector-to-a-public-ipport-combination-is-insecure)
+     * See the [security warning](https://nodejs.org/docs/latest-v25.x/api/cli.html#warning-binding-inspector-to-a-public-ipport-combination-is-insecure)
      * regarding the `host` parameter usage.
      * @param port Port to listen on for inspector connections. Defaults to what was specified on the CLI.
      * @param host Host to listen on for inspector connections. Defaults to what was specified on the CLI.
@@ -125,14 +120,14 @@ declare module "inspector" {
          * `Network.streamResourceContent` command was not invoked for the given request yet.
          *
          * Also enables `Network.getResponseBody` command to retrieve the response data.
-         * @since v22.17.0
+         * @since v24.2.0
          */
         function dataReceived(params: DataReceivedEventDataType): void;
         /**
          * This feature is only available with the `--experimental-network-inspection` flag enabled.
          *
          * Enables `Network.getRequestPostData` command to retrieve the request data.
-         * @since v22.18.0
+         * @since v24.3.0
          */
         function dataSent(params: unknown): void;
         /**
@@ -159,6 +154,30 @@ declare module "inspector" {
          * @since v22.7.0
          */
         function loadingFailed(params: LoadingFailedEventDataType): void;
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.webSocketCreated` event to connected frontends. This event indicates that
+         * a WebSocket connection has been initiated.
+         * @since v24.7.0
+         */
+        function webSocketCreated(params: WebSocketCreatedEventDataType): void;
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.webSocketHandshakeResponseReceived` event to connected frontends.
+         * This event indicates that the WebSocket handshake response has been received.
+         * @since v24.7.0
+         */
+        function webSocketHandshakeResponseReceived(params: WebSocketHandshakeResponseReceivedEventDataType): void;
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.webSocketClosed` event to connected frontends.
+         * This event indicates that a WebSocket connection has been closed.
+         * @since v24.7.0
+         */
+        function webSocketClosed(params: WebSocketClosedEventDataType): void;
     }
     namespace NetworkResources {
         /**
@@ -189,65 +208,57 @@ declare module "inspector" {
          * ```
          *
          * For more details, see the official CDP documentation: [Network.loadNetworkResource](https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-loadNetworkResource)
-         * @since v22.19.0
+         * @since v24.5.0
          * @experimental
          */
         function put(url: string, data: string): void;
     }
-}
-
-/**
- * The `node:inspector` module provides an API for interacting with the V8
- * inspector.
- */
-declare module "node:inspector" {
-    export * from "inspector";
-}
-
-/**
- * The `node:inspector/promises` module provides an API for interacting with the V8
- * inspector.
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/inspector/promises.js)
- * @since v19.0.0
- */
-declare module "inspector/promises" {
-    import EventEmitter = require("node:events");
-    export { close, console, NetworkResources, open, url, waitForDebugger } from "inspector";
-    /**
-     * The `inspector.Session` is used for dispatching messages to the V8 inspector
-     * back-end and receiving message responses and notifications.
-     * @since v19.0.0
-     */
-    export class Session extends EventEmitter {
+    namespace DOMStorage {
         /**
-         * Create a new instance of the inspector.Session class.
-         * The inspector session needs to be connected through `session.connect()` before the messages can be dispatched to the inspector backend.
+         * This feature is only available with the
+         * `--experimental-storage-inspection` flag enabled.
+         *
+         * Broadcasts the `DOMStorage.domStorageItemAdded` event to connected frontends.
+         * This event indicates that a new item has been added to the storage.
+         * @since v25.5.0
          */
-        constructor();
+        function domStorageItemAdded(params: DomStorageItemAddedEventDataType): void;
         /**
-         * Connects a session to the inspector back-end.
+         * This feature is only available with the
+         * `--experimental-storage-inspection` flag enabled.
+         *
+         * Broadcasts the `DOMStorage.domStorageItemRemoved` event to connected frontends.
+         * This event indicates that an item has been removed from the storage.
+         * @since v25.5.0
          */
-        connect(): void;
+        function domStorageItemRemoved(params: DomStorageItemRemovedEventDataType): void;
         /**
-         * Connects a session to the inspector back-end.
-         * An exception will be thrown if this API was not called on a Worker thread.
-         * @since v12.11.0
+         * This feature is only available with the
+         * `--experimental-storage-inspection` flag enabled.
+
+         * Broadcasts the `DOMStorage.domStorageItemUpdated` event to connected frontends.
+         * This event indicates that a storage item has been updated.
+         * @since v25.5.0
          */
-        connectToMainThread(): void;
+        function domStorageItemUpdated(params: DomStorageItemUpdatedEventDataType): void;
         /**
-         * Immediately close the session. All pending message callbacks will be called with an error.
-         * `session.connect()` will need to be called to be able to send messages again.
-         * Reconnected session will lose all inspector state, such as enabled agents or configured breakpoints.
+         * This feature is only available with the
+         * `--experimental-storage-inspection` flag enabled.
+         *
+         * Broadcasts the `DOMStorage.domStorageItemsCleared` event to connected
+         * frontends. This event indicates that all items have been cleared from the
+         * storage.
+         * @since v25.5.0
          */
-        disconnect(): void;
+        function domStorageItemsCleared(params: DomStorageItemsClearedEventDataType): void;
+        /**
+         * This feature is only available with the
+         * `--experimental-storage-inspection` flag enabled.
+         * @since v25.5.0
+         */
+        function registerStorage(params: unknown): void;
     }
 }
-
-/**
- * The `node:inspector/promises` module provides an API for interacting with the V8
- * inspector.
- * @since v19.0.0
- */
-declare module "node:inspector/promises" {
-    export * from "inspector/promises";
+declare module "inspector" {
+    export * from "node:inspector";
 }