clutchit 0.0.8 → 0.0.10

package/CHANGELOG.md

@@ -11,22 +11,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 #### `clutchit/unthrow`
 
-- `Result<T, E>` — synchronous typed error container with `Ok` and `Err` variants
-- `ResultAsync<T, E>` — async equivalent backed by `Promise<Result<T, E>>`, implements `PromiseLike`
-- `Result.Do` / `ResultAsync.Do` — generator-based Do notation for ergonomic sequential chaining
-- `Result.combine` / `ResultAsync.combine` — combine arrays of results, short-circuit on first error
-- `Result.combineWithAllErrors` / `ResultAsync.combineWithAllErrors` — collect all errors instead of stopping at first
-- `Result.fromThrowable` — wrap a throwing sync function into a `Result`
-- `ResultAsync.fromPromise` — lift a `Promise` into a `ResultAsync` with typed error mapping
+- `Try<T, E>` — synchronous typed error container with `Ok` and `Err` variants
+- `TryAsync<T, E>` — async equivalent backed by `Promise<Try<T, E>>`, implements `PromiseLike`
+- `ok()`, `err()`, `okAsync()`, `errAsync()` — standalone constructors
+- `Do` / `DoAsync` — generator-based Do notation with optional context parameter
+- Instance methods: `map`, `mapErr`, `andThen`, `orElse`, `tap`, `tapErr`, `andThrough`, `orThrough`, `catchFault`, `unwrapOr`, `match`
+- `fromPromise` — lift a `Promise` into a `TryAsync` with typed error mapping
+- `fromSafePromise` — lift a never-rejecting promise into `TryAsync<T, never>`
+- `fromThrowable` — wrap a throwing sync function into a `Try`
+- `fromAsyncThrowable` — wrap an async throwing function into a `TryAsync`
+- `combine` / `combineWithAllErrors` — combine arrays of `Try` or `TryAsync`
+- `unwrap` — assert a value is non-null/undefined, or return the fault
+- `flatten` — flatten nested `Try<Try<T, E2>, E1>` or `TryAsync<Try<T, E2>, E1>`
+- `race` — race multiple `TryAsync` values, like `Promise.race`
 - `Fault.Tagged` — factory for structured, tagged error classes with `code`, `_category`, and `_transient`
-- `Fault.isDomain` / `Fault.isInfrastructure` / `Fault.isTransient` — type guard helpers
+- `Fault.is` — duck-type guard for the `Fault` interface (accepts `unknown`)
+- `Fault.isDomain` / `Fault.isInfrastructure` / `Fault.isTransient` — type guard helpers (accept `unknown`)
 
 #### `clutchit/schedule`
 
 - `Schedule` — composable timing primitive with `.next(input, attempt)` and `.pipe(operator)` API
 - Factories: `spaced`, `exponential`, `linear`, `constant`, `fixed`, `windowed`, `fibonacci`, `cron`, `forever`, `once`
 - Operators: `recurs`, `cappedDelay`, `jittered`, `upTo`, `andThen`, `union`, `intersect`, `whileInput`, `whileOutput`, `map`
-- `Schedule.repeat` — run a `ResultAsync`-returning function repeatedly on a schedule with abort signal support
+- `Schedule.repeat` — run a `TryAsync`-returning function repeatedly on a schedule with abort signal support
 - `ScheduleInterruptedFault` — returned when `repeat` is cancelled via `AbortSignal`
 
 #### `clutchit/retry`
@@ -36,7 +43,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 #### `clutchit/timeout`
 
-- `withTimeout(fn, duration)` — wrap a `ResultAsync`-returning function with a deadline
+- `withTimeout(fn, duration)` — wrap a `TryAsync`-returning function with a deadline
 - `createTimeout(duration)` — create a reusable timeout wrapper
 - `TimeoutFault` — transient infrastructure fault emitted on deadline exceeded; aborts the underlying operation
 

