clutchit 0.0.9 → 0.0.11

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/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/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/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/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/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/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

package/dist/queue/dropping.queue.d.ts

@@ -0,0 +1,7 @@
+import { BaseQueue, type QueueOptions } from './base.queue.js';
+export declare class DroppingQueue<T> extends BaseQueue<T> {
+    constructor(options: QueueOptions);
+    /** Always succeeds. Drops the item if full. Returns whether item was accepted. */
+    offer(item: T): boolean;
+}
+//# sourceMappingURL=dropping.queue.d.ts.map

package/dist/queue/faults.d.ts

@@ -0,0 +1,24 @@
+declare const QueueFullFault_base: abstract new (fields: {
+    capacity: number;
+}) => Readonly<{
+    capacity: number;
+}> & {
+    readonly code: "QUEUE_FULL";
+    readonly _category: "infrastructure";
+    readonly _transient: false;
+    readonly message: string;
+};
+export declare class QueueFullFault extends QueueFullFault_base {
+    readonly message: string;
+}
+declare const QueueEmptyFault_base: abstract new () => Readonly<Record<string, unknown>> & {
+    readonly code: "QUEUE_EMPTY";
+    readonly _category: "infrastructure";
+    readonly _transient: false;
+    readonly message: string;
+};
+export declare class QueueEmptyFault extends QueueEmptyFault_base {
+    readonly message = "Queue is empty";
+}
+export {};
+//# sourceMappingURL=faults.d.ts.map

package/dist/queue/index.d.ts

