happy-rusty 1.9.0 → 1.9.2

package/dist/main.cjs

@@ -1,1507 +1,2308 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/core/option/symbols.ts
+/**
+* @module
+* Internal symbol used to identify `Option` type variants.
+*
+* This symbol is used as a property key to distinguish between `Some` and `None` variants.
+* It provides a reliable way to identify the variant of an `Option` instance without
+* relying on method calls or duck typing.
+*
+* Note: This symbol is an internal implementation detail and is not exported as part of the public API.
+* Use the `isOption` utility function for type checking instead.
+*/
+/**
+* A unique symbol used as a property key to identify the variant of an `Option` instance.
+*
+* When accessed on an `Option`, returns `'Some'` if the Option contains a value,
+* or `'None'` if it represents the absence of a value.
+*
+* This symbol is used internally by the `isOption` utility function to verify
+* that an object is a valid `Option` instance.
+*
+* @internal
+*/
 const OptionKindSymbol = /* @__PURE__ */ Symbol("Option kind");
-
+//#endregion
+//#region src/core/option/guards.ts
+/**
+* Checks if a value is an `Option`.
+*
+* @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);
+* console.log(isOption(x)); // true
+* console.log(isOption(null)); // false
+* console.log(isOption({ value: 5 })); // false
+* ```
+*/
 function isOption(o) {
-  return o != null && typeof o === "object" && OptionKindSymbol in o;
+	return o != null && typeof o === "object" && OptionKindSymbol in o;
 }
-
+//#endregion
+//#region src/core/result/symbols.ts
+/**
+* @module
+* Internal symbol used to identify `Result` type variants.
+*
+* This symbol is used as a property key to distinguish between `Ok` and `Err` variants.
+* It provides a reliable way to identify the variant of a `Result` instance without
+* relying on method calls or duck typing.
+*
+* Note: This symbol is an internal implementation detail and is not exported as part of the public API.
+* Use the `isResult` utility function for type checking instead.
+*/
+/**
+* A unique symbol used as a property key to identify the variant of a `Result` instance.
+*
+* When accessed on a `Result`, returns `'Ok'` if the Result represents success,
+* or `'Err'` if it represents failure.
+*
+* This symbol is used internally by the `isResult` utility function to verify
+* that an object is a valid `Result` instance.
+*
+* @internal
+*/
 const ResultKindSymbol = /* @__PURE__ */ Symbol("Result kind");
-
+//#endregion
+//#region src/core/result/guards.ts
+/**
+* Checks if a value is a `Result`.
+*
+* @typeParam T - The expected type of the success value contained within the `Result`.
+* @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);
+* console.log(isResult(x)); // true
+* console.log(isResult(null)); // false
+* console.log(isResult({ value: 5 })); // false
+* ```
+*/
 function isResult(r) {
-  return r != null && typeof r === "object" && ResultKindSymbol in r;
+	return r != null && typeof r === "object" && ResultKindSymbol in r;
 }
-
-const ASYNC_TRUE$1 = Promise.resolve(true);
-const ASYNC_FALSE$1 = Promise.resolve(false);
+//#endregion
+//#region src/core/prelude.ts
+/**
+* @module
+* Constructors and factory functions for creating `Option` and `Result` types.
+*
+* This module exports:
+* - `Some<T>(value)` - Creates an Option containing a value
+* - `None` - Constant representing absence of value
+* - `Ok<T, E>(value)` - Creates a successful Result
+* - `Err<T, E>(error)` - Creates a failed Result
+* - `None` interface - Type overrides for better type inference
+*/
+const ASYNC_TRUE$1 = /* @__PURE__ */ Promise.resolve(true);
+const ASYNC_FALSE$1 = /* @__PURE__ */ Promise.resolve(false);
+/**
+* Creates an `Option<T>` representing the presence of a value.
+* This function is typically used to construct an `Option` that contains a value, indicating that the operation yielding the value was successful.
+*
+* @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
+* if (maybeValue.isSome()) {
+*     console.log(maybeValue.unwrap()); // Outputs: 1
+* }
+* ```
+*/
 function Some(value) {
-  const some = Object.freeze({
-    [Symbol.toStringTag]: "Option",
-    [OptionKindSymbol]: "Some",
-    *[Symbol.iterator]() {
-      yield value;
-    },
-    toString() {
-      return `Some(${value})`;
-    },
-    isSome() {
-      return true;
-    },
-    isNone() {
-      return false;
-    },
-    isSomeAnd(predicate) {
-      return predicate(value);
-    },
-    isSomeAndAsync(predicate) {
-      return Promise.resolve(predicate(value));
-    },
-    isNoneOr(predicate) {
-      return predicate(value);
-    },
-    isNoneOrAsync(predicate) {
-      return Promise.resolve(predicate(value));
-    },
-    expect(_msg) {
-      return value;
-    },
-    unwrap() {
-      return value;
-    },
-    unwrapOr(_defaultValue) {
-      return value;
-    },
-    unwrapOrElse(_fn) {
-      return value;
-    },
-    unwrapOrElseAsync(_fn) {
-      return Promise.resolve(value);
-    },
-    okOr(_error) {
-      return Ok(value);
-    },
-    okOrElse(_err) {
-      return Ok(value);
-    },
-    transpose() {
-      assertResult(value);
-      return value.isOk() ? Ok(Some(value.unwrap())) : Err(value.unwrapErr());
-    },
-    filter(predicate) {
-      return predicate(value) ? some : None;
-    },
-    flatten() {
-      assertOption(value);
-      return value;
-    },
-    map(fn) {
-      return Some(fn(value));
-    },
-    mapOr(_defaultValue, fn) {
-      return fn(value);
-    },
-    mapOrElse(_defaultFn, fn) {
-      return fn(value);
-    },
-    zip(other) {
-      assertOption(other);
-      return other.isSome() ? Some([value, other.unwrap()]) : None;
-    },
-    zipWith(other, fn) {
-      assertOption(other);
-      return other.isSome() ? Some(fn(value, other.unwrap())) : None;
-    },
-    unzip() {
-      const tuple = value;
-      if (!Array.isArray(tuple) || tuple.length !== 2) {
-        throw new TypeError(`Option::unzip() requires a 2-element tuple, received ${Array.isArray(tuple) ? `array with ${tuple.length} elements` : typeof tuple}`);
-      }
-      const [a, b] = tuple;
-      return [Some(a), Some(b)];
-    },
-    reduce(other, fn) {
-      assertOption(other);
-      return other.isSome() ? Some(fn(value, other.unwrap())) : some;
-    },
-    and(other) {
-      assertOption(other);
-      return other;
-    },
-    andThen(fn) {
-      return fn(value);
-    },
-    andThenAsync(fn) {
-      return Promise.resolve(fn(value));
-    },
-    or(_other) {
-      return some;
-    },
-    orElse(_fn) {
-      return some;
-    },
-    orElseAsync(_fn) {
-      return Promise.resolve(some);
-    },
-    xor(other) {
-      assertOption(other);
-      return other.isSome() ? None : some;
-    },
-    inspect(fn) {
-      fn(value);
-      return some;
-    },
-    eq(other) {
-      assertOption(other);
-      return other.isSome() && other.unwrap() === value;
-    }
-  });
-  return some;
+	const some = Object.freeze({
+		[Symbol.toStringTag]: "Option",
+		[OptionKindSymbol]: "Some",
+		*[Symbol.iterator]() {
+			yield value;
+		},
+		toString() {
+			return `Some(${value})`;
+		},
+		isSome() {
+			return true;
+		},
+		isNone() {
+			return false;
+		},
+		isSomeAnd(predicate) {
+			return predicate(value);
+		},
+		isSomeAndAsync(predicate) {
+			return Promise.resolve(predicate(value));
+		},
+		isNoneOr(predicate) {
+			return predicate(value);
+		},
+		isNoneOrAsync(predicate) {
+			return Promise.resolve(predicate(value));
+		},
+		expect(_msg) {
+			return value;
+		},
+		unwrap() {
+			return value;
+		},
+		unwrapOr(_defaultValue) {
+			return value;
+		},
+		unwrapOrElse(_fn) {
+			return value;
+		},
+		unwrapOrElseAsync(_fn) {
+			return Promise.resolve(value);
+		},
+		okOr(_error) {
+			return Ok(value);
+		},
+		okOrElse(_err) {
+			return Ok(value);
+		},
+		transpose() {
+			assertResult(value);
+			return value.isOk() ? Ok(Some(value.unwrap())) : Err(value.unwrapErr());
+		},
+		filter(predicate) {
+			return predicate(value) ? some : None;
+		},
+		flatten() {
+			assertOption(value);
+			return value;
+		},
+		map(fn) {
+			return Some(fn(value));
+		},
+		mapOr(_defaultValue, fn) {
+			return fn(value);
+		},
+		mapOrElse(_defaultFn, fn) {
+			return fn(value);
+		},
+		zip(other) {
+			assertOption(other);
+			return other.isSome() ? Some([value, other.unwrap()]) : None;
+		},
+		zipWith(other, fn) {
+			assertOption(other);
+			return other.isSome() ? Some(fn(value, other.unwrap())) : None;
+		},
+		unzip() {
+			const tuple = value;
+			if (!Array.isArray(tuple) || tuple.length !== 2) throw new TypeError(`Option::unzip() requires a 2-element tuple, received ${Array.isArray(tuple) ? `array with ${tuple.length} elements` : typeof tuple}`);
+			const [a, b] = tuple;
+			return [Some(a), Some(b)];
+		},
+		reduce(other, fn) {
+			assertOption(other);
+			return other.isSome() ? Some(fn(value, other.unwrap())) : some;
+		},
+		and(other) {
+			assertOption(other);
+			return other;
+		},
+		andThen(fn) {
+			return fn(value);
+		},
+		andThenAsync(fn) {
+			return Promise.resolve(fn(value));
+		},
+		or(_other) {
+			return some;
+		},
+		orElse(_fn) {
+			return some;
+		},
+		orElseAsync(_fn) {
+			return Promise.resolve(some);
+		},
+		xor(other) {
+			assertOption(other);
+			return other.isSome() ? None : some;
+		},
+		inspect(fn) {
+			fn(value);
+			return some;
+		},
+		eq(other) {
+			assertOption(other);
+			return other.isSome() && other.unwrap() === value;
+		}
+	});
+	return some;
 }