package/README.md

@@ -1,11 +1,10 @@
 # clutchit
 
-Resilience primitives for TypeScript — typed errors, retry, timeout, circuit breaking, scheduling, concurrency, and queues.
+Resilience primitives for TypeScript.
 
 [![npm](https://img.shields.io/npm/v/clutchit)](https://www.npmjs.com/package/clutchit)
-[![license](https://img.shields.io/npm/l/clutchit)](../LICENSE)
+[![license](https://img.shields.io/npm/l/clutchit)](./LICENSE)
 [![docs](https://img.shields.io/badge/docs-clutchit.existin.space-blue)](https://clutchit.existin.space)
-[![bundle size](https://img.shields.io/bundlephobia/minzip/clutchit)](https://bundlephobia.com/package/clutchit)
 [![types](https://img.shields.io/npm/types/clutchit)](https://www.npmjs.com/package/clutchit)
 
 **[Documentation](https://clutchit.existin.space)** · [npm](https://www.npmjs.com/package/clutchit) · [Changelog](./CHANGELOG.md)
@@ -20,7 +19,7 @@ npm install clutchit
 
 | Import | Description |
 |---|---|
-| `clutchit/unthrow` | `Result<T,E>`, `ResultAsync<T,E>`, `Fault`, Do notation |
+| `clutchit/unthrow` | `Try<T,E>`, `TryAsync<T,E>`, `Fault`, Do notation |
 | `clutchit/schedule` | Composable timing schedules — exponential, linear, fibonacci, cron, … |
 | `clutchit/retry` | Retry policy with backoff schedules and abort signal support |
 | `clutchit/timeout` | Timeout wrapper with `AbortSignal` propagation |
@@ -33,10 +32,10 @@ npm install clutchit
 ## Quick start
 
 ```ts
-import { ResultAsync, Fault } from 'clutchit/unthrow';
-import { RetryPolicy }        from 'clutchit/retry';
-import { withTimeout }        from 'clutchit/timeout';
-import { Schedule }           from 'clutchit/schedule';
+import { ok, err, okAsync, errAsync, fromPromise, Fault } from 'clutchit/unthrow';
+import { RetryPolicy }  from 'clutchit/retry';
+import { withTimeout }  from 'clutchit/timeout';
+import { Schedule }     from 'clutchit/schedule';
 
 class ApiFault extends Fault.Tagged('API_ERROR', 'infrastructure', true)<{
   status: number;
@@ -44,8 +43,8 @@ class ApiFault extends Fault.Tagged('API_ERROR', 'infrastructure', true)<{
   readonly message = `API returned ${this.status}`;
 }
 
-function fetchUser(id: string, signal: AbortSignal): ResultAsync<User, ApiFault> {
-  return ResultAsync.fromPromise(
+function fetchUser(id: string, signal: AbortSignal): TryAsync<User, ApiFault> {
+  return fromPromise(
     fetch(`/api/users/${id}`, { signal }).then((r) => r.json()),
     () => new ApiFault({ status: 500 }),
   );
@@ -72,38 +71,38 @@ await result.match({
 
 Typed error handling without exceptions.
 
-### Result
+### Try
 
 ```ts
-import { Result } from 'clutchit/unthrow';
+import { ok, err } from 'clutchit/unthrow';
 
-const ok   = Result.ok(42);
-const fail = Result.err('oops');
+const success = ok(42);
+const failure = err('oops');
 
-ok.map((n) => n * 2);              // Ok(84)
-ok.andThen((n) => Result.ok(n));   // Ok(42)
-ok.unwrapOr(0);                    // 42
-fail.unwrapOr(0);                  // 0
+success.map((n) => n * 2);              // Ok(84)
+success.andThen((n) => ok(n));           // Ok(42)
+success.unwrapOr(0);                     // 42
+failure.unwrapOr(0);                     // 0
 
-ok.match({
+success.match({
   ok:  (value) => `got ${value}`,
   err: (error) => `failed: ${error}`,
 });
 
-if (ok.isOk())  ok.value;   // narrowed
-if (fail.isErr()) fail.error; // narrowed
+if (success.isOk())  success.value;   // narrowed
+if (failure.isErr()) failure.error;   // narrowed
 ```
 
-Methods: `isOk`, `isErr`, `map`, `mapErr`, `andThen`, `orElse`, `unwrapOr`, `match`
+Methods: `isOk`, `isErr`, `map`, `mapErr`, `andThen`, `orElse`, `tap`, `tapErr`, `andThrough`, `orThrough`, `catchFault`, `unwrapOr`, `match`
 
-### ResultAsync
+### TryAsync
 
-Wraps `Promise<Result<T, E>>`. Awaitable via `PromiseLike`, same chainable API as `Result`.
+Wraps `Promise<Try<T, E>>`. Awaitable via `PromiseLike`, same chainable API as `Try`.
 
 ```ts
-import { ResultAsync } from 'clutchit/unthrow';
+import { fromPromise } from 'clutchit/unthrow';
 
-const result = ResultAsync.fromPromise(
+const result = fromPromise(
   fetch('/api/data').then((r) => r.json()),
   (err) => new NetworkFault({ cause: String(err) }),
 );
@@ -113,26 +112,43 @@ const final = await result
   .andThen((items) => validate(items));
 ```
 
-Methods: `map`, `mapErr`, `andThen`, `orElse`, `unwrapOr`, `match` (all return `ResultAsync` or `Promise`)
+Methods: `map`, `mapErr`, `andThen`, `orElse`, `tap`, `tapErr`, `andThrough`, `orThrough`, `catchFault`, `unwrapOr`, `match` (all return `TryAsync` or `Promise`)
 
 ### Helpers
 
 ```ts
-import { Result, ResultAsync } from 'clutchit/unthrow';
+import { ok, err, okAsync, fromPromise, fromThrowable, fromSafePromise, fromAsyncThrowable, combine, combineWithAllErrors, unwrap, flatten, race } from 'clutchit/unthrow';
 
 // Wrap a throwable sync function
-Result.fromThrowable(
+fromThrowable(
   () => JSON.parse(raw),
   (err) => new ParseFault({ message: String(err) }),
 );
 
+// Wrap an async throwable function
+fromAsyncThrowable(
+  () => fetchData(),
+  (err) => new NetworkFault({ cause: String(err) }),
+);
+
+// Lift a safe (never-rejecting) promise
+fromSafePromise(Promise.resolve(42));
+
+// Assert non-null values
+unwrap(ok<string | null, E>(value), new NullFault());
+
+// Flatten nested results
+flatten(ok(ok(42)));  // Ok(42)
+
 // Combine — short-circuit on first error
-Result.combine([resultA, resultB]);           // Result<[A, B], E>
-ResultAsync.combine([asyncA, asyncB]);         // ResultAsync<[A, B], E>
+combine([ok(1), ok(2)]);              // Ok([1, 2])
+combine([okAsync(1), okAsync(2)]);    // TryAsync<[1, 2], E>
 
 // Combine — collect all errors
-Result.combineWithAllErrors([a, b, c]);        // Result<[A, B, C], E[]>
-ResultAsync.combineWithAllErrors([a, b, c]);   // ResultAsync<[A, B, C], E[]>
+combineWithAllErrors([ok(1), err('a'), err('b')]);  // Err(['a', 'b'])
+
+// Race — first to resolve wins
+race([okAsync(1), okAsync(2)]);
 ```
 
 ### Do notation
@@ -140,22 +156,28 @@ ResultAsync.combineWithAllErrors([a, b, c]);   // ResultAsync<[A, B, C], E[]>
 Generator-based sequential chaining. `yield*` unwraps `Ok`; any `Err` short-circuits the entire block.
 
 ```ts
-import { Result, ResultAsync } from 'clutchit/unthrow';
+import { Do, DoAsync } from 'clutchit/unthrow';
 
 // Sync
-const result = Result.Do(function* () {
-  const user  = yield* findUser(id);        // Result<User, NotFoundFault>
-  const perms = yield* getPermissions(user); // Result<Perms, PermFault>
+const result = Do(function* () {
+  const user  = yield* findUser(id);        // Try<User, NotFoundFault>
+  const perms = yield* getPermissions(user); // Try<Perms, PermFault>
   return { user, perms };
-  // Result<{ user, perms }, NotFoundFault | PermFault>
+  // Try<{ user, perms }, NotFoundFault | PermFault>
 });
 
 // Async
-const result = ResultAsync.Do(async function* () {
-  const user  = yield* fetchUser(id);         // ResultAsync<User, NetworkFault>
-  const order = yield* createOrder(user);     // ResultAsync<Order, OrderFault>
+const result = DoAsync(async function* () {
+  const user  = yield* fetchUser(id);         // TryAsync<User, NetworkFault>
+  const order = yield* createOrder(user);     // TryAsync<Order, OrderFault>
   return order;
-  // ResultAsync<Order, NetworkFault | OrderFault>
+  // TryAsync<Order, NetworkFault | OrderFault>
+});
+
+// With context
+const result = Do({ db }, function* (ctx) {
+  const user = yield* ctx.db.findUser(id);
+  return user;
 });
 ```
 
@@ -222,7 +244,7 @@ const result = Schedule.repeat(
     onExecution: (attempt, delay) => console.log(`#${attempt}, next in ${delay}ms`),
   },
 );
-// ResultAsync<number, SyncError | ScheduleInterruptedFault>
+// TryAsync<number, SyncError | ScheduleInterruptedFault>
 ```
 
 ---
@@ -241,7 +263,7 @@ const retry = new RetryPolicy({
 });
 
 const result = retry.execute((signal) => fetchData(signal));
-// ResultAsync<Data, FetchFault>
+// TryAsync<Data, FetchFault>
 ```
 
 Options can be set on the constructor (defaults for all calls) or overridden per `execute` call.
@@ -265,7 +287,7 @@ const result = withTimeout(
   (signal) => fetchData(signal),
   5_000,
 );
-// ResultAsync<Data, FetchFault | TimeoutFault>
+// TryAsync<Data, FetchFault | TimeoutFault>
 
 // Reusable wrapper
 const withFiveSeconds = createTimeout(5_000);
@@ -322,9 +344,9 @@ Atomic mutable reference with internal mutex:
 ```ts
 const counter = new Concurrency.Ref(0);
 
-await counter.update((n) => n + 1);       // ResultAsync<void, never>
-await counter.set(42);                    // ResultAsync<void, never>
-const next = await counter.modify(        // ResultAsync<number, never>
+await counter.update((n) => n + 1);       // TryAsync<void, never>
+await counter.set(42);                    // TryAsync<void, never>
+const next = await counter.modify(        // TryAsync<number, never>
   (n) => [n + 1, n + 1],
 );
 counter.get();                            // current value (sync)
@@ -347,7 +369,7 @@ const breaker = new Circuit.Breaker({
 });
 
 const result = breaker.protect(() => callService());
-// ResultAsync<T, ServiceFault | CircuitOpenFault>
+// TryAsync<T, ServiceFault | CircuitOpenFault>
 
 breaker.state;        // 'closed' | 'open' | 'half-open'
 breaker.failureCount; // consecutive failures
@@ -367,13 +389,13 @@ import { Queue, QueueFullFault, QueueEmptyFault } from 'clutchit/queue';
 
 const q = new Queue.Bounded<Job>({ capacity: 100 });
 
-q.offer(job);              // Result<void, QueueFullFault> — non-blocking
+q.offer(job);              // Try<void, QueueFullFault> — non-blocking
 await q.put(job);          // blocks until space is available
 await q.put(job, signal);  // cancellable
 
 const item  = await q.take();        // blocks until item available
 const batch = await q.takeBatch(10); // at least 1, up to 10
-const maybe = q.poll();              // Result<Job, QueueEmptyFault>
+const maybe = q.poll();              // Try<Job, QueueEmptyFault>
 ```
 
 ### DroppingQueue — drops newest when full
@@ -422,6 +444,7 @@ class UnauthorizedFault extends Fault.Tagged('UNAUTHORIZED', 'domain')() {
 ### Type guards
 
 ```ts
+Fault.is(value);                // duck-type check for Fault shape
 Fault.isDomain(fault);          // _category === 'domain'
 Fault.isInfrastructure(fault);  // _category === 'infrastructure'
 Fault.isTransient(fault);       // infrastructure + _transient

package/dist/circuit/circuit.breaker.d.ts

@@ -0,0 +1,51 @@
+import { type TryAsync } from '../unthrow/index.js';
+import { Schedule } from '../schedule/index.js';
+export type CircuitState = 'closed' | 'open' | 'half-open';
+declare const CircuitOpenFault_base: abstract new (fields: {
+    remainingTimeout: number;
+}) => Readonly<{
+    remainingTimeout: number;
+}> & {
+    readonly code: "CIRCUIT_OPEN";
+    readonly _category: "infrastructure";
+    readonly _transient: false;
+    readonly message: string;
+};
+export declare class CircuitOpenFault extends CircuitOpenFault_base {
+    readonly message: string;
+}
+export interface CircuitBreakerOptions {
+    /** Number of consecutive failures before opening. Default: 5 */
+    failureThreshold?: number;
+    /** Schedule for reset timing. Default: Schedule.constant(30_000) */
+    resetSchedule?: Schedule;
+    /** Number of trial requests allowed in half-open state. Default: 1 */
+    halfOpenAttempts?: number;
+    /** Predicate to determine if an error should count as a failure. Default: all errors count. */
+    isFailure?: (error: unknown) => boolean;
+    /** Called when circuit state changes (for logging/monitoring). */
+    onStateChange?: (from: CircuitState, to: CircuitState) => void;
+}
+export declare class CircuitBreaker {
+    private _state;
+    private _failureCount;
+    private _resetAttempt;
+    private _halfOpenTrials;
+    private _nextResetTime;
+    private readonly _failureThreshold;
+    private readonly _resetSchedule;
+    private readonly _maxHalfOpenAttempts;
+    private readonly _isFailure;
+    private readonly _onStateChange?;
+    constructor(options?: CircuitBreakerOptions);
+    protect<T, E>(fn: () => TryAsync<T, E>): TryAsync<T, E | CircuitOpenFault>;
+    get state(): CircuitState;
+    get failureCount(): number;
+    reset(): void;
+    private onSuccess;
+    private onFailure;
+    private scheduleReset;
+    private transition;
+}
+export {};
+//# sourceMappingURL=circuit.breaker.d.ts.map

package/dist/circuit/circuit.breaker.js

@@ -1,4 +1,4 @@
-import { Fault, ResultAsync } from '../unthrow/index.js';
+import { Fault, errAsync, fromPromise, } from '../unthrow/index.js';
 import { Schedule } from '../schedule/index.js';
 export class CircuitOpenFault extends Fault.Tagged('CIRCUIT_OPEN', 'infrastructure')() {
     message = `Circuit breaker is open. Retry after ${this.remainingTimeout}ms`;
@@ -31,16 +31,16 @@ export class CircuitBreaker {
                 const remainingTimeout = this._nextResetTime
                     ? Math.max(0, this._nextResetTime - Date.now())
                     : 0;
-                return ResultAsync.err(new CircuitOpenFault({ remainingTimeout }));
+                return errAsync(new CircuitOpenFault({ remainingTimeout }));
             }
         }
         if (this._state === 'half-open') {
             if (this._halfOpenTrials >= this._maxHalfOpenAttempts) {
-                return ResultAsync.err(new CircuitOpenFault({ remainingTimeout: 0 }));
+                return errAsync(new CircuitOpenFault({ remainingTimeout: 0 }));
             }
             this._halfOpenTrials++;
         }
-        return ResultAsync.fromPromise((async () => {
+        return fromPromise((async () => {
             const result = await fn();
             if (result.isOk()) {
                 this.onSuccess();

package/dist/circuit/index.d.ts

@@ -0,0 +1,10 @@
+import { CircuitBreaker } from './circuit.breaker.js';
+import type { CircuitState, CircuitBreakerOptions } from './circuit.breaker.js';
+export { CircuitOpenFault } from './circuit.breaker.js';
+export declare namespace Circuit {
+    const Breaker: typeof CircuitBreaker;
+    type Breaker = CircuitBreaker;
+    type BreakerOptions = CircuitBreakerOptions;
+    type State = CircuitState;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/concurrency/bulkhead.d.ts

@@ -0,0 +1,28 @@
+import { type TryAsync } from '../unthrow/index.js';
+declare const BulkheadRejectedFault_base: abstract new () => Readonly<Record<string, unknown>> & {
+    readonly code: "BULKHEAD_REJECTED";
+    readonly _category: "infrastructure";
+    readonly _transient: false;
+    readonly message: string;
+};
+export declare class BulkheadRejectedFault extends BulkheadRejectedFault_base {
+    readonly message = "Bulkhead capacity exceeded";
+}
+export interface BulkheadOptions {
+    concurrency: number;
+    queue?: number;
+}
+export declare class Bulkhead {
+    private _active;
+    private readonly _maxConcurrency;
+    private readonly _maxQueue;
+    private readonly _queue;
+    constructor(options: BulkheadOptions);
+    execute<T, E>(fn: () => TryAsync<T, E>): TryAsync<T, E | BulkheadRejectedFault>;
+    get activeCount(): number;
+    get queueSize(): number;
+    private acquire;
+    private release;
+}
+export {};
+//# sourceMappingURL=bulkhead.d.ts.map

package/dist/concurrency/bulkhead.js

@@ -1,4 +1,4 @@
-import { Fault, ResultAsync } from '../unthrow/index.js';
+import { Fault, errAsync, fromPromise, } from '../unthrow/index.js';
 export class BulkheadRejectedFault extends Fault.Tagged('BULKHEAD_REJECTED', 'infrastructure')() {
     message = 'Bulkhead capacity exceeded';
 }
@@ -14,9 +14,9 @@ export class Bulkhead {
     execute(fn) {
         if (this._active >= this._maxConcurrency &&
             this._queue.length >= this._maxQueue) {
-            return ResultAsync.err(new BulkheadRejectedFault());
+            return errAsync(new BulkheadRejectedFault());
         }
-        return ResultAsync.fromPromise((async () => {
+        return fromPromise((async () => {
             await this.acquire();
             try {
                 const result = await fn();

package/dist/concurrency/index.d.ts

@@ -0,0 +1,23 @@
+import { Semaphore as _Semaphore } from './semaphore.js';
+import type { SemaphoreOptions as _SemaphoreOptions } from './semaphore.js';
+import { RateLimiter as _RateLimiter } from './rate-limiter.js';
+import type { RateLimiterOptions as _RateLimiterOptions } from './rate-limiter.js';
+import { Bulkhead as _Bulkhead } from './bulkhead.js';
+import type { BulkheadOptions as _BulkheadOptions } from './bulkhead.js';
+import { Ref as _Ref } from './ref.js';
+export { RateLimitFault } from './rate-limiter.js';
+export { BulkheadRejectedFault } from './bulkhead.js';
+export declare namespace Concurrency {
+    const Semaphore: typeof _Semaphore;
+    type Semaphore = _Semaphore;
+    type SemaphoreOptions = _SemaphoreOptions;
+    const RateLimiter: typeof _RateLimiter;
+    type RateLimiter = _RateLimiter;
+    type RateLimiterOptions = _RateLimiterOptions;
+    const Bulkhead: typeof _Bulkhead;
+    type Bulkhead = _Bulkhead;
+    type BulkheadOptions = _BulkheadOptions;
+    const Ref: typeof _Ref;
+    type Ref<T> = _Ref<T>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/concurrency/rate-limiter.d.ts

@@ -0,0 +1,29 @@
+import { type TryAsync } from '../unthrow/index.js';
+declare const RateLimitFault_base: abstract new (fields: {
+    retryAfter: number;
+}) => Readonly<{
+    retryAfter: number;
+}> & {
+    readonly code: "RATE_LIMITED";
+    readonly _category: "infrastructure";
+    readonly _transient: true;
+    readonly message: string;
+};
+export declare class RateLimitFault extends RateLimitFault_base {
+    readonly message: string;
+}
+export interface RateLimiterOptions {
+    limit: number;
+    window: number;
+}
+export declare class RateLimiter {
+    private readonly _limit;
+    private readonly _window;
+    private readonly _timestamps;
+    constructor(options: RateLimiterOptions);
+    execute<T, E>(fn: () => TryAsync<T, E>): TryAsync<T, E | RateLimitFault>;
+    get remaining(): number;
+    private cleanup;
+}
+export {};
+//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/concurrency/rate-limiter.js

@@ -1,4 +1,4 @@
-import { Fault, ResultAsync } from '../unthrow/index.js';
+import { Fault, errAsync } from '../unthrow/index.js';
 export class RateLimitFault extends Fault.Tagged('RATE_LIMITED', 'infrastructure', true)() {
     message = `Rate limit exceeded. Retry after ${this.retryAfter}ms`;
 }
@@ -15,7 +15,7 @@ export class RateLimiter {
         if (this._timestamps.length >= this._limit) {
             const oldest = this._timestamps[0];
             const retryAfter = Math.max(0, oldest + this._window - Date.now());
-            return ResultAsync.err(new RateLimitFault({ retryAfter }));
+            return errAsync(new RateLimitFault({ retryAfter }));
         }
         this._timestamps.push(Date.now());
         return fn();

package/dist/concurrency/ref.d.ts

@@ -0,0 +1,11 @@
+import { type TryAsync } from '../unthrow/index.js';
+export declare class Ref<T> {
+    private _value;
+    private readonly _mutex;
+    constructor(initial: T);
+    get(): T;
+    modify<R>(fn: (current: T) => [next: T, result: R]): TryAsync<R, never>;
+    update(fn: (current: T) => T): TryAsync<void, never>;
+    set(value: T): TryAsync<void, never>;
+}
+//# sourceMappingURL=ref.d.ts.map

package/dist/concurrency/ref.js

@@ -1,4 +1,4 @@
-import { ResultAsync } from '../unthrow/index.js';
+import { okAsync } from '../unthrow/index.js';
 import { Semaphore } from './semaphore.js';
 export class Ref {
     _value;
@@ -13,7 +13,7 @@ export class Ref {
         return this._mutex.execute(() => {
             const [next, result] = fn(this._value);
             this._value = next;
-            return ResultAsync.ok(result);
+            return okAsync(result);
         });
     }
     update(fn) {

package/dist/concurrency/semaphore.d.ts

@@ -0,0 +1,15 @@
+import { type TryAsync } from '../unthrow/index.js';
+export interface SemaphoreOptions {
+    permits: number;
+}
+export declare class Semaphore {
+    private _available;
+    private readonly _queue;
+    constructor(options: SemaphoreOptions);
+    execute<T, E>(fn: () => TryAsync<T, E>): TryAsync<T, E>;
+    get available(): number;
+    get waiting(): number;
+    private acquire;
+    private release;
+}
+//# sourceMappingURL=semaphore.d.ts.map

package/dist/concurrency/semaphore.js

@@ -1,4 +1,4 @@
-import { ResultAsync } from '../unthrow/index.js';
+import { fromPromise } from '../unthrow/index.js';
 export class Semaphore {
     _available;
     _queue = [];
@@ -6,7 +6,7 @@ export class Semaphore {
         this._available = options.permits;
     }
     execute(fn) {
-        return ResultAsync.fromPromise((async () => {
+        return fromPromise((async () => {
             await this.acquire();
             try {
                 const result = await fn();

package/dist/queue/base.queue.d.ts

@@ -0,0 +1,18 @@
+import { type Try, type TryAsync } from '../unthrow/index.js';
+import { QueueEmptyFault } from './faults.js';
+export interface QueueOptions {
+    capacity: number;
+}
+export declare class BaseQueue<T> {
+    protected readonly _buffer: T[];
+    protected readonly _capacity: number;
+    protected readonly _takeWaiters: Array<(item: T) => void>;
+    constructor(options: QueueOptions);
+    protected _tryTake(): Try<T, QueueEmptyFault>;
+    take(signal?: AbortSignal): TryAsync<T, never>;
+    takeBatch(n: number, signal?: AbortSignal): TryAsync<T[], never>;
+    poll(): Try<T, QueueEmptyFault>;
+    get size(): number;
+    get capacity(): number;
+}
+//# sourceMappingURL=base.queue.d.ts.map

package/dist/queue/base.queue.js

@@ -1,4 +1,4 @@
-import { Result, ResultAsync } from '../unthrow/index.js';
+import { ok, err, okAsync, fromPromise, } from '../unthrow/index.js';
 import { QueueEmptyFault } from './faults.js';
 export class BaseQueue {
     _buffer = [];
@@ -9,15 +9,15 @@ export class BaseQueue {
     }
     _tryTake() {
         if (this._buffer.length > 0) {
-            return Result.ok(this._buffer.shift());
+            return ok(this._buffer.shift());
         }
-        return Result.err(new QueueEmptyFault());
+        return err(new QueueEmptyFault());
     }
     take(signal) {
         const taken = this._tryTake();
         if (taken.isOk())
-            return ResultAsync.ok(taken.value);
-        return ResultAsync.fromPromise(new Promise((resolve) => {
+            return okAsync(taken.value);
+        return fromPromise(new Promise((resolve) => {
             this._takeWaiters.push(resolve);
             signal?.addEventListener('abort', () => {
                 const idx = this._takeWaiters.indexOf(resolve);
@@ -27,7 +27,7 @@ export class BaseQueue {
         }), () => undefined);
     }
     takeBatch(n, signal) {
-        return ResultAsync.fromPromise((async () => {
+        return fromPromise((async () => {
             const taken = this._tryTake();
             let first;
             if (taken.isOk()) {

package/dist/queue/bounded.queue.d.ts

@@ -0,0 +1,11 @@
+import { type Try, type TryAsync } from '../unthrow/index.js';
+import { QueueEmptyFault, QueueFullFault } from './faults.js';
+import { BaseQueue, type QueueOptions } from './base.queue.js';
+export declare class BoundedQueue<T> extends BaseQueue<T> {
+    private readonly _putWaiters;
+    constructor(options: QueueOptions);
+    protected _tryTake(): Try<T, QueueEmptyFault>;
+    offer(item: T): Try<void, QueueFullFault>;
+    put(item: T, signal?: AbortSignal): TryAsync<void, never>;
+}
+//# sourceMappingURL=bounded.queue.d.ts.map