clutchit 0.0.3

package/dist/timeout/timeout.js

@@ -0,0 +1,37 @@
+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 function withTimeout(fn, duration) {
+    const controller = new AbortController();
+    return ResultAsync.fromPromise(
+    /* eslint-disable @typescript-eslint/prefer-promise-reject-errors -- intentional: rejections are typed E | TimeoutFault, caught by fromPromise */
+    new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            controller.abort();
+            reject(TimeoutFault(duration));
+        }, duration);
+        void fn(controller.signal).then((result) => {
+            clearTimeout(timer);
+            if (result.isOk())
+                resolve(result.value);
+            else
+                reject(result.error);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    }), 
+    /* eslint-enable @typescript-eslint/prefer-promise-reject-errors */
+    (e) => e);
+}
+export function createTimeout(duration) {
+    return (fn) => withTimeout(fn, duration);
+}
+//# sourceMappingURL=timeout.js.map

package/dist/unthrow/do.d.ts

@@ -0,0 +1,5 @@
+import { type Result, Err } from './result.js';
+import { ResultAsync } from './result.async.js';
+export declare function Do<T, E>(generator: () => Generator<Err<never, E>, T>): Result<T, E>;
+export declare function DoAsync<T, E>(generator: () => AsyncGenerator<Err<never, E>, T>): ResultAsync<T, E>;
+//# sourceMappingURL=do.d.ts.map

package/dist/unthrow/do.js

@@ -0,0 +1,23 @@
+import { ok } from './result.js';
+import { ResultAsync } from './result.async.js';
+export function Do(generator) {
+    const gen = generator();
+    const next = gen.next();
+    while (!next.done) {
+        // Each yielded value is an Err — short-circuit
+        return next.value;
+    }
+    return ok(next.value);
+}
+export function DoAsync(generator) {
+    return new ResultAsync((async () => {
+        const gen = generator();
+        const next = await gen.next();
+        while (!next.done) {
+            // Each yielded value is an Err — short-circuit
+            return next.value;
+        }
+        return ok(next.value);
+    })());
+}
+//# sourceMappingURL=do.js.map

package/dist/unthrow/fault.d.ts

@@ -0,0 +1,37 @@
+export interface Fault {
+    readonly code: string;
+    readonly message: string;
+    readonly _category: 'domain' | 'infrastructure';
+    readonly _transient: boolean;
+}
+export type DomainFault = Fault & {
+    readonly _category: 'domain';
+    readonly _transient: false;
+};
+export type InfrastructureFault = Fault & {
+    readonly _category: 'infrastructure';
+};
+export type TransientFault = InfrastructureFault & {
+    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 {};
+//# sourceMappingURL=fault.d.ts.map

package/dist/unthrow/fault.js

@@ -0,0 +1,22 @@
+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,
+        });
+    };
+}
+//# sourceMappingURL=fault.js.map

package/dist/unthrow/helpers.d.ts

@@ -0,0 +1,9 @@
+import { type Result } from './result.js';
+import { ResultAsync } from './result.async.js';
+export declare function combine<T, E>(results: Result<T, E>[]): Result<T[], E>;
+export declare function combine<T, E>(results: ResultAsync<T, E>[]): ResultAsync<T[], E>;
+export declare function combineWithAllErrors<T, E>(results: Result<T, E>[]): Result<T[], E[]>;
+export declare function combineWithAllErrors<T, E>(results: ResultAsync<T, E>[]): ResultAsync<T[], E[]>;
+export declare function fromPromise<T, E>(promise: Promise<T>, errorMapper: (error: unknown) => E): ResultAsync<T, E>;
+export declare function fromThrowable<T, E>(fn: () => T, errorMapper: (error: unknown) => E): Result<T, E>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/unthrow/helpers.js

