clutchit 0.0.3 → 0.0.6

package/dist/concurrency/index.d.ts

@@ -1,16 +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 type { SemaphoreOptions } from './semaphore.js';
-export type { RateLimiterOptions } from './rate-limiter.js';
-export type { RateLimitFault } from './rate-limiter.js';
-export type { BulkheadOptions } from './bulkhead.js';
-export type { BulkheadRejectedFault } from './bulkhead.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/index.js

@@ -2,6 +2,8 @@ import { Semaphore as _Semaphore } from './semaphore.js';
 import { RateLimiter as _RateLimiter } from './rate-limiter.js';
 import { Bulkhead as _Bulkhead } from './bulkhead.js';
 import { Ref as _Ref } from './ref.js';
+export { RateLimitFault } from './rate-limiter.js';
+export { BulkheadRejectedFault } from './bulkhead.js';
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export var Concurrency;
 (function (Concurrency) {

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

@@ -1,14 +1,17 @@
 import { ResultAsync } from '../unthrow/index.js';
-export declare const RateLimitFault: (retryAfter: number) => Readonly<{
-    code: "RATE_LIMITED";
-    _category: "infrastructure";
-    _transient: true;
-    message: string;
-} & Omit<{
-    message: string;
+declare const RateLimitFault_base: abstract new (fields: {
     retryAfter: number;
-}, "message">>;
-export type RateLimitFault = ReturnType<typeof RateLimitFault>;
+}) => 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;
@@ -22,4 +25,5 @@ export declare class RateLimiter {
     get remaining(): number;
     private cleanup;
 }
+export {};
 //# sourceMappingURL=rate-limiter.d.ts.map

package/dist/concurrency/rate-limiter.js

@@ -1,13 +1,7 @@
 import { Fault, ResultAsync } from '../unthrow/index.js';
-export const RateLimitFault = Fault.define({
-    code: 'RATE_LIMITED',
-    category: 'infrastructure',
-    transient: true,
-    create: (retryAfter) => ({
-        message: `Rate limit exceeded. Retry after ${retryAfter}ms`,
-        retryAfter,
-    }),
-});
+export class RateLimitFault extends Fault.Tagged('RATE_LIMITED', 'infrastructure', true)() {
+    message = `Rate limit exceeded. Retry after ${this.retryAfter}ms`;
+}
 export class RateLimiter {
     _limit;
     _window;
@@ -21,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(RateLimitFault(retryAfter));
+            return ResultAsync.err(new RateLimitFault({ retryAfter }));
         }
         this._timestamps.push(Date.now());
         return fn();

package/dist/queue/base.queue.js

@@ -11,7 +11,7 @@ export class BaseQueue {
         if (this._buffer.length > 0) {
             return Result.ok(this._buffer.shift());
         }
-        return Result.err(QueueEmptyFault());
+        return Result.err(new QueueEmptyFault());
     }
     take(signal) {
         const taken = this._tryTake();

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

@@ -4,8 +4,8 @@ import { BaseQueue, type QueueOptions } from './base.queue.js';
 export declare class BoundedQueue<T> extends BaseQueue<T> {
     private readonly _putWaiters;
     constructor(options: QueueOptions);
-    protected _tryTake(): Result<T, ReturnType<typeof QueueEmptyFault>>;
-    offer(item: T): Result<void, ReturnType<typeof QueueFullFault>>;
+    protected _tryTake(): Result<T, QueueEmptyFault>;
+    offer(item: T): Result<void, QueueFullFault>;
     put(item: T, signal?: AbortSignal): ResultAsync<void, never>;
 }
 //# sourceMappingURL=bounded.queue.d.ts.map

package/dist/queue/bounded.queue.js

@@ -23,7 +23,7 @@ export class BoundedQueue extends BaseQueue {
             pw.resolve();
             return Result.ok(pw.item);
         }
-        return Result.err(QueueEmptyFault());
+        return Result.err(new QueueEmptyFault());
     }
     offer(item) {
         // Give directly to a waiting consumer
@@ -33,7 +33,7 @@ export class BoundedQueue extends BaseQueue {
             return Result.ok(undefined);
         }
         if (this._buffer.length >= this._capacity) {
-            return Result.err(QueueFullFault(this._capacity));
+            return Result.err(new QueueFullFault({ capacity: this._capacity }));
         }
         this._buffer.push(item);
         return Result.ok(undefined);

package/dist/queue/faults.d.ts

@@ -1,20 +1,24 @@
-export declare const QueueFullFault: (capacity: number) => Readonly<{
-    code: "QUEUE_FULL";
-    _category: "infrastructure";
-    _transient: false;
-    message: string;
-} & Omit<{
-    message: string;
+declare const QueueFullFault_base: abstract new (fields: {
     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>;
+}) => 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/faults.js

@@ -1,17 +1,8 @@
 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',
-    }),
-});
+export class QueueFullFault extends Fault.Tagged('QUEUE_FULL', 'infrastructure')() {
+    message = `Queue is full (capacity: ${this.capacity})`;
+}
+export class QueueEmptyFault extends Fault.Tagged('QUEUE_EMPTY', 'infrastructure')() {
+    message = 'Queue is empty';
+}
 //# sourceMappingURL=faults.js.map

