arcane-os 0.1.0-dev.5

package/node_modules/event-pubsub/README.md

@@ -0,0 +1,363 @@
+# event-pubsub
+
+[![CI](https://github.com/RIAEvangelist/event-pubsub/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/RIAEvangelist/event-pubsub/actions/workflows/ci.yml)
+[![GitHub release](https://img.shields.io/github/v/release/RIAEvangelist/event-pubsub?sort=semver)](https://github.com/RIAEvangelist/event-pubsub/releases)
+[![npm](https://img.shields.io/npm/v/event-pubsub.svg)](https://www.npmjs.com/package/event-pubsub)
+[![Node](https://img.shields.io/badge/Node-%3E%3D22.12-339933?logo=nodedotjs&logoColor=white)](./package.json)
+[![runtime dependencies](https://img.shields.io/endpoint?url=https://riaevangelist.github.io/event-pubsub/badges/runtime-dependencies.json)](./package.json)
+[![strong-type](https://img.shields.io/endpoint?url=https://riaevangelist.github.io/event-pubsub/badges/strong-type.json)](https://www.npmjs.com/package/strong-type)
+[![vanilla-test](https://img.shields.io/endpoint?url=https://riaevangelist.github.io/event-pubsub/badges/vanilla-test.json)](https://www.npmjs.com/package/vanilla-test)
+[![license](https://img.shields.io/github/license/RIAEvangelist/event-pubsub.svg)](./licence)
+
+[![Node tests](https://img.shields.io/endpoint?url=https://riaevangelist.github.io/event-pubsub/badges/node-tests.json)](https://riaevangelist.github.io/event-pubsub/reports/node/test-results.json)
+[![Chrome tests](https://img.shields.io/endpoint?url=https://riaevangelist.github.io/event-pubsub/badges/chrome-tests.json)](https://riaevangelist.github.io/event-pubsub/reports/chrome/test-results.json)
+
+[![Node executable ranges](https://img.shields.io/endpoint?url=https://riaevangelist.github.io/event-pubsub/badges/node-statements.json)](https://riaevangelist.github.io/event-pubsub/reports/node/)
+[![Node block ranges](https://img.shields.io/endpoint?url=https://riaevangelist.github.io/event-pubsub/badges/node-branches.json)](https://riaevangelist.github.io/event-pubsub/reports/node/)
+[![Node function ranges](https://img.shields.io/endpoint?url=https://riaevangelist.github.io/event-pubsub/badges/node-functions.json)](https://riaevangelist.github.io/event-pubsub/reports/node/)
+[![Node executable lines](https://img.shields.io/endpoint?url=https://riaevangelist.github.io/event-pubsub/badges/node-lines.json)](https://riaevangelist.github.io/event-pubsub/reports/node/)
+
+[![Chrome executable ranges](https://img.shields.io/endpoint?url=https://riaevangelist.github.io/event-pubsub/badges/chrome-statements.json)](https://riaevangelist.github.io/event-pubsub/reports/chrome/)
+[![Chrome block ranges](https://img.shields.io/endpoint?url=https://riaevangelist.github.io/event-pubsub/badges/chrome-branches.json)](https://riaevangelist.github.io/event-pubsub/reports/chrome/)
+[![Chrome function ranges](https://img.shields.io/endpoint?url=https://riaevangelist.github.io/event-pubsub/badges/chrome-functions.json)](https://riaevangelist.github.io/event-pubsub/reports/chrome/)
+[![Chrome executable lines](https://img.shields.io/endpoint?url=https://riaevangelist.github.io/event-pubsub/badges/chrome-lines.json)](https://riaevangelist.github.io/event-pubsub/reports/chrome/)
+
+Small, synchronous, extensible publish/subscribe events for modern Node.js and browsers.
+
+> **Release status:** `6.1.0` is the current npm release and the verified source on `main`. `6.0.0` remains the most recent separately tagged GitHub source release.
+
+![event-pubsub signal fan-out](https://riaevangelist.github.io/event-pubsub/og.png)
+
+```sh
+npm install event-pubsub
+```
+
+```js
+import EventPubSub from 'event-pubsub';
+
+const events = new EventPubSub();
+
+events.on('ready', (payload) => {
+    console.log(payload);
+});
+
+events.emit('ready', {fast: true});
+```
+
+The same source is available directly to CommonJS on Node.js 22.12 or newer:
+
+```js
+const EventPubSub = require('event-pubsub');
+```
+
+## Measured dispatch speed
+
+[![event-pubsub dispatch execution latency](./site/benchmark-summary.svg)](https://riaevangelist.github.io/event-pubsub/benchmarks-dispatch.html)
+
+Bars show median nanoseconds per emit, whiskers show p25–p75, and dots show all seven samples. Every rate is derived from the same execution-only measurement; setup, warmup, validation, verification, serialization, file I/O, and CI orchestration are excluded. Lower latency is better. Open the [interactive charts](https://riaevangelist.github.io/event-pubsub/benchmarks.html) or [raw schema v2 evidence](https://riaevangelist.github.io/event-pubsub/data/benchmark.json).
+
+## Why this module
+
+- Five fluent methods: `on`, `once`, `off`, `emit`, and `reset`.
+- Synchronous, registration-order dispatch with wildcard subscribers first.
+- One-shot subscribers are removed before invocation, including reentrant emits.
+- Subscriber arrays remain live during an emit: additions can run in that emit, and specifically removed handlers are skipped before their turn. Removing a whole bucket or resetting the registry detaches it from future lookup while an already-active array finishes.
+- Safe event names, including `__proto__`, `constructor`, and `toString`.
+- Isolated `list` snapshots that cannot mutate the live registry.
+- One native ESM source for browser imports plus Node.js `import` and `require()`, without transpilation or a duplicate CommonJS build.
+- One explicit production validator: `strong-type` 2.0.0, loaded through the original Node/browser relative shim.
+
+## API
+
+| Member | Signature | Behavior |
+| --- | --- | --- |
+| `on` | `on(type, handler, once = false)` | Register a persistent or explicitly one-shot handler. |
+| `once` | `once(type, handler)` | Register a handler removed immediately before its first call. |
+| `off` | `off(type = '*', handler = '*')` | Remove every matching handler or a whole event type. |
+| `emit` | `emit(type, ...payload)` | Run wildcard handlers, then typed handlers, synchronously. |
+| `reset` | `reset()` | Clear the complete registry. |
+| `list` | `get list()` | Return an isolated null-prototype object snapshot of handler arrays. |
+
+All public mutators return the current instance. Event types must be strings, and `on`/`once` validate their handler immediately. For 5.x compatibility, `off` returns early for a missing type before validating its optional handler. Synchronous handler throws propagate to the publisher; return values and promises are ignored, so applications must handle asynchronous rejections themselves.
+
+### Wildcard events
+
+`*` subscribers run before typed subscribers and receive the emitted type as their first argument.
+
+```js
+events.on('*', (type, ...payload) => {
+    console.log(type, payload);
+});
+
+events.emit('invoice.paid', {id: 42});
+```
+
+The wildcard list entry is exposed at `Symbol.for('event-pubsub-all')`.
+
+Only the exact public string `*` maps to the internal wildcard Symbol. The ordinary string `Symbol(event-pubsub-all)` remains an exact typed event name and never aliases wildcard removal.
+
+### Browser import map
+
+The 6.1.0 runtime imports `strong-type` 2.0.0 through `../strong-type/index.js`. This preserves the original package-shaped Node/browser layout: serve `event-pubsub` and `strong-type` as sibling package directories, then map only the public package name:
+
+```html
+<script type="importmap">
+{
+  "imports": {
+    "event-pubsub": "./node_modules/event-pubsub/index.js"
+  }
+}
+</script>
+<script type="module">
+  import EventPubSub from 'event-pubsub';
+</script>
+```
+
+## Complete verification summary
+
+The shared host-neutral registry contains **119 unique checks**. `vanilla-test` 2.1.1 executes the same inventory in Node and real Google Chrome.
+
+| Suite | Cases | Focus |
+| --- | ---: | --- |
+| Unit | 16 | Exports, state, fluent identity, validation, and list shape |
+| Functional | 26 | Registration, dispatch, wildcard, once, removal, reset, and chaining |
+| Integration | 14 | Subclassing, routing, isolation, namespaces, lifecycle, and errors |
+| Regression | 43 | Mutation, reentrancy, snapshots, safe names, throws, and registration-local once state |
+| Interface | 20 | Playground parsing, safe display, bounded state, benchmark evidence, units, and chart scaling |
+| **Total** | **119** | One registry used by direct tests and both coverage runtimes |
+
+### Runtime and CI matrix
+
+| Verification | Runtime | Hosts | Result requirement |
+| --- | --- | --- | --- |
+| Direct shared suite | Node 22.12.0 and Node 24 | Ubuntu, macOS, Windows | 119/119 on every matrix job |
+| Node coverage | Node 24.18.0 | Ubuntu | 119/119 and every native V8 gate at 100% |
+| Browser coverage | Google Chrome Stable | Ubuntu | 119/119 and every native V8 gate at 100% |
+| Packed consumer | Node 24 | Ubuntu | Exact tarball contents, ESM exports, behavior, and the sole `strong-type` dependency |
+| Shared-source package smoke | Node 22.12.0 | Ubuntu | The same packed `index.js` through ESM `import` and direct CommonJS `require()` |
+| Execution benchmark | Node 24.18.0 | Ubuntu | Eight validated scenarios with execution-only timing boundaries |
+| GitHub Pages | Node 24 | Ubuntu | 21 pages, both runtime reports, badges, benchmark JSON, scripts, links, and licenses |
+
+### Coverage gates
+
+| Runtime | Executable ranges | Block ranges | Function ranges | Executable lines |
+| --- | ---: | ---: | ---: | ---: |
+| Node 24.18.0 | 100% | 100% | 100% | 100% |
+| Chrome Stable | 100% | 100% | 100% | 100% |
+
+These are native V8 executable/block/function range and executable-line totals for `index.js`, not parser-derived Istanbul statement or branch counts. Node and Chrome produce independent HTML, JSON, LCOV, and normalized test-result artifacts.
+
+### Commands
+
+| Command | Purpose |
+| --- | --- |
+| `npm test` | Stage the sibling packages and run all 119 checks in Node. |
+| `npm run test:unit` | Run the 16 Unit cases. |
+| `npm run test:functional` | Run the 26 Functional cases. |
+| `npm run test:integration` | Run the 14 Integration cases. |
+| `npm run test:regression` | Run the 43 Regression cases. |
+| `npm run test:interface` | Run the 20 Interface cases. |
+| `npm run coverage` | Run all 119 checks independently in Node and real Chrome with 100% gates. |
+| `npm run coverage:node` | Generate only the Node native V8 report. |
+| `npm run coverage:chrome` | Generate only the real-Chrome native V8 report. |
+| `npm run benchmark` | Record seven fixed-count latency samples for eight scenarios. |
+| `npm run benchmark:smoke` | Validate the benchmark quickly without replacing published results. |
+| `npm run test:package` | Pack, inspect, install, and exercise a clean consumer. |
+| `npm run site:check` | Validate all focused pages, exact test inventories, scripts, links, forms, and assets. |
+| `npm run verify` | Run the complete local release gate. |
+
+### Published evidence
+
+- [Testing strategy and suite totals](https://riaevangelist.github.io/event-pubsub/testing.html)
+- [Live execution of all 119 checks](https://riaevangelist.github.io/event-pubsub/live.html)
+- [Node test-result JSON](https://riaevangelist.github.io/event-pubsub/reports/node/test-results.json)
+- [Chrome test-result JSON](https://riaevangelist.github.io/event-pubsub/reports/chrome/test-results.json)
+- [Node HTML coverage](https://riaevangelist.github.io/event-pubsub/reports/node/)
+- [Chrome HTML coverage](https://riaevangelist.github.io/event-pubsub/reports/chrome/)
+- [Chrome coverage screenshot](https://riaevangelist.github.io/event-pubsub/reports/chrome/vanilla-test-chrome.png)
+- [Execution-latency charts](https://riaevangelist.github.io/event-pubsub/benchmarks.html)
+- [Raw benchmark schema v2 JSON](https://riaevangelist.github.io/event-pubsub/data/benchmark.json)
+
+## Complete test inventory
+
+Every test name below is sourced from the shared registry. The focused Pages site presents the same inventory one suite per page.
+
+<details>
+<summary><strong>Unit — 16 cases</strong></summary>
+
+1. default and named exports reference the same class
+2. a fresh instance exposes an empty list snapshot
+3. instances own independent event registries
+4. on returns the current instance
+5. once returns the current instance
+6. off returns the current instance when the type is absent
+7. emit returns the current instance when the type is absent
+8. reset returns the current instance
+9. on requires a string event type
+10. on requires a function handler
+11. on requires a boolean once flag
+12. once delegates type validation to on
+13. once delegates handler validation to on
+14. off requires a string event type
+15. off validates a handler when the event exists
+16. emit requires a string event type
+
+</details>
+
+<details>
+<summary><strong>Functional — 26 cases</strong></summary>
+
+1. on exposes the registered handler in list
+2. on preserves registration order in list
+3. duplicate registrations remain visible as separate entries
+4. emit runs a registered handler synchronously
+5. emit runs handlers in registration order
+6. emit forwards every payload argument by identity
+7. handlers run without an emitter-bound this value
+8. once runs a handler exactly once
+9. on with an explicit false once flag remains persistent
+10. on with an explicit true once flag matches once
+11. wildcard handlers receive the emitted type before payloads
+12. wildcard handlers run before typed handlers
+13. multiple wildcard handlers retain registration order
+14. once supports wildcard subscriptions
+15. wildcard handlers are exposed under the stable symbol
+16. off removes a matching handler
+17. off removes every duplicate registration of a handler
+18. off leaves nonmatching handlers registered
+19. off with a wildcard handler removes an event type
+20. off defaults the handler argument to wildcard removal
+21. off defaults the event type to wildcard subscriptions only
+22. off removes one wildcard handler without touching typed handlers
+23. reset removes typed and wildcard registrations
+24. emitting an unknown type does not run other typed handlers
+25. all public mutators support fluent chaining
+26. the same function can be once and persistent independently
+
+</details>
+
+<details>
+<summary><strong>Integration — 14 cases</strong></summary>
+
+1. a subclass can publish state changes
+2. multiple instances isolate same-named topics
+3. namespaced topic strings remain exact
+4. a wildcard audit stream observes several domains
+5. a one-shot readiness gate coexists with persistent progress
+6. a request-style payload preserves callbacks by identity
+7. a handler can publish a second event synchronously
+8. a wildcard handler can route selected events
+9. reset provides a clean lifecycle boundary
+10. empty and whitespace topic names remain distinct
+11. unicode topic names and payloads pass through unchanged
+12. async handlers are invoked without delaying synchronous peers
+13. synchronous handler exceptions propagate to the publisher
+14. list supports operational introspection without exposing records
+
+</details>
+
+<details>
+<summary><strong>Regression — 43 cases</strong></summary>
+
+1. `__proto__` is a safe event name
+2. `constructor` is a safe event name
+3. `toString` is a safe event name
+4. `hasOwnProperty` is a safe event name
+5. numeric-looking event names remain strings
+6. the wildcard symbol description remains an exact typed event
+7. off compares the remove-all handler sentinel strictly
+8. emitting the literal wildcard type invokes wildcard handlers once
+9. handlers added during typed dispatch run in that emit
+10. typed handlers added by a wildcard run in that emit
+11. wildcard handlers added during wildcard dispatch run in that emit
+12. handlers removed during dispatch do not run later in that dispatch
+13. a wildcard can remove a typed handler before the typed phase
+14. reset during typed dispatch leaves the active array running
+15. reset from a wildcard finishes that array but prevents typed dispatch
+16. once is removed before a reentrant emit
+17. persistent reentrant emits preserve nested registration order
+18. wildcard once is removed before a reentrant emit
+19. a throwing once handler remains removed
+20. a throwing once handler is absent from the next list snapshot
+21. a throwing persistent handler remains registered
+22. a thrown wildcard handler stops typed dispatch
+23. off with a nonmatching function preserves the type
+24. off ignores an invalid handler when the type is absent
+25. mutating a list array does not change the registry
+26. deleting a list property does not change the registry
+27. mutating a wildcard list snapshot does not change the registry
+28. frozen handler functions can be registered
+29. nonextensible handler functions can be registered
+30. duplicate once registrations each run once
+31. the same handler can be wildcard-once and typed-persistent
+32. registration does not write the old once symbol onto handlers
+33. the same handler can be once and persistent in one bucket
+34. the same handler has independent state across instances
+35. typed once removal does not skip the next registration
+36. wildcard once removal does not skip the next registration
+37. a sole once handler can add a handler to its live bucket
+38. off all during dispatch leaves the active array running
+39. stale once cleanup cannot delete a fresh same-name bucket
+40. an earlier once remains consumed when a later handler throws
+41. persistent self-removal preserves shifted-array iteration
+42. wildcard-only emits remain chainable
+43. reset instances accept new registrations immediately
+
+</details>
+
+<details>
+<summary><strong>Interface — 20 cases</strong></summary>
+
+1. the playground parses no-argument mode
+2. the playground preserves one exact text argument
+3. the playground parses an empty JSON argument array
+4. the playground spreads several JSON arguments
+5. invalid playground JSON is an explicit syntax error
+6. a non-array JSON argument source is rejected
+7. typed playground subscriptions preserve whitespace
+8. wildcard playground subscriptions resolve to star
+9. typed star subscriptions require wildcard mode
+10. event-type display quotes invisible characters
+11. safe value formatting exposes undefined
+12. safe value formatting marks circular references
+13. safe value formatting bounds long output
+14. bounded timeline retention keeps chronological tail entries
+15. benchmark evidence accepts all eight unique scenarios
+16. benchmark evidence rejects the wrong schema version
+17. benchmark evidence rejects duplicate or internally inconsistent scenarios
+18. benchmark dispatch selection returns four scenarios
+19. benchmark durations choose readable nanosecond and microsecond units
+20. benchmark chart values clamp and expose equivalent throughput
+
+</details>
+
+## Benchmark interpretation
+
+The benchmark reports median **execution latency**—nanoseconds per named operation—with p25, p75, min, max, and every raw sample. Fixed-count loops use exactly two `process.hrtime.bigint()` readings around the execution boundary. Dispatch scenarios use distinct minimal observable subscribers, then verify their accumulated effects after timing so empty callbacks cannot become an optimizer-only lower bound. Setup, validation, calibration, warmup, post-run checks, summary work, JSON serialization, file I/O, Node startup, and CI orchestration are excluded. The charts never present total benchmark or workflow duration as module execution time.
+
+## Documentation
+
+- [Overview](https://riaevangelist.github.io/event-pubsub/)
+- [Guide](https://riaevangelist.github.io/event-pubsub/guide.html)
+- [API](https://riaevangelist.github.io/event-pubsub/api.html)
+- [Examples](https://riaevangelist.github.io/event-pubsub/examples.html)
+- [Event console playground](https://riaevangelist.github.io/event-pubsub/playground.html)
+- [Mutation playground scenarios](https://riaevangelist.github.io/event-pubsub/playground-scenarios.html)
+- [All 119 tests](https://riaevangelist.github.io/event-pubsub/testing.html)
+- [Node and Chrome coverage](https://riaevangelist.github.io/event-pubsub/coverage.html)
+- [Benchmark overview](https://riaevangelist.github.io/event-pubsub/benchmarks.html)
+- [Dispatch latency chart](https://riaevangelist.github.io/event-pubsub/benchmarks-dispatch.html)
+- [Lifecycle latency charts](https://riaevangelist.github.io/event-pubsub/benchmarks-lifecycle.html)
+- [Benchmark methodology](https://riaevangelist.github.io/event-pubsub/benchmarks-methodology.html)
+- [5.x → 6.x migration](./MIGRATION.md)
+- [Security policy](./SECURITY.md)
+- [Changelog](./CHANGELOG.md)
+
+## Runtime support
+
+- Node.js 22.12.0 or newer for production, development, and direct CommonJS `require()` of the native ESM source.
+- Modern browsers with native modules, private class fields, and `Symbol`. Unbundled use must serve the sibling `event-pubsub` and `strong-type` package directories.
+
+## License
+
+MIT. See [licence](./licence).

package/node_modules/event-pubsub/SECURITY.md

@@ -0,0 +1,37 @@
+# Security policy
+
+## Supported versions
+
+| Version | Supported |
+| --- | --- |
+| 6.1.0 on npm | Current supported release |
+| 6.0.0 | Superseded GitHub source release |
+| 5.x and older | No planned security fixes |
+
+Version 6.1.0 is the current npm release and requires Node.js 22.12 or newer. Version 6.0.0 remains available as the earlier GitHub source release, but users should install the latest available 6.x release.
+
+## Reporting a vulnerability
+
+Do not open a public issue for a suspected vulnerability. Use the repository's private [GitHub Security Advisory form](https://github.com/RIAEvangelist/event-pubsub/security/advisories/new).
+
+Include:
+
+- affected versions and runtimes;
+- a minimal reproduction;
+- expected and observed behavior;
+- impact and realistic exploitation conditions; and
+- any proposed mitigation.
+
+Please allow reasonable time for triage and remediation before public disclosure.
+
+## Trust model
+
+event-pubsub synchronously invokes application-provided functions in the publisher's process and privilege context. It does not sandbox handlers, authorize event names, clone payloads, serialize data, catch synchronous throws, or observe returned promises. Applications are responsible for handling asynchronous rejections.
+
+- Register only trusted code.
+- Treat mutable payloads as shared references.
+- Use `off` and `reset` at lifecycle boundaries so long-lived registries do not retain unnecessary closures or state.
+- Add application-level authorization before publishing sensitive data across a shared hub.
+- Isolate untrusted work in a process, worker, or other security boundary; an event emitter is not one.
+
+Prototype-like event names are stored safely and covered by regression tests. This prevents object-prototype collisions but does not make arbitrary handler code safe.

package/node_modules/event-pubsub/index.js

@@ -0,0 +1,141 @@
+// Shim allowing the same module path to run in Node and an unbundled browser.
+import Is from '../strong-type/index.js';
+
+const is = new Is();
+const ALL_EVENTS = Symbol.for('event-pubsub-all');
+
+function dispatchTyped(registrations, args) {
+    for (let index = 0; index < registrations.length;) {
+        const registration = registrations[index];
+        const handler = registration.handler;
+
+        if (registration.once) registrations.splice(index, 1);
+        else index += 1;
+
+        if (args.length === 0) handler();
+        else if (args.length === 1) handler(args[0]);
+        else if (args.length === 2) handler(args[0], args[1]);
+        else handler(...args);
+    }
+}
+
+function dispatchWildcard(registrations, type, args) {
+    for (let index = 0; index < registrations.length;) {
+        const registration = registrations[index];
+        const handler = registration.handler;
+
+        if (registration.once) registrations.splice(index, 1);
+        else index += 1;
+
+        if (args.length === 0) handler(type);
+        else if (args.length === 1) handler(type, args[0]);
+        else if (args.length === 2) handler(type, args[0], args[1]);
+        else handler(type, ...args);
+    }
+}
+
+class EventPubSub {
+    #events = Object.create(null);
+
+    on(type, handler, once = false) {
+        is.string(type);
+        is.function(handler);
+        is.boolean(once);
+
+        const key = type === '*' ? ALL_EVENTS : type;
+        let registrations = this.#events[key];
+        if (registrations === undefined) registrations = this.#events[key] = [];
+        registrations.push({handler, once});
+        return this;
+    }
+
+    once(type, handler) {
+        return this.on(type, handler, true);
+    }
+
+    off(type = '*', handler = '*') {
+        is.string(type);
+
+        const key = type === '*' ? ALL_EVENTS : type;
+        const registrations = this.#events[key];
+        if (registrations === undefined) return this;
+
+        if (handler === '*') {
+            delete this.#events[key];
+            return this;
+        }
+
+        is.function(handler);
+
+        let write = 0;
+        for (let read = 0; read < registrations.length; read += 1) {
+            const registration = registrations[read];
+            if (registration.handler === handler) continue;
+            if (write !== read) registrations[write] = registration;
+            write += 1;
+        }
+        registrations.length = write;
+
+        if (registrations.length === 0 && this.#events[key] === registrations) {
+            delete this.#events[key];
+        }
+        return this;
+    }
+
+    emit(type, ...args) {
+        is.string(type);
+
+        const wildcard = this.#events[ALL_EVENTS];
+        if (wildcard !== undefined) {
+            const startedWithRegistrations = wildcard.length !== 0;
+            try {
+                dispatchWildcard(wildcard, type, args);
+            } finally {
+                if (
+                    startedWithRegistrations &&
+                    wildcard.length === 0 &&
+                    this.#events[ALL_EVENTS] === wildcard
+                ) {
+                    delete this.#events[ALL_EVENTS];
+                }
+            }
+        }
+
+        const typed = this.#events[type];
+        if (typed !== undefined) {
+            const startedWithRegistrations = typed.length !== 0;
+            try {
+                dispatchTyped(typed, args);
+            } finally {
+                if (
+                    startedWithRegistrations &&
+                    typed.length === 0 &&
+                    this.#events[type] === typed
+                ) {
+                    delete this.#events[type];
+                }
+            }
+        }
+        return this;
+    }
+
+    reset() {
+        this.#events = Object.create(null);
+        return this;
+    }
+
+    get list() {
+        const snapshot = Object.create(null);
+        for (const key of Reflect.ownKeys(this.#events)) {
+            snapshot[key] = this.#events[key].map(({handler}) => handler);
+        }
+        return snapshot;
+    }
+}
+
+Object.defineProperties(EventPubSub, {
+    default: {value: EventPubSub},
+    EventPubSub: {value: EventPubSub}
+});
+
+export {EventPubSub as default, EventPubSub, EventPubSub as 'module.exports'};

package/node_modules/event-pubsub/licence

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Brandon Nozaki Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/event-pubsub/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "event-pubsub",
+  "version": "6.1.0",
+  "description": "Small, synchronous, extensible publish/subscribe events for modern Node.js and browsers.",
+  "type": "module",
+  "main": "./index.js",
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "scripts": {
+    "stage": "node ./scripts/stage-runtime.js",
+    "test": "npm run stage && node ./test-runtime/event-pubsub/test/node.js",
+    "test:unit": "npm run stage && node ./test-runtime/event-pubsub/test/node.js unit",
+    "test:functional": "npm run stage && node ./test-runtime/event-pubsub/test/node.js functional",
+    "test:integration": "npm run stage && node ./test-runtime/event-pubsub/test/node.js integration",
+    "test:regression": "npm run stage && node ./test-runtime/event-pubsub/test/node.js regression",
+    "test:interface": "npm run stage && node ./test-runtime/event-pubsub/test/node.js interface",
+    "coverage": "npm run stage && vanilla-test coverage all",
+    "coverage:node": "npm run stage && vanilla-test coverage node",
+    "coverage:chrome": "npm run stage && vanilla-test coverage chrome",
+    "benchmark": "npm run stage && node ./benchmark/run.js && node ./scripts/benchmark-chart.js",
+    "benchmark:smoke": "npm run stage && node ./benchmark/run.js --smoke",
+    "benchmark:chart": "node ./scripts/benchmark-chart.js",
+    "benchmark:chart:check": "node ./scripts/benchmark-chart.js --check",
+    "test:package": "node ./scripts/package-smoke.js",
+    "site:check": "npm run stage && npm run benchmark:chart:check && node ./scripts/site-check.js",
+    "site:assemble": "node ./scripts/assemble-site.js _site",
+    "site:deployment-check": "node ./scripts/deployment-check.js _site",
+    "start": "node ./scripts/serve.js",
+    "verify": "npm test && npm run coverage && npm run benchmark:smoke && npm run test:package && npm run site:check && npm run site:assemble && npm run site:deployment-check"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RIAEvangelist/event-pubsub.git"
+  },
+  "homepage": "https://riaevangelist.github.io/event-pubsub/",
+  "bugs": {
+    "url": "https://github.com/RIAEvangelist/event-pubsub/issues"
+  },
+  "funding": "https://github.com/sponsors/RIAEvangelist",
+  "keywords": [
+    "event",
+    "events",
+    "pubsub",
+    "publish-subscribe",
+    "event-emitter",
+    "node",
+    "browser",
+    "esm"
+  ],
+  "author": "Brandon Nozaki Miller",
+  "license": "MIT",
+  "dependencies": {
+    "strong-type": "2.0.0"
+  },
+  "devDependencies": {
+    "vanilla-test": "2.1.1"
+  }
+}