clutchit 0.0.3

package/dist/queue/dropping.queue.js

@@ -0,0 +1,20 @@
+import { BaseQueue } from './base.queue.js';
+export class DroppingQueue extends BaseQueue {
+    constructor(options) {
+        super(options);
+    }
+    /** Always succeeds. Drops the item if full. Returns whether item was accepted. */
+    offer(item) {
+        const waiter = this._takeWaiters.shift();
+        if (waiter) {
+            waiter(item);
+            return true;
+        }
+        if (this._buffer.length >= this._capacity) {
+            return false;
+        }
+        this._buffer.push(item);
+        return true;
+    }
+}
+//# sourceMappingURL=dropping.queue.js.map

package/dist/queue/faults.d.ts

@@ -0,0 +1,20 @@
+export declare const QueueFullFault: (capacity: number) => Readonly<{
+    code: "QUEUE_FULL";
+    _category: "infrastructure";
+    _transient: false;
+    message: string;
+} & Omit<{
+    message: string;
+    capacity: number;
+}, "message">>;
+export type QueueFullFault = ReturnType<typeof QueueFullFault>;
+export declare const QueueEmptyFault: () => Readonly<{
+    code: "QUEUE_EMPTY";
+    _category: "infrastructure";
+    _transient: false;
+    message: string;
+} & Omit<{
+    message: string;
+}, "message">>;
+export type QueueEmptyFault = ReturnType<typeof QueueEmptyFault>;
+//# sourceMappingURL=faults.d.ts.map

package/dist/queue/faults.js

@@ -0,0 +1,17 @@
+import { Fault } from '../unthrow/index.js';
+export const QueueFullFault = Fault.define({
+    code: 'QUEUE_FULL',
+    category: 'infrastructure',
+    create: (capacity) => ({
+        message: `Queue is full (capacity: ${capacity})`,
+        capacity,
+    }),
+});
+export const QueueEmptyFault = Fault.define({
+    code: 'QUEUE_EMPTY',
+    category: 'infrastructure',
+    create: () => ({
+        message: 'Queue is empty',
+    }),
+});
+//# sourceMappingURL=faults.js.map

package/dist/queue/index.d.ts

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

package/dist/queue/index.js

@@ -0,0 +1,11 @@
+import { BoundedQueue as _BoundedQueue } from './bounded.queue.js';
+import { DroppingQueue as _DroppingQueue } from './dropping.queue.js';
+import { SlidingQueue as _SlidingQueue } from './sliding.queue.js';
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Queue;
+(function (Queue) {
+    Queue.Bounded = _BoundedQueue;
+    Queue.Dropping = _DroppingQueue;
+    Queue.Sliding = _SlidingQueue;
+})(Queue || (Queue = {}));
+//# sourceMappingURL=index.js.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/queue/sliding.queue.js

@@ -0,0 +1,19 @@
+import { BaseQueue } from './base.queue.js';
+export class SlidingQueue extends BaseQueue {
+    constructor(options) {
+        super(options);
+    }
+    /** Always succeeds. Drops oldest if full. */
+    offer(item) {
+        const waiter = this._takeWaiters.shift();
+        if (waiter) {
+            waiter(item);
+            return;
+        }
+        if (this._buffer.length >= this._capacity) {
+            this._buffer.shift();
+        }
+        this._buffer.push(item);
+    }
+}
+//# sourceMappingURL=sliding.queue.js.map

package/dist/retry/index.d.ts

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

package/dist/retry/index.js

@@ -0,0 +1,7 @@
+import { RetryPolicy as _RetryPolicy } from './retry.js';
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Retry;
+(function (Retry) {
+    Retry.Policy = _RetryPolicy;
+})(Retry || (Retry = {}));
+//# sourceMappingURL=index.js.map

package/dist/retry/retry.d.ts

@@ -0,0 +1,21 @@
+import { ResultAsync } 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) => ResultAsync<T, E>, options?: RetryOptions<E>): ResultAsync<T, E>;
+}
+//# sourceMappingURL=retry.d.ts.map

package/dist/retry/retry.js