@@ -0,0 +1,15 @@
+import type { QueueOptions } from './base.queue.js';
+import { BoundedQueue } from './bounded.queue.js';
+import { DroppingQueue } from './dropping.queue.js';
+import { SlidingQueue } from './sliding.queue.js';
+export { QueueFullFault, QueueEmptyFault } from './faults.js';
+export declare namespace Queue {
+    type Options = QueueOptions;
+    const Bounded: typeof BoundedQueue;
+    type Bounded<T> = BoundedQueue<T>;
+    const Dropping: typeof DroppingQueue;
+    type Dropping<T> = DroppingQueue<T>;
+    const Sliding: typeof SlidingQueue;
+    type Sliding<T> = SlidingQueue<T>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/queue/sliding.queue.d.ts

@@ -0,0 +1,7 @@
+import { BaseQueue, type QueueOptions } from './base.queue.js';
+export declare class SlidingQueue<T> extends BaseQueue<T> {
+    constructor(options: QueueOptions);
+    /** Always succeeds. Drops oldest if full. */
+    offer(item: T): void;
+}
+//# sourceMappingURL=sliding.queue.d.ts.map

package/dist/retry/index.d.ts

@@ -0,0 +1,8 @@
+import { RetryPolicy } from './retry.js';
+import type { RetryOptions } from './retry.js';
+export declare namespace Retry {
+    type Options = RetryOptions;
+    const Policy: typeof RetryPolicy;
+    type Policy = RetryPolicy;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/retry/retry.d.ts

@@ -0,0 +1,21 @@
+import { type TryAsync } from '../unthrow/index.js';
+import { Schedule } from '../schedule/index.js';
+export interface RetryOptions<E = unknown> {
+    /** Schedule for backoff timing. Default: exponential(200) | recurs(3) */
+    schedule?: Schedule;
+    /**
+     * Predicate to decide if an error should be retried.
+     * Default: retries transient errors (error._transient === true).
+     */
+    retryOn?: (error: E) => boolean;
+    /** Called on each retry attempt (for logging/observability). */
+    onRetry?: (error: E, attempt: number, delay: number) => void;
+    /** External cancellation signal. Aborts retrying when signalled. */
+    signal?: AbortSignal;
+}
+export declare class RetryPolicy {
+    private readonly defaults?;
+    constructor(defaults?: RetryOptions | undefined);
+    execute<T, E>(fn: (signal: AbortSignal) => TryAsync<T, E>, options?: RetryOptions<E>): TryAsync<T, E>;
+}
+//# sourceMappingURL=retry.d.ts.map

package/dist/schedule/index.d.ts

@@ -0,0 +1,36 @@
+import { Schedule as _Schedule } from './schedule.js';
+import type { ScheduleStep, ScheduleOperator } from './schedule.js';
+import { recurs as _recurs, cappedDelay as _cappedDelay, jittered as _jittered, upTo as _upTo, andThen as _andThen, union as _union, intersect as _intersect, whileInput as _whileInput, whileOutput as _whileOutput, map as _map } from './operators.js';
+import { repeat as _repeat } from './runner.js';
+import type { RepeatOptions as _RepeatOptions } from './runner.js';
+export { ScheduleInterruptedFault } from './runner.js';
+export type Schedule<In = unknown, Out = number> = _Schedule<In, Out>;
+export declare namespace Schedule {
+    type Step = ScheduleStep;
+    type Operator = ScheduleOperator;
+    const spaced: (ms: number) => _Schedule;
+    const exponential: (initialDelay: number, multiplier?: number) => _Schedule;
+    const linear: (initialDelay: number) => _Schedule;
+    const constant: (delay: number) => _Schedule;
+    const fixed: (interval: number) => _Schedule;
+    const windowed: (interval: number) => _Schedule;
+    const forever: _Schedule<unknown, number>;
+    const once: _Schedule<unknown, number>;
+    const fibonacci: (one: number) => _Schedule;
+    const cron: (expression: string, options?: {
+        timezone?: string;
+    }) => _Schedule;
+    const recurs: typeof _recurs;
+    const cappedDelay: typeof _cappedDelay;
+    const jittered: typeof _jittered;
+    const upTo: typeof _upTo;
+    const andThen: typeof _andThen;
+    const union: typeof _union;
+    const intersect: typeof _intersect;
+    const whileInput: typeof _whileInput;
+    const whileOutput: typeof _whileOutput;
+    const map: typeof _map;
+    const repeat: typeof _repeat;
+    type RepeatOptions = _RepeatOptions;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/schedule/operators.d.ts

@@ -0,0 +1,22 @@
+import { Schedule, type ScheduleOperator } from './schedule.js';
+/** Limit total repetitions to n */
+export declare function recurs(n: number): ScheduleOperator;
+/** Cap individual delay to maxDelay ms */
+export declare function cappedDelay(maxDelay: number): ScheduleOperator;
+/** Add random jitter (±factor, default ±0.25) */
+export declare function jittered(factor?: number): ScheduleOperator;
+/** Stop after total elapsed time exceeds duration ms */
+export declare function upTo(duration: number): ScheduleOperator;
+/** Sequential composition: run base until it stops, then switch to next */
+export declare function andThen(next: Schedule): ScheduleOperator;
+/** Continue while either wants to; use shorter delay */
+export declare function union(other: Schedule): ScheduleOperator;
+/** Continue while both want to; use longer delay */
+export declare function intersect(other: Schedule): ScheduleOperator;
+/** Continue while the input satisfies the predicate */
+export declare function whileInput<In>(predicate: (input: In) => boolean): <Out>(schedule: Schedule<In, Out>) => Schedule<In, Out>;
+/** Continue while the output satisfies the predicate */
+export declare function whileOutput<Out>(predicate: (output: Out) => boolean): <In>(schedule: Schedule<In, Out>) => Schedule<In, Out>;
+/** Transform the output value */
+export declare function map<Out, Out2>(f: (output: Out) => Out2): <In>(schedule: Schedule<In, Out>) => Schedule<In, Out2>;
+//# sourceMappingURL=operators.d.ts.map

package/dist/schedule/runner.d.ts

@@ -0,0 +1,31 @@
+import { type TryAsync } from '../unthrow/index.js';
+import type { Schedule } from './schedule.js';
+declare const ScheduleInterruptedFault_base: abstract new () => Readonly<Record<string, unknown>> & {
+    readonly code: "SCHEDULE_INTERRUPTED";
+    readonly _category: "infrastructure";
+    readonly _transient: false;
+    readonly message: string;
+};
+export declare class ScheduleInterruptedFault extends ScheduleInterruptedFault_base {
+    readonly message = "Scheduled execution was interrupted";
+}
+export interface RepeatOptions {
+    /** External cancellation signal. Aborts the loop when signalled. */
+    signal?: AbortSignal;
+    /** Called after each execution (for logging/observability). */
+    onExecution?: (attempt: number, delay: number) => void;
+}
+/**
+ * Execute `fn` repeatedly according to the given schedule's timing.
+ *
+ * - Executes `fn` immediately (no initial delay).
+ * - After each successful execution, consults schedule.next() for the delay and continuation.
+ * - If the schedule returns `continue: false`, resolves with Ok(output).
+ * - If `fn` returns an Err, stops immediately and surfaces the error.
+ * - If the signal is aborted, stops and returns Err(ScheduleInterruptedFault).
+ *
+ * Returns the last schedule output on completion.
+ */
+export declare function repeat<Out, E>(schedule: Schedule<unknown, Out>, fn: (signal: AbortSignal) => TryAsync<void, E>, options?: RepeatOptions): TryAsync<Out, E | ScheduleInterruptedFault>;
+export {};
+//# sourceMappingURL=runner.d.ts.map

package/dist/schedule/schedule.d.ts

@@ -0,0 +1,35 @@
+export interface ScheduleStep<Out = number> {
+    readonly delay: number;
+    readonly continue: boolean;
+    readonly output: Out;
+}
+export type ScheduleOperator = <In, Out>(schedule: Schedule<In, Out>) => Schedule<In, Out>;
+export declare class Schedule<In = unknown, Out = number> {
+    private readonly _next;
+    constructor(_next: (input: In, attempt: number) => ScheduleStep<Out>);
+    next(input: In, attempt: number): ScheduleStep<Out>;
+    pipe<Out2 = Out>(operator: (schedule: Schedule<In, Out>) => Schedule<In, Out2>): Schedule<In, Out2>;
+    /** Fixed delay between executions (from completion to next start) */
+    static spaced: (ms: number) => Schedule;
+    /** Exponential backoff: initialDelay * multiplier^attempt */
+    static exponential: (initialDelay: number, multiplier?: number) => Schedule;
+    /** Linear backoff: initialDelay * (attempt + 1) */
+    static linear: (initialDelay: number) => Schedule;
+    /** Constant delay (alias for spaced) */
+    static constant: (delay: number) => Schedule;
+    /** Fixed interval from start to start (compensates for execution time) */
+    static fixed: (interval: number) => Schedule;
+    /** Aligned to wall-clock time windows */
+    static windowed: (interval: number) => Schedule;
+    /** Zero-delay infinite schedule */
+    static forever: Schedule;
+    /** Continue once then stop. With repeat: initial + 1 repetition = 2 total executions */
+    static once: Schedule;
+    /** Fibonacci delay sequence: one, one, 2*one, 3*one, 5*one, 8*one, ... */
+    static fibonacci: (one: number) => Schedule;
+    /** Cron expression schedule (aligned to cron windows) */
+    static cron: (expression: string, options?: {
+        timezone?: string;
+    }) => Schedule;
+}
+//# sourceMappingURL=schedule.d.ts.map

package/dist/timeout/index.d.ts

@@ -0,0 +1,7 @@
+import { withTimeout as _withTimeout, createTimeout as _createTimeout } from './timeout.js';
+export { TimeoutFault } from './timeout.js';
+export declare namespace Timeout {
+    const wrap: typeof _withTimeout;
+    const create: typeof _createTimeout;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/timeout/timeout.d.ts

@@ -0,0 +1,18 @@
+import { type TryAsync } from '../unthrow/index.js';
+declare const TimeoutFault_base: abstract new (fields: {
+    duration: number;
+}) => Readonly<{
+    duration: number;
+}> & {
+    readonly code: "TIMEOUT";
+    readonly _category: "infrastructure";
+    readonly _transient: true;
+    readonly message: string;
+};
+export declare class TimeoutFault extends TimeoutFault_base {
+    readonly message: string;
+}
+export declare function withTimeout<T, E>(fn: (signal: AbortSignal) => TryAsync<T, E>, duration: number): TryAsync<T, E | TimeoutFault>;
+export declare function createTimeout(duration: number): <T, E>(fn: (signal: AbortSignal) => TryAsync<T, E>) => TryAsync<T, E | TimeoutFault>;
+export {};
+//# sourceMappingURL=timeout.d.ts.map

package/dist/unthrow/do.d.ts

@@ -0,0 +1,7 @@
+import { type Try, Err } from './try.js';
+import { TryAsync } from './try.async.js';
+export declare function Do<T, E>(generator: () => Generator<Err<never, E>, T>): Try<T, NoInfer<E>>;
+export declare function Do<C, T, E>(ctx: C, generator: (ctx: C) => Generator<Err<never, E>, T>): Try<T, NoInfer<E>>;
+export declare function DoAsync<T, E>(generator: () => AsyncGenerator<Err<never, E>, T>): TryAsync<T, NoInfer<E>>;
+export declare function DoAsync<C, T, E>(ctx: C, generator: (ctx: C) => AsyncGenerator<Err<never, E>, T>): TryAsync<T, NoInfer<E>>;
+//# sourceMappingURL=do.d.ts.map

package/dist/unthrow/fault.d.ts

@@ -0,0 +1,23 @@
+export interface Fault {
+    readonly code: string;
+    readonly message: string;
+    readonly _category: 'domain' | 'infrastructure';
+    readonly _transient: boolean;
+}
+export declare function isFault(value: unknown): value is Fault;
+export declare function isDomainFault(value: unknown): value is Fault & {
+    readonly _category: 'domain';
+};
+export declare function isInfrastructureFault(value: unknown): value is Fault & {
+    readonly _category: 'infrastructure';
+};
+export declare function isTransientFault(value: unknown): value is Fault & {
+    readonly _transient: true;
+};
+export declare function Fault<const Code extends string, const Category extends 'domain' | 'infrastructure', const Transient extends boolean = false>(code: Code, category: Category, transient?: Transient): <A extends Record<string, unknown> = Record<string, unknown>>() => abstract new (...args: Record<string, unknown> extends A ? [] : [fields: A]) => Readonly<A> & {
+    readonly code: Code;
+    readonly _category: Category;
+    readonly _transient: Transient;
+    readonly message: string;
+};
+//# sourceMappingURL=fault.d.ts.map

package/dist/unthrow/helpers.d.ts

@@ -0,0 +1,16 @@
+import { type Try } from './try.js';
+import { TryAsync } from './try.async.js';
+export declare function combine<T, E>(results: Try<T, E>[]): Try<T[], E>;
+export declare function combine<T, E>(results: TryAsync<T, E>[]): TryAsync<T[], E>;
+export declare function combineWithAllErrors<T, E>(results: Try<T, E>[]): Try<T[], E[]>;
+export declare function combineWithAllErrors<T, E>(results: TryAsync<T, E>[]): TryAsync<T[], E[]>;
+export declare function fromPromise<T, E>(promise: Promise<T>, errorMapper: (error: unknown) => E): TryAsync<T, E>;
+export declare function fromSafePromise<T>(promise: Promise<T>): TryAsync<T, never>;
+export declare function fromThrowable<T, E>(fn: () => T, errorMapper: (error: unknown) => E): Try<T, E>;
+export declare function fromAsyncThrowable<T, E>(fn: () => Promise<T>, errorMapper: (error: unknown) => E): TryAsync<T, E>;
+export declare function unwrap<T, E, F>(result: Try<T | null | undefined, E>, fault: F): Try<NonNullable<T>, E | F>;
+export declare function unwrap<T, E, F>(result: TryAsync<T | null | undefined, E>, fault: F): TryAsync<NonNullable<T>, E | F>;
+export declare function flatten<T, E1, E2>(result: Try<Try<T, E2>, E1>): Try<T, E1 | E2>;
+export declare function flatten<T, E1, E2>(result: TryAsync<Try<T, E2>, E1>): TryAsync<T, E1 | E2>;
+export declare function race<T, E>(results: TryAsync<T, E>[]): TryAsync<T, E>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/unthrow/index.d.ts

@@ -0,0 +1,14 @@
+import { Fault as _Fault, isFault as _isFault, isDomainFault as _isDomainFault, isInfrastructureFault as _isInfrastructureFault, isTransientFault as _isTransientFault } from './fault.js';
+export type Fault = _Fault;
+export declare namespace Fault {
+    const Tagged: typeof _Fault;
+    const is: typeof _isFault;
+    const isDomain: typeof _isDomainFault;
+    const isInfrastructure: typeof _isInfrastructureFault;
+    const isTransient: typeof _isTransientFault;
+}
+export { type Try, Ok, Err, ok, err } from './try.js';
+export { TryAsync, okAsync, errAsync } from './try.async.js';
+export { fromPromise, fromSafePromise, fromThrowable, fromAsyncThrowable, combine, combineWithAllErrors, unwrap, flatten, race, } from './helpers.js';
+export { Do, DoAsync } from './do.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/unthrow/try.async.d.ts

@@ -0,0 +1,29 @@
+import { type Try, Err } from './try.js';
+export declare class TryAsync<T, E> implements PromiseLike<Try<T, E>> {
+    private readonly _promise;
+    readonly then: PromiseLike<Try<T, E>>['then'];
+    constructor(promise: Promise<Try<T, E>>);
+    map<U>(fn: (value: T) => U | Promise<U>): TryAsync<U, E>;
+    mapErr<F>(fn: (error: E) => F | Promise<F>): TryAsync<T, F>;
+    andThen<U, F>(fn: (value: T) => Try<U, F> | TryAsync<U, F>): TryAsync<U, E | F>;
+    orElse<F>(fn: (error: E) => Try<T, F> | TryAsync<T, F>): TryAsync<T, F>;
+    tap(fn: (value: T) => void | Promise<void>): TryAsync<T, E>;
+    tapErr(fn: (error: E) => void | Promise<void>): TryAsync<T, E>;
+    andThrough<F>(fn: (value: T) => Try<unknown, F> | TryAsync<unknown, F>): TryAsync<T, E | F>;
+    orThrough<F>(fn: (error: E) => Try<unknown, F> | TryAsync<unknown, F>): TryAsync<T, E | F>;
+    catchFault<Code extends string, F>(code: Code, fn: (fault: Extract<E, {
+        code: Code;
+    }>) => Try<T, F> | TryAsync<T, F>): TryAsync<T, Exclude<E, {
+        code: Code;
+    }> | F>;
+    unwrapOr(defaultValue: T): Promise<T>;
+    match<U>(cases: {
+        ok: (value: T) => U;
+        err: (error: E) => U;
+    }): Promise<U>;
+    pipe<R>(fn: (result: TryAsync<T, E>) => R): R;
+    [Symbol.asyncIterator](): AsyncGenerator<Err<never, E>, T>;
+}
+export declare function okAsync<T, E = never>(value: T): TryAsync<T, E>;
+export declare function errAsync<T = never, E = unknown>(error: E): TryAsync<T, E>;
+//# sourceMappingURL=try.async.d.ts.map

package/dist/unthrow/try.async.js

@@ -95,6 +95,9 @@ export class TryAsync {
         const result = await this;
         return result.match(cases);
     }
+    pipe(fn) {
+        return fn(this);
+    }
     async *[Symbol.asyncIterator]() {
         const result = await this._promise;
         if (result.isErr()) {

package/dist/unthrow/try.d.ts

@@ -0,0 +1,58 @@
+export type Try<T, E> = Ok<T, E> | Err<T, E>;
+export declare class Ok<T, E = never> {
+    readonly value: T;
+    readonly _tag: symbol;
+    constructor(value: T);
+    isOk(): this is Ok<T, E>;
+    isErr(): this is Err<T, E>;
+    map<U>(fn: (value: T) => U): Try<U, E>;
+    mapErr<F>(_fn: (error: E) => F): Try<T, F>;
+    andThen<U, F>(fn: (value: T) => Try<U, F>): Try<U, E | F>;
+    orElse<F>(_fn: (error: E) => Try<T, F>): Try<T, F>;
+    tap(fn: (value: T) => void): Try<T, E>;
+    tapErr(_fn: (error: E) => void): Try<T, E>;
+    andThrough<F>(fn: (value: T) => Try<unknown, F>): Try<T, E | F>;
+    orThrough<F>(_fn: (error: E) => Try<unknown, F>): Try<T, E | F>;
+    catchFault<Code extends string, F>(_code: Code, _fn: (fault: Extract<E, {
+        code: Code;
+    }>) => Try<T, F>): Try<T, Exclude<E, {
+        code: Code;
+    }> | F>;
+    unwrapOr(_defaultValue: T): T;
+    match<U>(cases: {
+        ok: (value: T) => U;
+        err: (error: E) => U;
+    }): U;
+    pipe<R>(fn: (result: Try<T, E>) => R): R;
+    [Symbol.iterator](): Generator<Err<never, E>, T>;
+}
+export declare class Err<T = never, E = unknown> {
+    readonly error: E;
+    readonly _tag: symbol;
+    constructor(error: E);
+    isOk(): this is Ok<T, E>;
+    isErr(): this is Err<T, E>;
+    map<U>(_fn: (value: T) => U): Try<U, E>;
+    mapErr<F>(fn: (error: E) => F): Try<T, F>;
+    andThen<U, F>(_fn: (value: T) => Try<U, F>): Try<U, E | F>;
+    orElse<F>(fn: (error: E) => Try<T, F>): Try<T, F>;
+    tap(_fn: (value: T) => void): Try<T, E>;
+    tapErr(fn: (error: E) => void): Try<T, E>;
+    andThrough<F>(_fn: (value: T) => Try<unknown, F>): Try<T, E | F>;
+    orThrough<F>(fn: (error: E) => Try<unknown, F>): Try<T, E | F>;
+    catchFault<Code extends string, F>(code: Code, fn: (fault: Extract<E, {
+        code: Code;
+    }>) => Try<T, F>): Try<T, Exclude<E, {
+        code: Code;
+    }> | F>;
+    unwrapOr(defaultValue: T): T;
+    match<U>(cases: {
+        ok: (value: T) => U;
+        err: (error: E) => U;
+    }): U;
+    pipe<R>(fn: (result: Try<T, E>) => R): R;
+    [Symbol.iterator](): Generator<Err<never, E>, T>;
+}
+export declare function ok<T, E = never>(value: T): Ok<T, E>;
+export declare function err<T = never, E = unknown>(error: E): Err<T, E>;
+//# sourceMappingURL=try.d.ts.map

package/dist/unthrow/try.js

@@ -49,6 +49,9 @@ export class Ok {
     match(cases) {
         return cases.ok(this.value);
     }
+    pipe(fn) {
+        return fn(this);
+    }
     // eslint-disable-next-line require-yield
     *[Symbol.iterator]() {
         return this.value;
@@ -110,6 +113,9 @@ export class Err {
     match(cases) {
         return cases.err(this.error);
     }
+    pipe(fn) {
+        return fn(this);
+    }
     *[Symbol.iterator]() {
         // @ts-expect-error -- structurally equivalent, safe for Do notation
         yield this;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clutchit",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Resilience primitives for TypeScript — typed errors, retry, timeout, circuit breaking, scheduling, concurrency, and queues.",
   "keywords": [
     "typescript",