@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/debug/_internal.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @file Private internals for `debug/*` modules — the cached logger instance,
+ *   lazy `node:util` accessor, the `debugByNamespace` cache that
+ *   `namespace.getDebugJsInstance` fills, the lazy `pointingTriangle` glyph
+ *   used by every output function, and `customLog` (the `debug-js` log-writer
+ *   override). Co-located so the namespace / output / caller-info leaves don't
+ *   fragment ownership of this shared module state.
+ */
+export declare const logger: import("../logger/default").Logger;
+export declare const debugByNamespace: Map<any, any>;
+export { getNodeUtil as getUtil } from '../node/util';
+/**
+ * Custom log function for debug output.
+ *
+ * @private
+ */
+export declare function customLog(...args: unknown[]): void;
+/**
+ * Lazily resolve the "pointing triangle" glyph — `▸` on terminals with unicode
+ * support, `>` everywhere else. Initialised on first call by the output
+ * functions.
+ *
+ * @private
+ */
+export declare function getPointingTriangle(): string;

package/dist/debug/_internal.js

@@ -0,0 +1,77 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internal_exports = {};
+__export(internal_exports, {
+  customLog: () => customLog,
+  debugByNamespace: () => debugByNamespace,
+  getPointingTriangle: () => getPointingTriangle,
+  getUtil: () => import_util2.getNodeUtil,
+  logger: () => logger
+});
+module.exports = __toCommonJS(internal_exports);
+var import_is_unicode_supported = __toESM(require("../external/@socketregistry/is-unicode-supported"));
+var import_debug = __toESM(require("../external/debug"));
+var import_default = require("../logger/default");
+var import_map_set = require("../primordials/map-set");
+var import_reflect = require("../primordials/reflect");
+var import_util = require("../node/util");
+var import_util2 = require("../node/util");
+const logger = (0, import_default.getDefaultLogger)();
+const debugByNamespace = new import_map_set.MapCtor();
+let _pointingTriangle;
+// @__NO_SIDE_EFFECTS__
+function customLog(...args) {
+  const util = (0, import_util.getNodeUtil)();
+  const inspectOpts = import_debug.default.inspectOpts ? {
+    ...import_debug.default.inspectOpts,
+    showHidden: import_debug.default.inspectOpts.showHidden === null ? void 0 : import_debug.default.inspectOpts.showHidden,
+    depth: import_debug.default.inspectOpts.depth === null || typeof import_debug.default.inspectOpts.depth === "boolean" ? void 0 : import_debug.default.inspectOpts.depth
+  } : {};
+  (0, import_reflect.ReflectApply)(logger.info, logger, [
+    util.formatWithOptions(inspectOpts, ...args)
+  ]);
+}
+// @__NO_SIDE_EFFECTS__
+function getPointingTriangle() {
+  if (_pointingTriangle === void 0) {
+    const supported = (0, import_is_unicode_supported.default)();
+    _pointingTriangle = supported ? "\u25B8" : ">";
+  }
+  return _pointingTriangle;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  customLog,
+  debugByNamespace,
+  getPointingTriangle,
+  getUtil,
+  logger
+});

package/dist/debug/caller-info.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file `getCallerInfo` — extract the caller's function name from the V8 stack
+ *   trace at a given offset. Used by every output function to prefix the debug
+ *   line with the calling site. Strips V8-injected prefixes (`async`, `bound`,
+ *   `Object.`, etc.) so the printed name matches what the developer typed.
+ */
+/**
+ * Extract caller information from the stack trace.
+ *
+ * @private
+ */
+export declare function getCallerInfo(stackOffset?: number): string;

package/dist/debug/caller-info.js

@@ -0,0 +1,67 @@
+"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 caller_info_exports = {};
+__export(caller_info_exports, {
+  getCallerInfo: () => getCallerInfo
+});
+module.exports = __toCommonJS(caller_info_exports);
+var import_predicates = require("../objects/predicates");
+var import_string = require("../primordials/string");
+// @__NO_SIDE_EFFECTS__
+function getCallerInfo(stackOffset = 3) {
+  let name = "";
+  const captureStackTrace = Error.captureStackTrace;
+  if (typeof captureStackTrace === "function") {
+    const obj = {};
+    captureStackTrace(obj, getCallerInfo);
+    const stack = obj.stack;
+    if (typeof stack === "string") {
+      let lineCount = 0;
+      let lineStart = 0;
+      for (let i = 0, { length } = stack; i < length; i += 1) {
+        if (stack[i] === "\n") {
+          lineCount += 1;
+          if (lineCount < stackOffset) {
+            lineStart = i + 1;
+          } else {
+            const line = stack.slice(lineStart, i).trimStart();
+            const match = /(?<=^at\s+).*?(?=\s+\(|$)/.exec(line)?.[0];
+            if (match) {
+              name = match.replace(/^(?:async|bound|get|new|set)\s+/, "");
+              if ((0, import_string.StringPrototypeStartsWith)(name, "Object.")) {
+                const afterDot = (0, import_string.StringPrototypeSlice)(name, 7);
+                if (!(0, import_predicates.hasOwn)(Object, afterDot)) {
+                  name = afterDot;
+                }
+              }
+            }
+            break;
+          }
+        }
+      }
+    }
+  }
+  return name;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCallerInfo
+});