@@ -0,0 +1,58 @@
+import { ResultAsync } from '../unthrow/index.js';
+import { Schedule } from '../schedule/index.js';
+const NEVER_ABORT = new AbortController().signal;
+const DEFAULT_SCHEDULE = Schedule.exponential(200).pipe(Schedule.recurs(3));
+const defaultRetryOn = (error) => typeof error === 'object' &&
+    error !== null &&
+    '_transient' in error &&
+    error['_transient'] === true;
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (ms <= 0 || signal?.aborted) {
+            resolve();
+            return;
+        }
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener('abort', () => {
+            clearTimeout(timer);
+            resolve();
+        }, { once: true });
+    });
+}
+export class RetryPolicy {
+    defaults;
+    constructor(defaults) {
+        this.defaults = defaults;
+    }
+    execute(fn, options) {
+        const schedule = options?.schedule ?? this.defaults?.schedule ?? DEFAULT_SCHEDULE;
+        const retryOn = options?.retryOn ??
+            this.defaults?.retryOn ??
+            defaultRetryOn;
+        const onRetry = options?.onRetry ??
+            this.defaults?.onRetry;
+        const signal = options?.signal ?? this.defaults?.signal;
+        return ResultAsync.fromPromise((async () => {
+            let lastError;
+            for (let attempt = 0;; attempt++) {
+                const result = await fn(signal ?? NEVER_ABORT);
+                if (result.isOk())
+                    return result.value;
+                lastError = result.error;
+                // eslint-disable-next-line @typescript-eslint/only-throw-error -- intentional: fromPromise catches and maps E
+                if (signal?.aborted)
+                    throw lastError;
+                // eslint-disable-next-line @typescript-eslint/only-throw-error -- intentional: fromPromise catches and maps E
+                if (!retryOn(lastError))
+                    throw lastError;
+                const step = schedule.next(lastError, attempt);
+                // eslint-disable-next-line @typescript-eslint/only-throw-error -- intentional: fromPromise catches and maps E
+                if (!step.continue)
+                    throw lastError;
+                onRetry?.(lastError, attempt, step.delay);
+                await sleep(step.delay, signal);
+            }
+        })(), (e) => e);
+    }
+}
+//# sourceMappingURL=retry.js.map

package/dist/schedule/index.d.ts