@@ -0,0 +1,56 @@
+import { ok, err } from './result.js';
+import { ResultAsync } from './result.async.js';
+export function combine(results) {
+    if (results.length === 0) {
+        return ok([]);
+    }
+    if (results[0] instanceof ResultAsync) {
+        const asyncResults = results;
+        return new ResultAsync(Promise.all(asyncResults.map((r) => r.then((v) => v))).then((settled) => combineSync(settled)));
+    }
+    return combineSync(results);
+}
+function combineSync(results) {
+    const values = [];
+    for (const result of results) {
+        if (result.isErr())
+            return err(result.error);
+        values.push(result.value);
+    }
+    return ok(values);
+}
+export function combineWithAllErrors(results) {
+    if (results.length === 0) {
+        return ok([]);
+    }
+    if (results[0] instanceof ResultAsync) {
+        const asyncResults = results;
+        return new ResultAsync(Promise.all(asyncResults.map((r) => r.then((v) => v))).then((settled) => combineWithAllErrorsSync(settled)));
+    }
+    return combineWithAllErrorsSync(results);
+}
+function combineWithAllErrorsSync(results) {
+    const values = [];
+    const errors = [];
+    for (const result of results) {
+        if (result.isErr()) {
+            errors.push(result.error);
+        }
+        else {
+            values.push(result.value);
+        }
+    }
+    return errors.length > 0 ? err(errors) : ok(values);
+}
+export function fromPromise(promise, errorMapper) {
+    return new ResultAsync(promise.then((value) => ok(value), (error) => err(errorMapper(error))));
+}
+export function fromThrowable(fn, errorMapper) {
+    try {
+        return ok(fn());
+    }
+    catch (error) {
+        return err(errorMapper(error));
+    }
+}
+//# sourceMappingURL=helpers.js.map

package/dist/unthrow/index.d.ts