package/dist/debug/namespace.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @file Namespace-handling helpers — `extractOptions` normalises the
+ *   polymorphic first argument that every `*Ns` function takes,
+ *   `getDebugJsInstance` per-namespace caches the underlying `debug-js`
+ *   instance with `customLog` patched in, and `isEnabled` / `isDebug` /
+ *   `isDebugNs` are the gate predicates every output function consults before
+ *   writing.
+ */
+import type { DebugOptions, NamespacesOrOptions } from './types';
+/**
+ * Extract options from namespaces parameter.
+ *
+ * @private
+ */
+export declare function extractOptions(namespaces: NamespacesOrOptions): DebugOptions;
+/**
+ * Get or create a debug instance for a namespace.
+ *
+ * @private
+ */
+export declare function getDebugJsInstance(namespace: string): any;
+/**
+ * Check if debug mode is enabled.
+ */
+export declare function isDebug(): boolean;
+/**
+ * Check if debug mode is enabled.
+ */
+export declare function isDebugNs(namespaces: string | undefined): boolean;
+/**
+ * Check if debug is enabled for given namespaces.
+ *
+ * @private
+ */
+export declare function isEnabled(namespaces: string | undefined): boolean;

package/dist/debug/namespace.js

@@ -0,0 +1,101 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var namespace_exports = {};
+__export(namespace_exports, {
+  extractOptions: () => extractOptions,
+  getDebugJsInstance: () => getDebugJsInstance,
+  isDebug: () => isDebug,
+  isDebugNs: () => isDebugNs,
+  isEnabled: () => isEnabled
+});
+module.exports = __toCommonJS(namespace_exports);
+var import_debug = require("../env/debug");
+var import_socket = require("../env/socket");
+var import_debug2 = __toESM(require("../external/debug"));
+var import_string = require("../primordials/string");
+var import_internal = require("./_internal");
+// @__NO_SIDE_EFFECTS__
+function extractOptions(namespaces) {
+  return namespaces !== null && typeof namespaces === "object" ? { __proto__: null, ...namespaces } : { __proto__: null, namespaces };
+}
+// @__NO_SIDE_EFFECTS__
+function getDebugJsInstance(namespace) {
+  let inst = import_internal.debugByNamespace.get(namespace);
+  if (inst) {
+    return inst;
+  }
+  if (!(0, import_debug.getDebug)() && (0, import_socket.getSocketDebug)() && (namespace === "error" || namespace === "notice")) {
+    import_debug2.default.enable(namespace);
+  }
+  inst = (0, import_debug2.default)(namespace);
+  inst.log = import_internal.customLog;
+  import_internal.debugByNamespace.set(namespace, inst);
+  return inst;
+}
+// @__NO_SIDE_EFFECTS__
+function isDebug() {
+  return !!(0, import_socket.getSocketDebug)();
+}
+// @__NO_SIDE_EFFECTS__
+function isDebugNs(namespaces) {
+  return !!(0, import_socket.getSocketDebug)() && /* @__PURE__ */ isEnabled(namespaces);
+}
+// @__NO_SIDE_EFFECTS__
+function isEnabled(namespaces) {
+  if (!(0, import_socket.getSocketDebug)()) {
+    return false;
+  }
+  if (typeof namespaces !== "string" || !namespaces || namespaces === "*") {
+    return true;
+  }
+  const split = namespaces.trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+  const names = [];
+  const skips = [];
+  for (const ns of split) {
+    if ((0, import_string.StringPrototypeStartsWith)(ns, "-")) {
+      skips.push(ns.slice(1));
+    } else {
+      names.push(ns);
+    }
+  }
+  if (names.length && !names.some((ns) => (/* @__PURE__ */ getDebugJsInstance(ns)).enabled)) {
+    return false;
+  }
+  return skips.every((ns) => !(/* @__PURE__ */ getDebugJsInstance(ns)).enabled);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractOptions,
+  getDebugJsInstance,
+  isDebug,
+  isDebugNs,
+  isEnabled
+});