@@ -0,0 +1,30 @@
+import { Schedule as ScheduleClass } 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';
+export type { ScheduleStep, ScheduleOperator } from './schedule.js';
+export { ScheduleInterruptedFault } from './runner.js';
+export type { RepeatOptions } from './runner.js';
+export type Schedule<In = unknown, Out = number> = ScheduleClass<In, Out>;
+export declare namespace Schedule {
+    const spaced: (ms: number) => ScheduleClass;
+    const exponential: (initialDelay: number, multiplier?: number) => ScheduleClass;
+    const linear: (initialDelay: number) => ScheduleClass;
+    const constant: (delay: number) => ScheduleClass;
+    const fixed: (interval: number) => ScheduleClass;
+    const windowed: (interval: number) => ScheduleClass;
+    const forever: ScheduleClass<unknown, number>;
+    const once: ScheduleClass<unknown, number>;
+    const fibonacci: (one: number) => ScheduleClass;
+    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;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/schedule/index.js

@@ -0,0 +1,29 @@
+import { Schedule as ScheduleClass } 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';
+export { ScheduleInterruptedFault } from './runner.js';
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Schedule;
+(function (Schedule) {
+    Schedule.spaced = ScheduleClass.spaced;
+    Schedule.exponential = ScheduleClass.exponential;
+    Schedule.linear = ScheduleClass.linear;
+    Schedule.constant = ScheduleClass.constant;
+    Schedule.fixed = ScheduleClass.fixed;
+    Schedule.windowed = ScheduleClass.windowed;
+    Schedule.forever = ScheduleClass.forever;
+    Schedule.once = ScheduleClass.once;
+    Schedule.fibonacci = ScheduleClass.fibonacci;
+    Schedule.recurs = _recurs;
+    Schedule.cappedDelay = _cappedDelay;
+    Schedule.jittered = _jittered;
+    Schedule.upTo = _upTo;
+    Schedule.andThen = _andThen;
+    Schedule.union = _union;
+    Schedule.intersect = _intersect;
+    Schedule.whileInput = _whileInput;
+    Schedule.whileOutput = _whileOutput;
+    Schedule.map = _map;
+    Schedule.repeat = _repeat;
+})(Schedule || (Schedule = {}));
+//# sourceMappingURL=index.js.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/operators.js

@@ -0,0 +1,106 @@
+import { Schedule } from './schedule.js';
+/** Limit total repetitions to n */
+export function recurs(n) {
+    return (schedule) => new Schedule((input, attempt) => {
+        const step = schedule.next(input, attempt);
+        if (attempt >= n)
+            return { ...step, delay: 0, continue: false };
+        return step;
+    });
+}
+/** Cap individual delay to maxDelay ms */
+export function cappedDelay(maxDelay) {
+    return (schedule) => new Schedule((input, attempt) => {
+        const step = schedule.next(input, attempt);
+        return { ...step, delay: Math.min(step.delay, maxDelay) };
+    });
+}
+/** Add random jitter (±factor, default ±0.25) */
+export function jittered(factor = 0.25) {
+    return (schedule) => new Schedule((input, attempt) => {
+        const step = schedule.next(input, attempt);
+        const jitter = 1 + (Math.random() * 2 - 1) * factor;
+        return { ...step, delay: Math.round(step.delay * jitter) };
+    });
+}
+/** Stop after total elapsed time exceeds duration ms */
+export function upTo(duration) {
+    return (schedule) => {
+        const startTime = Date.now();
+        return new Schedule((input, attempt) => {
+            const step = schedule.next(input, attempt);
+            const elapsed = Date.now() - startTime;
+            if (elapsed >= duration)
+                return { ...step, delay: 0, continue: false };
+            return step;
+        });
+    };
+}
+/** Sequential composition: run base until it stops, then switch to next */
+export function andThen(next) {
+    return (schedule) => {
+        let switched = false;
+        let switchAttempt = 0;
+        return new Schedule((input, attempt) => {
+            if (!switched) {
+                const step = schedule.next(input, attempt);
+                if (step.continue)
+                    return step;
+                switched = true;
+                switchAttempt = attempt;
+            }
+            const nextStep = next.next(input, attempt - switchAttempt);
+            return { ...nextStep, output: nextStep.output };
+        });
+    };
+}
+/** Continue while either wants to; use shorter delay */
+export function union(other) {
+    return (schedule) => new Schedule((input, attempt) => {
+        const a = schedule.next(input, attempt);
+        const b = other.next(input, attempt);
+        return {
+            delay: Math.min(a.delay, b.delay),
+            continue: a.continue || b.continue,
+            output: a.output,
+        };
+    });
+}
+/** Continue while both want to; use longer delay */
+export function intersect(other) {
+    return (schedule) => new Schedule((input, attempt) => {
+        const a = schedule.next(input, attempt);
+        const b = other.next(input, attempt);
+        return {
+            delay: Math.max(a.delay, b.delay),
+            continue: a.continue && b.continue,
+            output: a.output,
+        };
+    });
+}
+/** Continue while the input satisfies the predicate */
+export function whileInput(predicate) {
+    return (schedule) => new Schedule((input, attempt) => {
+        const step = schedule.next(input, attempt);
+        if (!predicate(input))
+            return { ...step, delay: 0, continue: false };
+        return step;
+    });
+}
+/** Continue while the output satisfies the predicate */
+export function whileOutput(predicate) {
+    return (schedule) => new Schedule((input, attempt) => {
+        const step = schedule.next(input, attempt);
+        if (!predicate(step.output))
+            return { ...step, delay: 0, continue: false };
+        return step;
+    });
+}
+/** Transform the output value */
+export function map(f) {
+    return (schedule) => new Schedule((input, attempt) => {
+        const step = schedule.next(input, attempt);
+        return { ...step, output: f(step.output) };
+    });
+}
+//# sourceMappingURL=operators.js.map

package/dist/schedule/runner.d.ts

@@ -0,0 +1,30 @@
+import { ResultAsync } from '../unthrow/index.js';
+import type { Schedule } from './schedule.js';
+export declare const ScheduleInterruptedFault: () => Readonly<{
+    code: "SCHEDULE_INTERRUPTED";
+    _category: "infrastructure";
+    _transient: false;
+    message: string;
+} & Omit<{
+    message: string;
+}, "message">>;
+export type ScheduleInterruptedFault = ReturnType<typeof ScheduleInterruptedFault>;
+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) => ResultAsync<void, E>, options?: RepeatOptions): ResultAsync<Out, E | ScheduleInterruptedFault>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/schedule/runner.js

