@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/errors/message.js

@@ -1,49 +1,43 @@
 "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 message_exports = {};
-__export(message_exports, {
-  UNKNOWN_ERROR: () => import_sentinels.UNKNOWN_ERROR,
-  errorMessage: () => errorMessage,
-  messageWithCauses: () => import_pony_cause.messageWithCauses
-});
-module.exports = __toCommonJS(message_exports);
-var import_sentinels = require("../constants/sentinels");
-var import_pony_cause = require("../external/pony-cause");
-var import_predicates = require("./predicates");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants_sentinels = require('../constants/sentinels.js');
+const require_errors_predicates = require('./predicates.js');
+let src_external_pony_cause = require("../external/pony-cause");
+
+//#region src/errors/message.ts
+/**
+* @file Human-readable error-message extractor. `errorMessage` walks the
+*   `cause` chain via pony-cause's `messageWithCauses` for Errors and falls
+*   back to the shared `UNKNOWN_ERROR` sentinel for everything else.
+*   `messageWithCauses` and `UNKNOWN_ERROR` are re-exported for callers that
+*   need them directly.
+*/
+/**
+* Extract a human-readable message from any caught value.
+*
+* Walks the `cause` chain for Errors (via {@link messageWithCauses}); coerces
+* primitives and objects to string; returns {@link UNKNOWN_ERROR} for `null`,
+* `undefined`, empty strings, `[object Object]`, or Errors with no message.
+*
+* @example
+*   try {
+*     await readConfig(path)
+*   } catch (e) {
+*     throw new ErrorCtor(`Failed to read ${path}: ${errorMessage(e)}`, {
+*       cause: e,
+*     })
+*   }
+*/
 function errorMessage(value) {
-  if ((0, import_predicates.isError)(value)) {
-    return (0, import_pony_cause.messageWithCauses)(value) || import_sentinels.UNKNOWN_ERROR;
-  }
-  if (value === null || value === void 0) {
-    return import_sentinels.UNKNOWN_ERROR;
-  }
-  const s = String(value);
-  if (s === "" || s === "[object Object]") {
-    return import_sentinels.UNKNOWN_ERROR;
-  }
-  return s;
+	if (require_errors_predicates.isError(value)) return (0, src_external_pony_cause.messageWithCauses)(value) || "Unknown error";
+	if (value === null || value === void 0) return require_constants_sentinels.UNKNOWN_ERROR;
+	const s = String(value);
+	if (s === "" || s === "[object Object]") return require_constants_sentinels.UNKNOWN_ERROR;
+	return s;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  UNKNOWN_ERROR,
-  errorMessage,
-  messageWithCauses
-});
+
+//#endregion
+exports.UNKNOWN_ERROR = require_constants_sentinels.UNKNOWN_ERROR;
+exports.errorMessage = errorMessage;
+exports.messageWithCauses = src_external_pony_cause.messageWithCauses;

package/dist/errors/predicates.js

@@ -1,56 +1,68 @@
 "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 predicates_exports = {};
-__export(predicates_exports, {
-  isErrnoException: () => isErrnoException,
-  isError: () => isError,
-  isErrorBuiltin: () => isErrorBuiltin,
-  isErrorShim: () => isErrorShim
-});
-module.exports = __toCommonJS(predicates_exports);
-var import_object = require("../primordials/object");
-var import_string = require("../primordials/string");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_string = require('../primordials/string.js');
+const require_primordials_object = require('../primordials/object.js');
+
+//#region src/errors/predicates.ts
+/**
+* @file Error type-guard predicates — `isError` (with the `isErrorBuiltin` /
+*   `isErrorShim` building blocks) and the libuv errno-code narrower
+*   `isErrnoException`. Both are cross-realm-safe (they use `[[ErrorData]]`
+*   slot semantics rather than `instanceof Error`).
+*/
+/**
+* Reference to the native ES2025 `Error.isError` when the running engine ships
+* it, otherwise `undefined`. Exposed separately so tests and callers can detect
+* the fast-path without re-probing.
+*/
 const isErrorBuiltin = Error.isError;