@@ -0,0 +1,32 @@
+import { ResultAsync as ResultAsyncClass, okAsync, errAsync } from './result.async.js';
+import { DoAsync } from './do.js';
+import { defineFault, isDomainFault, isInfrastructureFault } from './fault.js';
+export { Ok, Err } from './result.js';
+export type { DomainFault, InfrastructureFault, TransientFault, } from './fault.js';
+export type Result<T, E> = import('./result.js').Ok<T, E> | import('./result.js').Err<T, E>;
+type _Result<T, E> = Result<T, E>;
+export declare namespace Result {
+    const ok: typeof import("./result.js").ok;
+    const err: typeof import("./result.js").err;
+    const fromThrowable: typeof import("./helpers.js").fromThrowable;
+    function combine<T, E>(results: _Result<T, E>[]): _Result<T[], E>;
+    function combineWithAllErrors<T, E>(results: _Result<T, E>[]): _Result<T[], E[]>;
+    const Do: typeof import("./do.js").Do;
+}
+export type ResultAsync<T, E> = ResultAsyncClass<T, E>;
+export declare namespace ResultAsync {
+    const ok: typeof okAsync;
+    const err: typeof errAsync;
+    const fromPromise: typeof import("./helpers.js").fromPromise;
+    function combine<T, E>(results: ResultAsyncClass<T, E>[]): ResultAsyncClass<T[], E>;
+    function combineWithAllErrors<T, E>(results: ResultAsyncClass<T, E>[]): ResultAsyncClass<T[], E[]>;
+    const Do: typeof DoAsync;
+}
+export type Fault = import('./fault.js').Fault;
+export declare namespace Fault {
+    const define: typeof defineFault;
+    const isTransient: typeof import("./fault.js").isTransient;
+    const isDomain: typeof isDomainFault;
+    const isInfrastructure: typeof isInfrastructureFault;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/unthrow/index.js

@@ -0,0 +1,55 @@
+import { ok, err } from './result.js';
+import { okAsync, errAsync, } from './result.async.js';
+import { fromPromise, fromThrowable, combine as combineFn, combineWithAllErrors as combineWithAllErrorsFn, } from './helpers.js';
+import { Do, DoAsync } from './do.js';
+import { defineFault, isTransient, isDomainFault, isInfrastructureFault, } from './fault.js';
+// Re-export instance types (needed in user signatures)
+export { Ok, Err } from './result.js';
+// Internal aliases (must precede namespaces that reference them)
+const _ok = ok;
+const _err = err;
+const _fromThrowable = fromThrowable;
+const _fromPromise = fromPromise;
+const _isTransient = isTransient;
+const _Do = Do;
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Result;
+(function (Result) {
+    Result.ok = _ok;
+    Result.err = _err;
+    Result.fromThrowable = _fromThrowable;
+    function combine(results) {
+        return combineFn(results);
+    }
+    Result.combine = combine;
+    function combineWithAllErrors(results) {
+        return combineWithAllErrorsFn(results);
+    }
+    Result.combineWithAllErrors = combineWithAllErrors;
+    Result.Do = _Do;
+})(Result || (Result = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var ResultAsync;
+(function (ResultAsync) {
+    ResultAsync.ok = okAsync;
+    ResultAsync.err = errAsync;
+    ResultAsync.fromPromise = _fromPromise;
+    function combine(results) {
+        return combineFn(results);
+    }
+    ResultAsync.combine = combine;
+    function combineWithAllErrors(results) {
+        return combineWithAllErrorsFn(results);
+    }
+    ResultAsync.combineWithAllErrors = combineWithAllErrors;
+    ResultAsync.Do = DoAsync;
+})(ResultAsync || (ResultAsync = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Fault;
+(function (Fault) {
+    Fault.define = defineFault;
+    Fault.isTransient = _isTransient;
+    Fault.isDomain = isDomainFault;
+    Fault.isInfrastructure = isInfrastructureFault;
+})(Fault || (Fault = {}));
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,19 @@
+import { type Result, Err } from './result.js';
+export declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
+    private readonly _promise;
+    readonly then: PromiseLike<Result<T, E>>['then'];
+    constructor(promise: Promise<Result<T, E>>);
+    map<U>(fn: (value: T) => U | Promise<U>): ResultAsync<U, E>;
+    mapErr<F>(fn: (error: E) => F | Promise<F>): ResultAsync<T, F>;
+    andThen<U, F>(fn: (value: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>;
+    orElse<F>(fn: (error: E) => Result<T, F> | ResultAsync<T, F>): ResultAsync<T, F>;
+    unwrapOr(defaultValue: T): Promise<T>;
+    match<U>(cases: {
+        ok: (value: T) => U;
+        err: (error: E) => U;
+    }): Promise<U>;
+    [Symbol.asyncIterator](): AsyncGenerator<Err<never, E>, T>;
+}
+export declare function okAsync<T, E = never>(value: T): ResultAsync<T, E>;
+export declare function errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E>;
+//# sourceMappingURL=result.async.d.ts.map

package/dist/unthrow/result.async.js

@@ -0,0 +1,63 @@
+import { Ok, Err, ok, err } from './result.js';
+export class ResultAsync {
+    _promise;
+    then;
+    constructor(promise) {
+        this._promise = promise;
+        this.then = promise.then.bind(promise);
+    }
+    map(fn) {
+        return new ResultAsync(this._promise.then(async (result) => {
+            if (result.isErr())
+                return new Err(result.error);
+            return new Ok(await fn(result.value));
+        }));
+    }
+    mapErr(fn) {
+        return new ResultAsync(this._promise.then(async (result) => {
+            if (result.isOk())
+                return new Ok(result.value);
+            return new Err(await fn(result.error));
+        }));
+    }
+    andThen(fn) {
+        return new ResultAsync(this._promise.then((result) => {
+            if (result.isErr())
+                return new Err(result.error);
+            const next = fn(result.value);
+            return next instanceof ResultAsync ? next._promise : next;
+        }));
+    }
+    orElse(fn) {
+        return new ResultAsync(this._promise.then((result) => {
+            if (result.isOk())
+                return new Ok(result.value);
+            const next = fn(result.error);
+            return next instanceof ResultAsync ? next._promise : next;
+        }));
+    }
+    async unwrapOr(defaultValue) {
+        const result = await this;
+        return result.unwrapOr(defaultValue);
+    }
+    async match(cases) {
+        const result = await this;
+        return result.match(cases);
+    }
+    async *[Symbol.asyncIterator]() {
+        const result = await this._promise;
+        if (result.isErr()) {
+            // @ts-expect-error -- structurally equivalent, safe for DoAsync notation
+            yield result;
+            throw new Error('Unreachable: DoAsync generator continued after Err yield');
+        }
+        return result.value;
+    }
+}
+export function okAsync(value) {
+    return new ResultAsync(Promise.resolve(ok(value)));
+}
+export function errAsync(error) {
+    return new ResultAsync(Promise.resolve(err(error)));
+}
+//# sourceMappingURL=result.async.js.map

package/dist/unthrow/result.d.ts

@@ -0,0 +1,38 @@
+export type Result<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): Result<U, E>;
+    mapErr<F>(_fn: (error: E) => F): Result<T, F>;
+    andThen<U, F>(fn: (value: T) => Result<U, F>): Result<U, E | F>;
+    orElse<F>(_fn: (error: E) => Result<T, F>): Result<T, F>;
+    unwrapOr(_defaultValue: T): T;
+    match<U>(cases: {
+        ok: (value: T) => U;
+        err: (error: E) => U;
+    }): U;
+    [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): Result<U, E>;
+    mapErr<F>(fn: (error: E) => F): Result<T, F>;
+    andThen<U, F>(_fn: (value: T) => Result<U, F>): Result<U, E | F>;
+    orElse<F>(fn: (error: E) => Result<T, F>): Result<T, F>;
+    unwrapOr(defaultValue: T): T;
+    match<U>(cases: {
+        ok: (value: T) => U;
+        err: (error: E) => U;
+    }): U;
+    [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=result.d.ts.map

package/dist/unthrow/result.js

@@ -0,0 +1,80 @@
+const OK = Symbol('Ok');
+const ERR = Symbol('Err');
+export class Ok {
+    value;
+    _tag = OK;
+    constructor(value) {
+        this.value = value;
+    }
+    isOk() {
+        return true;
+    }
+    isErr() {
+        return false;
+    }
+    map(fn) {
+        return new Ok(fn(this.value));
+    }
+    mapErr(_fn) {
+        return new Ok(this.value);
+    }
+    andThen(fn) {
+        return fn(this.value);
+    }
+    orElse(_fn) {
+        return new Ok(this.value);
+    }
+    unwrapOr(_defaultValue) {
+        return this.value;
+    }
+    match(cases) {
+        return cases.ok(this.value);
+    }
+    // eslint-disable-next-line require-yield
+    *[Symbol.iterator]() {
+        return this.value;
+    }
+}
+export class Err {
+    error;
+    _tag = ERR;
+    constructor(error) {
+        this.error = error;
+    }
+    isOk() {
+        return false;
+    }
+    isErr() {
+        return true;
+    }
+    map(_fn) {
+        return new Err(this.error);
+    }
+    mapErr(fn) {
+        return new Err(fn(this.error));
+    }
+    andThen(_fn) {
+        return new Err(this.error);
+    }
+    orElse(fn) {
+        return fn(this.error);
+    }
+    unwrapOr(defaultValue) {
+        return defaultValue;
+    }
+    match(cases) {
+        return cases.err(this.error);
+    }
+    *[Symbol.iterator]() {
+        // @ts-expect-error -- structurally equivalent, safe for Do notation
+        yield this;
+        throw new Error('Unreachable: Do notation generator continued after Err yield');
+    }
+}
+export function ok(value) {
+    return new Ok(value);
+}
+export function err(error) {
+    return new Err(error);
+}
+//# sourceMappingURL=result.js.map

package/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "clutchit",
+  "version": "0.0.3",
+  "description": "",
+  "author": {
+    "name": "hexac",
+    "url": "https://existin.space",
+    "email": "hexac@existin.space"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eishexac/clutchit.git",
+    "directory": "packages/unthrow"
+  },
+  "homepage": "https://github.com/eishexac/clutchit/tree/release/#readme",
+  "bugs": "https://github.com/eishexac/clutchit/issues",
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "type": "module",
+  "exports": {
+    "./unthrow": {
+      "@source": "./src/unthrow/index.ts",
+      "import": "./dist/unthrow/index.js",
+      "types": "./dist/unthrow/index.d.ts"
+    },
+    "./schedule": {
+      "@source": "./src/schedule/index.ts",
+      "import": "./dist/schedule/index.js",
+      "types": "./dist/schedule/index.d.ts"
+    },
+    "./retry": {
+      "@source": "./src/retry/index.ts",
+      "import": "./dist/retry/index.js",
+      "types": "./dist/retry/index.d.ts"
+    },
+    "./timeout": {
+      "@source": "./src/timeout/index.ts",
+      "import": "./dist/timeout/index.js",
+      "types": "./dist/timeout/index.d.ts"
+    },
+    "./concurrency": {
+      "@source": "./src/concurrency/index.ts",
+      "import": "./dist/concurrency/index.js",
+      "types": "./dist/concurrency/index.d.ts"
+    },
+    "./circuit": {
+      "@source": "./src/circuit/index.ts",
+      "import": "./dist/circuit/index.js",
+      "types": "./dist/circuit/index.d.ts"
+    },
+    "./queue": {
+      "@source": "./src/queue/index.ts",
+      "import": "./dist/queue/index.js",
+      "types": "./dist/queue/index.d.ts"
+    }
+  },
+  "lint-staged": {
+    "*.ts": [
+      "eslint",
+      "prettier --check"
+    ]
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/bun": "^1.3.9",
+    "@types/node": "^24.10.15",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^10.0.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-only-warn": "^1.1.0",
+    "eslint-plugin-turbo": "^2.8.10",
+    "globals": "^17.3.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.8.1",
+    "rimraf": "^6.1.3",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.1",
+    "vitest": "^4.0.18"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.2"
+  },
+  "engines": {
+    "node": ">=20",
+    "bun": ">=1"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc -p tsconfig.build.json",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "type:check": "tsc --noEmit",
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" \"test/**/*.ts\" --fix",
+    "test": "vitest run",
+    "test:unit": "vitest run --project unit",
+    "test:int": "vitest run --project int",
+    "test:e2e": "vitest run --project e2e",
+    "test:coverage": "vitest run --coverage"
+  }
+}