chore: synchronize repository state

Author: eli-sterling

RELEASE_NOTES.md

@@ -7,7 +7,7 @@
 - Hardened rollback and cleanup behavior for listener, logger, signal, and
   one-shot handler failures.
 - Added focused module-level tests while retaining public API coverage.
-- Updated `@eliware/log` to 2.1.0 and `@eliware/test` to 2.3.1.
+- Updated `@eliware/log` to 2.4.0 and `@eliware/test` to 2.4.0.
 
 ## 2.0.0 — 2026-08-25
 

index.d.ts

@@ -1,15 +1,23 @@
 import type logger from '@eliware/log';
 
 export type ProcessEvent = 'uncaughtException' | 'unhandledRejection' | 'warning';
-export interface ProcessLike {
-  on(event: string, listener: (...args: unknown[]) => void): unknown;
-  once?(event: string, listener: (...args: unknown[]) => void): unknown;
-  off?(event: string, listener: (...args: unknown[]) => void): unknown;
-  removeListener?(event: string, listener: (...args: unknown[]) => void): unknown;
+export type ProcessListener = (...args: unknown[]) => void;
+export interface Logger {
+  error(message: string, metadata: unknown): unknown;
+  warn(message: string, metadata: unknown): unknown;
+  debug(message: string): unknown;
 }
+export type ProcessLike = {
+  on(event: ProcessEvent, listener: ProcessListener): unknown;
+  once?(event: ProcessEvent, listener: ProcessListener): unknown;
+} & ({
+  off(event: ProcessEvent, listener: ProcessListener): unknown;
+} | {
+  removeListener(event: ProcessEvent, listener: ProcessListener): unknown;
+});
 export interface RegisterHandlersOptions {
   processObj?: ProcessLike;
-  log?: typeof logger;
+  log?: Logger;
   events?: ProcessEvent[];
   once?: boolean;
   signal?: AbortSignal;

index.mjs

@@ -1 +1,5 @@
-export { registerHandlers, registerHandlers as default } from './src/registration.mjs';
+import { registerHandlers } from './src/index.mjs';
+
+const publicRegisterHandlers = registerHandlers;
+
+export { publicRegisterHandlers as registerHandlers, publicRegisterHandlers as default };

package-lock.json

@@ -60,11 +60,11 @@
     },
     "homepage": "https://github.com/eliware/errors#readme",
     "devDependencies": {
-        "@eliware/test": "^2.3.1",
+        "@eliware/test": "^5.0.0",
         "typescript": "^7.0.2"
     },
     "dependencies": {
-        "@eliware/log": "^2.1.0"
+        "@eliware/log": "^2.4.0"
     },
     "engines": {
         "node": ">=26"

package.json

@@ -1,20 +1,24 @@
-export function createCleanup({ processObj, remove, selected, handlers, signal, registrations, registration }) {
+export function createCleanup({ processObj, remove, selected, handlers, signal, registrations, registration, detachedEvents }) {
   let abortListener;
+  const removedEvents = new Set();
   const removeHandlers = () => {
     if (registration.removed) return;
     registration.removed = true;
     let removalError;
     for (const event of selected) {
+      if (removedEvents.has(event)) continue;
+      if (detachedEvents.has(event)) {
+        removedEvents.add(event);
+        continue;
+      }
       try {
         processObj[remove](event, handlers[event]);
+        removedEvents.add(event);
       } catch (error) {
         removalError ??= error;
       }
     }
-    if (removalError) {
-      registration.removed = false;
-      throw removalError;
-    }
+    if (removalError) { registration.removed = false; throw removalError; }
     let abortError;
     if (abortListener && typeof signal?.removeEventListener === 'function') {
       try {
@@ -23,8 +27,12 @@ export function createCleanup({ processObj, remove, selected, handlers, signal,
         abortError = error;
       }
     }
+    if (abortError) {
+      registration.removed = false;
+      registrations.set(processObj, registration);
+      throw abortError;
+    }
     registrations.delete(processObj);
-    if (abortError) throw abortError;
   };
   abortListener = removeHandlers;
   return { removeHandlers, setAbortListener: listener => { abortListener = listener; } };

src/cleanup.mjs

@@ -0,0 +1,5 @@
+import { registerHandlers } from './registration.mjs';
+
+const publicRegisterHandlers = registerHandlers;
+
+export { publicRegisterHandlers as registerHandlers, publicRegisterHandlers as default };

src/index.mjs

@@ -1,5 +1,10 @@
+function diagnostic(value) {
+  if (value instanceof Error) return { name: 'Error', type: 'Error' };
+  return { type: typeof value };
+}
+
 export function eventLog(log, event, ...args) {
-  if (event === 'warning') return log.warn('Warning', { warning: args[0] });
-  if (event === 'unhandledRejection') return log.error('Unhandled Rejection', { reason: args[0], promise: args[1] });
-  return log.error('Uncaught Exception', { error: args[0] });
+  if (event === 'warning') return log.warn('Warning', { warning: diagnostic(args[0]) });
+  if (event === 'unhandledRejection') return log.error('Unhandled Rejection', { reasonType: typeof args[0] });
+  return log.error('Uncaught Exception', { error: diagnostic(args[0]) });
 }

src/logging.mjs

@@ -1,67 +1,116 @@
 import logger from '@eliware/log';
 import { defaultEvents } from './constants.mjs';
-import { normalizeEvents, validateProcessObject } from './validation.mjs';
+import { normalizeEvents, validateLogger, validateProcessObject } from './validation.mjs';
 import { eventLog } from './logging.mjs';
 import { createCleanup } from './cleanup.mjs';
 
 const registrations = new WeakMap();
 
+function attachFailure(error, key, secondary) {
+  if ((typeof error !== 'object' && typeof error !== 'function') || error === null) return;
+  try {
+    if (Object.isExtensible(error)) error[key] = secondary;
+  } catch {
+    // Preserve the primary failure when secondary-error reporting is unavailable.
+  }
+}
+
 export function registerHandlers({ processObj = process, log = logger, events, once = false, signal } = {}) {
   const selected = normalizeEvents(events);
-  const existing = registrations.get(processObj);
-  if (existing) return existing;
   const remove = validateProcessObject(processObj);
+  validateLogger(log);
+  const existing = registrations.get(processObj);
+  if (existing) {
+    if (signal && typeof signal.addEventListener !== 'function') throw new TypeError('signal must provide addEventListener');
+    if (!existing.ready) throw new Error('registration is still being set up');
+    return existing;
+  }
   const add = once && typeof processObj.once === 'function' ? 'once' : 'on';
-  const oneShot = add === 'once';
+  const oneShot = once;
   const fired = new Set();
-  const registration = { removed: false };
-  const handlers = Object.fromEntries(selected.map(event => [event, (...args) => {
-    const result = eventLog(log, event, ...args);
-    if (oneShot) {
-      fired.add(event);
-      if (fired.size === selected.length && registration.removeHandlers) {
-        registration.removeHandlers();
+  const detachedEvents = new Set();
+  const addedEvents = new Set();
+  const attachedEvents = new Set();
+  let setupComplete = false;
+  let cleanupPending = false;
+  const registration = { removed: false, ready: false };
+  const handlers = {};
+  for (const event of selected) {
+    handlers[event] = (...args) => {
+      if (registration.removed || fired.has(event)) return undefined;
+      try {
+        const result = eventLog(log, event, ...args);
+        if (oneShot) {
+          fired.add(event);
+          if (add === 'once' && addedEvents.has(event)) detachedEvents.add(event);
+        }
+        if (oneShot && fired.size === selected.length) {
+          if (setupComplete) registration.removeHandlers();
+          else cleanupPending = true;
+        }
+        return result;
+      } catch (error) {
+        if (oneShot) {
+          fired.add(event);
+          if (setupComplete) {
+            try { registration.removeHandlers(); } catch (cleanupError) { attachFailure(error, 'cleanupError', cleanupError); }
+          } else cleanupPending = true;
+        }
+        throw error;
       }
-    }
-    return result;
-  }]));
-  const added = [];
+    };
+  }
+  registrations.set(processObj, registration);
+  const cleanup = createCleanup({ processObj, remove, selected, handlers, signal, registrations, registration, detachedEvents });
+  registration.removeHandlers = cleanup.removeHandlers;
+  cleanup.setAbortListener(registration.removeHandlers);
   try {
     for (const event of selected) {
+      attachedEvents.add(event);
       processObj[add](event, handlers[event]);
-      added.push(event);
+      addedEvents.add(event);
     }
+    setupComplete = true;
+    if (cleanupPending || (oneShot && fired.size === selected.length)) registration.removeHandlers();
+    registration.ready = true;
   } catch (error) {
-    for (const event of added) {
+    let rollbackError;
+    for (const event of attachedEvents) {
       try {
         processObj[remove](event, handlers[event]);
-      } catch {
-        // Preserve the original registration failure while attempting all rollback removals.
+      } catch (removalError) {
+        rollbackError ??= removalError;
       }
     }
+    if (rollbackError) {
+      registration.ready = true;
+      registrations.set(processObj, registration);
+      attachFailure(error, 'rollbackError', rollbackError);
+      attachFailure(error, 'registration', registration);
+    } else registrations.delete(processObj);
     throw error;
   }
-  const cleanup = createCleanup({ processObj, remove, selected, handlers, signal, registrations, registration });
-  registration.removeHandlers = cleanup.removeHandlers;
-  cleanup.setAbortListener(registration.removeHandlers);
-  registrations.set(processObj, registration);
   if (oneShot && fired.size === selected.length) registration.removeHandlers();
   try {
-    if (signal) {
+    if (signal && !registration.removed) {
       if (typeof signal.addEventListener !== 'function') throw new TypeError('signal must provide addEventListener');
+      signal.addEventListener('abort', registration.removeHandlers, { once: true });
       if (signal.aborted) registration.removeHandlers();
-      else signal.addEventListener('abort', registration.removeHandlers, { once: true });
     }
     log.debug('Exception handlers registered');
   } catch (error) {
     let cleanupFailed = false;
     try {
       registration.removeHandlers();
-    } catch {
+    } catch (cleanupError) {
       // Preserve the original setup or logger failure.
       cleanupFailed = true;
+      attachFailure(error, 'cleanupError', cleanupError);
+    }
+    if (cleanupFailed) {
+      registration.ready = true;
+      registrations.set(processObj, registration);
     }
-    if (cleanupFailed) registrations.set(processObj, registration);
     else registrations.delete(processObj);
     throw error;
   }

src/registration.mjs

@@ -17,3 +17,9 @@ export function validateProcessObject(processObj) {
   if (typeof processObj[remove] !== 'function') throw new TypeError('processObj must provide an off or removeListener method');
   return remove;
 }
+
+export function validateLogger(log) {
+  for (const method of ['error', 'warn', 'debug']) {
+    if (!log || typeof log[method] !== 'function') throw new TypeError(`log must provide a ${method} method`);
+  }
+}