+/**
+* Narrow a caught value to a Node.js `ErrnoException` — an Error with a `.code`
+* string set by libuv/syscall failures (e.g. `'ENOENT'`, `'EACCES'`, `'EBUSY'`,
+* `'EPERM'`). Cross-realm safe (builds on {@link isError}), and checks that
+* `code` is a string so a merely branded Error without a real errno code
+* returns `false`.
+*
+* @example
+*   try {
+*     await fsPromises.readFile(path)
+*   } catch (e) {
+*     if (isErrnoException(e) && e.code === 'ENOENT') {
+*       // … retry, or return default …
+*     } else {
+*       throw e
+*     }
+*   }
+*/
 function isErrnoException(value) {
-  if (!isError(value)) {
-    return false;
-  }
-  const code = value.code;
-  if (typeof code !== "string" || code.length === 0) {
-    return false;
-  }
-  const first = (0, import_string.StringPrototypeCharCodeAt)(code, 0);
-  return first >= 65 && first <= 90;
+	if (!isError(value)) return false;
+	const code = value.code;
+	if (typeof code !== "string" || code.length === 0) return false;
+	const first = require_primordials_string.StringPrototypeCharCodeAt(code, 0);
+	return first >= 65 && first <= 90;
 }
+/**
+* `Error.isError` fallback shim — the in-language approximation used when the
+* native ES2025 method isn't available.
+*
+* Exported separately so test suites on engines that ship the native method can
+* still exercise the shim branch directly. Consumers should prefer
+* {@link isError}, which picks the native method when present.
+*/
 function isErrorShim(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  return (0, import_object.ObjectPrototypeToString)(value) === "[object Error]";
+	if (value === null || typeof value !== "object") return false;
+	return require_primordials_object.ObjectPrototypeToString(value) === "[object Error]";
 }
+/**
+* Prefer the native ES2025 `Error.isError` when available (exact
+* `[[ErrorData]]` slot check, cross-realm-safe); fall back to
+* {@link isErrorShim} otherwise.
+*/
 const isError = isErrorBuiltin ?? isErrorShim;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  isErrnoException,
-  isError,
-  isErrorBuiltin,
-  isErrorShim
-});
+
+//#endregion
+exports.isErrnoException = isErrnoException;
+exports.isError = isError;
+exports.isErrorBuiltin = isErrorBuiltin;
+exports.isErrorShim = isErrorShim;

package/dist/errors/stack.js

@@ -1,39 +1,27 @@
 "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 stack_exports = {};
-__export(stack_exports, {
-  errorStack: () => errorStack,
-  stackWithCauses: () => import_pony_cause.stackWithCauses
-});
-module.exports = __toCommonJS(stack_exports);
-var import_pony_cause = require("../external/pony-cause");
-var import_predicates = require("./predicates");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_errors_predicates = require('./predicates.js');
+let src_external_pony_cause = require("../external/pony-cause");
+
+//#region src/errors/stack.ts
+/**
+* @file Stack-trace extractor with cause-chain support. `errorStack` returns
+*   the cause-aware stack via pony-cause's `stackWithCauses` for Errors, and
+*   `undefined` for non-Error values so callers can log conditionally.
+*   `stackWithCauses` is re-exported for direct use.
+*/
+/**
+* Extract a stack trace (with causes) from any caught value.
+*
+* Returns the cause-aware stack via {@link stackWithCauses} for Errors; returns
+* `undefined` for non-Error values, so callers can `logger.error(msg, { stack:
+* errorStack(e) })` safely.
+*/
 function errorStack(value) {
-  if ((0, import_predicates.isError)(value)) {
-    return (0, import_pony_cause.stackWithCauses)(value);
-  }
-  return void 0;
+	if (require_errors_predicates.isError(value)) return (0, src_external_pony_cause.stackWithCauses)(value);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  errorStack,
-  stackWithCauses
-});
+
+//#endregion
+exports.errorStack = errorStack;
+exports.stackWithCauses = src_external_pony_cause.stackWithCauses;

package/dist/events/exit/_internal.js

@@ -1,39 +1,8 @@
 "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 internal_exports = {};
-__export(internal_exports, {
-  WIN32: () => WIN32,
-  emit: () => emit,
-  getEmitter: () => getEmitter,
-  getEvents: () => getEvents,
-  getSignals: () => getSignals,
-  globalProcess: () => globalProcess,
-  isLoaded: () => isLoaded,
-  originalProcessEmit: () => originalProcessEmit,
-  originalProcessReallyExit: () => originalProcessReallyExit,
-  platform: () => platform,
-  setLoaded: () => setLoaded,
-  setSignals: () => setSignals
-});
-module.exports = __toCommonJS(internal_exports);
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/events/exit/_internal.ts
 const globalProcess = globalThis.process;
 const originalProcessEmit = globalProcess?.emit;
 const platform = globalProcess?.platform ?? "";