package/dist/{debug.d.ts → debug/output.d.ts}

@@ -1,23 +1,12 @@
 /**
- * @fileoverview Debug logging utilities with lazy loading and environment-based control.
- * Provides Socket CLI specific debug functionality and logging formatters.
+ * @file Output entrypoints — `debug` / `debugCache` / `debugDir` / `debugLog`
+ *   and their `*Ns` namespace variants, plus `debuglog` (node-util-compatible)
+ *   and `debugtime` (start/end timers). Each output function gates through
+ *   `isEnabled`, prefixes the caller name from `getCallerInfo`, pauses any
+ *   active spinner across the write, and uses the lazy `pointingTriangle` glyph
+ *   for the divider.
  */
-interface DebugOptions {
-    namespaces?: string;
-    spinner?: {
-        isSpinning: boolean;
-        stop(): void;
-        start(): void;
-    };
-    [key: string]: unknown;
-}
-type NamespacesOrOptions = string | DebugOptions;
-interface InspectOptions {
-    depth?: number | null;
-    colors?: boolean;
-    [key: string]: unknown;
-}
-export type { DebugOptions, NamespacesOrOptions, InspectOptions };
+import type { InspectOptions, NamespacesOrOptions } from './types';
 /**
  * Debug output with caller info (wrapper for debugNs with default namespace).
  */
@@ -26,21 +15,21 @@ export declare function debug(...args: unknown[]): void;
  * Cache debug function with caller info.
  *
  * @example
- * ```typescript
- * debugCache('hit', 'socket-sdk:scans:abc123')
- * debugCache('miss', 'socket-sdk:scans:xyz', { ttl: 60000 })
- * ```
+ *   ;```typescript
+ *   debugCache('hit', 'socket-sdk:scans:abc123')
+ *   debugCache('miss', 'socket-sdk:scans:xyz', { ttl: 60000 })
+ *   ```
  */
 export declare function debugCache(operation: string, key: string, meta?: unknown | undefined): void;
 /**
- * Debug output for cache operations with caller info.
- * First argument is the operation type (hit/miss/set/clear).
- * Second argument is the cache key or message.
- * Optional third argument is metadata object.
+ * Debug output for cache operations with caller info. First argument is the
+ * operation type (hit/miss/set/clear). Second argument is the cache key or
+ * message. Optional third argument is metadata object.
  */
 export declare function debugCacheNs(namespacesOrOpts: NamespacesOrOptions, operation: string, key: string, meta?: unknown | undefined): void;
 /**
- * Debug output for object inspection (wrapper for debugDirNs with default namespace).
+ * Debug output for object inspection (wrapper for debugDirNs with default
+ * namespace).
  */
 export declare function debugDir(obj: unknown, inspectOpts?: InspectOptions | undefined): void;
 /**
@@ -55,29 +44,21 @@ export declare function debugLog(...args: unknown[]): void;
  * Debug logging function with caller info.
  */
 export declare function debugLogNs(namespacesOrOpts: NamespacesOrOptions, ...args: unknown[]): void;
-/**
- * Create a Node.js util.debuglog compatible function.
- * Returns a function that conditionally writes debug messages to stderr.
- */
-export declare function debuglog(section: string): import("util").DebugLogger;
 /**
  * Debug output with caller info.
  */
 export declare function debugNs(namespacesOrOpts: NamespacesOrOptions, ...args: unknown[]): void;
 /**
- * Create timing functions for measuring code execution time.
- * Returns an object with start() and end() methods, plus a callable function.
+ * Create a Node.js util.debuglog compatible function. Returns a function that
+ * conditionally writes debug messages to stderr.
+ */
+export declare function debuglog(section: string): import("util").DebugLogger;
+/**
+ * Create timing functions for measuring code execution time. Returns an object
+ * with start() and end() methods, plus a callable function.
  */
 export declare function debugtime(label: string): {
     (): void;
     start: () => void;
     end: () => void;
 };
-/**
- * Check if debug mode is enabled.
- */
-export declare function isDebug(): boolean;
-/**
- * Check if debug mode is enabled.
- */
-export declare function isDebugNs(namespaces: string | undefined): boolean;

package/dist/debug/output.js

