@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/env/xdg.d.ts

@@ -1,49 +1,49 @@
 /**
- * @fileoverview XDG Base Directory Specification environment variable getters.
- * Provides access to XDG user directories on Unix systems.
+ * @file XDG Base Directory Specification environment variable getters. Provides
+ *   access to XDG user directories on Unix systems.
  */
 /**
- * XDG_CACHE_HOME environment variable.
- * XDG Base Directory specification cache directory.
- *
- * @returns The XDG cache directory path, or `undefined` if not set
+ * XDG_CACHE_HOME environment variable. XDG Base Directory specification cache
+ * directory.
  *
  * @example
- * ```typescript
- * import { getXdgCacheHome } from '@socketsecurity/lib/env/xdg'
+ *   ;```typescript
+ *   import { getXdgCacheHome } from '@socketsecurity/lib/env/xdg'
+ *
+ *   const cacheDir = getXdgCacheHome()
+ *   // e.g. '/tmp/.cache' or undefined
+ *   ```
  *
- * const cacheDir = getXdgCacheHome()
- * // e.g. '/tmp/.cache' or undefined
- * ```
+ * @returns The XDG cache directory path, or `undefined` if not set
  */
 export declare function getXdgCacheHome(): string | undefined;
 /**
- * XDG_CONFIG_HOME environment variable.
- * XDG Base Directory specification config directory.
- *
- * @returns The XDG config directory path, or `undefined` if not set
+ * XDG_CONFIG_HOME environment variable. XDG Base Directory specification config
+ * directory.
  *
  * @example
- * ```typescript
- * import { getXdgConfigHome } from '@socketsecurity/lib/env/xdg'
+ *   ;```typescript
+ *   import { getXdgConfigHome } from '@socketsecurity/lib/env/xdg'
  *
- * const configDir = getXdgConfigHome()
- * // e.g. '/tmp/.config' or undefined
- * ```
+ *   const configDir = getXdgConfigHome()
+ *   // e.g. '/tmp/.config' or undefined
+ *   ```
+ *
+ * @returns The XDG config directory path, or `undefined` if not set
  */
 export declare function getXdgConfigHome(): string | undefined;
 /**
- * XDG_DATA_HOME environment variable.
- * Points to the user's data directory on Unix systems.
- *
- * @returns The XDG data directory path, or `undefined` if not set
+ * XDG_DATA_HOME environment variable. Points to the user's data directory on
+ * Unix systems.
  *
  * @example
- * ```typescript
- * import { getXdgDataHome } from '@socketsecurity/lib/env/xdg'
+ *   ;```typescript
+ *   import { getXdgDataHome } from '@socketsecurity/lib/env/xdg'
+ *
+ *   const dataDir = getXdgDataHome()
+ *   // e.g. '/tmp/.local/share' or undefined
+ *   ```
  *
- * const dataDir = getXdgDataHome()
- * // e.g. '/tmp/.local/share' or undefined
- * ```
+ * @returns The XDG data directory path, or `undefined` if not set
  */
 export declare function getXdgDataHome(): string | undefined;

package/dist/errors/message.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @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.
+ */
+import { UNKNOWN_ERROR } from '../constants/sentinels';
+import { messageWithCauses } from '../external/pony-cause';
+export { UNKNOWN_ERROR, messageWithCauses };
+/**
+ * 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,
+ *     })
+ *   }
+ */
+export declare function errorMessage(value: unknown): string;

package/dist/errors/message.js

@@ -0,0 +1,49 @@
+"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");
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UNKNOWN_ERROR,
+  errorMessage,
+  messageWithCauses
+});

package/dist/errors/predicates.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @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.
+ */
+export declare const isErrorBuiltin: ((value: unknown) => value is Error) | undefined;
+/**
+ * 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
+ *     }
+ *   }
+ */
+export declare function isErrnoException(value: unknown): value is NodeJS.ErrnoException;
+/**
+ * `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.
+ */
+export declare function isErrorShim(value: unknown): value is Error;
+/**
+ * Prefer the native ES2025 `Error.isError` when available (exact
+ * `[[ErrorData]]` slot check, cross-realm-safe); fall back to
+ * {@link isErrorShim} otherwise.
+ */
+export declare const isError: (value: unknown) => value is Error;