@@ -43,85 +12,99 @@ let _events;
 let _emitter;
 let _loaded = false;
 let _signals;
-// @__NO_SIDE_EFFECTS__
+/* c8 ignore start - Only called from signal-listener body and
+processEmit/processReallyExit interceptors, all of which are
+c8-ignored. Cannot be reached from the test runner. */
+/* @__NO_SIDE_EFFECTS__ */
 function emit(event, code, signal) {
-  const emitter = /* @__PURE__ */ getEmitter();
-  if (emitter.emitted?.[event]) {
-    return;
-  }
-  if (emitter.emitted) {
-    emitter.emitted[event] = true;
-  }
-  emitter.emit(event, code, signal);
+	const emitter = /* @__PURE__ */ getEmitter();
+	if (emitter.emitted?.[event]) return;
+	if (emitter.emitted) emitter.emitted[event] = true;
+	emitter.emit(event, code, signal);
 }
-// @__NO_SIDE_EFFECTS__
+/* c8 ignore stop */
+/* @__NO_SIDE_EFFECTS__ */
 function getEmitter() {
-  if (_emitter === void 0) {
-    if (globalProcess?.__signal_exit_emitter__) {
-      _emitter = globalProcess.__signal_exit_emitter__;
-    } else if (globalProcess) {
-      const EventEmitter = (/* @__PURE__ */ getEvents()).EventEmitter;
-      _emitter = globalProcess.__signal_exit_emitter__ = new EventEmitter();
-      _emitter.count = 0;
-      _emitter.emitted = { __proto__: null };
-    }
-    if (_emitter && !_emitter.infinite) {
-      _emitter.setMaxListeners(Number.POSITIVE_INFINITY);
-      _emitter.infinite = true;
-    }
-  }
-  return _emitter;
+	/* c8 ignore start */
+	if (_emitter === void 0) {
+		if (globalProcess?.__signal_exit_emitter__) _emitter = globalProcess.__signal_exit_emitter__;
+		else if (globalProcess) {
+			const EventEmitter = (/* @__PURE__ */ getEvents()).EventEmitter;
+			_emitter = globalProcess.__signal_exit_emitter__ = new EventEmitter();
+			_emitter.count = 0;
+			_emitter.emitted = { __proto__: null };
+		}
+		if (_emitter && !_emitter.infinite) {
+			_emitter.setMaxListeners(Number.POSITIVE_INFINITY);
+			_emitter.infinite = true;
+		}
+	}
+	/* c8 ignore stop */
+	return _emitter;
 }
