tryo 0.1.0 → 0.13.0

package/LICENSE

@@ -1,6 +1,21 @@
-Copyright 2026 sebastiansala
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+MIT License
 
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+Copyright (c) 2026 Sebastian Sala
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,15 +1,190 @@
-# trycatchfinally
+# tryo
 
-To install dependencies:
+Run sync/async functions and return a typed Result instead of throwing. `tryo` provides powerful error normalization, retry logic, concurrency control, and circuit breakers with a premium developer experience.
+
+## Installation
 
 ```bash
-bun install
+npm install tryo
+# or
+bun add tryo
 ```
 
-To run:
+## Basic Usage
 
-```bash
-bun run index.ts
+You can use the top-level shortcuts for simple cases, or create a configured instance for complex scenarios.
+
+### Using Shortcuts
+
+```typescript
+import { run } from 'tryo'
+
+const result = await run(async () => {
+  const res = await fetch('/api/data')
+  if (!res.ok) throw new Error('Failed')
+  return res.json()
+})
+
+if (result.ok) {
+  console.log(result.data) // result.data is typed
+} else {
+  console.error(result.error.code) // "HTTP", "UNKNOWN", etc.
+}
+```
+
+### Using the Factory (Best for Apps)
+
+Creating an instance allows you to shared configuration like retries, circuit breakers, and custom error rules across your app.
+
+```typescript
+import tryo from 'tryo'
+
+const ex = tryo({
+  retry: {
+    maxRetries: 3,
+    strategy: RetryStrategies.exponential(100),
+  },
+  circuitBreaker: {
+    failureThreshold: 5,
+    resetTimeout: 10000,
+  },
+})
+
+const result = await ex.run(fetchData)
+```
+
+## Error Handling
+
+`tryo` normalizes all errors into a `TypedError` instance with a stable `code`.
+
+### The `TypedError` Shape
+
+```typescript
+type TypedError<Code extends string = string, Meta = unknown> = {
+  code: Code // Stable error code (e.g. "TIMEOUT", "HTTP")
+  message: string // Human-readable message
+  cause?: unknown // Original error
+  meta?: Meta // Extra metadata (optional)
+  status?: number // Optional HTTP status (if applicable)
+  retryable: boolean // Whether the error is safe to retry
+  timestamp: number // When the error occurred (ms)
+  stack?: string // Stack trace for debugging
+}
+```
+
+### Default Rules
+
+By default, `tryo` detects:
+
+- **ABORTED**: Detects `AbortError`.
+- **TIMEOUT**: Detects `TimeoutError`.
+- **HTTP**: Detects status codes in error objects.
+- **UNKNOWN**: Fallback for everything else.
+
+### Custom Rules
+
+Map specific exceptions to typed error codes using the `rules` option.
+
+```typescript
+import tryo, { errorRule } from 'tryo'
+
+const ex = tryo({
+  rules: [
+    errorRule
+      .when(e => e === 'unauthorized')
+      .toError(() => ({
+        code: 'AUTH_ERROR',
+        message: 'Please login',
+      })),
+  ] as const,
+})
+```
+
+## API Reference
+
+### `.run(task, options?)`
+
+Executes a single task. The `options` can override the instance defaults (except `signal`, which must be passed per call).
+
+```typescript
+const result = await ex.run(task, {
+  timeout: 5000,
+  signal: abortController.signal,
+})
+```
+
+### `.all(tasks, options?)`
+
+Executes multiple tasks with **concurrency control**. Like `Promise.allSettled` but with retries, timeouts, and a worker pool.
+
+```typescript
+const tasks = [() => job(1), () => job(2), () => job(3)]
+
+// Execute 5-at-a-time
+const results = await ex.all(tasks, { concurrency: 5 })
+```
+
+### `.partitionAll(results)`
+
+Utility to separate successes from failures after an `all()` call.
+
+```typescript
+const { ok, failure, aborted, timeout } = ex.partitionAll(results)
+
+console.log(`Successes: ${ok.length}`)
+console.log(`Errors: ${failure.length}`)
+```
+
+### `.runOrThrow(task, options?)`
+
+Utility if you prefer exceptions but want the power of `tryo` (retries, breaker, normalization).
+
+```typescript
+const data = await ex.runOrThrow(task) // Returns data or throws TypedError
 ```
 
-This project was created using `bun init` in bun v1.2.9. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.
+## Advanced Features
+
+### Concurrency
+
+The `all()` method includes a worker pool that respects your `concurrency` limit and stops launching new tasks if the `signal` is aborted.
+
+### Circuit Breaker
+
+If your tasks fail repeatedly, the circuit breaker opens and prevents further calls to protect your downstream services.
+
+```typescript
+const ex = tryo({
+  circuitBreaker: {
+    failureThreshold: 5,
+    resetTimeout: 30000,
+    halfOpenRequests: 2,
+  },
+})
+```
+
+### Observability Hooks
+
+Add hooks for logging or monitoring:
+
+```typescript
+const ex = tryo({
+  hooks: {
+    onRetry: (attempt, error, delay) => console.log(`Retry ${attempt}...`),
+    onCircuitStateChange: (from, to) =>
+      console.log(`Breaker moved: ${from} -> ${to}`),
+  },
+})
+```
+
+## Why tryo?
+
+1. **No More Try/Catch**: Handle results as data.
+2. **Concurrency Control**: Built-in worker pool for batch operations.
+3. **Normalized Errors**: Stable codes instead of unreliable error messages.
+4. **Resiliency**: Sophisticated retry strategies and circuit breakers out of the box.
+5. **Type Safety**: Full TypeScript support with inference for custom error rules.
+
+---
+
+License: MIT

package/dist/index.cjs

@@ -0,0 +1 @@
+"use strict";var D=Object.defineProperty;var ce=Object.getOwnPropertyDescriptor;var le=Object.getOwnPropertyNames;var me=Object.prototype.hasOwnProperty;var de=(e,r,t)=>r in e?D(e,r,{enumerable:!0,configurable:!0,writable:!0,value:t}):e[r]=t;var ye=(e,r)=>{for(var t in r)D(e,t,{get:r[t],enumerable:!0})},pe=(e,r,t,n)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of le(r))!me.call(e,o)&&o!==t&&D(e,o,{get:()=>r[o],enumerable:!(n=ce(r,o))||n.enumerable});return e};var fe=e=>pe(D({},"__esModule",{value:!0}),e);var m=(e,r,t)=>de(e,typeof r!="symbol"?r+"":r,t);var Ae={};ye(Ae,{RetryStrategies:()=>X,all:()=>ne,allOrThrow:()=>oe,asConcurrencyLimit:()=>B,asMilliseconds:()=>C,asPercentage:()=>J,asRetryCount:()=>R,asStatusCode:()=>K,errorRule:()=>G,orThrow:()=>te,run:()=>ee,runOrThrow:()=>re,tryo:()=>z});module.exports=fe(Ae);var T=class extends Error{constructor(t,n){var o;super(t);m(this,"cause");m(this,"meta");m(this,"status");m(this,"timestamp");m(this,"retryable");this.timestamp=Date.now(),this.retryable=(o=n==null?void 0:n.retryable)!=null?o:!0,this.name=this.constructor.name,this.cause=n==null?void 0:n.cause,this.meta=n==null?void 0:n.meta,this.status=n==null?void 0:n.status,Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)}is(t){return this.code===t}withMeta(t){return Object.assign(this,{meta:t})}withStatus(t){return Object.assign(this,{status:t})}withCause(t){return Object.assign(this,{cause:t})}withRetryable(t){return this.retryable=t,this}toJSON(){return{name:this.name,code:this.code,message:this.message,timestamp:this.timestamp,retryable:this.retryable,cause:this.cause,stack:this.stack}}},v=class extends T{constructor(t,n){super(`Operation timed out after ${t}ms`,{cause:n,retryable:!0});m(this,"code","TIMEOUT")}};var A=class extends T{constructor(t,n){super(`Circuit breaker is open, reset after ${t}ms`,{cause:n,retryable:!1});m(this,"code","CIRCUIT_OPEN")}},I=class extends T{constructor(t,n,o){super(t,{cause:o,meta:{validationErrors:n},retryable:!1});this.validationErrors=n;m(this,"code","VALIDATION")}};var F=class extends T{constructor(t,n){super(t,{cause:n});m(this,"code","UNKNOWN")}};var C=e=>{if(e<0||!Number.isFinite(e))throw new Error(`Invalid milliseconds: must be a non-negative finite number, got ${e}`);return e},R=e=>{if(e<0||!Number.isInteger(e))throw new Error(`Invalid retry count: must be a non-negative integer, got ${e}`);return e},B=e=>{if(e<1||!Number.isInteger(e))throw new Error(`Invalid concurrency limit: must be a positive integer, got ${e}`);return e},J=e=>{if(e<0||e>100||!Number.isFinite(e))throw new Error(`Invalid percentage: must be between 0 and 100, got ${e}`);return e},K=e=>{if(!Number.isInteger(e)||e<100||e>599)throw new Error(`Invalid status code: must be an integer between 100-599, got ${e}`);return e};var L=class{constructor(r){m(this,"state");m(this,"config");this.config={failureThreshold:R(r.failureThreshold),resetTimeout:C(r.resetTimeout),halfOpenRequests:R(r.halfOpenRequests),shouldCountAsFailure:r.shouldCountAsFailure},this.state={state:"closed",failureCount:0,halfOpenCount:0}}async canExecute(){if(this.updateStateIfNeeded(),this.state.state==="open")return!1;if(this.state.state==="half-open"){if(this.state.halfOpenCount>=this.config.halfOpenRequests)return!1;this.state={...this.state,halfOpenCount:this.state.halfOpenCount+1}}return!0}async recordSuccess(){switch(this.state.state){case"closed":this.state={...this.state,failureCount:0};break;case"half-open":this.state={state:"closed",failureCount:0,halfOpenCount:0};break;case"open":break}}async recordFailure(r){var o,a,i;if(!((i=(a=(o=this.config).shouldCountAsFailure)==null?void 0:a.call(o,r))!=null?i:!0))return;let n=new Date;switch(this.state.state){case"closed":{let s=this.state.failureCount+1;s>=this.config.failureThreshold?this.state={state:"open",failureCount:s,halfOpenCount:0,lastFailureTime:n,nextAttemptTime:new Date(n.getTime()+this.config.resetTimeout)}:this.state={...this.state,failureCount:s,lastFailureTime:n};break}case"half-open":this.state={state:"open",failureCount:this.state.failureCount+1,halfOpenCount:0,lastFailureTime:n,nextAttemptTime:new Date(n.getTime()+this.config.resetTimeout)};break;case"open":this.state={...this.state,lastFailureTime:n,nextAttemptTime:new Date(n.getTime()+this.config.resetTimeout)};break}}getState(){return this.updateStateIfNeeded(),{...this.state,canExecute:this.state.state!=="open"}}createOpenError(){let r=this.state.nextAttemptTime?C(Math.max(0,this.state.nextAttemptTime.getTime()-Date.now())):this.config.resetTimeout;return new A(r)}forceState(r){this.state={state:r,failureCount:0,halfOpenCount:0}}reset(){this.state={state:"closed",failureCount:0,halfOpenCount:0}}updateStateIfNeeded(){this.state.state==="open"&&this.state.nextAttemptTime&&new Date>=this.state.nextAttemptTime&&(this.state={...this.state,state:"half-open",halfOpenCount:0})}};var q=(e,r)=>t=>{for(let n of e){let o=n(t);if(o!==null)return o}return r(t)},Y=e=>r=>r instanceof T?r:r instanceof Error?new e(r.message,r):typeof r=="string"?new e(r):new e("Unknown error occurred",r);var Te=e=>{if(typeof e!="object"||e===null)return!1;let r=e;return typeof r.status=="number"||typeof r.statusCode=="number"},Ee=e=>{if(typeof e!="object"||e===null)return!1;let r=e;return typeof r.code=="string"&&r.code.length>0},we=e=>{var r;if(e instanceof Error){if(e.name==="TypeError")return!0;let t=e.message.toLowerCase();if(t.includes("fetch")&&t.includes("failed")||t.includes("network"))return!0}if(Ee(e)){let t=((r=e.code)!=null?r:"").toUpperCase();return t==="ECONNRESET"||t==="ECONNREFUSED"||t==="ETIMEDOUT"||t==="ENOTFOUND"||t==="EAI_AGAIN"}return!1},U=class{constructor(r){this.predicate=r}toCode(r){return new _(this.predicate,r)}toError(r){return t=>{if(!this.predicate(t))return null;let n=r(t),o=n.code;class a extends T{constructor(){var u;super(n.message,{cause:(u=n.cause)!=null?u:t,meta:n.meta,status:n.status,retryable:n.retryable});m(this,"code",o)}}return new a}}},_=class{constructor(r,t){this.predicate=r;this.errorCode=t}with(r){return t=>{if(!this.predicate(t))return null;let n=r(t),o=this.errorCode;class a extends T{constructor(){super(n.message,{cause:n.cause,meta:n.meta,status:n.status,retryable:n.retryable});m(this,"code",o)}}return new a}}},E={when:e=>new U(e),instance:e=>new U(r=>r instanceof e),code:e=>({for:r=>new _(r,e)}),string:(e,r)=>({when:t=>E.when(t).toCode(r).with(n=>({message:n===e?e:`${r}: ${n}`,cause:n}))}),httpStatus:(e,r)=>({for:t=>E.when(t).toCode(r!=null?r:`HTTP_${e}`).with(n=>({message:`HTTP ${e} error`,cause:n}))})};var w={typed:(e=>e instanceof T?e:null),abort:E.when(e=>e instanceof DOMException&&e.name==="AbortError").toCode("ABORTED").with(e=>({message:e.message||"Operation was aborted",cause:e,retryable:!1})),timeout:E.when(e=>e instanceof Error&&e.name==="TimeoutError").toCode("TIMEOUT").with(e=>({message:e.message||"Operation timed out",cause:e})),network:E.when(e=>we(e)).toCode("NETWORK").with(e=>({message:(e instanceof Error,e.message||"Network error"),cause:e})),http:E.when(e=>{var n;if(!Te(e))return!1;let r=e,t=(n=r.status)!=null?n:r.statusCode;return typeof t=="number"&&t>=400}).toCode("HTTP").with(e=>{var n;let r=(n=e.status)!=null?n:e.statusCode,t=typeof r=="number"&&(r>=500||r===429);return{message:e.message||`HTTP ${r!=null?r:"error"} error`,cause:e,status:typeof r=="number"?r:void 0,retryable:t}}),unknown:E.when(e=>e instanceof Error&&!(e instanceof T)).toCode("UNKNOWN").with(e=>({message:e.message||"Unknown error occurred",cause:e}))};var be=[w.typed,w.abort,w.timeout,w.http,w.network,w.unknown];var G={when:e=>E.when(e),instance:e=>E.instance(e)},Q=be,He=w.timeout,Ve=w.abort,We=w.network,Je=w.http,Ke=E.when(e=>e instanceof A).toCode("CIRCUIT_OPEN").with(e=>({message:e.message,cause:e})),qe=E.when(e=>e instanceof I).toCode("VALIDATION").with(e=>({message:e.message,cause:e}));var X={fixed:e=>({type:"fixed",delay:e}),exponential:(e,r=2,t)=>({type:"exponential",base:e,factor:r,maxDelay:t}),fibonacci:(e,r)=>({type:"fibonacci",base:e,maxDelay:r}),custom:e=>({type:"custom",calculate:e})},Z=(e,r,t)=>{switch(e.type){case"fixed":return e.delay;case"exponential":{let n=e.base*e.factor**(Number(r)-1);return e.maxDelay?Math.min(n,e.maxDelay):n}case"fibonacci":{let n=e.base*he(Number(r));return e.maxDelay?Math.min(n,e.maxDelay):n}case"custom":return e.calculate(r,t);default:return e}},he=e=>{if(e<=1)return 1;let r=1,t=1;for(let n=2;n<=e;n++){let o=r+t;r=t,t=o}return t};var j=(e,r)=>new Promise((t,n)=>{if(r!=null&&r.aborted){n(new DOMException("Aborted","AbortError"));return}let o=s=>{r&&s&&r.removeEventListener("abort",s)},a,i=()=>{a&&clearTimeout(a),o(i),n(new DOMException("Aborted","AbortError"))};a=setTimeout(()=>{o(i),t()},e),r==null||r.addEventListener("abort",i,{once:!0})});var Ce=e=>{var i,s,u;if(e.toError)return e.toError;let r=(i=e.rulesMode)!=null?i:"extend",t=(s=e.rules)!=null?s:[],n=Q,o=(u=e.fallback)!=null?u:(c=>Y(F)(c)),a=r==="replace"?t:[...t,...n];return q(a,o)},H=class e{constructor(r={}){m(this,"circuitBreaker");m(this,"config");m(this,"lastCircuitState");let{rules:t,rulesMode:n,fallback:o,toError:a,mapError:i,...s}=r,u=Ce(r),c={...s,errorHandling:{normalizer:u,mapError:i}};this.config=c,c.circuitBreaker&&(this.circuitBreaker=new L(c.circuitBreaker),this.lastCircuitState=this.circuitBreaker.getState().state)}async run(r,t={}){var a,i,s,u,c,b;let n={...this.config,...t};if(this.circuitBreaker){let l=(a=this.lastCircuitState)!=null?a:this.circuitBreaker.getState().state,y=await this.circuitBreaker.canExecute(),p=this.circuitBreaker.getState().state;if(l!==p)try{(s=(i=n.hooks)==null?void 0:i.onCircuitStateChange)==null||s.call(i,l,p)}catch{}if(this.lastCircuitState=p,!y)return{type:"failure",ok:!1,data:null,error:this.circuitBreaker.createOpenError(),metrics:{totalAttempts:0,totalRetries:0,totalDuration:0,retryHistory:[]}}}let o=await xe(r,n);if(this.circuitBreaker){let l=(u=this.lastCircuitState)!=null?u:this.circuitBreaker.getState().state;o.ok?await this.circuitBreaker.recordSuccess():await this.circuitBreaker.recordFailure(o.error);let y=this.circuitBreaker.getState().state;if(l!==y)try{(b=(c=n.hooks)==null?void 0:c.onCircuitStateChange)==null||b.call(c,l,y)}catch{}this.lastCircuitState=y}return o}async runOrThrow(r,t={}){let n=await this.run(r,t);if(n.ok)return n.data;throw n.error}async orThrow(r,t={}){let n=await this.run(r,t);if(n.ok)return n.data;throw n.error}async all(r,t={}){var b;let n={...this.config,...t},o=(b=n.concurrency)!=null?b:Number.POSITIVE_INFINITY,a=Number.isFinite(o)?Number(B(o)):Number.POSITIVE_INFINITY,i=new Array(r.length),s=0,u=async()=>{var l;for(;s<r.length&&!((l=n.signal)!=null&&l.aborted);){let y=s++;if(y>=r.length)break;let p=r[y];p&&(i[y]=await this.run(p,n))}},c=Array.from({length:Math.min(a,r.length)},()=>u());await Promise.all(c);for(let l=0;l<r.length;l++)if(!(l in i)){let y=r[l];y&&(i[l]=await this.run(y,n))}return i}async allOrThrow(r,t={}){let n=await this.all(r,t);for(let o of n)if(!o.ok)throw o.error;return n.map(o=>{if(!o.ok)throw o.error;return o.data})}partitionAll(r){let t=[],n=[],o=[],a=[],i=[];for(let s of r){if(s.type==="success"){t.push(s);continue}switch(n.push(s),s.type){case"failure":o.push(s);break;case"aborted":a.push(s);break;case"timeout":i.push(s);break}}return{ok:t,errors:n,failure:o,aborted:a,timeout:i}}getCircuitBreakerState(){var r;return(r=this.circuitBreaker)==null?void 0:r.getState()}resetCircuitBreaker(){var r;(r=this.circuitBreaker)==null||r.reset()}getConfig(){return{...this.config}}withConfig(r){var u,c;let{errorHandling:t,...n}=this.config,{errorHandling:o,...a}=r,i=(u=o==null?void 0:o.normalizer)!=null?u:t.normalizer,s=(c=o==null?void 0:o.mapError)!=null?c:t.mapError;return new e({...n,...a,toError:i,mapError:s})}withErrorType(r={}){return new e(r)}};function z(e={}){let r=new H(e);return{run:(t,n)=>r.run(t,n),orThrow:(t,n)=>r.orThrow(t,n),runOrThrow:(t,n)=>r.runOrThrow(t,n),all:(t,n)=>r.all(t,n),allOrThrow:(t,n)=>r.allOrThrow(t,n),partitionAll:t=>r.partitionAll(t),withConfig:t=>r.withConfig(t)}}async function xe(e,r){let{signal:t,ignoreAbort:n=!0,timeout:o,retry:a,errorHandling:i,hooks:s,logger:u}=r,c=(g,...d)=>{try{g==null||g(...d)}catch{}},b,l=0,y=0,p=[],k=Date.now(),{signal:x,cleanup:se}=Re(t);try{if(x.aborted){c(s==null?void 0:s.onAbort,x);let d=i.normalizer(new DOMException("Aborted","AbortError")),f=i.mapError?i.mapError(d):d;return{type:"aborted",ok:!1,data:null,error:f,metrics:{totalAttempts:l,totalRetries:y,totalDuration:Date.now()-k,lastError:f,retryHistory:p}}}let g=async d=>{var f,P,O;l=d;try{let M=e({signal:x}),S=o?await ke(M,o,x):await M;return c(s==null?void 0:s.onSuccess,S),c(u==null?void 0:u.info,`Task succeeded on attempt ${d}`),S}catch(M){let S=i.normalizer(M),h=i.mapError?i.mapError(S):S;b=h,h.code==="ABORTED"&&c(s==null?void 0:s.onAbort,x),n&&h.code==="ABORTED"||(c(s==null?void 0:s.onError,h),c(u==null?void 0:u.error,`Task failed on attempt ${d}`,h));let ae=R((f=a==null?void 0:a.maxRetries)!=null?f:0);if(d<=Number(ae)){let V=a==null?void 0:a.shouldRetry,ie={totalAttempts:Number(l),elapsedTime:Date.now()-k,startTime:new Date(k),lastDelay:(P=p[p.length-1])!=null&&P.delay?Number((O=p[p.length-1])==null?void 0:O.delay):void 0};if(!V||V(d,h,ie)){let ue=a?Z(a.strategy,d,h):0,$=ge(ue,a==null?void 0:a.jitter),W=C($);return p.push({attempt:d,error:h,delay:W,timestamp:new Date}),c(s==null?void 0:s.onRetry,d,h,$),c(u==null?void 0:u.info,`Retrying in ${$}ms (attempt ${d+1})`),await j(W,x),g(d+1)}}throw h}};try{let d=await g(1);y=l>0?Number(l)-1:0;let f={totalAttempts:l,totalRetries:y,totalDuration:Date.now()-k,retryHistory:p};return c(s==null?void 0:s.onFinally,f),{type:"success",ok:!0,data:d,error:null,metrics:f}}catch(d){let f=b!=null?b:i.normalizer(d),P=f.code==="TIMEOUT"?"timeout":f.code==="ABORTED"?"aborted":"failure";y=l>0?Number(l)-1:0;let O={totalAttempts:l,totalRetries:y,totalDuration:Date.now()-k,lastError:f,retryHistory:p};return c(s==null?void 0:s.onFinally,O),{type:P,ok:!1,data:null,error:f,metrics:O}}}finally{se()}}function Re(e){let r=new AbortController;if(!e)return{signal:r.signal,cleanup:()=>{}};let t=()=>r.abort();return e.aborted?(t(),{signal:r.signal,cleanup:()=>{}}):(e.addEventListener("abort",t,{once:!0}),{signal:r.signal,cleanup:()=>e.removeEventListener("abort",t)})}async function ke(e,r,t){return new Promise((n,o)=>{if(t!=null&&t.aborted){o(new DOMException("Aborted","AbortError"));return}let a=!1,i=setTimeout(()=>{a=!0,u(),o(new v(C(r)))},r),s=()=>{a||(a=!0,u(),o(new DOMException("Aborted","AbortError")))},u=()=>{clearTimeout(i),t==null||t.removeEventListener("abort",s)};t==null||t.addEventListener("abort",s,{once:!0}),e.then(c=>{a||(a=!0,u(),n(c))},c=>{a||(a=!0,u(),o(c))})})}function ge(e,r){if(!r||r.type==="none"||e<=0)return e;switch(r.type){case"full":{let t=Number(r.ratio)/100,n=Math.max(0,Number(e)*(1-t)),o=Number(e);return n+Math.random()*(o-n)}case"equal":{let t=Number(r.ratio)/100,n=Number(e)*t/2;return Number(e)-n+Math.random()*n}case"custom":return r.calculate(e);default:return r}}var N=z(),ee=N.run,re=N.runOrThrow,te=N.orThrow,ne=N.all,oe=N.allOrThrow;0&&(module.exports={RetryStrategies,all,allOrThrow,asConcurrencyLimit,asMilliseconds,asPercentage,asRetryCount,asStatusCode,errorRule,orThrow,run,runOrThrow,tryo});

package/dist/index.d.cts

@@ -0,0 +1,395 @@
+/**
+ * Branded types for enhanced type safety and runtime validation
+ * These provide compile-time guarantees while maintaining runtime checks
+ */
+type Milliseconds = number & {
+    readonly __brand: 'Milliseconds';
+};
+type RetryCount = number & {
+    readonly __brand: 'RetryCount';
+};
+type ConcurrencyLimit = number & {
+    readonly __brand: 'ConcurrencyLimit';
+};
+type Percentage = number & {
+    readonly __brand: 'Percentage';
+};
+type StatusCode = number & {
+    readonly __brand: 'StatusCode';
+};
+declare const asMilliseconds: (n: number) => Milliseconds;
+declare const asRetryCount: (n: number) => RetryCount;
+declare const asConcurrencyLimit: (n: number) => ConcurrencyLimit;
+declare const asPercentage: (n: number) => Percentage;
+declare const asStatusCode: (n: number) => StatusCode;
+
+/**
+ * Modern typed error hierarchy with enhanced capabilities
+ * Provides type-safe error handling with fluent API and metadata support
+ */
+
+declare abstract class TypedError<Code extends string = string, Meta = unknown> extends Error {
+    abstract readonly code: Code;
+    readonly cause?: unknown;
+    readonly meta?: Meta;
+    readonly status?: number;
+    readonly timestamp: number;
+    readonly retryable: boolean;
+    constructor(message: string, opts?: {
+        cause?: unknown;
+        meta?: Meta;
+        status?: number;
+        retryable?: boolean;
+    });
+    is<C extends string>(code: C): this is TypedError<C> & {
+        code: C;
+    };
+    withMeta<const M>(meta: M): this & {
+        meta: M;
+    };
+    withStatus(status: number): this & {
+        status: number;
+    };
+    withCause(cause: unknown): this & {
+        cause: unknown;
+    };
+    withRetryable(retryable: boolean): this;
+    toJSON(): Record<string, unknown>;
+}
+declare class TimeoutError extends TypedError<'TIMEOUT'> {
+    readonly code: "TIMEOUT";
+    constructor(timeout: Milliseconds, cause?: unknown);
+}
+declare class AbortedError extends TypedError<'ABORTED'> {
+    readonly code: "ABORTED";
+    constructor(reason?: string, cause?: unknown);
+}
+declare class CircuitOpenError extends TypedError<'CIRCUIT_OPEN'> {
+    readonly code: "CIRCUIT_OPEN";
+    constructor(resetAfter: Milliseconds, cause?: unknown);
+}
+type ValidationMeta = {
+    validationErrors: unknown[];
+};
+declare class ValidationError extends TypedError<'VALIDATION', ValidationMeta> {
+    readonly validationErrors: unknown[];
+    readonly code: "VALIDATION";
+    constructor(message: string, validationErrors: unknown[], cause?: unknown);
+}
+declare class NetworkError extends TypedError<'NETWORK'> {
+    readonly statusCode?: number | undefined;
+    readonly code: "NETWORK";
+    constructor(message: string, statusCode?: number | undefined, cause?: unknown);
+}
+type HttpMeta = {
+    response?: unknown;
+};
+declare class HttpError extends TypedError<'HTTP', HttpMeta> {
+    readonly status: number;
+    readonly response?: unknown | undefined;
+    readonly code: "HTTP";
+    constructor(message: string, status: number, response?: unknown | undefined, cause?: unknown);
+}
+declare class UnknownError extends TypedError<'UNKNOWN'> {
+    readonly code: "UNKNOWN";
+    constructor(message: string, cause?: unknown);
+}
+
+/**
+ * Modern circuit breaker implementation with enhanced state management
+ * Provides circuit breaker pattern with type safety and observability
+ */
+
+interface CircuitBreakerConfig<E extends TypedError = TypedError> {
+    /** Number of consecutive failures before opening circuit */
+    readonly failureThreshold: number;
+    /** How long to wait before attempting to close circuit */
+    readonly resetTimeout: number;
+    /** Number of requests allowed in half-open state */
+    readonly halfOpenRequests: number;
+    /** Optional function to determine if error should count as failure */
+    readonly shouldCountAsFailure?: (error: E) => boolean;
+}
+
+/**
+ * Modern error normalization system
+ * Provides type-safe error transformation and normalization
+ */
+
+type ErrorNormalizer<E extends TypedError = TypedError> = (error: unknown) => E;
+type ErrorRule<E extends TypedError = TypedError> = (error: unknown) => E | null;
+
+/**
+ * Modern result types with enhanced discriminated unions
+ * Provides better type safety and more granular result categorization
+ */
+
+type TryoResult<T, E extends TypedError = TypedError> = SuccessResult<T, E> | FailureResult<E> | AbortedResult<E> | TimeoutResult<E>;
+interface SuccessResult<T, E extends TypedError> {
+    readonly type: 'success';
+    readonly ok: true;
+    readonly data: T;
+    readonly error: null;
+    readonly metrics?: TryoMetrics$1<E>;
+}
+interface FailureResult<E extends TypedError> {
+    readonly type: 'failure';
+    readonly ok: false;
+    readonly data: null;
+    readonly error: E;
+    readonly metrics?: TryoMetrics$1<E>;
+}
+interface AbortedResult<E extends TypedError> {
+    readonly type: 'aborted';
+    readonly ok: false;
+    readonly data: null;
+    readonly error: E;
+    readonly metrics?: TryoMetrics$1<E>;
+}
+interface TimeoutResult<E extends TypedError> {
+    readonly type: 'timeout';
+    readonly ok: false;
+    readonly data: null;
+    readonly error: E;
+    readonly metrics?: TryoMetrics$1<E>;
+}
+interface TryoMetrics$1<E extends TypedError> {
+    readonly totalAttempts: RetryCount;
+    readonly totalRetries: RetryCount;
+    readonly totalDuration: Milliseconds;
+    readonly lastError?: E;
+    readonly retryHistory: Array<{
+        readonly attempt: RetryCount;
+        readonly error: E;
+        readonly delay: Milliseconds;
+        readonly timestamp: Date;
+    }>;
+}
+
+/**
+ * Modern retry strategies with enhanced capabilities
+ * Provides various retry patterns with type safety
+ */
+
+type RetryStrategy = FixedDelayStrategy | ExponentialBackoffStrategy | FibonacciBackoffStrategy | CustomDelayStrategy;
+interface FixedDelayStrategy {
+    readonly type: 'fixed';
+    readonly delay: number;
+}
+interface ExponentialBackoffStrategy {
+    readonly type: 'exponential';
+    readonly base: number;
+    readonly factor: number;
+    readonly maxDelay?: number;
+}
+interface FibonacciBackoffStrategy {
+    readonly type: 'fibonacci';
+    readonly base: number;
+    readonly maxDelay?: number;
+}
+interface CustomDelayStrategy {
+    readonly type: 'custom';
+    readonly calculate: (attempt: RetryCount, error: unknown) => number;
+}
+declare const RetryStrategies: {
+    readonly fixed: (delay: number) => FixedDelayStrategy;
+    readonly exponential: (base: number, factor?: number, maxDelay?: number) => ExponentialBackoffStrategy;
+    readonly fibonacci: (base: number, maxDelay?: number) => FibonacciBackoffStrategy;
+    readonly custom: (calculate: (attempt: RetryCount, error: unknown) => number) => CustomDelayStrategy;
+};
+
+interface TryoConfig<E extends TypedError = TypedError> {
+    /** Abort signal passed to tasks */
+    readonly signal?: AbortSignal;
+    /** If true, aborts are treated as non-throwing failures */
+    readonly ignoreAbort?: boolean;
+    /** Timeout configuration */
+    readonly timeout?: number;
+    /** Retry configuration */
+    readonly retry?: RetryConfig<E>;
+    /** Circuit breaker configuration */
+    readonly circuitBreaker?: CircuitBreakerConfig<E>;
+    /** Error handling configuration */
+    readonly errorHandling: ErrorHandlingConfig<E>;
+    /** Concurrency configuration for batch operations */
+    readonly concurrency?: number;
+    /** Logging configuration */
+    readonly logger?: LoggerConfig<E>;
+    /** Callback hooks */
+    readonly hooks?: HookConfig<E>;
+}
+interface RetryConfig<E extends TypedError> {
+    /** Maximum number of retry attempts */
+    readonly maxRetries: number;
+    /** Base delay strategy */
+    readonly strategy: RetryStrategy;
+    /** Jitter configuration to prevent thundering herd */
+    readonly jitter?: JitterConfig;
+    /** Function to determine if retry should be attempted */
+    readonly shouldRetry?: ShouldRetryPredicate<E>;
+}
+type ShouldRetryPredicate<E extends TypedError> = (attempt: number, error: E, context: RetryContext) => boolean;
+interface RetryContext {
+    /** Total attempts made so far */
+    readonly totalAttempts: number;
+    /** Elapsed time since start */
+    readonly elapsedTime: number;
+    /** Start timestamp */
+    readonly startTime: Date;
+    /** Last delay applied */
+    readonly lastDelay?: number;
+}
+interface ErrorHandlingConfig<E extends TypedError> {
+    /** Error normalizer function */
+    readonly normalizer: ErrorNormalizer<E>;
+    /** Optional error mapping/transformation */
+    readonly mapError?: (error: E) => E;
+}
+interface LoggerConfig<E extends TypedError> {
+    /** Debug logging function */
+    readonly debug?: (message: string, meta?: unknown) => void;
+    /** Error logging function */
+    readonly error?: (message: string, error: E) => void;
+    /** Info logging function */
+    readonly info?: (message: string, meta?: unknown) => void;
+    /** Warning logging function */
+    readonly warn?: (message: string, meta?: unknown) => void;
+}
+interface HookConfig<E extends TypedError> {
+    /** Called on successful execution */
+    readonly onSuccess?: <T>(data: T, metrics?: TryoMetrics<E>) => void;
+    /** Called on failed execution */
+    readonly onError?: (error: E, metrics?: TryoMetrics<E>) => void;
+    /** Called always, success or failure */
+    readonly onFinally?: (metrics?: TryoMetrics<E>) => void;
+    /** Called on abort */
+    readonly onAbort?: (signal: AbortSignal) => void;
+    /** Called before retry attempt */
+    readonly onRetry?: (attempt: number, error: E, delay: number) => void;
+    /** Called when circuit breaker state changes */
+    readonly onCircuitStateChange?: (from: CircuitState, to: CircuitState) => void;
+}
+type CircuitState = 'closed' | 'open' | 'half-open';
+type TryoMetrics<E extends TypedError> = TryoMetrics$1<E>;
+type JitterConfig = {
+    type: 'none';
+} | {
+    type: 'full';
+    ratio: number;
+} | {
+    type: 'equal';
+    ratio: number;
+} | {
+    type: 'custom';
+    calculate: (delay: number) => number;
+};
+declare const JitterConfig: {
+    readonly none: () => JitterConfig;
+    readonly full: (ratio?: number) => JitterConfig;
+    readonly equal: (ratio?: number) => JitterConfig;
+    readonly custom: (calculate: (delay: number) => number) => JitterConfig;
+};
+
+type RulesMode = 'extend' | 'replace';
+type DefaultError = AbortedError | TimeoutError | NetworkError | HttpError | CircuitOpenError | ValidationError | UnknownError;
+type NonNull<T> = T extends null ? never : T;
+type RuleReturn<R> = R extends (err: unknown) => infer Out ? NonNull<Out> : never;
+type InferErrorFromRules<TRules extends readonly ErrorRule<TypedError>[]> = TRules extends readonly [] ? TypedError : RuleReturn<TRules[number]> | UnknownError;
+type TryoOptions<E extends TypedError = TypedError> = Omit<Partial<TryoConfig<E>>, 'errorHandling' | 'signal'> & {
+    rules?: Array<ErrorRule<E>>;
+    rulesMode?: RulesMode;
+    fallback?: (err: unknown) => E;
+    toError?: (err: unknown) => E;
+    mapError?: (error: E) => E;
+};
+declare function tryo<const TRules extends readonly ErrorRule<TypedError>[]>(options: Omit<TryoOptions<InferErrorFromRules<TRules>>, 'rules'> & {
+    rules: TRules;
+}): Tryo<InferErrorFromRules<TRules>>;
+declare function tryo<E extends TypedError = DefaultError>(options?: TryoOptions<E>): Tryo<E>;
+type Tryo<E extends TypedError = TypedError> = {
+    run: <T>(task: (ctx: {
+        signal: AbortSignal;
+    }) => Promise<T>, options?: Partial<TryoConfig<E>>) => Promise<TryoResult<T, E>>;
+    runOrThrow: <T>(task: (ctx: {
+        signal: AbortSignal;
+    }) => Promise<T>, options?: Partial<TryoConfig<E>>) => Promise<T>;
+    orThrow: <T>(task: (ctx: {
+        signal: AbortSignal;
+    }) => Promise<T>, options?: Partial<TryoConfig<E>>) => Promise<T>;
+    all: <T>(tasks: Array<(ctx: {
+        signal: AbortSignal;
+    }) => Promise<T>>, options?: Partial<TryoConfig<E> & {
+        concurrency?: number;
+    }>) => Promise<Array<TryoResult<T, E>>>;
+    allOrThrow: <T>(tasks: Array<(ctx: {
+        signal: AbortSignal;
+    }) => Promise<T>>, options?: Partial<TryoConfig<E> & {
+        concurrency?: number;
+    }>) => Promise<T[]>;
+    partitionAll: <T>(results: Array<TryoResult<T, E>>) => {
+        ok: Array<SuccessResult<T, E>>;
+        errors: Array<FailureResult<E> | AbortedResult<E> | TimeoutResult<E>>;
+        failure: Array<FailureResult<E>>;
+        aborted: Array<AbortedResult<E>>;
+        timeout: Array<TimeoutResult<E>>;
+    };
+    withConfig: (additionalConfig: Omit<Partial<TryoConfig<E>>, 'signal'>) => Tryo<E>;
+};
+
+declare const run: <T>(task: (ctx: {
+    signal: AbortSignal;
+}) => Promise<T>, options?: Partial<TryoConfig<DefaultError>> | undefined) => Promise<TryoResult<T, DefaultError>>;
+declare const runOrThrow: <T>(task: (ctx: {
+    signal: AbortSignal;
+}) => Promise<T>, options?: Partial<TryoConfig<DefaultError>> | undefined) => Promise<T>;
+declare const orThrow: <T>(task: (ctx: {
+    signal: AbortSignal;
+}) => Promise<T>, options?: Partial<TryoConfig<DefaultError>> | undefined) => Promise<T>;
+declare const all: <T>(tasks: ((ctx: {
+    signal: AbortSignal;
+}) => Promise<T>)[], options?: Partial<TryoConfig<DefaultError> & {
+    concurrency?: number;
+}> | undefined) => Promise<TryoResult<T, DefaultError>[]>;
+declare const allOrThrow: <T>(tasks: ((ctx: {
+    signal: AbortSignal;
+}) => Promise<T>)[], options?: Partial<TryoConfig<DefaultError> & {
+    concurrency?: number;
+}> | undefined) => Promise<T[]>;
+
+/**
+ * Modern fluent error rule builder
+ * Provides type-safe error rule creation with enhanced ergonomics
+ */
+
+declare class ErrorRuleBuilder<T> {
+    private readonly predicate;
+    constructor(predicate: (err: unknown) => err is T);
+    toCode<const C extends string>(code: C): ErrorMapper<T, C>;
+    toError<const Out extends {
+        code: string;
+        message: string;
+        meta?: unknown;
+        status?: number;
+        cause?: unknown;
+        retryable?: boolean;
+    }>(mapper: (err: T) => Out): ErrorRule<TypedError<Out['code'], Out['meta']>>;
+}
+declare class ErrorMapper<T, C extends string> {
+    private readonly predicate;
+    private readonly errorCode;
+    constructor(predicate: (err: unknown) => err is T, errorCode: C);
+    with<const M = unknown>(mapper: (err: T) => {
+        message: string;
+        cause?: unknown;
+        meta?: M;
+        status?: number;
+        retryable?: boolean;
+    }): (err: unknown) => TypedError<C, M> | null;
+}
+
+declare const errorRule: {
+    readonly when: <T>(predicate: (err: unknown) => err is T) => ErrorRuleBuilder<T>;
+    readonly instance: <T extends new (...args: unknown[]) => unknown>(ErrorClass: T) => ErrorRuleBuilder<InstanceType<T>>;
+};
+
+export { type AbortedResult, type ConcurrencyLimit, type FailureResult, type Milliseconds, type Percentage, type RetryCount, RetryStrategies, type RulesMode, type StatusCode, type SuccessResult, type TimeoutResult, type TryoConfig, type TryoMetrics$1 as TryoMetrics, type TryoOptions, type TryoResult, all, allOrThrow, asConcurrencyLimit, asMilliseconds, asPercentage, asRetryCount, asStatusCode, errorRule, orThrow, run, runOrThrow, tryo };

package/dist/index.d.ts

@@ -0,0 +1,395 @@
+/**
+ * Branded types for enhanced type safety and runtime validation
+ * These provide compile-time guarantees while maintaining runtime checks
+ */
+type Milliseconds = number & {
+    readonly __brand: 'Milliseconds';
+};
+type RetryCount = number & {
+    readonly __brand: 'RetryCount';
+};
+type ConcurrencyLimit = number & {
+    readonly __brand: 'ConcurrencyLimit';
+};
+type Percentage = number & {
+    readonly __brand: 'Percentage';
+};
+type StatusCode = number & {
+    readonly __brand: 'StatusCode';
+};
+declare const asMilliseconds: (n: number) => Milliseconds;
+declare const asRetryCount: (n: number) => RetryCount;
+declare const asConcurrencyLimit: (n: number) => ConcurrencyLimit;
+declare const asPercentage: (n: number) => Percentage;
+declare const asStatusCode: (n: number) => StatusCode;
+
+/**
+ * Modern typed error hierarchy with enhanced capabilities
+ * Provides type-safe error handling with fluent API and metadata support
+ */
+
+declare abstract class TypedError<Code extends string = string, Meta = unknown> extends Error {
+    abstract readonly code: Code;
+    readonly cause?: unknown;
+    readonly meta?: Meta;
+    readonly status?: number;
+    readonly timestamp: number;
+    readonly retryable: boolean;
+    constructor(message: string, opts?: {
+        cause?: unknown;
+        meta?: Meta;
+        status?: number;
+        retryable?: boolean;
+    });
+    is<C extends string>(code: C): this is TypedError<C> & {
+        code: C;
+    };
+    withMeta<const M>(meta: M): this & {
+        meta: M;
+    };
+    withStatus(status: number): this & {
+        status: number;
+    };
+    withCause(cause: unknown): this & {
+        cause: unknown;
+    };
+    withRetryable(retryable: boolean): this;
+    toJSON(): Record<string, unknown>;
+}
+declare class TimeoutError extends TypedError<'TIMEOUT'> {
+    readonly code: "TIMEOUT";
+    constructor(timeout: Milliseconds, cause?: unknown);
+}
+declare class AbortedError extends TypedError<'ABORTED'> {
+    readonly code: "ABORTED";
+    constructor(reason?: string, cause?: unknown);
+}
+declare class CircuitOpenError extends TypedError<'CIRCUIT_OPEN'> {
+    readonly code: "CIRCUIT_OPEN";
+    constructor(resetAfter: Milliseconds, cause?: unknown);
+}
+type ValidationMeta = {
+    validationErrors: unknown[];
+};
+declare class ValidationError extends TypedError<'VALIDATION', ValidationMeta> {
+    readonly validationErrors: unknown[];
+    readonly code: "VALIDATION";
+    constructor(message: string, validationErrors: unknown[], cause?: unknown);
+}
+declare class NetworkError extends TypedError<'NETWORK'> {
+    readonly statusCode?: number | undefined;
+    readonly code: "NETWORK";
+    constructor(message: string, statusCode?: number | undefined, cause?: unknown);
+}
+type HttpMeta = {
+    response?: unknown;
+};
+declare class HttpError extends TypedError<'HTTP', HttpMeta> {
+    readonly status: number;
+    readonly response?: unknown | undefined;
+    readonly code: "HTTP";
+    constructor(message: string, status: number, response?: unknown | undefined, cause?: unknown);
+}
+declare class UnknownError extends TypedError<'UNKNOWN'> {
+    readonly code: "UNKNOWN";
+    constructor(message: string, cause?: unknown);
+}
+
+/**
+ * Modern circuit breaker implementation with enhanced state management
+ * Provides circuit breaker pattern with type safety and observability
+ */
+
+interface CircuitBreakerConfig<E extends TypedError = TypedError> {
+    /** Number of consecutive failures before opening circuit */
+    readonly failureThreshold: number;
+    /** How long to wait before attempting to close circuit */
+    readonly resetTimeout: number;
+    /** Number of requests allowed in half-open state */
+    readonly halfOpenRequests: number;
+    /** Optional function to determine if error should count as failure */
+    readonly shouldCountAsFailure?: (error: E) => boolean;
+}
+
+/**
+ * Modern error normalization system
+ * Provides type-safe error transformation and normalization
+ */
+
+type ErrorNormalizer<E extends TypedError = TypedError> = (error: unknown) => E;
+type ErrorRule<E extends TypedError = TypedError> = (error: unknown) => E | null;
+
+/**
+ * Modern result types with enhanced discriminated unions
+ * Provides better type safety and more granular result categorization
+ */
+
+type TryoResult<T, E extends TypedError = TypedError> = SuccessResult<T, E> | FailureResult<E> | AbortedResult<E> | TimeoutResult<E>;
+interface SuccessResult<T, E extends TypedError> {
+    readonly type: 'success';
+    readonly ok: true;
+    readonly data: T;
+    readonly error: null;
+    readonly metrics?: TryoMetrics$1<E>;
+}
+interface FailureResult<E extends TypedError> {
+    readonly type: 'failure';
+    readonly ok: false;
+    readonly data: null;
+    readonly error: E;
+    readonly metrics?: TryoMetrics$1<E>;
+}
+interface AbortedResult<E extends TypedError> {
+    readonly type: 'aborted';
+    readonly ok: false;
+    readonly data: null;
+    readonly error: E;
+    readonly metrics?: TryoMetrics$1<E>;
+}
+interface TimeoutResult<E extends TypedError> {
+    readonly type: 'timeout';
+    readonly ok: false;
+    readonly data: null;
+    readonly error: E;
+    readonly metrics?: TryoMetrics$1<E>;
+}
+interface TryoMetrics$1<E extends TypedError> {
+    readonly totalAttempts: RetryCount;
+    readonly totalRetries: RetryCount;
+    readonly totalDuration: Milliseconds;
+    readonly lastError?: E;
+    readonly retryHistory: Array<{
+        readonly attempt: RetryCount;
+        readonly error: E;
+        readonly delay: Milliseconds;
+        readonly timestamp: Date;
+    }>;
+}
+
+/**
+ * Modern retry strategies with enhanced capabilities
+ * Provides various retry patterns with type safety
+ */
+
+type RetryStrategy = FixedDelayStrategy | ExponentialBackoffStrategy | FibonacciBackoffStrategy | CustomDelayStrategy;
+interface FixedDelayStrategy {
+    readonly type: 'fixed';
+    readonly delay: number;
+}
+interface ExponentialBackoffStrategy {
+    readonly type: 'exponential';
+    readonly base: number;
+    readonly factor: number;
+    readonly maxDelay?: number;
+}
+interface FibonacciBackoffStrategy {
+    readonly type: 'fibonacci';
+    readonly base: number;
+    readonly maxDelay?: number;
+}
+interface CustomDelayStrategy {
+    readonly type: 'custom';
+    readonly calculate: (attempt: RetryCount, error: unknown) => number;
+}
+declare const RetryStrategies: {
+    readonly fixed: (delay: number) => FixedDelayStrategy;
+    readonly exponential: (base: number, factor?: number, maxDelay?: number) => ExponentialBackoffStrategy;
+    readonly fibonacci: (base: number, maxDelay?: number) => FibonacciBackoffStrategy;
+    readonly custom: (calculate: (attempt: RetryCount, error: unknown) => number) => CustomDelayStrategy;
+};
+
+interface TryoConfig<E extends TypedError = TypedError> {
+    /** Abort signal passed to tasks */
+    readonly signal?: AbortSignal;
+    /** If true, aborts are treated as non-throwing failures */
+    readonly ignoreAbort?: boolean;
+    /** Timeout configuration */
+    readonly timeout?: number;
+    /** Retry configuration */
+    readonly retry?: RetryConfig<E>;
+    /** Circuit breaker configuration */
+    readonly circuitBreaker?: CircuitBreakerConfig<E>;
+    /** Error handling configuration */
+    readonly errorHandling: ErrorHandlingConfig<E>;
+    /** Concurrency configuration for batch operations */
+    readonly concurrency?: number;
+    /** Logging configuration */
+    readonly logger?: LoggerConfig<E>;
+    /** Callback hooks */
+    readonly hooks?: HookConfig<E>;
+}
+interface RetryConfig<E extends TypedError> {
+    /** Maximum number of retry attempts */
+    readonly maxRetries: number;
+    /** Base delay strategy */
+    readonly strategy: RetryStrategy;
+    /** Jitter configuration to prevent thundering herd */
+    readonly jitter?: JitterConfig;
+    /** Function to determine if retry should be attempted */
+    readonly shouldRetry?: ShouldRetryPredicate<E>;
+}
+type ShouldRetryPredicate<E extends TypedError> = (attempt: number, error: E, context: RetryContext) => boolean;
+interface RetryContext {
+    /** Total attempts made so far */
+    readonly totalAttempts: number;
+    /** Elapsed time since start */
+    readonly elapsedTime: number;
+    /** Start timestamp */
+    readonly startTime: Date;
+    /** Last delay applied */
+    readonly lastDelay?: number;
+}
+interface ErrorHandlingConfig<E extends TypedError> {
+    /** Error normalizer function */
+    readonly normalizer: ErrorNormalizer<E>;
+    /** Optional error mapping/transformation */
+    readonly mapError?: (error: E) => E;
+}
+interface LoggerConfig<E extends TypedError> {
+    /** Debug logging function */
+    readonly debug?: (message: string, meta?: unknown) => void;
+    /** Error logging function */
+    readonly error?: (message: string, error: E) => void;
+    /** Info logging function */
+    readonly info?: (message: string, meta?: unknown) => void;
+    /** Warning logging function */
+    readonly warn?: (message: string, meta?: unknown) => void;
+}
+interface HookConfig<E extends TypedError> {
+    /** Called on successful execution */
+    readonly onSuccess?: <T>(data: T, metrics?: TryoMetrics<E>) => void;
+    /** Called on failed execution */
+    readonly onError?: (error: E, metrics?: TryoMetrics<E>) => void;
+    /** Called always, success or failure */
+    readonly onFinally?: (metrics?: TryoMetrics<E>) => void;
+    /** Called on abort */
+    readonly onAbort?: (signal: AbortSignal) => void;
+    /** Called before retry attempt */
+    readonly onRetry?: (attempt: number, error: E, delay: number) => void;
+    /** Called when circuit breaker state changes */
+    readonly onCircuitStateChange?: (from: CircuitState, to: CircuitState) => void;
+}
+type CircuitState = 'closed' | 'open' | 'half-open';
+type TryoMetrics<E extends TypedError> = TryoMetrics$1<E>;
+type JitterConfig = {
+    type: 'none';
+} | {
+    type: 'full';
+    ratio: number;
+} | {
+    type: 'equal';
+    ratio: number;
+} | {
+    type: 'custom';
+    calculate: (delay: number) => number;
+};
+declare const JitterConfig: {
+    readonly none: () => JitterConfig;
+    readonly full: (ratio?: number) => JitterConfig;
+    readonly equal: (ratio?: number) => JitterConfig;
+    readonly custom: (calculate: (delay: number) => number) => JitterConfig;
+};
+
+type RulesMode = 'extend' | 'replace';
+type DefaultError = AbortedError | TimeoutError | NetworkError | HttpError | CircuitOpenError | ValidationError | UnknownError;
+type NonNull<T> = T extends null ? never : T;
+type RuleReturn<R> = R extends (err: unknown) => infer Out ? NonNull<Out> : never;
+type InferErrorFromRules<TRules extends readonly ErrorRule<TypedError>[]> = TRules extends readonly [] ? TypedError : RuleReturn<TRules[number]> | UnknownError;
+type TryoOptions<E extends TypedError = TypedError> = Omit<Partial<TryoConfig<E>>, 'errorHandling' | 'signal'> & {
+    rules?: Array<ErrorRule<E>>;
+    rulesMode?: RulesMode;
+    fallback?: (err: unknown) => E;
+    toError?: (err: unknown) => E;
+    mapError?: (error: E) => E;
+};
+declare function tryo<const TRules extends readonly ErrorRule<TypedError>[]>(options: Omit<TryoOptions<InferErrorFromRules<TRules>>, 'rules'> & {
+    rules: TRules;
+}): Tryo<InferErrorFromRules<TRules>>;
+declare function tryo<E extends TypedError = DefaultError>(options?: TryoOptions<E>): Tryo<E>;
+type Tryo<E extends TypedError = TypedError> = {
+    run: <T>(task: (ctx: {
+        signal: AbortSignal;
+    }) => Promise<T>, options?: Partial<TryoConfig<E>>) => Promise<TryoResult<T, E>>;
+    runOrThrow: <T>(task: (ctx: {
+        signal: AbortSignal;
+    }) => Promise<T>, options?: Partial<TryoConfig<E>>) => Promise<T>;
+    orThrow: <T>(task: (ctx: {
+        signal: AbortSignal;
+    }) => Promise<T>, options?: Partial<TryoConfig<E>>) => Promise<T>;
+    all: <T>(tasks: Array<(ctx: {
+        signal: AbortSignal;
+    }) => Promise<T>>, options?: Partial<TryoConfig<E> & {
+        concurrency?: number;
+    }>) => Promise<Array<TryoResult<T, E>>>;
+    allOrThrow: <T>(tasks: Array<(ctx: {
+        signal: AbortSignal;
+    }) => Promise<T>>, options?: Partial<TryoConfig<E> & {
+        concurrency?: number;
+    }>) => Promise<T[]>;
+    partitionAll: <T>(results: Array<TryoResult<T, E>>) => {
+        ok: Array<SuccessResult<T, E>>;
+        errors: Array<FailureResult<E> | AbortedResult<E> | TimeoutResult<E>>;
+        failure: Array<FailureResult<E>>;
+        aborted: Array<AbortedResult<E>>;
+        timeout: Array<TimeoutResult<E>>;
+    };
+    withConfig: (additionalConfig: Omit<Partial<TryoConfig<E>>, 'signal'>) => Tryo<E>;
+};
+
+declare const run: <T>(task: (ctx: {
+    signal: AbortSignal;
+}) => Promise<T>, options?: Partial<TryoConfig<DefaultError>> | undefined) => Promise<TryoResult<T, DefaultError>>;
+declare const runOrThrow: <T>(task: (ctx: {
+    signal: AbortSignal;
+}) => Promise<T>, options?: Partial<TryoConfig<DefaultError>> | undefined) => Promise<T>;
+declare const orThrow: <T>(task: (ctx: {
+    signal: AbortSignal;
+}) => Promise<T>, options?: Partial<TryoConfig<DefaultError>> | undefined) => Promise<T>;
+declare const all: <T>(tasks: ((ctx: {
+    signal: AbortSignal;
+}) => Promise<T>)[], options?: Partial<TryoConfig<DefaultError> & {
+    concurrency?: number;
+}> | undefined) => Promise<TryoResult<T, DefaultError>[]>;
+declare const allOrThrow: <T>(tasks: ((ctx: {
+    signal: AbortSignal;
+}) => Promise<T>)[], options?: Partial<TryoConfig<DefaultError> & {
+    concurrency?: number;
+}> | undefined) => Promise<T[]>;
+
+/**
+ * Modern fluent error rule builder
+ * Provides type-safe error rule creation with enhanced ergonomics
+ */
+
+declare class ErrorRuleBuilder<T> {
+    private readonly predicate;
+    constructor(predicate: (err: unknown) => err is T);
+    toCode<const C extends string>(code: C): ErrorMapper<T, C>;
+    toError<const Out extends {
+        code: string;
+        message: string;
+        meta?: unknown;
+        status?: number;
+        cause?: unknown;
+        retryable?: boolean;
+    }>(mapper: (err: T) => Out): ErrorRule<TypedError<Out['code'], Out['meta']>>;
+}
+declare class ErrorMapper<T, C extends string> {
+    private readonly predicate;
+    private readonly errorCode;
+    constructor(predicate: (err: unknown) => err is T, errorCode: C);
+    with<const M = unknown>(mapper: (err: T) => {
+        message: string;
+        cause?: unknown;
+        meta?: M;
+        status?: number;
+        retryable?: boolean;
+    }): (err: unknown) => TypedError<C, M> | null;
+}
+
+declare const errorRule: {
+    readonly when: <T>(predicate: (err: unknown) => err is T) => ErrorRuleBuilder<T>;
+    readonly instance: <T extends new (...args: unknown[]) => unknown>(ErrorClass: T) => ErrorRuleBuilder<InstanceType<T>>;
+};
+
+export { type AbortedResult, type ConcurrencyLimit, type FailureResult, type Milliseconds, type Percentage, type RetryCount, RetryStrategies, type RulesMode, type StatusCode, type SuccessResult, type TimeoutResult, type TryoConfig, type TryoMetrics$1 as TryoMetrics, type TryoOptions, type TryoResult, all, allOrThrow, asConcurrencyLimit, asMilliseconds, asPercentage, asRetryCount, asStatusCode, errorRule, orThrow, run, runOrThrow, tryo };

package/dist/index.js

@@ -0,0 +1 @@
+var j=Object.defineProperty;var ee=(e,r,t)=>r in e?j(e,r,{enumerable:!0,configurable:!0,writable:!0,value:t}):e[r]=t;var m=(e,r,t)=>ee(e,typeof r!="symbol"?r+"":r,t);var T=class extends Error{constructor(t,n){var o;super(t);m(this,"cause");m(this,"meta");m(this,"status");m(this,"timestamp");m(this,"retryable");this.timestamp=Date.now(),this.retryable=(o=n==null?void 0:n.retryable)!=null?o:!0,this.name=this.constructor.name,this.cause=n==null?void 0:n.cause,this.meta=n==null?void 0:n.meta,this.status=n==null?void 0:n.status,Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)}is(t){return this.code===t}withMeta(t){return Object.assign(this,{meta:t})}withStatus(t){return Object.assign(this,{status:t})}withCause(t){return Object.assign(this,{cause:t})}withRetryable(t){return this.retryable=t,this}toJSON(){return{name:this.name,code:this.code,message:this.message,timestamp:this.timestamp,retryable:this.retryable,cause:this.cause,stack:this.stack}}},D=class extends T{constructor(t,n){super(`Operation timed out after ${t}ms`,{cause:n,retryable:!0});m(this,"code","TIMEOUT")}};var g=class extends T{constructor(t,n){super(`Circuit breaker is open, reset after ${t}ms`,{cause:n,retryable:!1});m(this,"code","CIRCUIT_OPEN")}},v=class extends T{constructor(t,n,o){super(t,{cause:o,meta:{validationErrors:n},retryable:!1});this.validationErrors=n;m(this,"code","VALIDATION")}};var I=class extends T{constructor(t,n){super(t,{cause:n});m(this,"code","UNKNOWN")}};var x=e=>{if(e<0||!Number.isFinite(e))throw new Error(`Invalid milliseconds: must be a non-negative finite number, got ${e}`);return e},A=e=>{if(e<0||!Number.isInteger(e))throw new Error(`Invalid retry count: must be a non-negative integer, got ${e}`);return e},_=e=>{if(e<1||!Number.isInteger(e))throw new Error(`Invalid concurrency limit: must be a positive integer, got ${e}`);return e},re=e=>{if(e<0||e>100||!Number.isFinite(e))throw new Error(`Invalid percentage: must be between 0 and 100, got ${e}`);return e},te=e=>{if(!Number.isInteger(e)||e<100||e>599)throw new Error(`Invalid status code: must be an integer between 100-599, got ${e}`);return e};var F=class{constructor(r){m(this,"state");m(this,"config");this.config={failureThreshold:A(r.failureThreshold),resetTimeout:x(r.resetTimeout),halfOpenRequests:A(r.halfOpenRequests),shouldCountAsFailure:r.shouldCountAsFailure},this.state={state:"closed",failureCount:0,halfOpenCount:0}}async canExecute(){if(this.updateStateIfNeeded(),this.state.state==="open")return!1;if(this.state.state==="half-open"){if(this.state.halfOpenCount>=this.config.halfOpenRequests)return!1;this.state={...this.state,halfOpenCount:this.state.halfOpenCount+1}}return!0}async recordSuccess(){switch(this.state.state){case"closed":this.state={...this.state,failureCount:0};break;case"half-open":this.state={state:"closed",failureCount:0,halfOpenCount:0};break;case"open":break}}async recordFailure(r){var o,a,i;if(!((i=(a=(o=this.config).shouldCountAsFailure)==null?void 0:a.call(o,r))!=null?i:!0))return;let n=new Date;switch(this.state.state){case"closed":{let s=this.state.failureCount+1;s>=this.config.failureThreshold?this.state={state:"open",failureCount:s,halfOpenCount:0,lastFailureTime:n,nextAttemptTime:new Date(n.getTime()+this.config.resetTimeout)}:this.state={...this.state,failureCount:s,lastFailureTime:n};break}case"half-open":this.state={state:"open",failureCount:this.state.failureCount+1,halfOpenCount:0,lastFailureTime:n,nextAttemptTime:new Date(n.getTime()+this.config.resetTimeout)};break;case"open":this.state={...this.state,lastFailureTime:n,nextAttemptTime:new Date(n.getTime()+this.config.resetTimeout)};break}}getState(){return this.updateStateIfNeeded(),{...this.state,canExecute:this.state.state!=="open"}}createOpenError(){let r=this.state.nextAttemptTime?x(Math.max(0,this.state.nextAttemptTime.getTime()-Date.now())):this.config.resetTimeout;return new g(r)}forceState(r){this.state={state:r,failureCount:0,halfOpenCount:0}}reset(){this.state={state:"closed",failureCount:0,halfOpenCount:0}}updateStateIfNeeded(){this.state.state==="open"&&this.state.nextAttemptTime&&new Date>=this.state.nextAttemptTime&&(this.state={...this.state,state:"half-open",halfOpenCount:0})}};var W=(e,r)=>t=>{for(let n of e){let o=n(t);if(o!==null)return o}return r(t)},J=e=>r=>r instanceof T?r:r instanceof Error?new e(r.message,r):typeof r=="string"?new e(r):new e("Unknown error occurred",r);var ne=e=>{if(typeof e!="object"||e===null)return!1;let r=e;return typeof r.status=="number"||typeof r.statusCode=="number"},oe=e=>{if(typeof e!="object"||e===null)return!1;let r=e;return typeof r.code=="string"&&r.code.length>0},se=e=>{var r;if(e instanceof Error){if(e.name==="TypeError")return!0;let t=e.message.toLowerCase();if(t.includes("fetch")&&t.includes("failed")||t.includes("network"))return!0}if(oe(e)){let t=((r=e.code)!=null?r:"").toUpperCase();return t==="ECONNRESET"||t==="ECONNREFUSED"||t==="ETIMEDOUT"||t==="ENOTFOUND"||t==="EAI_AGAIN"}return!1},B=class{constructor(r){this.predicate=r}toCode(r){return new L(this.predicate,r)}toError(r){return t=>{if(!this.predicate(t))return null;let n=r(t),o=n.code;class a extends T{constructor(){var u;super(n.message,{cause:(u=n.cause)!=null?u:t,meta:n.meta,status:n.status,retryable:n.retryable});m(this,"code",o)}}return new a}}},L=class{constructor(r,t){this.predicate=r;this.errorCode=t}with(r){return t=>{if(!this.predicate(t))return null;let n=r(t),o=this.errorCode;class a extends T{constructor(){super(n.message,{cause:n.cause,meta:n.meta,status:n.status,retryable:n.retryable});m(this,"code",o)}}return new a}}},E={when:e=>new B(e),instance:e=>new B(r=>r instanceof e),code:e=>({for:r=>new L(r,e)}),string:(e,r)=>({when:t=>E.when(t).toCode(r).with(n=>({message:n===e?e:`${r}: ${n}`,cause:n}))}),httpStatus:(e,r)=>({for:t=>E.when(t).toCode(r!=null?r:`HTTP_${e}`).with(n=>({message:`HTTP ${e} error`,cause:n}))})};var w={typed:(e=>e instanceof T?e:null),abort:E.when(e=>e instanceof DOMException&&e.name==="AbortError").toCode("ABORTED").with(e=>({message:e.message||"Operation was aborted",cause:e,retryable:!1})),timeout:E.when(e=>e instanceof Error&&e.name==="TimeoutError").toCode("TIMEOUT").with(e=>({message:e.message||"Operation timed out",cause:e})),network:E.when(e=>se(e)).toCode("NETWORK").with(e=>({message:(e instanceof Error,e.message||"Network error"),cause:e})),http:E.when(e=>{var n;if(!ne(e))return!1;let r=e,t=(n=r.status)!=null?n:r.statusCode;return typeof t=="number"&&t>=400}).toCode("HTTP").with(e=>{var n;let r=(n=e.status)!=null?n:e.statusCode,t=typeof r=="number"&&(r>=500||r===429);return{message:e.message||`HTTP ${r!=null?r:"error"} error`,cause:e,status:typeof r=="number"?r:void 0,retryable:t}}),unknown:E.when(e=>e instanceof Error&&!(e instanceof T)).toCode("UNKNOWN").with(e=>({message:e.message||"Unknown error occurred",cause:e}))};var ae=[w.typed,w.abort,w.timeout,w.http,w.network,w.unknown];var ie={when:e=>E.when(e),instance:e=>E.instance(e)},K=ae,Fe=w.timeout,Be=w.abort,Le=w.network,Ue=w.http,_e=E.when(e=>e instanceof g).toCode("CIRCUIT_OPEN").with(e=>({message:e.message,cause:e})),ze=E.when(e=>e instanceof v).toCode("VALIDATION").with(e=>({message:e.message,cause:e}));var ue={fixed:e=>({type:"fixed",delay:e}),exponential:(e,r=2,t)=>({type:"exponential",base:e,factor:r,maxDelay:t}),fibonacci:(e,r)=>({type:"fibonacci",base:e,maxDelay:r}),custom:e=>({type:"custom",calculate:e})},q=(e,r,t)=>{switch(e.type){case"fixed":return e.delay;case"exponential":{let n=e.base*e.factor**(Number(r)-1);return e.maxDelay?Math.min(n,e.maxDelay):n}case"fibonacci":{let n=e.base*ce(Number(r));return e.maxDelay?Math.min(n,e.maxDelay):n}case"custom":return e.calculate(r,t);default:return e}},ce=e=>{if(e<=1)return 1;let r=1,t=1;for(let n=2;n<=e;n++){let o=r+t;r=t,t=o}return t};var Y=(e,r)=>new Promise((t,n)=>{if(r!=null&&r.aborted){n(new DOMException("Aborted","AbortError"));return}let o=s=>{r&&s&&r.removeEventListener("abort",s)},a,i=()=>{a&&clearTimeout(a),o(i),n(new DOMException("Aborted","AbortError"))};a=setTimeout(()=>{o(i),t()},e),r==null||r.addEventListener("abort",i,{once:!0})});var le=e=>{var i,s,u;if(e.toError)return e.toError;let r=(i=e.rulesMode)!=null?i:"extend",t=(s=e.rules)!=null?s:[],n=K,o=(u=e.fallback)!=null?u:(c=>J(I)(c)),a=r==="replace"?t:[...t,...n];return W(a,o)},z=class e{constructor(r={}){m(this,"circuitBreaker");m(this,"config");m(this,"lastCircuitState");let{rules:t,rulesMode:n,fallback:o,toError:a,mapError:i,...s}=r,u=le(r),c={...s,errorHandling:{normalizer:u,mapError:i}};this.config=c,c.circuitBreaker&&(this.circuitBreaker=new F(c.circuitBreaker),this.lastCircuitState=this.circuitBreaker.getState().state)}async run(r,t={}){var a,i,s,u,c,b;let n={...this.config,...t};if(this.circuitBreaker){let l=(a=this.lastCircuitState)!=null?a:this.circuitBreaker.getState().state,y=await this.circuitBreaker.canExecute(),p=this.circuitBreaker.getState().state;if(l!==p)try{(s=(i=n.hooks)==null?void 0:i.onCircuitStateChange)==null||s.call(i,l,p)}catch{}if(this.lastCircuitState=p,!y)return{type:"failure",ok:!1,data:null,error:this.circuitBreaker.createOpenError(),metrics:{totalAttempts:0,totalRetries:0,totalDuration:0,retryHistory:[]}}}let o=await me(r,n);if(this.circuitBreaker){let l=(u=this.lastCircuitState)!=null?u:this.circuitBreaker.getState().state;o.ok?await this.circuitBreaker.recordSuccess():await this.circuitBreaker.recordFailure(o.error);let y=this.circuitBreaker.getState().state;if(l!==y)try{(b=(c=n.hooks)==null?void 0:c.onCircuitStateChange)==null||b.call(c,l,y)}catch{}this.lastCircuitState=y}return o}async runOrThrow(r,t={}){let n=await this.run(r,t);if(n.ok)return n.data;throw n.error}async orThrow(r,t={}){let n=await this.run(r,t);if(n.ok)return n.data;throw n.error}async all(r,t={}){var b;let n={...this.config,...t},o=(b=n.concurrency)!=null?b:Number.POSITIVE_INFINITY,a=Number.isFinite(o)?Number(_(o)):Number.POSITIVE_INFINITY,i=new Array(r.length),s=0,u=async()=>{var l;for(;s<r.length&&!((l=n.signal)!=null&&l.aborted);){let y=s++;if(y>=r.length)break;let p=r[y];p&&(i[y]=await this.run(p,n))}},c=Array.from({length:Math.min(a,r.length)},()=>u());await Promise.all(c);for(let l=0;l<r.length;l++)if(!(l in i)){let y=r[l];y&&(i[l]=await this.run(y,n))}return i}async allOrThrow(r,t={}){let n=await this.all(r,t);for(let o of n)if(!o.ok)throw o.error;return n.map(o=>{if(!o.ok)throw o.error;return o.data})}partitionAll(r){let t=[],n=[],o=[],a=[],i=[];for(let s of r){if(s.type==="success"){t.push(s);continue}switch(n.push(s),s.type){case"failure":o.push(s);break;case"aborted":a.push(s);break;case"timeout":i.push(s);break}}return{ok:t,errors:n,failure:o,aborted:a,timeout:i}}getCircuitBreakerState(){var r;return(r=this.circuitBreaker)==null?void 0:r.getState()}resetCircuitBreaker(){var r;(r=this.circuitBreaker)==null||r.reset()}getConfig(){return{...this.config}}withConfig(r){var u,c;let{errorHandling:t,...n}=this.config,{errorHandling:o,...a}=r,i=(u=o==null?void 0:o.normalizer)!=null?u:t.normalizer,s=(c=o==null?void 0:o.mapError)!=null?c:t.mapError;return new e({...n,...a,toError:i,mapError:s})}withErrorType(r={}){return new e(r)}};function $(e={}){let r=new z(e);return{run:(t,n)=>r.run(t,n),orThrow:(t,n)=>r.orThrow(t,n),runOrThrow:(t,n)=>r.runOrThrow(t,n),all:(t,n)=>r.all(t,n),allOrThrow:(t,n)=>r.allOrThrow(t,n),partitionAll:t=>r.partitionAll(t),withConfig:t=>r.withConfig(t)}}async function me(e,r){let{signal:t,ignoreAbort:n=!0,timeout:o,retry:a,errorHandling:i,hooks:s,logger:u}=r,c=(k,...d)=>{try{k==null||k(...d)}catch{}},b,l=0,y=0,p=[],R=Date.now(),{signal:C,cleanup:G}=de(t);try{if(C.aborted){c(s==null?void 0:s.onAbort,C);let d=i.normalizer(new DOMException("Aborted","AbortError")),f=i.mapError?i.mapError(d):d;return{type:"aborted",ok:!1,data:null,error:f,metrics:{totalAttempts:l,totalRetries:y,totalDuration:Date.now()-R,lastError:f,retryHistory:p}}}let k=async d=>{var f,P,O;l=d;try{let M=e({signal:C}),S=o?await ye(M,o,C):await M;return c(s==null?void 0:s.onSuccess,S),c(u==null?void 0:u.info,`Task succeeded on attempt ${d}`),S}catch(M){let S=i.normalizer(M),h=i.mapError?i.mapError(S):S;b=h,h.code==="ABORTED"&&c(s==null?void 0:s.onAbort,C),n&&h.code==="ABORTED"||(c(s==null?void 0:s.onError,h),c(u==null?void 0:u.error,`Task failed on attempt ${d}`,h));let Q=A((f=a==null?void 0:a.maxRetries)!=null?f:0);if(d<=Number(Q)){let H=a==null?void 0:a.shouldRetry,X={totalAttempts:Number(l),elapsedTime:Date.now()-R,startTime:new Date(R),lastDelay:(P=p[p.length-1])!=null&&P.delay?Number((O=p[p.length-1])==null?void 0:O.delay):void 0};if(!H||H(d,h,X)){let Z=a?q(a.strategy,d,h):0,U=pe(Z,a==null?void 0:a.jitter),V=x(U);return p.push({attempt:d,error:h,delay:V,timestamp:new Date}),c(s==null?void 0:s.onRetry,d,h,U),c(u==null?void 0:u.info,`Retrying in ${U}ms (attempt ${d+1})`),await Y(V,C),k(d+1)}}throw h}};try{let d=await k(1);y=l>0?Number(l)-1:0;let f={totalAttempts:l,totalRetries:y,totalDuration:Date.now()-R,retryHistory:p};return c(s==null?void 0:s.onFinally,f),{type:"success",ok:!0,data:d,error:null,metrics:f}}catch(d){let f=b!=null?b:i.normalizer(d),P=f.code==="TIMEOUT"?"timeout":f.code==="ABORTED"?"aborted":"failure";y=l>0?Number(l)-1:0;let O={totalAttempts:l,totalRetries:y,totalDuration:Date.now()-R,lastError:f,retryHistory:p};return c(s==null?void 0:s.onFinally,O),{type:P,ok:!1,data:null,error:f,metrics:O}}}finally{G()}}function de(e){let r=new AbortController;if(!e)return{signal:r.signal,cleanup:()=>{}};let t=()=>r.abort();return e.aborted?(t(),{signal:r.signal,cleanup:()=>{}}):(e.addEventListener("abort",t,{once:!0}),{signal:r.signal,cleanup:()=>e.removeEventListener("abort",t)})}async function ye(e,r,t){return new Promise((n,o)=>{if(t!=null&&t.aborted){o(new DOMException("Aborted","AbortError"));return}let a=!1,i=setTimeout(()=>{a=!0,u(),o(new D(x(r)))},r),s=()=>{a||(a=!0,u(),o(new DOMException("Aborted","AbortError")))},u=()=>{clearTimeout(i),t==null||t.removeEventListener("abort",s)};t==null||t.addEventListener("abort",s,{once:!0}),e.then(c=>{a||(a=!0,u(),n(c))},c=>{a||(a=!0,u(),o(c))})})}function pe(e,r){if(!r||r.type==="none"||e<=0)return e;switch(r.type){case"full":{let t=Number(r.ratio)/100,n=Math.max(0,Number(e)*(1-t)),o=Number(e);return n+Math.random()*(o-n)}case"equal":{let t=Number(r.ratio)/100,n=Number(e)*t/2;return Number(e)-n+Math.random()*n}case"custom":return r.calculate(e);default:return r}}var N=$(),fe=N.run,Te=N.runOrThrow,Ee=N.orThrow,we=N.all,be=N.allOrThrow;export{ue as RetryStrategies,we as all,be as allOrThrow,_ as asConcurrencyLimit,x as asMilliseconds,re as asPercentage,A as asRetryCount,te as asStatusCode,ie as errorRule,Ee as orThrow,fe as run,Te as runOrThrow,$ as tryo};

package/package.json

@@ -1,28 +1,59 @@
 {
-  "name": "tryo",
-  "version": "0.1.0",
-  "description": "Run async functions and return a typed Result instead of throwing.",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "typescript": "^5.0.0"
-  },
-  "license": "MIT"
+	"name": "tryo",
+	"version": "0.13.0",
+	"description": "Run sync/async functions and return a typed Result instead of throwing.",
+	"type": "module",
+	"sideEffects": false,
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"require": "./dist/index.cjs"
+		}
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE"
+	],
+	"scripts": {
+		"build": "tsup",
+		"typecheck": "tsc --noEmit",
+		"test": "bun test",
+		"docs:dev": "cd docs && mintlify dev",
+		"docs:dev:es": "cd docs && mintlify dev --config mint.es.json",
+		"docs:build": "cd docs && mintlify build",
+		"docs:preview": "cd docs && mintlify preview",
+		"prepublishOnly": "npm run build",
+		"format": "biome format --write",
+		"lint": "biome lint",
+		"lint:fix": "biome lint --fix",
+		"check": "biome check",
+		"check:fix": "biome check --write",
+		"prepare": "husky"
+	},
+	"lint-staged": {
+		"*.{ts,tsx,js,jsx,json}": [
+			"biome check --write"
+		]
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.3.13",
+		"@types/bun": "latest",
+		"husky": "^9.1.7",
+		"lint-staged": "^16.2.7",
+		"mint": "latest",
+		"tsup": "^8.5.1",
+		"typescript": "^5.0.0"
+	},
+	"license": "MIT",
+	"homepage": "https://tryo-docs.pages.dev/",
+	"bugs": "https://github.com/sebasxsala/tryo/issues",
+	"author": {
+		"name": "sebasxsala",
+		"url": "https://github.com/sebasxsala"
+	}
 }