package/dist/{errors.js → errors/predicates.js}

@@ -18,30 +18,17 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var errors_exports = {};
-__export(errors_exports, {
-  UNKNOWN_ERROR: () => import_core.UNKNOWN_ERROR,
-  errorMessage: () => errorMessage,
-  errorStack: () => errorStack,
+var predicates_exports = {};
+__export(predicates_exports, {
   isErrnoException: () => isErrnoException,
   isError: () => isError,
   isErrorBuiltin: () => isErrorBuiltin,
-  isErrorShim: () => isErrorShim,
-  messageWithCauses: () => import_pony_cause.messageWithCauses,
-  stackWithCauses: () => import_pony_cause.stackWithCauses
+  isErrorShim: () => isErrorShim
 });
-module.exports = __toCommonJS(errors_exports);
-var import_core = require("./constants/core");
-var import_pony_cause = require("./external/pony-cause");
-var import_primordials = require("./primordials");
-function isErrorShim(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  return (0, import_primordials.ObjectPrototypeToString)(value) === "[object Error]";
-}
+module.exports = __toCommonJS(predicates_exports);
+var import_object = require("../primordials/object");
+var import_string = require("../primordials/string");
 const isErrorBuiltin = Error.isError;
-const isError = isErrorBuiltin ?? isErrorShim;
 function isErrnoException(value) {
   if (!isError(value)) {
     return false;
@@ -50,37 +37,20 @@ function isErrnoException(value) {
   if (typeof code !== "string" || code.length === 0) {
     return false;
   }
-  const first = (0, import_primordials.StringPrototypeCharCodeAt)(code, 0);
+  const first = (0, import_string.StringPrototypeCharCodeAt)(code, 0);
   return first >= 65 && first <= 90;
 }
-function errorMessage(value) {
-  if (isError(value)) {
-    return (0, import_pony_cause.messageWithCauses)(value) || import_core.UNKNOWN_ERROR;
-  }
-  if (value === null || value === void 0) {
-    return import_core.UNKNOWN_ERROR;
-  }
-  const s = String(value);
-  if (s === "" || s === "[object Object]") {
-    return import_core.UNKNOWN_ERROR;
-  }
-  return s;
-}
-function errorStack(value) {
-  if (isError(value)) {
-    return (0, import_pony_cause.stackWithCauses)(value);
+function isErrorShim(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
   }
-  return void 0;
+  return (0, import_object.ObjectPrototypeToString)(value) === "[object Error]";
 }
+const isError = isErrorBuiltin ?? isErrorShim;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  UNKNOWN_ERROR,
-  errorMessage,
-  errorStack,
   isErrnoException,
   isError,
   isErrorBuiltin,
-  isErrorShim,
-  messageWithCauses,
-  stackWithCauses
+  isErrorShim
 });

package/dist/errors/stack.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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.
+ */
+import { stackWithCauses } from '../external/pony-cause';
+export { stackWithCauses };
+/**
+ * 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.
+ */
+export declare function errorStack(value: unknown): string | undefined;

package/dist/errors/stack.js

@@ -0,0 +1,39 @@
+"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");
+function errorStack(value) {
+  if ((0, import_predicates.isError)(value)) {
+    return (0, import_pony_cause.stackWithCauses)(value);
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  errorStack,
+  stackWithCauses
+});

package/dist/events/exit/_internal.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @file Private internals for `events/exit/*` modules — the shared
+ *   module-singleton state plus the lazy accessors that read and mutate it.
+ *   Owns the emitter, signal list, and `loaded` flag. `lifecycle`
+ *   (load/unload/getSignalListeners) and `intercept`
+ *   (processEmit/processReallyExit) share state through this leaf. Inlined
+ *   signal-exit: https://socket.dev/npm/package/signal-exit/overview/4.1.0 ISC
+ *   License — Copyright (c) 2015-2023 Benjamin Coe, Isaac Z. Schlueter, and
+ *   Contributors.
+ */
+import type { SignalExitEmitter } from './types';
+export declare const globalProcess: (NodeJS.Process & {
+    __signal_exit_emitter__?: import('node:events').EventEmitter;
+    reallyExit?: (code?: number | undefined) => never;
+}) | undefined;
+export declare const originalProcessEmit: {
+    (event: "beforeExit", code: number): boolean;
+    (event: "disconnect"): boolean;
+    (event: "exit", code: number): boolean;
+    (event: "rejectionHandled", promise: Promise<unknown>): boolean;
+    (event: "uncaughtException", error: Error): boolean;
+    (event: "uncaughtExceptionMonitor", error: Error): boolean;
+    (event: "unhandledRejection", reason: unknown, promise: Promise<unknown>): boolean;
+    (event: "warning", warning: Error): boolean;
+    (event: "message", message: unknown, sendHandle: import("child_process").SendHandle): NodeJS.Process & {
+        __signal_exit_emitter__?: import('node:events').EventEmitter;
+        reallyExit?: (code?: number | undefined) => never;
+    };
+    (event: NodeJS.Signals, signal?: NodeJS.Signals): boolean;
+    (event: "multipleResolves", type: NodeJS.MultipleResolveType, promise: Promise<unknown>, value: unknown): NodeJS.Process & {
+        __signal_exit_emitter__?: import('node:events').EventEmitter;
+        reallyExit?: (code?: number | undefined) => never;
+    };
+    (event: "worker", listener: NodeJS.WorkerListener): NodeJS.Process & {
+        __signal_exit_emitter__?: import('node:events').EventEmitter;
+        reallyExit?: (code?: number | undefined) => never;
+    };
+} | undefined;
+export declare const platform: string;
+export declare const originalProcessReallyExit: ((code?: number | undefined) => never) | undefined;
+export declare const WIN32: boolean;
+export declare function emit(event: string, code: number | undefined, signal: string | undefined): void;
+export declare function getEmitter(): SignalExitEmitter;
+export declare function getEvents(): typeof import('node:events');
+/**
+ * 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.
+ */
+export declare function getSignals(): string[];
+/**
+ * Read the loaded flag from a sibling leaf (lifecycle / on-exit).
+ *
+ * @private
+ */
+export declare function isLoaded(): boolean;
+/**
+ * Set the `loaded` flag from a sibling leaf (load / unload).
+ *
+ * @private
+ */
+export declare function setLoaded(value: boolean): void;
+/**
+ * Replace the cached signal list (used by `load()`'s filter step).
+ *
+ * @private
+ */
+export declare function setSignals(value: string[]): void;

package/dist/events/exit/_internal.js

@@ -0,0 +1,127 @@
+"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);
+const globalProcess = globalThis.process;
+const originalProcessEmit = globalProcess?.emit;
+const platform = globalProcess?.platform ?? "";
+const originalProcessReallyExit = globalProcess?.reallyExit;
+const WIN32 = platform === "win32";
+let _events;
+let _emitter;
+let _loaded = false;
+let _signals;
+// @__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);
+}
+// @__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;
+}
+// @__NO_SIDE_EFFECTS__
+function getEvents() {
+  if (_events === void 0) {
+    _events = require("node:events");
+  }
+  return _events;
+}
+// @__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;
+}
+function isLoaded() {
+  return _loaded;
+}
+function setLoaded(value) {
+  _loaded = value;
+}
+function setSignals(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
+});

package/dist/events/exit/handler.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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.
+ */
+import type { OnExitOptions } from './types';
+/**
+ * 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()
+ *   ```
+ */
+export declare function onExit(cb: (code: number | null, signal: string | null) => void, options?: OnExitOptions | undefined): () => void;

package/dist/events/exit/handler.js

@@ -0,0 +1,58 @@
+"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__
+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)();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  onExit
+});

package/dist/events/exit/intercept.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file Process-method interceptors — `processEmit` replaces `process.emit` and
+ *   `processReallyExit` replaces `process.reallyExit` while `load()` is active.
+ *   Both forward to the originals captured in `_internal` and broadcast `exit`
+ *   / `afterexit` through the signal-exit emitter.
+ */
+export declare function processEmit(this: NodeJS.Process, eventName: string, exitCode?: number | undefined, ...args: unknown[]): boolean;
+export declare function processReallyExit(code?: number | undefined): never;