-// @__NO_SIDE_EFFECTS__
+/* @__NO_SIDE_EFFECTS__ */
 function getEvents() {
-  if (_events === void 0) {
-    _events = require("node:events");
-  }
-  return _events;
+	/* c8 ignore start */
+	if (_events === void 0) _events = /* @__PURE__ */ require("node:events");
+	/* c8 ignore stop */
+	return _events;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Get the cached signal list. Triggers lazy init on first call; after `load()`
+* runs it returns the filtered subset of successfully registered signals
+* instead of the full default list.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function getSignals() {
-  if (_signals === void 0) {
-    _signals = ["SIGABRT", "SIGALRM", "SIGHUP", "SIGINT", "SIGTERM"];
-    if (!WIN32) {
-      _signals.push(
-        "SIGVTALRM",
-        "SIGXCPU",
-        "SIGXFSZ",
-        "SIGUSR2",
-        "SIGTRAP",
-        "SIGSYS",
-        "SIGQUIT",
-        "SIGIOT"
-      );
-    }
-    if (platform === "linux") {
-      _signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
-    }
-  }
-  return _signals;
+	if (_signals === void 0) {
+		_signals = [
+			"SIGABRT",
+			"SIGALRM",
+			"SIGHUP",
+			"SIGINT",
+			"SIGTERM"
+		];
+		/* c8 ignore start */
+		if (!WIN32) _signals.push("SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+		if (platform === "linux") _signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
+	}
+	return _signals;
 }
+/**
+* Read the loaded flag from a sibling leaf (lifecycle / on-exit).
+*
+* @private
+*/
 function isLoaded() {
-  return _loaded;
+	return _loaded;
 }
+/**
+* Set the `loaded` flag from a sibling leaf (load / unload).
+*
+* @private
+*/
 function setLoaded(value) {
-  _loaded = value;
+	_loaded = value;
 }
+/**
+* Replace the cached signal list (used by `load()`'s filter step).
+*
+* @private
+*/
 function setSignals(value) {
-  _signals = value;
+	_signals = value;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WIN32,
-  emit,
-  getEmitter,
-  getEvents,
-  getSignals,
-  globalProcess,
-  isLoaded,
-  originalProcessEmit,
-  originalProcessReallyExit,
-  platform,
-  setLoaded,
-  setSignals
-});
+
+//#endregion
+exports.WIN32 = WIN32;
+exports.emit = emit;
+exports.getEmitter = getEmitter;
+exports.getEvents = getEvents;
+exports.getSignals = getSignals;
+exports.globalProcess = globalProcess;
+exports.isLoaded = isLoaded;
+exports.originalProcessEmit = originalProcessEmit;
+exports.originalProcessReallyExit = originalProcessReallyExit;
+exports.platform = platform;
+exports.setLoaded = setLoaded;
+exports.setSignals = setSignals;

package/dist/events/exit/handler.js

@@ -1,58 +1,51 @@
 "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 handler_exports = {};
-__export(handler_exports, {
-  onExit: () => onExit
-});
-module.exports = __toCommonJS(handler_exports);
-var import_error = require("../../primordials/error");
-var import_internal = require("./_internal");
-var import_lifecycle = require("./lifecycle");
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_error = require('../../primordials/error.js');
+const require_events_exit__internal = require('./_internal.js');
+const require_events_exit_lifecycle = require('./lifecycle.js');
+
+//#region src/events/exit/handler.ts
+/**
+* @file `onExit` — register a callback for process exit / signal. Triggers
+*   `load()` on first call. Returns a remover that unregisters the callback and
+*   calls `unload()` once both `exit` and `afterexit` listener lists empty
+*   out.
+*/
+/**
+* Register a callback to run on process exit or signal.
+*
+* @example
+*   ```typescript
+*   const remove = onExit((code, signal) => {
+*   console.log(`Exiting with code ${code}, signal ${signal}`)
+*   })
+*   // Later, to unregister:
+*   remove()
+*   ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function onExit(cb, options) {
-  if (!import_internal.globalProcess) {
-    return function remove() {
-    };
-  }
-  if (typeof cb !== "function") {
-    throw new import_error.TypeErrorCtor("a callback must be provided for exit handler");
-  }
-  if ((0, import_internal.isLoaded)() === false) {
-    (0, import_lifecycle.load)();
-  }
-  const { alwaysLast } = { __proto__: null, ...options };
-  let eventName = "exit";
-  if (alwaysLast) {
-    eventName = "afterexit";
-  }
-  const emitter = (0, import_internal.getEmitter)();
-  emitter.on(eventName, cb);
-  return function remove() {
-    emitter.removeListener(eventName, cb);
-    if (!emitter.listeners("exit").length && !emitter.listeners("afterexit").length) {
-      (0, import_lifecycle.unload)();
-    }
-  };
+	/* c8 ignore start */
+	if (!require_events_exit__internal.globalProcess) return function remove() {};
+	/* c8 ignore stop */
+	if (typeof cb !== "function") throw new require_primordials_error.TypeErrorCtor("a callback must be provided for exit handler");
+	if (require_events_exit__internal.isLoaded() === false) /* @__PURE__ */ require_events_exit_lifecycle.load();
+	const { alwaysLast } = {
+		__proto__: null,
+		...options
+	};
+	let eventName = "exit";
+	if (alwaysLast) eventName = "afterexit";
+	const emitter = /* @__PURE__ */ require_events_exit__internal.getEmitter();
+	emitter.on(eventName, cb);
+	return function remove() {
+		emitter.removeListener(eventName, cb);
+		/* c8 ignore start */
+		if (!emitter.listeners("exit").length && !emitter.listeners("afterexit").length) /* @__PURE__ */ require_events_exit_lifecycle.unload();
+		/* c8 ignore stop */
+	};
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  onExit
-});
+
+//#endregion
+exports.onExit = onExit;