@openclaw/diagnostics-otel 2026.6.8 → 2026.6.9

package/node_modules/protobufjs/src/util.js

@@ -11,9 +11,9 @@ var roots = require("./roots");
 var Type, // cyclic
     Enum;
 
-util.codegen  = require("./util/codegen");
-util.fetch    = require("./util/fetch");
-util.path     = require("./util/path");
+util.codegen = require("@protobufjs/codegen");
+util.fetch   = require("@protobufjs/fetch");
+util.path    = require("@protobufjs/path");
 util.patterns = require("./util/patterns");
 
 var reservedRe = util.patterns.reservedRe;
@@ -24,6 +24,20 @@ var reservedRe = util.patterns.reservedRe;
  */
 util.fs = require("./util/fs");
 
+/**
+ * Checks a recursion depth.
+ * @param {number|undefined} depth Depth of recursion
+ * @returns {number} Depth of recursion
+ * @throws {Error} If depth exceeds util.recursionLimit
+ */
+util.checkDepth = function checkDepth(depth) {
+    if (depth === undefined)
+        depth = 0;
+    if (depth > util.recursionLimit)
+        throw Error("max depth exceeded");
+    return depth;
+};
+
 /**
  * Converts an object's values to an array.
  * @param {Object.<string,*>} object Object to convert
@@ -117,7 +131,6 @@ util.compareFieldsById = function compareFieldsById(a, b) {
  * @returns {Type} Reflected type
  * @template T extends Message<T>
  * @property {Root} root Decorators root
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 util.decorateType = function decorateType(ctor, typeName) {
 
@@ -149,7 +162,6 @@ var decorateEnumIndex = 0;
  * Decorator helper for enums (TypeScript).
  * @param {Object} object Enum object
  * @returns {Enum} Reflected enum
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 util.decorateEnum = function decorateEnum(object) {
 
@@ -210,7 +222,6 @@ util.setProperty = function setProperty(dst, path, value, ifNotSet) {
  * @name util.decorateRoot
  * @type {Root}
  * @readonly
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 Object.defineProperty(util, "decorateRoot", {
     get: function() {

package/node_modules/protobufjs/src/verifier.js

@@ -32,7 +32,7 @@ function genVerifyValue(gen, field, fieldIndex, ref) {
         } else {
             gen
             ("{")
-                ("var e=types[%i].verify(%s,q+1);", fieldIndex, ref)
+                ("var e=types[%i].verify(%s,n+1);", fieldIndex, ref)
                 ("if(e)")
                     ("return%j+e", field.name + ".")
             ("}");
@@ -122,12 +122,12 @@ function genVerifyKey(gen, field, ref) {
 function verifier(mtype) {
     /* eslint-disable no-unexpected-multiline */
 
-    var gen = util.codegen(["m", "q"], mtype.name + "$verify")
+    var gen = util.codegen(["m", "n"], mtype.name + "$verify")
     ("if(typeof m!==\"object\"||m===null)")
         ("return%j", "object expected")
-    ("if(q===undefined)q=0")
-    ("if(q>util.recursionLimit)")
-        ("return%j", "max depth exceeded");
+    ("if(n===undefined)n=0")
+    ("if(n>util.recursionLimit)")
+        ("return%j", "maximum nesting depth exceeded");
     var oneofs = mtype.oneofsArray,
         seenFirstField = {};
     if (oneofs.length) gen