-const None = Object.freeze({
-  [Symbol.toStringTag]: "Option",
-  [OptionKindSymbol]: "None",
-  *[Symbol.iterator]() {
-  },
-  toString() {
-    return "None";
-  },
-  isSome() {
-    return false;
-  },
-  isNone() {
-    return true;
-  },
-  isSomeAnd(_predicate) {
-    return false;
-  },
-  isSomeAndAsync(_predicate) {
-    return ASYNC_FALSE$1;
-  },
-  isNoneOr(_predicate) {
-    return true;
-  },
-  isNoneOrAsync(_predicate) {
-    return ASYNC_TRUE$1;
-  },
-  expect(msg) {
-    throw new TypeError(msg);
-  },
-  unwrap() {
-    throw new TypeError("Option::unwrap() called on a `None` value");
-  },
-  unwrapOr(defaultValue) {
-    return defaultValue;
-  },
-  unwrapOrElse(fn) {
-    return fn();
-  },
-  unwrapOrElseAsync(fn) {
-    return Promise.resolve(fn());
-  },
-  okOr(error) {
-    return Err(error);
-  },
-  okOrElse(err) {
-    return Err(err());
-  },
-  transpose() {
-    return Ok(None);
-  },
-  filter(_predicate) {
-    return None;
-  },
-  flatten() {
-    return None;
-  },
-  map(_fn) {
-    return None;
-  },
-  mapOr(defaultValue, _fn) {
-    return defaultValue;
-  },
-  mapOrElse(defaultFn, _fn) {
-    return defaultFn();
-  },
-  zip(_other) {
-    return None;
-  },
-  zipWith(_other, _fn) {
-    return None;
-  },
-  unzip() {
-    return [None, None];
-  },
-  reduce(other, _fn) {
-    assertOption(other);
-    return other;
-  },
-  and(_other) {
-    return None;
-  },
-  andThen(_fn) {
-    return None;
-  },
-  andThenAsync(_fn) {
-    return ASYNC_NONE;
-  },
-  or(other) {
-    assertOption(other);
-    return other;
-  },
-  orElse(fn) {
-    return fn();
-  },
-  orElseAsync(fn) {
-    return Promise.resolve(fn());
-  },
-  xor(other) {
-    assertOption(other);
-    return other.isSome() ? other : None;
-  },
-  inspect(_fn) {
-    return None;
-  },
-  eq(other) {
-    assertOption(other);
-    return other === None;
-  }
+/**
+* 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
+* function findUser(id: number): Option<User> {
+*     const user = users.find(u => u.id === id);
+*     return user ? Some(user) : None;
+* }
+*
+* // None is a singleton, so you can compare by reference
+* const result = findUser(999);
+* if (result === None) {
+*     console.log('User not found');
+* }
+*
+* // Use with Option methods
+* const name = None.unwrapOr('Anonymous'); // 'Anonymous'
+* ```
+*/
+const None = /* @__PURE__ */ Object.freeze({
+	[Symbol.toStringTag]: "Option",
+	[OptionKindSymbol]: "None",
+	*[Symbol.iterator]() {},
+	toString() {
+		return "None";
+	},
+	isSome() {
+		return false;
+	},
+	isNone() {
+		return true;
+	},
+	isSomeAnd(_predicate) {
+		return false;
+	},
+	isSomeAndAsync(_predicate) {
+		return ASYNC_FALSE$1;
+	},
+	isNoneOr(_predicate) {
+		return true;
+	},
+	isNoneOrAsync(_predicate) {
+		return ASYNC_TRUE$1;
+	},
+	expect(msg) {
+		throw new TypeError(msg);
+	},
+	unwrap() {
+		throw new TypeError("Option::unwrap() called on a `None` value");
+	},
+	unwrapOr(defaultValue) {
+		return defaultValue;
+	},
+	unwrapOrElse(fn) {
+		return fn();
+	},
+	unwrapOrElseAsync(fn) {
+		return Promise.resolve(fn());
+	},
+	okOr(error) {
+		return Err(error);
+	},
+	okOrElse(err) {
+		return Err(err());
+	},
+	transpose() {
+		return Ok(None);
+	},
+	filter(_predicate) {
+		return None;
+	},
+	flatten() {
+		return None;
+	},
+	map(_fn) {
+		return None;
+	},
+	mapOr(defaultValue, _fn) {
+		return defaultValue;
+	},
+	mapOrElse(defaultFn, _fn) {
+		return defaultFn();
+	},
+	zip(_other) {
+		return None;
+	},
+	zipWith(_other, _fn) {
+		return None;
+	},
+	unzip() {
+		return [None, None];
+	},
+	reduce(other, _fn) {
+		assertOption(other);
+		return other;
+	},
+	and(_other) {
+		return None;
+	},
+	andThen(_fn) {
+		return None;
+	},
+	andThenAsync(_fn) {
+		return ASYNC_NONE;
+	},
+	or(other) {
+		assertOption(other);
+		return other;
+	},
+	orElse(fn) {
+		return fn();
+	},
+	orElseAsync(fn) {
+		return Promise.resolve(fn());
+	},
+	xor(other) {
+		assertOption(other);
+		return other.isSome() ? other : None;
+	},
+	inspect(_fn) {
+		return None;
+	},
+	eq(other) {
+		assertOption(other);
+		return other === None;
+	}
 });
-const ASYNC_NONE = Promise.resolve(None);
+/**
+* Async Option constant for `None`.
+* A pre-resolved `Promise<None>` that can be reused to avoid creating
+* new Promise instances when returning `None` from async functions.
+*
+* 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> {
+*     if (id < 0) {
+*         return ASYNC_NONE;
+*     }
+*     const user = await db.findUser(id);
+*     return user ? Some(user) : ASYNC_NONE;
+* }
+* ```
+*
+* @example
+* ```ts
+* // Useful in conditional async returns
+* function maybeLoadAsync(shouldLoad: boolean): AsyncOption<Data> {
+*     if (!shouldLoad) {
+*         return ASYNC_NONE;
+*     }
+*     return loadDataAsync();
+* }
+* ```
+*/
+const ASYNC_NONE = /* @__PURE__ */ Promise.resolve(None);
 function Ok(value) {
-  const ok = Object.freeze({
-    [Symbol.toStringTag]: "Result",
-    [ResultKindSymbol]: "Ok",
-    *[Symbol.iterator]() {
-      yield value;
-    },
-    toString() {
-      return `Ok(${value})`;
-    },
-    isOk() {
-      return true;
-    },
-    isErr() {
-      return false;
-    },
-    isOkAnd(predicate) {
-      return predicate(value);
-    },
-    isOkAndAsync(predicate) {
-      return Promise.resolve(predicate(value));
-    },
-    isErrAnd(_predicate) {
-      return false;
-    },
-    isErrAndAsync(_predicate) {
-      return ASYNC_FALSE$1;
-    },
-    expect(_msg) {
-      return value;
-    },
-    unwrap() {
-      return value;
-    },
-    unwrapOr(_defaultValue) {
-      return value;
-    },
-    unwrapOrElse(_fn) {
-      return value;
-    },
-    unwrapOrElseAsync(_fn) {
-      return Promise.resolve(value);
-    },
-    expectErr(msg) {
-      throw new TypeError(`${msg}: ${value}`);
-    },
-    unwrapErr() {
-      throw new TypeError("Result::unwrapErr() called on an `Ok` value");
-    },
-    intoOk() {
-      return value;
-    },
-    intoErr() {
-      throw new TypeError("Result::intoErr() called on an `Ok` value");
-    },
-    ok() {
-      return Some(value);
-    },
-    err() {
-      return None;
-    },
-    transpose() {
-      assertOption(value);
-      return value.isSome() ? Some(Ok(value.unwrap())) : None;
-    },
-    map(fn) {
-      return Ok(fn(value));
-    },
-    mapErr(_fn) {
-      return ok;
-    },
-    mapOr(_defaultValue, fn) {
-      return fn(value);
-    },
-    mapOrElse(_defaultFn, fn) {
-      return fn(value);
-    },
-    flatten() {
-      assertResult(value);
-      return value;
-    },
-    and(other) {
-      assertResult(other);
-      return other;
-    },
-    or(_other) {
-      return ok;
-    },
-    andThen(fn) {
-      return fn(value);
-    },
-    andThenAsync(fn) {
-      return Promise.resolve(fn(value));
-    },
-    orElse(_fn) {
-      return ok;
-    },
-    orElseAsync(_fn) {
-      return Promise.resolve(ok);
-    },
-    inspect(fn) {
-      fn(value);
-      return ok;
-    },
-    inspectErr(_fn) {
-      return ok;
-    },
-    eq(other) {
-      assertResult(other);
-      return other.isOk() && other.unwrap() === value;
-    },
-    asOk() {
-      return ok;
-    },
-    asErr() {
-      throw new TypeError("Result::asErr() called on an `Ok` value");
-    },
-    andTryAsync(fn) {
-      try {
-        const result = fn(value);
-        return Promise.resolve(result).then(
-          Ok,
-          Err
-        );
-      } catch (e) {
-        return Promise.resolve(Err(e));
-      }
-    },
-    orTryAsync(_fn) {
-      return Promise.resolve(ok);
-    }
-  });
-  return ok;
+	const ok = Object.freeze({
+		[Symbol.toStringTag]: "Result",
+		[ResultKindSymbol]: "Ok",
+		*[Symbol.iterator]() {
+			yield value;
+		},
+		toString() {
+			return `Ok(${value})`;
+		},
+		isOk() {
+			return true;
+		},
+		isErr() {
+			return false;
+		},
+		isOkAnd(predicate) {
+			return predicate(value);
+		},
+		isOkAndAsync(predicate) {
+			return Promise.resolve(predicate(value));
+		},
+		isErrAnd(_predicate) {
+			return false;
+		},
+		isErrAndAsync(_predicate) {
+			return ASYNC_FALSE$1;
+		},
+		expect(_msg) {
+			return value;
+		},
+		unwrap() {
+			return value;
+		},
+		unwrapOr(_defaultValue) {
+			return value;
+		},
+		unwrapOrElse(_fn) {
+			return value;
+		},
+		unwrapOrElseAsync(_fn) {
+			return Promise.resolve(value);
+		},
+		expectErr(msg) {
+			throw new TypeError(`${msg}: ${value}`);
+		},
+		unwrapErr() {
+			throw new TypeError("Result::unwrapErr() called on an `Ok` value");
+		},
+		intoOk() {
+			return value;
+		},
+		intoErr() {
+			throw new TypeError("Result::intoErr() called on an `Ok` value");
+		},
+		ok() {
+			return Some(value);
+		},
+		err() {
+			return None;
+		},
+		transpose() {
+			assertOption(value);
+			return value.isSome() ? Some(Ok(value.unwrap())) : None;
+		},
+		map(fn) {
+			return Ok(fn(value));
+		},
+		mapErr(_fn) {
+			return ok;
+		},
+		mapOr(_defaultValue, fn) {
+			return fn(value);
+		},
+		mapOrElse(_defaultFn, fn) {
+			return fn(value);
+		},
+		flatten() {
+			assertResult(value);
+			return value;
+		},
+		and(other) {
+			assertResult(other);
+			return other;
+		},
+		or(_other) {
+			return ok;
+		},
+		andThen(fn) {
+			return fn(value);
+		},
+		andThenAsync(fn) {
+			return Promise.resolve(fn(value));
+		},
+		orElse(_fn) {
+			return ok;
+		},
+		orElseAsync(_fn) {
+			return Promise.resolve(ok);
+		},
+		inspect(fn) {
+			fn(value);
+			return ok;
+		},
+		inspectErr(_fn) {
+			return ok;
+		},
+		eq(other) {
+			assertResult(other);
+			return other.isOk() && other.unwrap() === value;
+		},
+		asOk() {
+			return ok;
+		},
+		asErr() {
+			throw new TypeError("Result::asErr() called on an `Ok` value");
+		},
+		andTryAsync(fn) {
+			try {
+				const result = fn(value);
+				return Promise.resolve(result).then(Ok, Err);
+			} catch (e) {
+				return Promise.resolve(Err(e));
+			}
+		},
+		orTryAsync(_fn) {
+			return Promise.resolve(ok);
+		}
+	});
+	return ok;
 }
+/**
+* Creates a `Result<T, E>` representing a failed outcome containing an error.
+* This function is used to construct a `Result` that signifies the operation failed by containing the error `E`.
+*
+* @typeParam T - The type of the value that the result could potentially contain (not used in this case).
+* @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'));
+* if (badResult.isErr()) {
+*   console.error(badResult.unwrapErr()); // Outputs: Error: Something went wrong
+* }
+* ```
+*/
 function Err(error) {
-  const err = Object.freeze({
-    [Symbol.toStringTag]: "Result",
-    [ResultKindSymbol]: "Err",
-    *[Symbol.iterator]() {
-    },
-    toString() {
-      return `Err(${error})`;
-    },
-    isOk() {
-      return false;
-    },
-    isErr() {
-      return true;
-    },
-    isOkAnd(_predicate) {
-      return false;
-    },
-    isOkAndAsync(_predicate) {
-      return ASYNC_FALSE$1;
-    },
-    isErrAnd(predicate) {
-      return predicate(error);
-    },
-    isErrAndAsync(predicate) {
-      return Promise.resolve(predicate(error));
-    },
-    expect(msg) {
-      throw new TypeError(`${msg}: ${error}`);
-    },
-    unwrap() {
-      throw new TypeError("Result::unwrap() called on an `Err` value");
-    },
-    unwrapOr(defaultValue) {
-      return defaultValue;
-    },
-    unwrapOrElse(fn) {
-      return fn(error);
-    },
-    unwrapOrElseAsync(fn) {
-      return Promise.resolve(fn(error));
-    },
-    expectErr(_msg) {
-      return error;
-    },
-    unwrapErr() {
-      return error;
-    },
-    intoOk() {
-      throw new TypeError("Result::intoOk() called on an `Err` value");
-    },
-    intoErr() {
-      return error;
-    },
-    ok() {
-      return None;
-    },
-    err() {
-      return Some(error);
-    },
-    transpose() {
-      return Some(err);
-    },
-    map(_fn) {
-      return err;
-    },
-    mapErr(fn) {
-      return Err(fn(error));
-    },
-    mapOr(defaultValue, _fn) {
-      return defaultValue;
-    },
-    mapOrElse(defaultFn, _fn) {
-      return defaultFn(error);
-    },
-    flatten() {
-      return err;
-    },
-    and(_other) {
-      return err;
-    },
-    or(other) {
-      assertResult(other);
-      return other;
-    },
-    andThen(_fn) {
-      return err;
-    },
-    andThenAsync(_fn) {
-      return Promise.resolve(err);
-    },
-    orElse(fn) {
-      return fn(error);
-    },
-    orElseAsync(fn) {
-      return Promise.resolve(fn(error));
-    },
-    inspect(_fn) {
-      return err;
-    },
-    inspectErr(fn) {
-      fn(error);
-      return err;
-    },
-    eq(other) {
-      assertResult(other);
-      return other.isErr() && other.unwrapErr() === error;
-    },
-    asOk() {
-      throw new TypeError("Result::asOk() called on an `Err` value");
-    },
-    asErr() {
-      return err;
-    },
-    andTryAsync(_fn) {
-      return Promise.resolve(err);
-    },
-    orTryAsync(fn) {
-      try {
-        const result = fn(error);
-        return Promise.resolve(result).then(
-          Ok,
-          Err
-        );
-      } catch (e) {
-        return Promise.resolve(Err(e));
-      }
-    }
-  });
-  return err;
+	const err = Object.freeze({
+		[Symbol.toStringTag]: "Result",
+		[ResultKindSymbol]: "Err",
+		*[Symbol.iterator]() {},
+		toString() {
+			return `Err(${error})`;
+		},
+		isOk() {
+			return false;
+		},
+		isErr() {
+			return true;
+		},
+		isOkAnd(_predicate) {
+			return false;
+		},
+		isOkAndAsync(_predicate) {
+			return ASYNC_FALSE$1;
+		},
+		isErrAnd(predicate) {
+			return predicate(error);
+		},
+		isErrAndAsync(predicate) {
+			return Promise.resolve(predicate(error));
+		},
+		expect(msg) {
+			throw new TypeError(`${msg}: ${error}`);
+		},
+		unwrap() {
+			throw new TypeError("Result::unwrap() called on an `Err` value");
+		},
+		unwrapOr(defaultValue) {
+			return defaultValue;
+		},
+		unwrapOrElse(fn) {
+			return fn(error);
+		},
+		unwrapOrElseAsync(fn) {
+			return Promise.resolve(fn(error));
+		},
+		expectErr(_msg) {
+			return error;
+		},
+		unwrapErr() {
+			return error;
+		},
+		intoOk() {
+			throw new TypeError("Result::intoOk() called on an `Err` value");
+		},
+		intoErr() {
+			return error;
+		},
+		ok() {
+			return None;
+		},
+		err() {
+			return Some(error);
+		},
+		transpose() {
+			return Some(err);
+		},
+		map(_fn) {
+			return err;
+		},
+		mapErr(fn) {
+			return Err(fn(error));
+		},
+		mapOr(defaultValue, _fn) {
+			return defaultValue;
+		},
+		mapOrElse(defaultFn, _fn) {
+			return defaultFn(error);
+		},
+		flatten() {
+			return err;
+		},
+		and(_other) {
+			return err;
+		},
+		or(other) {
+			assertResult(other);
+			return other;
+		},
+		andThen(_fn) {
+			return err;
+		},
+		andThenAsync(_fn) {
+			return Promise.resolve(err);
+		},
+		orElse(fn) {
+			return fn(error);
+		},
+		orElseAsync(fn) {
+			return Promise.resolve(fn(error));
+		},
+		inspect(_fn) {
+			return err;
+		},
+		inspectErr(fn) {
+			fn(error);
+			return err;
+		},
+		eq(other) {
+			assertResult(other);
+			return other.isErr() && other.unwrapErr() === error;
+		},
+		asOk() {
+			throw new TypeError("Result::asOk() called on an `Err` value");
+		},
+		asErr() {
+			return err;
+		},
+		andTryAsync(_fn) {
+			return Promise.resolve(err);
+		},
+		orTryAsync(fn) {
+			try {
+				const result = fn(error);
+				return Promise.resolve(result).then(Ok, Err);
+			} catch (e) {
+				return Promise.resolve(Err(e));
+			}
+		}
+	});
+	return err;
 }
+/**
+* Safely converts a value to a string representation for error messages.
+* Handles cases where `toString()` might throw or values are null/undefined.
+*
+* @param value - The value to stringify.
+* @returns A safe string representation of the value.
+*/
 function safeStringify(value) {
-  try {
-    if (value === null) {
-      return "null";
-    }
-    if (value === void 0) {
-      return "undefined";
-    }
-    if (typeof value === "object") {
-      return Object.prototype.toString.call(value);
-    }
-    return String(value);
-  } catch {
-    return "[unable to stringify]";
-  }
+	try {
+		if (value === null) return "null";
+		if (value === void 0) return "undefined";
+		if (typeof value === "object") return Object.prototype.toString.call(value);
+		return String(value);
+	} catch {
+		return "[unable to stringify]";
+	}
 }
+/**
+* Asserts that a given value is an `Option`.
+*
+* @typeParam T - The expected type of the value contained within the `Option`.
+* @param o - The value to be checked as an `Option`.
+* @throws {TypeError} If the value is not an `Option`.
+* @see isOption
+*/
 function assertOption(o) {
-  if (!isOption(o)) {
-    throw new TypeError(`Expected an Option, but received: ${safeStringify(o)}`);
-  }
+	if (!isOption(o)) throw new TypeError(`Expected an Option, but received: ${safeStringify(o)}`);
 }
+/**
+* Asserts that a given value is a `Result`.
+*
+* @typeParam T - The expected type of the success value contained within the `Result`.
+* @typeParam E - The expected type of the error value contained within the `Result`.
+* @param r - The value to be checked as a `Result`.
+* @throws {TypeError} If the value is not a `Result`.
+* @see isResult
+*/
 function assertResult(r) {
-  if (!isResult(r)) {
-    throw new TypeError(`Expected a Result, but received: ${safeStringify(r)}`);
-  }
+	if (!isResult(r)) throw new TypeError(`Expected a Result, but received: ${safeStringify(r)}`);
 }
-
+//#endregion
+//#region src/core/option/extensions.ts
+/**
+* @module
+* Extension functions for bridging standard JavaScript patterns with Option types.
+*
+* This module provides utilities for:
+* - Converting try-catch patterns to Option-based handling
+* - Integrating async/await patterns with Option types
+*/
+/**
+* Executes a function and returns `Some` with the result if successful, or `None` if it throws.
+*
+* This converts try-catch patterns to Option-based handling, where you only care
+* about success/failure, not the error details.
+*
+* Similar to `Promise.try`, this function accepts optional arguments that are passed to the function.
+*
+* @typeParam T - The type of the value returned by the function.
+* @typeParam Args - The types of the arguments to pass to the function.
+* @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
+* const data = tryOption(JSON.parse, jsonString);
+* console.log(data.unwrapOr(defaultData));
+* ```
+*
+* @example
+* ```ts
+* // Validate URL - using closure form
+* const url = tryOption(() => new URL(input));
+* url.inspect(u => console.log('Valid URL:', u.href));
+* ```
+*
+* @example
+* ```ts
+* // Decode URI component with arguments
+* const decoded = tryOption(decodeURIComponent, str);
+* ```
+*/
 function tryOption(fn, ...args) {
-  try {
-    return Some(fn(...args));
-  } catch {
-    return None;
-  }
+	try {
+		return Some(fn(...args));
+	} catch {
+		return None;
+	}
 }
 async function tryAsyncOption(task, ...args) {
-  try {
-    const result = typeof task === "function" ? task(...args) : task;
-    return Some(await result);
-  } catch {
-    return None;
-  }
+	try {
+		return Some(await (typeof task === "function" ? task(...args) : task));
+	} catch {
+		return None;
+	}
 }
-
-const RESULT_TRUE = Ok(true);
-const RESULT_FALSE = Ok(false);
-const RESULT_ZERO = Ok(0);
-const RESULT_VOID = Ok();
-
+//#endregion
+//#region src/core/result/constants.ts
+/**
+* @module
+* Pre-defined Result constants for common return values.
+*
+* These immutable constants can be reused throughout the application to avoid
+* creating new Result instances for common values like `true`, `false`, `0`, and `void`.
+*
+* The error type is `never` because these are always `Ok` values that can never
+* contain an error. This allows them to be assigned to any `Result<T, E>` type.
+*/
+/**
+* Result constant for `true`.
+* Can be used anywhere due to immutability.
+* @since 1.3.0
+* @example
+* ```ts
+* function validate(): Result<boolean, Error> {
+*     return RESULT_TRUE;
+* }
+*
+* const result: Result<boolean, string> = RESULT_TRUE;
+* const value: boolean = RESULT_TRUE.intoOk(); // Safe extraction
+* ```
+*/
+const RESULT_TRUE = /* @__PURE__ */ Ok(true);
+/**
+* Result constant for `false`.
+* Can be used anywhere due to immutability.
+* @since 1.3.0
+* @example
+* ```ts
+* function validate(): Result<boolean, Error> {
+*     return RESULT_FALSE;
+* }
+*
+* const result: Result<boolean, string> = RESULT_FALSE;
+* const value: boolean = RESULT_FALSE.intoOk(); // Safe extraction
+* ```
+*/
+const RESULT_FALSE = /* @__PURE__ */ Ok(false);
+/**
+* Result constant for `0`.
+* Can be used anywhere due to immutability.
+* @since 1.3.0
+* @example
+* ```ts
+* function count(): Result<number, Error> {
+*     return RESULT_ZERO;
+* }
+*
+* const result: Result<number, string> = RESULT_ZERO;
+* const value: number = RESULT_ZERO.intoOk(); // Safe extraction
+* ```
+*/
+const RESULT_ZERO = /* @__PURE__ */ Ok(0);
+/**
+* Result constant for `void` or `()`.
+* Can be used anywhere due to immutability.
+* @since 1.4.0
+* @example
+* ```ts
+* function doSomething(): Result<void, Error> {
+*     return RESULT_VOID;
+* }
+*
+* const result: Result<void, string> = RESULT_VOID;
+* RESULT_VOID.intoOk(); // Safe extraction (returns undefined)
+* ```
+*/
+const RESULT_VOID = /* @__PURE__ */ Ok();
+//#endregion
+//#region src/core/result/extensions.ts
+/**
+* @module
+* Extension functions for bridging standard JavaScript patterns with Result types.
+*
+* This module provides utilities for:
+* - Converting try-catch patterns to Result-based error handling
+* - Integrating async/await patterns with Result types
+*/
+/**
+* Executes a function and captures any thrown exception as an `Err`.
+* If the function executes successfully, returns `Ok` with the result.
+*
+* Use this to convert traditional try-catch error handling to Result-based handling.
+*
+* Similar to `Promise.try`, this function accepts optional arguments that are passed to the function.
+*
+* @typeParam T - The type of the value returned by the function.
+* @typeParam E - The type of the error that may be thrown, defaults to `Error`.
+* @typeParam Args - The types of the arguments to pass to the function.
+* @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
+* const result = tryResult(JSON.parse, jsonString);
+* result.inspect(data => console.log('Parsed:', data))
+*       .inspectErr(err => console.error('Invalid JSON:', err));
+* ```
+*
+* @example
+* ```ts
+* // Validate URL - using closure form
+* const result = tryResult(() => new URL(input));
+* if (result.isOk()) {
+*     console.log('Valid URL:', result.unwrap().href);
+* }
+* ```
+*
+* @example
+* ```ts
+* // With custom error type
+* const result = tryResult<Config, ConfigError, [string]>(parseConfig, raw);
+* ```
+*/
 function tryResult(fn, ...args) {
-  try {
-    return Ok(fn(...args));
-  } catch (err) {
-    return Err(err);
-  }
+	try {
+		return Ok(fn(...args));
+	} catch (err) {
+		return Err(err);
+	}
 }
 async function tryAsyncResult(task, ...args) {
-  try {
-    const result = typeof task === "function" ? task(...args) : task;
-    return Ok(await result);
-  } catch (err) {
-    return Err(err);
-  }
+	try {
+		return Ok(await (typeof task === "function" ? task(...args) : task));
+	} catch (err) {
+		return Err(err);
+	}
 }
-
+//#endregion
+//#region src/std/ops/symbols.ts
+/**
+* @module
+* Internal symbols used to identify `ControlFlow` type variants.
+*
+* These symbols are used as property keys to distinguish between `Break` and `Continue` variants.
+* They provide a reliable way to identify the variant of a `ControlFlow` instance without
+* relying on method calls or duck typing.
+*
+* Note: These symbols are internal implementation details and are not exported as part of the public API.
+* Use the `isControlFlow` utility function for type checking instead.
+*/
+/**
+* A unique symbol used as a property key to identify the variant of a `ControlFlow` instance.
+*
+* When accessed on a `ControlFlow`, returns `'Break'` if the ControlFlow signals early exit,
+* or `'Continue'` if it signals to proceed as normal.
+*
+* This symbol is used internally by the `isControlFlow` utility function to verify
+* that an object is a valid `ControlFlow` instance.
+*
+* @internal
+*/
 const ControlFlowKindSymbol = /* @__PURE__ */ Symbol("ControlFlow kind");
-
+//#endregion
+//#region src/std/ops/control_flow.ts
+/**
+* @module
+* Rust-inspired [ControlFlow](https://doc.rust-lang.org/std/ops/enum.ControlFlow.html) for control flow handling.
+*/
 function Break(value) {
-  const brk = Object.freeze({
-    [Symbol.toStringTag]: "ControlFlow",
-    [ControlFlowKindSymbol]: "Break",
-    toString() {
-      return `Break(${value})`;
-    },
-    isBreak() {
-      return true;
-    },
-    isContinue() {
-      return false;
-    },
-    breakValue() {
-      return Some(value);
-    },
-    continueValue() {
-      return None;
-    },
-    mapBreak(fn) {
-      return Break(fn(value));
-    },
-    mapContinue(_fn) {
-      return brk;
-    },
-    breakOk() {
-      return Ok(value);
-    },
-    continueOk() {
-      return Err(value);
-    },
-    intoValue() {
-      return value;
-    }
-  });
-  return brk;
+	const brk = Object.freeze({
+		[Symbol.toStringTag]: "ControlFlow",
+		[ControlFlowKindSymbol]: "Break",
+		toString() {
+			return `Break(${value})`;
+		},
+		isBreak() {
+			return true;
+		},
+		isContinue() {
+			return false;
+		},
+		breakValue() {
+			return Some(value);
+		},
+		continueValue() {
+			return None;
+		},
+		mapBreak(fn) {
+			return Break(fn(value));
+		},
+		mapContinue(_fn) {
+			return brk;
+		},
+		breakOk() {
+			return Ok(value);
+		},
+		continueOk() {
+			return Err(value);
+		},
+		intoValue() {
+			return value;
+		}
+	});
+	return brk;
 }
 function Continue(value) {
-  const cont = Object.freeze({
-    [Symbol.toStringTag]: "ControlFlow",
-    [ControlFlowKindSymbol]: "Continue",
-    toString() {
-      return `Continue(${value})`;
-    },
-    isBreak() {
-      return false;
-    },
-    isContinue() {
-      return true;
-    },
-    breakValue() {
-      return None;
-    },
-    continueValue() {
-      return Some(value);
-    },
-    mapBreak(_fn) {
-      return cont;
-    },
-    mapContinue(fn) {
-      return Continue(fn(value));
-    },
-    breakOk() {
-      return Err(value);
-    },
-    continueOk() {
-      return Ok(value);
-    },
-    intoValue() {
-      return value;
-    }
-  });
-  return cont;
+	const cont = Object.freeze({
+		[Symbol.toStringTag]: "ControlFlow",
+		[ControlFlowKindSymbol]: "Continue",
+		toString() {
+			return `Continue(${value})`;
+		},
+		isBreak() {
+			return false;
+		},
+		isContinue() {
+			return true;
+		},
+		breakValue() {
+			return None;
+		},
+		continueValue() {
+			return Some(value);
+		},
+		mapBreak(_fn) {
+			return cont;
+		},
+		mapContinue(fn) {
+			return Continue(fn(value));
+		},
+		breakOk() {
+			return Err(value);
+		},
+		continueOk() {
+			return Ok(value);
+		},
+		intoValue() {
+			return value;
+		}
+	});
+	return cont;
 }
-
+//#endregion
+//#region src/std/ops/fn_once.ts
+/**
+* @module
+* Rust-inspired [FnOnce](https://doc.rust-lang.org/std/ops/trait.FnOnce.html) for one-time callable functions.
+*
+* **When to use `FnOnce` vs `FnOnceAsync`:**
+* - Use `FnOnce` for sync functions
+* - Use `FnOnceAsync` for async functions
+*/
+/**
+* Creates a `FnOnce` wrapper around a function, making it callable only once.
+*
+* @typeParam A - Tuple type of the function arguments.
+* @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(() => {
+*     console.log('Initializing...');
+*     return { ready: true };
+* });
+*
+* const result = initialize.call(); // Logs 'Initializing...', returns { ready: true }
+* // initialize.call(); // Throws Error: FnOnce has already been consumed
+* ```
+*/
 function FnOnce(fn) {
-  let consumed = false;
-  return Object.freeze({
-    [Symbol.toStringTag]: "FnOnce",
-    toString() {
-      return `FnOnce(${consumed ? "consumed" : "pending"})`;
-    },
-    call(...args) {
-      if (consumed) {
-        throw new Error("FnOnce has already been consumed");
-      }
-      consumed = true;
-      return fn(...args);
-    },
-    tryCall(...args) {
-      if (consumed) {
-        return None;
-      }
-      consumed = true;
-      return Some(fn(...args));
-    },
-    isConsumed() {
-      return consumed;
-    }
-  });
+	let consumed = false;
+	return Object.freeze({
+		[Symbol.toStringTag]: "FnOnce",
+		toString() {
+			return `FnOnce(${consumed ? "consumed" : "pending"})`;
+		},
+		call(...args) {
+			if (consumed) throw new Error("FnOnce has already been consumed");
+			consumed = true;
+			return fn(...args);
+		},
+		tryCall(...args) {
+			if (consumed) return None;
+			consumed = true;
+			return Some(fn(...args));
+		},
+		isConsumed() {
+			return consumed;
+		}
+	});
 }
-
+//#endregion
+//#region src/std/ops/fn_once_async.ts
+/**
+* @module
+* Rust-inspired [AsyncFnOnce](https://doc.rust-lang.org/std/ops/trait.AsyncFnOnce.html) for one-time callable async functions.
+*
+* **When to use `FnOnce` vs `FnOnceAsync`:**
+* - Use `FnOnce` for sync functions
+* - Use `FnOnceAsync` for async functions
+*/
+/**
+* Creates a `FnOnceAsync` wrapper around an async function, making it callable only once.
+*
+* @typeParam A - Tuple type of the function arguments.
+* @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 () => {
+*     console.log('Initializing...');
+*     await loadResources();
+*     return { ready: true };
+* });
+*
+* const result = await initialize.call(); // Logs 'Initializing...', returns { ready: true }
+* // await initialize.call(); // Throws Error: FnOnceAsync has already been consumed
+* ```
+*/
 function FnOnceAsync(fn) {
-  let consumed = false;
-  return Object.freeze({
-    [Symbol.toStringTag]: "FnOnceAsync",
-    toString() {
-      return `FnOnceAsync(${consumed ? "consumed" : "pending"})`;
-    },
-    call(...args) {
-      if (consumed) {
-        throw new Error("FnOnceAsync has already been consumed");
-      }
-      consumed = true;
-      return Promise.resolve(fn(...args));
-    },
-    // Use `Promise.resolve(fn())` instead of `async` to preserve sync error behavior:
-    // sync throws propagate directly, async errors become rejected Promises.
-    tryCall(...args) {
-      if (consumed) {
-        return ASYNC_NONE;
-      }
-      consumed = true;
-      return Promise.resolve(fn(...args)).then(Some);
-    },
-    isConsumed() {
-      return consumed;
-    }
-  });
+	let consumed = false;
+	return Object.freeze({
+		[Symbol.toStringTag]: "FnOnceAsync",
+		toString() {
+			return `FnOnceAsync(${consumed ? "consumed" : "pending"})`;
+		},
+		call(...args) {
+			if (consumed) throw new Error("FnOnceAsync has already been consumed");
+			consumed = true;
+			return Promise.resolve(fn(...args));
+		},
+		tryCall(...args) {
+			if (consumed) return ASYNC_NONE;
+			consumed = true;
+			return Promise.resolve(fn(...args)).then(Some);
+		},
+		isConsumed() {
+			return consumed;
+		}
+	});
 }
-
+//#endregion
+//#region src/std/ops/guards.ts
+/**
+* Checks if a value is a `ControlFlow`.
+*
+* @typeParam B - The expected type of the break value contained within the `ControlFlow`.
+* @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);
+* console.log(isControlFlow(x)); // true
+* console.log(isControlFlow(null)); // false
+* console.log(isControlFlow({ isBreak: () => true })); // false
+* ```
+*/
 function isControlFlow(cf) {
-  return cf != null && typeof cf === "object" && ControlFlowKindSymbol in cf;
+	return cf != null && typeof cf === "object" && ControlFlowKindSymbol in cf;
 }
-
-const ASYNC_TRUE = Promise.resolve(true);
-const ASYNC_FALSE = Promise.resolve(false);
+//#endregion
+//#region src/std/sync/channel.ts
+/**
+* @module
+* Rust-inspired MPMC (multi-producer multi-consumer) channel for async message passing.
+*
+* Provides a type-safe channel with optional bounded capacity and backpressure support.
+* Supports rendezvous (capacity=0) for synchronous handoff between sender and receiver.
+*
+*/
+const ASYNC_TRUE = /* @__PURE__ */ Promise.resolve(true);
+const ASYNC_FALSE = /* @__PURE__ */ Promise.resolve(false);
+/**
+* Creates a new MPMC channel with the specified capacity.
+*
+* @typeParam T - The type of values that can be sent through the channel.
+* @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)
+* const unbounded = Channel<string>();
+*
+* // Bounded channel with backpressure
+* const bounded = Channel<string>(100);
+*
+* // Rendezvous channel (synchronous handoff)
+* const rendezvous = Channel<string>(0);
+* ```
+*
+* @example
+* ```ts
+* // Task queue with backpressure
+* const taskQueue = Channel<() => Promise<void>>(10);
+*
+* // Worker
+* (async () => {
+*     for await (const task of taskQueue) {
+*         await task();
+*     }
+* })();
+*
+* // Producer - will wait if queue is full
+* await taskQueue.send(async () => {
+*     console.log('Processing...');
+* });
+* ```
+*
+* @example
+* ```ts
+* // Log aggregation with multiple producers
+* const logs = Channel<string>(1000);
+*
+* // Multiple producers
+* async function logFromService(name: string) {
+*     const sender = logs.sender();
+*     await sender.send(`[${name}] Started`);
+*     // ... do work ...
+*     await sender.send(`[${name}] Finished`);
+* }
+*
+* // Single consumer writing to file
+* async function writeLogsToFile() {
+*     const receiver = logs.receiver();
+*     for await (const log of receiver) {
+*         await fs.appendFile('app.log', log + '\n');
+*     }
+* }
+* ```
+*/
 function Channel(capacity = Infinity) {
-  if (capacity < 0 || !Number.isInteger(capacity) && capacity !== Infinity) {
-    throw new RangeError("Channel capacity must be a non-negative integer or Infinity");
-  }
-  const buffer = [];
-  let closed = false;
-  const sendWaitQueue = [];
-  const receiveWaitQueue = [];
-  let cachedSender;
-  let cachedReceiver;
-  function send(value) {
-    if (closed) {
-      return ASYNC_FALSE;
-    }
-    if (trySend(value)) {
-      return ASYNC_TRUE;
-    }
-    return new Promise((resolve) => {
-      sendWaitQueue.push({ value, resolve });
-    });
-  }
-  function trySend(value) {
-    if (closed) {
-      return false;
-    }
-    if (receiveWaitQueue.length > 0) {
-      const receiver = receiveWaitQueue.shift();
-      receiver(Some(value));
-      return true;
-    }
-    if (buffer.length < capacity) {
-      buffer.push(value);
-      return true;
-    }
-    return false;
-  }
-  function receive() {
-    const result = tryReceive();
-    if (result.isSome()) {
-      return Promise.resolve(result);
-    }
-    if (closed) {
-      return ASYNC_NONE;
-    }
-    return new Promise((resolve) => {
-      receiveWaitQueue.push(resolve);
-    });
-  }
-  function tryReceive() {
-    if (buffer.length > 0) {
-      const value = buffer.shift();
-      if (sendWaitQueue.length > 0) {
-        const sender = sendWaitQueue.shift();
-        buffer.push(sender.value);
-        sender.resolve(true);
-      }
-      return Some(value);
-    }
-    if (sendWaitQueue.length > 0) {
-      const sender = sendWaitQueue.shift();
-      sender.resolve(true);
-      return Some(sender.value);
-    }
-    return None;
-  }
-  function close() {
-    if (closed) {
-      return;
-    }
-    closed = true;
-    while (sendWaitQueue.length > 0) {
-      const sender = sendWaitQueue.shift();
-      sender.resolve(false);
-    }
-    while (receiveWaitQueue.length > 0) {
-      const receiver = receiveWaitQueue.shift();
-      receiver(None);
-    }
-  }
-  function sendTimeout(value, ms) {
-    if (closed) {
-      return ASYNC_FALSE;
-    }
-    if (trySend(value)) {
-      return ASYNC_TRUE;
-    }
-    return new Promise((resolve) => {
-      const waiter = { value, resolve };
-      sendWaitQueue.push(waiter);
-      const timeoutId = setTimeout(() => {
-        const index = sendWaitQueue.indexOf(waiter);
-        sendWaitQueue.splice(index, 1);
-        resolve(false);
-      }, ms);
-      const originalResolve = waiter.resolve;
-      waiter.resolve = (success) => {
-        clearTimeout(timeoutId);
-        originalResolve(success);
-      };
-    });
-  }
-  function receiveTimeout(ms) {
-    const result = tryReceive();
-    if (result.isSome()) {
-      return Promise.resolve(result);
-    }
-    if (closed) {
-      return ASYNC_NONE;
-    }
-    return new Promise((resolve) => {
-      const wrappedWaiter = (value) => {
-        clearTimeout(timeoutId);
-        resolve(value);
-      };
-      receiveWaitQueue.push(wrappedWaiter);
-      const timeoutId = setTimeout(() => {
-        const index = receiveWaitQueue.indexOf(wrappedWaiter);
-        receiveWaitQueue.splice(index, 1);
-        resolve(None);
-      }, ms);
-    });
-  }
-  function asyncIterator() {
-    return {
-      async next() {
-        const result = await receive();
-        if (result.isNone()) {
-          return { done: true, value: void 0 };
-        }
-        return { done: false, value: result.unwrap() };
-      }
-    };
-  }
-  function createSender() {
-    return Object.freeze({
-      [Symbol.toStringTag]: "Sender",
-      toString() {
-        if (closed) {
-          return "Sender(<closed>)";
-        }
-        if (capacity === Infinity) {
-          return `Sender(${buffer.length}/∞)`;
-        }
-        return `Sender(${buffer.length}/${capacity})`;
-      },
-      get capacity() {
-        return capacity;
-      },
-      get length() {
-        return buffer.length;
-      },
-      get isClosed() {
-        return closed;
-      },
-      get isEmpty() {
-        return buffer.length === 0;
-      },
-      get isFull() {
-        return buffer.length >= capacity;
-      },
-      send,
-      trySend,
-      sendTimeout
-    });
-  }
-  function createReceiver() {
-    return Object.freeze({
-      [Symbol.toStringTag]: "Receiver",
-      [Symbol.asyncIterator]: asyncIterator,
-      toString() {
-        if (closed) {
-          return "Receiver(<closed>)";
-        }
-        if (capacity === Infinity) {
-          return `Receiver(${buffer.length}/∞)`;
-        }
-        return `Receiver(${buffer.length}/${capacity})`;
-      },
-      get capacity() {
-        return capacity;
-      },
-      get length() {
-        return buffer.length;
-      },
-      get isClosed() {
-        return closed;
-      },
-      get isEmpty() {
-        return buffer.length === 0;
-      },
-      get isFull() {
-        return buffer.length >= capacity;
-      },
-      receive,
-      tryReceive,
-      receiveTimeout
-    });
-  }
-  return Object.freeze({
-    [Symbol.toStringTag]: "Channel",
-    [Symbol.asyncIterator]: asyncIterator,
-    toString() {
-      if (closed) {
-        return "Channel(<closed>)";
-      }
-      if (capacity === Infinity) {
-        return `Channel(${buffer.length}/∞)`;
-      }
-      return `Channel(${buffer.length}/${capacity})`;
-    },
-    get capacity() {
-      return capacity;
-    },
-    get length() {
-      return buffer.length;
-    },
-    get isClosed() {
-      return closed;
-    },
-    get isEmpty() {
-      return buffer.length === 0;
-    },
-    get isFull() {
-      return buffer.length >= capacity;
-    },
-    get sender() {
-      return cachedSender ??= createSender();
-    },
-    get receiver() {
-      return cachedReceiver ??= createReceiver();
-    },
-    send,
-    trySend,
-    sendTimeout,
-    receive,
-    tryReceive,
-    receiveTimeout,
-    close
-  });
+	if (capacity < 0 || !Number.isInteger(capacity) && capacity !== Infinity) throw new RangeError("Channel capacity must be a non-negative integer or Infinity");
+	const buffer = new Queue();
+	let closed = false;
+	const sendWaitQueue = [];
+	const receiveWaitQueue = [];
+	let cachedSender;
+	let cachedReceiver;
+	function send(value) {
+		if (closed) return ASYNC_FALSE;
+		if (trySend(value)) return ASYNC_TRUE;
+		return new Promise((resolve) => {
+			sendWaitQueue.push({
+				value,
+				resolve
+			});
+		});
+	}
+	function trySend(value) {
+		if (closed) return false;
+		if (receiveWaitQueue.length > 0) {
+			receiveWaitQueue.shift()(Some(value));
+			return true;
+		}
+		if (buffer.length < capacity) {
+			buffer.push(value);
+			return true;
+		}
+		return false;
+	}
+	function receive() {
+		const result = tryReceive();
+		if (result.isSome()) return Promise.resolve(result);
+		if (closed) return ASYNC_NONE;
+		return new Promise((resolve) => {
+			receiveWaitQueue.push(resolve);
+		});
+	}
+	function tryReceive() {
+		if (buffer.length > 0) {
+			const value = buffer.shift();
+			if (sendWaitQueue.length > 0) {
+				const sender = sendWaitQueue.shift();
+				buffer.push(sender.value);
+				sender.resolve(true);
+			}
+			return Some(value);
+		}
+		if (sendWaitQueue.length > 0) {
+			const sender = sendWaitQueue.shift();
+			sender.resolve(true);
+			return Some(sender.value);
+		}
+		return None;
+	}
+	function close() {
+		if (closed) return;
+		closed = true;
+		while (sendWaitQueue.length > 0) sendWaitQueue.shift().resolve(false);
+		while (receiveWaitQueue.length > 0) receiveWaitQueue.shift()(None);
+	}
+	function sendTimeout(value, ms) {
+		if (closed) return ASYNC_FALSE;
+		if (trySend(value)) return ASYNC_TRUE;
+		return new Promise((resolve) => {
+			const waiter = {
+				value,
+				resolve
+			};
+			sendWaitQueue.push(waiter);
+			const timeoutId = setTimeout(() => {
+				const index = sendWaitQueue.indexOf(waiter);
+				sendWaitQueue.splice(index, 1);
+				resolve(false);
+			}, ms);
+			const originalResolve = waiter.resolve;
+			waiter.resolve = (success) => {
+				clearTimeout(timeoutId);
+				originalResolve(success);
+			};
+		});
+	}
+	function receiveTimeout(ms) {
+		const result = tryReceive();
+		if (result.isSome()) return Promise.resolve(result);
+		if (closed) return ASYNC_NONE;
+		return new Promise((resolve) => {
+			const wrappedWaiter = (value) => {
+				clearTimeout(timeoutId);
+				resolve(value);
+			};
+			receiveWaitQueue.push(wrappedWaiter);
+			const timeoutId = setTimeout(() => {
+				const index = receiveWaitQueue.indexOf(wrappedWaiter);
+				receiveWaitQueue.splice(index, 1);
+				resolve(None);
+			}, ms);
+		});
+	}
+	function asyncIterator() {
+		return { async next() {
+			const result = await receive();
+			if (result.isNone()) return {
+				done: true,
+				value: void 0
+			};
+			return {
+				done: false,
+				value: result.unwrap()
+			};
+		} };
+	}
+	function createSender() {
+		return Object.freeze({
+			[Symbol.toStringTag]: "Sender",
+			toString() {
+				if (closed) return "Sender(<closed>)";
+				if (capacity === Infinity) return `Sender(${buffer.length}/∞)`;
+				return `Sender(${buffer.length}/${capacity})`;
+			},
+			get capacity() {
+				return capacity;
+			},
+			get length() {
+				return buffer.length;
+			},
+			get isClosed() {
+				return closed;
+			},
+			get isEmpty() {
+				return buffer.length === 0;
+			},
+			get isFull() {
+				return buffer.length >= capacity;
+			},
+			send,
+			trySend,
+			sendTimeout
+		});
+	}
+	function createReceiver() {
+		return Object.freeze({
+			[Symbol.toStringTag]: "Receiver",
+			[Symbol.asyncIterator]: asyncIterator,
+			toString() {
+				if (closed) return "Receiver(<closed>)";
+				if (capacity === Infinity) return `Receiver(${buffer.length}/∞)`;
+				return `Receiver(${buffer.length}/${capacity})`;
+			},
+			get capacity() {
+				return capacity;
+			},
+			get length() {
+				return buffer.length;
+			},
+			get isClosed() {
+				return closed;
+			},
+			get isEmpty() {
+				return buffer.length === 0;
+			},
+			get isFull() {
+				return buffer.length >= capacity;
+			},
+			receive,
+			tryReceive,
+			receiveTimeout
+		});
+	}
+	return Object.freeze({
+		[Symbol.toStringTag]: "Channel",
+		[Symbol.asyncIterator]: asyncIterator,
+		toString() {
+			if (closed) return "Channel(<closed>)";
+			if (capacity === Infinity) return `Channel(${buffer.length}/∞)`;
+			return `Channel(${buffer.length}/${capacity})`;
+		},
+		get capacity() {
+			return capacity;
+		},
+		get length() {
+			return buffer.length;
+		},
+		get isClosed() {
+			return closed;
+		},
+		get isEmpty() {
+			return buffer.length === 0;
+		},
+		get isFull() {
+			return buffer.length >= capacity;
+		},
+		get sender() {
+			return cachedSender ??= createSender();
+		},
+		get receiver() {
+			return cachedReceiver ??= createReceiver();
+		},
+		send,
+		trySend,
+		sendTimeout,
+		receive,
+		tryReceive,
+		receiveTimeout,
+		close
+	});
 }
-
+/**
+* A fast FIFO queue implementation using an array and an offset pointer.
+* This avoids the O(n) overhead of Array.shift() by simply incrementing the offset.
+*
+* When the offset exceeds a threshold (1024) and more than half the array is empty,
+* the array is compacted by slicing. The threshold 1024 was chosen empirically:
+* - Too small: frequent compaction overhead
+* - Too large: excessive memory waste
+* - 1024 balances compaction frequency and memory usage across typical workloads
+*
+* Benchmark results show minimal performance difference between thresholds (64-16384),
+* so 1024 is a reasonable default that works well for most Channel use cases.
+*/
+var Queue = class {
+	data = [];
+	offset = 0;
+	get length() {
+		return this.data.length - this.offset;
+	}
+	push(item) {
+		this.data.push(item);
+	}
+	shift() {
+		const item = this.data[this.offset];
+		this.data[this.offset] = void 0;
+		this.offset++;
+		if (this.offset > 1024 && this.offset * 2 > this.data.length) {
+			this.data = this.data.slice(this.offset);
+			this.offset = 0;
+		}
+		return item;
+	}
+};
+//#endregion
+//#region src/std/sync/lazy.ts
+/**
+* @module
+* Rust-inspired [LazyLock](https://doc.rust-lang.org/std/sync/struct.LazyLock.html) for lazy initialization.
+*
+* Unlike `Once<T>`, which allows setting values manually or with different
+* initializers, `Lazy<T>` binds the initializer at creation time.
+*
+* **When to use `Lazy<T>` vs `LazyAsync<T>`:**
+* - Use `Lazy<T>` for sync-only initialization
+* - Use `LazyAsync<T>` for async initialization with concurrent call handling
+*/
+/**
+* Creates a new `Lazy<T>` with the given synchronous initialization function.
+*
+* The function is called at most once, on first access via `force()`.
+*
+* @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
+* const lazy = Lazy(() => {
+*     console.log('Initializing');
+*     return 42;
+* });
+*
+* console.log(lazy.isInitialized()); // false
+* console.log(lazy.force()); // logs "Initializing", returns 42
+* console.log(lazy.isInitialized()); // true
+* console.log(lazy.force()); // returns 42 (no log)
+* ```
+*
+* @example
+* ```ts
+* // Lazy singleton pattern
+* const logger = Lazy(() => new Logger('app'));
+*
+* function getLogger(): Logger {
+*     return logger.force();
+* }
+* ```
+*
+* @example
+* ```ts
+* // Expensive computation
+* const fibonacci = Lazy(() => {
+*     function fib(n: number): number {
+*         if (n <= 1) return n;
+*         return fib(n - 1) + fib(n - 2);
+*     }
+*     return fib(40); // Only computed once
+* });
+* ```
+*/
 function Lazy(fn) {
-  let value;
-  let initialized = false;
-  return Object.freeze({
-    [Symbol.toStringTag]: "Lazy",
-    toString() {
-      return initialized ? `Lazy(${value})` : "Lazy(<uninitialized>)";
-    },
-    force() {
-      if (!initialized) {
-        value = fn();
-        initialized = true;
-      }
-      return value;
-    },
-    get() {
-      return initialized ? Some(value) : None;
-    },
-    isInitialized() {
-      return initialized;
-    }
-  });
+	let value;
+	let initialized = false;
+	return Object.freeze({
+		[Symbol.toStringTag]: "Lazy",
+		toString() {
+			return initialized ? `Lazy(${value})` : "Lazy(<uninitialized>)";
+		},
+		force() {
+			if (!initialized) {
+				value = fn();
+				initialized = true;
+			}
+			return value;
+		},
+		get() {
+			return initialized ? Some(value) : None;
+		},
+		isInitialized() {
+			return initialized;
+		}
+	});
 }
-
+//#endregion
+//#region src/std/sync/lazy_async.ts
+/**
+* @module
+* Rust-inspired [LazyLock](https://doc.rust-lang.org/std/sync/struct.LazyLock.html) for async lazy initialization.
+*
+* **When to use `Lazy<T>` vs `LazyAsync<T>`:**
+* - Use `Lazy<T>` for sync-only initialization
+* - Use `LazyAsync<T>` for async initialization with concurrent call handling
+*/
+/**
+* Creates a new `LazyAsync<T>` with the given async initialization function.
+*
+* The function is called at most once, on first access via `force()`.
+* Concurrent calls to `force()` before initialization completes will
+* wait for the single initialization to finish.
+*
+* @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
+* const lazy = LazyAsync(async () => {
+*     const response = await fetch('/api/data');
+*     return await response.json();
+* });
+*
+* const data = await lazy.force();
+* ```
+*
+* @example
+* ```ts
+* // Database connection singleton
+* const db = LazyAsync(async () => {
+*     console.log('Connecting to database...');
+*     return await Database.connect(connectionString);
+* });
+*
+* async function getDb(): Promise<Database> {
+*     return await db.force();
+* }
+*
+* // Multiple calls - connection happens only once
+* const [db1, db2] = await Promise.all([getDb(), getDb()]);
+* console.log(db1 === db2); // true
+* ```
+*
+* @example
+* ```ts
+* // Configuration loader
+* const config = LazyAsync(async () => {
+*     const response = await fetch('/api/config');
+*     if (!response.ok) {
+*         throw new Error(`Failed to load config: ${response.status}`);
+*     }
+*     return await response.json() as Config;
+* });
+*
+* // Used throughout the app
+* async function getApiEndpoint(): Promise<string> {
+*     const cfg = await config.force();
+*     return cfg.apiEndpoint;
+* }
+* ```
+*/
 function LazyAsync(fn) {
-  let value;
-  let initialized = false;
-  let pendingPromise;
-  return Object.freeze({
-    [Symbol.toStringTag]: "LazyAsync",
-    toString() {
-      return initialized ? `LazyAsync(${value})` : "LazyAsync(<uninitialized>)";
-    },
-    // Use `Promise.resolve(fn())` instead of `async` to preserve sync error behavior:
-    // sync throws propagate directly, async errors become rejected Promises.
-    force() {
-      if (initialized) {
-        return pendingPromise ??= Promise.resolve(value);
-      }
-      if (pendingPromise) {
-        return pendingPromise;
-      }
-      pendingPromise = Promise.resolve(fn()).then(
-        (result) => {
-          value = result;
-          initialized = true;
-          return result;
-        }
-      ).catch((err) => {
-        pendingPromise = void 0;
-        throw err;
-      });
-      return pendingPromise;
-    },
-    get() {
-      return initialized ? Some(value) : None;
-    },
-    isInitialized() {
-      return initialized;
-    }
-  });
+	let value;
+	let initialized = false;
+	let pendingPromise;
+	return Object.freeze({
+		[Symbol.toStringTag]: "LazyAsync",
+		toString() {
+			return initialized ? `LazyAsync(${value})` : "LazyAsync(<uninitialized>)";
+		},
+		force() {
+			if (initialized) return pendingPromise ??= Promise.resolve(value);
+			if (pendingPromise) return pendingPromise;
+			pendingPromise = Promise.resolve(fn()).then((result) => {
+				value = result;
+				initialized = true;
+				return result;
+			}).catch((err) => {
+				pendingPromise = void 0;
+				throw err;
+			});
+			return pendingPromise;
+		},
+		get() {
+			return initialized ? Some(value) : None;
+		},
+		isInitialized() {
+			return initialized;
+		}
+	});
 }
-
+//#endregion
+//#region src/std/sync/mutex.ts
+/**
+* @module
+* Rust-inspired [Mutex](https://doc.rust-lang.org/std/sync/struct.Mutex.html) for async mutual exclusion.
+*
+* In JavaScript's single-threaded environment, `Mutex<T>` is used to serialize
+* async operations, ensuring only one async task accesses the protected resource at a time.
+*/
+/**
+* Creates a new `Mutex<T>` protecting the given value.
+*
+* @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
+* const counter = Mutex(0);
+*
+* // Protect an object
+* const state = Mutex({ users: [], lastUpdate: Date.now() });
+*
+* // Protect a resource
+* const db = Mutex(await createConnection());
+* ```
+*
+* @example
+* ```ts
+* // Database transaction safety
+* const connection = Mutex(db);
+*
+* async function transfer(from: string, to: string, amount: number) {
+*     await connection.withLock(async (conn) => {
+*         await conn.beginTransaction();
+*         try {
+*             const balance = await conn.query('SELECT balance FROM accounts WHERE id = ?', [from]);
+*             if (balance < amount) {
+*                 throw new Error('Insufficient funds');
+*             }
+*             await conn.query('UPDATE accounts SET balance = balance - ? WHERE id = ?', [amount, from]);
+*             await conn.query('UPDATE accounts SET balance = balance + ? WHERE id = ?', [amount, to]);
+*             await conn.commit();
+*         } catch (e) {
+*             await conn.rollback();
+*             throw e;
+*         }
+*     });
+* }
+* ```
+*
+* @example
+* ```ts
+* // Token refresh with mutex
+* const authState = Mutex({ token: '', expiresAt: 0 });
+*
+* async function getToken(): Promise<string> {
+*     return await authState.withLock(async (state) => {
+*         if (Date.now() > state.expiresAt) {
+*             const response = await fetch('/api/refresh');
+*             const data = await response.json();
+*             state.token = data.token;
+*             state.expiresAt = Date.now() + data.expiresIn * 1000;
+*         }
+*         return state.token;
+*     });
+* }
+* ```
+*
+* @example
+* ```ts
+* // File write serialization
+* const fileLock = Mutex('/path/to/file.json');
+*
+* async function appendToFile(data: string) {
+*     await fileLock.withLock(async (path) => {
+*         const content = await fs.readFile(path, 'utf-8');
+*         const json = JSON.parse(content);
+*         json.entries.push(data);
+*         await fs.writeFile(path, JSON.stringify(json, null, 2));
+*     });
+* }
+* ```
+*/
 function Mutex(value) {
-  let currentValue = value;
-  let locked = false;
-  const waitQueue = [];
-  function unlock() {
-    if (waitQueue.length > 0) {
-      const next = waitQueue.shift();
-      next();
-    } else {
-      locked = false;
-    }
-  }
-  function createGuard() {
-    let released = false;
-    return Object.freeze({
-      [Symbol.toStringTag]: "MutexGuard",
-      toString() {
-        if (released) {
-          return "MutexGuard(<released>)";
-        }
-        return `MutexGuard(${currentValue})`;
-      },
-      get value() {
-        if (released) {
-          throw new Error("MutexGuard has been released");
-        }
-        return currentValue;
-      },
-      set value(newValue) {
-        if (released) {
-          throw new Error("MutexGuard has been released");
-        }
-        currentValue = newValue;
-      },
-      unlock() {
-        if (released) {
-          return;
-        }
-        released = true;
-        unlock();
-      }
-    });
-  }
-  function lock() {
-    if (!locked) {
-      locked = true;
-      return Promise.resolve(createGuard());
-    }
-    return new Promise((resolve) => {
-      waitQueue.push(() => {
-        resolve(createGuard());
-      });
-    });
-  }
-  return Object.freeze({
-    [Symbol.toStringTag]: "Mutex",
-    toString() {
-      return locked ? "Mutex(<locked>)" : "Mutex(<unlocked>)";
-    },
-    async withLock(fn) {
-      const guard = await lock();
-      try {
-        return await fn(guard.value);
-      } finally {
-        guard.unlock();
-      }
-    },
-    lock,
-    tryLock() {
-      if (locked) {
-        return None;
-      }
-      locked = true;
-      return Some(createGuard());
-    },
-    isLocked() {
-      return locked;
-    },
-    async get() {
-      const guard = await lock();
-      try {
-        return guard.value;
-      } finally {
-        guard.unlock();
-      }
-    },
-    async set(value2) {
-      const guard = await lock();
-      try {
-        guard.value = value2;
-      } finally {
-        guard.unlock();
-      }
-    },
-    async replace(value2) {
-      const guard = await lock();
-      try {
-        const old = guard.value;
-        guard.value = value2;
-        return old;
-      } finally {
-        guard.unlock();
-      }
-    }
-  });
+	let currentValue = value;
+	let locked = false;
+	const waitQueue = [];
+	function unlock() {
+		if (waitQueue.length > 0) waitQueue.shift()();
+		else locked = false;
+	}
+	function createGuard() {
+		let released = false;
+		return Object.freeze({
+			[Symbol.toStringTag]: "MutexGuard",
+			toString() {
+				if (released) return "MutexGuard(<released>)";
+				return `MutexGuard(${currentValue})`;
+			},
+			get value() {
+				if (released) throw new Error("MutexGuard has been released");
+				return currentValue;
+			},
+			set value(newValue) {
+				if (released) throw new Error("MutexGuard has been released");
+				currentValue = newValue;
+			},
+			unlock() {
+				if (released) return;
+				released = true;
+				unlock();
+			}
+		});
+	}
+	function lock() {
+		if (!locked) {
+			locked = true;
+			return Promise.resolve(createGuard());
+		}
+		return new Promise((resolve) => {
+			waitQueue.push(() => {
+				resolve(createGuard());
+			});
+		});
+	}
+	return Object.freeze({
+		[Symbol.toStringTag]: "Mutex",
+		toString() {
+			return locked ? "Mutex(<locked>)" : "Mutex(<unlocked>)";
+		},
+		async withLock(fn) {
+			const guard = await lock();
+			try {
+				return await fn(guard.value);
+			} finally {
+				guard.unlock();
+			}
+		},
+		lock,
+		tryLock() {
+			if (locked) return None;
+			locked = true;
+			return Some(createGuard());
+		},
+		isLocked() {
+			return locked;
+		},
+		async get() {
+			const guard = await lock();
+			try {
+				return guard.value;
+			} finally {
+				guard.unlock();
+			}
+		},
+		async set(value) {
+			const guard = await lock();
+			try {
+				guard.value = value;
+			} finally {
+				guard.unlock();
+			}
+		},
+		async replace(value) {
+			const guard = await lock();
+			try {
+				const old = guard.value;
+				guard.value = value;
+				return old;
+			} finally {
+				guard.unlock();
+			}
+		}
+	});
 }
-
+//#endregion
+//#region src/std/sync/once.ts
+/**
+* @module
+* Rust-inspired [OnceLock](https://doc.rust-lang.org/std/sync/struct.OnceLock.html) for one-time initialization.
+*
+* `Once<T>` is a container which can be written to only once. It provides safe access
+* to lazily initialized data with synchronous initialization.
+*
+* **When to use `Once<T>` vs `OnceAsync<T>`:**
+* - Use `Once<T>` for sync-only initialization
+* - Use `OnceAsync<T>` for async initialization with concurrent call handling
+*/
+/**
+* Creates a new empty `Once<T>`.
+*
+* @typeParam T - The type of value to store.
+* @returns A new uninitialized `Once`.
+* @example
+* ```ts
+* // Basic usage
+* const once = Once<string>();
+* once.set('hello');
+* console.log(once.get().unwrap()); // 'hello'
+* ```
+*
+* @example
+* ```ts
+* // Sync lazy singleton pattern
+* const logger = Once<Logger>();
+*
+* function getLogger(): Logger {
+*     return logger.getOrInit(() => new Logger('app'));
+* }
+* ```
+*
+* @example
+* ```ts
+* // Fallible sync initialization
+* const config = Once<Config>();
+*
+* function loadConfig(): Result<Config, Error> {
+*     return config.getOrTryInit(() => {
+*         const data = readFileSync('config.json');
+*         return data ? Ok(JSON.parse(data)) : Err(new Error('Config not found'));
+*     });
+* }
+* ```
+*/
 function Once() {
-  let value;
-  let initialized = false;
-  function setValue(val) {
-    value = val;
-    initialized = true;
-  }
-  return Object.freeze({
-    [Symbol.toStringTag]: "Once",
-    toString() {
-      return initialized ? `Once(${value})` : "Once(<uninitialized>)";
-    },
-    get() {
-      return initialized ? Some(value) : None;
-    },
-    set(newValue) {
-      if (initialized) {
-        return Err(newValue);
-      }
-      setValue(newValue);
-      return RESULT_VOID;
-    },
-    tryInsert(newValue) {
-      if (initialized) {
-        return Err([value, newValue]);
-      }
-      setValue(newValue);
-      return Ok(newValue);
-    },
-    getOrInit(fn) {
-      if (!initialized) {
-        setValue(fn());
-      }
-      return value;
-    },
-    getOrTryInit(fn) {
-      if (initialized) {
-        return Ok(value);
-      }
-      const result = fn();
-      if (result.isOk()) {
-        setValue(result.unwrap());
-      }
-      return result;
-    },
-    take() {
-      if (!initialized) {
-        return None;
-      }
-      const taken = value;
-      value = void 0;
-      initialized = false;
-      return Some(taken);
-    },
-    isInitialized() {
-      return initialized;
-    }
-  });
+	let value;
+	let initialized = false;
+	/**
+	* Sets the value and marks as initialized.
+	*/
+	function setValue(val) {
+		value = val;
+		initialized = true;
+	}
+	return Object.freeze({
+		[Symbol.toStringTag]: "Once",
+		toString() {
+			return initialized ? `Once(${value})` : "Once(<uninitialized>)";
+		},
+		get() {
+			return initialized ? Some(value) : None;
+		},
+		set(newValue) {
+			if (initialized) return Err(newValue);
+			setValue(newValue);
+			return RESULT_VOID;
+		},
+		tryInsert(newValue) {
+			if (initialized) return Err([value, newValue]);
+			setValue(newValue);
+			return Ok(newValue);
+		},
+		getOrInit(fn) {
+			if (!initialized) setValue(fn());
+			return value;
+		},
+		getOrTryInit(fn) {
+			if (initialized) return Ok(value);
+			const result = fn();
+			if (result.isOk()) setValue(result.unwrap());
+			return result;
+		},
+		take() {
+			if (!initialized) return None;
+			const taken = value;
+			value = void 0;
+			initialized = false;
+			return Some(taken);
+		},
+		isInitialized() {
+			return initialized;
+		}
+	});
 }
-
+//#endregion
+//#region src/std/sync/once_async.ts
+/**
+* @module
+* Async-first one-time initialization container.
+*
+* `OnceAsync<T>` is designed for async initialization where the stored value
+* is always `Awaited<T>`, matching JavaScript's Promise flattening behavior.
+*
+* **When to use `OnceAsync<T>` vs `Once<T>`:**
+* - Use `Once<T>` for sync-only initialization
+* - Use `OnceAsync<T>` for async initialization with concurrent call handling
+*/
+/**
+* Creates a new empty `OnceAsync<T>`.
+*
+* `OnceAsync<T>` stores `Awaited<T>`, matching JavaScript's Promise flattening behavior.
+* This means `OnceAsync<Promise<number>>` and `OnceAsync<number>` behave identically.
+*
+* @typeParam T - The type parameter. The actual stored type is `Awaited<T>`.
+* @returns A new uninitialized `OnceAsync`.
+* @example
+* ```ts
+* // Basic usage
+* const once = OnceAsync<string>();
+* await once.getOrInit(async () => 'hello');
+* console.log(once.get().unwrap()); // 'hello'
+* ```
+*
+* @example
+* ```ts
+* // Async lazy singleton pattern
+* const db = OnceAsync<Database>();
+*
+* async function getDb(): Promise<Database> {
+*     return await db.getOrInit(async () => {
+*         console.log('Connecting to database...');
+*         return await Database.connect(connectionString);
+*     });
+* }
+*
+* // Multiple calls - connection happens only once
+* const [db1, db2] = await Promise.all([getDb(), getDb()]);
+* console.log(db1 === db2); // true
+* ```
+*
+* @example
+* ```ts
+* // Fallible async initialization
+* const config = OnceAsync<Config>();
+*
+* async function loadConfig(): Promise<Result<Config, Error>> {
+*     return await config.getOrTryInit(async () => {
+*         try {
+*             const response = await fetch('/api/config');
+*             if (!response.ok) {
+*                 return Err(new Error(`HTTP ${response.status}`));
+*             }
+*             return Ok(await response.json());
+*         } catch (e) {
+*             return Err(e as Error);
+*         }
+*     });
+* }
+* ```
+*/
 function OnceAsync() {
-  let value;
-  let initialized = false;
-  let pendingPromise;
-  let resolvedPromise;
-  let resolvedResultPromise;
-  let waiters = [];
-  function setValue(val) {
-    value = val;
-    initialized = true;
-    for (const waiter of waiters) {
-      waiter(val);
-    }
-    waiters = [];
-  }
-  function getOrTryInit(fn) {
-    if (initialized) {
-      return resolvedResultPromise ??= Promise.resolve(Ok(value));
-    }
-    if (pendingPromise) {
-      return pendingPromise.then(
-        () => Ok(value),
-        // Previous initialization failed via Err result, let this call try again.
-        // Note: fn's sync errors won't throw here since we're inside a .then() callback,
-        // they will be caught and converted to rejected Promise by Promise.resolve(fn()).
-        () => getOrTryInit(fn)
-      );
-    }
-    const resultPromise = Promise.resolve(fn());
-    pendingPromise = resultPromise.then(
-      (result) => {
-        if (result.isOk()) {
-          const val = result.unwrap();
-          setValue(val);
-          return val;
-        }
-        throw result;
-      }
-    ).finally(() => {
-      pendingPromise = void 0;
-    });
-    return pendingPromise.then(
-      () => resultPromise,
-      () => resultPromise
-    );
-  }
-  return Object.freeze({
-    [Symbol.toStringTag]: "OnceAsync",
-    toString() {
-      return initialized ? `OnceAsync(${value})` : "OnceAsync(<uninitialized>)";
-    },
-    get() {
-      return initialized ? Some(value) : None;
-    },
-    set(newValue) {
-      if (initialized) {
-        return Err(newValue);
-      }
-      setValue(newValue);
-      return RESULT_VOID;
-    },
-    tryInsert(newValue) {
-      if (initialized) {
-        return Err([value, newValue]);
-      }
-      setValue(newValue);
-      return Ok(newValue);
-    },
-    // Use `Promise.resolve(fn())` instead of `async` to preserve sync error behavior:
-    // sync throws propagate directly, async errors become rejected Promises.
-    getOrInit(fn) {
-      if (initialized) {
-        return resolvedPromise ??= Promise.resolve(value);
-      }
-      if (pendingPromise) {
-        return pendingPromise;
-      }
-      pendingPromise = Promise.resolve(fn()).then(
-        (result) => {
-          setValue(result);
-          return result;
-        }
-      ).finally(() => {
-        pendingPromise = void 0;
-      });
-      return pendingPromise;
-    },
-    getOrTryInit,
-    take() {
-      if (!initialized) {
-        return None;
-      }
-      const taken = value;
-      value = void 0;
-      initialized = false;
-      resolvedPromise = void 0;
-      resolvedResultPromise = void 0;
-      return Some(taken);
-    },
-    isInitialized() {
-      return initialized;
-    },
-    wait() {
-      if (initialized) {
-        return resolvedPromise ??= Promise.resolve(value);
-      }
-      if (pendingPromise) {
-        return pendingPromise;
-      }
-      return new Promise((resolve) => {
-        waiters.push(resolve);
-      });
-    }
-  });
+	let value;
+	let initialized = false;
+	let pendingPromise;
+	let resolvedPromise;
+	let resolvedResultPromise;
+	let waiters = [];
+	/**
+	* Sets the value, marks as initialized, and notifies all waiters.
+	*/
+	function setValue(val) {
+		value = val;
+		initialized = true;
+		for (const waiter of waiters) waiter(val);
+		waiters = [];
+	}
+	function getOrTryInit(fn) {
+		if (initialized) return resolvedResultPromise ??= Promise.resolve(Ok(value));
+		if (pendingPromise) return pendingPromise.then(() => Ok(value), () => getOrTryInit(fn));
+		const resultPromise = Promise.resolve(fn());
+		pendingPromise = resultPromise.then((result) => {
+			if (result.isOk()) {
+				const val = result.unwrap();
+				setValue(val);
+				return val;
+			}
+			throw result;
+		}).finally(() => {
+			pendingPromise = void 0;
+		});
+		return pendingPromise.then(() => resultPromise, () => resultPromise);
+	}
+	return Object.freeze({
+		[Symbol.toStringTag]: "OnceAsync",
+		toString() {
+			return initialized ? `OnceAsync(${value})` : "OnceAsync(<uninitialized>)";
+		},
+		get() {
+			return initialized ? Some(value) : None;
+		},
+		set(newValue) {
+			if (initialized) return Err(newValue);
+			setValue(newValue);
+			return RESULT_VOID;
+		},
+		tryInsert(newValue) {
+			if (initialized) return Err([value, newValue]);
+			setValue(newValue);
+			return Ok(newValue);
+		},
+		getOrInit(fn) {
+			if (initialized) return resolvedPromise ??= Promise.resolve(value);
+			if (pendingPromise) return pendingPromise;
+			pendingPromise = Promise.resolve(fn()).then((result) => {
+				setValue(result);
+				return result;
+			}).finally(() => {
+				pendingPromise = void 0;
+			});
+			return pendingPromise;
+		},
+		getOrTryInit,
+		take() {
+			if (!initialized) return None;
+			const taken = value;
+			value = void 0;
+			initialized = false;
+			resolvedPromise = void 0;
+			resolvedResultPromise = void 0;
+			return Some(taken);
+		},
+		isInitialized() {
+			return initialized;
+		},
+		wait() {
+			if (initialized) return resolvedPromise ??= Promise.resolve(value);
+			if (pendingPromise) return pendingPromise;
+			return new Promise((resolve) => {
+				waiters.push(resolve);
+			});
+		}
+	});
 }
-
+//#endregion
+//#region src/std/sync/rwlock.ts
+/**
+* @module
+* Rust-inspired [RwLock](https://doc.rust-lang.org/std/sync/struct.RwLock.html) for async read-write locking.
+*
+* In JavaScript's single-threaded environment, `RwLock<T>` allows multiple
+* concurrent readers or a single exclusive writer. This is useful when
+* read operations are frequent and write operations are rare.
+*
+* **When to use RwLock vs Mutex:**
+* - Use `RwLock` when reads are frequent, writes are rare, and read operations
+*   contain `await` statements that could benefit from concurrent access.
+* - Use `Mutex` for simpler cases or when read/write frequency is balanced.
+*
+* **Important:** In JS, the benefit of RwLock is limited because:
+* - JS is single-threaded, so "parallel reads" don't truly execute simultaneously
+* - If read operations don't contain `await`, there's no opportunity for concurrency
+* - RwLock adds complexity over Mutex with marginal performance benefit
+*/
+/**
+* Creates a new `RwLock<T>` protecting the given value.
+*
+* @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
+* const counter = RwLock(0);
+*
+* // Read (multiple can proceed)
+* const value = await counter.withRead(v => v);
+*
+* // Write (exclusive)
+* await counter.withWrite(v => v + 1);
+* ```
+*
+* @example
+* ```ts
+* // Cache with read-heavy workload
+* const cache = RwLock(new Map<string, Data>());
+*
+* // Many concurrent reads
+* async function get(key: string): Promise<Data | undefined> {
+*     return cache.withRead(map => map.get(key));
+* }
+*
+* // Occasional writes
+* async function set(key: string, value: Data): Promise<void> {
+*     await cache.withWrite(map => { map.set(key, value); });
+* }
+* ```
+*
+* @example
+* ```ts
+* // Configuration that's read frequently, updated rarely
+* interface AppConfig {
+*     apiUrl: string;
+*     timeout: number;
+*     features: string[];
+* }
+*
+* const config = RwLock<AppConfig>({
+*     apiUrl: 'https://api.example.com',
+*     timeout: 5000,
+*     features: ['feature-a', 'feature-b'],
+* });
+*
+* // Read config (concurrent)
+* async function isFeatureEnabled(feature: string): Promise<boolean> {
+*     return config.withRead(cfg => cfg.features.includes(feature));
+* }
+*
+* // Update config (exclusive)
+* async function enableFeature(feature: string): Promise<void> {
+*     await config.withWrite(cfg => {
+*         if (!cfg.features.includes(feature)) {
+*             cfg.features.push(feature);
+*         }
+*     });
+* }
+* ```
+*/
 function RwLock(value) {
-  let currentValue = value;
-  let readers = 0;
-  let writer = false;
-  let pendingWriters = 0;
-  const readWaitQueue = [];
-  const writeWaitQueue = [];
-  function tryAcquireRead() {
-    if (!writer && pendingWriters === 0) {
-      readers++;
-      return true;
-    }
-    return false;
-  }
-  function tryAcquireWrite() {
-    if (readers === 0 && !writer) {
-      writer = true;
-      return true;
-    }
-    return false;
-  }
-  function releaseRead() {
-    readers--;
-    if (readers === 0 && writeWaitQueue.length > 0) {
-      const next = writeWaitQueue.shift();
-      writer = true;
-      pendingWriters--;
-      next();
-    }
-  }
-  function releaseWrite() {
-    writer = false;
-    if (writeWaitQueue.length > 0) {
-      const next = writeWaitQueue.shift();
-      writer = true;
-      pendingWriters--;
-      next();
-    } else {
-      while (readWaitQueue.length > 0) {
-        readers++;
-        const next = readWaitQueue.shift();
-        next();
-      }
-    }
-  }
-  function createReadGuard() {
-    let released = false;
-    return Object.freeze({
-      [Symbol.toStringTag]: "RwLockReadGuard",
-      toString() {
-        if (released) {
-          return "RwLockReadGuard(<released>)";
-        }
-        return `RwLockReadGuard(${currentValue})`;
-      },
-      get value() {
-        if (released) {
-          throw new Error("RwLockReadGuard has been released");
-        }
-        return currentValue;
-      },
-      unlock() {
-        if (released) {
-          return;
-        }
-        released = true;
-        releaseRead();
-      }
-    });
-  }
-  function createWriteGuard() {
-    let released = false;
-    return Object.freeze({
-      [Symbol.toStringTag]: "RwLockWriteGuard",
-      toString() {
-        if (released) {
-          return "RwLockWriteGuard(<released>)";
-        }
-        return `RwLockWriteGuard(${currentValue})`;
-      },
-      get value() {
-        if (released) {
-          throw new Error("RwLockWriteGuard has been released");
-        }
-        return currentValue;
-      },
-      set value(newValue) {
-        if (released) {
-          throw new Error("RwLockWriteGuard has been released");
-        }
-        currentValue = newValue;
-      },
-      unlock() {
-        if (released) {
-          return;
-        }
-        released = true;
-        releaseWrite();
-      }
-    });
-  }
-  function read() {
-    if (tryAcquireRead()) {
-      return Promise.resolve(createReadGuard());
-    }
-    return new Promise((resolve) => {
-      readWaitQueue.push(() => {
-        resolve(createReadGuard());
-      });
-    });
-  }
-  function write() {
-    if (tryAcquireWrite()) {
-      return Promise.resolve(createWriteGuard());
-    }
-    pendingWriters++;
-    return new Promise((resolve) => {
-      writeWaitQueue.push(() => {
-        resolve(createWriteGuard());
-      });
-    });
-  }
-  return Object.freeze({
-    [Symbol.toStringTag]: "RwLock",
-    toString() {
-      if (writer) {
-        return "RwLock(<write-locked>)";
-      }
-      if (readers > 0) {
-        return `RwLock(<read-locked:${readers}>)`;
-      }
-      return "RwLock(<unlocked>)";
-    },
-    async withRead(fn) {
-      const guard = await read();
-      try {
-        return await fn(guard.value);
-      } finally {
-        guard.unlock();
-      }
-    },
-    async withWrite(fn) {
-      const guard = await write();
-      try {
-        return await fn(guard.value);
-      } finally {
-        guard.unlock();
-      }
-    },
-    read,
-    write,
-    tryRead() {
-      if (tryAcquireRead()) {
-        return Some(createReadGuard());
-      }
-      return None;
-    },
-    tryWrite() {
-      if (tryAcquireWrite()) {
-        return Some(createWriteGuard());
-      }
-      return None;
-    },
-    readerCount() {
-      return readers;
-    },
-    isWriteLocked() {
-      return writer;
-    },
-    async get() {
-      const guard = await read();
-      try {
-        return guard.value;
-      } finally {
-        guard.unlock();
-      }
-    },
-    async set(value2) {
-      const guard = await write();
-      try {
-        guard.value = value2;
-      } finally {
-        guard.unlock();
-      }
-    },
-    async replace(value2) {
-      const guard = await write();
-      try {
-        const old = guard.value;
-        guard.value = value2;
-        return old;
-      } finally {
-        guard.unlock();
-      }
-    }
-  });
+	let currentValue = value;
+	let readers = 0;
+	let writer = false;
+	let pendingWriters = 0;
+	const readWaitQueue = [];
+	const writeWaitQueue = [];
+	function tryAcquireRead() {
+		if (!writer && pendingWriters === 0) {
+			readers++;
+			return true;
+		}
+		return false;
+	}
+	function tryAcquireWrite() {
+		if (readers === 0 && !writer) {
+			writer = true;
+			return true;
+		}
+		return false;
+	}
+	function releaseRead() {
+		readers--;
+		if (readers === 0 && writeWaitQueue.length > 0) {
+			const next = writeWaitQueue.shift();
+			writer = true;
+			pendingWriters--;
+			next();
+		}
+	}
+	function releaseWrite() {
+		writer = false;
+		if (writeWaitQueue.length > 0) {
+			const next = writeWaitQueue.shift();
+			writer = true;
+			pendingWriters--;
+			next();
+		} else while (readWaitQueue.length > 0) {
+			readers++;
+			readWaitQueue.shift()();
+		}
+	}
+	function createReadGuard() {
+		let released = false;
+		return Object.freeze({
+			[Symbol.toStringTag]: "RwLockReadGuard",
+			toString() {
+				if (released) return "RwLockReadGuard(<released>)";
+				return `RwLockReadGuard(${currentValue})`;
+			},
+			get value() {
+				if (released) throw new Error("RwLockReadGuard has been released");
+				return currentValue;
+			},
+			unlock() {
+				if (released) return;
+				released = true;
+				releaseRead();
+			}
+		});
+	}
+	function createWriteGuard() {
+		let released = false;
+		return Object.freeze({
+			[Symbol.toStringTag]: "RwLockWriteGuard",
+			toString() {
+				if (released) return "RwLockWriteGuard(<released>)";
+				return `RwLockWriteGuard(${currentValue})`;
+			},
+			get value() {
+				if (released) throw new Error("RwLockWriteGuard has been released");
+				return currentValue;
+			},
+			set value(newValue) {
+				if (released) throw new Error("RwLockWriteGuard has been released");
+				currentValue = newValue;
+			},
+			unlock() {
+				if (released) return;
+				released = true;
+				releaseWrite();
+			}
+		});
+	}
+	function read() {
+		if (tryAcquireRead()) return Promise.resolve(createReadGuard());
+		return new Promise((resolve) => {
+			readWaitQueue.push(() => {
+				resolve(createReadGuard());
+			});
+		});
+	}
+	function write() {
+		if (tryAcquireWrite()) return Promise.resolve(createWriteGuard());
+		pendingWriters++;
+		return new Promise((resolve) => {
+			writeWaitQueue.push(() => {
+				resolve(createWriteGuard());
+			});
+		});
+	}
+	return Object.freeze({
+		[Symbol.toStringTag]: "RwLock",
+		toString() {
+			if (writer) return "RwLock(<write-locked>)";
+			if (readers > 0) return `RwLock(<read-locked:${readers}>)`;
+			return "RwLock(<unlocked>)";
+		},
+		async withRead(fn) {
+			const guard = await read();
+			try {
+				return await fn(guard.value);
+			} finally {
+				guard.unlock();
+			}
+		},
+		async withWrite(fn) {
+			const guard = await write();
+			try {
+				return await fn(guard.value);
+			} finally {
+				guard.unlock();
+			}
+		},
+		read,
+		write,
+		tryRead() {
+			if (tryAcquireRead()) return Some(createReadGuard());
+			return None;
+		},
+		tryWrite() {
+			if (tryAcquireWrite()) return Some(createWriteGuard());
+			return None;
+		},
+		readerCount() {
+			return readers;
+		},
+		isWriteLocked() {
+			return writer;
+		},
+		async get() {
+			const guard = await read();
+			try {
+				return guard.value;
+			} finally {
+				guard.unlock();
+			}
+		},
+		async set(value) {
+			const guard = await write();
+			try {
+				guard.value = value;
+			} finally {
+				guard.unlock();
+			}
+		},
+		async replace(value) {
+			const guard = await write();
+			try {
+				const old = guard.value;
+				guard.value = value;
+				return old;
+			} finally {
+				guard.unlock();
+			}
+		}
+	});
 }
-
+//#endregion
 exports.ASYNC_NONE = ASYNC_NONE;
 exports.Break = Break;
 exports.Channel = Channel;
@@ -1529,4 +2330,5 @@ exports.tryAsyncOption = tryAsyncOption;
 exports.tryAsyncResult = tryAsyncResult;
 exports.tryOption = tryOption;
 exports.tryResult = tryResult;
-//# sourceMappingURL=main.cjs.map
+
+//# sourceMappingURL=main.cjs.map