package/dist/queue/index.d.ts

@@ -1,11 +1,15 @@
-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';
+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 {
-    const Bounded: typeof _BoundedQueue;
-    const Dropping: typeof _DroppingQueue;
-    const Sliding: typeof _SlidingQueue;
+    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/index.js

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

package/dist/retry/index.d.ts

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

package/dist/retry/index.js

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

package/dist/schedule/index.d.ts

@@ -1,20 +1,25 @@
-import { Schedule as ScheduleClass } from './schedule.js';
+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';
-export type { ScheduleStep, ScheduleOperator } from './schedule.js';
+import type { RepeatOptions as _RepeatOptions } from './runner.js';
 export { ScheduleInterruptedFault } from './runner.js';
-export type { RepeatOptions } from './runner.js';
-export type Schedule<In = unknown, Out = number> = ScheduleClass<In, Out>;
+export type Schedule<In = unknown, Out = number> = _Schedule<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;
+    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;
@@ -26,5 +31,6 @@ export declare namespace Schedule {
     const whileOutput: typeof _whileOutput;
     const map: typeof _map;
     const repeat: typeof _repeat;
+    type RepeatOptions = _RepeatOptions;
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/schedule/index.js

@@ -1,19 +1,20 @@
-import { Schedule as ScheduleClass } from './schedule.js';
+import { Schedule as _Schedule } 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.spaced = _Schedule.spaced;
+    Schedule.exponential = _Schedule.exponential;
+    Schedule.linear = _Schedule.linear;
+    Schedule.constant = _Schedule.constant;
+    Schedule.fixed = _Schedule.fixed;
+    Schedule.windowed = _Schedule.windowed;
+    Schedule.forever = _Schedule.forever;
+    Schedule.once = _Schedule.once;
+    Schedule.fibonacci = _Schedule.fibonacci;
+    Schedule.cron = _Schedule.cron;
     Schedule.recurs = _recurs;
     Schedule.cappedDelay = _cappedDelay;
     Schedule.jittered = _jittered;

package/dist/schedule/runner.d.ts

@@ -1,14 +1,14 @@
 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>;
+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;
@@ -27,4 +27,5 @@ export interface RepeatOptions {
  * 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>;
+export {};
 //# sourceMappingURL=runner.d.ts.map

package/dist/schedule/runner.js

@@ -1,11 +1,7 @@
 import { Fault, ResultAsync } from '../unthrow/index.js';
-export const ScheduleInterruptedFault = Fault.define({
-    code: 'SCHEDULE_INTERRUPTED',
-    category: 'infrastructure',
-    create: () => ({
-        message: 'Scheduled execution was interrupted',
-    }),
-});
+export class ScheduleInterruptedFault extends Fault.Tagged('SCHEDULE_INTERRUPTED', 'infrastructure')() {
+    message = 'Scheduled execution was interrupted';
+}
 const NEVER_ABORT = new AbortController().signal;
 function sleep(ms, signal) {
     return new Promise((resolve) => {
@@ -38,7 +34,7 @@ export function repeat(schedule, fn, options) {
         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();
+                throw new 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())
@@ -50,7 +46,7 @@ export function repeat(schedule, fn, options) {
             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();
+                throw new ScheduleInterruptedFault();
         }
     })(), (e) => e);
 }

package/dist/schedule/schedule.d.ts

@@ -27,5 +27,9 @@ export declare class Schedule<In = unknown, Out = number> {
     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/schedule/schedule.js

@@ -1,3 +1,4 @@
+import { Cron } from 'croner';
 export class Schedule {
     _next;
     constructor(_next) {
@@ -90,5 +91,16 @@ export class Schedule {
             return { delay, continue: true, output: attempt };
         });
     };
+    /** Cron expression schedule (aligned to cron windows) */
+    static cron = (expression, options) => {
+        const pattern = new Cron(expression, options?.timezone ? { timezone: options.timezone } : undefined);
+        return new Schedule((_input, attempt) => {
+            const next = pattern.nextRun();
+            if (!next)
+                return { delay: 0, continue: false, output: attempt };
+            const delay = Math.max(0, next.getTime() - Date.now());
+            return { delay, continue: true, output: attempt };
+        });
+    };
 }
 //# sourceMappingURL=schedule.js.map

package/dist/timeout/index.d.ts

@@ -1,16 +1,7 @@
 import { withTimeout as _withTimeout, createTimeout as _createTimeout } from './timeout.js';
-export type { TimeoutFault } from './timeout.js';
+export { 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

@@ -1,9 +1,9 @@
-import { TimeoutFault as _TimeoutFault, withTimeout as _withTimeout, createTimeout as _createTimeout, } from './timeout.js';
+import { withTimeout as _withTimeout, createTimeout as _createTimeout, } from './timeout.js';
+export { TimeoutFault } 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

@@ -1,14 +1,18 @@
 import { ResultAsync } from '../unthrow/index.js';
-export declare const TimeoutFault: (duration: number) => Readonly<{
-    code: "TIMEOUT";
-    _category: "infrastructure";
-    _transient: true;
-    message: string;
-} & Omit<{
-    message: string;
+declare const TimeoutFault_base: abstract new (fields: {
     duration: number;
-}, "message">>;
-export type TimeoutFault = ReturnType<typeof TimeoutFault>;
+}) => 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) => 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>;
+export {};
 //# sourceMappingURL=timeout.d.ts.map

package/dist/timeout/timeout.js

@@ -1,13 +1,7 @@
 import { Fault, ResultAsync } from '../unthrow/index.js';
-export const TimeoutFault = Fault.define({
-    code: 'TIMEOUT',
-    category: 'infrastructure',
-    transient: true,
-    create: (duration) => ({
-        message: `Operation timed out after ${duration}ms`,
-        duration,
-    }),
-});
+export class TimeoutFault extends Fault.Tagged('TIMEOUT', 'infrastructure', true)() {
+    message = `Operation timed out after ${this.duration}ms`;
+}
 export function withTimeout(fn, duration) {
     const controller = new AbortController();
     return ResultAsync.fromPromise(
@@ -15,7 +9,7 @@ export function withTimeout(fn, duration) {
     new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
             controller.abort();
-            reject(TimeoutFault(duration));
+            reject(new TimeoutFault({ duration }));
         }, duration);
         void fn(controller.signal).then((result) => {
             clearTimeout(timer);

package/dist/unthrow/fault.d.ts

@@ -4,34 +4,19 @@ export interface Fault {
     readonly _category: 'domain' | 'infrastructure';
     readonly _transient: boolean;
 }
-export type DomainFault = Fault & {
+export declare function isDomainFault(error: Fault): error is Fault & {
     readonly _category: 'domain';
-    readonly _transient: false;
 };
-export type InfrastructureFault = Fault & {
+export declare function isInfrastructureFault(error: Fault): error is Fault & {
     readonly _category: 'infrastructure';
 };
-export type TransientFault = InfrastructureFault & {
+export declare function isTransientFault(error: Fault): error is Fault & {
     readonly _transient: true;
 };
-export declare function isTransient(error: Fault): error is TransientFault;
-export declare function isDomainFault(error: Fault): error is DomainFault;
-export declare function isInfrastructureFault(error: Fault): error is InfrastructureFault;
-type InferTransient<O> = O extends {
-    transient: infer T extends boolean;
-} ? T : false;
-export declare function defineFault<const O extends {
-    code: string;
-    category: 'domain' | 'infrastructure';
-    transient?: boolean;
-    create: (...args: any[]) => {
-        message: string;
-    };
-}>(options: O): (...args: Parameters<O['create']>) => Readonly<{
-    code: O['code'];
-    _category: O['category'];
-    _transient: InferTransient<O>;
-    message: string;
-} & Omit<ReturnType<O['create']>, 'message'>>;
-export {};
+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/fault.js

@@ -1,22 +1,27 @@
-export function isTransient(error) {
-    return error._transient && error._category === 'infrastructure';
-}
 export function isDomainFault(error) {
     return error._category === 'domain';
 }
 export function isInfrastructureFault(error) {
     return error._category === 'infrastructure';
 }
-export function defineFault(options) {
-    const transient = (options.transient ?? false);
-    return (...args) => {
-        const extra = options.create(...args);
-        return Object.freeze({
-            code: options.code,
-            _category: options.category,
-            _transient: transient,
-            ...extra,
-        });
+export function isTransientFault(error) {
+    return error._transient && error._category === 'infrastructure';
+}
+export function Fault(code, category, transient) {
+    const _transient = (transient ?? false);
+    return () => {
+        class FaultImpl {
+            code = code;
+            _category = category;
+            _transient = _transient;
+            constructor(...args) {
+                const fields = args[0];
+                if (fields) {
+                    Object.assign(this, fields);
+                }
+            }
+        }
+        return FaultImpl;
     };
 }
 //# sourceMappingURL=fault.js.map