@@ -138,7 +138,7 @@ function verifier(mtype) {
             ref   = "m" + util.safeProp(field.name);
 
         if (field.optional) gen
-        ("if(%s!=null&&m.hasOwnProperty(%j)){", ref, field.name); // !== undefined && !== null
+        ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)){", ref, field.name); // !== undefined && !== null
 
         // map fields
         if (field.map) { gen

package/node_modules/protobufjs/src/wrappers.js

@@ -75,6 +75,7 @@ wrappers[".google.protobuf.Any"] = {
         var googleApi = "type.googleapis.com/";
         var prefix = "";
         var name = "";
+
         // decode value if requested and unmapped
         if (options && options.json && message.type_url && message.value) {
             // Only use fully qualified type name after the last '/'

package/node_modules/protobufjs/src/writer.js

@@ -173,11 +173,6 @@ function writeByte(val, buf, pos) {
     buf[pos] = val & 255;
 }
 
-function writeStringAscii(val, buf, pos) {
-    for (var i = 0; i < val.length;)
-        buf[pos++] = val.charCodeAt(i++);
-}
-
 function writeVarint32(val, buf, pos) {
     while (val > 127) {
         buf[pos++] = val & 127 | 128;
@@ -230,7 +225,7 @@ Writer.prototype.uint32 = function write_uint32(value) {
  * @returns {Writer} `this`
  */
 Writer.prototype.int32 = function write_int32(value) {
-    return value < 0
+    return (value |= 0) < 0
         ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec
         : this.uint32(value);
 };
@@ -245,16 +240,18 @@ Writer.prototype.sint32 = function write_sint32(value) {
 };
 
 function writeVarint64(val, buf, pos) {
-    while (val.hi) {
-        buf[pos++] = val.lo & 127 | 128;
-        val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
-        val.hi >>>= 7;
+    var lo = val.lo,
+        hi = val.hi;
+    while (hi) {
+        buf[pos++] = lo & 127 | 128;
+        lo = (lo >>> 7 | hi << 25) >>> 0;
+        hi >>>= 7;
     }
-    while (val.lo > 127) {
-        buf[pos++] = val.lo & 127 | 128;
-        val.lo = val.lo >>> 7;
+    while (lo > 127) {
+        buf[pos++] = lo & 127 | 128;
+        lo = lo >>> 7;
     }
-    buf[pos++] = val.lo;
+    buf[pos++] = lo;
 }
 
 /**
@@ -388,16 +385,6 @@ Writer.prototype.bytes = function write_bytes(value) {
     return this.uint32(len)._push(writeBytes, len, value);
 };
 
-/**
- * Writes raw bytes without a tag or length prefix.
- * @param {Uint8Array} value Raw bytes
- * @returns {Writer} `this`
- */
-Writer.prototype.raw = function write_raw(value) {
-    var len = value.length >>> 0;
-    return len ? this._push(writeBytes, len, value) : this;
-};
-
 /**
  * Writes a string.
  * @param {string} value Value to write
@@ -406,7 +393,7 @@ Writer.prototype.raw = function write_raw(value) {
 Writer.prototype.string = function write_string(value) {
     var len = utf8.length(value);
     return len
-        ? this.uint32(len)._push(len === value.length ? writeStringAscii : utf8.write, len, value)
+        ? this.uint32(len)._push(utf8.write, len, value)
         : this._push(writeByte, 1, 0);
 };
 
@@ -461,28 +448,15 @@ Writer.prototype.ldelim = function ldelim() {
  * @returns {Uint8Array} Finished buffer
  */
 Writer.prototype.finish = function finish() {
-    return this.finishInto(this.constructor.alloc(this.len), 0);
-};
-
-/**
- * Finishes the write operation, writing into the provided buffer.
- * The caller must ensure that `buf` has enough space starting at `offset`
- * to hold {@link Writer#len} bytes.
- * @param {T} buf Target buffer
- * @param {number} [offset=0] Offset to start writing at
- * @returns {T} The provided buffer
- * @template T extends Uint8Array
- */
-Writer.prototype.finishInto = function finishInto(buf, offset) {
-    if (offset === undefined)
-        offset = 0;
-    var head = this.head.next,
-        pos  = offset;
+    var head = this.head.next, // skip noop
+        buf  = this.constructor.alloc(this.len),
+        pos  = 0;
     while (head) {
         head.fn(head.val, buf, pos);
         pos += head.len;
         head = head.next;
     }
+    // this.head = this.tail = null;
     return buf;
 };
 

package/node_modules/protobufjs/src/writer_buffer.js

@@ -54,23 +54,6 @@ BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
     return this;
 };
 
-/**
- * Writes raw bytes without a tag or length prefix.
- * @name BufferWriter#raw
- * @function
- * @param {Uint8Array} value Raw bytes
- * @returns {BufferWriter} `this`
- */
-BufferWriter.prototype.raw = function write_raw_buffer(value) {
-    var len = value.length >>> 0;
-    return len ? this._push(BufferWriter.writeBytesBuffer, len, value) : this;
-};
-
-function writeStringBufferAscii(val, buf, pos) {
-    for (var i = 0; i < val.length;)
-        buf[pos++] = val.charCodeAt(i++);
-}
-
 function writeStringBuffer(val, buf, pos) {
     if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)
         util.utf8.write(val, buf, pos);
@@ -87,7 +70,7 @@ BufferWriter.prototype.string = function write_string_buffer(value) {
     var len = util.Buffer.byteLength(value);
     this.uint32(len);
     if (len)
-        this._push(len === value.length && len < 40 ? writeStringBufferAscii : writeStringBuffer, len, value);
+        this._push(writeStringBuffer, len, value);
     return this;
 };
 

package/node_modules/protobufjs/tsconfig.json

@@ -1,6 +1,8 @@
 {
     "compilerOptions": {
-        "target": "es2019",
-        "module": "commonjs"
+        "target": "ES5",
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true,
+        "esModuleInterop": true,
     }
-}
+}

package/node_modules/undici-types/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Matteo Collina and Undici contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/undici-types/README.md

@@ -0,0 +1,6 @@
+# undici-types
+
+This package is a dual-publish of the [undici](https://www.npmjs.com/package/undici) library types. The `undici` package **still contains types**. This package is for users who _only_ need undici types (such as for `@types/node`). It is published alongside every release of `undici`, so you can always use the same version.
+
+- [GitHub nodejs/undici](https://github.com/nodejs/undici)
+- [Undici Documentation](https://undici.nodejs.org/#/)

package/node_modules/undici-types/agent.d.ts

@@ -0,0 +1,32 @@
+import { URL } from 'node:url'
+import Pool from './pool'
+import Dispatcher from './dispatcher'
+import TClientStats from './client-stats'
+import TPoolStats from './pool-stats'
+
+export default Agent
+
+declare class Agent extends Dispatcher {
+  constructor (opts?: Agent.Options)
+  /** `true` after `dispatcher.close()` has been called. */
+  closed: boolean
+  /** `true` after `dispatcher.destroyed()` has been called or `dispatcher.close()` has been called and the dispatcher shutdown has completed. */
+  destroyed: boolean
+  /** Dispatches a request. */
+  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
+  /** Aggregate stats for a Agent by origin. */
+  readonly stats: Record<string, TClientStats | TPoolStats>
+}
+
+declare namespace Agent {
+  export interface Options extends Pool.Options {
+    /** Default: `(origin, opts) => new Pool(origin, opts)`. */
+    factory?(origin: string | URL, opts: Object): Dispatcher;
+
+    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options['interceptors']
+    maxOrigins?: number
+  }
+
+  export interface DispatchOptions extends Dispatcher.DispatchOptions {
+  }
+}

package/node_modules/undici-types/api.d.ts

@@ -0,0 +1,43 @@
+import { URL, UrlObject } from 'node:url'
+import { Duplex } from 'node:stream'
+import Dispatcher from './dispatcher'
+
+/** Performs an HTTP request. */
+declare function request<TOpaque = null> (
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
+): Promise<Dispatcher.ResponseData<TOpaque>>
+
+/** A faster version of `request`. */
+declare function stream<TOpaque = null> (
+  url: string | URL | UrlObject,
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path'>,
+  factory: Dispatcher.StreamFactory<TOpaque>
+): Promise<Dispatcher.StreamData<TOpaque>>
+
+/** For easy use with `stream.pipeline`. */
+declare function pipeline<TOpaque = null> (
+  url: string | URL | UrlObject,
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions<TOpaque>, 'origin' | 'path'>,
+  handler: Dispatcher.PipelineHandler<TOpaque>
+): Duplex
+
+/** Starts two-way communications with the requested resource. */
+declare function connect<TOpaque = null> (
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin' | 'path'>
+): Promise<Dispatcher.ConnectData<TOpaque>>
+
+/** Upgrade to a different protocol. */
+declare function upgrade (
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.UpgradeOptions, 'origin' | 'path'>
+): Promise<Dispatcher.UpgradeData>
+
+export {
+  request,
+  stream,
+  pipeline,
+  connect,
+  upgrade
+}

package/node_modules/undici-types/balanced-pool.d.ts

@@ -0,0 +1,30 @@
+import Pool from './pool'
+import Dispatcher from './dispatcher'
+import { URL } from 'node:url'
+
+export default BalancedPool
+
+type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+
+declare class BalancedPool extends Dispatcher {
+  constructor (url: string | string[] | URL | URL[], options?: Pool.Options)
+
+  addUpstream (upstream: string | URL): BalancedPool
+  removeUpstream (upstream: string | URL): BalancedPool
+  getUpstream (upstream: string | URL): Pool | undefined
+  upstreams: Array<string>
+
+  /** `true` after `pool.close()` has been called. */
+  closed: boolean
+  /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
+  destroyed: boolean
+
+  // Override dispatcher APIs.
+  override connect (
+    options: BalancedPoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
+    options: BalancedPoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void
+}

package/node_modules/undici-types/cache-interceptor.d.ts

@@ -0,0 +1,179 @@
+import { Readable, Writable } from 'node:stream'
+
+export default CacheHandler
+
+declare namespace CacheHandler {
+  export type CacheMethods = 'GET' | 'HEAD' | 'OPTIONS' | 'TRACE'
+
+  export interface CacheHandlerOptions {
+    store: CacheStore
+
+    cacheByDefault?: number
+
+    type?: CacheOptions['type']
+  }
+
+  export interface CacheOptions {
+    store?: CacheStore
+
+    /**
+     * The methods to cache
+     * Note we can only cache safe methods. Unsafe methods (i.e. PUT, POST)
+     *  invalidate the cache for a origin.
+     * @see https://www.rfc-editor.org/rfc/rfc9111.html#name-invalidating-stored-respons
+     * @see https://www.rfc-editor.org/rfc/rfc9110#section-9.2.1
+     */
+    methods?: CacheMethods[]
+
+    /**
+     * RFC9111 allows for caching responses that we aren't explicitly told to
+     *  cache or to not cache.
+     * @see https://www.rfc-editor.org/rfc/rfc9111.html#section-3-5
+     * @default undefined
+     */
+    cacheByDefault?: number
+
+    /**
+     * TODO docs
+     * @default 'shared'
+     */
+    type?: 'shared' | 'private'
+
+    /**
+     * Array of origins to cache. Only requests to these origins will be cached.
+     * Supports strings (case insensitive) and RegExp patterns.
+     * @default undefined (cache all origins)
+     */
+    origins?: (string | RegExp)[]
+  }
+
+  export interface CacheControlDirectives {
+    'max-stale'?: number;
+    'min-fresh'?: number;
+    'max-age'?: number;
+    's-maxage'?: number;
+    'stale-while-revalidate'?: number;
+    'stale-if-error'?: number;
+    public?: true;
+    private?: true | string[];
+    'no-store'?: true;
+    'no-cache'?: true | string[];
+    'must-revalidate'?: true;
+    'proxy-revalidate'?: true;
+    immutable?: true;
+    'no-transform'?: true;
+    'must-understand'?: true;
+    'only-if-cached'?: true;
+  }
+
+  export interface CacheKey {
+    origin: string
+    method: string
+    path: string
+    headers?: Record<string, string | string[]>
+  }
+
+  export interface CacheValue {
+    statusCode: number
+    statusMessage: string
+    headers: Record<string, string | string[]>
+    vary?: Record<string, string | string[] | null>
+    etag?: string
+    cacheControlDirectives?: CacheControlDirectives
+    cachedAt: number
+    staleAt: number
+    deleteAt: number
+  }
+
+  export interface DeleteByUri {
+    origin: string
+    method: string
+    path: string
+  }
+
+  type GetResult = {
+    statusCode: number
+    statusMessage: string
+    headers: Record<string, string | string[]>
+    vary?: Record<string, string | string[] | null>
+    etag?: string
+    body?: Readable | Iterable<Buffer> | AsyncIterable<Buffer> | Buffer | Iterable<string> | AsyncIterable<string> | string
+    cacheControlDirectives: CacheControlDirectives,
+    cachedAt: number
+    staleAt: number
+    deleteAt: number
+  }
+
+  /**
+   * Underlying storage provider for cached responses
+   */
+  export interface CacheStore {
+    get(key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream(key: CacheKey, val: CacheValue): Writable | undefined
+
+    delete(key: CacheKey): void | Promise<void>
+  }
+
+  export interface MemoryCacheStoreOpts {
+    /**
+       * @default Infinity
+       */
+    maxCount?: number
+
+    /**
+     * @default Infinity
+     */
+    maxSize?: number
+
+    /**
+     * @default Infinity
+     */
+    maxEntrySize?: number
+
+    errorCallback?: (err: Error) => void
+  }
+
+  export class MemoryCacheStore implements CacheStore {
+    constructor (opts?: MemoryCacheStoreOpts)
+
+    get (key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream (key: CacheKey, value: CacheValue): Writable | undefined
+
+    delete (key: CacheKey): void | Promise<void>
+  }
+
+  export interface SqliteCacheStoreOpts {
+    /**
+     * Location of the database
+     * @default ':memory:'
+     */
+    location?: string
+
+    /**
+     * @default Infinity
+     */
+    maxCount?: number
+
+    /**
+     * @default Infinity
+     */
+    maxEntrySize?: number
+  }
+
+  export class SqliteCacheStore implements CacheStore {
+    constructor (opts?: SqliteCacheStoreOpts)
+
+    /**
+     * Closes the connection to the database
+     */
+    close (): void
+
+    get (key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream (key: CacheKey, value: CacheValue): Writable | undefined
+
+    delete (key: CacheKey): void | Promise<void>
+  }
+}

package/node_modules/undici-types/cache.d.ts

@@ -0,0 +1,36 @@
+import type { RequestInfo, Response, Request } from './fetch'
+
+export interface CacheStorage {
+  match (request: RequestInfo, options?: MultiCacheQueryOptions): Promise<Response | undefined>,
+  has (cacheName: string): Promise<boolean>,
+  open (cacheName: string): Promise<Cache>,
+  delete (cacheName: string): Promise<boolean>,
+  keys (): Promise<string[]>
+}
+
+declare const CacheStorage: {
+  prototype: CacheStorage
+  new(): CacheStorage
+}
+
+export interface Cache {
+  match (request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>,
+  matchAll (request?: RequestInfo, options?: CacheQueryOptions): Promise<readonly Response[]>,
+  add (request: RequestInfo): Promise<undefined>,
+  addAll (requests: RequestInfo[]): Promise<undefined>,
+  put (request: RequestInfo, response: Response): Promise<undefined>,
+  delete (request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>,
+  keys (request?: RequestInfo, options?: CacheQueryOptions): Promise<readonly Request[]>
+}
+
+export interface CacheQueryOptions {
+  ignoreSearch?: boolean,
+  ignoreMethod?: boolean,
+  ignoreVary?: boolean
+}
+
+export interface MultiCacheQueryOptions extends CacheQueryOptions {
+  cacheName?: string
+}
+
+export declare const caches: CacheStorage

package/node_modules/undici-types/client-stats.d.ts

@@ -0,0 +1,15 @@
+import Client from './client'
+
+export default ClientStats
+
+declare class ClientStats {
+  constructor (pool: Client)
+  /** If socket has open connection. */
+  connected: boolean
+  /** Number of open socket connections in this client that do not have an active request. */
+  pending: number
+  /** Number of currently active requests of this client. */
+  running: number
+  /** Number of active, pending, or queued requests of this client. */
+  size: number
+}