@@ -0,0 +1,209 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var output_exports = {};
+__export(output_exports, {
+  debug: () => debug,
+  debugCache: () => debugCache,
+  debugCacheNs: () => debugCacheNs,
+  debugDir: () => debugDir,
+  debugDirNs: () => debugDirNs,
+  debugLog: () => debugLog,
+  debugLogNs: () => debugLogNs,
+  debugNs: () => debugNs,
+  debuglog: () => debuglog,
+  debugtime: () => debugtime
+});
+module.exports = __toCommonJS(output_exports);
+var import_debug = __toESM(require("../external/debug"));
+var import_array = require("../primordials/array");
+var import_date = require("../primordials/date");
+var import_reflect = require("../primordials/reflect");
+var import_default = require("../spinner/default");
+var import_format = require("../strings/format");
+var import_internal = require("./_internal");
+var import_caller_info = require("./caller-info");
+var import_namespace = require("./namespace");
+var import_socket = require("../env/socket");
+function debug(...args) {
+  debugNs("*", ...args);
+}
+// @__NO_SIDE_EFFECTS__
+function debugCache(operation, key, meta) {
+  if (!(0, import_socket.getSocketDebug)()) {
+    return;
+  }
+  const callerName = (0, import_caller_info.getCallerInfo)(3) || "cache";
+  const pointingTriangle = (0, import_internal.getPointingTriangle)();
+  const prefix = `[CACHE] ${callerName} ${pointingTriangle} ${operation}: ${key}`;
+  const args = meta !== void 0 ? [prefix, meta] : [prefix];
+  (0, import_reflect.ReflectApply)(import_internal.logger.info, import_internal.logger, args);
+}
+function debugCacheNs(namespacesOrOpts, operation, key, meta) {
+  const options = (0, import_namespace.extractOptions)(namespacesOrOpts);
+  const { namespaces } = options;
+  if (!(0, import_namespace.isEnabled)(namespaces)) {
+    return;
+  }
+  const callerName = (0, import_caller_info.getCallerInfo)(4) || "cache";
+  const pointingTriangle = (0, import_internal.getPointingTriangle)();
+  const prefix = `[CACHE] ${callerName} ${pointingTriangle} ${operation}: ${key}`;
+  const logArgs = meta !== void 0 ? [prefix, meta] : [prefix];
+  const spinnerInstance = options.spinner || (0, import_default.getDefaultSpinner)();
+  const wasSpinning = spinnerInstance?.isSpinning;
+  spinnerInstance?.stop();
+  (0, import_reflect.ReflectApply)(import_internal.logger.info, import_internal.logger, logArgs);
+  if (wasSpinning) {
+    spinnerInstance?.start();
+  }
+}
+function debugDir(obj, inspectOpts) {
+  debugDirNs("*", obj, inspectOpts);
+}
+function debugDirNs(namespacesOrOpts, obj, inspectOpts) {
+  const options = (0, import_namespace.extractOptions)(namespacesOrOpts);
+  const { namespaces } = options;
+  if (!(0, import_namespace.isEnabled)(namespaces)) {
+    return;
+  }
+  const callerName = (0, import_caller_info.getCallerInfo)(4) || "anonymous";
+  const pointingTriangle = (0, import_internal.getPointingTriangle)();
+  let opts = inspectOpts;
+  if (opts === void 0) {
+    const debugOpts = import_debug.default.inspectOpts;
+    if (debugOpts) {
+      opts = {
+        ...debugOpts,
+        showHidden: debugOpts.showHidden === null ? void 0 : debugOpts.showHidden,
+        depth: debugOpts.depth === null || typeof debugOpts.depth === "boolean" ? void 0 : debugOpts.depth
+      };
+    }
+  }
+  const spinnerInstance = options.spinner || (0, import_default.getDefaultSpinner)();
+  const wasSpinning = spinnerInstance?.isSpinning;
+  spinnerInstance?.stop();
+  import_internal.logger.info(`[DEBUG] ${callerName} ${pointingTriangle} object inspection:`);
+  import_internal.logger.dir(obj, inspectOpts);
+  if (wasSpinning) {
+    spinnerInstance?.start();
+  }
+}
+function debugLog(...args) {
+  debugLogNs("*", ...args);
+}
+function debugLogNs(namespacesOrOpts, ...args) {
+  const options = (0, import_namespace.extractOptions)(namespacesOrOpts);
+  const { namespaces } = options;
+  if (!(0, import_namespace.isEnabled)(namespaces)) {
+    return;
+  }
+  const callerName = (0, import_caller_info.getCallerInfo)(4) || "anonymous";
+  const pointingTriangle = (0, import_internal.getPointingTriangle)();
+  const text = (0, import_array.ArrayPrototypeAt)(args, 0);
+  const logArgs = typeof text === "string" ? [
+    (0, import_format.applyLinePrefix)(`${callerName} ${pointingTriangle} ${text}`, {
+      prefix: "[DEBUG] "
+    }),
+    ...(0, import_array.ArrayPrototypeSlice)(args, 1)
+  ] : [`[DEBUG] ${callerName} ${pointingTriangle}`, ...args];
+  const spinnerInstance = options.spinner || (0, import_default.getDefaultSpinner)();
+  const wasSpinning = spinnerInstance?.isSpinning;
+  spinnerInstance?.stop();
+  (0, import_reflect.ReflectApply)(import_internal.logger.info, import_internal.logger, logArgs);
+  if (wasSpinning) {
+    spinnerInstance?.start();
+  }
+}
+function debugNs(namespacesOrOpts, ...args) {
+  const options = (0, import_namespace.extractOptions)(namespacesOrOpts);
+  const { namespaces } = options;
+  if (!(0, import_namespace.isEnabled)(namespaces)) {
+    return;
+  }
+  const name = (0, import_caller_info.getCallerInfo)(4) || "anonymous";
+  const pointingTriangle = (0, import_internal.getPointingTriangle)();
+  const text = (0, import_array.ArrayPrototypeAt)(args, 0);
+  const logArgs = typeof text === "string" ? [
+    (0, import_format.applyLinePrefix)(`${name} ${pointingTriangle} ${text}`, {
+      prefix: "[DEBUG] "
+    }),
+    ...(0, import_array.ArrayPrototypeSlice)(args, 1)
+  ] : args;
+  const spinnerInstance = options.spinner || (0, import_default.getDefaultSpinner)();
+  const wasSpinning = spinnerInstance?.isSpinning;
+  spinnerInstance?.stop();
+  (0, import_reflect.ReflectApply)(import_internal.logger.info, import_internal.logger, logArgs);
+  if (wasSpinning) {
+    spinnerInstance?.start();
+  }
+}
+// @__NO_SIDE_EFFECTS__
+function debuglog(section) {
+  const util = (0, import_internal.getUtil)();
+  return util.debuglog(section);
+}
+// @__NO_SIDE_EFFECTS__
+function debugtime(label) {
+  const util = (0, import_internal.getUtil)();
+  let startTime;
+  const impl = () => {
+    if (startTime === void 0) {
+      startTime = (0, import_date.DateNow)();
+    } else {
+      const duration = (0, import_date.DateNow)() - startTime;
+      util.debuglog("time")(`${label}: ${duration}ms`);
+      startTime = void 0;
+    }
+  };
+  impl.start = () => {
+    startTime = (0, import_date.DateNow)();
+  };
+  impl.end = () => {
+    if (startTime !== void 0) {
+      const duration = (0, import_date.DateNow)() - startTime;
+      util.debuglog("time")(`${label}: ${duration}ms`);
+      startTime = void 0;
+    }
+  };
+  return impl;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debug,
+  debugCache,
+  debugCacheNs,
+  debugDir,
+  debugDirNs,
+  debugLog,
+  debugLogNs,
+  debugNs,
+  debuglog,
+  debugtime
+});