@@ -0,0 +1,57 @@
+import { Fault, ResultAsync } from '../unthrow/index.js';
+export const ScheduleInterruptedFault = Fault.define({
+    code: 'SCHEDULE_INTERRUPTED',
+    category: 'infrastructure',
+    create: () => ({
+        message: 'Scheduled execution was interrupted',
+    }),
+});
+const NEVER_ABORT = new AbortController().signal;
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (ms <= 0 || signal?.aborted) {
+            resolve();
+            return;
+        }
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener('abort', () => {
+            clearTimeout(timer);
+            resolve();
+        }, { once: true });
+    });
+}
+/**
+ * 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 function repeat(schedule, fn, options) {
+    const signal = options?.signal;
+    const onExecution = options?.onExecution;
+    return ResultAsync.fromPromise((async () => {
+        for (let attempt = 0;; attempt++) {
+            // eslint-disable-next-line @typescript-eslint/only-throw-error -- intentional: fromPromise catches and maps E
+            if (signal?.aborted)
+                throw ScheduleInterruptedFault();
+            const result = await fn(signal ?? NEVER_ABORT);
+            // eslint-disable-next-line @typescript-eslint/only-throw-error -- intentional: fromPromise catches and maps E
+            if (result.isErr())
+                throw result.error;
+            const step = schedule.next(undefined, attempt);
+            onExecution?.(attempt, step.delay);
+            if (!step.continue)
+                return step.output;
+            await sleep(step.delay, signal);
+            // eslint-disable-next-line @typescript-eslint/only-throw-error -- intentional: fromPromise catches and maps E
+            if (signal?.aborted)
+                throw ScheduleInterruptedFault();
+        }
+    })(), (e) => e);
+}
+//# sourceMappingURL=runner.js.map

package/dist/schedule/schedule.d.ts

@@ -0,0 +1,31 @@
+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;
+}
+//# sourceMappingURL=schedule.d.ts.map

package/dist/schedule/schedule.js

@@ -0,0 +1,94 @@
+export class Schedule {
+    _next;
+    constructor(_next) {
+        this._next = _next;
+    }
+    next(input, attempt) {
+        return this._next(input, attempt);
+    }
+    pipe(operator) {
+        return operator(this);
+    }
+    // ── Static Factories ─────────────────────────────────────────────
+    /** Fixed delay between executions (from completion to next start) */
+    static spaced = (ms) => new Schedule((_input, attempt) => ({
+        delay: ms,
+        continue: true,
+        output: attempt,
+    }));
+    /** Exponential backoff: initialDelay * multiplier^attempt */
+    static exponential = (initialDelay, multiplier = 2) => new Schedule((_input, attempt) => ({
+        delay: initialDelay * multiplier ** attempt,
+        continue: true,
+        output: attempt,
+    }));
+    /** Linear backoff: initialDelay * (attempt + 1) */
+    static linear = (initialDelay) => new Schedule((_input, attempt) => ({
+        delay: initialDelay * (attempt + 1),
+        continue: true,
+        output: attempt,
+    }));
+    /** Constant delay (alias for spaced) */
+    static constant = (delay) => new Schedule((_input, attempt) => ({
+        delay,
+        continue: true,
+        output: attempt,
+    }));
+    /** Fixed interval from start to start (compensates for execution time) */
+    static fixed = (interval) => {
+        let lastCallTime = null;
+        let lastDelay = 0;
+        return new Schedule((_input, attempt) => {
+            const now = Date.now();
+            if (lastCallTime === null) {
+                lastCallTime = now;
+                lastDelay = interval;
+                return { delay: interval, continue: true, output: attempt };
+            }
+            const elapsed = now - lastCallTime;
+            const execTime = Math.max(0, elapsed - lastDelay);
+            const delay = Math.max(0, interval - execTime);
+            lastCallTime = now;
+            lastDelay = delay;
+            return { delay, continue: true, output: attempt };
+        });
+    };
+    /** Aligned to wall-clock time windows */
+    static windowed = (interval) => {
+        return new Schedule((_input, attempt) => {
+            const now = Date.now();
+            const nextWindow = Math.ceil(now / interval) * interval;
+            const delay = nextWindow - now;
+            return {
+                delay: delay === 0 ? interval : delay,
+                continue: true,
+                output: attempt,
+            };
+        });
+    };
+    /** Zero-delay infinite schedule */
+    static forever = new Schedule((_input, attempt) => ({
+        delay: 0,
+        continue: true,
+        output: attempt,
+    }));
+    /** Continue once then stop. With repeat: initial + 1 repetition = 2 total executions */
+    static once = new Schedule((_input, attempt) => ({
+        delay: 0,
+        continue: attempt < 1,
+        output: attempt,
+    }));
+    /** Fibonacci delay sequence: one, one, 2*one, 3*one, 5*one, 8*one, ... */
+    static fibonacci = (one) => {
+        let prev = 0;
+        let curr = one;
+        return new Schedule((_input, attempt) => {
+            const delay = curr;
+            const next = prev + curr;
+            prev = curr;
+            curr = next;
+            return { delay, continue: true, output: attempt };
+        });
+    };
+}
+//# sourceMappingURL=schedule.js.map

package/dist/timeout/index.d.ts

@@ -0,0 +1,16 @@
+import { withTimeout as _withTimeout, createTimeout as _createTimeout } from './timeout.js';
+export type { TimeoutFault } from './timeout.js';
+export declare namespace Timeout {
+    const wrap: typeof _withTimeout;
+    const create: typeof _createTimeout;
+    const Fault: (duration: number) => Readonly<{
+        code: "TIMEOUT";
+        _category: "infrastructure";
+        _transient: true;
+        message: string;
+    } & Omit<{
+        message: string;
+        duration: number;
+    }, "message">>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/timeout/index.js

@@ -0,0 +1,9 @@
+import { TimeoutFault as _TimeoutFault, withTimeout as _withTimeout, createTimeout as _createTimeout, } from './timeout.js';
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Timeout;
+(function (Timeout) {
+    Timeout.wrap = _withTimeout;
+    Timeout.create = _createTimeout;
+    Timeout.Fault = _TimeoutFault;
+})(Timeout || (Timeout = {}));
+//# sourceMappingURL=index.js.map

package/dist/timeout/timeout.d.ts

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