hookified 1.15.0 → 2.0.0

package/README.md

@@ -4,7 +4,7 @@
 
 [![tests](https://github.com/jaredwray/hookified/actions/workflows/tests.yaml/badge.svg)](https://github.com/jaredwray/hookified/actions/workflows/tests.yaml)
 [![GitHub license](https://img.shields.io/github/license/jaredwray/hookified)](https://github.com/jaredwray/hookified/blob/master/LICENSE)
-[![codecov](https://codecov.io/gh/jaredwray/hookified/graph/badge.svg?token=nKkVklTFdA)](https://codecov.io/gh/jaredwray/hookified)
+[![codecov](https://codecov.io/gh/jaredwray/hookified/branch/main/graph/badge.svg?token=nKkVklTFdA)](https://codecov.io/gh/jaredwray/hookified)
 [![npm](https://img.shields.io/npm/dm/hookified)](https://npmjs.com/package/hookified)
 [![jsDelivr](https://data.jsdelivr.com/v1/package/npm/hookified/badge)](https://www.jsdelivr.com/package/npm/hookified)
 [![npm](https://img.shields.io/npm/v/hookified)](https://npmjs.com/package/hookified)
@@ -19,37 +19,45 @@
 - Enforce consistent hook naming conventions with `enforceBeforeAfter`
 - Deprecation warnings for hooks with `deprecatedHooks`
 - Control deprecated hook execution with `allowDeprecated`
-- No package dependencies and only 200KB in size
+- WaterfallHook for sequential data transformation pipelines
+- No package dependencies and only 250KB in size
 - Fast and Efficient with [Benchmarks](#benchmarks)
 - Maintained on a regular basis!
 
 # Table of Contents
 - [Installation](#installation)
 - [Usage](#usage)
+- [Migrating from v1 to v2](#migrating-from-v1-to-v2)
 - [Using it in the Browser](#using-it-in-the-browser)
+- [Hooks](#hooks)
+  - [Standard Hook](#standard-hook)
+  - [Waterfall Hook](#waterfallhook)
 - [API - Hooks](#api---hooks)
-  - [.throwOnHookError](#throwhookerror)
-  - [.logger](#logger)
-  - [.enforceBeforeAfter](#enforcebeforeafter)
-  - [.deprecatedHooks](#deprecatedhooks)
   - [.allowDeprecated](#allowdeprecated)
-  - [.onHook(eventName, handler)](#onhookeventname-handler)
-  - [.onHookEntry(hookEntry)](#onhookentryhookentry)
-  - [.addHook(eventName, handler)](#addhookeventname-handler)
-  - [.onHooks(Array)](#onhooksarray)
-  - [.onceHook(eventName, handler)](#oncehookeventname-handler)
-  - [.prependHook(eventName, handler)](#prependhookeventname-handler)
-  - [.prependOnceHook(eventName, handler)](#prependoncehookeventname-handler)
-  - [.removeHook(eventName)](#removehookeventname)
-  - [.removeHooks(Array)](#removehooksarray)
-  - [.hook(eventName, ...args)](#hookeventname-args)
-  - [.callHook(eventName, ...args)](#callhookeventname-args)
-  - [.beforeHook(eventName, ...args)](#beforehookeventname-args)
+  - [.deprecatedHooks](#deprecatedhooks)
+  - [.enforceBeforeAfter](#enforcebeforeafter)
+  - [.eventLogger](#eventlogger)
+  - [.hooks](#hooks-1)
+  - [.throwOnHookError](#throwOnHookError)
+  - [.useHookClone](#usehookclone)
+  - [.addHook(event, handler)](#addhookevent-handler)
   - [.afterHook(eventName, ...args)](#afterhookeventname-args)
-  - [.hookSync(eventName, ...args)](#hooksync-eventname-args)
-  - [.hooks](#hooks)
+  - [.beforeHook(eventName, ...args)](#beforehookeventname-args)
+  - [.callHook(eventName, ...args)](#callhookeventname-args)
+  - [.clearHooks()](#clearhooks)
+  - [.getHook(id)](#gethookid)
   - [.getHooks(eventName)](#gethookseventname)
-  - [.clearHooks(eventName)](#clearhookeventname)
+  - [.hook(eventName, ...args)](#hookeventname-args)
+  - [.hookSync(eventName, ...args)](#hooksync-eventname-args)
+  - [.onHook(hook, options?)](#onhookhook-options)
+  - [.onHooks(Array, options?)](#onhooksarray-options)
+  - [.onceHook(hook)](#oncehookhook)
+  - [.prependHook(hook, options?)](#prependhookhook-options)
+  - [.prependOnceHook(hook, options?)](#prependoncehookhook-options)
+  - [.removeEventHooks(eventName)](#removeeventhookseventname)
+  - [.removeHook(hook)](#removehookhook)
+  - [.removeHookById(id)](#removehookbyidid)
+  - [.removeHooks(Array)](#removehooksarray)
 - [API - Events](#api---events)
   - [.throwOnEmitError](#throwonemitterror)
   - [.throwOnEmptyListeners](#throwonemptylisteners)
@@ -87,11 +95,11 @@ class MyClass extends Hookified {
   }
 
   async myMethodEmittingEvent() {
-    this.emit('message', 'Hello World'); //using Emittery
+    this.emit('message', 'Hello World');
   }
 
   //with hooks you can pass data in and if they are subscribed via onHook they can modify the data
-  async myMethodWithHooks() Promise<any> {
+  async myMethodWithHooks(): Promise<any> {
     let data = { some: 'data' };
     // do something
     await this.hook('before:myMethod2', data);
@@ -111,7 +119,7 @@ class MyClass extends Hookified {
     super();
   }
 
-  async myMethodWithHooks() Promise<any> {
+  async myMethodWithHooks(): Promise<any> {
     let data = { some: 'data' };
     let data2 = { some: 'data2' };
     // do something
@@ -134,11 +142,11 @@ class MyClass extends Hookified {
     }
 
     async myMethodEmittingEvent() {
-      this.emit('message', 'Hello World'); //using Emittery
+      this.emit('message', 'Hello World');
     }
 
     //with hooks you can pass data in and if they are subscribed via onHook they can modify the data
-    async myMethodWithHooks() Promise<any> {
+    async myMethodWithHooks(): Promise<any> {
       let data = { some: 'data' };
       // do something
       await this.hook('before:myMethod2', data);
@@ -160,11 +168,11 @@ if you are not using ESM modules, you can use the following:
     }
 
     async myMethodEmittingEvent() {
-      this.emit('message', 'Hello World'); //using Emittery
+      this.emit('message', 'Hello World');
     }
 
     //with hooks you can pass data in and if they are subscribed via onHook they can modify the data
-    async myMethodWithHooks() Promise<any> {
+    async myMethodWithHooks(): Promise<any> {
       let data = { some: 'data' };
       // do something
       await this.hook('before:myMethod2', data);
@@ -175,191 +183,175 @@ if you are not using ESM modules, you can use the following:
 </script>
 ```
 
-# API - Hooks
+# Hooks
 
-## .throwOnHookError
+## Standard Hook
 
-If set to true, errors thrown in hooks will be thrown. If set to false, errors will be only emitted.
+The `Hook` class provides a convenient way to create hook entries. It implements the `IHook` interface.
+
+The `IHook` interface has the following properties:
+
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| `id` | `string` | No | Unique identifier for the hook. Auto-generated via `crypto.randomUUID()` if not provided. |
+| `event` | `string` | Yes | The event name for the hook. |
+| `handler` | `HookFn` | Yes | The handler function for the hook. |
+
+When a hook is registered, it is assigned an `id` (auto-generated if not provided). The `id` can be used to look up or remove hooks via `getHook` and `removeHookById`. If you register a hook with the same `id` on the same event, it will replace the existing hook in-place (preserving its position).
+
+**Using the `Hook` class:**
 
 ```javascript
-import { Hookified } from 'hookified';
+import { Hook, Hookified } from 'hookified';
 
 class MyClass extends Hookified {
-  constructor() {
-    super({ throwOnHookError: true });
-  }
+  constructor() { super(); }
 }
 
 const myClass = new MyClass();
 
-console.log(myClass.throwOnHookError); // true. because it is set in super
+// Without id (auto-generated)
+const hook = new Hook('before:save', async (data) => {
+  data.validated = true;
+});
 
-try {
-  myClass.onHook('error-event', async () => {
-    throw new Error('error');
-  });
+// With id
+const hook2 = new Hook('after:save', async (data) => {
+  console.log('saved');
+}, 'my-after-save-hook');
 
-  await myClass.hook('error-event');
-} catch (error) {
-  console.log(error.message); // error
-}
+// Register with onHook
+myClass.onHook(hook);
 
-myClass.throwOnHookError = false;
-console.log(myClass.throwOnHookError); // false
-```
+// Or register multiple hooks with onHooks
+const hooks = [
+  new Hook('before:save', async (data) => { data.validated = true; }),
+  new Hook('after:save', async (data) => { console.log('saved'); }),
+];
+myClass.onHooks(hooks);
 
-## .logger
-If set, errors thrown in hooks will be logged to the logger. If not set, errors will be only emitted.
+// Remove hooks
+myClass.removeHooks(hooks);
+```
 
-```javascript
-import { Hookified } from 'hookified';
-import pino from 'pino';
+**Using plain TypeScript with the `IHook` interface:**
 
-const logger = pino(); // create a logger instance that is compatible with Logger type
+```typescript
+import { Hookified, type IHook } from 'hookified';
 
 class MyClass extends Hookified {
-  constructor() {
-    super({ logger });
-  }
-
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // do something
-    await this.hook('before:myMethod2', data);
-
-    return data;
-  }
+  constructor() { super(); }
 }
 
 const myClass = new MyClass();
-myClass.onHook('before:myMethod2', async () => {
-  throw new Error('error');
-});
 
-// when you call before:myMethod2 it will log the error to the logger
-await myClass.hook('before:myMethod2');
+const hook: IHook = {
+  id: 'my-validation-hook', // optional — auto-generated if omitted
+  event: 'before:save',
+  handler: async (data) => {
+    data.validated = true;
+  },
+};
+
+const stored = myClass.onHook(hook);
+console.log(stored?.id); // 'my-validation-hook'
+
+// Later, remove by id
+myClass.removeHookById('my-validation-hook');
 ```
 
-## .enforceBeforeAfter
+## Waterfall Hook
 
-If set to true, enforces that all hook names must start with 'before' or 'after'. This is useful for maintaining consistent hook naming conventions in your application. Default is false.
+The `WaterfallHook` class chains multiple hook functions sequentially in a waterfall pipeline. Each hook receives a context containing the original arguments and the accumulated results from all previous hooks. It implements the `IHook` interface, so it integrates directly with `Hookified.onHook()`.
 
-```javascript
-import { Hookified } from 'hookified';
+The `WaterfallHookContext` has the following properties:
 
-class MyClass extends Hookified {
-  constructor() {
-    super({ enforceBeforeAfter: true });
-  }
-}
+| Property | Type | Description |
+|----------|------|-------------|
+| `initialArgs` | `any` | The original arguments passed to the waterfall execution. |
+| `results` | `WaterfallHookResult[]` | Array of `{ hook, result }` entries from previous hooks. Empty for the first hook. |
 
-const myClass = new MyClass();
+**Basic usage:**
 
-console.log(myClass.enforceBeforeAfter); // true
+```javascript
+import { WaterfallHook } from 'hookified';
 
-// These will work fine
-myClass.onHook('beforeSave', async () => {
-  console.log('Before save hook');
+const wh = new WaterfallHook('process', ({ results, initialArgs }) => {
+  // Final handler receives all accumulated results
+  const lastResult = results[results.length - 1].result;
+  console.log('Final:', lastResult);
 });
 
-myClass.onHook('afterSave', async () => {
-  console.log('After save hook');
+// Add transformation hooks to the pipeline
+wh.addHook(({ initialArgs }) => {
+  return initialArgs + 1; // 5 -> 6
 });
 
-myClass.onHook('before:validation', async () => {
-  console.log('Before validation hook');
+wh.addHook(({ results }) => {
+  return results[results.length - 1].result * 2; // 6 -> 12
 });
 
-// This will throw an error
-try {
-  myClass.onHook('customEvent', async () => {
-    console.log('This will not work');
-  });
-} catch (error) {
-  console.log(error.message); // Hook event "customEvent" must start with "before" or "after" when enforceBeforeAfter is enabled
-}
-
-// You can also change it dynamically
-myClass.enforceBeforeAfter = false;
-myClass.onHook('customEvent', async () => {
-  console.log('This will work now');
-});
+// Execute the waterfall by calling handler directly
+await wh.handler(5); // Final: 12
 ```
 
-The validation applies to all hook-related methods:
-- `onHook()`, `addHook()`, `onHookEntry()`, `onHooks()`
-- `prependHook()`, `onceHook()`, `prependOnceHook()`
-- `hook()`, `callHook()`
-- `getHooks()`, `removeHook()`, `removeHooks()`
-
-Note: The `beforeHook()` and `afterHook()` helper methods automatically generate proper hook names and work regardless of the `enforceBeforeAfter` setting.
-
-## .deprecatedHooks
-
-A Map of deprecated hook names to deprecation messages. When a deprecated hook is used, a warning will be emitted via the 'warn' event and logged to the logger (if available). Default is an empty Map.
+**Integrating with Hookified via `onHook()`:**
 
 ```javascript
-import { Hookified } from 'hookified';
-
-// Define deprecated hooks with custom messages
-const deprecatedHooks = new Map([
-  ['oldHook', 'Use newHook instead'],
-  ['legacyMethod', 'This hook will be removed in v2.0'],
-  ['deprecatedFeature', ''] // Empty message - will just say "deprecated"
-]);
+import { Hookified, WaterfallHook } from 'hookified';
 
 class MyClass extends Hookified {
-  constructor() {
-    super({ deprecatedHooks });
-  }
+  constructor() { super(); }
 }
 
 const myClass = new MyClass();
 
-console.log(myClass.deprecatedHooks); // Map with deprecated hooks
-
-// Listen for deprecation warnings
-myClass.on('warn', (event) => {
-  console.log(`Deprecation warning: ${event.message}`);
-  // event.hook contains the hook name
-  // event.message contains the full warning message
+const wh = new WaterfallHook('save', ({ results }) => {
+  const data = results[results.length - 1].result;
+  console.log('Saved:', data);
 });
 
-// Using a deprecated hook will emit warnings
-myClass.onHook('oldHook', () => {
-  console.log('This hook is deprecated');
+wh.addHook(({ initialArgs }) => {
+  return { ...initialArgs, validated: true };
 });
-// Output: Hook "oldHook" is deprecated: Use newHook instead
 
-// Using a deprecated hook with empty message
-myClass.onHook('deprecatedFeature', () => {
-  console.log('This hook is deprecated');
+wh.addHook(({ results }) => {
+  return { ...results[results.length - 1].result, timestamp: Date.now() };
 });
-// Output: Hook "deprecatedFeature" is deprecated
 
-// You can also set deprecated hooks dynamically
-myClass.deprecatedHooks.set('anotherOldHook', 'Please migrate to the new API');
+// Register with Hookified — works because WaterfallHook implements IHook
+myClass.onHook(wh);
 
-// Works with logger if provided
-import pino from 'pino';
-const logger = pino();
+// When hook() fires, the full waterfall pipeline executes
+await myClass.hook('save', { name: 'test' });
+// Saved: { name: 'test', validated: true, timestamp: ... }
+```
 
-const myClassWithLogger = new Hookified({ 
-  deprecatedHooks,
-  logger 
-});
+**Managing hooks:**
 
-// Deprecation warnings will be logged to logger.warn
+```javascript
+const wh = new WaterfallHook('process', ({ results }) => results);
+
+const myHook = ({ initialArgs }) => initialArgs + 1;
+wh.addHook(myHook);
+
+// Remove a hook by reference
+wh.removeHook(myHook); // returns true
+
+// Access the hooks array
+console.log(wh.hooks.length); // 0
 ```
 
-The deprecation warning system applies to all hook-related methods:
-- Registration: `onHook()`, `addHook()`, `onHookEntry()`, `onHooks()`, `prependHook()`, `onceHook()`, `prependOnceHook()`
-- Execution: `hook()`, `callHook()`
-- Management: `getHooks()`, `removeHook()`, `removeHooks()`
+# API - Hooks
 
-Deprecation warnings are emitted in two ways:
-1. **Event**: A 'warn' event is emitted with `{ hook: string, message: string }`
-2. **Logger**: Logged to `logger.warn()` if a logger is configured and has a `warn` method
+> All examples below assume the following setup unless otherwise noted:
+> ```javascript
+> import { Hookified } from 'hookified';
+> class MyClass extends Hookified {
+>   constructor(options) { super(options); }
+> }
+> const myClass = new MyClass();
+> ```
 
 ## .allowDeprecated
 
@@ -388,9 +380,9 @@ myClass.on('warn', (event) => {
 });
 
 // Try to register a deprecated hook - will emit warning but not register
-myClass.onHook('oldHook', () => {
+myClass.onHook({ event: 'oldHook', handler: () => {
   console.log('This will never execute');
-});
+}});
 // Output: Warning: Hook "oldHook" is deprecated: Use newHook instead
 
 // Verify hook was not registered
@@ -402,9 +394,9 @@ await myClass.hook('oldHook');
 // (but no handlers execute)
 
 // Non-deprecated hooks work normally
-myClass.onHook('validHook', () => {
+myClass.onHook({ event: 'validHook', handler: () => {
   console.log('This works fine');
-});
+}});
 
 console.log(myClass.getHooks('validHook')); // [handler function]
 
@@ -412,17 +404,17 @@ console.log(myClass.getHooks('validHook')); // [handler function]
 myClass.allowDeprecated = true;
 
 // Now deprecated hooks can be registered and executed
-myClass.onHook('oldHook', () => {
+myClass.onHook({ event: 'oldHook', handler: () => {
   console.log('Now this works');
-});
+}});
 
 console.log(myClass.getHooks('oldHook')); // [handler function]
 ```
 
 **Behavior when `allowDeprecated` is false:**
 - **Registration**: All hook registration methods (`onHook`, `addHook`, `prependHook`, etc.) will emit warnings but skip registration
-- **Execution**: Hook execution methods (`hook`, `callHook`) will emit warnings but skip execution  
-- **Management**: Hook management methods (`getHooks`, `removeHook`) will emit warnings and return undefined/skip operations
+- **Execution**: Hook execution methods (`hook`, `callHook`) will emit warnings but skip execution
+- **Removal/Reading**: `removeHook`, `removeHooks`, and `getHooks` always work regardless of deprecation status
 - **Warnings**: Deprecation warnings are always emitted regardless of `allowDeprecated` setting
 
 **Use cases:**
@@ -431,543 +423,550 @@ console.log(myClass.getHooks('oldHook')); // [handler function]
 - **Migration**: Gradually disable deprecated hooks during API transitions
 - **Production**: Disable deprecated hooks to prevent legacy code execution
 
-## .onHook(eventName, handler)
+## .deprecatedHooks
 
-Subscribe to a hook event.
+A Map of deprecated hook names to deprecation messages. When a deprecated hook is used, a warning will be emitted via the 'warn' event and logged to the logger (if available). Default is an empty Map.
 
 ```javascript
 import { Hookified } from 'hookified';
 
+// Define deprecated hooks with custom messages
+const deprecatedHooks = new Map([
+  ['oldHook', 'Use newHook instead'],
+  ['legacyMethod', 'This hook will be removed in v2.0'],
+  ['deprecatedFeature', ''] // Empty message - will just say "deprecated"
+]);
+
 class MyClass extends Hookified {
   constructor() {
-    super();
-  }
-
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // do something
-    await this.hook('before:myMethod2', data);
-
-    return data;
+    super({ deprecatedHooks });
   }
 }
 
 const myClass = new MyClass();
-myClass.onHook('before:myMethod2', async (data) => {
-  data.some = 'new data';
-});
-```
 
-## .onHookEntry(hookEntry)
+console.log(myClass.deprecatedHooks); // Map with deprecated hooks
 
-This allows you to create a hook with the `HookEntry` type which includes the event and handler. This is useful for creating hooks with a single object.
+// Listen for deprecation warnings
+myClass.on('warn', (event) => {
+  console.log(`Deprecation warning: ${event.message}`);
+  // event.hook contains the hook name
+  // event.message contains the full warning message
+});
 
-```javascript
-import { Hookified, HookEntry } from 'hookified';
+// Using a deprecated hook will emit warnings
+myClass.onHook({ event: 'oldHook', handler: () => {
+  console.log('This hook is deprecated');
+}});
+// Output: Hook "oldHook" is deprecated: Use newHook instead
 
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+// Using a deprecated hook with empty message
+myClass.onHook({ event: 'deprecatedFeature', handler: () => {
+  console.log('This hook is deprecated');
+}});
+// Output: Hook "deprecatedFeature" is deprecated
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // do something
-    await this.hook('before:myMethod2', data);
+// You can also set deprecated hooks dynamically
+myClass.deprecatedHooks.set('anotherOldHook', 'Please migrate to the new API');
 
-    return data;
-  }
-}
+// Works with logger if provided
+import pino from 'pino';
+const logger = pino();
 
-const myClass = new MyClass();
-myClass.onHookEntry({
-  event: 'before:myMethod2',
-  handler: async (data) => {
-    data.some = 'new data';
-  },
+const myClassWithLogger = new Hookified({
+  deprecatedHooks,
+  eventLogger: logger
 });
+
+// Deprecation warnings will be logged to logger.warn
 ```
 
-## .addHook(eventName, handler)
+The deprecation warning system applies to the following hook-related methods:
+- Registration: `onHook()`, `addHook()`, `onHooks()`, `prependHook()`, `onceHook()`, `prependOnceHook()`
+- Execution: `hook()`, `callHook()`
+
+Note: `getHooks()`, `removeHook()`, and `removeHooks()` do not check for deprecated hooks and always operate normally.
 
-This is an alias for `.onHook(eventName, handler)` for backwards compatibility.
+Deprecation warnings are emitted in two ways:
+1. **Event**: A 'warn' event is emitted with `{ hook: string, message: string }`
+2. **Logger**: Logged to `eventLogger.warn()` if an `eventLogger` is configured and has a `warn` method
 
-## .onHooks(Array)
+## .enforceBeforeAfter
 
-Subscribe to multiple hook events at once
+If set to true, enforces that all hook names must start with 'before' or 'after'. This is useful for maintaining consistent hook naming conventions in your application. Default is false.
 
 ```javascript
 import { Hookified } from 'hookified';
 
 class MyClass extends Hookified {
   constructor() {
-    super();
+    super({ enforceBeforeAfter: true });
   }
+}
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    await this.hook('before:myMethodWithHooks', data);
-    
-    // do something here with the data
-    data.some = 'new data';
+const myClass = new MyClass();
 
-    await this.hook('after:myMethodWithHooks', data);
+console.log(myClass.enforceBeforeAfter); // true
 
-    return data;
-  }
+// These will work fine
+myClass.onHook({ event: 'beforeSave', handler: async () => {
+  console.log('Before save hook');
+}});
+
+myClass.onHook({ event: 'afterSave', handler: async () => {
+  console.log('After save hook');
+}});
+
+myClass.onHook({ event: 'before:validation', handler: async () => {
+  console.log('Before validation hook');
+}});
+
+// This will throw an error
+try {
+  myClass.onHook({ event: 'customEvent', handler: async () => {
+    console.log('This will not work');
+  }});
+} catch (error) {
+  console.log(error.message); // Hook event "customEvent" must start with "before" or "after" when enforceBeforeAfter is enabled
 }
 
-const myClass = new MyClass();
-const hooks = [
-  {
-    event: 'before:myMethodWithHooks',
-    handler: async (data) => {
-      data.some = 'new data1';
-    },
-  },
-  {
-    event: 'after:myMethodWithHooks',
-    handler: async (data) => {
-      data.some = 'new data2';
-    },
-  },
-];
+// You can also change it dynamically
+myClass.enforceBeforeAfter = false;
+myClass.onHook({ event: 'customEvent', handler: async () => {
+  console.log('This will work now');
+}});
 ```
 
-## .onceHook(eventName, handler)
+The validation applies to all hook-related methods:
+- `onHook()`, `addHook()`, `onHooks()`
+- `prependHook()`, `onceHook()`, `prependOnceHook()`
+- `hook()`, `callHook()`
+- `getHooks()`, `removeHook()`, `removeHooks()`
+
+Note: The `beforeHook()` and `afterHook()` helper methods automatically generate proper hook names and work regardless of the `enforceBeforeAfter` setting.
 
-Subscribe to a hook event once.
+## .eventLogger
+If set, errors thrown in hooks will be logged to the logger. If not set, errors will be only emitted.
 
 ```javascript
-import { Hookified } from 'hookified';
+import pino from 'pino';
 
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+const myClass = new MyClass({ eventLogger: pino() });
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // do something
-    await this.hook('before:myMethod2', data);
+myClass.onHook({ event: 'before:myMethod2', handler: async () => {
+  throw new Error('error');
+}});
 
-    return data;
-  }
-}
+// when you call before:myMethod2 it will log the error to the logger
+await myClass.hook('before:myMethod2');
+```
 
-const myClass = new MyClass();
+## .hooks
 
-myClass.onHookOnce('before:myMethod2', async (data) => {
-  data.some = 'new data';
-});
+Get all hooks. Returns a `Map<string, IHook[]>` where each key is an event name and the value is an array of `IHook` objects.
 
-myClass.myMethodWithHooks();
+```javascript
+myClass.onHook({ event: 'before:myMethod2', handler: async (data) => {
+  data.some = 'new data';
+}});
 
-console.log(myClass.hooks.length); // 0
+console.log(myClass.hooks); // Map { 'before:myMethod2' => [{ event: 'before:myMethod2', handler: [Function] }] }
 ```
 
-## .prependHook(eventName, handler)
+## .throwOnHookError
 
-Subscribe to a hook event before all other hooks.
+If set to true, errors thrown in hooks will be thrown. If set to false, errors will be only emitted.
 
 ```javascript
-import { Hookified } from 'hookified';
+const myClass = new MyClass({ throwOnHookError: true });
 
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+console.log(myClass.throwOnHookError); // true
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // do something
-    await this.hook('before:myMethod2', data);
+try {
+  myClass.onHook({ event: 'error-event', handler: async () => {
+    throw new Error('error');
+  }});
 
-    return data;
-  }
+  await myClass.hook('error-event');
+} catch (error) {
+  console.log(error.message); // error
 }
 
-const myClass = new MyClass();
-myClass.onHook('before:myMethod2', async (data) => {
-  data.some = 'new data';
-});
-myClass.preHook('before:myMethod2', async (data) => {
-  data.some = 'will run before new data';
-});
+myClass.throwOnHookError = false;
+console.log(myClass.throwOnHookError); // false
 ```
 
-## .prependOnceHook(eventName, handler)
+## .useHookClone
 
-Subscribe to a hook event before all other hooks. After it is used once it will be removed.
+Controls whether hook objects are cloned before storing internally. Default is `true`. When `true`, a shallow copy of the `IHook` object is stored, preventing external mutation from affecting registered hooks. When `false`, the original reference is stored directly.
 
 ```javascript
-import { Hookified } from 'hookified';
+const myClass = new MyClass({ useHookClone: false });
 
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+const hook = { event: 'before:save', handler: async (data) => {} };
+myClass.onHook(hook);
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // do something
-    await this.hook('before:myMethod2', data);
+// With useHookClone: false, the stored hook is the same reference
+const storedHooks = myClass.getHooks('before:save');
+console.log(storedHooks[0] === hook); // true
 
-    return data;
-  }
-}
+// You can dynamically change the setting
+myClass.useHookClone = true;
+```
 
-const myClass = new MyClass();
-myClass.onHook('before:myMethod2', async (data) => {
+## .addHook(event, handler)
+
+This is an alias for `.onHook()` that takes an event name and handler function directly.
+
+```javascript
+myClass.addHook('before:myMethod2', async (data) => {
   data.some = 'new data';
 });
-myClass.preHook('before:myMethod2', async (data) => {
-  data.some = 'will run before new data';
-});
 ```
 
-## .removeHook(eventName)
+## .afterHook(eventName, ...args)
 
-Unsubscribe from a hook event.
+This is a helper function that will prepend a hook name with `after:`.
 
 ```javascript
-import { Hookified } from 'hookified';
+// Inside your class method — the event name will be `after:myMethod2`
+await this.afterHook('myMethod2', data);
+```
 
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+## .beforeHook(eventName, ...args)
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // do something
-    await this.hook('before:myMethod2', data);
+This is a helper function that will prepend a hook name with `before:`.
 
-    return data;
-  }
-}
+```javascript
+// Inside your class method — the event name will be `before:myMethod2`
+await this.beforeHook('myMethod2', data);
+```
 
-const myClass = new MyClass();
-const handler = async (data) => {
-  data.some = 'new data';
-};
+## .callHook(eventName, ...args)
 
-myClass.onHook('before:myMethod2', handler);
+This is an alias for `.hook(eventName, ...args)` for backwards compatibility.
 
-myClass.removeHook('before:myMethod2', handler);
-```
+## .clearHooks()
 
-## .removeHooks(Array)
-Unsubscribe from multiple hooks.
+Clear all hooks across all events.
 
 ```javascript
-import { Hookified } from 'hookified';
+myClass.onHook({ event: 'before:myMethod2', handler: async (data) => {
+  data.some = 'new data';
+}});
 
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+myClass.clearHooks();
+```
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    await this.hook('before:myMethodWithHooks', data);
-    
-    // do something
-    data.some = 'new data';
-    await this.hook('after:myMethodWithHooks', data);
+## .getHook(id)
 
-    return data;
-  }
-}
+Get a specific hook by `id`, searching across all events. Returns the `IHook` if found, or `undefined`.
 
+```javascript
 const myClass = new MyClass();
 
-const hooks = [
-  {
-    event: 'before:myMethodWithHooks',
-    handler: async (data) => {
-      data.some = 'new data1';
-    },
-  },
-  {
-    event: 'after:myMethodWithHooks',
-    handler: async (data) => {
-      data.some = 'new data2';
-    },
-  },
-];
-myClass.onHooks(hooks);
+myClass.onHook({
+  id: 'my-hook',
+  event: 'before:save',
+  handler: async (data) => { data.validated = true; },
+});
 
-// remove all hooks
-myClass.removeHook(hooks);
+const hook = myClass.getHook('my-hook');
+console.log(hook?.id); // 'my-hook'
+console.log(hook?.event); // 'before:save'
+console.log(hook?.handler); // [Function]
 ```
 
-## .hook(eventName, ...args)
+## .getHooks(eventName)
 
-Run a hook event.
+Get all hooks for an event. Returns an `IHook[]` array, or `undefined` if no hooks are registered for the event.
 
 ```javascript
-import { Hookified } from 'hookified';
+myClass.onHook({ event: 'before:myMethod2', handler: async (data) => {
+  data.some = 'new data';
+}});
 
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+console.log(myClass.getHooks('before:myMethod2')); // [{ event: 'before:myMethod2', handler: [Function] }]
+```
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // do something
-    await this.hook('before:myMethod2', data);
+## .hook(eventName, ...args)
 
-    return data;
-  }
-}
+Run a hook event.
+
+```javascript
+// Inside your class method
+await this.hook('before:myMethod2', data);
 ```
 
-in this example we are passing multiple arguments to the hook:
+You can pass multiple arguments to the hook:
 
 ```javascript
-import { Hookified } from 'hookified';
+// Inside your class method
+await this.hook('before:myMethod2', data, data2);
 
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+// The handler receives all arguments
+myClass.onHook({ event: 'before:myMethod2', handler: async (data, data2) => {
+  data.some = 'new data';
+  data2.some = 'new data2';
+}});
+```
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    let data2 = { some: 'data2' };
-    // do something
-    await this.hook('before:myMethod2', data, data2);
+## .hookSync(eventName, ...args)
 
-    return data;
-  }
-}
+Run a hook event synchronously. Async handlers (functions declared with `async` keyword) are silently skipped and only synchronous handlers are executed.
 
-const myClass = new MyClass();
+> **Note:** The `.hook()` method is preferred as it executes both sync and async functions. Use `.hookSync()` only when you specifically need synchronous execution.
 
-myClass.onHook('before:myMethod2', async (data, data2) => {
-  data.some = 'new data';
-  data2.some = 'new data2';
-});
+```javascript
+// This sync handler will execute
+myClass.onHook({ event: 'before:myMethod', handler: (data) => {
+  data.some = 'modified';
+}});
 
-await myClass.myMethodWithHooks();
+// This async handler will be silently skipped
+myClass.onHook({ event: 'before:myMethod', handler: async (data) => {
+  data.some = 'will not run';
+}});
+
+// Inside your class method
+this.hookSync('before:myMethod', data); // Only sync handler runs
 ```
 
-## .callHook(eventName, ...args)
+## .onHook(hook, options?)
 
-This is an alias for `.hook(eventName, ...args)` for backwards compatibility.
+Subscribe to a hook event. Takes an `IHook` object and an optional `OnHookOptions` object. Returns the stored `IHook` (with `id` assigned), or `undefined` if the hook was blocked by deprecation. The returned reference is the exact object stored internally, which is useful for later removal with `.removeHook()` or `.removeHookById()`. To register multiple hooks at once, use `.onHooks()`.
 
-## .beforeHook(eventName, ...args)
+If the hook has an `id`, it will be used as-is. If not, a UUID is auto-generated via `crypto.randomUUID()`. If a hook with the same `id` already exists on the same event, it will be **replaced in-place** (preserving its position in the array).
 
-This is a helper function that will prepend a hook name with `before:`.
+**Options (`OnHookOptions`)**:
+- `useHookClone` (boolean, optional) — Per-call override for the instance-level `useHookClone` setting. When `true`, the hook object is cloned before storing. When `false`, the original reference is stored directly. When omitted, falls back to the instance-level setting.
+- `position` (`"Top"` | `"Bottom"` | `number`, optional) — Controls where the hook is inserted in the handlers array. `"Top"` inserts at the beginning, `"Bottom"` appends to the end (default). A number inserts at that index, clamped to the array bounds.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
-
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // the event name will be `before:myMethod2`
-    await this.beforeHook('myMethod2', data);
+// Single hook — returns the stored IHook with id
+const stored = myClass.onHook({
+  event: 'before:myMethod2',
+  handler: async (data) => {
+    data.some = 'new data';
+  },
+});
+console.log(stored.id); // auto-generated UUID
 
-    return data;
-  }
-}
-```
+// With a custom id
+const stored2 = myClass.onHook({
+  id: 'my-validation',
+  event: 'before:save',
+  handler: async (data) => { data.validated = true; },
+});
 
-## .afterHook(eventName, ...args)
+// Replace hook by registering with the same id
+myClass.onHook({
+  id: 'my-validation',
+  event: 'before:save',
+  handler: async (data) => { data.validated = true; data.extra = true; },
+});
+// Only one hook with id 'my-validation' exists, at the same position
 
-This is a helper function that will prepend a hook name with `after:`.
+// Remove by id
+myClass.removeHookById('my-validation');
 
-```javascript
-import { Hookified } from 'hookified';
+// Use the returned reference to remove the hook later
+myClass.removeHook(stored);
 
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+// Override useHookClone per-call — store original reference even though instance default is true
+const hook = { event: 'before:save', handler: async (data) => {} };
+myClass.onHook(hook, { useHookClone: false });
+console.log(myClass.getHooks('before:save')[0] === hook); // true
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // the event name will be `after:myMethod2`
-    await this.afterHook('myMethod2', data);
+// Insert at the top of the handlers array
+myClass.onHook({ event: 'before:save', handler: async (data) => {} }, { position: 'Top' });
 
-    return data;
-  }
-}
+// Insert at a specific index
+myClass.onHook({ event: 'before:save', handler: async (data) => {} }, { position: 1 });
 ```
 
-## .hookSync(eventName, ...args)
+## .onHooks(Array, options?)
 
-Run a hook event synchronously. Async handlers (functions declared with `async` keyword) are silently skipped and only synchronous handlers are executed.
-
-> **Note:** The `.hook()` method is preferred as it executes both sync and async functions. Use `.hookSync()` only when you specifically need synchronous execution.
+Subscribe to multiple hook events at once. Takes an array of `IHook` objects and an optional `OnHookOptions` object that is applied to each hook.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+const hooks = [
+  {
+    event: 'before:myMethodWithHooks',
+    handler: async (data) => {
+      data.some = 'new data1';
+    },
+  },
+  {
+    event: 'after:myMethodWithHooks',
+    handler: async (data) => {
+      data.some = 'new data2';
+    },
+  },
+];
+myClass.onHooks(hooks);
 
-  myMethodWithSyncHooks() {
-    let data = { some: 'data' };
-    // Only synchronous handlers will execute
-    this.hookSync('before:myMethod', data);
+// With options — insert all hooks at the top
+myClass.onHooks(hooks, { position: 'Top' });
 
-    return data;
-  }
-}
+// With options — skip cloning for all hooks in this batch
+myClass.onHooks(hooks, { useHookClone: false });
+```
 
-const myClass = new MyClass();
+## .onceHook(hook)
 
-// This sync handler will execute
-myClass.onHook('before:myMethod', (data) => {
-  data.some = 'modified';
-});
+Subscribe to a hook event once. Takes an `IHook` object with `event` and `handler` properties. After the handler is called once, it is automatically removed.
 
-// This async handler will be silently skipped
-myClass.onHook('before:myMethod', async (data) => {
-  data.some = 'will not run';
-});
+```javascript
+myClass.onceHook({ event: 'before:myMethod2', handler: async (data) => {
+  data.some = 'new data';
+}});
 
-myClass.myMethodWithSyncHooks(); // Only sync handler runs
+await myClass.hook('before:myMethod2', data); // handler runs once then is removed
+console.log(myClass.hooks.size); // 0
 ```
 
-## .hooks
+## .prependHook(hook, options?)
 
-Get all hooks.
+Subscribe to a hook event before all other hooks. Takes an `IHook` object with `event` and `handler` properties. Returns the stored `IHook` (with generated `id`), or `undefined` if blocked by deprecation. Equivalent to calling `onHook(hook, { position: "Top" })`.
+
+An optional `PrependHookOptions` object can be passed with:
+- `useHookClone` (boolean) — per-call override for hook cloning behavior
 
 ```javascript
-import { Hookified } from 'hookified';
+myClass.onHook({ event: 'before:myMethod2', handler: async (data) => {
+  data.some = 'new data';
+}});
+myClass.prependHook({ event: 'before:myMethod2', handler: async (data) => {
+  data.some = 'will run before new data';
+}});
+```
 
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+## .prependOnceHook(hook, options?)
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // do something
-    await this.hook('before:myMethod2', data);
+Subscribe to a hook event before all other hooks. Takes an `IHook` object with `event` and `handler` properties. After the handler is called once, it is automatically removed. Returns the stored `IHook` (with generated `id`), or `undefined` if blocked by deprecation.
 
-    return data;
-  }
-}
+An optional `PrependHookOptions` object can be passed with:
+- `useHookClone` (boolean) — per-call override for hook cloning behavior
 
-const myClass = new MyClass();
-myClass.onHook('before:myMethod2', async (data) => {
+```javascript
+myClass.onHook({ event: 'before:myMethod2', handler: async (data) => {
   data.some = 'new data';
-});
-
-console.log(myClass.hooks);
+}});
+myClass.prependOnceHook({ event: 'before:myMethod2', handler: async (data) => {
+  data.some = 'will run before new data';
+}});
 ```
 
-## .getHooks(eventName)
+## .removeEventHooks(eventName)
 
-Get all hooks for an event.
+Removes all hooks for a specific event and returns the removed hooks as an `IHook[]` array. Returns an empty array if no hooks are registered for the event.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+myClass.onHook({ event: 'before:myMethod2', handler: async (data) => {
+  data.some = 'new data';
+}});
+myClass.onHook({ event: 'before:myMethod2', handler: async (data) => {
+  data.some = 'more data';
+}});
+
+// Remove all hooks for a specific event
+const removed = myClass.removeEventHooks('before:myMethod2');
+console.log(removed.length); // 2
+```
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // do something
-    await this.hook('before:myMethod2', data);
+## .removeHook(hook)
 
-    return data;
-  }
-}
+Unsubscribe a handler from a hook event. Takes an `IHook` object with `event` and `handler` properties. Returns the removed hook as an `IHook` object, or `undefined` if the handler was not found.
 
-const myClass = new MyClass();
-myClass.onHook('before:myMethod2', async (data) => {
+```javascript
+const handler = async (data) => {
   data.some = 'new data';
-});
+};
+
+myClass.onHook({ event: 'before:myMethod2', handler });
 
-console.log(myClass.getHooks('before:myMethod2'));
+const removed = myClass.removeHook({ event: 'before:myMethod2', handler });
+console.log(removed); // { event: 'before:myMethod2', handler: [Function] }
 ```
 
-## .clearHooks(eventName)
+## .removeHookById(id)
+
+Remove one or more hooks by `id`, searching across all events. Accepts a single `string` or an array of `string` ids.
 
-Clear all hooks for an event.
+- **Single id**: Returns the removed `IHook`, or `undefined` if not found.
+- **Array of ids**: Returns an `IHook[]` array of the hooks that were successfully removed.
+
+When the last hook for an event is removed, the event key is cleaned up.
 
 ```javascript
-import { Hookified } from 'hookified';
+const myClass = new MyClass();
 
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+myClass.onHook({ id: 'hook-a', event: 'before:save', handler: async () => {} });
+myClass.onHook({ id: 'hook-b', event: 'after:save', handler: async () => {} });
+myClass.onHook({ id: 'hook-c', event: 'before:save', handler: async () => {} });
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // do something
-    await this.hook('before:myMethod2', data);
+// Remove a single hook by id
+const removed = myClass.removeHookById('hook-a');
+console.log(removed?.id); // 'hook-a'
 
-    return data;
-  }
-}
+// Remove multiple hooks by ids
+const removedMany = myClass.removeHookById(['hook-b', 'hook-c']);
+console.log(removedMany.length); // 2
+```
 
-const myClass = new MyClass();
+## .removeHooks(Array)
 
-myClass.onHook('before:myMethod2', async (data) => {
-  data.some = 'new data';
-});
+Unsubscribe from multiple hooks. Returns an array of the hooks that were successfully removed.
+
+```javascript
+const hooks = [
+  { event: 'before:save', handler: async (data) => { data.some = 'new data1'; } },
+  { event: 'after:save', handler: async (data) => { data.some = 'new data2'; } },
+];
+myClass.onHooks(hooks);
 
-myClass.clearHooks('before:myMethod2');
+const removed = myClass.removeHooks(hooks);
+console.log(removed.length); // 2
 ```
 
 # API - Events
 
+> All examples below assume the following setup unless otherwise noted:
+> ```javascript
+> import { Hookified } from 'hookified';
+> class MyClass extends Hookified {
+>   constructor(options) { super(options); }
+> }
+> const myClass = new MyClass();
+> ```
+
 ## .throwOnEmitError
 
-If set to true, errors emitted as `error` will be thrown if there are no listeners. If set to false, errors will be only emitted.
+If set to true, errors emitted as `error` will always be thrown, even if there are listeners. If set to false (default), errors will only be emitted to listeners.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
+const myClass = new MyClass({ throwOnEmitError: true });
 
-  async myMethodWithHooks() Promise<any> {
-    let data = { some: 'data' };
-    // do something
-    await this.hook('before:myMethod2', data);
+myClass.on('error', (err) => {
+  console.log('listener received:', err.message);
+});
 
-    return data;
-  }
+try {
+  myClass.emit('error', new Error('This will throw despite having a listener'));
+} catch (error) {
+  console.log(error.message); // This will throw despite having a listener
 }
 ```
 
 ## .throwOnEmptyListeners
 
-If set to true, errors will be thrown when emitting an `error` event with no listeners. This follows the standard Node.js EventEmitter behavior. Default is false. In version 2, this will be set to true by default.
+If set to true, errors will be thrown when emitting an `error` event with no listeners. This follows the standard Node.js EventEmitter behavior. Default is `true`.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super({ throwOnEmptyListeners: true });
-  }
-}
-
-const myClass = new MyClass();
+const myClass = new MyClass({ throwOnEmptyListeners: true });
 
-console.log(myClass.throwOnEmptyListeners); // true
+console.log(myClass.throwOnEmptyListeners); // true (default)
 
 // This will throw because there are no error listeners
 try {
@@ -999,20 +998,6 @@ When both are set to `true`, `throwOnEmitError` takes precedence.
 Subscribe to an event.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
-
-  async myMethodEmittingEvent() {
-    this.emit('message', 'Hello World');
-  }
-}
-
-const myClass = new MyClass();
-
 myClass.on('message', (message) => {
   console.log(message);
 });
@@ -1023,26 +1008,12 @@ myClass.on('message', (message) => {
 Unsubscribe from an event.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
-
-  async myMethodEmittingEvent() {
-    this.emit('message', 'Hello World');
-  }
-}
-
-const myClass = new MyClass();
-myClass.on('message', (message) => {
+const handler = (message) => {
   console.log(message);
-});
+};
 
-myClass.off('message', (message) => {
-  console.log(message);
-});
+myClass.on('message', handler);
+myClass.off('message', handler);
 ```
 
 ## .emit(eventName, ...args)
@@ -1050,17 +1021,7 @@ myClass.off('message', (message) => {
 Emit an event.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
-
-  async myMethodEmittingEvent() {
-    this.emit('message', 'Hello World');
-  }
-}
+myClass.emit('message', 'Hello World');
 ```
 
 ## .listeners(eventName)
@@ -1068,20 +1029,6 @@ class MyClass extends Hookified {
 Get all listeners for an event.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
-
-  async myMethodEmittingEvent() {
-    this.emit('message', 'Hello World');
-  }
-}
-
-const myClass = new MyClass();
-
 myClass.on('message', (message) => {
   console.log(message);
 });
@@ -1094,20 +1041,6 @@ console.log(myClass.listeners('message'));
 Remove all listeners for an event.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
-
-  async myMethodEmittingEvent() {
-    this.emit('message', 'Hello World');
-  }
-}
-
-const myClass = new MyClass();
-
 myClass.on('message', (message) => {
   console.log(message);
 });
@@ -1117,23 +1050,9 @@ myClass.removeAllListeners('message');
 
 ## .setMaxListeners(maxListeners: number)
 
-Set the maximum number of listeners and will truncate if there are already too many.
-
-```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
-
-  async myMethodEmittingEvent() {
-    this.emit('message', 'Hello World');
-  }
-}
-
-const myClass = new MyClass();
+Set the maximum number of listeners for a single event. Default is `0` (unlimited). Negative values are treated as `0`. Setting to `0` disables the limit and the warning. When the limit is exceeded, a `MaxListenersExceededWarning` is emitted via `console.warn` but the listener is still added. This matches standard Node.js EventEmitter behavior.
 
+```javascript
 myClass.setMaxListeners(1);
 
 myClass.on('message', (message) => {
@@ -1142,9 +1061,9 @@ myClass.on('message', (message) => {
 
 myClass.on('message', (message) => {
   console.log(message);
-}); // this will not be added and console warning
+}); // warning emitted but listener is still added
 
-console.log(myClass.listenerCount('message')); // 1
+console.log(myClass.listenerCount('message')); // 2
 ```
 
 ## .once(eventName, handler)
@@ -1152,23 +1071,12 @@ console.log(myClass.listenerCount('message')); // 1
 Subscribe to an event once.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
-}
-
-const myClass = new MyClass();
-
 myClass.once('message', (message) => {
   console.log(message);
 });
 
-myClass.emit('message', 'Hello World');
-
-myClass.emit('message', 'Hello World'); // this will not be called
+myClass.emit('message', 'Hello World'); // handler runs
+myClass.emit('message', 'Hello World'); // handler does not run
 ```
 
 ## .prependListener(eventName, handler)
@@ -1176,16 +1084,6 @@ myClass.emit('message', 'Hello World'); // this will not be called
 Prepend a listener to an event. This will be called before any other listeners.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
-}
-
-const myClass = new MyClass();
-
 myClass.prependListener('message', (message) => {
   console.log(message);
 });
@@ -1196,16 +1094,6 @@ myClass.prependListener('message', (message) => {
 Prepend a listener to an event once. This will be called before any other listeners.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
-}
-
-const myClass = new MyClass();
-
 myClass.prependOnceListener('message', (message) => {
   console.log(message);
 });
@@ -1218,38 +1106,18 @@ myClass.emit('message', 'Hello World');
 Get all event names.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
-}
-
-const myClass = new MyClass();
-
 myClass.on('message', (message) => {
   console.log(message);
 });
 
-console.log(myClass.eventNames());
+console.log(myClass.eventNames()); // ['message']
 ```
 
 ## .listenerCount(eventName?)
 
-Get the count of listeners for an event or all events if evenName not provided.
+Get the count of listeners for an event or all events if eventName not provided.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
-}
-
-const myClass = new MyClass();
-
 myClass.on('message', (message) => {
   console.log(message);
 });
@@ -1259,19 +1127,9 @@ console.log(myClass.listenerCount('message')); // 1
 
 ## .rawListeners(eventName?)
 
-Get all listeners for an event or all events if evenName not provided.
+Get all listeners for an event or all events if eventName not provided.
 
 ```javascript
-import { Hookified } from 'hookified';
-
-class MyClass extends Hookified {
-  constructor() {
-    super();
-  }
-}
-
-const myClass = new MyClass();
-
 myClass.on('message', (message) => {
   console.log(message);
 });
@@ -1281,20 +1139,20 @@ console.log(myClass.rawListeners('message'));
 
 # Logging
 
-Hookified integrates logging directly into the event system. When a logger is configured, all emitted events are automatically logged to the appropriate log level based on the event name.
+Hookified integrates logging directly into the event system. When an `eventLogger` is configured, all emitted events are automatically logged to the appropriate log level based on the event name.
 
 ## How It Works
 
-When you emit an event, Hookified automatically sends the event data to the configured logger using the appropriate log method:
+When you emit an event, Hookified automatically sends the event data to the configured `eventLogger` using the appropriate log method:
 
 | Event Name | Logger Method |
 |------------|---------------|
-| `error`    | `logger.error()` |
-| `warn`     | `logger.warn()` |
-| `debug`    | `logger.debug()` |
-| `trace`    | `logger.trace()` |
-| `fatal`    | `logger.fatal()` |
-| Any other  | `logger.info()` |
+| `error`    | `eventLogger.error()` |
+| `warn`     | `eventLogger.warn()` |
+| `debug`    | `eventLogger.debug()` |
+| `trace`    | `eventLogger.trace()` |
+| `fatal`    | `eventLogger.fatal()` |
+| Any other  | `eventLogger.info()` |
 
 The logger receives two arguments:
 1. **message**: A string extracted from the event data (error messages, object messages, or JSON stringified data)
@@ -1325,7 +1183,7 @@ const logger = pino();
 
 class MyService extends Hookified {
   constructor() {
-    super({ logger });
+    super({ eventLogger: logger });
   }
 
   async processData(data) {
@@ -1351,14 +1209,14 @@ service.emit('error', new Error('Failed'));      // -> logger.error()
 service.emit('custom-event', { foo: 'bar' });    // -> logger.info() (default)
 ```
 
-You can also set or change the logger after instantiation:
+You can also set or change the eventLogger after instantiation:
 
 ```javascript
 const service = new MyService();
-service.logger = pino({ level: 'debug' });
+service.eventLogger = pino({ level: 'debug' });
 
-// Or remove the logger
-service.logger = undefined;
+// Or remove the eventLogger
+service.eventLogger = undefined;
 ```
 
 # Benchmarks
@@ -1367,10 +1225,10 @@ We are doing very simple benchmarking to see how this compares to other librarie
 
 ## Hooks
 
-|         name          |  summary  |  ops/sec  |  time/op  |  margin  |  samples  |
-|-----------------------|:---------:|----------:|----------:|:--------:|----------:|
-|  Hookified (v1.14.0)  |    🥇     |       3M  |    318ns  |  ±0.01%  |       3M  |
-|  Hookable (v6.0.1)    |   -57%    |       1M  |    834ns  |  ±0.01%  |       1M  |
+|         name         |  summary  |  ops/sec  |  time/op  |  margin  |  samples  |
+|----------------------|:---------:|----------:|----------:|:--------:|----------:|
+|  Hookified (v2.0.0)  |    🥇     |       5M  |    214ns  |  ±0.01%  |       5M  |
+|  Hookable (v6.0.1)   |   -59%    |       2M  |    567ns  |  ±0.01%  |       2M  |
 
 ## Emits
 
@@ -1378,30 +1236,427 @@ This shows how on par `hookified` is to the native `EventEmitter` and popular `e
 
 |           name            |  summary  |  ops/sec  |  time/op  |  margin  |  samples  |
 |---------------------------|:---------:|----------:|----------:|:--------:|----------:|
-|  Hookified (v1.13.0)      |    🥇     |      12M  |     90ns  |  ±3.17%  |      11M  |
-|  EventEmitter3 (v5.0.1)   |  -0.52%   |      12M  |     89ns  |  ±1.66%  |      11M  |
-|  EventEmitter (v20.17.0)  |   -3.5%   |      12M  |     91ns  |  ±0.42%  |      11M  |
-|  Emittery (v1.2.0)        |   -91%    |       1M  |      1µs  |  ±3.33%  |     959K  |
+|  EventEmitter3 (v5.0.4)   |    🥇     |      14M  |     82ns  |  ±0.02%  |      12M  |
+|  Hookified (v2.0.0)       |   -6.9%   |      13M  |     97ns  |  ±0.02%  |      10M  |
+|  EventEmitter (v24.11.1)  |   -7.2%   |      13M  |     83ns  |  ±0.02%  |      12M  |
+|  Emittery (v1.2.0)        |   -92%    |       1M  |      1µs  |  ±0.01%  |     979K  ||
 
 _Note: the `EventEmitter` version is Nodejs versioning._
 
-# How to Contribute
+# Migrating from v1 to v2
 
-Hookified is written in TypeScript and tests are written in `vitest`. To run the tests, use the following command:
+## Quick Guide
 
-To setup the environment and run the tests:
+v2 overhauls hook storage to use `IHook` objects instead of raw functions. This enables hook IDs, ordering via position, cloning control, and new hook types like `WaterfallHook`. The main change most users will notice is that `onHook` now takes an `IHook` object instead of positional arguments:
 
-```bash
-pnpm i && pnpm test
+```typescript
+// v1 — positional arguments
+hookified.onHook('before:save', async (data) => {});
+
+// v2 — IHook object (or use addHook for positional args)
+hookified.onHook({ event: 'before:save', handler: async (data) => {} });
+hookified.addHook('before:save', async (data) => {}); // still works
 ```
 
-Note that we are using `pnpm` as our package manager. If you don't have it installed, you can install it globally with:
+**Other common changes:**
+
+| v1 | v2 |
+|---|---|
+| `throwHookErrors` | `throwOnHookError` |
+| `logger` | `eventLogger` |
+| `onHookEntry(hook)` | `onHook(hook)` |
+| `HookEntry` type | `IHook` interface |
+| `Hook` type (fn) | `HookFn` type |
+| `getHooks()` returns `HookFn[]` | `getHooks()` returns `IHook[]` |
+| `removeHook(event, handler)` | `removeHook({ event, handler })` |
+
+See below for full details on each change.
+
+**[Breaking Changes](#breaking-changes)**
+- [`throwHookErrors` removed — use `throwOnHookError` instead](#throwhookerrors-removed--use-throwonhookerror-instead)
+- [`throwOnEmptyListeners` now defaults to `true`](#throwonemptylisteners-now-defaults-to-true)
+- [`logger` renamed to `eventLogger`](#logger-renamed-to-eventlogger)
+- [`maxListeners` default changed from `100` to `0` (unlimited) and no longer truncates](#maxlisteners-default-changed-from-100-to-0-unlimited-and-no-longer-truncates)
+- [`onHookEntry` removed — use `onHook` instead](#onhookentry-removed--use-onhook-instead)
+- [`onHook` signature changed](#onhook-signature-changed)
+- [`HookEntry` type and `Hook` type removed](#hookentry-type-and-hook-type-removed)
+- [`removeHook` and `removeHooks` now return removed hooks](#removehook-and-removehooks-now-return-removed-hooks)
+- [`removeHook`, `removeHooks`, and `getHooks` no longer check for deprecated hooks](#removehook-removehooks-and-gethooks-no-longer-check-for-deprecated-hooks)
+- [Internal hook storage now uses `IHook` objects](#internal-hook-storage-now-uses-ihook-objects)
+- [`onceHook`, `prependHook`, `prependOnceHook`, and `removeHook` now take `IHook`](#oncehook-prependhook-prependoncehook-and-removehook-now-take-ihook)
+- [`onHook` now returns the stored hook](#onhook-now-returns-the-stored-hook)
+
+**[New Features](#new-features)**
+- [standard `Hook` class now available](#standard-hook)
+- [`WaterfallHook` class for sequential data transformation pipelines](#waterfallhook-class)
+- [`useHookClone` option](#usehookclone-option)
+- [`onHook` now accepts `OnHookOptions`](#onhook-now-accepts-onhookoptions)
+- [`IHook` now has an `id` property](#ihook-now-has-an-id-property)
+- [`removeEventHooks` method](#removeeventhooks-method)
+
+## Breaking Changes
+
+| Change | Summary |
+|---|---|
+| `throwHookErrors` | Renamed to `throwOnHookError` |
+| `throwOnEmptyListeners` | Default changed from `false` to `true` |
+| `logger` | Renamed to `eventLogger` |
+| `maxListeners` | Default changed from `100` to `0` (unlimited), no longer truncates |
+| `onHookEntry` | Removed — use `onHook` instead |
+| `onHook` signature | Now takes `IHook` object instead of `(event, handler)` |
+| `HookEntry` / `Hook` types | Replaced with `IHook` / `HookFn` |
+| `removeHook` / `removeHooks` | Now return removed hooks; no longer check deprecated status |
+| Internal hook storage | Uses `IHook` objects instead of raw functions |
+| `onceHook`, `prependHook`, etc. | Now take `IHook` instead of `(event, handler)` |
+| `onHook` return | Now returns stored `IHook` (was `void`) |
+
+### `throwHookErrors` removed — use `throwOnHookError` instead
+
+The deprecated `throwHookErrors` option and property has been removed. Use `throwOnHookError` instead.
+
+**Before (v1):**
 
-```bash
-npm install -g pnpm
+```javascript
+super({ throwHookErrors: true });
+myClass.throwHookErrors = false;
 ```
 
-To contribute follow the [Contributing Guidelines](CONTRIBUTING.md) and [Code of Conduct](CODE_OF_CONDUCT.md).
+**After (v2):**
+
+```javascript
+super({ throwOnHookError: true });
+myClass.throwOnHookError = false;
+```
+
+### `throwOnEmptyListeners` now defaults to `true`
+
+The `throwOnEmptyListeners` option now defaults to `true`, matching standard Node.js EventEmitter behavior. Previously it defaulted to `false`. If you emit an `error` event with no listeners registered, an error will now be thrown by default.
+
+**Before (v1):**
+
+```javascript
+const myClass = new MyClass(); // throwOnEmptyListeners defaults to false
+myClass.emit('error', new Error('No throw')); // silently ignored
+```
+
+**After (v2):**
+
+```javascript
+const myClass = new MyClass(); // throwOnEmptyListeners defaults to true
+myClass.emit('error', new Error('This will throw')); // throws!
+
+// To restore v1 behavior:
+const myClass2 = new MyClass({ throwOnEmptyListeners: false });
+```
+
+### `logger` renamed to `eventLogger`
+
+The `logger` option and property has been renamed to `eventLogger` to avoid conflicts with other logger properties in your classes.
+
+**Before (v1):**
+
+```javascript
+super({ logger });
+myClass.logger = pino({ level: 'debug' });
+```
+
+**After (v2):**
+
+```javascript
+super({ eventLogger: logger });
+myClass.eventLogger = pino({ level: 'debug' });
+```
+
+### `maxListeners` default changed from `100` to `0` (unlimited) and no longer truncates
+
+The default maximum number of listeners has changed from `100` to `0` (unlimited). The `MaxListenersExceededWarning` will no longer be emitted unless you explicitly set a limit via `setMaxListeners()`. Additionally, `setMaxListeners()` no longer truncates existing listeners — it only sets the warning threshold, matching standard Node.js EventEmitter behavior.
+
+**Before (v1):**
+
+```javascript
+const myClass = new MyClass(); // maxListeners defaults to 100
+// Warning emitted after adding 100+ listeners to the same event
+// setMaxListeners() would truncate existing listeners exceeding the limit
+```
+
+**After (v2):**
+
+```javascript
+const myClass = new MyClass(); // maxListeners defaults to 0 (unlimited)
+// No warning — unlimited listeners allowed
+// setMaxListeners() only sets warning threshold, never removes listeners
+
+// To restore v1 warning behavior:
+myClass.setMaxListeners(100);
+```
+
+### `onHookEntry` removed — use `onHook` instead
+
+The `onHookEntry` method has been removed. Use `onHook` which now accepts an `IHook` object (or array of `IHook`) directly.
+
+**Before (v1):**
+
+```typescript
+hookified.onHookEntry({ event: 'before:save', handler: async (data) => {} });
+```
+
+**After (v2):**
+
+```typescript
+hookified.onHook({ event: 'before:save', handler: async (data) => {} });
+```
+
+### `onHook` signature changed
+
+`onHook` no longer accepts positional `(event, handler)` arguments. It now takes a single `IHook` object or `Hook` class instance. Use `addHook(event, handler)` if you prefer positional arguments. Use `onHooks()` for bulk registration.
+
+**Before (v1):**
+
+```typescript
+hookified.onHook('before:save', async (data) => {});
+```
+
+**After (v2):**
+
+```typescript
+// Using IHook object
+hookified.onHook({ event: 'before:save', handler: async (data) => {} });
+
+// For multiple hooks, use onHooks
+hookified.onHooks([
+  { event: 'before:save', handler: async (data) => {} },
+  { event: 'after:save', handler: async (data) => {} },
+]);
+
+// Or use addHook for positional args
+hookified.addHook('before:save', async (data) => {});
+```
+
+### `HookEntry` type and `Hook` type removed
+
+The `HookEntry` type has been removed and replaced with the `IHook` interface. The `Hook` type (function type) has been renamed to `HookFn`.
+
+**Before (v1):**
+
+```typescript
+import type { HookEntry, Hook } from 'hookified';
+
+const hook: HookEntry = { event: 'before:save', handler: async () => {} };
+const myHook: Hook = async (data) => {};
+```
+
+**After (v2):**
+
+```typescript
+import type { IHook, HookFn } from 'hookified';
+
+const hook: IHook = { event: 'before:save', handler: async () => {} };
+const myHook: HookFn = async (data) => {};
+```
+
+### `removeHook` and `removeHooks` now return removed hooks
+
+`removeHook` now returns the removed hook as an `IHook` object (or `undefined` if not found). `removeHooks` now returns an `IHook[]` array of the hooks that were successfully removed. Previously both returned `void`.
+
+**Before (v1):**
+
+```typescript
+hookified.removeHook('before:save', handler); // void
+hookified.removeHooks(hooks); // void
+```
+
+**After (v2):**
+
+```typescript
+const removed = hookified.removeHook({ event: 'before:save', handler }); // IHook | undefined
+const removedHooks = hookified.removeHooks(hooks); // IHook[]
+```
+
+### `removeHook`, `removeHooks`, and `getHooks` no longer check for deprecated hooks
+
+Previously, `removeHook`, `removeHooks`, and `getHooks` would skip their operation and emit a deprecation warning when called with a deprecated hook name and `allowDeprecated` was `false`. This made it impossible to clean up or inspect deprecated hooks. These methods now always operate regardless of deprecation status.
+
+### Internal hook storage now uses `IHook` objects
+
+The internal `_hooks` map now stores full `IHook` objects (`Map<string, IHook[]>`) instead of raw handler functions (`Map<string, HookFn[]>`). This means `.hooks` returns `Map<string, IHook[]>` and `.getHooks()` returns `IHook[] | undefined`.
+
+**Before (v1):**
+
+```typescript
+const hooks = myClass.getHooks('before:save'); // HookFn[]
+hooks[0](data); // direct function call
+```
+
+**After (v2):**
+
+```typescript
+const hooks = myClass.getHooks('before:save'); // IHook[]
+hooks[0].handler(data); // access .handler property
+hooks[0].event; // 'before:save'
+```
+
+### `onceHook`, `prependHook`, `prependOnceHook`, and `removeHook` now take `IHook`
+
+These methods now accept an `IHook` object instead of separate `(event, handler)` arguments.
+
+**Before (v1):**
+
+```typescript
+hookified.onceHook('before:save', async (data) => {});
+hookified.prependHook('before:save', async (data) => {});
+hookified.prependOnceHook('before:save', async (data) => {});
+hookified.removeHook('before:save', handler);
+```
+
+**After (v2):**
+
+```typescript
+hookified.onceHook({ event: 'before:save', handler: async (data) => {} });
+hookified.prependHook({ event: 'before:save', handler: async (data) => {} });
+hookified.prependOnceHook({ event: 'before:save', handler: async (data) => {} });
+hookified.removeHook({ event: 'before:save', handler });
+```
+
+### `onHook` now returns the stored hook
+
+`onHook` now returns the stored `IHook` object (or `undefined` if blocked by deprecation). Previously it returned `void`. The returned reference is the exact object stored internally, making it easy to later remove with `removeHook()`.
+
+**Before (v1):**
+
+```typescript
+hookified.onHook({ event: 'before:save', handler }); // void
+```
+
+**After (v2):**
+
+```typescript
+const stored = hookified.onHook({ event: 'before:save', handler }); // IHook | undefined
+hookified.removeHook(stored); // exact reference match
+```
+
+## New Features
+
+### `Hook` class
+
+A new `Hook` class is available for creating hook entries. It implements the `IHook` interface and can be used anywhere `IHook` is accepted.
+
+```typescript
+import { Hook } from 'hookified';
+
+const hook = new Hook('before:save', async (data) => {
+  data.validated = true;
+});
+
+myClass.onHook(hook);
+```
+
+### `WaterfallHook` class
+
+A new `WaterfallHook` class is available for creating sequential data transformation pipelines. It implements the `IHook` interface and integrates directly with `Hookified.onHook()`. Each hook in the chain receives a `WaterfallHookContext` with `initialArgs` (the original arguments) and `results` (an array of `{ hook, result }` entries from all previous hooks).
+
+```typescript
+import { Hookified, WaterfallHook } from 'hookified';
+
+class MyClass extends Hookified {
+  constructor() { super(); }
+}
+
+const myClass = new MyClass();
+
+const wh = new WaterfallHook('save', ({ results }) => {
+  const data = results[results.length - 1].result;
+  console.log('Saved:', data);
+});
+
+wh.addHook(({ initialArgs }) => {
+  return { ...initialArgs, validated: true };
+});
+
+wh.addHook(({ results }) => {
+  return { ...results[results.length - 1].result, timestamp: Date.now() };
+});
+
+myClass.onHook(wh);
+await myClass.hook('save', { name: 'test' });
+// Saved: { name: 'test', validated: true, timestamp: ... }
+```
+
+See the [Waterfall Hook](#waterfallhook) section for full documentation.
+
+### `useHookClone` option
+
+A new `useHookClone` option (default `true`) controls whether hook objects are shallow-cloned before storing. When enabled, external mutation of a registered hook object won't affect the internal state. Set to `false` to store the original reference for performance or when you need reference equality.
+
+```typescript
+class MyClass extends Hookified {
+  constructor() { super({ useHookClone: false }); }
+}
+```
+
+### `onHook` now accepts `OnHookOptions`
+
+`onHook` now accepts an optional second parameter of type `OnHookOptions`. This allows you to override the instance-level `useHookClone` setting and control hook positioning on a per-call basis.
+
+```typescript
+// Override useHookClone for this specific call
+hookified.onHook({ event: 'before:save', handler }, { useHookClone: false });
+
+// Insert at the top of the handlers array instead of the end
+hookified.onHook({ event: 'before:save', handler }, { position: 'Top' });
+
+// Insert at a specific index
+hookified.onHook({ event: 'before:save', handler }, { position: 1 });
+```
+
+### `IHook` now has an `id` property
+
+Every hook now has an optional `id` property. If not provided, a UUID is auto-generated via `crypto.randomUUID()`. The `id` enables easier lookups and removal via the new `getHook(id)` and `removeHookById(id)` methods, which search across all events.
+
+Registering a hook with the same `id` on the same event replaces the existing hook in-place (preserving its position).
+
+```typescript
+// With custom id
+const stored = hookified.onHook({
+  id: 'my-validation',
+  event: 'before:save',
+  handler: async (data) => { data.validated = true; },
+});
+
+// Without id — auto-generated
+const stored2 = hookified.onHook({
+  event: 'before:save',
+  handler: async (data) => {},
+});
+console.log(stored2.id); // e.g. '550e8400-e29b-41d4-a716-446655440000'
+
+// Look up by id (searches all events)
+const hook = hookified.getHook('my-validation');
+
+// Remove by id (searches all events)
+hookified.removeHookById('my-validation');
+
+// Remove multiple by ids
+hookified.removeHookById(['hook-a', 'hook-b']);
+```
+
+The `Hook` class also accepts an optional `id` parameter:
+
+```typescript
+const hook = new Hook('before:save', handler, 'my-custom-id');
+```
+
+### `removeEventHooks` method
+
+A new `removeEventHooks(event)` method removes all hooks for a specific event and returns the removed hooks as an `IHook[]` array.
+
+```typescript
+const removed = hookified.removeEventHooks('before:save');
+console.log(removed.length); // number of hooks removed
+```
+
+# How to Contribute
+
+Hookified is written in TypeScript and tests are written with `vitest`. To setup the environment and run the tests:
 
 ```bash
 pnpm i && pnpm test
@@ -1418,7 +1673,3 @@ To contribute follow the [Contributing Guidelines](CONTRIBUTING.md) and [Code of
 # License and Copyright
 
 [MIT & © Jared Wray](LICENSE)
-
-
-
-