package/dist/debug/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @file Public type surface for `debug/*` modules — the options bag accepted by
+ *   every `debug*Ns` entrypoint and the `InspectOptions` mirror of
+ *   `node:util`'s shape (the public subset we accept; not the full thing). Pure
+ *   types, no runtime side effects.
+ */
+export interface DebugOptions {
+    namespaces?: string;
+    spinner?: {
+        isSpinning: boolean;
+        stop(): void;
+        start(): void;
+    };
+    [key: string]: unknown;
+}
+export type NamespacesOrOptions = string | DebugOptions;
+export interface InspectOptions {
+    depth?: number | null;
+    colors?: boolean;
+    [key: string]: unknown;
+}

package/dist/debug/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/dlx/_internal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file Shared internals for the `dlx/*` module — the bounded LRU cache used by
+ *   `resolveBinaryPath` on Windows. Webpack-safe lazy `node:fs` / `node:path` /
+ *   `node:crypto` loaders live in the canonical
+ *   `@socketsecurity/lib/node/{fs,path,crypto}` helpers — import `getNodeFs` /
+ *   `getNodePath` / `getNodeCrypto` directly from there.
+ */
+export declare const BINARY_PATH_CACHE_MAX_SIZE = 200;
+export declare const binaryPathCache: Map<string, string>;
+export declare function binaryPathCacheSet(key: string, value: string): void;