evnty 5.0.0 → 5.1.0

package/build/broadcast.d.ts

@@ -0,0 +1,164 @@
+import { Signal } from './signal.js';
+import { Action, Fn, Emitter, MaybePromise, Promiseable } from './types.js';
+/**
+ * A handle representing a consumer's position in a Broadcast.
+ * Returned by `Broadcast.join()` and used to consume values.
+ * Implements Disposable for automatic cleanup via `using` keyword.
+ *
+ * @example
+ * ```typescript
+ * const broadcast = new Broadcast<number>();
+ * using handle = broadcast.join();
+ * broadcast.emit(42);
+ * const value = broadcast.consume(handle); // 42
+ * ```
+ */
+export declare class ConsumerHandle<T> implements Disposable {
+    #private;
+    constructor(broadcast: Broadcast<T>);
+    /**
+     * The current position of this consumer in the buffer.
+     */
+    get cursor(): number;
+    /**
+     * Leaves the broadcast, releasing this consumer's position.
+     */
+    [Symbol.dispose](): void;
+}
+/**
+ * @internal
+ */
+export declare class BroadcastIterator<T> implements AsyncIterator<T, void, void> {
+    #private;
+    constructor(broadcast: Broadcast<T>, signal: Signal<T>, handle: ConsumerHandle<T>);
+    next(): Promise<IteratorResult<T, void>>;
+    return(): Promise<IteratorResult<T, void>>;
+}
+/**
+ * A multi-consumer FIFO queue where each consumer maintains its own read position.
+ * Values are buffered and each consumer can read them independently at their own pace.
+ * The buffer automatically compacts when all consumers have read past a position.
+ *
+ * Key characteristics:
+ * - Multiple consumers - each gets their own cursor position
+ * - Buffered delivery - values are stored until all consumers read them
+ * - Late joiners only see values emitted after joining
+ * - Automatic cleanup via FinalizationRegistry when handles are garbage collected
+ *
+ * Differs from:
+ * - Event: Broadcast buffers values, Event does not
+ * - Sequence: Broadcast supports multiple consumers, Sequence is single-consumer
+ * - Signal: Broadcast buffers values, Signal only notifies current waiters
+ *
+ * @template T - The type of values in the broadcast
+ *
+ * @example
+ * ```typescript
+ * const broadcast = new Broadcast<number>();
+ *
+ * const handle1 = broadcast.join();
+ * const handle2 = broadcast.join();
+ *
+ * broadcast.emit(1);
+ * broadcast.emit(2);
+ *
+ * broadcast.consume(handle1); // 1
+ * broadcast.consume(handle2); // 1
+ * broadcast.consume(handle1); // 2
+ * ```
+ */
+export declare class Broadcast<T> implements Emitter<T, boolean>, Promiseable<T>, Promise<T>, Disposable, AsyncIterable<T> {
+    #private;
+    readonly [Symbol.toStringTag] = "Broadcast";
+    constructor();
+    /**
+     * Returns a bound emit function for use as a callback.
+     */
+    get sink(): Fn<[T], boolean>;
+    /**
+     * DOM EventListener interface compatibility.
+     */
+    handleEvent(event: T): void;
+    /**
+     * The number of active consumers.
+     */
+    get size(): number;
+    /**
+     * Emits a value to all consumers. The value is buffered for consumption.
+     *
+     * @param value - The value to emit.
+     * @returns `true` if the value was emitted.
+     */
+    emit(value: T): boolean;
+    /**
+     * Waits for the next emitted value without joining as a consumer.
+     * Does not buffer - only receives values emitted after calling.
+     *
+     * @returns A promise that resolves with the next emitted value.
+     */
+    receive(): Promise<T>;
+    then<OK = T, ERR = never>(onfulfilled?: Fn<[T], MaybePromise<OK>> | null, onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<OK | ERR>;
+    catch<ERR = never>(onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<T | ERR>;
+    finally(onfinally?: Action | null): Promise<T>;
+    /**
+     * Joins the broadcast as a consumer. Returns a handle used to consume values.
+     * The consumer starts at the current buffer position and will only see
+     * values emitted after joining.
+     *
+     * @example
+     * ```typescript
+     * const handle = broadcast.join();
+     * // Use handle with consume(), readable(), leave()
+     * ```
+     */
+    join(): ConsumerHandle<T>;
+    /**
+     * Gets the current cursor position for a consumer handle.
+     *
+     * @param handle - The consumer handle.
+     * @returns The cursor position.
+     * @throws If the handle is invalid (already left or never joined).
+     */
+    getCursor(handle: ConsumerHandle<T>): number;
+    /**
+     * Removes a consumer from the broadcast. The handle becomes invalid after this call.
+     * Idempotent - calling multiple times has no effect.
+     *
+     * @param handle - The consumer handle to remove.
+     */
+    leave(handle: ConsumerHandle<T>): void;
+    /**
+     * Consumes and returns the next value for a consumer.
+     * Advances the consumer's cursor position.
+     *
+     * @param handle - The consumer handle.
+     * @throws If no value is available or the handle is invalid.
+     *
+     * @example
+     * ```typescript
+     * if (broadcast.readable(handle)) {
+     *   const value = broadcast.consume(handle);
+     * }
+     * ```
+     */
+    consume(handle: ConsumerHandle<T>): T;
+    /**
+     * Attempts to consume the next value for a consumer.
+     * Returns `{ done: true }` when no value is currently available.
+     *
+     * @param handle - The consumer handle.
+     * @returns The next value, or `{ done: true }` when nothing is available.
+     * @throws If the handle is invalid.
+     */
+    tryConsume(handle: ConsumerHandle<T>): IteratorResult<T, void>;
+    /**
+     * Checks if there are values available for a consumer to read.
+     *
+     * @param handle - The consumer handle.
+     * @returns `true` if there are unread values, `false` otherwise.
+     */
+    readable(handle: ConsumerHandle<T>): boolean;
+    [Symbol.asyncIterator](): AsyncIterator<T, void, void>;
+    dispose(): void;
+    [Symbol.dispose](): void;
+}

package/build/broadcast.js

@@ -0,0 +1,184 @@
+import { RingBuffer } from "./ring-buffer.js";
+import { Signal } from "./signal.js";
+import { Disposer } from "./async.js";
+import { min } from "./utils.js";
+export class ConsumerHandle {
+    #broadcast;
+    constructor(broadcast){
+        this.#broadcast = broadcast;
+    }
+    get cursor() {
+        return this.#broadcast.getCursor(this);
+    }
+    [Symbol.dispose]() {
+        this.#broadcast.leave(this);
+    }
+}
+export class BroadcastIterator {
+    #broadcast;
+    #signal;
+    #handle;
+    constructor(broadcast, signal, handle){
+        this.#broadcast = broadcast;
+        this.#signal = signal;
+        this.#handle = handle;
+    }
+    async next() {
+        try {
+            while(true){
+                const result = this.#broadcast.tryConsume(this.#handle);
+                if (!result.done) {
+                    return {
+                        value: result.value,
+                        done: false
+                    };
+                }
+                await this.#signal.receive();
+            }
+        } catch  {
+            return {
+                value: undefined,
+                done: true
+            };
+        }
+    }
+    async return() {
+        this.#broadcast.leave(this.#handle);
+        return {
+            value: undefined,
+            done: true
+        };
+    }
+}
+export class Broadcast {
+    #buffer = new RingBuffer();
+    #signal = new Signal();
+    #disposer;
+    #sink;
+    #nextId = 0;
+    #cursors = new Map();
+    #handles = new WeakMap();
+    #minCursor = 0;
+    #registry = new FinalizationRegistry((id)=>{
+        const cursor = this.#cursors.get(id);
+        this.#cursors.delete(id);
+        if (cursor === this.#minCursor) {
+            this.#minCursor = min(this.#cursors.values(), this.#buffer.right);
+            const shift = this.#minCursor - this.#buffer.left;
+            if (shift > 0) this.#buffer.shiftN(shift);
+        }
+    });
+    [Symbol.toStringTag] = 'Broadcast';
+    constructor(){
+        this.#disposer = new Disposer(this);
+    }
+    get sink() {
+        return this.#sink ??= this.emit.bind(this);
+    }
+    handleEvent(event) {
+        this.emit(event);
+    }
+    get size() {
+        return this.#cursors.size;
+    }
+    emit(value) {
+        if (this.#disposer.disposed) {
+            return false;
+        }
+        this.#buffer.push(value);
+        this.#signal.emit(value);
+        return true;
+    }
+    receive() {
+        return this.#signal.receive();
+    }
+    then(onfulfilled, onrejected) {
+        return this.receive().then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.receive().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.receive().finally(onfinally);
+    }
+    join() {
+        const id = this.#nextId++;
+        const cursor = this.#buffer.right;
+        const handle = new ConsumerHandle(this);
+        this.#handles.set(handle, id);
+        this.#cursors.set(id, cursor);
+        if (this.#cursors.size === 1 || cursor < this.#minCursor) {
+            this.#minCursor = cursor;
+        }
+        this.#registry.register(handle, id, handle);
+        return handle;
+    }
+    getCursor(handle) {
+        const id = this.#handles.get(handle);
+        if (id === undefined) throw new Error('Invalid handle');
+        const cursor = this.#cursors.get(id);
+        if (cursor === undefined) throw new Error('Invalid handle');
+        return cursor;
+    }
+    leave(handle) {
+        const id = this.#handles.get(handle);
+        if (id === undefined) return;
+        const cursor = this.#cursors.get(id);
+        this.#handles.delete(handle);
+        this.#cursors.delete(id);
+        this.#registry.unregister(handle);
+        if (cursor === this.#minCursor) {
+            this.#minCursor = min(this.#cursors.values(), this.#buffer.right);
+            const shift = this.#minCursor - this.#buffer.left;
+            if (shift > 0) this.#buffer.shiftN(shift);
+        }
+    }
+    consume(handle) {
+        const result = this.tryConsume(handle);
+        if (result.done) {
+            throw new Error('No value available');
+        }
+        return result.value;
+    }
+    tryConsume(handle) {
+        const id = this.#handles.get(handle);
+        if (id === undefined) throw new Error('Invalid handle');
+        const cursor = this.#cursors.get(id);
+        if (cursor === undefined) throw new Error('Invalid handle');
+        if (cursor >= this.#buffer.right) {
+            return {
+                value: undefined,
+                done: true
+            };
+        }
+        const value = this.#buffer.peekAt(cursor);
+        this.#cursors.set(id, cursor + 1);
+        if (cursor === this.#minCursor) {
+            this.#minCursor = min(this.#cursors.values(), this.#buffer.right);
+            const shift = this.#minCursor - this.#buffer.left;
+            if (shift > 0) this.#buffer.shiftN(shift);
+        }
+        return {
+            value,
+            done: false
+        };
+    }
+    readable(handle) {
+        return this.getCursor(handle) < this.#buffer.right;
+    }
+    [Symbol.asyncIterator]() {
+        return new BroadcastIterator(this, this.#signal, this.join());
+    }
+    dispose() {
+        this[Symbol.dispose]();
+    }
+    [Symbol.dispose]() {
+        if (this.#disposer[Symbol.dispose]()) {
+            this.#signal[Symbol.dispose]();
+            this.#buffer.clear();
+            this.#cursors.clear();
+        }
+    }
+}
+
+//# sourceMappingURL=broadcast.js.map

package/build/broadcast.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/broadcast.ts"],"sourcesContent":["import { RingBuffer } from './ring-buffer.js';\nimport { Signal } from './signal.js';\nimport { Disposer } from './async.js';\nimport { min } from './utils.js';\nimport { Action, Fn, Emitter, MaybePromise, Promiseable } from './types.js';\n\n/**\n * A handle representing a consumer's position in a Broadcast.\n * Returned by `Broadcast.join()` and used to consume values.\n * Implements Disposable for automatic cleanup via `using` keyword.\n *\n * @example\n * ```typescript\n * const broadcast = new Broadcast<number>();\n * using handle = broadcast.join();\n * broadcast.emit(42);\n * const value = broadcast.consume(handle); // 42\n * ```\n */\nexport class ConsumerHandle<T> implements Disposable {\n  #broadcast: Broadcast<T>;\n\n  constructor(broadcast: Broadcast<T>) {\n    this.#broadcast = broadcast;\n  }\n\n  /**\n   * The current position of this consumer in the buffer.\n   */\n  get cursor(): number {\n    return this.#broadcast.getCursor(this);\n  }\n\n  /**\n   * Leaves the broadcast, releasing this consumer's position.\n   */\n  [Symbol.dispose](): void {\n    this.#broadcast.leave(this);\n  }\n}\n\n/**\n * @internal\n */\nexport class BroadcastIterator<T> implements AsyncIterator<T, void, void> {\n  #broadcast: Broadcast<T>;\n  #signal: Signal<T>;\n  #handle: ConsumerHandle<T>;\n\n  constructor(broadcast: Broadcast<T>, signal: Signal<T>, handle: ConsumerHandle<T>) {\n    this.#broadcast = broadcast;\n    this.#signal = signal;\n    this.#handle = handle;\n  }\n\n  async next(): Promise<IteratorResult<T, void>> {\n    try {\n      while (true) {\n        const result = this.#broadcast.tryConsume(this.#handle);\n        if (!result.done) {\n          return { value: result.value, done: false };\n        }\n        await this.#signal.receive();\n      }\n    } catch {\n      return { value: undefined, done: true };\n    }\n  }\n\n  async return(): Promise<IteratorResult<T, void>> {\n    this.#broadcast.leave(this.#handle);\n    return { value: undefined, done: true };\n  }\n}\n\n/**\n * A multi-consumer FIFO queue where each consumer maintains its own read position.\n * Values are buffered and each consumer can read them independently at their own pace.\n * The buffer automatically compacts when all consumers have read past a position.\n *\n * Key characteristics:\n * - Multiple consumers - each gets their own cursor position\n * - Buffered delivery - values are stored until all consumers read them\n * - Late joiners only see values emitted after joining\n * - Automatic cleanup via FinalizationRegistry when handles are garbage collected\n *\n * Differs from:\n * - Event: Broadcast buffers values, Event does not\n * - Sequence: Broadcast supports multiple consumers, Sequence is single-consumer\n * - Signal: Broadcast buffers values, Signal only notifies current waiters\n *\n * @template T - The type of values in the broadcast\n *\n * @example\n * ```typescript\n * const broadcast = new Broadcast<number>();\n *\n * const handle1 = broadcast.join();\n * const handle2 = broadcast.join();\n *\n * broadcast.emit(1);\n * broadcast.emit(2);\n *\n * broadcast.consume(handle1); // 1\n * broadcast.consume(handle2); // 1\n * broadcast.consume(handle1); // 2\n * ```\n */\nexport class Broadcast<T> implements Emitter<T, boolean>, Promiseable<T>, Promise<T>, Disposable, AsyncIterable<T> {\n  #buffer = new RingBuffer<T>();\n  #signal = new Signal<T>();\n  #disposer: Disposer;\n  #sink?: Fn<[T], boolean>;\n  #nextId = 0;\n  #cursors = new Map<number, number>();\n  #handles = new WeakMap<ConsumerHandle<T>, number>();\n  #minCursor = 0;\n\n  // Stryker disable all: FinalizationRegistry callback only testable via GC, excluded from mutation testing\n  #registry = new FinalizationRegistry<number>((id) => {\n    const cursor = this.#cursors.get(id)!;\n    this.#cursors.delete(id);\n\n    if (cursor === this.#minCursor) {\n      this.#minCursor = min(this.#cursors.values(), this.#buffer.right);\n      const shift = this.#minCursor - this.#buffer.left;\n      if (shift > 0) this.#buffer.shiftN(shift);\n    }\n  });\n  // Stryker restore all\n\n  readonly [Symbol.toStringTag] = 'Broadcast';\n\n  constructor() {\n    this.#disposer = new Disposer(this);\n  }\n\n  /**\n   * Returns a bound emit function for use as a callback.\n   */\n  get sink(): Fn<[T], boolean> {\n    return (this.#sink ??= this.emit.bind(this));\n  }\n\n  /**\n   * DOM EventListener interface compatibility.\n   */\n  handleEvent(event: T): void {\n    this.emit(event);\n  }\n\n  /**\n   * The number of active consumers.\n   */\n  get size(): number {\n    return this.#cursors.size;\n  }\n\n  /**\n   * Emits a value to all consumers. The value is buffered for consumption.\n   *\n   * @param value - The value to emit.\n   * @returns `true` if the value was emitted.\n   */\n  emit(value: T): boolean {\n    if (this.#disposer.disposed) {\n      return false;\n    }\n    this.#buffer.push(value);\n    this.#signal.emit(value);\n    return true;\n  }\n\n  /**\n   * Waits for the next emitted value without joining as a consumer.\n   * Does not buffer - only receives values emitted after calling.\n   *\n   * @returns A promise that resolves with the next emitted value.\n   */\n  receive(): Promise<T> {\n    return this.#signal.receive();\n  }\n\n  then<OK = T, ERR = never>(onfulfilled?: Fn<[T], MaybePromise<OK>> | null, onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<OK | ERR> {\n    return this.receive().then(onfulfilled, onrejected);\n  }\n\n  catch<ERR = never>(onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<T | ERR> {\n    return this.receive().catch(onrejected);\n  }\n\n  finally(onfinally?: Action | null): Promise<T> {\n    return this.receive().finally(onfinally);\n  }\n\n  /**\n   * Joins the broadcast as a consumer. Returns a handle used to consume values.\n   * The consumer starts at the current buffer position and will only see\n   * values emitted after joining.\n   *\n   * @example\n   * ```typescript\n   * const handle = broadcast.join();\n   * // Use handle with consume(), readable(), leave()\n   * ```\n   */\n  join(): ConsumerHandle<T> {\n    // Stryker disable next-line UpdateOperator: IDs only need uniqueness, direction is irrelevant\n    const id = this.#nextId++;\n    const cursor = this.#buffer.right;\n    const handle = new ConsumerHandle<T>(this);\n\n    this.#handles.set(handle, id);\n    this.#cursors.set(id, cursor);\n\n    // Stryker disable all: minCursor is an optimization hint; tryConsume recalculates on use\n    if (this.#cursors.size === 1 || cursor < this.#minCursor) {\n      this.#minCursor = cursor;\n    }\n    // Stryker restore all\n\n    this.#registry.register(handle, id, handle);\n    return handle;\n  }\n\n  /**\n   * Gets the current cursor position for a consumer handle.\n   *\n   * @param handle - The consumer handle.\n   * @returns The cursor position.\n   * @throws If the handle is invalid (already left or never joined).\n   */\n  getCursor(handle: ConsumerHandle<T>): number {\n    const id = this.#handles.get(handle);\n    // Stryker disable next-line ConditionalExpression: second cursor check catches invalid handles\n    if (id === undefined) throw new Error('Invalid handle');\n    const cursor = this.#cursors.get(id);\n    if (cursor === undefined) throw new Error('Invalid handle');\n    return cursor;\n  }\n\n  /**\n   * Removes a consumer from the broadcast. The handle becomes invalid after this call.\n   * Idempotent - calling multiple times has no effect.\n   *\n   * @param handle - The consumer handle to remove.\n   */\n  leave(handle: ConsumerHandle<T>): void {\n    const id = this.#handles.get(handle);\n    // Stryker disable next-line ConditionalExpression,EqualityOperator: subsequent ops are safe with undefined id\n    if (id === undefined) return;\n\n    const cursor = this.#cursors.get(id)!;\n    this.#handles.delete(handle);\n    this.#cursors.delete(id);\n    this.#registry.unregister(handle);\n\n    // Stryker disable all: compaction condition is optimization; buffer reads are correct regardless\n    if (cursor === this.#minCursor) {\n      this.#minCursor = min(this.#cursors.values(), this.#buffer.right);\n      const shift = this.#minCursor - this.#buffer.left;\n      if (shift > 0) this.#buffer.shiftN(shift);\n    }\n    // Stryker restore all\n  }\n\n  /**\n   * Consumes and returns the next value for a consumer.\n   * Advances the consumer's cursor position.\n   *\n   * @param handle - The consumer handle.\n   * @throws If no value is available or the handle is invalid.\n   *\n   * @example\n   * ```typescript\n   * if (broadcast.readable(handle)) {\n   *   const value = broadcast.consume(handle);\n   * }\n   * ```\n   */\n  consume(handle: ConsumerHandle<T>): T {\n    const result = this.tryConsume(handle);\n    if (result.done) {\n      throw new Error('No value available');\n    }\n    return result.value;\n  }\n\n  /**\n   * Attempts to consume the next value for a consumer.\n   * Returns `{ done: true }` when no value is currently available.\n   *\n   * @param handle - The consumer handle.\n   * @returns The next value, or `{ done: true }` when nothing is available.\n   * @throws If the handle is invalid.\n   */\n  tryConsume(handle: ConsumerHandle<T>): IteratorResult<T, void> {\n    const id = this.#handles.get(handle);\n    // Stryker disable next-line ConditionalExpression: second cursor check catches invalid handles\n    if (id === undefined) throw new Error('Invalid handle');\n\n    const cursor = this.#cursors.get(id);\n    if (cursor === undefined) throw new Error('Invalid handle');\n    if (cursor >= this.#buffer.right) {\n      return { value: undefined, done: true };\n    }\n\n    const value = this.#buffer.peekAt(cursor)!;\n    this.#cursors.set(id, cursor + 1);\n\n    // Stryker disable all: compaction condition is optimization; buffer reads are correct regardless\n    if (cursor === this.#minCursor) {\n      this.#minCursor = min(this.#cursors.values(), this.#buffer.right);\n      const shift = this.#minCursor - this.#buffer.left;\n      if (shift > 0) this.#buffer.shiftN(shift);\n    }\n    // Stryker restore all\n\n    return { value, done: false };\n  }\n\n  /**\n   * Checks if there are values available for a consumer to read.\n   *\n   * @param handle - The consumer handle.\n   * @returns `true` if there are unread values, `false` otherwise.\n   */\n  readable(handle: ConsumerHandle<T>): boolean {\n    return this.getCursor(handle) < this.#buffer.right;\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T, void, void> {\n    return new BroadcastIterator(this, this.#signal, this.join());\n  }\n\n  dispose(): void {\n    this[Symbol.dispose]();\n  }\n\n  [Symbol.dispose](): void {\n    // Stryker disable next-line ConditionalExpression: double-dispose re-clears empty collections, no observable effect\n    if (this.#disposer[Symbol.dispose]()) {\n      this.#signal[Symbol.dispose]();\n      this.#buffer.clear();\n      this.#cursors.clear();\n    }\n  }\n}\n"],"names":["RingBuffer","Signal","Disposer","min","ConsumerHandle","broadcast","cursor","getCursor","Symbol","dispose","leave","BroadcastIterator","signal","handle","next","result","tryConsume","done","value","receive","undefined","return","Broadcast","Map","WeakMap","FinalizationRegistry","id","get","delete","values","right","shift","left","shiftN","toStringTag","sink","emit","bind","handleEvent","event","size","disposed","push","then","onfulfilled","onrejected","catch","finally","onfinally","join","set","register","Error","unregister","consume","peekAt","readable","asyncIterator","clear"],"mappings":"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"}

package/build/dispatch-result.cjs

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DispatchResult () {
+        return DispatchResult;
+    },
+    get err () {
+        return err;
+    },
+    get isErr () {
+        return isErr;
+    },
+    get isOk () {
+        return isOk;
+    },
+    get unwrap () {
+        return unwrap;
+    }
+});
+const _utilscjs = require("./utils.cjs");
+const ERR_BRAND = Symbol.for('evnty.ResultError');
+function ResultError(error) {
+    this.error = error;
+}
+ResultError.prototype[ERR_BRAND] = true;
+function err(error) {
+    return new ResultError(error);
+}
+function isErr(result) {
+    return typeof result === 'object' && result !== null && result[ERR_BRAND] === true;
+}
+function isOk(result) {
+    return typeof result !== 'object' || result === null || !result[ERR_BRAND];
+}
+function unwrap(results) {
+    const len = results.length;
+    const unwrapped = new Array(len);
+    for(let i = 0; i < len; i++){
+        const r = results[i];
+        unwrapped[i] = isErr(r) ? Promise.reject(r.error) : r;
+    }
+    return unwrapped;
+}
+async function resolveMaybePromises(items, asyncIndices) {
+    const pending = new Array(asyncIndices.length);
+    for(let j = 0; j < asyncIndices.length; j++){
+        pending[j] = items[asyncIndices[j]];
+    }
+    const resolved = await Promise.all(pending);
+    for(let j = 0; j < asyncIndices.length; j++){
+        items[asyncIndices[j]] = resolved[j];
+    }
+    return items;
+}
+function resolveAll(results) {
+    const len = results.length;
+    if (len === 0) return results;
+    let firstError;
+    let hasError = false;
+    let asyncIndices = null;
+    for(let i = 0; i < len; i++){
+        const r = results[i];
+        if (isErr(r)) {
+            if (!hasError) {
+                hasError = true;
+                firstError = r.error;
+            }
+        } else try {
+            if ((0, _utilscjs.isThenable)(r)) (asyncIndices ??= []).push(i);
+        } catch (e) {
+            if (!hasError) {
+                hasError = true;
+                firstError = e;
+            }
+        }
+    }
+    if (hasError) {
+        if (asyncIndices !== null) {
+            for(let j = 0; j < asyncIndices.length; j++){
+                results[asyncIndices[j]].then(_utilscjs.noop, _utilscjs.noop);
+            }
+        }
+        return Promise.reject(firstError);
+    }
+    if (asyncIndices === null) return results;
+    return resolveMaybePromises(results, asyncIndices);
+}
+function settleAll(results) {
+    const len = results.length;
+    if (len === 0) return [];
+    let asyncIndices = null;
+    const settled = new Array(len);
+    for(let i = 0; i < len; i++){
+        const r = results[i];
+        if (isErr(r)) {
+            settled[i] = {
+                status: 'rejected',
+                reason: r.error
+            };
+        } else try {
+            if ((0, _utilscjs.isThenable)(r)) {
+                const wrapped = r.then((value)=>({
+                        status: 'fulfilled',
+                        value
+                    }), (reason)=>({
+                        status: 'rejected',
+                        reason
+                    }));
+                (asyncIndices ??= []).push(i);
+                settled[i] = wrapped;
+            } else {
+                settled[i] = {
+                    status: 'fulfilled',
+                    value: r
+                };
+            }
+        } catch (e) {
+            settled[i] = {
+                status: 'rejected',
+                reason: e
+            };
+        }
+    }
+    if (asyncIndices === null) return settled;
+    return resolveMaybePromises(settled, asyncIndices);
+}
+class DispatchResult {
+    #results;
+    [Symbol.toStringTag] = 'DispatchResult';
+    constructor(results){
+        this.#results = results;
+    }
+    then(onfulfilled, onrejected) {
+        const resolved = this.all();
+        if (resolved instanceof Promise) return resolved.then(onfulfilled, onrejected);
+        return Promise.resolve(resolved).then(onfulfilled, onrejected);
+    }
+    all() {
+        return resolveAll(this.#results);
+    }
+    settled() {
+        return settleAll(this.#results);
+    }
+}
+
+//# sourceMappingURL=dispatch-result.cjs.map

package/build/dispatch-result.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dispatch-result.ts"],"sourcesContent":["import { Fn, MaybePromise } from './types.js';\nimport { isThenable, noop } from './utils.js';\n\nconst ERR_BRAND = Symbol.for('evnty.ResultError');\n\n/**\n * @internal\n */\nexport interface ResultError<E = unknown> {\n  readonly error: E;\n  readonly [ERR_BRAND]: true;\n}\n\nfunction ResultError<E>(this: ResultError<E>, error: E): void {\n  (this as { error: E }).error = error;\n}\n(ResultError.prototype as { [ERR_BRAND]: true })[ERR_BRAND] = true;\n\n/**\n * @internal\n */\nexport function err<E>(error: E): ResultError<E> {\n  return new (ResultError as unknown as new (error: E) => ResultError<E>)(error);\n}\n\n/**\n * @internal\n */\nexport function isErr(result: unknown): result is ResultError<unknown> {\n  return typeof result === 'object' && result !== null && (result as Record<symbol, boolean>)[ERR_BRAND] === true;\n}\n\n/**\n * @internal\n */\nexport function isOk(result: unknown): boolean {\n  return typeof result !== 'object' || result === null || !(result as Record<symbol, boolean>)[ERR_BRAND];\n}\n\n/**\n * @internal\n */\nexport type DispatchResultItem<T> = MaybePromise<T> | ResultError;\n\n/**\n * @internal\n */\nexport function unwrap<T>(results: DispatchResultItem<T>[]): MaybePromise<T>[] {\n  const len = results.length;\n  const unwrapped = new Array<MaybePromise<T>>(len);\n  for (let i = 0; i < len; i++) {\n    const r = results[i];\n    unwrapped[i] = isErr(r) ? Promise.reject(r.error) : r;\n  }\n  return unwrapped;\n}\n\nasync function resolveMaybePromises<T>(items: MaybePromise<T>[], asyncIndices: number[]): Promise<T[]> {\n  const pending = new Array<PromiseLike<T>>(asyncIndices.length);\n  for (let j = 0; j < asyncIndices.length; j++) {\n    pending[j] = items[asyncIndices[j]] as PromiseLike<T>;\n  }\n  const resolved = await Promise.all(pending);\n  for (let j = 0; j < asyncIndices.length; j++) {\n    items[asyncIndices[j]] = resolved[j];\n  }\n  return items as T[];\n}\n\nfunction resolveAll<T>(results: DispatchResultItem<T>[]): T[] | Promise<T[]> {\n  const len = results.length;\n  if (len === 0) return results as T[];\n\n  let firstError: unknown;\n  let hasError = false;\n  let asyncIndices: number[] | null = null;\n\n  for (let i = 0; i < len; i++) {\n    const r = results[i];\n    if (isErr(r)) {\n      if (!hasError) {\n        hasError = true;\n        firstError = r.error;\n      }\n    } else\n      try {\n        if (isThenable(r)) (asyncIndices ??= []).push(i);\n      } catch (e) {\n        if (!hasError) {\n          hasError = true;\n          firstError = e;\n        }\n      }\n  }\n\n  if (hasError) {\n    if (asyncIndices !== null) {\n      for (let j = 0; j < asyncIndices.length; j++) {\n        (results[asyncIndices[j]] as PromiseLike<T>).then(noop, noop);\n      }\n    }\n    return Promise.reject(firstError);\n  }\n  if (asyncIndices === null) return results as T[];\n\n  return resolveMaybePromises(results as MaybePromise<T>[], asyncIndices);\n}\n\nfunction settleAll<T>(results: DispatchResultItem<T>[]): PromiseSettledResult<T>[] | Promise<PromiseSettledResult<T>[]> {\n  const len = results.length;\n  if (len === 0) return [] as PromiseSettledResult<T>[];\n\n  let asyncIndices: number[] | null = null;\n  const settled = new Array<MaybePromise<PromiseSettledResult<T>>>(len);\n\n  for (let i = 0; i < len; i++) {\n    const r = results[i];\n    if (isErr(r)) {\n      settled[i] = { status: 'rejected', reason: r.error };\n    } else\n      try {\n        if (isThenable(r)) {\n          const wrapped = r.then(\n            (value: T): PromiseFulfilledResult<T> => ({ status: 'fulfilled', value }),\n            (reason: unknown): PromiseRejectedResult => ({ status: 'rejected', reason }),\n          );\n          (asyncIndices ??= []).push(i);\n          settled[i] = wrapped;\n        } else {\n          settled[i] = { status: 'fulfilled', value: r };\n        }\n      } catch (e) {\n        settled[i] = { status: 'rejected', reason: e };\n      }\n  }\n\n  if (asyncIndices === null) return settled as PromiseSettledResult<T>[];\n\n  return resolveMaybePromises(settled, asyncIndices);\n}\n\n/**\n * Wraps an array of values or promises (typically listener results) and provides batch resolution.\n *\n * @template T\n */\nexport class DispatchResult<T> implements PromiseLike<T[]> {\n  #results: DispatchResultItem<T>[];\n\n  readonly [Symbol.toStringTag] = 'DispatchResult';\n\n  constructor(results: DispatchResultItem<T>[]) {\n    this.#results = results;\n  }\n\n  then<TResult1 = T, TResult2 = never>(\n    onfulfilled?: Fn<[T[]], MaybePromise<TResult1>> | null,\n    onrejected?: Fn<[any], MaybePromise<TResult2>> | null,\n  ): PromiseLike<TResult1 | TResult2> {\n    const resolved = this.all();\n    if (resolved instanceof Promise) return resolved.then(onfulfilled, onrejected);\n    return Promise.resolve(resolved).then(onfulfilled, onrejected);\n  }\n\n  /**\n   * Resolves all listener results, rejecting if any promise rejects or any ResultError exists.\n   */\n  all(): T[] | Promise<T[]> {\n    return resolveAll(this.#results);\n  }\n\n  /**\n   * Waits for all listener results to settle, regardless of fulfillment or rejection.\n   */\n  settled(): PromiseSettledResult<T>[] | Promise<PromiseSettledResult<T>[]> {\n    return settleAll(this.#results);\n  }\n}\n"],"names":["DispatchResult","err","isErr","isOk","unwrap","ERR_BRAND","Symbol","for","ResultError","error","prototype","result","results","len","length","unwrapped","Array","i","r","Promise","reject","resolveMaybePromises","items","asyncIndices","pending","j","resolved","all","resolveAll","firstError","hasError","isThenable","push","e","then","noop","settleAll","settled","status","reason","wrapped","value","toStringTag","onfulfilled","onrejected","resolve"],"mappings":"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"}

package/build/dispatch-result.d.ts

@@ -0,0 +1,49 @@
+import { Fn, MaybePromise } from './types.js';
+declare const ERR_BRAND: unique symbol;
+/**
+ * @internal
+ */
+export interface ResultError<E = unknown> {
+    readonly error: E;
+    readonly [ERR_BRAND]: true;
+}
+/**
+ * @internal
+ */
+export declare function err<E>(error: E): ResultError<E>;
+/**
+ * @internal
+ */
+export declare function isErr(result: unknown): result is ResultError<unknown>;
+/**
+ * @internal
+ */
+export declare function isOk(result: unknown): boolean;
+/**
+ * @internal
+ */
+export type DispatchResultItem<T> = MaybePromise<T> | ResultError;
+/**
+ * @internal
+ */
+export declare function unwrap<T>(results: DispatchResultItem<T>[]): MaybePromise<T>[];
+/**
+ * Wraps an array of values or promises (typically listener results) and provides batch resolution.
+ *
+ * @template T
+ */
+export declare class DispatchResult<T> implements PromiseLike<T[]> {
+    #private;
+    readonly [Symbol.toStringTag] = "DispatchResult";
+    constructor(results: DispatchResultItem<T>[]);
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: Fn<[T[]], MaybePromise<TResult1>> | null, onrejected?: Fn<[any], MaybePromise<TResult2>> | null): PromiseLike<TResult1 | TResult2>;
+    /**
+     * Resolves all listener results, rejecting if any promise rejects or any ResultError exists.
+     */
+    all(): T[] | Promise<T[]>;
+    /**
+     * Waits for all listener results to settle, regardless of fulfillment or rejection.
+     */
+    settled(): PromiseSettledResult<T>[] | Promise<PromiseSettledResult<T>[]>;
+}
+export {};