happy-rusty 1.9.0 → 1.9.2

package/dist/types.d.ts

@@ -41,6 +41,7 @@ pub enum Result<T, E> {
 ```
  * @typeParam T - The type of the value contained in a successful `Result`.
  * @typeParam E - The type of the error contained in an unsuccessful `Result`.
+ * @since 1.0.0
  * @see https://doc.rust-lang.org/std/result/enum.Result.html
  */
 interface Result<T, E> {
@@ -663,6 +664,8 @@ interface Result<T, E> {
      */
     asErr<U>(): Result<U, E>;
     /**
+     * **Non-standard extension**: This method is not part of Rust's standard library.
+     *
      * Like `andThenAsync`, but automatically catches any thrown exceptions or Promise rejections
      * and converts them to `Err`.
      *
@@ -676,6 +679,7 @@ interface Result<T, E> {
      * @typeParam U - The type of the value returned by the function.
      * @param fn - A function that takes the `Ok` value and returns `PromiseLike<U>` or `U`. May throw or reject.
      * @returns A promise that resolves to `Ok(U)` if successful, or `Err(E)` if `this` is `Err` or if `fn` throws/rejects.
+     * @since 1.9.0
      * @see andThenAsync
      * @see tryAsyncResult
      * @example
@@ -703,6 +707,8 @@ interface Result<T, E> {
      */
     andTryAsync<U>(fn: (value: T) => PromiseLike<U> | U): AsyncResult<Awaited<U>, E>;
     /**
+     * **Non-standard extension**: This method is not part of Rust's standard library.
+     *
      * Like `orElseAsync`, but automatically catches any thrown exceptions or Promise rejections
      * and converts them to `Err`.
      *
@@ -716,6 +722,7 @@ interface Result<T, E> {
      * @typeParam F - The type of the error returned by the function.
      * @param fn - A function that takes the `Err` value and returns `PromiseLike<T>` or `T`. May throw or reject.
      * @returns A promise that resolves to `Ok(T)` if `this` is `Ok` or if `fn` succeeds, or `Err(F)` if `fn` throws/rejects.
+     * @since 1.9.0
      * @see orElseAsync
      * @see tryAsyncResult
      * @example
@@ -749,6 +756,7 @@ interface Result<T, E> {
  *
  * @typeParam T - The type of the value that is produced by a successful operation.
  * @typeParam E - The type of the error that may be produced by a failed operation.
+ * @since 1.5.0
  * @example
  * ```ts
  * async function fetchUser(id: number): AsyncResult<User, Error> {
@@ -772,6 +780,7 @@ type AsyncResult<T, E> = Promise<Result<T, E>>;
  *
  * @typeParam T - The type of the value that is produced by a successful operation.
  * @typeParam E - The type of the error that may be produced by a failed operation.
+ * @since 1.8.0
  * @example
  * ```ts
  * // Works with any PromiseLike, not just Promise
@@ -823,6 +832,7 @@ pub enum Option<T> {
 }
 ```
  * @typeParam T - The type of the value contained in the `Some` variant.
+ * @since 1.0.0
  * @see https://doc.rust-lang.org/std/option/enum.Option.html
  */
 interface Option<T> {
@@ -1429,6 +1439,7 @@ interface Option<T> {
  * and return an `Option` as the result.
  *
  * @typeParam T - The type of the value that may be contained in the `Some` variant.
+ * @since 1.5.0
  * @example
  * ```ts
  * async function fetchUser(id: number): AsyncOption<User> {
@@ -1447,6 +1458,7 @@ type AsyncOption<T> = Promise<Option<T>>;
  * allowing compatibility with any thenable object.
  *
  * @typeParam T - The type of the value that may be contained in the `Some` variant.
+ * @since 1.8.0
  * @example
  * ```ts
  * // Works with any PromiseLike, not just Promise
@@ -1470,7 +1482,7 @@ type AsyncLikeOption<T> = PromiseLike<Option<T>>;
  * @param fn - A function that may throw an exception.
  * @param args - Arguments to pass to the function.
  * @returns `Some<T>` if the function succeeds, or `None` if it throws.
- *
+ * @since 1.7.0
  * @example
  * ```ts
  * // Parse JSON, ignore error details
@@ -1501,7 +1513,7 @@ declare function tryOption<T, Args extends unknown[]>(fn: (...args: Args) => T,
  * @typeParam T - The type of the value that the promise resolves to.
  * @param task - A promise or promise-like object to await.
  * @returns A promise that resolves to `Some<T>` if successful, or `None` if rejected.
- *
+ * @since 1.7.0
  * @example
  * ```ts
  * // Fetch data, ignore error details
@@ -1529,7 +1541,7 @@ declare function tryAsyncOption<T>(task: PromiseLike<T>): AsyncOption<Awaited<T>
  * @param task - A function that returns a value or promise-like object.
  * @param args - Arguments to pass to the function.
  * @returns A promise that resolves to `Some<T>` if successful, or `None` if thrown or rejected.
- *
+ * @since 1.7.0
  * @example
  * ```ts
  * // Function with arguments
@@ -1569,6 +1581,7 @@ declare function tryAsyncOption<T, Args extends unknown[]>(task: (...args: Args)
  * @typeParam T - The expected type of the value contained within the `Option`.
  * @param o - The value to be checked as an `Option`.
  * @returns `true` if the value is an `Option`, otherwise `false`.
+ * @since 1.2.0
  * @example
  * ```ts
  * const x = Some(5);
@@ -1586,7 +1599,7 @@ declare function isOption<T>(o: unknown): o is Option<T>;
  * @typeParam T - The type of the value to be wrapped in a `Some`.
  * @param value - The value to wrap as a `Some` option.
  * @returns An `Option<T>` that contains the provided value, representing the `Some` case.
- *
+ * @since 1.0.0
  * @example
  * ```ts
  * const maybeValue = Some(1); // Option<number> with a value
@@ -1641,6 +1654,7 @@ interface None extends Option<never> {
  * A constant representing the `None` case of an `Option`, indicating the absence of a value.
  * This constant is frozen to ensure it is immutable and cannot be altered, preserving the integrity of `None` throughout the application.
  *
+ * @since 1.0.0
  * @example
  * ```ts
  * // Use None to represent absence of a value
@@ -1668,6 +1682,7 @@ declare const None: None;
  * Since `None extends Option<never>`, this constant can be assigned to any
  * `AsyncOption<T>` (i.e., `Promise<Option<T>>`) due to TypeScript's covariance.
  *
+ * @since 1.8.0
  * @example
  * ```ts
  * async function findUser(id: number): AsyncOption<User> {
@@ -1699,7 +1714,7 @@ declare const ASYNC_NONE: Promise<None>;
  * @typeParam E - The type of the error that the result could potentially contain (not used in this case).
  * @param value - The value to wrap as an `Ok` result.
  * @returns A `Result<T, E>` that contains the provided value, representing the `Ok` case.
- *
+ * @since 1.0.0
  * @example
  * ```ts
  * const goodResult = Ok<number, Error>(1); // Result<number, Error> with a value
@@ -1718,7 +1733,7 @@ declare function Ok<T, E = never>(value: T): Result<T, E>;
  *
  * @typeParam E - The type of the error that the result could potentially contain.
  * @returns A `Result<void, E>` representing a successful operation with no value.
- *
+ * @since 1.4.0
  * @example
  * ```ts
  * function saveToFile(path: string): Result<void, Error> {
@@ -1745,7 +1760,7 @@ declare function Ok<E = never>(): Result<void, E>;
  * @typeParam E - The type of the error to be wrapped in the `Err` result.
  * @param error - The error to wrap as an `Err` result.
  * @returns A `Result<T, E>` that contains the provided error, representing the `Err` case.
- *
+ * @since 1.0.0
  * @example
  * ```ts
  * const badResult = Err<number, Error>(new Error('Something went wrong'));
@@ -1771,6 +1786,7 @@ declare function Err<T = never, E = unknown>(error: E): Result<T, E>;
  * Similar to Rust's `Result<(), E>`.
  *
  * @typeParam E - The type of the error that may be produced by a failed operation.
+ * @since 1.4.0
  * @example
  * ```ts
  * function saveData(data: string): VoidResult<Error> {
@@ -1787,6 +1803,7 @@ type VoidResult<E> = Result<void, E>;
  * `VoidResult<E>` wrapped by `Promise`.
  *
  * @typeParam E - The type of the error that may be produced by a failed operation.
+ * @since 1.4.0
  * @example
  * ```ts
  * async function deleteFile(path: string): AsyncVoidResult<Error> {
@@ -1805,6 +1822,7 @@ type AsyncVoidResult<E> = Promise<VoidResult<E>>;
  * This is a result that is either `Ok(T)` if the operation was successful, or `Err(Error)` if there was an error.
  *
  * @typeParam T - The type of the value that is produced by a successful operation.
+ * @since 1.0.0
  * @example
  * ```ts
  * function parseJSON<T>(json: string): IOResult<T> {
@@ -1822,6 +1840,7 @@ type IOResult<T> = Result<T, Error>;
  * This is a promise that resolves to `Ok(T)` if the I/O operation was successful, or `Err(Error)` if there was an error.
  *
  * @typeParam T - The type of the value that is produced by a successful I/O operation.
+ * @since 1.0.0
  * @example
  * ```ts
  * async function readFile(path: string): AsyncIOResult<string> {
@@ -1837,6 +1856,7 @@ type IOResult<T> = Result<T, Error>;
 type AsyncIOResult<T> = AsyncResult<T, Error>;
 /**
  * Similar to Rust's `Result<(), Error>`.
+ * @since 1.4.0
  * @example
  * ```ts
  * function logMessage(msg: string): VoidIOResult {
@@ -1852,6 +1872,7 @@ type AsyncIOResult<T> = AsyncResult<T, Error>;
 type VoidIOResult = IOResult<void>;
 /**
  * `VoidIOResult` wrapped by `Promise`.
+ * @since 1.4.0
  * @example
  * ```ts
  * async function sendEmail(to: string, body: string): AsyncVoidIOResult {
@@ -1874,6 +1895,7 @@ type AsyncVoidIOResult = AsyncIOResult<void>;
  * - Safe extraction via `intoOk()` without runtime checks
  *
  * @typeParam T - The type of the value that is always produced.
+ * @since 1.8.0
  * @see {@link Result.intoOk}
  * @example
  * ```ts
@@ -1889,6 +1911,7 @@ type SafeResult<T> = Result<T, never>;
  * `SafeResult<T>` wrapped by `Promise`.
  *
  * @typeParam T - The type of the value that is always produced.
+ * @since 1.8.0
  * @example
  * ```ts
  * async function loadCachedData(): AsyncSafeResult<Data> {
@@ -1902,6 +1925,7 @@ type AsyncSafeResult<T> = Promise<SafeResult<T>>;
 /**
  * Result constant for `true`.
  * Can be used anywhere due to immutability.
+ * @since 1.3.0
  * @example
  * ```ts
  * function validate(): Result<boolean, Error> {
@@ -1916,6 +1940,7 @@ declare const RESULT_TRUE: Result<boolean, never>;
 /**
  * Result constant for `false`.
  * Can be used anywhere due to immutability.
+ * @since 1.3.0
  * @example
  * ```ts
  * function validate(): Result<boolean, Error> {
@@ -1930,6 +1955,7 @@ declare const RESULT_FALSE: Result<boolean, never>;
 /**
  * Result constant for `0`.
  * Can be used anywhere due to immutability.
+ * @since 1.3.0
  * @example
  * ```ts
  * function count(): Result<number, Error> {
@@ -1944,6 +1970,7 @@ declare const RESULT_ZERO: Result<number, never>;
 /**
  * Result constant for `void` or `()`.
  * Can be used anywhere due to immutability.
+ * @since 1.4.0
  * @example
  * ```ts
  * function doSomething(): Result<void, Error> {
@@ -1970,7 +1997,7 @@ declare const RESULT_VOID: Result<void, never>;
  * @param fn - A function that may throw an exception.
  * @param args - Arguments to pass to the function.
  * @returns `Ok<T>` if the function succeeds, or `Err<E>` if it throws.
- *
+ * @since 1.7.0
  * @example
  * ```ts
  * // Parse JSON safely with arguments
@@ -2006,7 +2033,7 @@ declare function tryResult<T, E = Error, Args extends unknown[] = []>(fn: (...ar
  * @typeParam E - The type of the error that may be rejected, defaults to `Error`.
  * @param task - A promise or promise-like object to await.
  * @returns A promise that resolves to `Ok<T>` if successful, or `Err<E>` if rejected.
- *
+ * @since 1.7.0
  * @example
  * ```ts
  * // Fetch data safely
@@ -2037,7 +2064,7 @@ declare function tryAsyncResult<T, E = Error>(task: PromiseLike<T>): AsyncResult
  * @param task - A function that returns a value or promise-like object.
  * @param args - Arguments to pass to the function.
  * @returns A promise that resolves to `Ok<T>` if successful, or `Err<E>` if thrown or rejected.
- *
+ * @since 1.7.0
  * @example
  * ```ts
  * // Function with arguments
@@ -2084,6 +2111,7 @@ declare function tryAsyncResult<T, E = Error, Args extends unknown[] = []>(task:
  * @typeParam E - The expected type of the error value contained within the `Result`.
  * @param r - The value to be checked as a `Result`.
  * @returns `true` if the value is a `Result`, otherwise `false`.
+ * @since 1.2.0
  * @example
  * ```ts
  * const x = Ok(5);
@@ -2136,8 +2164,8 @@ declare const ControlFlowKindSymbol: unique symbol;
  *
  * @typeParam B - The type of the value returned on `Break` (early exit).
  * @typeParam C - The type of the value returned on `Continue` (default: `void`).
+ * @since 1.6.0
  * @see https://doc.rust-lang.org/std/ops/enum.ControlFlow.html
- *
  * @example
  * ```ts
  * // Using ControlFlow to short-circuit a search
@@ -2235,7 +2263,6 @@ interface ControlFlow<B, C = void> {
      * `ControlFlow` was `Break` and `None` otherwise.
      *
      * @returns `Some(value)` if `Break`, `None` if `Continue`.
-     *
      * @example
      * ```ts
      * console.log(Break(3).breakValue()); // Some(3)
@@ -2248,7 +2275,6 @@ interface ControlFlow<B, C = void> {
      * `ControlFlow` was `Continue` and `None` otherwise.
      *
      * @returns `Some(value)` if `Continue`, `None` if `Break`.
-     *
      * @example
      * ```ts
      * console.log(Continue(5).continueValue()); // Some(5)
@@ -2263,7 +2289,6 @@ interface ControlFlow<B, C = void> {
      * @typeParam T - The type of the new break value.
      * @param fn - A function to apply to the break value.
      * @returns A new `ControlFlow` with the mapped break value.
-     *
      * @example
      * ```ts
      * const flow = Break(3);
@@ -2278,7 +2303,6 @@ interface ControlFlow<B, C = void> {
      * @typeParam T - The type of the new continue value.
      * @param fn - A function to apply to the continue value.
      * @returns A new `ControlFlow` with the mapped continue value.
-     *
      * @example
      * ```ts
      * const flow = Continue(5);
@@ -2291,7 +2315,6 @@ interface ControlFlow<B, C = void> {
      * `ControlFlow` was `Break` and `Err` otherwise.
      *
      * @returns `Ok(breakValue)` if `Break`, `Err(continueValue)` if `Continue`.
-     *
      * @example
      * ```ts
      * console.log(Break(3).breakOk()); // Ok(3)
@@ -2304,7 +2327,6 @@ interface ControlFlow<B, C = void> {
      * `ControlFlow` was `Continue` and `Err` otherwise.
      *
      * @returns `Ok(continueValue)` if `Continue`, `Err(breakValue)` if `Break`.
-     *
      * @example
      * ```ts
      * console.log(Continue(5).continueOk()); // Ok(5)
@@ -2319,7 +2341,6 @@ interface ControlFlow<B, C = void> {
      * It returns the contained value regardless of whether this is a `Break` or `Continue`.
      *
      * @returns The contained value.
-     *
      * @example
      * ```ts
      * const breakFlow: ControlFlow<number, number> = Break(5);
@@ -2340,7 +2361,6 @@ interface ControlFlow<B, C = void> {
  * @typeParam C - The type of the continue value (defaults to `void` when a value is provided).
  * @param value - The value to return on break.
  * @returns A `ControlFlow` in the `Break` state.
- *
  * @example
  * ```ts
  * const flow = Break('found it');
@@ -2358,7 +2378,6 @@ declare function Break<B, C = never>(value: B): ControlFlow<B, C>;
  *
  * @typeParam C - The type of the continue value (allows type specification when chaining with Continue).
  * @returns A `ControlFlow<void, C>` in the `Break` state.
- *
  * @example
  * ```ts
  * const voidFlow = Break();
@@ -2379,7 +2398,6 @@ declare function Break<C = never>(): ControlFlow<void, C>;
  * @typeParam C - The type of the continue value.
  * @param value - The value to carry forward (optional, defaults to `undefined`).
  * @returns A `ControlFlow` in the `Continue` state.
- *
  * @example
  * ```ts
  * const flow = Continue();
@@ -2396,7 +2414,6 @@ declare function Continue<B = never, C = void>(value: C): ControlFlow<B, C>;
  *
  * @typeParam B - The type of the break value (allows type specification when chaining with Break).
  * @returns A `ControlFlow<B, void>` in the `Continue` state.
- *
  * @example
  * ```ts
  * const voidFlow = Continue();
@@ -2432,10 +2449,9 @@ declare function Continue<B = never>(): ControlFlow<B, void>;
  *
  * @typeParam A - Tuple type of the function arguments.
  * @typeParam R - Return type of the function.
- *
+ * @since 1.8.0
  * @see {@link FnOnceAsync} for async one-time callable functions
  * @see https://doc.rust-lang.org/std/ops/trait.FnOnce.html
- *
  * @example
  * ```ts
  * // Basic usage
@@ -2506,7 +2522,6 @@ interface FnOnce<A extends unknown[], R> {
      * @param args - The arguments to pass to the function.
      * @returns The return value of the function.
      * @throws {Error} If the function has already been called.
-     *
      * @example
      * ```ts
      * const add = FnOnce((a: number, b: number) => a + b);
@@ -2523,7 +2538,6 @@ interface FnOnce<A extends unknown[], R> {
      *
      * @param args - The arguments to pass to the function.
      * @returns `Some(result)` if the function was called, `None` if already consumed.
-     *
      * @example
      * ```ts
      * const greet = FnOnce((name: string) => `Hi, ${name}`);
@@ -2552,7 +2566,6 @@ interface FnOnce<A extends unknown[], R> {
  * @typeParam R - Return type of the function.
  * @param fn - The function to wrap.
  * @returns A `FnOnce` instance that wraps the function.
- *
  * @example
  * ```ts
  * const initialize = FnOnce(() => {
@@ -2589,9 +2602,8 @@ declare function FnOnce<A extends unknown[], R>(fn: (...args: A) => R): FnOnce<A
  *
  * @typeParam A - Tuple type of the function arguments.
  * @typeParam R - The resolved type of the Promise returned by the async function.
- *
+ * @since 1.8.0
  * @see {@link FnOnce} for sync one-time callable functions
- *
  * @example
  * ```ts
  * // Basic usage
@@ -2655,7 +2667,6 @@ interface FnOnceAsync<A extends unknown[], R> {
      * @param args - The arguments to pass to the function.
      * @returns A Promise that resolves to the return value of the function.
      * @throws {Error} If the function has already been called.
-     *
      * @example
      * ```ts
      * const fetchUser = FnOnceAsync(async (id: number) => {
@@ -2677,7 +2688,6 @@ interface FnOnceAsync<A extends unknown[], R> {
      *
      * @param args - The arguments to pass to the function.
      * @returns A Promise that resolves to `Some(result)` if the function was called, `None` if already consumed.
-     *
      * @example
      * ```ts
      * const fetchData = FnOnceAsync(async (id: number) => {
@@ -2710,7 +2720,6 @@ interface FnOnceAsync<A extends unknown[], R> {
  * @typeParam R - The resolved type of the Promise returned by the async function.
  * @param fn - A function that returns `PromiseLike<R>` or `R`.
  * @returns A `FnOnceAsync` instance that wraps the function.
- *
  * @example
  * ```ts
  * const initialize = FnOnceAsync(async () => {
@@ -2739,6 +2748,7 @@ declare function FnOnceAsync<A extends unknown[], R>(fn: (...args: A) => Promise
  * @typeParam C - The expected type of the continue value contained within the `ControlFlow`.
  * @param cf - The value to be checked as a `ControlFlow`.
  * @returns `true` if the value is a `ControlFlow`, otherwise `false`.
+ * @since 1.6.0
  * @example
  * ```ts
  * const x = Break(5);
@@ -2764,7 +2774,6 @@ declare function isControlFlow<B, C>(cf: unknown): cf is ControlFlow<B, C>;
  * Created by calling `channel.sender()`. Shares state with the parent channel.
  *
  * @typeParam T - The type of values that can be sent.
- *
  * @see https://doc.rust-lang.org/std/sync/mpmc/struct.Sender.html
  */
 interface Sender<T> {
@@ -2825,9 +2834,7 @@ interface Sender<T> {
      *
      * @param value - The value to send.
      * @returns A promise that resolves to `true` if sent successfully, `false` if the channel is closed.
-     *
      * @see {@link Channel.send}
-     *
      * @example
      * ```ts
      * const success = await sender.send(42);
@@ -2846,9 +2853,7 @@ interface Sender<T> {
      *
      * @param value - The value to send.
      * @returns `true` if sent successfully, `false` if full or closed.
-     *
      * @see {@link Channel.trySend}
-     *
      * @example
      * ```ts
      * if (!sender.trySend(42)) {
@@ -2869,7 +2874,6 @@ interface Sender<T> {
      *          `false` if timed out, channel is full, or closed.
      *
      * @see {@link Channel.sendTimeout}
-     *
      * @example
      * ```ts
      * const success = await sender.sendTimeout(42, 1000);
@@ -2887,7 +2891,6 @@ interface Sender<T> {
  * Implements `AsyncIterable` for use with `for await...of`.
  *
  * @typeParam T - The type of values that can be received.
- *
  * @see https://doc.rust-lang.org/std/sync/mpmc/struct.Receiver.html
  */
 interface Receiver<T> {
@@ -2959,9 +2962,7 @@ interface Receiver<T> {
      * - If the channel is closed and empty, returns `None`.
      *
      * @returns A promise that resolves to `Some(value)` or `None` if closed and empty.
-     *
      * @see {@link Channel.receive}
-     *
      * @example
      * ```ts
      * const result = await receiver.receive();
@@ -2981,9 +2982,7 @@ interface Receiver<T> {
      * - Otherwise returns `None`.
      *
      * @returns `Some(value)` if available, `None` if empty.
-     *
      * @see {@link Channel.tryReceive}
-     *
      * @example
      * ```ts
      * const result = receiver.tryReceive();
@@ -3002,7 +3001,6 @@ interface Receiver<T> {
      *          empty, or closed.
      *
      * @see {@link Channel.receiveTimeout}
-     *
      * @example
      * ```ts
      * const result = await receiver.receiveTimeout(1000);
@@ -3020,8 +3018,8 @@ interface Receiver<T> {
  * typed values. Values are delivered in FIFO order.
  *
  * @typeParam T - The type of values that can be sent through the channel.
+ * @since 1.8.0
  * @see https://doc.rust-lang.org/std/sync/mpmc/fn.channel.html
- *
  * @example
  * ```ts
  * // Create a bounded channel with capacity 10
@@ -3198,7 +3196,6 @@ interface Channel<T> {
      *
      * @param value - The value to send.
      * @returns A promise that resolves to `true` if sent successfully, `false` if the channel is closed.
-     *
      * @example
      * ```ts
      * const ch = Channel<number>(1);
@@ -3218,7 +3215,6 @@ interface Channel<T> {
      *
      * @param value - The value to send.
      * @returns `true` if sent successfully, `false` if full or closed.
-     *
      * @example
      * ```ts
      * const ch = Channel<number>(0);
@@ -3257,7 +3253,6 @@ interface Channel<T> {
      * - If the channel is closed and empty, returns `None`.
      *
      * @returns A promise that resolves to `Some(value)` or `None` if closed and empty.
-     *
      * @example
      * ```ts
      * const ch = Channel<number>(10);
@@ -3277,7 +3272,6 @@ interface Channel<T> {
      * - Otherwise returns `None`.
      *
      * @returns `Some(value)` if available, `None` if empty.
-     *
      * @example
      * ```ts
      * const ch = Channel<number>(10);
@@ -3336,7 +3330,7 @@ interface Channel<T> {
  * @param capacity - Maximum buffer size. Defaults to `Infinity` (unbounded).
  *                   Use `0` for a rendezvous channel (direct handoff).
  * @returns A new `Channel<T>` instance.
- *
+ * @throws {RangeError} If capacity is negative or not an integer (except Infinity).
  * @example
  * ```ts
  * // Unbounded channel (default)
@@ -3375,9 +3369,9 @@ interface Channel<T> {
  * // Multiple producers
  * async function logFromService(name: string) {
  *     const sender = logs.sender();
- *     await sender.send(`[${ name }] Started`);
+ *     await sender.send(`[${name}] Started`);
  *     // ... do work ...
- *     await sender.send(`[${ name }] Finished`);
+ *     await sender.send(`[${name}] Finished`);
  * }
  *
  * // Single consumer writing to file
@@ -3410,10 +3404,9 @@ declare function Channel<T>(capacity?: number): Channel<T>;
  * on first access. Subsequent accesses return the cached value.
  *
  * @typeParam T - The type of the value stored.
- *
+ * @since 1.6.0
  * @see {@link LazyAsync} for async lazy initialization
  * @see https://doc.rust-lang.org/std/sync/struct.LazyLock.html
- *
  * @example
  * ```ts
  * const expensive = Lazy(() => {
@@ -3457,7 +3450,7 @@ interface Lazy<T> {
      * and returns it.
      *
      * @returns The initialized value.
-     *
+     * @throws Rethrows any exception thrown by the initialization function.
      * @example
      * ```ts
      * const lazy = Lazy(() => 42);
@@ -3472,7 +3465,6 @@ interface Lazy<T> {
      * Unlike `force()`, this does not trigger initialization.
      *
      * @returns `Some(value)` if initialized, `None` otherwise.
-     *
      * @example
      * ```ts
      * const lazy = Lazy(() => 42);
@@ -3505,7 +3497,6 @@ interface Lazy<T> {
  * @typeParam T - The type of value to store.
  * @param fn - The initialization function that produces the value.
  * @returns A new `Lazy<T>` instance.
- *
  * @example
  * ```ts
  * // Basic usage
@@ -3561,9 +3552,8 @@ declare function Lazy<T>(fn: () => T): Lazy<T>;
  * completes, only one initialization will run.
  *
  * @typeParam T - The type of the value stored.
- *
+ * @since 1.6.0
  * @see {@link Lazy} for sync-only lazy initialization
- *
  * @example
  * ```ts
  * const db = LazyAsync(async () => {
@@ -3605,7 +3595,7 @@ interface LazyAsync<T> {
      * Otherwise, starts initialization.
      *
      * @returns A promise that resolves to the initialized value.
-     *
+     * @throws Rejects with any error thrown or rejected by the initialization function.
      * @example
      * ```ts
      * const lazy = LazyAsync(async () => {
@@ -3622,7 +3612,6 @@ interface LazyAsync<T> {
      * Unlike `force()`, this does not trigger initialization.
      *
      * @returns `Some(value)` if initialized, `None` otherwise.
-     *
      * @example
      * ```ts
      * const lazy = LazyAsync(async () => 42);
@@ -3659,7 +3648,6 @@ interface LazyAsync<T> {
  * @typeParam T - The type of value to store.
  * @param fn - A function that returns `PromiseLike<T>` or `T` to initialize.
  * @returns A new `LazyAsync<T>` instance.
- *
  * @example
  * ```ts
  * // Basic usage
@@ -3746,7 +3734,6 @@ interface MutexGuard<T> {
      * Custom `toString` implementation.
      *
      * @returns A string representation of the guard.
-     *
      * @example
      * ```ts
      * const guard = await mutex.lock();
@@ -3783,8 +3770,8 @@ interface MutexGuard<T> {
  * serializes async operations in the single-threaded event loop.
  *
  * @typeParam T - The type of the protected value.
+ * @since 1.6.0
  * @see https://doc.rust-lang.org/std/sync/struct.Mutex.html
- *
  * @example
  * ```ts
  * const mutex = Mutex({ balance: 100 });
@@ -3827,7 +3814,6 @@ interface Mutex<T> {
      * @typeParam U - The return type of the callback.
      * @param fn - The callback that receives the protected value.
      * @returns A promise that resolves to the callback's return value.
-     *
      * @example
      * ```ts
      * const mutex = Mutex<number[]>([]);
@@ -3845,7 +3831,6 @@ interface Mutex<T> {
      * **Important:** Always release the lock in a `finally` block to prevent deadlocks.
      *
      * @returns A promise that resolves to a guard providing access to the value.
-     *
      * @example
      * ```ts
      * const guard = await mutex.lock();
@@ -3866,7 +3851,6 @@ interface Mutex<T> {
      * or `None` if it's currently held by another operation.
      *
      * @returns `Some(guard)` if acquired, `None` if locked.
-     *
      * @example
      * ```ts
      * const maybeGuard = mutex.tryLock();
@@ -3904,7 +3888,6 @@ interface Mutex<T> {
      * This is a convenience method equivalent to `withLock(v => v)`.
      *
      * @returns A promise that resolves to a copy of the value.
-     *
      * @example
      * ```ts
      * const mutex = Mutex(42);
@@ -3920,7 +3903,6 @@ interface Mutex<T> {
      *
      * @param value - The new value to set.
      * @returns A promise that resolves when the value has been set.
-     *
      * @example
      * ```ts
      * const mutex = Mutex(42);
@@ -3939,7 +3921,6 @@ interface Mutex<T> {
      *
      * @param value - The new value to set.
      * @returns A promise that resolves to the old value.
-     *
      * @example
      * ```ts
      * const mutex = Mutex(42);
@@ -3956,7 +3937,6 @@ interface Mutex<T> {
  * @typeParam T - The type of the protected value.
  * @param value - The initial value to protect.
  * @returns A new `Mutex<T>` instance.
- *
  * @example
  * ```ts
  * // Protect a simple value
@@ -4047,10 +4027,9 @@ declare function Mutex<T>(value: T): Mutex<T>;
  * that should only happen once.
  *
  * @typeParam T - The type of the value stored.
- *
+ * @since 1.6.0
  * @see {@link OnceAsync} for async one-time initialization
  * @see https://doc.rust-lang.org/std/sync/struct.OnceLock.html
- *
  * @example
  * ```ts
  * const once = Once<number>();
@@ -4092,7 +4071,6 @@ interface Once<T> {
      * Gets the reference to the underlying value.
      *
      * @returns `Some(value)` if initialized, `None` otherwise.
-     *
      * @example
      * ```ts
      * const once = Once<number>();
@@ -4108,7 +4086,6 @@ interface Once<T> {
      *
      * @param value - The value to store.
      * @returns `Ok(undefined)` if empty, `Err(value)` if already initialized.
-     *
      * @example
      * ```ts
      * const once = Once<number>();
@@ -4127,7 +4104,6 @@ interface Once<T> {
      *
      * @param value - The value to store.
      * @returns `Ok(value)` if empty, `Err([currentValue, passedValue])` if already initialized.
-     *
      * @example
      * ```ts
      * const once = Once<number>();
@@ -4147,7 +4123,6 @@ interface Once<T> {
      *
      * @param fn - The synchronous initialization function, called only if empty.
      * @returns The stored value.
-     *
      * @example
      * ```ts
      * const once = Once<number>();
@@ -4171,7 +4146,6 @@ interface Once<T> {
      * @typeParam E - The error type.
      * @param fn - The initialization function that may fail.
      * @returns `Ok(value)` if initialized, `Err(error)` if initialization failed.
-     *
      * @example
      * ```ts
      * const once = Once<Config>();
@@ -4191,7 +4165,6 @@ interface Once<T> {
      * Takes the value out, leaving it uninitialized.
      *
      * @returns `Some(value)` if initialized, `None` otherwise.
-     *
      * @example
      * ```ts
      * const once = Once<number>();
@@ -4222,7 +4195,6 @@ interface Once<T> {
  *
  * @typeParam T - The type of value to store.
  * @returns A new uninitialized `Once`.
- *
  * @example
  * ```ts
  * // Basic usage
@@ -4280,9 +4252,8 @@ declare function Once<T>(): Once<T>;
  * - `OnceAsync<T>` always stores `Awaited<T>` (flattened value)
  *
  * @typeParam T - The type parameter. The actual stored type is `Awaited<T>`.
- *
+ * @since 1.8.0
  * @see {@link Once} for sync-only one-time initialization
- *
  * @example
  * ```ts
  * const db = OnceAsync<Database>();
@@ -4331,7 +4302,6 @@ interface OnceAsync<T> {
      * Gets the reference to the underlying value.
      *
      * @returns `Some(value)` if initialized, `None` otherwise.
-     *
      * @example
      * ```ts
      * const once = OnceAsync<number>();
@@ -4347,7 +4317,6 @@ interface OnceAsync<T> {
      *
      * @param value - The value to store.
      * @returns `Ok(undefined)` if empty, `Err(value)` if already initialized.
-     *
      * @example
      * ```ts
      * const once = OnceAsync<number>();
@@ -4366,7 +4335,6 @@ interface OnceAsync<T> {
      *
      * @param value - The value to store.
      * @returns `Ok(value)` if empty, `Err([currentValue, passedValue])` if already initialized.
-     *
      * @example
      * ```ts
      * const once = OnceAsync<number>();
@@ -4389,7 +4357,6 @@ interface OnceAsync<T> {
      *
      * @param fn - A function that returns `PromiseLike<Awaited<T>>` or `Awaited<T>` to initialize.
      * @returns A promise that resolves to the stored value (`Awaited<T>`).
-     *
      * @example
      * ```ts
      * const db = OnceAsync<Database>();
@@ -4414,7 +4381,6 @@ interface OnceAsync<T> {
      * @typeParam E - The error type.
      * @param fn - A function that returns `PromiseLike<Result<Awaited<T>, E>>` or `Result<Awaited<T>, E>`.
      * @returns A promise that resolves to `Ok(value)` or `Err(error)`.
-     *
      * @example
      * ```ts
      * const config = OnceAsync<Config>();
@@ -4434,7 +4400,6 @@ interface OnceAsync<T> {
      * Takes the value out, leaving it uninitialized.
      *
      * @returns `Some(value)` if initialized, `None` otherwise.
-     *
      * @example
      * ```ts
      * const once = OnceAsync<number>();
@@ -4468,7 +4433,6 @@ interface OnceAsync<T> {
      * the returned promise will resolve when another caller initializes the cell.
      *
      * @returns A promise that resolves to the stored value once initialized.
-     *
      * @example
      * ```ts
      * const once = OnceAsync<number>();
@@ -4493,7 +4457,6 @@ interface OnceAsync<T> {
  *
  * @typeParam T - The type parameter. The actual stored type is `Awaited<T>`.
  * @returns A new uninitialized `OnceAsync`.
- *
  * @example
  * ```ts
  * // Basic usage
@@ -4588,7 +4551,6 @@ interface RwLockReadGuard<T> {
      * Custom `toString` implementation.
      *
      * @returns A string representation of the guard.
-     *
      * @example
      * ```ts
      * const guard = await rwlock.read();
@@ -4642,7 +4604,6 @@ interface RwLockWriteGuard<T> {
      * Custom `toString` implementation.
      *
      * @returns A string representation of the guard.
-     *
      * @example
      * ```ts
      * const guard = await rwlock.write();
@@ -4674,8 +4635,8 @@ interface RwLockWriteGuard<T> {
  * Writers are given priority to prevent writer starvation.
  *
  * @typeParam T - The type of the protected value.
+ * @since 1.8.0
  * @see https://doc.rust-lang.org/std/sync/struct.RwLock.html
- *
  * @example
  * ```ts
  * const config = RwLock({ apiUrl: 'https://api.example.com', timeout: 5000 });
@@ -4724,7 +4685,6 @@ interface RwLock<T> {
      * @typeParam U - The return type of the callback.
      * @param fn - The callback that receives the protected value (read-only).
      * @returns A promise that resolves to the callback's return value.
-     *
      * @example
      * ```ts
      * const data = await rwlock.withRead(async (value) => {
@@ -4741,7 +4701,6 @@ interface RwLock<T> {
      * @typeParam U - The return type of the callback.
      * @param fn - The callback that receives the protected value (read-write).
      * @returns A promise that resolves to the callback's return value.
-     *
      * @example
      * ```ts
      * await rwlock.withWrite(async (value) => {
@@ -4754,7 +4713,6 @@ interface RwLock<T> {
      * Acquires a read lock and returns a guard for manual control.
      *
      * @returns A promise that resolves to a read guard.
-     *
      * @example
      * ```ts
      * const guard = await rwlock.read();
@@ -4770,7 +4728,6 @@ interface RwLock<T> {
      * Acquires a write lock and returns a guard for manual control.
      *
      * @returns A promise that resolves to a write guard.
-     *
      * @example
      * ```ts
      * const guard = await rwlock.write();
@@ -4788,7 +4745,6 @@ interface RwLock<T> {
      * Returns `None` if a write lock is currently held.
      *
      * @returns `Some(guard)` if acquired, `None` if a writer holds the lock.
-     *
      * @example
      * ```ts
      * const maybeGuard = rwlock.tryRead();
@@ -4809,7 +4765,6 @@ interface RwLock<T> {
      * Returns `None` if any read or write lock is currently held.
      *
      * @returns `Some(guard)` if acquired, `None` if any lock is held.
-     *
      * @example
      * ```ts
      * const maybeGuard = rwlock.tryWrite();
@@ -4850,7 +4805,6 @@ interface RwLock<T> {
      * Acquires a read lock and returns a copy of the protected value.
      *
      * @returns A promise that resolves to a copy of the value.
-     *
      * @example
      * ```ts
      * const value = await rwlock.get();
@@ -4862,7 +4816,6 @@ interface RwLock<T> {
      *
      * @param value - The new value to set.
      * @returns A promise that resolves when the value has been set.
-     *
      * @example
      * ```ts
      * await rwlock.set(newValue);
@@ -4874,7 +4827,6 @@ interface RwLock<T> {
      *
      * @param value - The new value to set.
      * @returns A promise that resolves to the old value.
-     *
      * @example
      * ```ts
      * const rwlock = RwLock(42);
@@ -4891,7 +4843,6 @@ interface RwLock<T> {
  * @typeParam T - The type of the protected value.
  * @param value - The initial value to protect.
  * @returns A new `RwLock<T>` instance.
- *
  * @example
  * ```ts
  * // Basic usage