zephyr-events 1.1.2 → 1.3.0

package/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
 Copyright (c) 2021 Jason Miller
+Copyright (c) 2025 ebogdum
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,211 +1,318 @@
-# 🌪️ Zephyr Events
+# Zephyr Events — Tiny TypeScript Event Emitter
 
-Ultra-fast ES2023 event emitter with **905B** bundle size and race-condition safety.
+A lightweight, type-safe event emitter for TypeScript and JavaScript. Zero dependencies, under 2KB, with built-in race-condition safety that larger alternatives like EventEmitter3 and Node.js EventEmitter lack.
 
 [![npm version](https://img.shields.io/npm/v/zephyr-events.svg)](https://www.npmjs.com/package/zephyr-events)
-[![Bundle Size](https://img.shields.io/badge/size-905B-brightgreen.svg)](https://bundlephobia.com/package/zephyr-events)
+[![npm downloads](https://img.shields.io/npm/dm/zephyr-events.svg)](https://www.npmjs.com/package/zephyr-events)
+[![bundle size](https://img.shields.io/bundlephobia/minzip/zephyr-events)](https://bundlephobia.com/package/zephyr-events)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.x-blue.svg)](https://www.typescriptlang.org/)
+[![license](https://img.shields.io/npm/l/zephyr-events.svg)](https://github.com/ebogdum/zephyr-events/blob/main/LICENSE)
 
----
+## Why Zephyr Events?
 
-## ⚡ Key Features
+Most event emitter libraries break when handlers modify the listener list during emission — a handler that calls `off()` on itself can skip the next handler, or adding a new listener mid-emit can cause infinite loops. Zephyr Events solves this with snapshot-based iteration, making it safe for real-world use in UI frameworks, state machines, and plugin systems.
 
-- **🔥 Ultra Fast**: 33M+ operations/second with native Set/Map optimizations
-- **🪶 Tiny Bundle**: Only 905B minified, 0 dependencies  
-- **🛡️ Race-Condition Safe**: Immutable snapshots prevent handler modification issues
-- **🎯 ES2023 Native**: Optional chaining, nullish coalescing, spread operators
-- **📦 Tree Shakeable**: ES modules with proper exports
-- **🔧 TypeScript**: Full type safety with generics and strict types
+- **Under 2KB** — 1.9KB ESM, zero dependencies, tree-shakeable
+- **Race-condition safe** — handlers can subscribe, unsubscribe, or clear during emit without side effects
+- **Fast mode** — `zephyrEventsFast` drops snapshot safety for up to 82% faster emit
+- **Full TypeScript support** — generic event maps, strict handler signatures, IDE autocompletion
+- **Universal builds** — ESM, CommonJS, and UMD for browsers, Node.js, and bundlers
+- **Wildcard listeners** — subscribe to all events with `*`
+- **Shared state** — pass a handler map between emitters for cross-module communication
 
----
-
-## 📥 Installation
+## Installation
 
 ```bash
 npm install zephyr-events
 ```
 
----
+```bash
+yarn add zephyr-events
+```
+
+```bash
+pnpm add zephyr-events
+```
+
+## Quick Start
 
-## 🚀 Quick Start
+### TypeScript Event Emitter
 
 ```typescript
 import zephyrEvents from 'zephyr-events';
 
-// Create typed emitter
-type Events = {
-  user: { id: number; name: string }
-  error: Error
+// Define your event types
+type AppEvents = {
+  'user:login': { id: number; name: string }
+  'user:logout': { id: number }
+  'error': Error
 }
 
-const emitter = zephyrEvents<Events>();
+const emitter = zephyrEvents<AppEvents>();
 
-// Subscribe with auto-cleanup
-const unsubscribe = emitter.on('user', (user) => {
-  console.log(`User: ${user.name}`);
+// Subscribe — returns an unsubscribe function for easy cleanup
+const unsubscribe = emitter.on('user:login', (user) => {
+  console.log(`Welcome, ${user.name}`);
 });
 
-// Emit events
-emitter.emit('user', { id: 1, name: 'Alice' });
+// Emit with full type checking
+emitter.emit('user:login', { id: 1, name: 'Alice' });
 
-// Cleanup
+// Clean up when done
 unsubscribe();
 ```
 
----
+### Fast Mode
 
-## 🎨 API Reference
+When handlers never modify the listener list during emit, use `zephyrEventsFast` for maximum throughput:
 
-### `zephyrEvents<Events>()`
+```typescript
+import { zephyrEventsFast } from 'zephyr-events';
+
+const emitter = zephyrEventsFast<AppEvents>();
+// Same API — on(), off(), emit(), all
+```
 
-Create a new event emitter instance.
+### JavaScript Event Emitter
+
+```javascript
+const zephyrEvents = require('zephyr-events');
+const { zephyrEventsFast } = require('zephyr-events');
+
+const emitter = zephyrEvents();       // safe (snapshot)
+const fast = zephyrEventsFast();       // fast (no snapshot)
+
+emitter.on('message', (data) => {
+  console.log('Received:', data);
+});
+
+emitter.emit('message', { text: 'Hello' });
+```
+
+## API Reference
+
+### `zephyrEvents<Events>(all?)`
+
+Creates a new typed event emitter with snapshot-safe emission. Optionally accepts an existing handler map to share event state between emitters.
 
 ```typescript
 const emitter = zephyrEvents<{
   message: string
   data: { value: number }
 }>();
+
+// Share handlers between emitters
+const shared = new Map();
+const emitterA = zephyrEvents(shared);
+const emitterB = zephyrEvents(shared);
 ```
 
-### `emitter.on(type, handler)`
+### `zephyrEventsFast<Events>(all?)`
 
-Register event handler. Returns unsubscribe function.
+Creates a non-snapshot event emitter. Same API as `zephyrEvents`, but `emit()` iterates the live handler array instead of a copy. Up to 82% faster for single-handler emit. Use when handlers do not add/remove listeners during emission.
 
 ```typescript
+import { zephyrEventsFast } from 'zephyr-events';
+
+const emitter = zephyrEventsFast<{ tick: number }>();
+```
+
+### `emitter.on(type, handler): Unsubscribe`
+
+Registers an event handler. Returns an unsubscribe function for automatic cleanup — no need to keep a reference to the handler.
+
+```typescript
+// Type-safe subscription
 const unsub = emitter.on('message', (msg) => {
   console.log(msg);
 });
 
-// Wildcard listener
+// Wildcard listener — receives every event
 emitter.on('*', (type, event) => {
-  console.log(`Event ${type}:`, event);
+  console.log(`[${String(type)}]`, event);
 });
+
+// Unsubscribe when no longer needed
+unsub();
 ```
 
 ### `emitter.off(type, handler?)`
 
-Remove event handler(s).
+Removes a specific handler, or all handlers for an event type.
 
 ```typescript
-// Remove specific handler
-emitter.off('message', handler);
+// Remove a specific handler
+emitter.off('message', myHandler);
 
-// Remove all handlers for type
+// Remove all handlers for an event type
 emitter.off('message');
 ```
 
 ### `emitter.emit(type, event)`
 
-Emit event to all registered handlers.
+Emits an event to all registered handlers. Handlers run synchronously from a snapshot, so the listener list can be safely modified during emission.
 
 ```typescript
 emitter.emit('message', 'Hello World!');
 emitter.emit('data', { value: 42 });
 ```
 
----
+### `emitter.all`
+
+The underlying `Map<EventType, Handler[]>` that stores all registered handlers. Can be inspected, serialized, or shared between emitter instances.
 
-## 🏗️ Technical Details
+## Use Cases
 
-### Architecture
+### Event Bus for React Components
+
+```typescript
+import zephyrEvents from 'zephyr-events';
 
-Zephyr Events uses a **dual-storage architecture** for maximum performance:
+type UIEvents = {
+  'modal:open': { id: string }
+  'modal:close': { id: string }
+  'toast': { message: string; severity: 'info' | 'error' }
+}
 
-- **Set**: O(1) add/remove operations
-- **Array snapshots**: Fast iteration with race-condition safety
-- **ES2023 optimizations**: Native optional chaining and nullish coalescing
+// Create a shared event bus
+export const uiBus = zephyrEvents<UIEvents>();
 
-### Race-Condition Safety
+// In a React component — clean up on unmount
+useEffect(() => {
+  const unsub = uiBus.on('toast', (toast) => {
+    showToast(toast.message, toast.severity);
+  });
+  return unsub;
+}, []);
+```
 
-Handlers are executed from immutable snapshots:
+### Pub/Sub in Node.js Microservices
 
 ```typescript
-emitter.on('test', function selfRemover() {
-  emitter.off('test', selfRemover); // Safe during emit
+import zephyrEvents from 'zephyr-events';
+
+type ServiceEvents = {
+  'order:created': { orderId: string; total: number }
+  'order:shipped': { orderId: string; trackingId: string }
+  'inventory:low': { sku: string; remaining: number }
+}
+
+const events = zephyrEvents<ServiceEvents>();
+
+// Multiple subscribers
+events.on('order:created', sendConfirmationEmail);
+events.on('order:created', updateAnalytics);
+events.on('inventory:low', notifyWarehouse);
+
+// Audit logging with wildcard
+events.on('*', (type, data) => {
+  logger.info({ event: type, payload: data });
 });
 ```
 
-### ES2023 Features
+### Plugin System
+
+```typescript
+import zephyrEvents from 'zephyr-events';
 
-- **Nullish coalescing**: `all ??= new Map()`
-- **Optional chaining**: `handlers?.size`
-- **Spread operators**: `[...handlers]` for fast snapshots
+type PluginEvents = {
+  'init': { config: Record<string, unknown> }
+  'transform': { input: string }
+  'destroy': undefined
+}
 
-### Bundle Formats
+function createPluginHost() {
+  const emitter = zephyrEvents<PluginEvents>();
 
-- **ESM**: `dist/zephyr-events.mjs` (905B)
-- **CommonJS**: `dist/zephyr-events.js` (977B) 
-- **UMD**: `dist/zephyr-events.umd.js` (1.3KB)
+  return {
+    register(plugin: (on: typeof emitter.on) => void) {
+      plugin(emitter.on.bind(emitter));
+    },
+    emit: emitter.emit.bind(emitter),
+  };
+}
+```
 
----
+## Race-Condition Safety
 
-## 🆚 Comparison
+Unlike most event emitters, Zephyr Events handles listener modification during emission safely. Each `emit()` call iterates over a snapshot of the handler list, so adding or removing handlers mid-emit never causes skipped handlers or infinite loops:
 
-| Feature | Zephyr Events | mitt* | eventemitter3 |
-|---------|---------------|------|---------------|
-| Bundle Size | 905B | 200B | 7KB |
-| TypeScript | ✅ Native | ✅ | ✅ |
-| Race-Safe | ✅ | ❌ | ❌ |
-| ES2023 | ✅ | ❌ | ❌ |
-| Performance | 33M ops/s | 15M ops/s | 10M ops/s |
+```typescript
+const emitter = zephyrEvents();
 
-*\*Based on original mitt package by Jason Miller*
+// Safe: handler removes itself during emit
+emitter.on('data', function once(data) {
+  emitter.off('data', once);
+  process(data); // next handler still fires
+});
 
----
+// Safe: handler adds new listeners during emit
+emitter.on('init', () => {
+  emitter.on('init', () => {
+    // this will NOT fire during the current emit cycle
+  });
+});
+```
 
-## 🚀 Performance Benchmarks
+## Comparison with Other Event Emitters
 
-Comprehensive performance benchmarks on **Apple Silicon M-series (ARM64)** with **Node.js v23.10.0**:
+| Feature | Zephyr Events | mitt | EventEmitter3 | Node.js EventEmitter |
+|---------|:---:|:---:|:---:|:---:|
+| Bundle size | ~2KB | ~200B | ~7KB | Built-in |
+| TypeScript types | Native | Native | Bundled | `@types/node` |
+| Race-condition safe | Yes | No | No | No |
+| Fast (no-snapshot) mode | Yes | No | No | No |
+| Wildcard listeners | Yes | Yes | No | No |
+| Unsubscribe function | Yes | No | No | No |
+| Shared handler maps | Yes | Yes | No | No |
+| Zero dependencies | Yes | Yes | Yes | N/A |
+| Tree-shakeable ESM | Yes | Yes | Yes | No |
 
-### Core Operations Performance
+## Performance Benchmarks
 
-| Operation | Ops/Second | Description |
-|-----------|------------|-------------|
-| **Emitter Creation** | **10.54M** | Creating new emitter instances |
-| **Single Handler Emit** | **33.69M** | Emitting to one event handler |
-| **Wildcard Emit** | **26.12M** | Emitting to wildcard listeners |
-| **10 Handlers Emit** | **9.32M** | Emitting to 10 concurrent handlers |
-| **100 Handlers Emit** | **1.57M** | Emitting to 100 concurrent handlers |
-| **Mixed Operations** | **7.17M** | Realistic usage: on/emit/off cycle |
+Tested on Apple Silicon M-series (ARM64), Node.js v25.2.1. Median of 3 runs in isolated V8 processes. Run `node benchmark-compare.js` to reproduce.
 
-### Management Operations Performance
+### Safe vs Fast
 
-| Operation | Ops/Second | Description |
-|-----------|------------|-------------|
-| **Off Method** | **194.17M** | Removing specific handler with `.off()` |
-| **Unsubscribe** | **143.54M** | Removing handler with returned function |
-| **Event Subscription** | **9.19K** | Adding new event handlers with `.on()` |
-| **Memory Stress** | **130** | Complex multi-event scenario |
+| Operation | Safe (snapshot) | Fast (no snapshot) | Delta |
+|-----------|----------------:|-------------------:|------:|
+| **Emit (1 handler)** | 49.4M ops/s | 89.9M ops/s | **+82%** |
+| **Emit (10 handlers)** | 14.0M ops/s | 16.9M ops/s | **+21%** |
+| **Emit (100 handlers)** | 1.9M ops/s | 2.1M ops/s | **+12%** |
+| **Wildcard emit** | 38.4M ops/s | 62.7M ops/s | **+63%** |
+| **Emit (no wildcards)** | 36.3M ops/s | 57.5M ops/s | **+59%** |
+| **On + unsub cycle** | 11.0M ops/s | 11.0M ops/s | 0% |
+| **Off (specific handler)** | 11.8M ops/s | 11.7M ops/s | 0% |
+| **Mixed (on/emit/unsub)** | 8.6M ops/s | 9.3M ops/s | **+8%** |
 
-### Key Performance Insights
+All benchmarks use proper setup/run separation with warmup passes. No-op handlers measure emitter overhead only — real-world throughput depends on handler complexity.
 
-- **🔥 Ultra-fast emission**: Up to **33.69M operations/second** for single handlers
-- **⚡ Instant cleanup**: Handler removal at **194.17M operations/second**  
-- **📈 Scales efficiently**: Maintains high performance with multiple handlers
-- **🛡️ Race-condition safe**: Minimal overhead for safety guarantees
-- **🎯 Real-world optimized**: **7.17M ops/sec** for typical usage patterns
+## Bundle Formats
 
-### Architecture Benefits
+Zephyr Events ships three bundle formats for maximum compatibility:
 
-- **Dual Storage**: Set for O(1) add/remove + Array snapshots for fast iteration
-- **ES2023 Native**: Optional chaining (`?.`) and nullish coalescing (`??`) optimizations
-- **Memory Efficient**: Stable performance under stress conditions
-- **Zero Dependencies**: Pure JavaScript with no external overhead
+| Format | File | Use case |
+|--------|------|----------|
+| ESM | `dist/zephyr-events.mjs` | Modern bundlers (Vite, Rollup, webpack 5+) |
+| CommonJS | `dist/zephyr-events.js` | Node.js `require()`, older bundlers |
+| UMD | `dist/zephyr-events.umd.js` | Script tags, AMD loaders, legacy environments |
 
----
+## Requirements
 
-## 🙏 Acknowledgments
+- **Node.js** >= 18
+- **TypeScript** >= 4.7 (for type features; runtime has no TS dependency)
+- Works in all modern browsers (ES2020+ support)
 
-**Zephyr Events** is a heavy modernization and performance upgrade of the original [mitt](https://github.com/developit/mitt) package by [Jason Miller](https://github.com/developit). Thanks for the foundational work!
+## Contributing
 
----
+Contributions are welcome. Please read [CONTRIBUTING.md](CONTRIBUTING.md) before opening a pull request.
 
-## 🤝 Contributing
+## Acknowledgments
 
-Contributions welcome! Please read [CONTRIBUTING.md](CONTRIBUTING.md).
+Zephyr Events is a modernization of [mitt](https://github.com/developit/mitt) by [Jason Miller](https://github.com/developit). Built on the same simple API with added type safety, race-condition handling, and universal module support.
 
-## 📄 License
+## License
 
-MIT © [ebogdum](https://github.com/ebogdum)
+[MIT](LICENSE)
 
-Original mitt: MIT © [Jason Miller](https://github.com/developit)
+Original mitt: MIT (c) [Jason Miller](https://github.com/developit)

package/dist/index.d.ts

@@ -15,3 +15,9 @@ export interface Emitter<Events extends Record<EventType, unknown>> {
     emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
 }
 export default function zephyrEvents<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>): Emitter<Events>;
+/**
+ * Creates a fast, non-snapshot event emitter. Handlers that modify the
+ * listener list during emit may cause skipped or double-fired handlers.
+ * Use when maximum throughput matters and handlers do not mutate listeners.
+ */
+export declare function zephyrEventsFast<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>): Emitter<Events>;

package/dist/index.js

@@ -1,53 +1,154 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = zephyrEvents;
+exports.zephyrEventsFast = zephyrEventsFast;
 function zephyrEvents(all) {
     all ??= new Map();
-    const handlerSets = new Map();
-    const getHandlerSet = (type) => {
-        let handlers = handlerSets.get(type);
-        if (!handlers) {
-            handlers = new Set();
-            handlerSets.set(type, handlers);
-            all.set(type, []);
-        }
-        return handlers;
-    };
-    const syncMap = (type) => {
-        const handlers = handlerSets.get(type);
-        if (handlers) {
-            all.set(type, [...handlers]);
+    let hasWildcards = false;
+    let emitting = 0;
+    return {
+        all,
+        on(type, handler) {
+            let handlers = all.get(type);
+            if (!handlers) {
+                handlers = [];
+                all.set(type, handlers);
+            }
+            handlers.push(handler);
+            if ('*' === type)
+                hasWildcards = true;
+            return () => {
+                const current = all.get(type);
+                if (current) {
+                    const idx = current.indexOf(handler);
+                    if (-1 < idx) {
+                        current.splice(idx, 1);
+                    }
+                    if (0 === current.length) {
+                        all.delete(type);
+                        if ('*' === type)
+                            hasWildcards = false;
+                    }
+                }
+            };
+        },
+        off(type, handler) {
+            const handlers = all.get(type);
+            if (!handlers)
+                return;
+            if (handler) {
+                const idx = handlers.indexOf(handler);
+                if (-1 < idx) {
+                    handlers.splice(idx, 1);
+                }
+                if (0 === handlers.length) {
+                    all.delete(type);
+                    if ('*' === type)
+                        hasWildcards = false;
+                }
+            }
+            else {
+                all.delete(type);
+                if ('*' === type)
+                    hasWildcards = false;
+            }
+        },
+        emit(type, evt) {
+            const handlers = all.get(type);
+            if (handlers) {
+                emitting++;
+                const snapshot = handlers.slice();
+                const len = snapshot.length;
+                for (let i = 0; i < len; i++) {
+                    snapshot[i](evt);
+                }
+                emitting--;
+            }
+            if (hasWildcards && '*' !== type) {
+                const wildcards = all.get('*');
+                if (wildcards) {
+                    emitting++;
+                    const snapshot = wildcards.slice();
+                    const len = snapshot.length;
+                    for (let i = 0; i < len; i++) {
+                        snapshot[i](type, evt);
+                    }
+                    emitting--;
+                }
+            }
         }
     };
+}
+/**
+ * Creates a fast, non-snapshot event emitter. Handlers that modify the
+ * listener list during emit may cause skipped or double-fired handlers.
+ * Use when maximum throughput matters and handlers do not mutate listeners.
+ */
+function zephyrEventsFast(all) {
+    all ??= new Map();
+    let hasWildcards = false;
     return {
         all,
         on(type, handler) {
-            const handlers = getHandlerSet(type);
-            handlers.add(handler);
-            syncMap(type);
+            let handlers = all.get(type);
+            if (!handlers) {
+                handlers = [];
+                all.set(type, handlers);
+            }
+            handlers.push(handler);
+            if ('*' === type)
+                hasWildcards = true;
             return () => {
-                handlers.delete(handler);
-                syncMap(type);
+                const current = all.get(type);
+                if (current) {
+                    const idx = current.indexOf(handler);
+                    if (-1 < idx) {
+                        current.splice(idx, 1);
+                    }
+                    if (0 === current.length) {
+                        all.delete(type);
+                        if ('*' === type)
+                            hasWildcards = false;
+                    }
+                }
             };
         },
         off(type, handler) {
-            const handlers = handlerSets.get(type);
+            const handlers = all.get(type);
             if (!handlers)
                 return;
-            handler ? handlers.delete(handler) : handlers.clear();
-            syncMap(type);
+            if (handler) {
+                const idx = handlers.indexOf(handler);
+                if (-1 < idx) {
+                    handlers.splice(idx, 1);
+                }
+                if (0 === handlers.length) {
+                    all.delete(type);
+                    if ('*' === type)
+                        hasWildcards = false;
+                }
+            }
+            else {
+                all.delete(type);
+                if ('*' === type)
+                    hasWildcards = false;
+            }
         },
         emit(type, evt) {
-            const handlers = handlerSets.get(type);
-            if (handlers?.size) {
-                for (const handler of [...handlers]) {
-                    handler(evt);
+            const handlers = all.get(type);
+            if (handlers) {
+                const len = handlers.length;
+                for (let i = 0; i < len; i++) {
+                    handlers[i](evt);
                 }
             }
-            const wildcards = handlerSets.get('*');
-            if (wildcards?.size) {
-                for (const handler of [...wildcards]) {
-                    handler(type, evt);
+            if (hasWildcards && '*' !== type) {
+                const wildcards = all.get('*');
+                if (wildcards) {
+                    const len = wildcards.length;
+                    for (let i = 0; i < len; i++) {
+                        wildcards[i](type, evt);
+                    }
                 }
             }
         }

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/index.ts"],"version":"5.9.2"}
+{"root":["../src/index.ts"],"version":"5.9.3"}

package/dist/zephyr-events.js

@@ -1 +1,149 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value: true});exports.default=zephyrEvents;function zephyrEvents(all){all ??=new Map();const handlerSets=new Map();const getHandlerSet=(type)=>{let handlers=handlerSets.get(type);if(!handlers){handlers=new Set();handlerSets.set(type,handlers);all.set(type,[]);}return handlers;};const syncMap=(type)=>{const handlers=handlerSets.get(type);if(handlers){all.set(type,[...handlers]);}};return{all,on(type,handler){const handlers=getHandlerSet(type);handlers.add(handler);syncMap(type);return()=>{handlers.delete(handler);syncMap(type);};},off(type,handler){const handlers=handlerSets.get(type);if(!handlers)return;handler ? handlers.delete(handler): handlers.clear();syncMap(type);},emit(type,evt){const handlers=handlerSets.get(type);if(handlers?.size){for(const handler of [...handlers]){handler(evt);}}const wildcards=handlerSets.get('*');if(wildcards?.size){for(const handler of [...wildcards]){handler(type,evt);}}}};}
+"use strict";
+module.exports = function zephyrEvents(all) {
+    all ??= new Map();
+    let hasWildcards = false;
+    let emitting = 0;
+    return {
+        all,
+        on(type, handler) {
+            let handlers = all.get(type);
+            if (!handlers) {
+                handlers = [];
+                all.set(type, handlers);
+            }
+            handlers.push(handler);
+            if ('*' === type)
+                hasWildcards = true;
+            return () => {
+                const current = all.get(type);
+                if (current) {
+                    const idx = current.indexOf(handler);
+                    if (-1 < idx) {
+                        current.splice(idx, 1);
+                    }
+                    if (0 === current.length) {
+                        all.delete(type);
+                        if ('*' === type)
+                            hasWildcards = false;
+                    }
+                }
+            };
+        },
+        off(type, handler) {
+            const handlers = all.get(type);
+            if (!handlers)
+                return;
+            if (handler) {
+                const idx = handlers.indexOf(handler);
+                if (-1 < idx) {
+                    handlers.splice(idx, 1);
+                }
+                if (0 === handlers.length) {
+                    all.delete(type);
+                    if ('*' === type)
+                        hasWildcards = false;
+                }
+            }
+            else {
+                all.delete(type);
+                if ('*' === type)
+                    hasWildcards = false;
+            }
+        },
+        emit(type, evt) {
+            const handlers = all.get(type);
+            if (handlers) {
+                emitting++;
+                const snapshot = handlers.slice();
+                const len = snapshot.length;
+                for (let i = 0; i < len; i++) {
+                    snapshot[i](evt);
+                }
+                emitting--;
+            }
+            if (hasWildcards && '*' !== type) {
+                const wildcards = all.get('*');
+                if (wildcards) {
+                    emitting++;
+                    const snapshot = wildcards.slice();
+                    const len = snapshot.length;
+                    for (let i = 0; i < len; i++) {
+                        snapshot[i](type, evt);
+                    }
+                    emitting--;
+                }
+            }
+        }
+    };
+}
+module.exports.default = module.exports;
+module.exports.zephyrEventsFast = function zephyrEventsFast(all) {
+    all ??= new Map();
+    let hasWildcards = false;
+    return {
+        all,
+        on(type, handler) {
+            let handlers = all.get(type);
+            if (!handlers) {
+                handlers = [];
+                all.set(type, handlers);
+            }
+            handlers.push(handler);
+            if ('*' === type)
+                hasWildcards = true;
+            return () => {
+                const current = all.get(type);
+                if (current) {
+                    const idx = current.indexOf(handler);
+                    if (-1 < idx) {
+                        current.splice(idx, 1);
+                    }
+                    if (0 === current.length) {
+                        all.delete(type);
+                        if ('*' === type)
+                            hasWildcards = false;
+                    }
+                }
+            };
+        },
+        off(type, handler) {
+            const handlers = all.get(type);
+            if (!handlers)
+                return;
+            if (handler) {
+                const idx = handlers.indexOf(handler);
+                if (-1 < idx) {
+                    handlers.splice(idx, 1);
+                }
+                if (0 === handlers.length) {
+                    all.delete(type);
+                    if ('*' === type)
+                        hasWildcards = false;
+                }
+            }
+            else {
+                all.delete(type);
+                if ('*' === type)
+                    hasWildcards = false;
+            }
+        },
+        emit(type, evt) {
+            const handlers = all.get(type);
+            if (handlers) {
+                const len = handlers.length;
+                for (let i = 0; i < len; i++) {
+                    handlers[i](evt);
+                }
+            }
+            if (hasWildcards && '*' !== type) {
+                const wildcards = all.get('*');
+                if (wildcards) {
+                    const len = wildcards.length;
+                    for (let i = 0; i < len; i++) {
+                        wildcards[i](type, evt);
+                    }
+                }
+            }
+        }
+    };
+}

package/dist/zephyr-events.mjs

@@ -1 +1,147 @@
-export default zephyrEvents;function zephyrEvents(all){all ??=new Map();const handlerSets=new Map();const getHandlerSet=(type)=>{let handlers=handlerSets.get(type);if(!handlers){handlers=new Set();handlerSets.set(type,handlers);all.set(type,[]);}return handlers;};const syncMap=(type)=>{const handlers=handlerSets.get(type);if(handlers){all.set(type,[...handlers]);}};return{all,on(type,handler){const handlers=getHandlerSet(type);handlers.add(handler);syncMap(type);return()=>{handlers.delete(handler);syncMap(type);};},off(type,handler){const handlers=handlerSets.get(type);if(!handlers)return;handler ? handlers.delete(handler): handlers.clear();syncMap(type);},emit(type,evt){const handlers=handlerSets.get(type);if(handlers?.size){for(const handler of [...handlers]){handler(evt);}}const wildcards=handlerSets.get('*');if(wildcards?.size){for(const handler of [...wildcards]){handler(type,evt);}}}};}
+export default function zephyrEvents(all) {
+    all ??= new Map();
+    let hasWildcards = false;
+    let emitting = 0;
+    return {
+        all,
+        on(type, handler) {
+            let handlers = all.get(type);
+            if (!handlers) {
+                handlers = [];
+                all.set(type, handlers);
+            }
+            handlers.push(handler);
+            if ('*' === type)
+                hasWildcards = true;
+            return () => {
+                const current = all.get(type);
+                if (current) {
+                    const idx = current.indexOf(handler);
+                    if (-1 < idx) {
+                        current.splice(idx, 1);
+                    }
+                    if (0 === current.length) {
+                        all.delete(type);
+                        if ('*' === type)
+                            hasWildcards = false;
+                    }
+                }
+            };
+        },
+        off(type, handler) {
+            const handlers = all.get(type);
+            if (!handlers)
+                return;
+            if (handler) {
+                const idx = handlers.indexOf(handler);
+                if (-1 < idx) {
+                    handlers.splice(idx, 1);
+                }
+                if (0 === handlers.length) {
+                    all.delete(type);
+                    if ('*' === type)
+                        hasWildcards = false;
+                }
+            }
+            else {
+                all.delete(type);
+                if ('*' === type)
+                    hasWildcards = false;
+            }
+        },
+        emit(type, evt) {
+            const handlers = all.get(type);
+            if (handlers) {
+                emitting++;
+                const snapshot = handlers.slice();
+                const len = snapshot.length;
+                for (let i = 0; i < len; i++) {
+                    snapshot[i](evt);
+                }
+                emitting--;
+            }
+            if (hasWildcards && '*' !== type) {
+                const wildcards = all.get('*');
+                if (wildcards) {
+                    emitting++;
+                    const snapshot = wildcards.slice();
+                    const len = snapshot.length;
+                    for (let i = 0; i < len; i++) {
+                        snapshot[i](type, evt);
+                    }
+                    emitting--;
+                }
+            }
+        }
+    };
+}
+export function zephyrEventsFast(all) {
+    all ??= new Map();
+    let hasWildcards = false;
+    return {
+        all,
+        on(type, handler) {
+            let handlers = all.get(type);
+            if (!handlers) {
+                handlers = [];
+                all.set(type, handlers);
+            }
+            handlers.push(handler);
+            if ('*' === type)
+                hasWildcards = true;
+            return () => {
+                const current = all.get(type);
+                if (current) {
+                    const idx = current.indexOf(handler);
+                    if (-1 < idx) {
+                        current.splice(idx, 1);
+                    }
+                    if (0 === current.length) {
+                        all.delete(type);
+                        if ('*' === type)
+                            hasWildcards = false;
+                    }
+                }
+            };
+        },
+        off(type, handler) {
+            const handlers = all.get(type);
+            if (!handlers)
+                return;
+            if (handler) {
+                const idx = handlers.indexOf(handler);
+                if (-1 < idx) {
+                    handlers.splice(idx, 1);
+                }
+                if (0 === handlers.length) {
+                    all.delete(type);
+                    if ('*' === type)
+                        hasWildcards = false;
+                }
+            }
+            else {
+                all.delete(type);
+                if ('*' === type)
+                    hasWildcards = false;
+            }
+        },
+        emit(type, evt) {
+            const handlers = all.get(type);
+            if (handlers) {
+                const len = handlers.length;
+                for (let i = 0; i < len; i++) {
+                    handlers[i](evt);
+                }
+            }
+            if (hasWildcards && '*' !== type) {
+                const wildcards = all.get('*');
+                if (wildcards) {
+                    const len = wildcards.length;
+                    for (let i = 0; i < len; i++) {
+                        wildcards[i](type, evt);
+                    }
+                }
+            }
+        }
+    };
+}

package/dist/zephyr-events.umd.js

@@ -1,7 +1,156 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-  typeof define === 'function' && define.amd ? define(factory) :
-  (global = global || self, global.zephyrEvents = factory());
-}(this, (function () { 'use strict';
-  "use strict";Object.defineProperty(exports,"__esModule",{value: true});exports.default=zephyrEvents;function zephyrEvents(all){all ??=new Map();const handlerSets=new Map();const getHandlerSet=(type)=>{let handlers=handlerSets.get(type);if(!handlers){handlers=new Set();handlerSets.set(type,handlers);all.set(type,[]);}return handlers;};const syncMap=(type)=>{const handlers=handlerSets.get(type);if(handlers){all.set(type,[...handlers]);}};return{all,on(type,handler){const handlers=getHandlerSet(type);handlers.add(handler);syncMap(type);return()=>{handlers.delete(handler);syncMap(type);};},off(type,handler){const handlers=handlerSets.get(type);if(!handlers)return;handler ? handlers.delete(handler): handlers.clear();syncMap(type);},emit(type,evt){const handlers=handlerSets.get(type);if(handlers?.size){for(const handler of [...handlers]){handler(evt);}}const wildcards=handlerSets.get('*');if(wildcards?.size){for(const handler of [...wildcards]){handler(type,evt);}}}};}
-})));
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global));
+}(this, (function (exports) {
+	'use strict';
+	function zephyrEvents(all) {
+    all ??= new Map();
+    let hasWildcards = false;
+    let emitting = 0;
+    return {
+        all,
+        on(type, handler) {
+            let handlers = all.get(type);
+            if (!handlers) {
+                handlers = [];
+                all.set(type, handlers);
+            }
+            handlers.push(handler);
+            if ('*' === type)
+                hasWildcards = true;
+            return () => {
+                const current = all.get(type);
+                if (current) {
+                    const idx = current.indexOf(handler);
+                    if (-1 < idx) {
+                        current.splice(idx, 1);
+                    }
+                    if (0 === current.length) {
+                        all.delete(type);
+                        if ('*' === type)
+                            hasWildcards = false;
+                    }
+                }
+            };
+        },
+        off(type, handler) {
+            const handlers = all.get(type);
+            if (!handlers)
+                return;
+            if (handler) {
+                const idx = handlers.indexOf(handler);
+                if (-1 < idx) {
+                    handlers.splice(idx, 1);
+                }
+                if (0 === handlers.length) {
+                    all.delete(type);
+                    if ('*' === type)
+                        hasWildcards = false;
+                }
+            }
+            else {
+                all.delete(type);
+                if ('*' === type)
+                    hasWildcards = false;
+            }
+        },
+        emit(type, evt) {
+            const handlers = all.get(type);
+            if (handlers) {
+                emitting++;
+                const snapshot = handlers.slice();
+                const len = snapshot.length;
+                for (let i = 0; i < len; i++) {
+                    snapshot[i](evt);
+                }
+                emitting--;
+            }
+            if (hasWildcards && '*' !== type) {
+                const wildcards = all.get('*');
+                if (wildcards) {
+                    emitting++;
+                    const snapshot = wildcards.slice();
+                    const len = snapshot.length;
+                    for (let i = 0; i < len; i++) {
+                        snapshot[i](type, evt);
+                    }
+                    emitting--;
+                }
+            }
+        }
+    };
+}
+	function zephyrEventsFast(all) {
+    all ??= new Map();
+    let hasWildcards = false;
+    return {
+        all,
+        on(type, handler) {
+            let handlers = all.get(type);
+            if (!handlers) {
+                handlers = [];
+                all.set(type, handlers);
+            }
+            handlers.push(handler);
+            if ('*' === type)
+                hasWildcards = true;
+            return () => {
+                const current = all.get(type);
+                if (current) {
+                    const idx = current.indexOf(handler);
+                    if (-1 < idx) {
+                        current.splice(idx, 1);
+                    }
+                    if (0 === current.length) {
+                        all.delete(type);
+                        if ('*' === type)
+                            hasWildcards = false;
+                    }
+                }
+            };
+        },
+        off(type, handler) {
+            const handlers = all.get(type);
+            if (!handlers)
+                return;
+            if (handler) {
+                const idx = handlers.indexOf(handler);
+                if (-1 < idx) {
+                    handlers.splice(idx, 1);
+                }
+                if (0 === handlers.length) {
+                    all.delete(type);
+                    if ('*' === type)
+                        hasWildcards = false;
+                }
+            }
+            else {
+                all.delete(type);
+                if ('*' === type)
+                    hasWildcards = false;
+            }
+        },
+        emit(type, evt) {
+            const handlers = all.get(type);
+            if (handlers) {
+                const len = handlers.length;
+                for (let i = 0; i < len; i++) {
+                    handlers[i](evt);
+                }
+            }
+            if (hasWildcards && '*' !== type) {
+                const wildcards = all.get('*');
+                if (wildcards) {
+                    const len = wildcards.length;
+                    for (let i = 0; i < len; i++) {
+                        wildcards[i](type, evt);
+                    }
+                }
+            }
+        }
+    };
+}
+	exports.zephyrEvents = zephyrEvents;
+	exports.zephyrEventsFast = zephyrEventsFast;
+})));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zephyr-events",
-  "version": "1.1.2",
-  "description": "Ultra-fast ES2023 event emitter with 889B bundle size and race-condition safety",
+  "version": "1.3.0",
+  "description": "Tiny typed event emitter with race-condition safety",
   "main": "dist/zephyr-events.js",
   "module": "dist/zephyr-events.mjs",
   "types": "dist/index.d.ts",
@@ -19,23 +19,29 @@
   ],
   "scripts": {
     "build": "tsc --build && node build.js",
-    "prepublishOnly": "npm run build"
+    "test": "node test/index.js",
+    "prepublishOnly": "npm run build && npm test"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ebogdum/zephyr-events.git"
   },
   "keywords": [
-    "events",
+    "event-emitter",
     "eventemitter",
+    "events",
     "emitter",
     "pubsub",
+    "event-bus",
     "typescript",
-    "es2023",
-    "fast",
+    "typed-events",
+    "mitt-alternative",
+    "lightweight",
     "tiny",
-    "performance",
-    "race-condition-safe"
+    "subscribe",
+    "observer",
+    "race-condition-safe",
+    "wildcard"
   ],
   "homepage": "https://github.com/ebogdum/zephyr-events",
   "bugs": {
@@ -44,7 +50,7 @@
   "author": "ebogdum <https://github.com/ebogdum>",
   "license": "MIT",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "devDependencies": {
     "typescript": "^5.9.2"