@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/memo/decorator.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @file `Memoize` — class-method decorator that wraps the decorated method via
+ *   `memoize`. Preserves `this`-context by installing the wrapper on the
+ *   property descriptor. Defaults the cache `name` option to the property key
+ *   for nicer debug output.
+ */
+import type { MemoizeOptions } from './types';
+/**
+ * Create a memoized version of a method. Preserves 'this' context for class
+ * methods.
+ *
+ * @example
+ *   import { Memoize } from '@socketsecurity/lib/memo/decorator'
+ *
+ *   class Calculator {
+ *     @Memoize()
+ *     fibonacci(n: number): number {
+ *       if (n <= 1) return n
+ *       return this.fibonacci(n - 1) + this.fibonacci(n - 2)
+ *     }
+ *   }
+ *
+ * @param target - Object containing the method.
+ * @param propertyKey - Method name.
+ * @param descriptor - Property descriptor.
+ *
+ * @returns Modified descriptor with memoized method
+ */
+export declare function Memoize(options?: MemoizeOptions<unknown[]>): (_target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/memo/decorator.js

@@ -0,0 +1,40 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var decorator_exports = {};
+__export(decorator_exports, {
+  Memoize: () => Memoize
+});
+module.exports = __toCommonJS(decorator_exports);
+var import_memoize = require("./memoize");
+function Memoize(options = {}) {
+  return (_target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    descriptor.value = (0, import_memoize.memoize)(originalMethod, {
+      ...options,
+      name: options.name || propertyKey
+    });
+    return descriptor;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Memoize
+});

package/dist/memo/memoize.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @file `memoize` — synchronous function memoizer with LRU eviction (Map
+ *   insertion-order based), optional TTL, and optional custom key generator.
+ *   Each instance registers itself with the shared `cacheRegistry` so
+ *   `clearAllMemoizationCaches` can sweep it.
+ */
+import type { MemoizeOptions } from './types';
+/**
+ * Memoize a function with configurable caching behavior. Caches function
+ * results to avoid repeated computation.
+ *
+ * @example
+ *   import { memoize } from '@socketsecurity/lib/memo/memoize'
+ *
+ *   const expensiveOperation = memoize(
+ *     (n: number) => {
+ *       // Heavy computation
+ *       return Array(n)
+ *         .fill(0)
+ *         .reduce((a, _, i) => a + i, 0)
+ *     },
+ *     { maxSize: 100, ttl: 60000, name: 'sum' },
+ *   )
+ *
+ *   expensiveOperation(1000) // Computed
+ *   expensiveOperation(1000) // Cached
+ *
+ * @param fn - Function to memoize.
+ * @param options - Memoization options.
+ *
+ * @returns Memoized version of the function
+ */
+export declare function memoize<Args extends unknown[], Result>(fn: (...args: Args) => Result, options?: MemoizeOptions<Args>): (...args: Args) => Result;

package/dist/memo/memoize.js

@@ -0,0 +1,91 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var memoize_exports = {};
+__export(memoize_exports, {
+  memoize: () => memoize
+});
+module.exports = __toCommonJS(memoize_exports);
+var import_output = require("../debug/output");
+var import_date = require("../primordials/date");
+var import_error = require("../primordials/error");
+var import_map_set = require("../primordials/map-set");
+var import_internal = require("./_internal");
+function memoize(fn, options = {}) {
+  const {
+    keyGen = (...args) => (0, import_internal.defaultKeyGen)(args),
+    maxSize = Number.POSITIVE_INFINITY,
+    name = fn.name || "anonymous",
+    ttl = Number.POSITIVE_INFINITY
+  } = options;
+  if (ttl < 0) {
+    throw new import_error.TypeErrorCtor("TTL must be non-negative");
+  }
+  const cache = new import_map_set.MapCtor();
+  import_internal.cacheRegistry.push(() => {
+    cache.clear();
+  });
+  function evictLRU() {
+    if (cache.size >= maxSize) {
+      const oldest = cache.keys().next().value;
+      if (oldest !== void 0) {
+        cache.delete(oldest);
+        (0, import_output.debugLog)(`[memoize:${name}] clear`, {
+          key: oldest,
+          reason: "LRU"
+        });
+      }
+    }
+  }
+  function isExpired(entry) {
+    if (ttl === Number.POSITIVE_INFINITY) {
+      return false;
+    }
+    return (0, import_date.DateNow)() - entry.timestamp > ttl;
+  }
+  return function memoized(...args) {
+    const key = keyGen(...args);
+    const cached = cache.get(key);
+    if (cached) {
+      if (!isExpired(cached)) {
+        cached.hits++;
+        cache.delete(key);
+        cache.set(key, cached);
+        (0, import_output.debugLog)(`[memoize:${name}] hit`, { key, hits: cached.hits });
+        return cached.value;
+      }
+      cache.delete(key);
+    }
+    (0, import_output.debugLog)(`[memoize:${name}] miss`, { key });
+    const value = fn(...args);
+    evictLRU();
+    cache.set(key, {
+      value,
+      timestamp: Date.now(),
+      hits: 0
+    });
+    (0, import_output.debugLog)(`[memoize:${name}] set`, { key, cacheSize: cache.size });
+    return value;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  memoize
+});

package/dist/memo/once.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @file `once` — zero-argument memoizer. Caches a single result forever and
+ *   emits `set` / `hit` debug events. Distinct from `memoize` because it skips
+ *   the key-gen / TTL / LRU machinery that the general-purpose memoizer needs.
+ */
+/**
+ * Simple once() for zero-argument initialization functions. Caches a single
+ * result forever and emits debug-log events on hit/miss.
+ *
+ * @example
+ *   import { once } from '@socketsecurity/lib/memo/once'
+ *
+ *   const initialize = once(() => {
+ *     console.log('Initializing…')
+ *     return loadConfig()
+ *   })
+ *
+ *   initialize() // Logs "Initializing…" and returns config
+ *   initialize() // Returns cached config (no log)
+ *
+ * @param fn - Zero-argument function to run once.
+ *
+ * @returns Memoized version that only executes once
+ */
+export declare function once<Result>(fn: () => Result): () => Result;

package/dist/memo/once.js

@@ -0,0 +1,44 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var once_exports = {};
+__export(once_exports, {
+  once: () => once
+});
+module.exports = __toCommonJS(once_exports);
+var import_output = require("../debug/output");
+function once(fn) {
+  let called = false;
+  let result;
+  return function memoized() {
+    if (!called) {
+      result = fn();
+      called = true;
+      (0, import_output.debugLog)(`[once:${fn.name}] set`);
+    } else {
+      (0, import_output.debugLog)(`[once:${fn.name}] hit`);
+    }
+    return result;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  once
+});

package/dist/memo/types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @file Public type surface for `memo/*` modules — `MemoizeOptions` is the
+ *   user-facing options bag accepted by every memoize entrypoint,
+ *   `CacheEntry<T>` is the internal row stored in each per-function cache. Pure
+ *   types, no runtime side effects.
+ */
+/**
+ * Options for memoization behavior.
+ */
+export type MemoizeOptions<Args extends unknown[]> = {
+    /**
+     * Custom cache key generator (defaults to JSON.stringify)
+     */
+    keyGen?: (...args: Args) => string;
+    /**
+     * Maximum cache size (LRU eviction when exceeded)
+     */
+    maxSize?: number;
+    /**
+     * TTL in milliseconds (cache entries expire after this time)
+     */
+    ttl?: number;
+    /**
+     * Cache name for debugging.
+     */
+    name?: string;
+    /**
+     * Weak cache for object keys (enables GC)
+     */
+    weak?: boolean;
+    /**
+     * Custom equality check for cache hits.
+     */
+    equals?: (a: Args, b: Args) => boolean;
+};
+/**
+ * Cache entry with metadata.
+ */
+export type CacheEntry<T> = {
+    value: T;
+    timestamp: number;
+    hits: number;
+};

package/dist/memo/types.js

@@ -0,0 +1,18 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/memo/weak.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @file `memoizeWeak` — memoizer keyed by an object reference via `WeakMap`.
+ *   Cache entries are eligible for GC as soon as the keying object becomes
+ *   unreachable, so there's no need for explicit eviction. First (and only)
+ *   argument must be an object.
+ */
+/**
+ * Memoize with WeakMap for object keys. Allows garbage collection when objects
+ * are no longer referenced. Only works when first argument is an object.
+ *
+ * @example
+ *   import { memoizeWeak } from '@socketsecurity/lib/memo/weak'
+ *
+ *   const processConfig = memoizeWeak((config: Config) => {
+ *     return expensiveTransform(config)
+ *   })
+ *
+ *   processConfig(config1) // Computed
+ *   processConfig(config1) // Cached
+ *   // When config1 is no longer referenced, cache entry is GC'd
+ *
+ * @param fn - Function to memoize.
+ *
+ * @returns Memoized version using WeakMap
+ */
+export declare function memoizeWeak<K extends object, Result>(fn: (key: K) => Result): (key: K) => Result;

package/dist/memo/weak.js

@@ -0,0 +1,44 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var weak_exports = {};
+__export(weak_exports, {
+  memoizeWeak: () => memoizeWeak
+});
+module.exports = __toCommonJS(weak_exports);
+var import_output = require("../debug/output");
+var import_map_set = require("../primordials/map-set");
+function memoizeWeak(fn) {
+  const cache = new import_map_set.WeakMapCtor();
+  return function memoized(key) {
+    if (cache.has(key)) {
+      (0, import_output.debugLog)(`[memoizeWeak:${fn.name}] hit`);
+      return cache.get(key);
+    }
+    (0, import_output.debugLog)(`[memoizeWeak:${fn.name}] miss`);
+    const result = fn(key);
+    cache.set(key, result);
+    return result;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  memoizeWeak
+});

package/dist/node/async-hooks.d.ts

@@ -1,6 +1,6 @@
 /**
- * @fileoverview Lazy-loader for `node:async_hooks`. See `node/fs.ts`
- * for the design rationale shared across all `node/*.ts` lazy-loaders.
+ * @file Lazy-loader for `node:async_hooks`. See `node/fs.ts` for the design
+ *   rationale shared across all `node/*.ts` lazy-loaders.
  */
 import type * as NodeAsyncHooks from 'node:async_hooks';
 export declare function getNodeAsyncHooks(): typeof NodeAsyncHooks;

package/dist/node/child-process.d.ts

@@ -1,11 +1,9 @@
 /**
- * @fileoverview Lazy-loader for `node:child_process`. See `node/fs.ts`
- * for the design rationale shared across all `node/*.ts` lazy-loaders.
- *
- * Filename uses `child-process` (kebab-case) to match the rest of
- * socket-lib's filename convention. The exported getter name is
- * `getNodeChildProcess` (camelCase, prefixed with `Node` to match
- * every other `node/*` lazy-loader).
+ * @file Lazy-loader for `node:child_process`. See `node/fs.ts` for the design
+ *   rationale shared across all `node/*.ts` lazy-loaders. Filename uses
+ *   `child-process` (kebab-case) to match the rest of socket-lib's filename
+ *   convention. The exported getter name is `getNodeChildProcess` (camelCase,
+ *   prefixed with `Node` to match every other `node/*` lazy-loader).
  */
 import type * as NodeChildProcess from 'node:child_process';
 export declare function getNodeChildProcess(): typeof NodeChildProcess;

package/dist/node/crypto.d.ts

@@ -1,6 +1,6 @@
 /**
- * @fileoverview Lazy-loader for `node:crypto`. See `node/fs.ts` for
- * the design rationale shared across all `node/*.ts` lazy-loaders.
+ * @file Lazy-loader for `node:crypto`. See `node/fs.ts` for the design
+ *   rationale shared across all `node/*.ts` lazy-loaders.
  */
 import type * as NodeCrypto from 'node:crypto';
 export declare function getNodeCrypto(): typeof NodeCrypto;

package/dist/node/events.d.ts

@@ -1,6 +1,6 @@
 /**
- * @fileoverview Lazy-loader for `node:events`. See `node/fs.ts` for
- * the design rationale shared across all `node/*.ts` lazy-loaders.
+ * @file Lazy-loader for `node:events`. See `node/fs.ts` for the design
+ *   rationale shared across all `node/*.ts` lazy-loaders.
  */
 import type * as NodeEvents from 'node:events';
 export declare function getNodeEvents(): typeof NodeEvents;

package/dist/node/fs-promises.d.ts

@@ -1,6 +1,6 @@
 /**
- * @fileoverview Lazy-loader for `node:fs/promises`. See `node/fs.ts`
- * for the design rationale shared across all `node/*.ts` lazy-loaders.
+ * @file Lazy-loader for `node:fs/promises`. See `node/fs.ts` for the design
+ *   rationale shared across all `node/*.ts` lazy-loaders.
  */
 import type * as NodeFsPromises from 'node:fs/promises';
 export declare function getNodeFsPromises(): typeof NodeFsPromises;

package/dist/node/fs.d.ts

@@ -1,14 +1,10 @@
 /**
- * @fileoverview Lazy-loader for `node:fs`.
- *
- * Bundlers (Webpack/Rollup/esbuild) targeting browsers can't statically
- * resolve `require('node:fs')` — but they CAN drop the call entirely
- * if it's wrapped in a `/*@__NO_SIDE_EFFECTS__*\/`-marked function and
- * never called. So we always go through `getFs()` instead of importing
- * top-level.
- *
- * Cache slot is module-local: first call resolves the require, every
- * subsequent call returns the cached reference.
+ * @file Lazy-loader for `node:fs`. Bundlers (Webpack/Rollup/esbuild) targeting
+ *   browsers can't statically resolve `require('node:fs')` — but they CAN drop
+ *   the call entirely if it's wrapped in a `/*@__NO_SIDE_EFFECTS__*\/`-marked
+ *   function and never called. So we always go through `getFs()` instead of
+ *   importing top-level. Cache slot is module-local: first call resolves the
+ *   require, every subsequent call returns the cached reference.
  */
 import type * as NodeFs from 'node:fs';
 export declare function getNodeFs(): typeof NodeFs;

package/dist/node/http.d.ts

@@ -1,6 +1,6 @@
 /**
- * @fileoverview Lazy-loader for `node:http`. See `node/fs.ts` for
- * the design rationale shared across all `node/*.ts` lazy-loaders.
+ * @file Lazy-loader for `node:http`. See `node/fs.ts` for the design rationale
+ *   shared across all `node/*.ts` lazy-loaders.
  */
 import type * as NodeHttp from 'node:http';
 export declare function getNodeHttp(): typeof NodeHttp;

package/dist/node/https.d.ts

@@ -1,6 +1,6 @@
 /**
- * @fileoverview Lazy-loader for `node:https`. See `node/fs.ts` for
- * the design rationale shared across all `node/*.ts` lazy-loaders.
+ * @file Lazy-loader for `node:https`. See `node/fs.ts` for the design rationale
+ *   shared across all `node/*.ts` lazy-loaders.
  */
 import type * as NodeHttps from 'node:https';
 export declare function getNodeHttps(): typeof NodeHttps;

package/dist/node/module.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file Lazy-loader for `node:module`. See `node/fs.ts` for the design
+ *   rationale shared across all `node/*.ts` lazy-loaders.
+ */
+import type * as NodeModule from 'node:module';
+export declare function getNodeModule(): typeof NodeModule;
+export declare function isNodeBuiltin(name: string): boolean;

package/dist/node/module.js

@@ -0,0 +1,41 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var module_exports = {};
+__export(module_exports, {
+  getNodeModule: () => getNodeModule,
+  isNodeBuiltin: () => isNodeBuiltin
+});
+module.exports = __toCommonJS(module_exports);
+let _module;
+// @__NO_SIDE_EFFECTS__
+function getNodeModule() {
+  return _module ??= require("node:module");
+}
+let _isBuiltin;
+// @__NO_SIDE_EFFECTS__
+function isNodeBuiltin(name) {
+  return (_isBuiltin ??= (/* @__PURE__ */ getNodeModule()).isBuiltin)(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNodeModule,
+  isNodeBuiltin
+});

package/dist/node/os.d.ts

@@ -1,6 +1,6 @@
 /**
- * @fileoverview Lazy-loader for `node:os`. See `node/fs.ts` for
- * the design rationale shared across all `node/*.ts` lazy-loaders.
+ * @file Lazy-loader for `node:os`. See `node/fs.ts` for the design rationale
+ *   shared across all `node/*.ts` lazy-loaders.
  */
 import type * as NodeOs from 'node:os';
 export declare function getNodeOs(): typeof NodeOs;

package/dist/node/path.d.ts

@@ -1,6 +1,6 @@
 /**
- * @fileoverview Lazy-loader for `node:path`. See `node/fs.ts` for the
- * design rationale shared across all `node/*.ts` lazy-loaders.
+ * @file Lazy-loader for `node:path`. See `node/fs.ts` for the design rationale
+ *   shared across all `node/*.ts` lazy-loaders.
  */
 import type * as NodePath from 'node:path';
 export declare function getNodePath(): typeof NodePath;

package/dist/node/timers-promises.d.ts

@@ -1,6 +1,6 @@
 /**
- * @fileoverview Lazy-loader for `node:timers/promises`. See `node/fs.ts`
- * for the design rationale shared across all `node/*.ts` lazy-loaders.
+ * @file Lazy-loader for `node:timers/promises`. See `node/fs.ts` for the design
+ *   rationale shared across all `node/*.ts` lazy-loaders.
  */
 import type * as NodeTimersPromises from 'node:timers/promises';
 export declare function getNodeTimersPromises(): typeof NodeTimersPromises;

package/dist/node/url.d.ts

@@ -1,6 +1,6 @@
 /**
- * @fileoverview Lazy-loader for `node:url`. See `node/fs.ts` for
- * the design rationale shared across all `node/*.ts` lazy-loaders.
+ * @file Lazy-loader for `node:url`. See `node/fs.ts` for the design rationale
+ *   shared across all `node/*.ts` lazy-loaders.
  */
 import type * as NodeUrl from 'node:url';
 export declare function getNodeUrl(): typeof NodeUrl;

package/dist/node/util.d.ts

@@ -1,6 +1,6 @@
 /**
- * @fileoverview Lazy-loader for `node:util`. See `node/fs.ts` for
- * the design rationale shared across all `node/*.ts` lazy-loaders.
+ * @file Lazy-loader for `node:util`. See `node/fs.ts` for the design rationale
+ *   shared across all `node/*.ts` lazy-loaders.
  */
 import type * as NodeUtil from 'node:util';
 export declare function getNodeUtil(): typeof NodeUtil;