@openclaw/msteams 2026.7.1-beta.1 → 2026.7.1-beta.4

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

@@ -33,7 +33,10 @@ declare module "node:diagnostics_channel" {
      * @param name The channel name
      * @return The named channel object
      */
-    function channel(name: string | symbol): Channel;
+    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+    function channel<ContextType = any, StoreType = ContextType>(
+        name: string | symbol,
+    ): Channel<ContextType, StoreType>;
     type ChannelListener = (message: unknown, name: string | symbol) => void;
     /**
      * Register a message handler to subscribe to this channel. This message handler
@@ -96,12 +99,39 @@ declare module "node:diagnostics_channel" {
      * @param nameOrChannels Channel name or object containing all the `TracingChannel Channels`
      * @return Collection of channels to trace with
      */
-    function tracingChannel<
-        StoreType = unknown,
-        ContextType extends object = StoreType extends object ? StoreType : object,
-    >(
-        nameOrChannels: string | TracingChannelCollection<StoreType, ContextType>,
-    ): TracingChannel<StoreType, ContextType>;
+    function tracingChannel<ContextType extends object = object, StoreType = ContextType>(
+        nameOrChannels: string | TracingChannelCollection<ContextType, StoreType>,
+    ): TracingChannel<ContextType, StoreType>;
+    /**
+     * Creates a {@link BoundedChannel} wrapper for the given channels. If a name is
+     * given, the corresponding channels will be created in the form of
+     * `tracing:${name}:${eventType}` where `eventType` is `start` or `end`.
+     *
+     * A `BoundedChannel` is a simplified version of {@link TracingChannel} that only
+     * traces synchronous operations. It only has `start` and `end` events, without
+     * `asyncStart`, `asyncEnd`, or `error` events, making it suitable for tracing
+     * operations that don't involve asynchronous continuations or error handling.
+     *
+     * ```js
+     * import { boundedChannel, channel } from 'node:diagnostics_channel';
+     *
+     * const wc = boundedChannel('my-operation');
+     *
+     * // or...
+     *
+     * const wc2 = boundedChannel({
+     *   start: channel('tracing:my-operation:start'),
+     *   end: channel('tracing:my-operation:end'),
+     * });
+     * ```
+     * @since v26.1.0
+     * @experimental
+     * @param nameOrChannels Channel name or
+     * object containing all the [BoundedChannel Channels](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html#boundedchannel-channels)
+     */
+    function boundedChannel<ContextType extends object = object, StoreType = ContextType>(
+        nameOrChannels: string | BoundedChannelCollection<ContextType, StoreType>,
+    ): BoundedChannel<ContextType, StoreType>;
     /**
      * The class `Channel` represents an individual named channel within the data
      * pipeline. It is used to track subscribers and to publish messages when there
@@ -111,7 +141,8 @@ declare module "node:diagnostics_channel" {
      * with `new Channel(name)` is not supported.
      * @since v15.1.0, v14.17.0
      */
-    class Channel<StoreType = unknown, ContextType = StoreType> {
+    class Channel<ContextType = any, StoreType = ContextType> {
+        private constructor();
         readonly name: string | symbol;
         /**
          * Check if there are active subscribers to this channel. This is helpful if
@@ -132,7 +163,6 @@ declare module "node:diagnostics_channel" {
          * @since v15.1.0, v14.17.0
          */
         readonly hasSubscribers: boolean;
-        private constructor(name: string | symbol);
         /**
          * Publish a message to any subscribers to the channel. This will trigger
          * message handlers synchronously so they will execute within the same context.
@@ -277,7 +307,48 @@ declare module "node:diagnostics_channel" {
             thisArg?: ThisArg,
             ...args: Args
         ): Result;
+        /**
+         * Creates a disposable scope that binds the given data to any AsyncLocalStorage
+         * instances bound to the channel and publishes it to subscribers. The scope
+         * automatically restores the previous storage contexts when disposed.
+         *
+         * This method enables the use of JavaScript's explicit resource management
+         * (`using` syntax with `Symbol.dispose`) to manage store contexts without
+         * closure wrapping.
+         *
+         * ```js
+         * import { channel } from 'node:diagnostics_channel';
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const store = new AsyncLocalStorage();
+         * const ch = channel('my-channel');
+         *
+         * ch.bindStore(store, (message) => {
+         *   return { ...message, timestamp: Date.now() };
+         * });
+         *
+         * {
+         *   using scope = ch.withStoreScope({ request: 'data' });
+         *   // Store is entered, data is published
+         *   console.log(store.getStore()); // { request: 'data', timestamp: ... }
+         * }
+         * // Store is automatically restored on scope exit
+         * ```
+         * @since v26.1.0
+         * @experimental
+         */
+        withStoreScope(data: ContextType): RunStoresScope;
     }
+    /**
+     * The class `RunStoresScope` represents a disposable scope created by
+     * `channel.withStoreScope(data)`. It manages the lifecycle of store
+     * contexts and ensures they are properly restored when the scope exits.
+     *
+     * The scope must be used with the `using` syntax to ensure proper disposal.
+     * @since v26.1.0
+     * @experimental
+     */
+    interface RunStoresScope extends Disposable {}
     interface TracingChannelSubscribers<ContextType extends object> {
         start: (message: ContextType) => void;
         end: (
@@ -304,12 +375,12 @@ declare module "node:diagnostics_channel" {
             },
         ) => void;
     }
-    interface TracingChannelCollection<StoreType = unknown, ContextType = StoreType> {
-        start: Channel<StoreType, ContextType>;
-        end: Channel<StoreType, ContextType>;
-        asyncStart: Channel<StoreType, ContextType>;
-        asyncEnd: Channel<StoreType, ContextType>;
-        error: Channel<StoreType, ContextType>;
+    interface TracingChannelCollection<ContextType extends object = object, StoreType = ContextType> {
+        start: Channel<ContextType, StoreType>;
+        end: Channel<ContextType, StoreType>;
+        asyncStart: Channel<ContextType, StoreType>;
+        asyncEnd: Channel<ContextType, StoreType>;
+        error: Channel<ContextType, StoreType>;
     }
     /**
      * The class `TracingChannel` is a collection of `TracingChannel Channels` which
@@ -320,12 +391,9 @@ declare module "node:diagnostics_channel" {
      * @since v19.9.0
      * @experimental
      */
-    class TracingChannel<StoreType = unknown, ContextType extends object = {}> implements TracingChannelCollection {
-        start: Channel<StoreType, ContextType>;
-        end: Channel<StoreType, ContextType>;
-        asyncStart: Channel<StoreType, ContextType>;
-        asyncEnd: Channel<StoreType, ContextType>;
-        error: Channel<StoreType, ContextType>;
+    interface TracingChannel<ContextType extends object = object, StoreType = ContextType>
+        extends TracingChannelCollection<ContextType, StoreType>
+    {
         /**
          * Helper to subscribe a collection of functions to the corresponding channels.
          * This is the same as calling `channel.subscribe(onMessage)` on each channel
@@ -358,7 +426,7 @@ declare module "node:diagnostics_channel" {
          * @experimental
          * @param subscribers Set of `TracingChannel Channels` subscribers
          */
-        subscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
+        subscribe(subscribers: NodeJS.PartialOptions<TracingChannelSubscribers<ContextType>>): void;
         /**
          * Helper to unsubscribe a collection of functions from the corresponding channels.
          * This is the same as calling `channel.unsubscribe(onMessage)` on each channel
@@ -392,7 +460,7 @@ declare module "node:diagnostics_channel" {
          * @param subscribers Set of `TracingChannel Channels` subscribers
          * @return `true` if all handlers were successfully unsubscribed, and `false` otherwise.
          */
-        unsubscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
+        unsubscribe(subscribers: NodeJS.PartialOptions<TracingChannelSubscribers<ContextType>>): void;
         /**
          * Trace a synchronous function call. This will always produce a `start event` and `end event` around the execution and may produce an `error event` if the given function throws an error.
          * This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
@@ -427,12 +495,20 @@ declare module "node:diagnostics_channel" {
             ...args: Args
         ): Result;
         /**
-         * Trace a promise-returning function call. This will always produce a `start event` and `end event` around the synchronous portion of the
-         * function execution, and will produce an `asyncStart event` and `asyncEnd event` when a promise continuation is reached. It may also
-         * produce an `error event` if the given function throws an error or the
-         * returned promise rejects. This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
+         * Trace an asynchronous function call which returns a `Promise` or
+         * [thenable object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#thenables). This will always produce a [`start` event](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html#startevent) and
+         * [`end` event](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html#endevent) around the synchronous portion of the function execution, and
+         * will produce an [`asyncStart` event](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html#asyncstartevent) and [`asyncEnd` event](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html#asyncendevent) when the
+         * returned promise is resolved or rejected. It may also produce an
+         * [`error` event](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html#errorevent) if the given function throws an error or the returned promise
+         * is rejected. This will run the given function using
+         * [`channel.runStores(context, ...)`](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html##channelrunstorescontext-fn-thisarg-args) on the `start` channel which ensures all
          * events should have any bound stores set to match this trace context.
          *
+         * If the value returned by `fn` is not a Promise or thenable, then it will be
+         * returned with a warning, and no `asyncStart` or `asyncEnd` events will be
+         * produced.
+         *
          * To ensure only correct trace graphs are formed, events will only be published if subscribers are present prior to starting the trace. Subscriptions
          * which are added after the trace begins will not receive future events from that trace, only future traces will be seen.
          *
@@ -449,18 +525,21 @@ declare module "node:diagnostics_channel" {
          * ```
          * @since v19.9.0
          * @experimental
-         * @param fn Promise-returning function to wrap a trace around
+         * @param fn Function to wrap a trace around
          * @param context Shared object to correlate trace events through
          * @param thisArg The receiver to be used for the function call
          * @param args Optional arguments to pass to the function
-         * @return Chained from promise returned by the given function
+         * @returns The return value of the given function, or the result of
+         * calling `.then(...)` on the return value if the tracing channel has active
+         * subscribers. If the return value is not a Promise or thenable, then
+         * it is returned as-is and a warning is emitted.
          */
-        tracePromise<ThisArg = any, Args extends any[] = any[], Result = any>(
-            fn: (this: ThisArg, ...args: Args) => Promise<Result>,
+        tracePromise<ThisArg = any, Args extends any[] = any[], Result extends PromiseLike<unknown> = any>(
+            fn: (this: ThisArg, ...args: Args) => Result,
             context?: ContextType,
             thisArg?: ThisArg,
             ...args: Args
-        ): Promise<Result>;
+        ): Result;
         /**
          * Trace a callback-receiving function call. This will always produce a `start event` and `end event` around the synchronous portion of the
          * function execution, and will produce a `asyncStart event` and `asyncEnd event` around the callback execution. It may also produce an `error event` if the given function throws an error or
@@ -546,6 +625,169 @@ declare module "node:diagnostics_channel" {
          */
         readonly hasSubscribers: boolean;
     }
+    interface BoundedChannelSubscribers<ContextType extends object> {
+        start: (message: ContextType) => void;
+        end: (message: ContextType) => void;
+    }
+    interface BoundedChannelCollection<ContextType extends object = object, StoreType = ContextType> {
+        start: Channel<ContextType, StoreType>;
+        end: Channel<ContextType, StoreType>;
+    }
+    /**
+     * The class `BoundedChannel` is a simplified version of {@link TracingChannel} that
+     * only traces synchronous operations. It consists of two channels (`start` and
+     * `end`) instead of five, omitting the `asyncStart`, `asyncEnd`, and `error`
+     * events. This makes it suitable for tracing operations that don't involve
+     * asynchronous continuations or error handling.
+     *
+     * Like `TracingChannel`, it is recommended to create and reuse a single
+     * `BoundedChannel` at the top-level of the file rather than creating them
+     * dynamically.
+     * @since v26.1.0
+     * @experimental
+     */
+    interface BoundedChannel<ContextType extends object = object, StoreType = ContextType>
+        extends BoundedChannelCollection<ContextType, StoreType>
+    {
+        /**
+         * Check if any of the `start` or `end` channels have subscribers.
+         *
+         * ```js
+         * import { boundedChannel } from 'node:diagnostics_channel';
+         *
+         * const wc = boundedChannel('my-operation');
+         *
+         * if (wc.hasSubscribers) {
+         *   // There are subscribers, perform traced operation
+         * }
+         * ```
+         * @since v26.1.0
+         */
+        readonly hasSubscribers: boolean;
+        /**
+         * Subscribe to the bounded channel events. This is equivalent to calling
+         * [`channel.subscribe(onMessage)`][] on each channel individually.
+         *
+         * ```mjs
+         * import { boundedChannel } from 'node:diagnostics_channel';
+         *
+         * const wc = boundedChannel('my-operation');
+         *
+         * wc.subscribe({
+         *   start(message) {
+         *     // Handle start
+         *   },
+         *   end(message) {
+         *     // Handle end
+         *   },
+         * });
+         * ```
+         * @since v26.1.0
+         * @param handlers Set of channel subscribers
+         */
+        subscribe(handlers: NodeJS.PartialOptions<BoundedChannelSubscribers<ContextType>>): void;
+        /**
+         * Unsubscribe from the bounded channel events. This is equivalent to calling
+         * [`channel.unsubscribe(onMessage)`][] on each channel individually.
+         *
+         * ```js
+         * import { boundedChannel } from 'node:diagnostics_channel';
+         *
+         * const wc = boundedChannel('my-operation');
+         *
+         * const handlers = {
+         *   start(message) {},
+         *   end(message) {},
+         * };
+         *
+         * wc.subscribe(handlers);
+         * wc.unsubscribe(handlers);
+         * ```
+         * @since v26.1.0
+         * @param handlers Set of channel subscribers
+         * @returns `true` if all handlers were successfully unsubscribed,
+         * `false` otherwise.
+         */
+        unsubscribe(handlers: NodeJS.PartialOptions<BoundedChannelSubscribers<ContextType>>): boolean;
+        /**
+         * Trace a synchronous function call. This will produce a `start` event and `end`
+         * event around the execution. This runs the given function using
+         * [`channel.runStores(context, ...)`][] on the `start` channel which ensures all
+         * events have any bound stores set to match this trace context.
+         *
+         * ```js
+         * import { boundedChannel } from 'node:diagnostics_channel';
+         *
+         * const wc = boundedChannel('my-operation');
+         *
+         * const result = wc.run({ operationId: '123' }, () => {
+         *   // Perform operation
+         *   return 42;
+         * });
+         * ```
+         * @since v26.1.0
+         * @param context Shared object to correlate events through
+         * @param fn Function to wrap a trace around
+         * @param thisArg The receiver to be used for the function call
+         * @param args Optional arguments to pass to the function
+         * @returns The return value of the given function
+         */
+        run<ThisArg = any, Args extends any[] = any[], Result = any>(
+            fn: (this: ThisArg, ...args: Args) => Result,
+            context?: ContextType,
+            thisArg?: ThisArg,
+            ...args: Args
+        ): Result;
+        /**
+         * Create a disposable scope for tracing a synchronous operation using JavaScript's
+         * explicit resource management (`using` syntax). The scope automatically publishes
+         * `start` and `end` events, enters bound stores, and handles cleanup when disposed.
+         *
+         * ```js
+         * import { boundedChannel } from 'node:diagnostics_channel';
+         *
+         * const wc = boundedChannel('my-operation');
+         *
+         * const context = { operationId: '123' };
+         * {
+         *   using scope = wc.withScope(context);
+         *   // Stores are entered, start event is published
+         *
+         *   // Perform work and set result on context
+         *   context.result = 42;
+         * }
+         * // End event is published, stores are restored automatically
+         * ```
+         * @since v26.1.0
+         * @param context Shared object to correlate events through
+         * @returns Disposable scope object
+         */
+        withScope(context: ContextType): BoundedChannelScope;
+    }
+    /**
+     * The class `BoundedChannelScope` represents a disposable scope created by
+     * `boundedChannel.withScope(context)`. It manages the lifecycle of a traced
+     * operation, automatically publishing events and managing store contexts.
+     *
+     * The scope must be used with the `using` syntax to ensure proper disposal.
+     *
+     * ```js
+     * import { boundedChannel } from 'node:diagnostics_channel';
+     *
+     * const wc = boundedChannel('my-operation');
+     *
+     * const context = {};
+     * {
+     *   using scope = wc.withScope(context);
+     *   // Start event is published, stores are entered
+     *   context.result = performOperation();
+     *   // End event is automatically published at end of block
+     * }
+     * ```
+     * @since v26.1.0
+     * @experimental
+     */
+    interface BoundedChannelScope extends Disposable {}
 }
 declare module "diagnostics_channel" {
     export * from "node:diagnostics_channel";

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

@@ -24,7 +24,7 @@ declare module "node:dns" {
          */
         family?: number | "IPv4" | "IPv6" | undefined;
         /**
-         * One or more [supported `getaddrinfo`](https://nodejs.org/docs/latest-v25.x/api/dns.html#supported-getaddrinfo-flags) flags. Multiple flags may be
+         * One or more [supported `getaddrinfo`](https://nodejs.org/docs/latest-v26.x/api/dns.html#supported-getaddrinfo-flags) flags. Multiple flags may be
          * passed by bitwise `OR`ing their values.
          */
         hints?: number | undefined;
@@ -34,10 +34,10 @@ declare module "node:dns" {
          */
         all?: boolean | undefined;
         /**
-         * When `verbatim`, the resolved addresses are return unsorted. When `ipv4first`, the resolved addresses are sorted
+         * When `verbatim`, the resolved addresses are returned unsorted. When `ipv4first`, the resolved addresses are sorted
          * by placing IPv4 addresses before IPv6 addresses. When `ipv6first`, the resolved addresses are sorted by placing IPv6
          * addresses before IPv4 addresses. Default value is configurable using
-         * {@link setDefaultResultOrder} or [`--dns-result-order`](https://nodejs.org/docs/latest-v25.x/api/cli.html#--dns-result-orderorder).
+         * {@link setDefaultResultOrder} or [`--dns-result-order`](https://nodejs.org/docs/latest-v26.x/api/cli.html#--dns-result-orderorder).
          * @default `verbatim` (addresses are not reordered)
          * @since v22.1.0
          */
@@ -86,7 +86,7 @@ declare module "node:dns" {
      * The implementation uses an operating system facility that can associate names
      * with addresses and vice versa. This implementation can have subtle but
      * important consequences on the behavior of any Node.js program. Please take some
-     * time to consult the [Implementation considerations section](https://nodejs.org/docs/latest-v25.x/api/dns.html#implementation-considerations)
+     * time to consult the [Implementation considerations section](https://nodejs.org/docs/latest-v26.x/api/dns.html#implementation-considerations)
      * before using `dns.lookup()`.
      *
      * Example usage:
@@ -108,7 +108,7 @@ declare module "node:dns" {
      * // addresses: [{"address":"2606:2800:220:1:248:1893:25c8:1946","family":6}]
      * ```
      *
-     * If this method is invoked as its [util.promisify()](https://nodejs.org/docs/latest-v25.x/api/util.html#utilpromisifyoriginal) ed
+     * If this method is invoked as its [util.promisify()](https://nodejs.org/docs/latest-v26.x/api/util.html#utilpromisifyoriginal) ed
      * version, and `all` is not set to `true`, it returns a `Promise` for an `Object` with `address` and `family` properties.
      * @since v0.1.90
      */
@@ -148,7 +148,7 @@ declare module "node:dns" {
      * If `address` is not a valid IP address, a `TypeError` will be thrown.
      * The `port` will be coerced to a number. If it is not a legal port, a `TypeError` will be thrown.
      *
-     * On an error, `err` is an [`Error`](https://nodejs.org/docs/latest-v25.x/api/errors.html#class-error) object,
+     * On an error, `err` is an [`Error`](https://nodejs.org/docs/latest-v26.x/api/errors.html#class-error) object,
      * where `err.code` is the error code.
      *
      * ```js
@@ -159,7 +159,7 @@ declare module "node:dns" {
      * });
      * ```
      *
-     * If this method is invoked as its [util.promisify()](https://nodejs.org/docs/latest-v25.x/api/util.html#utilpromisifyoriginal) ed
+     * If this method is invoked as its [util.promisify()](https://nodejs.org/docs/latest-v26.x/api/util.html#utilpromisifyoriginal) ed
      * version, it returns a `Promise` for an `Object` with `hostname` and `service` properties.
      * @since v0.11.14
      */
@@ -288,7 +288,7 @@ declare module "node:dns" {
      *
      * <omitted>
      *
-     * On error, `err` is an [`Error`](https://nodejs.org/docs/latest-v25.x/api/errors.html#class-error) object,
+     * On error, `err` is an [`Error`](https://nodejs.org/docs/latest-v26.x/api/errors.html#class-error) object,
      * where `err.code` is one of the `DNS error codes`.
      * @since v0.1.27
      * @param hostname Host name to resolve.
@@ -667,8 +667,8 @@ declare module "node:dns" {
      * Performs a reverse DNS query that resolves an IPv4 or IPv6 address to an
      * array of host names.
      *
-     * On error, `err` is an [`Error`](https://nodejs.org/docs/latest-v25.x/api/errors.html#class-error) object, where `err.code` is
-     * one of the [DNS error codes](https://nodejs.org/docs/latest-v25.x/api/dns.html#error-codes).
+     * On error, `err` is an [`Error`](https://nodejs.org/docs/latest-v26.x/api/errors.html#class-error) object, where `err.code` is
+     * one of the [DNS error codes](https://nodejs.org/docs/latest-v26.x/api/dns.html#error-codes).
      * @since v0.1.16
      */
     function reverse(
@@ -676,7 +676,7 @@ declare module "node:dns" {
         callback: (err: NodeJS.ErrnoException | null, hostnames: string[]) => void,
     ): void;
     /**
-     * Get the default value for `order` in {@link lookup} and [`dnsPromises.lookup()`](https://nodejs.org/docs/latest-v25.x/api/dns.html#dnspromiseslookuphostname-options).
+     * Get the default value for `order` in {@link lookup} and [`dnsPromises.lookup()`](https://nodejs.org/docs/latest-v26.x/api/dns.html#dnspromiseslookuphostname-options).
      * The value could be:
      *
      * * `ipv4first`: for `order` defaulting to `ipv4first`.
@@ -731,7 +731,7 @@ declare module "node:dns" {
      */
     function getServers(): string[];
     /**
-     * Set the default value of `order` in {@link lookup} and [`dnsPromises.lookup()`](https://nodejs.org/docs/latest-v25.x/api/dns.html#dnspromiseslookuphostname-options).
+     * Set the default value of `order` in {@link lookup} and [`dnsPromises.lookup()`](https://nodejs.org/docs/latest-v26.x/api/dns.html#dnspromiseslookuphostname-options).
      * The value could be:
      *
      * * `ipv4first`: sets default `order` to `ipv4first`.
@@ -739,8 +739,8 @@ declare module "node:dns" {
      * * `verbatim`: sets default `order` to `verbatim`.
      *
      * The default is `verbatim` and {@link setDefaultResultOrder} have higher
-     * priority than [`--dns-result-order`](https://nodejs.org/docs/latest-v25.x/api/cli.html#--dns-result-orderorder). When using
-     * [worker threads](https://nodejs.org/docs/latest-v25.x/api/worker_threads.html), {@link setDefaultResultOrder} from the main
+     * priority than [`--dns-result-order`](https://nodejs.org/docs/latest-v26.x/api/cli.html#--dns-result-orderorder). When using
+     * [worker threads](https://nodejs.org/docs/latest-v26.x/api/worker_threads.html), {@link setDefaultResultOrder} from the main
      * thread won't affect the default dns orders in workers.
      * @since v16.4.0, v14.18.0
      * @param order must be `'ipv4first'`, `'ipv6first'` or `'verbatim'`.
@@ -791,7 +791,7 @@ declare module "node:dns" {
      * An independent resolver for DNS requests.
      *
      * Creating a new resolver uses the default server settings. Setting
-     * the servers used for a resolver using [`resolver.setServers()`](https://nodejs.org/docs/latest-v25.x/api/dns.html#dnssetserversservers) does not affect
+     * the servers used for a resolver using [`resolver.setServers()`](https://nodejs.org/docs/latest-v26.x/api/dns.html#dnssetserversservers) does not affect
      * other resolvers:
      *
      * ```js

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

@@ -32,7 +32,7 @@ declare module "node:events" {
     interface EventEmitterOptions {
         /**
          * It enables
-         * [automatic capturing of promise rejection](https://nodejs.org/docs/latest-v25.x/api/events.html#capture-rejections-of-promises).
+         * [automatic capturing of promise rejection](https://nodejs.org/docs/latest-v26.x/api/events.html#capture-rejections-of-promises).
          * @default false
          */
         captureRejections?: boolean | undefined;
@@ -445,7 +445,7 @@ declare module "node:events" {
             signal?: AbortSignal | undefined;
         }
         /**
-         * See how to write a custom [rejection handler](https://nodejs.org/docs/latest-v25.x/api/events.html#emittersymbolfornodejsrejectionerr-eventname-args).
+         * See how to write a custom [rejection handler](https://nodejs.org/docs/latest-v26.x/api/events.html#emittersymbolfornodejsrejectionerr-eventname-args).
          * @since v13.4.0, v12.16.0
          */
         const captureRejectionSymbol: unique symbol;
@@ -857,7 +857,7 @@ declare module "node:events" {
         /**
          * Integrates `EventEmitter` with `AsyncResource` for `EventEmitter`s that
          * require manual async tracking. Specifically, all events emitted by instances
-         * of `events.EventEmitterAsyncResource` will run within its [async context](https://nodejs.org/docs/latest-v25.x/api/async_context.html).
+         * of `events.EventEmitterAsyncResource` will run within its [async context](https://nodejs.org/docs/latest-v26.x/api/async_context.html).
          *
          * ```js
          * import { EventEmitterAsyncResource, EventEmitter } from 'node:events';