awaitly 1.35.0 → 2.0.0

package/dist/index.js

@@ -1,2 +1,4399 @@
-var Ve=Object.defineProperty;var $e=(e,r)=>{for(var n in r)Ve(e,n,{get:r[n],enumerable:!0})};var U={};$e(U,{AWAITLY_CANCELLED:()=>re,AWAITLY_TIMEOUT:()=>ne,AWAITLY_UNEXPECTED:()=>ee,DESERIALIZATION_ERROR:()=>R,PROMISE_REJECTED:()=>p,UnexpectedError:()=>C,UnwrapError:()=>k,all:()=>Ue,allAsync:()=>Oe,allSettled:()=>Be,allSettledAsync:()=>De,andThen:()=>ye,any:()=>Se,anyAsync:()=>je,bimap:()=>xe,deserialize:()=>He,err:()=>u,flatten:()=>Ie,from:()=>le,fromNullable:()=>de,fromPromise:()=>pe,hydrate:()=>ve,isErr:()=>f,isOk:()=>l,isPromiseRejectedError:()=>oe,isSerializedResult:()=>be,isUnexpectedError:()=>m,map:()=>Te,mapError:()=>Ce,mapErrorTry:()=>ge,mapTry:()=>me,match:()=>v,matchError:()=>P,matchErrorPartial:()=>Ne,ok:()=>a,orElse:()=>we,orElseAsync:()=>Ae,partition:()=>_e,recover:()=>he,recoverAsync:()=>Pe,runOrNull:()=>ce,runOrThrow:()=>ae,runOrThrowAsync:()=>ie,runOrUndefined:()=>Ee,serialize:()=>Ke,tags:()=>te,tap:()=>Re,tapError:()=>ke,tryAsync:()=>fe,unwrap:()=>g,unwrapOr:()=>se,unwrapOrElse:()=>ue,zip:()=>b,zipAsync:()=>Fe});var We={"step-require-id":"step-require-id","step-no-immediate-execution":"step-no-immediate-execution","step-require-thunk-for-key":"step-require-thunk-for-key","step-no-bare-await":"step-no-bare-await","step-no-try-catch-wrap":"step-no-try-catch-wrap","step-stable-cache-keys":"step-stable-cache-keys","workflow-no-floating":"workflow-no-floating","workflow-options-position":"workflow-options-position","workflow-callback-shape":"workflow-callback-shape","workflow-no-callable-form":"workflow-no-callable-form","workflow-no-dynamic-import":"workflow-no-dynamic-import","result-no-floating":"result-no-floating","result-require-handling":"result-require-handling","result-no-double-wrap":"result-no-double-wrap","result-no-manual-propagation":"result-no-manual-propagation","result-no-direct-ok-err":"result-no-direct-ok-err","error-check-unexpected-first":"error-check-unexpected-first","error-access-cause":"error-access-cause","error-normalize":"error-normalize","error-no-throw-in-deps":"error-no-throw-in-deps","concurrency-no-promise-all":"concurrency-no-promise-all","concurrency-no-promise-race":"concurrency-no-promise-race","concurrency-no-promise-allsettled":"concurrency-no-promise-allsettled","runtime-step-timeout":"runtime-step-timeout","runtime-step-aborted":"runtime-step-aborted","runtime-retry-exhausted":"runtime-retry-exhausted","runtime-rate-limit":"runtime-rate-limit","runtime-circuit-open":"runtime-circuit-open","runtime-unexpected":"runtime-unexpected","runtime-resolver-not-found":"runtime-resolver-not-found","runtime-saga-compensation":"runtime-saga-compensation"};function G(e){return`https://jagreehal.github.io/awaitly/rules/#${e}`}var ur=Object.keys(We);var y=class extends Error{_tag};function c(e,r){return class extends y{_tag=e;constructor(n,t){let o=r?.message?r.message(n??{}):e;if(super(o),this.name=e,r?.slug!==void 0){if(!r.hint)throw new TypeError(`TaggedError: 'hint' is required when 'slug' is set (slug: "${r.slug}")`);Object.defineProperty(this,"code",{value:r.slug,enumerable:!0,writable:!1,configurable:!1}),Object.defineProperty(this,"hint",{value:r.hint,enumerable:!0,writable:!1,configurable:!1}),Object.defineProperty(this,"docsUrl",{value:G(r.slug),enumerable:!0,writable:!1,configurable:!1})}if(Object.setPrototypeOf(this,new.target.prototype),n&&typeof n=="object"){let s;if(r?.slug!==void 0){let{_tag:T,name:h,message:Le,stack:ze,code:z,hint:tr,docsUrl:or,...Ge}=n;s=Ge}else{let{_tag:T,name:h,message:Le,stack:ze,...z}=n;s=z}let i=Object.prototype.hasOwnProperty.call(s,"cause"),E=i?s.cause:void 0;i&&delete s.cause;let d=t?.cause!==void 0;if(i&&d)throw new TypeError("TaggedError: cannot provide 'cause' in props when also setting ErrorOptions.cause");Object.assign(this,s),i&&(this.cause=E),d&&(this.cause=t?.cause)}else t?.cause!==void 0&&(this.cause=t.cause)}}}Object.defineProperty(c,Symbol.hasInstance,{value:e=>e instanceof y});(o=>{function e(s){return s instanceof Error}o.isError=e;function r(s){return s instanceof y}o.isTaggedError=r;function n(s,i){let E=s._tag,d=i[E];return d(s)}o.match=n;function t(s,i,E){let d=s._tag,T=i[d];return T?T(s):E(s)}o.matchPartial=t})(c||={});var V=class extends c("TimeoutError",{slug:"runtime-step-timeout",hint:"Increase the step's timeout option, or check why the upstream operation is slow.",message:r=>r.operation?`TimeoutError: ${r.operation} timed out after ${r.ms}ms`:`TimeoutError: Operation timed out after ${r.ms}ms`}){},$=class extends c("RetryExhaustedError",{slug:"runtime-retry-exhausted",hint:"All retry attempts failed. Inspect lastError and decide whether to surface it or compensate.",message:r=>r.operation?`RetryExhaustedError: ${r.operation} failed after ${r.attempts} attempts`:`RetryExhaustedError: Operation failed after ${r.attempts} attempts`}){},W=class extends c("RateLimitError",{slug:"runtime-rate-limit",hint:"Wait retryAfterMs before retrying, or apply step.cache to deduplicate calls.",message:r=>r.limiterName?`RateLimitError: Rate limit exceeded for ${r.limiterName}${r.retryAfterMs?`, retry after ${r.retryAfterMs}ms`:""}`:`RateLimitError: Rate limit exceeded${r.retryAfterMs?`, retry after ${r.retryAfterMs}ms`:""}`}){},Y=class extends c("CircuitBreakerOpenError",{slug:"runtime-circuit-open",hint:"The circuit is open. Wait for it to half-open or fall back to a degraded path.",message:r=>`CircuitBreakerOpenError: Circuit ${r.circuitName} is ${r.state??"OPEN"}${r.retryAfterMs?`, retry after ${Math.ceil(r.retryAfterMs/1e3)}s`:""}`}){},J=class extends c("ValidationError",{message:r=>`ValidationError: Invalid ${r.field} - ${r.reason}`}){},q=class extends c("NotFoundError",{message:r=>r.id?`NotFoundError: ${r.resource} with id ${r.id} not found`:`NotFoundError: ${r.resource} not found`}){},Z=class extends c("UnauthorizedError",{message:r=>r.reason?`UnauthorizedError: ${r.reason}`:r.action&&r.resource?`UnauthorizedError: Not authorized to ${r.action} ${r.resource}`:"UnauthorizedError: Access denied"}){},X=class extends c("NetworkError",{message:r=>r.url?`NetworkError: ${r.reason} (${r.url})`:`NetworkError: ${r.reason}`}){},Q=class extends c("CompensationError",{slug:"runtime-saga-compensation",hint:"A saga compensation step failed. Inspect compensationError and ensure compensation is idempotent.",message:r=>`CompensationError: Failed to compensate step ${r.step}`}){},C=class extends c("UnexpectedError",{slug:"runtime-unexpected",hint:"An unexpected exception escaped a step. Inspect cause; consider returning a typed Result instead of throwing.",message:r=>`UnexpectedError: ${r.cause instanceof Error?r.cause.message:String(r.cause??"unknown")}`}){};var p="PROMISE_REJECTED",ee="AWAITLY_UNEXPECTED",re="AWAITLY_CANCELLED",ne="AWAITLY_TIMEOUT",te=(...e)=>e;function a(e){return{ok:!0,value:e}}function u(e,r){let n=r?.cause;return{ok:!1,error:e,...n!==void 0?{cause:n}:{}}}var l=e=>e.ok,f=e=>!e.ok,m=e=>e instanceof C||typeof e=="object"&&e!==null&&"_tag"in e&&e._tag==="UnexpectedError",oe=e=>typeof e=="object"&&e!==null&&"type"in e&&e.type===p;function P(e,r){if(r===void 0){let t=e;return o=>P(o,t)}let n=e;return m(n)?r.UnexpectedError(n):r[n](n)}var k=class extends Error{error;cause;constructor(r){let n=typeof r.error=="string"?r.error:JSON.stringify(r.error);super(`Attempted to unwrap an Err: ${n}`),this.name="UnwrapError",this.error=r.error,this.cause=r.cause}},g=e=>{if(e.ok)return e.value;throw new k(e)},se=(e,r)=>e.ok?e.value:r,ue=(e,r)=>e.ok?e.value:r(e.error,e.cause),ae=e=>g(e),ie=e=>Promise.resolve(e).then(g),ce=e=>e.ok?e.value:null,Ee=e=>e.ok?e.value:void 0;function le(e,r){try{return a(e())}catch(n){return r?u(r(n),{cause:n}):u(n)}}async function pe(e,r){try{return a(await e)}catch(n){return r?u(r(n),{cause:n}):u(n)}}async function fe(e,r){try{return a(await e())}catch(n){return r?u(r(n),{cause:n}):u(n)}}function de(e,r){return e!=null?a(e):u(r())}function Te(e,r){return e.ok?a(r(e.value)):e}function Ce(e,r){return e.ok?e:u(r(e.error,e.cause),{cause:e.cause})}function v(e,r){if(r===void 0){let n=e;return t=>v(t,n)}return e.ok?r.ok(e.value):r.err(e.error,e.cause)}function ye(e,r){return e.ok?r(e.value):e}function Re(e,r){return e.ok&&r(e.value),e}function ke(e,r){return e.ok||r(e.error,e.cause),e}function me(e,r,n){if(!e.ok)return e;try{return a(r(e.value))}catch(t){return u(n(t),{cause:t})}}function ge(e,r,n){if(e.ok)return e;try{return u(r(e.error),{cause:e.cause})}catch(t){return u(n(t),{cause:t})}}function xe(e,r,n){return e.ok?a(r(e.value)):u(n(e.error,e.cause),{cause:e.cause})}function we(e,r){return e.ok?e:r(e.error,e.cause)}async function Ae(e,r){return e.ok?e:r(e.error,e.cause)}function he(e,r){return e.ok?a(e.value):a(r(e.error,e.cause))}async function Pe(e,r){let n=await e;return n.ok?a(n.value):a(await r(n.error,n.cause))}function ve(e){if(typeof e!="object"||e===null||!("ok"in e))return null;let r=e;return r.ok===!0&&"value"in r?a(r.value):r.ok===!1&&"error"in r?u(r.error,{cause:r.cause}):null}function be(e){if(typeof e!="object"||e===null||!("ok"in e))return!1;let r=e;return r.ok===!0&&"value"in r||r.ok===!1&&"error"in r}function Ue(e){let r=[];for(let n of e){if(!n.ok)return n;r.push(n.value)}return a(r)}async function Oe(e){let r=[];for(let n of e)try{let t=await n;if(!t.ok)return t;r.push(t.value)}catch(t){return u({type:p,cause:t},{cause:{type:"PROMISE_REJECTION",reason:t}})}return a(r)}function Be(e){let r=[],n=[];for(let t of e)t.ok?r.push(t.value):n.push({error:t.error,cause:t.cause});return n.length>0?u(n):a(r)}async function De(e){let r=await Promise.all(e.map(o=>Promise.resolve(o).then(s=>({status:"result",result:s})).catch(s=>({status:"rejected",error:{type:p,cause:s},cause:{type:"PROMISE_REJECTION",reason:s}})))),n=[],t=[];for(let o of r)o.status==="rejected"?t.push({error:o.error,cause:o.cause}):o.result.ok?n.push(o.result.value):t.push({error:o.result.error,cause:o.result.cause});return t.length>0?u(t):a(n)}function _e(e){let r=[],n=[];for(let t of e)t.ok?r.push(t.value):n.push(t.error);return{values:r,errors:n}}function Se(e){if(e.length===0)return u({type:"EMPTY_INPUT",message:"any() requires at least one Result"});let r;for(let n of e){if(n.ok)return n;r||(r=n)}return r}async function je(e){return e.length===0?u({type:"EMPTY_INPUT",message:"anyAsync() requires at least one Result"}):new Promise(r=>{let n=!1,t=e.length,o=null;for(let s of e)Promise.resolve(s).catch(i=>u({type:p,cause:i},{cause:{type:"PROMISE_REJECTION",reason:i}})).then(i=>{if(!n){if(i.ok){n=!0,r(i);return}o||(o=i),t--,t===0&&r(o)}})})}function b(e,r){return e.ok?r.ok?a([e.value,r.value]):r:e}async function Fe(e,r){let n=s=>Promise.resolve(s).catch(i=>u({type:p,cause:i},{cause:{type:"PROMISE_REJECTION",reason:i}})),[t,o]=await Promise.all([n(e),n(r)]);return b(t,o)}function Ie(e){return e.ok?e.value:e}var R="DESERIALIZATION_ERROR";function He(e){if(typeof e!="object"||e===null)return u({type:R,value:e});if(!("ok"in e))return u({type:R,value:e});let r=e;return r.ok===!0&&"value"in r?a(r.value):r.ok===!1&&"error"in r?u(r.error,{cause:r.cause}):u({type:R,value:e})}function Ke(e){return e.ok?{ok:!0,value:e.value}:{ok:!1,error:e.error}}function Ne(e,r,n){if(m(e)){let o=r.UnexpectedError;return o?o(e):n(e)}let t=r[e];return t?t(e):n(e)}function O(e,...r){return r.reduce((n,t)=>t(n),e)}function B(...e){return r=>e.reduce((n,t)=>t(n),r)}function D(...e){return r=>e.reduceRight((n,t)=>t(n),r)}var _=e=>e;function Ye(e,r){return l(e)?a(r(e.value)):e}function Je(e,r){return l(e)?r(e.value):e}function qe(e,r,n){return l(e)?a(r(e.value)):u(n(e.error),{cause:e.cause})}function Ze(e,r){return f(e)?u(r(e.error),{cause:e.cause}):e}function Xe(e,r){return l(e)&&r(e.value),e}function Qe(e,r){return f(e)&&r(e.error),e}function er(e,r){return l(e)?r.ok(e.value):r.err(e.error,e.cause)}function rr(e,r){return l(e)?e.value:r(e.error)}function x(e,r){return l(e)?e:r(e.error)}function w(e,r){return l(e)?e.value:r}function A(e,r){return l(e)?e.value:r()}async function S(e,r){let n=await e;return l(n)?a(await r(n.value)):n}async function j(e,r){let n=await e;return l(n)?r(n.value):n}async function F(e,r){let n=await e;return l(n)&&await r(n.value),n}async function I(e,r){let n=await e;return f(n)&&await r(n.error),n}async function nr(e){if(e.length===0)return a([]);let r=new Array(e.length),n=0,t=!1;return new Promise(o=>{e.forEach((s,i)=>{s.then(E=>{t||(f(E)?(t=!0,o(E)):(r[i]=E.value,n++,n===e.length&&(t=!0,o(a(r)))))},E=>{t||(t=!0,o(u({type:p,cause:E},{cause:{type:"PROMISE_REJECTION",reason:E}})))})})})}async function H(e){return Promise.race(e.map(r=>r.catch(n=>u({type:p,cause:n},{cause:{type:"PROMISE_REJECTION",reason:n}}))))}function K(e,r){let n=[];for(let t=0;t<e.length;t++){let o=r(e[t],t);if(f(o))return o;n.push(o.value)}return a(n)}async function N(e,r){let n=[];for(let t=0;t<e.length;t++){let o=await r(e[t],t);if(f(o))return o;n.push(o.value)}return a(n)}async function M(e,r){return nr(e.map((n,t)=>r(n,t)))}var L={map:e=>r=>Ye(r,e),flatMap:e=>r=>Je(r,e),bimap:(e,r)=>n=>qe(n,e,r),mapError:e=>r=>Ze(r,e),tap:e=>r=>Xe(r,e),tapError:e=>r=>Qe(r,e),match:e=>r=>er(r,e),recover:e=>r=>rr(r,e),recoverWith:e=>r=>x(r,e),getOrElse:e=>r=>w(r,e),getOrElseLazy:e=>r=>A(r,e)};function Me(e,r){let n=t=>((...o)=>{let s=o.at(-1),i=o.length>0&&typeof s=="object"&&s!==null&&!Array.isArray(s)&&typeof s!="function",E=i?s:void 0,d=i?o.slice(0,-1):o,T={...r,...E?.deps??{}},h=E?{...E,deps:T}:{deps:T};return e[t](...d,h)});return{run:n("run"),runWithState:n("runWithState"),withDeps(t){return Me(e,{...r,...t})}}}var kr={...U,TaggedError:c,pipe:O,flow:B,compose:D,identity:_,R:L,recoverWith:x,getOrElse:w,getOrElseLazy:A,mapAsync:S,flatMapAsync:j,tapAsync:F,tapErrorAsync:I,race:H,traverse:K,traverseAsync:N,traverseParallel:M};export{re as AWAITLY_CANCELLED,ne as AWAITLY_TIMEOUT,ee as AWAITLY_UNEXPECTED,kr as Awaitly,R as DESERIALIZATION_ERROR,p as PROMISE_REJECTED,L as R,c as TaggedError,C as UnexpectedError,k as UnwrapError,Ue as all,Oe as allAsync,Be as allSettled,De as allSettledAsync,ye as andThen,Se as any,je as anyAsync,xe as bimap,D as compose,He as deserialize,u as err,j as flatMapAsync,Ie as flatten,B as flow,le as from,de as fromNullable,pe as fromPromise,w as getOrElse,A as getOrElseLazy,ve as hydrate,_ as identity,f as isErr,l as isOk,oe as isPromiseRejectedError,be as isSerializedResult,m as isUnexpectedError,Te as map,S as mapAsync,Ce as mapError,ge as mapErrorTry,me as mapTry,v as match,P as matchError,Ne as matchErrorPartial,a as ok,we as orElse,Ae as orElseAsync,_e as partition,O as pipe,H as race,he as recover,Pe as recoverAsync,x as recoverWith,ce as runOrNull,ae as runOrThrow,ie as runOrThrowAsync,Ee as runOrUndefined,Ke as serialize,te as tags,Re as tap,F as tapAsync,ke as tapError,I as tapErrorAsync,K as traverse,N as traverseAsync,M as traverseParallel,fe as tryAsync,g as unwrap,se as unwrapOr,ue as unwrapOrElse,Me as withDeps,b as zip,Fe as zipAsync};
+// src/slugs.ts
+var AWAITLY_SLUGS = {
+  // --- step-* ---
+  "step-require-id": "step-require-id",
+  "step-no-immediate-execution": "step-no-immediate-execution",
+  "step-require-thunk-for-key": "step-require-thunk-for-key",
+  "step-no-bare-await": "step-no-bare-await",
+  "step-no-try-catch-wrap": "step-no-try-catch-wrap",
+  "step-stable-cache-keys": "step-stable-cache-keys",
+  // --- workflow-* ---
+  "workflow-no-floating": "workflow-no-floating",
+  "workflow-options-position": "workflow-options-position",
+  "workflow-callback-shape": "workflow-callback-shape",
+  "workflow-no-callable-form": "workflow-no-callable-form",
+  "workflow-no-dynamic-import": "workflow-no-dynamic-import",
+  "workflow-prefer-step-if": "workflow-prefer-step-if",
+  "workflow-prefer-step-foreach": "workflow-prefer-step-foreach",
+  // --- result-* ---
+  "result-no-floating": "result-no-floating",
+  "result-require-handling": "result-require-handling",
+  "result-no-double-wrap": "result-no-double-wrap",
+  "result-no-manual-propagation": "result-no-manual-propagation",
+  "result-no-direct-ok-err": "result-no-direct-ok-err",
+  // --- error-* ---
+  "error-check-unexpected-first": "error-check-unexpected-first",
+  "error-access-cause": "error-access-cause",
+  "error-normalize": "error-normalize",
+  "error-no-throw-in-deps": "error-no-throw-in-deps",
+  // --- concurrency-* ---
+  "concurrency-no-promise-all": "concurrency-no-promise-all",
+  "concurrency-no-promise-race": "concurrency-no-promise-race",
+  "concurrency-no-promise-allsettled": "concurrency-no-promise-allsettled",
+  // --- runtime-* ---
+  "runtime-step-timeout": "runtime-step-timeout",
+  "runtime-step-aborted": "runtime-step-aborted",
+  "runtime-retry-exhausted": "runtime-retry-exhausted",
+  "runtime-rate-limit": "runtime-rate-limit",
+  "runtime-circuit-open": "runtime-circuit-open",
+  "runtime-unexpected": "runtime-unexpected",
+  "runtime-resolver-not-found": "runtime-resolver-not-found",
+  "runtime-saga-compensation": "runtime-saga-compensation"
+};
+function slugCategory(slug) {
+  return slug.split("-")[0];
+}
+function slugDocsUrl(slug) {
+  return `https://jagreehal.github.io/awaitly/rules/#${slug}`;
+}
+function isAwaitlySlug(value) {
+  return Object.prototype.hasOwnProperty.call(AWAITLY_SLUGS, value);
+}
+var ALL_SLUGS = Object.keys(
+  AWAITLY_SLUGS
+);
+
+// src/tagged-error.ts
+var InternalTaggedErrorBase = class extends Error {
+  type;
+  /** @deprecated Use `type`. */
+  _tag;
+};
+function TaggedError(tag2, options) {
+  return class extends InternalTaggedErrorBase {
+    type = tag2;
+    /** @deprecated Use `type`. */
+    _tag = tag2;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(props, errorOptions) {
+      const message = options?.message ? options.message(props ?? {}) : tag2;
+      super(message);
+      this.name = tag2;
+      if (options?.slug !== void 0) {
+        if (!options.hint) {
+          throw new TypeError(
+            `TaggedError: 'hint' is required when 'slug' is set (slug: "${options.slug}")`
+          );
+        }
+        Object.defineProperty(this, "code", {
+          value: options.slug,
+          enumerable: true,
+          writable: false,
+          configurable: false
+        });
+        Object.defineProperty(this, "hint", {
+          value: options.hint,
+          enumerable: true,
+          writable: false,
+          configurable: false
+        });
+        Object.defineProperty(this, "docsUrl", {
+          value: slugDocsUrl(options.slug),
+          enumerable: true,
+          writable: false,
+          configurable: false
+        });
+      }
+      Object.setPrototypeOf(this, new.target.prototype);
+      if (props && typeof props === "object") {
+        let safeProps;
+        if (options?.slug !== void 0) {
+          const {
+            _tag: _,
+            type: _t,
+            name: _n,
+            message: _m,
+            stack: _s,
+            code: _c,
+            hint: _h,
+            docsUrl: _d,
+            ...rest
+          } = props;
+          safeProps = rest;
+        } else {
+          const {
+            _tag: _,
+            type: _t,
+            name: _n,
+            message: _m,
+            stack: _s,
+            ...rest
+          } = props;
+          safeProps = rest;
+        }
+        const hasUserCause = Object.prototype.hasOwnProperty.call(
+          safeProps,
+          "cause"
+        );
+        const userCause = hasUserCause ? safeProps.cause : void 0;
+        if (hasUserCause) {
+          delete safeProps.cause;
+        }
+        const hasOptionsCause = errorOptions?.cause !== void 0;
+        if (hasUserCause && hasOptionsCause) {
+          throw new TypeError(
+            "TaggedError: cannot provide 'cause' in props when also setting ErrorOptions.cause"
+          );
+        }
+        Object.assign(this, safeProps);
+        if (hasUserCause) {
+          this.cause = userCause;
+        }
+        if (hasOptionsCause) {
+          this.cause = errorOptions?.cause;
+        }
+      } else if (errorOptions?.cause !== void 0) {
+        this.cause = errorOptions.cause;
+      }
+    }
+  };
+}
+Object.defineProperty(TaggedError, Symbol.hasInstance, {
+  value: (instance) => instance instanceof InternalTaggedErrorBase
+});
+((TaggedError2) => {
+  function isError(value) {
+    return value instanceof Error;
+  }
+  TaggedError2.isError = isError;
+  function isTaggedError(value) {
+    return value instanceof InternalTaggedErrorBase;
+  }
+  TaggedError2.isTaggedError = isTaggedError;
+  function match2(error, handlers) {
+    const tag2 = error._tag;
+    const handler = handlers[tag2];
+    return handler(
+      error
+    );
+  }
+  TaggedError2.match = match2;
+  function matchPartial(error, handlers, otherwise) {
+    const tag2 = error._tag;
+    const handler = handlers[tag2];
+    if (handler) {
+      return handler(
+        error
+      );
+    }
+    return otherwise(error);
+  }
+  TaggedError2.matchPartial = matchPartial;
+})(TaggedError || (TaggedError = {}));
+
+// src/errors.ts
+function makeError(tag2, options) {
+  const messageGenerator = options?.message ?? (() => tag2);
+  const defaults = options?.defaults ?? {};
+  const BaseClass = TaggedError(tag2, {
+    message: (props) => messageGenerator({ ...defaults, ...props })
+  });
+  return class extends BaseClass {
+    constructor(props) {
+      super({ ...defaults, ...props });
+      Object.assign(this, { ...defaults, ...props });
+    }
+  };
+}
+var TimeoutError = class extends (/* @__PURE__ */ TaggedError("TimeoutError", {
+  slug: "runtime-step-timeout",
+  hint: "Increase the step's timeout option, or check why the upstream operation is slow.",
+  message: (p) => p.operation ? `TimeoutError: ${p.operation} timed out after ${p.ms}ms` : `TimeoutError: Operation timed out after ${p.ms}ms`
+})) {
+};
+var RetryExhaustedError = class extends (/* @__PURE__ */ TaggedError("RetryExhaustedError", {
+  slug: "runtime-retry-exhausted",
+  hint: "All retry attempts failed. Inspect lastError and decide whether to surface it or compensate.",
+  message: (p) => p.operation ? `RetryExhaustedError: ${p.operation} failed after ${p.attempts} attempts` : `RetryExhaustedError: Operation failed after ${p.attempts} attempts`
+})) {
+};
+var RateLimitError = class extends (/* @__PURE__ */ TaggedError("RateLimitError", {
+  slug: "runtime-rate-limit",
+  hint: "Wait retryAfterMs before retrying, or apply step.cache to deduplicate calls.",
+  message: (p) => p.limiterName ? `RateLimitError: Rate limit exceeded for ${p.limiterName}${p.retryAfterMs ? `, retry after ${p.retryAfterMs}ms` : ""}` : `RateLimitError: Rate limit exceeded${p.retryAfterMs ? `, retry after ${p.retryAfterMs}ms` : ""}`
+})) {
+};
+var CircuitBreakerOpenError = class extends (/* @__PURE__ */ TaggedError(
+  "CircuitBreakerOpenError",
+  {
+    slug: "runtime-circuit-open",
+    hint: "The circuit is open. Wait for it to half-open or fall back to a degraded path.",
+    message: (p) => `CircuitBreakerOpenError: Circuit ${p.circuitName} is ${p.state ?? "OPEN"}${p.retryAfterMs ? `, retry after ${Math.ceil(p.retryAfterMs / 1e3)}s` : ""}`
+  }
+)) {
+};
+var ValidationError = class extends (/* @__PURE__ */ TaggedError("ValidationError", {
+  message: (p) => `ValidationError: Invalid ${p.field} - ${p.reason}`
+})) {
+};
+var NotFoundError = class extends (/* @__PURE__ */ TaggedError("NotFoundError", {
+  message: (p) => p.id ? `NotFoundError: ${p.resource} with id ${p.id} not found` : `NotFoundError: ${p.resource} not found`
+})) {
+};
+var UnauthorizedError = class extends (/* @__PURE__ */ TaggedError("UnauthorizedError", {
+  message: (p) => p.reason ? `UnauthorizedError: ${p.reason}` : p.action && p.resource ? `UnauthorizedError: Not authorized to ${p.action} ${p.resource}` : "UnauthorizedError: Access denied"
+})) {
+};
+var NetworkError = class extends (/* @__PURE__ */ TaggedError("NetworkError", {
+  message: (p) => p.url ? `NetworkError: ${p.reason} (${p.url})` : `NetworkError: ${p.reason}`
+})) {
+};
+var CompensationError = class extends (/* @__PURE__ */ TaggedError("CompensationError", {
+  slug: "runtime-saga-compensation",
+  hint: "A saga compensation step failed. Inspect compensationError and ensure compensation is idempotent.",
+  message: (p) => `CompensationError: Failed to compensate step ${p.step}`
+})) {
+};
+var UnexpectedError = class extends (/* @__PURE__ */ TaggedError("UnexpectedError", {
+  slug: "runtime-unexpected",
+  hint: "An unexpected exception escaped a step. Inspect cause; consider returning a typed Result instead of throwing.",
+  message: (p) => `UnexpectedError: ${p.cause instanceof Error ? p.cause.message : String(p.cause ?? "unknown")}`
+})) {
+};
+var AWAITLY_SYSTEM_ERROR_CLASSES = [
+  TimeoutError,
+  RetryExhaustedError,
+  RateLimitError,
+  CircuitBreakerOpenError,
+  CompensationError,
+  UnexpectedError
+];
+function isTimeoutError(error) {
+  return TaggedError.isTaggedError(error) && error._tag === "TimeoutError";
+}
+function isRetryExhaustedError(error) {
+  return TaggedError.isTaggedError(error) && error._tag === "RetryExhaustedError";
+}
+function isRateLimitError(error) {
+  return TaggedError.isTaggedError(error) && error._tag === "RateLimitError";
+}
+function isCircuitBreakerOpenError(error) {
+  return TaggedError.isTaggedError(error) && error._tag === "CircuitBreakerOpenError";
+}
+function isValidationError(error) {
+  return TaggedError.isTaggedError(error) && error._tag === "ValidationError";
+}
+function isNotFoundError(error) {
+  return TaggedError.isTaggedError(error) && error._tag === "NotFoundError";
+}
+function isUnauthorizedError(error) {
+  return TaggedError.isTaggedError(error) && error._tag === "UnauthorizedError";
+}
+function isNetworkError(error) {
+  return TaggedError.isTaggedError(error) && error._tag === "NetworkError";
+}
+function isCompensationError(error) {
+  return TaggedError.isTaggedError(error) && error._tag === "CompensationError";
+}
+function isAwaitlyError(error) {
+  if (!TaggedError.isTaggedError(error)) return false;
+  const tag2 = error._tag;
+  return [
+    "TimeoutError",
+    "RetryExhaustedError",
+    "RateLimitError",
+    "CircuitBreakerOpenError",
+    "ValidationError",
+    "NotFoundError",
+    "UnauthorizedError",
+    "NetworkError",
+    "CompensationError",
+    "UnexpectedError"
+  ].includes(tag2);
+}
+
+// src/result/index.ts
+var PROMISE_REJECTED = "PROMISE_REJECTED";
+var AWAITLY_UNEXPECTED = "AWAITLY_UNEXPECTED";
+var AWAITLY_CANCELLED = "AWAITLY_CANCELLED";
+var AWAITLY_TIMEOUT = "AWAITLY_TIMEOUT";
+var tags = (...t) => t;
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error, options) {
+  const cause = options?.cause;
+  return { ok: false, error, ...cause !== void 0 ? { cause } : {} };
+}
+var isOk = (r) => r.ok;
+var isErr = (r) => !r.ok;
+var isUnexpectedError = (e) => e instanceof UnexpectedError || typeof e === "object" && e !== null && "_tag" in e && e._tag === "UnexpectedError";
+var isPromiseRejectedError = (e) => typeof e === "object" && e !== null && "type" in e && e.type === PROMISE_REJECTED;
+function matchError(errorOrHandlers, handlers) {
+  if (handlers === void 0) {
+    const h = errorOrHandlers;
+    return (e) => matchError(e, h);
+  }
+  const error = errorOrHandlers;
+  if (isUnexpectedError(error)) {
+    return handlers.UnexpectedError(error);
+  }
+  return handlers[error](error);
+}
+var UnwrapError = class extends Error {
+  error;
+  cause;
+  constructor(result) {
+    const errorStr = typeof result.error === "string" ? result.error : JSON.stringify(result.error);
+    super(`Attempted to unwrap an Err: ${errorStr}`);
+    this.name = "UnwrapError";
+    this.error = result.error;
+    this.cause = result.cause;
+  }
+};
+var unwrap = (r) => {
+  if (r.ok) return r.value;
+  throw new UnwrapError(r);
+};
+var unwrapOr = (r, defaultValue) => r.ok ? r.value : defaultValue;
+var unwrapOrElse = (r, fn) => r.ok ? r.value : fn(r.error, r.cause);
+var runOrThrow = (r) => unwrap(r);
+var runOrThrowAsync = (ar) => Promise.resolve(ar).then(unwrap);
+var runOrNull = (r) => r.ok ? r.value : null;
+var runOrUndefined = (r) => r.ok ? r.value : void 0;
+function from(fn, onError) {
+  try {
+    return ok(fn());
+  } catch (cause) {
+    return onError ? err(onError(cause), { cause }) : err(cause);
+  }
+}
+async function fromPromise(promise, onError) {
+  try {
+    return ok(await promise);
+  } catch (cause) {
+    return onError ? err(onError(cause), { cause }) : err(cause);
+  }
+}
+async function tryAsync(fn, onError) {
+  try {
+    return ok(await fn());
+  } catch (cause) {
+    return onError ? err(onError(cause), { cause }) : err(cause);
+  }
+}
+function fromNullable(value, onNull) {
+  return value != null ? ok(value) : err(onNull());
+}
+function map(r, fn) {
+  return r.ok ? ok(fn(r.value)) : r;
+}
+function mapError(r, fn) {
+  return r.ok ? r : err(fn(r.error, r.cause), { cause: r.cause });
+}
+function match(r, handlers) {
+  if (handlers === void 0) {
+    const h = r;
+    return (result) => match(result, h);
+  }
+  if (r.ok) return handlers.ok(r.value);
+  if (typeof handlers.err === "function") return handlers.err(r.error, r.cause);
+  const e = r.error;
+  const key = typeof e === "string" ? e : e?.type ?? e?._tag;
+  const handler = key === void 0 ? void 0 : handlers[key];
+  if (typeof handler === "function") return handler(e, r.cause);
+  throw new TypeError(
+    `match: no handler for error type "${String(key)}". Add a handler for it, or use the { ok, err } form for a catch-all.`
+  );
+}
+function andThen(r, fn) {
+  return r.ok ? fn(r.value) : r;
+}
+function tap(r, fn) {
+  if (r.ok) fn(r.value);
+  return r;
+}
+function tapError(r, fn) {
+  if (!r.ok) fn(r.error, r.cause);
+  return r;
+}
+function mapTry(r, fn, onError) {
+  if (!r.ok) return r;
+  try {
+    return ok(fn(r.value));
+  } catch (error) {
+    return err(onError(error), { cause: error });
+  }
+}
+function mapErrorTry(r, fn, onError) {
+  if (r.ok) return r;
+  try {
+    return err(fn(r.error), { cause: r.cause });
+  } catch (error) {
+    return err(onError(error), { cause: error });
+  }
+}
+function bimap(r, onOk, onErr) {
+  return r.ok ? ok(onOk(r.value)) : err(onErr(r.error, r.cause), { cause: r.cause });
+}
+function orElse(r, fn) {
+  return r.ok ? r : fn(r.error, r.cause);
+}
+async function orElseAsync(r, fn) {
+  return r.ok ? r : fn(r.error, r.cause);
+}
+function recover(r, fn) {
+  return r.ok ? ok(r.value) : ok(fn(r.error, r.cause));
+}
+async function recoverAsync(r, fn) {
+  const resolved = await r;
+  if (resolved.ok) return ok(resolved.value);
+  return ok(await fn(resolved.error, resolved.cause));
+}
+function hydrate(value) {
+  if (typeof value !== "object" || value === null) return null;
+  if (!("ok" in value)) return null;
+  const obj = value;
+  if (obj.ok === true && "value" in obj) {
+    return ok(obj.value);
+  }
+  if (obj.ok === false && "error" in obj) {
+    return err(obj.error, { cause: obj.cause });
+  }
+  return null;
+}
+function isSerializedResult(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("ok" in value)) return false;
+  const obj = value;
+  return obj.ok === true && "value" in obj || obj.ok === false && "error" in obj;
+}
+function all(results) {
+  const values = [];
+  for (const result of results) {
+    if (!result.ok) {
+      return result;
+    }
+    values.push(result.value);
+  }
+  return ok(values);
+}
+async function allAsync(results) {
+  const values = [];
+  for (const resultOrPromise of results) {
+    try {
+      const r = await resultOrPromise;
+      if (!r.ok) return r;
+      values.push(r.value);
+    } catch (reason) {
+      return err(
+        { type: PROMISE_REJECTED, cause: reason },
+        { cause: { type: "PROMISE_REJECTION", reason } }
+      );
+    }
+  }
+  return ok(values);
+}
+function allSettled(results) {
+  const values = [];
+  const errors = [];
+  for (const result of results) {
+    if (result.ok) {
+      values.push(result.value);
+    } else {
+      errors.push({ error: result.error, cause: result.cause });
+    }
+  }
+  if (errors.length > 0) {
+    return err(errors);
+  }
+  return ok(values);
+}
+async function allSettledAsync(results) {
+  const settled = await Promise.all(
+    results.map(
+      (item) => Promise.resolve(item).then((result) => ({ status: "result", result })).catch((reason) => ({
+        status: "rejected",
+        error: { type: PROMISE_REJECTED, cause: reason },
+        cause: { type: "PROMISE_REJECTION", reason }
+      }))
+    )
+  );
+  const values = [];
+  const errors = [];
+  for (const item of settled) {
+    if (item.status === "rejected") {
+      errors.push({ error: item.error, cause: item.cause });
+    } else if (item.result.ok) {
+      values.push(item.result.value);
+    } else {
+      errors.push({ error: item.result.error, cause: item.result.cause });
+    }
+  }
+  if (errors.length > 0) {
+    return err(errors);
+  }
+  return ok(values);
+}
+function partition(results) {
+  const values = [];
+  const errors = [];
+  for (const r of results) {
+    if (r.ok) values.push(r.value);
+    else errors.push(r.error);
+  }
+  return { values, errors };
+}
+function any(results) {
+  if (results.length === 0) {
+    return err({ type: "EMPTY_INPUT", message: "any() requires at least one Result" });
+  }
+  let firstErr;
+  for (const r of results) {
+    if (r.ok) return r;
+    if (!firstErr) firstErr = r;
+  }
+  return firstErr;
+}
+async function anyAsync(results) {
+  if (results.length === 0) {
+    return err({ type: "EMPTY_INPUT", message: "anyAsync() requires at least one Result" });
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    let pendingCount = results.length;
+    let firstError = null;
+    for (const item of results) {
+      Promise.resolve(item).catch(
+        (reason) => err(
+          { type: PROMISE_REJECTED, cause: reason },
+          { cause: { type: "PROMISE_REJECTION", reason } }
+        )
+      ).then((result) => {
+        if (settled) return;
+        if (result.ok) {
+          settled = true;
+          resolve(result);
+          return;
+        }
+        if (!firstError) firstError = result;
+        pendingCount--;
+        if (pendingCount === 0) {
+          resolve(firstError);
+        }
+      });
+    }
+  });
+}
+function zip(a, b) {
+  if (!a.ok) return a;
+  if (!b.ok) return b;
+  return ok([a.value, b.value]);
+}
+async function zipAsync(a, b) {
+  const wrapRejection = (p) => Promise.resolve(p).catch(
+    (reason) => err(
+      { type: PROMISE_REJECTED, cause: reason },
+      { cause: { type: "PROMISE_REJECTION", reason } }
+    )
+  );
+  const [ra, rb] = await Promise.all([wrapRejection(a), wrapRejection(b)]);
+  return zip(ra, rb);
+}
+function flatten(result) {
+  if (!result.ok) return result;
+  return result.value;
+}
+var DESERIALIZATION_ERROR = "DESERIALIZATION_ERROR";
+function deserialize(value) {
+  if (typeof value !== "object" || value === null) {
+    return err({ type: DESERIALIZATION_ERROR, value });
+  }
+  if (!("ok" in value)) {
+    return err({ type: DESERIALIZATION_ERROR, value });
+  }
+  const obj = value;
+  if (obj.ok === true && "value" in obj) {
+    return ok(obj.value);
+  }
+  if (obj.ok === false && "error" in obj) {
+    return err(obj.error, { cause: obj.cause });
+  }
+  return err({ type: DESERIALIZATION_ERROR, value });
+}
+function serialize(result) {
+  return result.ok ? { ok: true, value: result.value } : { ok: false, error: result.error };
+}
+function matchErrorPartial(error, handlers, fallback2) {
+  if (isUnexpectedError(error)) {
+    const h2 = handlers.UnexpectedError;
+    return h2 ? h2(error) : fallback2(error);
+  }
+  const h = handlers[error];
+  return h ? h(error) : fallback2(error);
+}
+
+// src/di.ts
+function withDeps(workflow, overrides) {
+  const forward = (method) => ((...args) => {
+    const last = args.at(-1);
+    const hasConfig = args.length > 0 && typeof last === "object" && last !== null && !Array.isArray(last) && typeof last !== "function";
+    const config = hasConfig ? last : void 0;
+    const head = hasConfig ? args.slice(0, -1) : args;
+    const mergedDeps = { ...overrides, ...config?.deps ?? {} };
+    const mergedConfig = config ? { ...config, deps: mergedDeps } : { deps: mergedDeps };
+    return workflow[method](...head, mergedConfig);
+  });
+  return {
+    run: forward("run"),
+    runWithState: forward("runWithState"),
+    withDeps(nextOverrides) {
+      return withDeps(workflow, { ...overrides, ...nextOverrides });
+    }
+  };
+}
+
+// src/duration.ts
+function millis(ms) {
+  return { _tag: "Duration", millis: ms };
+}
+function seconds(s) {
+  return { _tag: "Duration", millis: s * 1e3 };
+}
+function minutes(m) {
+  return { _tag: "Duration", millis: m * 60 * 1e3 };
+}
+function hours(h) {
+  return { _tag: "Duration", millis: h * 60 * 60 * 1e3 };
+}
+function days(d) {
+  return { _tag: "Duration", millis: d * 24 * 60 * 60 * 1e3 };
+}
+var zero = { _tag: "Duration", millis: 0 };
+var infinity = { _tag: "Duration", millis: Infinity };
+function toMillis(duration) {
+  return duration.millis;
+}
+function toSeconds(duration) {
+  return duration.millis / 1e3;
+}
+function toMinutes(duration) {
+  return duration.millis / (60 * 1e3);
+}
+function toHours(duration) {
+  return duration.millis / (60 * 60 * 1e3);
+}
+function toDays(duration) {
+  return duration.millis / (24 * 60 * 60 * 1e3);
+}
+function add(a, b) {
+  return { _tag: "Duration", millis: a.millis + b.millis };
+}
+function subtract(a, b) {
+  return { _tag: "Duration", millis: Math.max(0, a.millis - b.millis) };
+}
+function multiply(duration, factor) {
+  return { _tag: "Duration", millis: duration.millis * factor };
+}
+function divide(duration, divisor) {
+  return { _tag: "Duration", millis: duration.millis / divisor };
+}
+function lessThan(a, b) {
+  return a.millis < b.millis;
+}
+function lessThanOrEqual(a, b) {
+  return a.millis <= b.millis;
+}
+function greaterThan(a, b) {
+  return a.millis > b.millis;
+}
+function greaterThanOrEqual(a, b) {
+  return a.millis >= b.millis;
+}
+function equals(a, b) {
+  return a.millis === b.millis;
+}
+function min(a, b) {
+  return a.millis <= b.millis ? a : b;
+}
+function max(a, b) {
+  return a.millis >= b.millis ? a : b;
+}
+function clamp(duration, minimum, maximum) {
+  return min(max(duration, minimum), maximum);
+}
+function isZero(duration) {
+  return duration.millis === 0;
+}
+function isInfinite(duration) {
+  return duration.millis === Infinity;
+}
+function isFinite(duration) {
+  return Number.isFinite(duration.millis) && duration.millis > 0;
+}
+function isDuration(value) {
+  return typeof value === "object" && value !== null && "_tag" in value && value._tag === "Duration" && "millis" in value && typeof value.millis === "number";
+}
+function format(duration) {
+  const ms = duration.millis;
+  if (ms === Infinity) return "\u221E";
+  if (ms === 0) return "0ms";
+  const days2 = Math.floor(ms / (24 * 60 * 60 * 1e3));
+  const hours2 = Math.floor(ms % (24 * 60 * 60 * 1e3) / (60 * 60 * 1e3));
+  const minutes2 = Math.floor(ms % (60 * 60 * 1e3) / (60 * 1e3));
+  const seconds2 = Math.floor(ms % (60 * 1e3) / 1e3);
+  const millis2 = ms % 1e3;
+  const parts = [];
+  if (days2 > 0) parts.push(`${days2}d`);
+  if (hours2 > 0) parts.push(`${hours2}h`);
+  if (minutes2 > 0) parts.push(`${minutes2}m`);
+  if (seconds2 > 0) parts.push(`${seconds2}s`);
+  if (millis2 > 0 && parts.length === 0) parts.push(`${millis2}ms`);
+  return parts.join(" ") || "0ms";
+}
+function parse(input) {
+  const match2 = input.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i);
+  if (!match2) return void 0;
+  const value = parseFloat(match2[1]);
+  const unit = match2[2].toLowerCase();
+  switch (unit) {
+    case "ms":
+      return millis(value);
+    case "s":
+      return seconds(value);
+    case "m":
+      return minutes(value);
+    case "h":
+      return hours(value);
+    case "d":
+      return days(value);
+    default:
+      return void 0;
+  }
+}
+var Duration = {
+  // Constructors
+  millis,
+  seconds,
+  minutes,
+  hours,
+  days,
+  zero,
+  infinity,
+  // Conversions
+  toMillis,
+  toSeconds,
+  toMinutes,
+  toHours,
+  toDays,
+  // Operations
+  add,
+  subtract,
+  multiply,
+  divide,
+  // Comparisons
+  lessThan,
+  lessThanOrEqual,
+  greaterThan,
+  greaterThanOrEqual,
+  equals,
+  min,
+  max,
+  clamp,
+  // Predicates
+  isZero,
+  isInfinite,
+  isFinite,
+  isDuration,
+  // Formatting
+  format,
+  parse
+};
+
+// src/core/bound-steps.ts
+var isDepResultShaped = (value) => typeof value === "object" && value !== null && "ok" in value && typeof value.ok === "boolean" && (value.ok ? "value" in value : "error" in value);
+var bindSteps = (deps, step) => {
+  const steps = {};
+  const invocationCounts = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(deps)) {
+    const dep = deps[key];
+    if (typeof dep !== "function") continue;
+    steps[key] = (...args) => {
+      const count = (invocationCounts.get(key) ?? 0) + 1;
+      invocationCounts.set(key, count);
+      const stepKey = count === 1 ? key : `${key}#${count}`;
+      return step(stepKey, async () => {
+        const value = await dep(...args);
+        return isDepResultShaped(value) ? value : ok(value);
+      });
+    };
+  }
+  return steps;
+};
+
+// src/core/policies.ts
+var toMs = (d) => typeof d === "number" ? d : toMillis(d);
+var attemptCall = async (fn, args) => {
+  try {
+    const value = await fn(...args);
+    if (isDepResultShaped(value)) {
+      return value.ok ? { kind: "ok", value: value.value } : { kind: "err", error: value.error, result: value };
+    }
+    return { kind: "ok", value };
+  } catch (thrown) {
+    return { kind: "threw", thrown };
+  }
+};
+var named = (wrapped, source) => {
+  const name = source.name;
+  if (name) {
+    Object.defineProperty(wrapped, "name", { value: name, configurable: true });
+  }
+  return wrapped;
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function retry(fn, options) {
+  const attempts = Math.max(1, Math.trunc(options.attempts));
+  const baseDelay = options.delay === void 0 ? 0 : toMs(options.delay);
+  const maxDelay = options.maxDelay === void 0 ? Infinity : toMs(options.maxDelay);
+  const backoff = options.backoff ?? "fixed";
+  const delayFor = (attempt) => {
+    const raw = backoff === "exponential" ? baseDelay * 2 ** (attempt - 1) : backoff === "linear" ? baseDelay * attempt : baseDelay;
+    return Math.min(raw, maxDelay);
+  };
+  const wrapped = async (...args) => {
+    let last = { kind: "threw", thrown: void 0 };
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      last = await attemptCall(fn, args);
+      if (last.kind === "ok") return ok(last.value);
+      const failure = last.kind === "err" ? last.error : last.thrown;
+      if (options.retryIf && !options.retryIf(failure)) break;
+      if (attempt < attempts) {
+        options.onRetry?.({ attempt, failure });
+        const ms = delayFor(attempt);
+        if (ms > 0) await sleep(ms);
+      }
+    }
+    if (last.kind === "err") return last.result;
+    throw last.thrown;
+  };
+  return named(wrapped, fn);
+}
+function timeout(fn, after) {
+  const ms = toMs(after);
+  const TIMED_OUT = /* @__PURE__ */ Symbol("timed-out");
+  const wrapped = async (...args) => {
+    let timer;
+    try {
+      const outcome = await Promise.race([
+        attemptCall(fn, args),
+        new Promise((resolve) => {
+          timer = setTimeout(() => resolve(TIMED_OUT), ms);
+        })
+      ]);
+      if (outcome === TIMED_OUT) {
+        return err(new TimeoutError({ operation: fn.name || void 0, ms }));
+      }
+      if (outcome.kind === "ok") return ok(outcome.value);
+      if (outcome.kind === "err") return outcome.result;
+      throw outcome.thrown;
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  };
+  return named(wrapped, fn);
+}
+function fallback(fn, onFailure) {
+  const wrapped = async (...args) => {
+    const outcome = await attemptCall(fn, args);
+    if (outcome.kind === "ok") return ok(outcome.value);
+    const failure = outcome.kind === "err" ? outcome.error : new UnexpectedError({ cause: outcome.thrown });
+    const recovered = await attemptCall(onFailure, [failure, ...args]);
+    if (recovered.kind === "ok") return ok(recovered.value);
+    if (recovered.kind === "err") return recovered.result;
+    throw recovered.thrown;
+  };
+  return named(wrapped, fn);
+}
+
+// src/core/index.ts
+function parseDurationString(input) {
+  const match2 = input.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i);
+  if (!match2) return void 0;
+  const value = parseFloat(match2[1]);
+  const unit = match2[2].toLowerCase();
+  const multipliers = { ms: 1, s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+  return { _tag: "Duration", millis: value * (multipliers[unit] ?? 1) };
+}
+function defaultCatchUnexpected(cause) {
+  return new UnexpectedError({ cause });
+}
+function ok2(value) {
+  return { ok: true, value };
+}
+function err2(error, options) {
+  const cause = options?.cause;
+  return { ok: false, error, ...cause !== void 0 ? { cause } : {} };
+}
+function extractErrorTag(error) {
+  if (error == null) return "unknown";
+  if (typeof error === "string") return error.trim() || "unknown";
+  if (typeof error === "object") {
+    const tagged = error;
+    if (typeof tagged._tag === "string") {
+      const trimmed = tagged._tag.trim();
+      if (trimmed) return trimmed;
+    }
+    if (typeof tagged.tag === "string") {
+      const trimmed = tagged.tag.trim();
+      if (trimmed) return trimmed;
+    }
+    if (typeof tagged.code === "string") {
+      const trimmed = tagged.code.trim();
+      if (trimmed) return trimmed;
+    } else if (typeof tagged.code === "number") {
+      return String(tagged.code);
+    }
+    if (error instanceof Error && error.name) {
+      const trimmed = error.name.trim();
+      if (trimmed) return trimmed;
+    }
+  }
+  return "unknown";
+}
+function lookupErrorClassification(tag2, errorMeta) {
+  if (!errorMeta || !tag2) return void 0;
+  return errorMeta[tag2];
+}
+function extractStepMetadata(options) {
+  const { intent, domain, owner, tags: tags3, stateChanges, emits, calls } = options;
+  if (!intent && !domain && !owner && !tags3?.length && !stateChanges?.length && !emits?.length && !calls?.length) {
+    return void 0;
+  }
+  const metadata = {};
+  if (intent) metadata.intent = intent;
+  if (domain) metadata.domain = domain;
+  if (owner) metadata.owner = owner;
+  if (tags3?.length) metadata.tags = tags3;
+  if (stateChanges?.length) metadata.stateChanges = stateChanges;
+  if (emits?.length) metadata.emits = emits;
+  if (calls?.length) metadata.calls = calls;
+  return metadata;
+}
+function buildStepErrorPayload(error, errorMeta, origin, attempt, cumulativeDurationMs) {
+  const tag2 = extractErrorTag(error);
+  const classification = lookupErrorClassification(tag2, errorMeta);
+  const diagnostics = { tag: tag2, origin };
+  if (classification !== void 0) diagnostics.classification = classification;
+  if (attempt !== void 0) diagnostics.attempt = attempt;
+  if (cumulativeDurationMs !== void 0) diagnostics.cumulativeDurationMs = cumulativeDurationMs;
+  return diagnostics;
+}
+var STEP_TIMEOUT_MARKER = /* @__PURE__ */ Symbol.for("step_timeout_marker");
+function isStepTimeoutError(e) {
+  if (typeof e !== "object" || e === null) {
+    return false;
+  }
+  if (e.type === "STEP_TIMEOUT") {
+    return true;
+  }
+  return STEP_TIMEOUT_MARKER in e;
+}
+function getStepTimeoutMeta(e) {
+  if (typeof e !== "object" || e === null) {
+    return void 0;
+  }
+  if (e.type === "STEP_TIMEOUT") {
+    const err3 = e;
+    return {
+      timeoutMs: err3.timeoutMs,
+      stepName: err3.stepName,
+      stepKey: err3.stepKey,
+      attempt: err3.attempt
+    };
+  }
+  if (STEP_TIMEOUT_MARKER in e) {
+    return e[STEP_TIMEOUT_MARKER];
+  }
+  return void 0;
+}
+var EARLY_EXIT_SYMBOL = /* @__PURE__ */ Symbol("early-exit");
+function createEarlyExit(error, meta) {
+  return {
+    [EARLY_EXIT_SYMBOL]: true,
+    error,
+    meta
+  };
+}
+function isEarlyExit(e) {
+  return typeof e === "object" && e !== null && e[EARLY_EXIT_SYMBOL] === true;
+}
+var MAPPER_EXCEPTION_SYMBOL = /* @__PURE__ */ Symbol("mapper-exception");
+function createMapperException(thrown) {
+  return { [MAPPER_EXCEPTION_SYMBOL]: true, thrown };
+}
+function isMapperException(e) {
+  return typeof e === "object" && e !== null && e[MAPPER_EXCEPTION_SYMBOL] === true;
+}
+function calculateRetryDelay(attempt, options) {
+  const { backoff, initialDelay, maxDelay, jitter } = options;
+  let delay;
+  switch (backoff) {
+    case "fixed":
+      delay = initialDelay;
+      break;
+    case "linear":
+      delay = initialDelay * attempt;
+      break;
+    case "exponential":
+      delay = initialDelay * Math.pow(2, attempt - 1);
+      break;
+  }
+  delay = Math.min(delay, maxDelay);
+  if (jitter) {
+    const jitterAmount = delay * 0.25 * Math.random();
+    delay = delay + jitterAmount;
+  }
+  return Math.floor(delay);
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var TIMEOUT_SYMBOL = /* @__PURE__ */ Symbol("timeout");
+var TIMEOUT_OPTION_SYMBOL = /* @__PURE__ */ Symbol("timeout-option");
+function isTimeoutOptionMarker(value) {
+  return typeof value === "object" && value !== null && value[TIMEOUT_OPTION_SYMBOL] === true;
+}
+async function executeWithTimeout(operation, options, stepInfo, externalSignal) {
+  const controller = new AbortController();
+  const behavior = options.onTimeout ?? "error";
+  const createTimeoutError = () => {
+    if (typeof behavior === "function") {
+      return behavior({
+        name: stepInfo.name,
+        key: stepInfo.key,
+        ms: options.ms
+      });
+    }
+    return options.error ?? {
+      type: "STEP_TIMEOUT",
+      stepName: stepInfo.name,
+      stepKey: stepInfo.key,
+      timeoutMs: options.ms,
+      attempt: stepInfo.attempt
+    };
+  };
+  let timeoutId;
+  if (externalSignal?.aborted) {
+    controller.abort(externalSignal.reason);
+  }
+  let externalAbortHandler;
+  if (externalSignal && !externalSignal.aborted) {
+    externalAbortHandler = () => controller.abort(externalSignal.reason);
+    externalSignal.addEventListener("abort", externalAbortHandler, { once: true });
+  }
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      if (behavior !== "disconnect") {
+        controller.abort();
+      }
+      if (behavior === "option") {
+        reject({ [TIMEOUT_OPTION_SYMBOL]: true, ms: options.ms });
+        return;
+      }
+      reject({ [TIMEOUT_SYMBOL]: true, error: createTimeoutError() });
+    }, options.ms);
+  });
+  let operationPromise;
+  if (options.signal) {
+    operationPromise = Promise.resolve(
+      operation(controller.signal)
+    );
+  } else {
+    operationPromise = Promise.resolve(operation());
+  }
+  try {
+    const result = await Promise.race([operationPromise, timeoutPromise]);
+    return result;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && error[TIMEOUT_OPTION_SYMBOL] === true) {
+      throw { [TIMEOUT_OPTION_SYMBOL]: true, ms: options.ms };
+    }
+    if (typeof error === "object" && error !== null && error[TIMEOUT_SYMBOL] === true) {
+      if (behavior === "disconnect") {
+        operationPromise.catch(() => {
+        });
+      }
+      const errorToThrow = error.error;
+      if (typeof errorToThrow === "object" && errorToThrow !== null && errorToThrow.type !== "STEP_TIMEOUT") {
+        const meta = {
+          timeoutMs: options.ms,
+          stepName: stepInfo.name,
+          stepKey: stepInfo.key,
+          attempt: stepInfo.attempt
+        };
+        if (STEP_TIMEOUT_MARKER in errorToThrow) {
+          errorToThrow[STEP_TIMEOUT_MARKER] = meta;
+        } else {
+          Object.defineProperty(errorToThrow, STEP_TIMEOUT_MARKER, {
+            value: meta,
+            enumerable: false,
+            writable: true,
+            configurable: false
+          });
+        }
+      }
+      throw errorToThrow;
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
+    if (externalAbortHandler && externalSignal) {
+      externalSignal.removeEventListener("abort", externalAbortHandler);
+    }
+  }
+}
+var DEFAULT_RETRY_CONFIG = {
+  backoff: "exponential",
+  initialDelay: 100,
+  maxDelay: 3e4,
+  jitter: true,
+  shouldRetry: () => true,
+  onRetry: () => {
+  }
+};
+async function runFn(fnOrDeps, optionsOrFn, maybeOptions) {
+  if (typeof fnOrDeps !== "function") {
+    const deps = fnOrDeps;
+    const boundFn = optionsOrFn;
+    if (typeof boundFn !== "function") {
+      throw new TypeError(
+        "[awaitly] run(deps, fn) requires a callback as the second argument. Example: run({ getUser }, async (s) => s.getUser(id))"
+      );
+    }
+    const classicRun = runFn;
+    return classicRun(
+      ({ step }) => boundFn(bindSteps(deps, step), { step }),
+      maybeOptions
+    );
+  }
+  const fn = fnOrDeps;
+  const options = optionsOrFn;
+  const {
+    onError,
+    onEvent,
+    catchUnexpected,
+    workflowId: providedWorkflowId,
+    workflowName,
+    context,
+    graph,
+    _workflowSignal
+  } = options && typeof options === "object" ? options : {};
+  const workflowId = providedWorkflowId ?? crypto.randomUUID();
+  const declaredIds = graph ? new Set(
+    Array.isArray(graph) ? graph : graph.states.map((state) => state.semanticId ?? state.id)
+  ) : void 0;
+  const declaredPatterns = declaredIds ? [...declaredIds].filter((id) => id.includes("{")).map(
+    (id) => new RegExp(
+      `^${id.replaceAll(/[.*+?^$()[\]\\|]/g, String.raw`\$&`).replaceAll(/\{[^}]*\}/g, ".+")}$`
+    )
+  ) : void 0;
+  const assertDeclared = (id, kind) => {
+    if (!declaredIds || declaredIds.has(id)) return;
+    if (declaredPatterns?.some((re) => re.test(id))) return;
+    throw new Error(
+      `[awaitly] ${kind} id "${id}" is not in the declared workflow graph. Declared ids: ${[...declaredIds].join(", ")}. Either add it to the graph or remove the graph option.`
+    );
+  };
+  const effectiveCatchUnexpected = catchUnexpected ?? defaultCatchUnexpected;
+  const activeScopeStack = [];
+  let stepIdCounter = 0;
+  const generateStepId = (stepKey) => {
+    return stepKey ?? `step_${++stepIdCounter}`;
+  };
+  const emitEvent = (event) => {
+    const eventWithContext = event.context !== void 0 || context === void 0 ? event : { ...event, context };
+    const eventWithName = workflowName !== void 0 && eventWithContext.workflowName === void 0 ? { ...eventWithContext, workflowName } : eventWithContext;
+    if (eventWithName.type === "step_success") {
+      const stepId = eventWithName.stepId;
+      for (let i = activeScopeStack.length - 1; i >= 0; i--) {
+        const scope = activeScopeStack[i];
+        if (scope.type === "race" && !scope.winnerId) {
+          scope.winnerId = stepId;
+          break;
+        }
+      }
+    }
+    onEvent?.(eventWithName, context);
+  };
+  const earlyExit = createEarlyExit;
+  const isEarlyExitE = (e) => isEarlyExit(e);
+  const wrapForStep = (error, _meta) => {
+    return error;
+  };
+  const isResultLike = (value) => {
+    if (typeof value === "function") return false;
+    if (value && typeof value === "object" && "ok" in value) return true;
+    if (value && typeof value === "object" && "then" in value && typeof value.then === "function") return true;
+    return false;
+  };
+  try {
+    let normalizeParallelOperations2 = function(rawOperations) {
+      const out = {};
+      for (const [key, value2] of Object.entries(rawOperations)) {
+        if (typeof value2 === "function") {
+          out[key] = value2;
+        } else if (value2 && typeof value2 === "object" && "fn" in value2) {
+          out[key] = value2.fn;
+        } else {
+          throw new TypeError(`step.all: operation "${key}" must be a function or { fn, errors? } object`);
+        }
+      }
+      return out;
+    }, executeParallelArray2 = function(name, operation) {
+      const scopeId = `scope_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      return (async () => {
+        const startTime = performance.now();
+        let scopeEnded = false;
+        activeScopeStack.push({ scopeId, type: "parallel" });
+        const emitScopeEnd = () => {
+          if (scopeEnded) return;
+          scopeEnded = true;
+          const idx = activeScopeStack.findIndex((s) => s.scopeId === scopeId);
+          if (idx !== -1) activeScopeStack.splice(idx, 1);
+          emitEvent({
+            type: "scope_end",
+            workflowId,
+            scopeId,
+            ts: Date.now(),
+            durationMs: performance.now() - startTime
+          });
+        };
+        emitEvent({
+          type: "scope_start",
+          workflowId,
+          scopeId,
+          scopeType: "parallel",
+          name,
+          ts: Date.now()
+        });
+        try {
+          const result = await operation();
+          emitScopeEnd();
+          if (!result.ok) {
+            onError?.(result.error, name, context);
+            throw earlyExit(result.error, {
+              origin: "result",
+              resultCause: result.cause
+            });
+          }
+          return result.value;
+        } catch (error) {
+          emitScopeEnd();
+          throw error;
+        }
+      })();
+    }, executeParallelNamed2 = function(operations, options2) {
+      const keys = Object.keys(operations);
+      const name = options2.name ?? `Parallel(${keys.join(", ")})`;
+      const scopeId = `scope_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      return (async () => {
+        const startTime = performance.now();
+        let scopeEnded = false;
+        activeScopeStack.push({ scopeId, type: "parallel" });
+        const emitScopeEnd = () => {
+          if (scopeEnded) return;
+          scopeEnded = true;
+          const idx = activeScopeStack.findIndex((s) => s.scopeId === scopeId);
+          if (idx !== -1) activeScopeStack.splice(idx, 1);
+          emitEvent({
+            type: "scope_end",
+            workflowId,
+            scopeId,
+            ts: Date.now(),
+            durationMs: performance.now() - startTime
+          });
+        };
+        emitEvent({
+          type: "scope_start",
+          workflowId,
+          scopeId,
+          scopeType: "parallel",
+          name,
+          ts: Date.now()
+        });
+        try {
+          const results = await new Promise((resolve) => {
+            if (keys.length === 0) {
+              resolve([]);
+              return;
+            }
+            let settled = false;
+            let pendingCount = keys.length;
+            const resultArray = new Array(keys.length);
+            for (let i = 0; i < keys.length; i++) {
+              const key = keys[i];
+              const index = i;
+              Promise.resolve(operations[key]()).catch((reason) => err2(
+                { type: "PROMISE_REJECTED", cause: reason },
+                { cause: { type: "PROMISE_REJECTION", reason } }
+              )).then((result) => {
+                if (settled) return;
+                if (!result.ok) {
+                  settled = true;
+                  resolve([{ key, result }]);
+                  return;
+                }
+                resultArray[index] = { key, result };
+                pendingCount--;
+                if (pendingCount === 0) {
+                  resolve(resultArray);
+                }
+              });
+            }
+          });
+          emitScopeEnd();
+          const output = {};
+          for (const { key, result } of results) {
+            if (!result.ok) {
+              onError?.(result.error, key, context);
+              throw earlyExit(result.error, {
+                origin: "result",
+                resultCause: result.cause
+              });
+            }
+            output[key] = result.value;
+          }
+          return output;
+        } catch (error) {
+          emitScopeEnd();
+          throw error;
+        }
+      })();
+    };
+    var normalizeParallelOperations = normalizeParallelOperations2, executeParallelArray = executeParallelArray2, executeParallelNamed = executeParallelNamed2;
+    const stepFn = (id, operationOrResult, stepOptions2) => {
+      return (async () => {
+        if (typeof id !== "string" || id.length === 0) {
+          throw new Error(
+            '[awaitly] step() requires an explicit string ID as the first argument. Example: step("fetchUser", () => fetchUser(id))'
+          );
+        }
+        assertDeclared(id, "step");
+        const parsedOptions = stepOptions2 ?? {};
+        const stepMetadata = extractStepMetadata(parsedOptions);
+        const stepName = id;
+        const stepKey = parsedOptions.key ?? id;
+        const explicitKey = parsedOptions.key ?? id;
+        const { description: stepDescription, retry: retryConfig, timeout: timeoutConfig } = parsedOptions;
+        const stepId = generateStepId(stepKey);
+        const hasEventListeners = onEvent;
+        const overallStartTime = hasEventListeners ? performance.now() : 0;
+        const isDirectResult = isResultLike(operationOrResult);
+        const operation = isDirectResult ? () => operationOrResult : operationOrResult;
+        const maxAttempts = Math.max(1, retryConfig?.attempts ?? 1);
+        const effectiveRetry = {
+          attempts: maxAttempts,
+          backoff: retryConfig?.backoff ?? DEFAULT_RETRY_CONFIG.backoff,
+          initialDelay: retryConfig?.initialDelay ?? DEFAULT_RETRY_CONFIG.initialDelay,
+          maxDelay: retryConfig?.maxDelay ?? DEFAULT_RETRY_CONFIG.maxDelay,
+          jitter: retryConfig?.jitter ?? DEFAULT_RETRY_CONFIG.jitter,
+          shouldRetry: retryConfig?.shouldRetry ?? DEFAULT_RETRY_CONFIG.shouldRetry,
+          onRetry: retryConfig?.onRetry ?? DEFAULT_RETRY_CONFIG.onRetry
+        };
+        if (onEvent) {
+          emitEvent({
+            type: "step_start",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            description: stepDescription,
+            ts: Date.now(),
+            ...stepMetadata && { metadata: stepMetadata }
+          });
+        }
+        let lastResult;
+        for (let attempt = 1; attempt <= effectiveRetry.attempts; attempt++) {
+          const attemptStartTime = hasEventListeners ? performance.now() : 0;
+          try {
+            let result;
+            if (timeoutConfig) {
+              result = await executeWithTimeout(
+                operation,
+                timeoutConfig,
+                { name: stepName, key: stepKey, attempt },
+                _workflowSignal
+              );
+            } else {
+              result = await operation();
+            }
+            if (result.ok) {
+              const durationMs = performance.now() - overallStartTime;
+              emitEvent({
+                type: "step_success",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                description: stepDescription,
+                ts: Date.now(),
+                durationMs,
+                ...stepMetadata && { metadata: stepMetadata }
+              });
+              if (explicitKey) {
+                emitEvent({
+                  type: "step_complete",
+                  workflowId,
+                  stepKey: explicitKey,
+                  name: stepName,
+                  description: stepDescription,
+                  ts: Date.now(),
+                  durationMs,
+                  result,
+                  ...stepMetadata && { metadata: stepMetadata }
+                });
+              }
+              return result.value;
+            }
+            lastResult = result;
+            if (attempt < effectiveRetry.attempts && effectiveRetry.shouldRetry(result.error, attempt)) {
+              const delay = calculateRetryDelay(attempt, effectiveRetry);
+              emitEvent({
+                type: "step_retry",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                attempt: attempt + 1,
+                maxAttempts: effectiveRetry.attempts,
+                delayMs: delay,
+                error: result.error,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(result.error, parsedOptions.errorMeta, "result", attempt, performance.now() - overallStartTime)
+              });
+              effectiveRetry.onRetry(result.error, attempt, delay);
+              await sleep2(delay);
+              continue;
+            }
+            if (effectiveRetry.attempts > 1) {
+              emitEvent({
+                type: "step_retries_exhausted",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: performance.now() - overallStartTime,
+                attempts: attempt,
+                lastError: result.error,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(result.error, parsedOptions.errorMeta, "result", attempt, performance.now() - overallStartTime)
+              });
+            }
+            break;
+          } catch (thrown) {
+            const durationMs = performance.now() - attemptStartTime;
+            if (isTimeoutOptionMarker(thrown)) {
+              const timeoutMs = thrown.ms;
+              emitEvent({
+                type: "step_timeout",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                timeoutMs,
+                attempt,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "timeout", attempt)
+              });
+              emitEvent({
+                type: "step_success",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                description: stepDescription,
+                ts: Date.now(),
+                durationMs: performance.now() - overallStartTime,
+                ...stepMetadata && { metadata: stepMetadata }
+              });
+              if (explicitKey) {
+                emitEvent({
+                  type: "step_complete",
+                  workflowId,
+                  stepKey: explicitKey,
+                  name: stepName,
+                  description: stepDescription,
+                  ts: Date.now(),
+                  durationMs: performance.now() - overallStartTime,
+                  result: ok2(void 0),
+                  ...stepMetadata && { metadata: stepMetadata }
+                });
+              }
+              return void 0;
+            }
+            if (isEarlyExitE(thrown)) {
+              emitEvent({
+                type: "step_aborted",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                description: stepDescription,
+                ts: Date.now(),
+                durationMs,
+                ...stepMetadata && { metadata: stepMetadata }
+              });
+              throw thrown;
+            }
+            if (isStepTimeoutError(thrown)) {
+              const timeoutMeta = getStepTimeoutMeta(thrown);
+              const timeoutMs = timeoutConfig?.ms ?? timeoutMeta?.timeoutMs ?? 0;
+              emitEvent({
+                type: "step_timeout",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                timeoutMs,
+                attempt,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "timeout", attempt)
+              });
+              if (attempt < effectiveRetry.attempts && effectiveRetry.shouldRetry(thrown, attempt)) {
+                const delay = calculateRetryDelay(attempt, effectiveRetry);
+                emitEvent({
+                  type: "step_retry",
+                  workflowId,
+                  stepId,
+                  stepKey,
+                  name: stepName,
+                  ts: Date.now(),
+                  attempt: attempt + 1,
+                  maxAttempts: effectiveRetry.attempts,
+                  delayMs: delay,
+                  error: thrown,
+                  ...stepMetadata && { metadata: stepMetadata },
+                  diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "timeout", attempt, performance.now() - overallStartTime)
+                });
+                effectiveRetry.onRetry(thrown, attempt, delay);
+                await sleep2(delay);
+                continue;
+              }
+              if (effectiveRetry.attempts > 1) {
+                emitEvent({
+                  type: "step_retries_exhausted",
+                  workflowId,
+                  stepId,
+                  stepKey,
+                  name: stepName,
+                  ts: Date.now(),
+                  durationMs: performance.now() - overallStartTime,
+                  attempts: attempt,
+                  lastError: thrown,
+                  ...stepMetadata && { metadata: stepMetadata },
+                  diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "timeout", attempt, performance.now() - overallStartTime)
+                });
+              }
+              const totalDurationMs3 = performance.now() - overallStartTime;
+              emitEvent({
+                type: "step_error",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                description: stepDescription,
+                ts: Date.now(),
+                durationMs: totalDurationMs3,
+                error: thrown,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "timeout", attempt, totalDurationMs3)
+              });
+              if (explicitKey) {
+                emitEvent({
+                  type: "step_complete",
+                  workflowId,
+                  stepKey: explicitKey,
+                  name: stepName,
+                  description: stepDescription,
+                  ts: Date.now(),
+                  durationMs: totalDurationMs3,
+                  result: err2(thrown, { cause: thrown }),
+                  meta: { origin: "throw", thrown },
+                  ...stepMetadata && { metadata: stepMetadata }
+                });
+              }
+              onError?.(thrown, stepName, context);
+              throw earlyExit(thrown, { origin: "throw", thrown });
+            }
+            if (attempt < effectiveRetry.attempts && effectiveRetry.shouldRetry(thrown, attempt)) {
+              const delay = calculateRetryDelay(attempt, effectiveRetry);
+              emitEvent({
+                type: "step_retry",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                attempt: attempt + 1,
+                maxAttempts: effectiveRetry.attempts,
+                delayMs: delay,
+                error: thrown,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "throw", attempt, performance.now() - overallStartTime)
+              });
+              effectiveRetry.onRetry(thrown, attempt, delay);
+              await sleep2(delay);
+              continue;
+            }
+            if (effectiveRetry.attempts > 1 && !isStepTimeoutError(thrown)) {
+              emitEvent({
+                type: "step_retries_exhausted",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: performance.now() - overallStartTime,
+                attempts: attempt,
+                lastError: thrown,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "throw", attempt, performance.now() - overallStartTime)
+              });
+            }
+            const totalDurationMs2 = performance.now() - overallStartTime;
+            let mappedError;
+            try {
+              mappedError = effectiveCatchUnexpected(thrown);
+            } catch (mapperError) {
+              throw createMapperException(mapperError);
+            }
+            emitEvent({
+              type: "step_error",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              description: stepDescription,
+              ts: Date.now(),
+              durationMs: totalDurationMs2,
+              error: mappedError,
+              ...stepMetadata && { metadata: stepMetadata },
+              diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "throw", attempt, totalDurationMs2)
+            });
+            if (explicitKey) {
+              emitEvent({
+                type: "step_complete",
+                workflowId,
+                stepKey: explicitKey,
+                name: stepName,
+                description: stepDescription,
+                ts: Date.now(),
+                durationMs: totalDurationMs2,
+                result: err2(mappedError, { cause: thrown }),
+                meta: { origin: "throw", thrown },
+                ...stepMetadata && { metadata: stepMetadata }
+              });
+            }
+            onError?.(mappedError, stepName, context);
+            throw earlyExit(mappedError, { origin: "throw", thrown });
+          }
+        }
+        const errorResult = lastResult;
+        const totalDurationMs = performance.now() - overallStartTime;
+        const wrappedError = wrapForStep(errorResult.error, {
+          origin: "result",
+          resultCause: errorResult.cause
+        });
+        emitEvent({
+          type: "step_error",
+          workflowId,
+          stepId,
+          stepKey,
+          name: stepName,
+          description: stepDescription,
+          ts: Date.now(),
+          durationMs: totalDurationMs,
+          error: wrappedError,
+          ...stepMetadata && { metadata: stepMetadata },
+          diagnostics: buildStepErrorPayload(errorResult.error, parsedOptions.errorMeta, "result", effectiveRetry.attempts, totalDurationMs)
+        });
+        if (explicitKey) {
+          emitEvent({
+            type: "step_complete",
+            workflowId,
+            stepKey: explicitKey,
+            name: stepName,
+            description: stepDescription,
+            ts: Date.now(),
+            durationMs: totalDurationMs,
+            result: errorResult,
+            meta: { origin: "result", resultCause: errorResult.cause },
+            ...stepMetadata && { metadata: stepMetadata }
+          });
+        }
+        onError?.(wrappedError, stepName, context);
+        throw earlyExit(wrappedError, {
+          origin: "result",
+          resultCause: errorResult.cause
+        });
+      })();
+    };
+    stepFn.try = (id, operation, opts) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.try() requires an explicit string ID as the first argument. Example: step.try("parse", () => JSON.parse(str), { error: "PARSE_ERROR" })'
+        );
+      }
+      assertDeclared(id, "step");
+      const mapToError = "error" in opts ? () => opts.error : opts.onError;
+      if (opts.retry || opts.timeout) {
+        return stepFn.retry(
+          id,
+          async () => {
+            try {
+              return ok2(await operation());
+            } catch (cause) {
+              return err2(mapToError(cause), { cause });
+            }
+          },
+          {
+            attempts: opts.retry?.attempts ?? 1,
+            ...opts.retry ?? {},
+            key: opts.key,
+            timeout: opts.timeout
+          }
+        );
+      }
+      const stepKey = opts.key ?? id;
+      const stepName = id;
+      const stepId = id;
+      const hasEventListeners = onEvent;
+      return (async () => {
+        const startTime = hasEventListeners ? performance.now() : 0;
+        if (onEvent) {
+          emitEvent({
+            type: "step_start",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now()
+          });
+        }
+        try {
+          const value2 = await operation();
+          const durationMs = performance.now() - startTime;
+          emitEvent({
+            type: "step_success",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs,
+              result: ok2(value2)
+            });
+          }
+          return value2;
+        } catch (error) {
+          const mapped = mapToError(error);
+          const durationMs = performance.now() - startTime;
+          const wrappedError = wrapForStep(mapped, { origin: "throw", thrown: error });
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs,
+            error: wrappedError
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs,
+              result: err2(mapped, { cause: error }),
+              meta: { origin: "throw", thrown: error }
+            });
+          }
+          onError?.(wrappedError, stepName, context);
+          throw earlyExit(wrappedError, { origin: "throw", thrown: error });
+        }
+      })();
+    };
+    stepFn.fromResult = (id, operation, opts) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.fromResult() requires an explicit string ID as the first argument. Example: step.fromResult("callProvider", () => callProvider(input), { onError: (e) => ({ type: "FAILED" }) })'
+        );
+      }
+      assertDeclared(id, "step");
+      const stepKey = opts.key ?? id;
+      const stepName = id;
+      const stepId = id;
+      const mapToError = "error" in opts ? () => opts.error : opts.onError;
+      const hasEventListeners = onEvent;
+      return (async () => {
+        const startTime = hasEventListeners ? performance.now() : 0;
+        if (onEvent) {
+          emitEvent({
+            type: "step_start",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now()
+          });
+        }
+        const result = await operation();
+        if (result.ok) {
+          const durationMs = performance.now() - startTime;
+          emitEvent({
+            type: "step_success",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs,
+              result: ok2(result.value)
+            });
+          }
+          return result.value;
+        } else {
+          const mapped = mapToError(result.error);
+          const durationMs = performance.now() - startTime;
+          const wrappedError = wrapForStep(mapped, {
+            origin: "result",
+            resultCause: result.error
+          });
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs,
+            error: wrappedError
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs,
+              result: err2(mapped, { cause: result.error }),
+              meta: { origin: "result", resultCause: result.error }
+            });
+          }
+          onError?.(wrappedError, stepName, context);
+          throw earlyExit(wrappedError, {
+            origin: "result",
+            resultCause: result.error
+          });
+        }
+      })();
+    };
+    stepFn.fromNullable = (id, operation, onNull, options2) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.fromNullable() requires an explicit string ID as the first argument. Example: step.fromNullable("getUser", () => db.find(id), () => ({ type: "NOT_FOUND" }))'
+        );
+      }
+      return stepFn(
+        id,
+        async () => {
+          const value2 = await operation();
+          return value2 != null ? ok2(value2) : err2(onNull());
+        },
+        options2
+      );
+    };
+    stepFn.retry = (id, operation, options2) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.retry() requires an explicit string ID as the first argument. Example: step.retry("fetchData", () => fetchData(), { attempts: 3 })'
+        );
+      }
+      return stepFn(id, operation, {
+        key: options2.key ?? id,
+        retry: {
+          attempts: options2.attempts,
+          backoff: options2.backoff,
+          initialDelay: options2.initialDelay,
+          maxDelay: options2.maxDelay,
+          jitter: options2.jitter,
+          shouldRetry: options2.shouldRetry,
+          onRetry: options2.onRetry
+        },
+        timeout: options2.timeout
+      });
+    };
+    stepFn.withTimeout = (id, operation, options2) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.withTimeout() requires an explicit string ID as the first argument. Example: step.withTimeout("slowOp", () => slowOp(), { ms: 5000 })'
+        );
+      }
+      return stepFn(
+        id,
+        operation,
+        {
+          key: options2.key ?? id,
+          timeout: options2
+        }
+      );
+    };
+    stepFn.sleep = (id, duration, options2) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.sleep() requires an explicit string ID as the first argument. Example: step.sleep("delay", "5s")'
+        );
+      }
+      const d = typeof duration === "string" ? parseDurationString(duration) : duration;
+      if (!d) {
+        throw new Error(`step.sleep: invalid duration '${duration}'`);
+      }
+      const ms = d.millis;
+      const userSignal = options2?.signal;
+      return stepFn(
+        id,
+        async () => {
+          if (_workflowSignal?.aborted || userSignal?.aborted) {
+            const e = new Error("Sleep aborted");
+            e.name = "AbortError";
+            throw e;
+          }
+          return new Promise((resolve, reject) => {
+            const state = { timeoutId: void 0 };
+            const onAbort = () => {
+              if (state.timeoutId) clearTimeout(state.timeoutId);
+              const e = new Error("Sleep aborted");
+              e.name = "AbortError";
+              reject(e);
+            };
+            _workflowSignal?.addEventListener("abort", onAbort, { once: true });
+            userSignal?.addEventListener("abort", onAbort, { once: true });
+            state.timeoutId = setTimeout(() => {
+              _workflowSignal?.removeEventListener("abort", onAbort);
+              userSignal?.removeEventListener("abort", onAbort);
+              resolve(ok2(void 0));
+            }, ms);
+          });
+        },
+        {
+          key: options2?.key ?? id,
+          description: options2?.description
+        }
+      );
+    };
+    stepFn.all = ((...args) => {
+      if (typeof args[0] !== "string") {
+        throw new TypeError(
+          "step.all(name, ...): first argument must be a string (step name). Example: step.all('Fetch data', { user: () => fetchUser(), posts: () => fetchPosts() })"
+        );
+      }
+      const name = args[0];
+      const second = args[1];
+      if (typeof second === "function") {
+        return executeParallelArray2(name, second);
+      }
+      if (second && typeof second === "object" && !Array.isArray(second)) {
+        const rawOperations = second;
+        const normalizedOperations = normalizeParallelOperations2(rawOperations);
+        return executeParallelNamed2(normalizedOperations, { name });
+      }
+      throw new TypeError(
+        "step.all(name, ...): second argument must be a function (array form) or an object of operations (object form)."
+      );
+    });
+    stepFn.race = (name, operation) => {
+      const scopeId = `scope_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      return (async () => {
+        const startTime = performance.now();
+        let scopeEnded = false;
+        const scopeEntry = { scopeId, type: "race", winnerId: void 0 };
+        activeScopeStack.push(scopeEntry);
+        const emitScopeEnd = () => {
+          if (scopeEnded) return;
+          scopeEnded = true;
+          const idx = activeScopeStack.findIndex((s) => s.scopeId === scopeId);
+          if (idx !== -1) activeScopeStack.splice(idx, 1);
+          emitEvent({
+            type: "scope_end",
+            workflowId,
+            scopeId,
+            ts: Date.now(),
+            durationMs: performance.now() - startTime,
+            winnerId: scopeEntry.winnerId
+          });
+        };
+        emitEvent({
+          type: "scope_start",
+          workflowId,
+          scopeId,
+          scopeType: "race",
+          name,
+          ts: Date.now()
+        });
+        try {
+          const result = await operation();
+          emitScopeEnd();
+          if (!result.ok) {
+            onError?.(result.error, name, context);
+            throw earlyExit(result.error, {
+              origin: "result",
+              resultCause: result.cause
+            });
+          }
+          return result.value;
+        } catch (error) {
+          emitScopeEnd();
+          throw error;
+        }
+      })();
+    };
+    stepFn.if = (id, conditionLabel, condition) => {
+      assertDeclared(id, "decision");
+      const value2 = condition();
+      emitEvent({
+        type: "decision",
+        workflowId,
+        decisionId: id,
+        label: conditionLabel,
+        branch: value2 ? "then" : "else",
+        value: value2,
+        ts: Date.now()
+      });
+      return value2;
+    };
+    stepFn.label = stepFn.if;
+    stepFn.branch = async (id, options2) => {
+      const { condition, then: thenFn, else: elseFn } = options2;
+      assertDeclared(id, "decision");
+      const conditionResult = condition();
+      const branch = conditionResult ? "then" : "else";
+      const startTime = performance.now();
+      emitEvent({
+        type: "decision",
+        workflowId,
+        decisionId: id,
+        label: options2.conditionLabel,
+        branch,
+        value: conditionResult,
+        phase: "start",
+        ts: Date.now()
+      });
+      const emitEnd = () => {
+        emitEvent({
+          type: "decision",
+          workflowId,
+          decisionId: id,
+          label: options2.conditionLabel,
+          branch,
+          value: conditionResult,
+          phase: "end",
+          durationMs: performance.now() - startTime,
+          ts: Date.now()
+        });
+      };
+      try {
+        if (conditionResult) {
+          return await thenFn();
+        } else if (elseFn) {
+          return await elseFn();
+        }
+        return void 0;
+      } finally {
+        emitEnd();
+      }
+    };
+    stepFn.arm = (fn2, errors) => {
+      return { fn: fn2, errors };
+    };
+    stepFn.forEach = async (_id, items, options2) => {
+      const results = [];
+      const maxIterations = options2.maxIterations;
+      let index = 0;
+      const isRunForm = "run" in options2;
+      const asyncItems = Symbol.asyncIterator in items ? items : (async function* () {
+        yield* items;
+      })();
+      for await (const item of asyncItems) {
+        if (maxIterations !== void 0 && index >= maxIterations) {
+          break;
+        }
+        let result;
+        if (isRunForm) {
+          const runOptions = options2;
+          result = await runOptions.run(item, index);
+        } else {
+          const itemOptions = options2;
+          result = await itemOptions.item.handler(item, index, stepFn);
+        }
+        results.push(result);
+        index++;
+      }
+      return results;
+    };
+    stepFn.item = (handler) => {
+      return {
+        __forEachItemHandler: true,
+        handler
+      };
+    };
+    stepFn.dep = (_name, fn2) => {
+      return fn2;
+    };
+    stepFn.workflow = (id, getter, options2) => {
+      return stepFn(id, getter, options2);
+    };
+    stepFn.map = async (id, items, mapper, options2) => {
+      const concurrency = options2?.concurrency ?? items.length;
+      return stepFn(
+        id,
+        () => {
+          if (concurrency >= items.length) {
+            return allAsync2(items.map((item, index) => mapper(item, index)));
+          } else {
+            return (async () => {
+              const results = [];
+              for (let i = 0; i < items.length; i += concurrency) {
+                const batch = items.slice(i, i + concurrency);
+                const batchResult = await allAsync2(
+                  batch.map((item, batchIndex) => mapper(item, i + batchIndex))
+                );
+                if (!batchResult.ok) {
+                  return batchResult;
+                }
+                results.push(...batchResult.value);
+              }
+              return ok2(results);
+            })();
+          }
+        },
+        { key: options2?.key }
+      );
+    };
+    stepFn.withFallback = (id, operation, options2) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.withFallback() requires an explicit string ID as the first argument. Example: step.withFallback("getUser", () => fetchUser(id), { fallback: () => fetchFromCache(id) })'
+        );
+      }
+      assertDeclared(id, "step");
+      const stepKey = options2.key ?? id;
+      const stepName = id;
+      const stepId = generateStepId(stepKey);
+      const hasEventListeners = onEvent;
+      return (async () => {
+        const startTime = hasEventListeners ? performance.now() : 0;
+        if (onEvent) {
+          emitEvent({
+            type: "step_start",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now()
+          });
+        }
+        let primaryResult;
+        try {
+          primaryResult = await operation();
+        } catch (thrown) {
+          if (isEarlyExitE(thrown)) {
+            emitEvent({
+              type: "step_aborted",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: performance.now() - startTime
+            });
+            throw thrown;
+          }
+          let mappedError;
+          try {
+            mappedError = effectiveCatchUnexpected(thrown);
+          } catch (mapperError) {
+            throw createMapperException(mapperError);
+          }
+          if (options2.on !== void 0 && options2.on !== mappedError) {
+            const durationMs2 = performance.now() - startTime;
+            emitEvent({
+              type: "step_error",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              error: mappedError
+            });
+            if (stepKey) {
+              emitEvent({
+                type: "step_complete",
+                workflowId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: durationMs2,
+                result: err2(mappedError, { cause: thrown }),
+                meta: { origin: "throw", thrown }
+              });
+            }
+            onError?.(mappedError, stepName, context);
+            throw earlyExit(mappedError, { origin: "throw", thrown });
+          }
+          let fallbackResultFromThrow;
+          try {
+            fallbackResultFromThrow = await options2.fallback();
+          } catch (fallbackThrown) {
+            if (isEarlyExitE(fallbackThrown)) {
+              emitEvent({
+                type: "step_aborted",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: performance.now() - startTime
+              });
+              throw fallbackThrown;
+            }
+            let fallbackMappedError;
+            try {
+              fallbackMappedError = effectiveCatchUnexpected(fallbackThrown);
+            } catch (mapperError) {
+              throw createMapperException(mapperError);
+            }
+            const durationMs2 = performance.now() - startTime;
+            emitEvent({
+              type: "step_error",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              error: fallbackMappedError
+            });
+            if (stepKey) {
+              emitEvent({
+                type: "step_complete",
+                workflowId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: durationMs2,
+                result: err2(fallbackMappedError, { cause: fallbackThrown }),
+                meta: { origin: "throw", thrown: fallbackThrown }
+              });
+            }
+            onError?.(fallbackMappedError, stepName, context);
+            throw earlyExit(fallbackMappedError, { origin: "throw", thrown: fallbackThrown });
+          }
+          if (fallbackResultFromThrow.ok) {
+            const durationMs2 = performance.now() - startTime;
+            emitEvent({
+              type: "step_success",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2
+            });
+            if (stepKey) {
+              emitEvent({
+                type: "step_complete",
+                workflowId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: durationMs2,
+                result: fallbackResultFromThrow,
+                meta: { origin: "fallback", fallbackUsed: true, fallbackReason: String(mappedError) }
+              });
+            }
+            return fallbackResultFromThrow.value;
+          } else {
+            const durationMs2 = performance.now() - startTime;
+            const wrappedError2 = wrapForStep(fallbackResultFromThrow.error, {
+              origin: "result",
+              resultCause: fallbackResultFromThrow.cause
+            });
+            emitEvent({
+              type: "step_error",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              error: wrappedError2
+            });
+            if (stepKey) {
+              emitEvent({
+                type: "step_complete",
+                workflowId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: durationMs2,
+                result: fallbackResultFromThrow,
+                meta: { origin: "result", resultCause: fallbackResultFromThrow.cause }
+              });
+            }
+            onError?.(wrappedError2, stepName, context);
+            throw earlyExit(wrappedError2, {
+              origin: "result",
+              resultCause: fallbackResultFromThrow.cause
+            });
+          }
+        }
+        if (primaryResult.ok) {
+          const durationMs2 = performance.now() - startTime;
+          emitEvent({
+            type: "step_success",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: primaryResult
+            });
+          }
+          return primaryResult.value;
+        }
+        const primaryError = primaryResult.error;
+        if (options2.on !== void 0 && options2.on !== primaryError) {
+          const durationMs2 = performance.now() - startTime;
+          const wrappedError2 = wrapForStep(primaryError, {
+            origin: "result",
+            resultCause: primaryResult.cause
+          });
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2,
+            error: wrappedError2
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: primaryResult,
+              meta: { origin: "result", resultCause: primaryResult.cause }
+            });
+          }
+          onError?.(wrappedError2, stepName, context);
+          throw earlyExit(wrappedError2, {
+            origin: "result",
+            resultCause: primaryResult.cause
+          });
+        }
+        let fallbackResult;
+        try {
+          fallbackResult = await options2.fallback();
+        } catch (thrown) {
+          if (isEarlyExitE(thrown)) {
+            emitEvent({
+              type: "step_aborted",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: performance.now() - startTime
+            });
+            throw thrown;
+          }
+          let mappedError;
+          try {
+            mappedError = effectiveCatchUnexpected(thrown);
+          } catch (mapperError) {
+            throw createMapperException(mapperError);
+          }
+          const durationMs2 = performance.now() - startTime;
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2,
+            error: mappedError
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: err2(mappedError, { cause: thrown }),
+              meta: { origin: "throw", thrown }
+            });
+          }
+          onError?.(mappedError, stepName, context);
+          throw earlyExit(mappedError, { origin: "throw", thrown });
+        }
+        if (fallbackResult.ok) {
+          const durationMs2 = performance.now() - startTime;
+          emitEvent({
+            type: "step_success",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: fallbackResult,
+              meta: { origin: "fallback", fallbackUsed: true, fallbackReason: String(primaryError) }
+            });
+          }
+          return fallbackResult.value;
+        }
+        const durationMs = performance.now() - startTime;
+        const wrappedError = wrapForStep(fallbackResult.error, {
+          origin: "result",
+          resultCause: fallbackResult.cause
+        });
+        emitEvent({
+          type: "step_error",
+          workflowId,
+          stepId,
+          stepKey,
+          name: stepName,
+          ts: Date.now(),
+          durationMs,
+          error: wrappedError
+        });
+        if (stepKey) {
+          emitEvent({
+            type: "step_complete",
+            workflowId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs,
+            result: fallbackResult,
+            meta: { origin: "result", resultCause: fallbackResult.cause }
+          });
+        }
+        onError?.(wrappedError, stepName, context);
+        throw earlyExit(wrappedError, {
+          origin: "result",
+          resultCause: fallbackResult.cause
+        });
+      })();
+    };
+    stepFn.withResource = (id, options2) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.withResource() requires an explicit string ID as the first argument. Example: step.withResource("useDb", { acquire: () => connect(), use: (db) => query(db), release: (db) => db.close() })'
+        );
+      }
+      assertDeclared(id, "step");
+      const stepKey = id;
+      const stepName = id;
+      const stepId = generateStepId(stepKey);
+      const hasEventListeners = onEvent;
+      return (async () => {
+        const startTime = hasEventListeners ? performance.now() : 0;
+        if (onEvent) {
+          emitEvent({
+            type: "step_start",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now()
+          });
+        }
+        let acquireResult;
+        try {
+          acquireResult = await options2.acquire();
+        } catch (thrown) {
+          if (isEarlyExitE(thrown)) {
+            emitEvent({
+              type: "step_aborted",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: performance.now() - startTime
+            });
+            throw thrown;
+          }
+          let mappedError;
+          try {
+            mappedError = effectiveCatchUnexpected(thrown);
+          } catch (mapperError) {
+            throw createMapperException(mapperError);
+          }
+          const durationMs2 = performance.now() - startTime;
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2,
+            error: mappedError
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: err2(mappedError, { cause: thrown }),
+              meta: { origin: "throw", thrown }
+            });
+          }
+          onError?.(mappedError, stepName, context);
+          throw earlyExit(mappedError, { origin: "throw", thrown });
+        }
+        if (!acquireResult.ok) {
+          const durationMs2 = performance.now() - startTime;
+          const wrappedError2 = wrapForStep(acquireResult.error, {
+            origin: "result",
+            resultCause: acquireResult.cause
+          });
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2,
+            error: wrappedError2
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: acquireResult,
+              meta: { origin: "result", resultCause: acquireResult.cause }
+            });
+          }
+          onError?.(wrappedError2, stepName, context);
+          throw earlyExit(wrappedError2, {
+            origin: "result",
+            resultCause: acquireResult.cause
+          });
+        }
+        const resource = acquireResult.value;
+        let useResult;
+        let useThrown;
+        let useThrewNonResult = false;
+        try {
+          useResult = await options2.use(resource);
+        } catch (thrown) {
+          if (isEarlyExitE(thrown)) {
+            try {
+              await options2.release(resource);
+            } catch (releaseErr) {
+              console.warn(
+                `[awaitly] step.withResource("${id}"): release threw after earlyExit:`,
+                releaseErr
+              );
+            }
+            throw thrown;
+          }
+          useThrown = thrown;
+          useThrewNonResult = true;
+        }
+        try {
+          await options2.release(resource);
+        } catch (releaseErr) {
+          console.warn(
+            `[awaitly] step.withResource("${id}"): release threw:`,
+            releaseErr
+          );
+        }
+        if (useThrewNonResult) {
+          let mappedError;
+          try {
+            mappedError = effectiveCatchUnexpected(useThrown);
+          } catch (mapperError) {
+            throw createMapperException(mapperError);
+          }
+          const durationMs2 = performance.now() - startTime;
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2,
+            error: mappedError
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: err2(mappedError, { cause: useThrown }),
+              meta: { origin: "throw", thrown: useThrown }
+            });
+          }
+          onError?.(mappedError, stepName, context);
+          throw earlyExit(mappedError, { origin: "throw", thrown: useThrown });
+        }
+        const result = useResult;
+        if (result.ok) {
+          const durationMs2 = performance.now() - startTime;
+          emitEvent({
+            type: "step_success",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result
+            });
+          }
+          return result.value;
+        }
+        const durationMs = performance.now() - startTime;
+        const wrappedError = wrapForStep(result.error, {
+          origin: "result",
+          resultCause: result.cause
+        });
+        emitEvent({
+          type: "step_error",
+          workflowId,
+          stepId,
+          stepKey,
+          name: stepName,
+          ts: Date.now(),
+          durationMs,
+          error: wrappedError
+        });
+        if (stepKey) {
+          emitEvent({
+            type: "step_complete",
+            workflowId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs,
+            result,
+            meta: { origin: "result", resultCause: result.cause }
+          });
+        }
+        onError?.(wrappedError, stepName, context);
+        throw earlyExit(wrappedError, {
+          origin: "result",
+          resultCause: result.cause
+        });
+      })();
+    };
+    const step = stepFn;
+    const value = await fn({ step });
+    if (process.env.NODE_ENV !== "production" && value !== null && typeof value === "object" && "ok" in value && typeof value.ok === "boolean") {
+      const maybeResult = value;
+      if (maybeResult.ok === true && "value" in maybeResult || maybeResult.ok === false && "error" in maybeResult) {
+        console.warn(
+          `awaitly: Workflow executor returned a Result-like object. Return raw values, not ok() or err().
+
+  Incorrect: return ok({ data });
+  Correct:   return { data };
+
+See: https://jagreehal.github.io/awaitly/guides/troubleshooting/#returning-ok-from-workflow-executor-double-wrapping`
+        );
+      }
+    }
+    return ok2(value);
+  } catch (error) {
+    if (isMapperException(error)) {
+      throw error.thrown;
+    }
+    if (isEarlyExitE(error)) {
+      const originalCause = error.meta.origin === "throw" ? error.meta.thrown : error.meta.origin === "result" ? error.meta.resultCause : void 0;
+      return err2(error.error, { cause: originalCause });
+    }
+    const mapped = effectiveCatchUnexpected(error);
+    onError?.(mapped, "unexpected", context);
+    return err2(mapped, { cause: error });
+  }
+}
+var runStrict = (fn, options) => {
+  return runFn(fn, options);
+};
+var run = /* @__PURE__ */ Object.assign(runFn, { strict: runStrict });
+async function allAsync2(results) {
+  if (results.length === 0) {
+    return ok2([]);
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    let pendingCount = results.length;
+    const values = new Array(results.length);
+    for (let i = 0; i < results.length; i++) {
+      const index = i;
+      Promise.resolve(results[index]).catch((reason) => err2(
+        { type: "PROMISE_REJECTED", cause: reason },
+        { cause: { type: "PROMISE_REJECTION", reason } }
+      )).then((result) => {
+        if (settled) return;
+        if (!result.ok) {
+          settled = true;
+          resolve(result);
+          return;
+        }
+        values[index] = result.value;
+        pendingCount--;
+        if (pendingCount === 0) {
+          resolve(ok2(values));
+        }
+      });
+    }
+  });
+}
+
+// src/match.ts
+function tag(tagValue, handler) {
+  return (matcher) => {
+    const newHandlers = new Map(matcher.handlers);
+    newHandlers.set(tagValue, handler);
+    return {
+      _tag: "Matcher",
+      value: matcher.value,
+      handlers: newHandlers,
+      _remaining: void 0,
+      _output: void 0
+    };
+  };
+}
+function tags2(handlers) {
+  return (matcher) => {
+    const newHandlers = new Map(matcher.handlers);
+    for (const [tagValue, handler] of Object.entries(handlers)) {
+      if (handler) {
+        newHandlers.set(tagValue, handler);
+      }
+    }
+    return {
+      _tag: "Matcher",
+      value: matcher.value,
+      handlers: newHandlers,
+      _remaining: void 0,
+      _output: void 0
+    };
+  };
+}
+function exhaustive(matcher) {
+  const handler = matcher.handlers.get(matcher.value._tag);
+  if (!handler) {
+    throw new Error(`No handler for tag: ${matcher.value._tag}`);
+  }
+  return handler(matcher.value);
+}
+function orElse2(handler) {
+  return (matcher) => {
+    const specificHandler = matcher.handlers.get(matcher.value._tag);
+    if (specificHandler) {
+      return specificHandler(matcher.value);
+    }
+    return handler(matcher.value);
+  };
+}
+function orElseValue(defaultValue) {
+  return orElse2(() => defaultValue);
+}
+function when(tagValue, predicate, handler) {
+  return (matcher) => {
+    const newHandlers = new Map(matcher.handlers);
+    const existingHandler = matcher.handlers.get(tagValue);
+    newHandlers.set(tagValue, (value) => {
+      const typedValue = value;
+      if (predicate(typedValue)) {
+        return handler(typedValue);
+      }
+      if (existingHandler) {
+        return existingHandler(value);
+      }
+      throw new Error(`No handler matched for tag: ${tagValue}`);
+    });
+    return {
+      _tag: "Matcher",
+      value: matcher.value,
+      handlers: newHandlers,
+      _remaining: matcher._remaining,
+      _output: void 0
+    };
+  };
+}
+function is(tagValue) {
+  return (value) => value._tag === tagValue;
+}
+function isOneOf(...tags3) {
+  const tagSet = new Set(tags3);
+  return (value) => tagSet.has(value._tag);
+}
+function isMatcher(value) {
+  return typeof value === "object" && value !== null && "_tag" in value && value._tag === "Matcher";
+}
+function addPipe(matcher) {
+  return {
+    ...matcher,
+    pipe(fn) {
+      const result = fn(matcher);
+      if (isMatcher(result)) {
+        return addPipe(result);
+      }
+      return result;
+    }
+  };
+}
+function matchValue(input) {
+  const matcher = {
+    _tag: "Matcher",
+    value: input,
+    handlers: /* @__PURE__ */ new Map(),
+    _remaining: input,
+    _output: void 0
+  };
+  return addPipe(matcher);
+}
+var Match = {
+  value: matchValue,
+  tag,
+  tags: tags2,
+  when,
+  exhaustive,
+  orElse: orElse2,
+  orElseValue,
+  is,
+  isOneOf
+};
+
+// src/circuit-breaker.ts
+var CircuitOpenError = class extends Error {
+  type = "CIRCUIT_OPEN";
+  circuitName;
+  state;
+  retryAfterMs;
+  constructor(options) {
+    super(
+      options.message ?? `Circuit breaker "${options.circuitName}" is ${options.state}. Retry after ${Math.ceil(options.retryAfterMs / 1e3)}s`
+    );
+    this.name = "CircuitOpenError";
+    this.circuitName = options.circuitName;
+    this.state = options.state;
+    this.retryAfterMs = options.retryAfterMs;
+  }
+};
+function isCircuitOpenError(error) {
+  return typeof error === "object" && error !== null && error.type === "CIRCUIT_OPEN";
+}
+var DEFAULT_CONFIG = {
+  failureThreshold: 5,
+  resetTimeout: 3e4,
+  windowSize: 6e4,
+  halfOpenMax: 3
+};
+function createCircuitBreaker(name, config) {
+  const effectiveConfig = {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+  let state = "CLOSED";
+  let failures = [];
+  let lastFailureTime = null;
+  let lastSuccessTime = null;
+  let successCount = 0;
+  let halfOpenSuccesses = 0;
+  function cleanupFailures() {
+    const now = Date.now();
+    failures = failures.filter(
+      (f) => now - f.timestamp < effectiveConfig.windowSize
+    );
+  }
+  function transitionTo(newState) {
+    if (state !== newState) {
+      const oldState = state;
+      state = newState;
+      if (newState === "HALF_OPEN") {
+        halfOpenSuccesses = 0;
+      }
+      effectiveConfig.onStateChange?.(oldState, newState, name);
+    }
+  }
+  function checkOpenToHalfOpen() {
+    if (state !== "OPEN" || lastFailureTime === null) {
+      return false;
+    }
+    const now = Date.now();
+    if (now - lastFailureTime >= effectiveConfig.resetTimeout) {
+      transitionTo("HALF_OPEN");
+      return true;
+    }
+    return false;
+  }
+  function handleSuccess() {
+    lastSuccessTime = Date.now();
+    successCount++;
+    if (state === "HALF_OPEN") {
+      halfOpenSuccesses++;
+      if (halfOpenSuccesses >= effectiveConfig.halfOpenMax) {
+        transitionTo("CLOSED");
+        failures = [];
+      }
+    }
+  }
+  function handleFailure(error) {
+    const now = Date.now();
+    lastFailureTime = now;
+    cleanupFailures();
+    failures.push({ timestamp: now, error });
+    if (state === "HALF_OPEN") {
+      transitionTo("OPEN");
+    } else if (state === "CLOSED") {
+      if (failures.length >= effectiveConfig.failureThreshold) {
+        transitionTo("OPEN");
+      }
+    }
+  }
+  function canExecute() {
+    if (state === "CLOSED") {
+      return 0;
+    }
+    if (state === "OPEN") {
+      if (checkOpenToHalfOpen()) {
+        return 0;
+      }
+      const now = Date.now();
+      const elapsed = lastFailureTime ? now - lastFailureTime : 0;
+      return Math.max(0, effectiveConfig.resetTimeout - elapsed);
+    }
+    return 0;
+  }
+  return {
+    async execute(operation, _options) {
+      const waitTime = canExecute();
+      if (waitTime > 0) {
+        throw new CircuitOpenError({
+          circuitName: name,
+          state,
+          retryAfterMs: waitTime
+        });
+      }
+      try {
+        const result = await operation();
+        handleSuccess();
+        return result;
+      } catch (error) {
+        handleFailure(error);
+        throw error;
+      }
+    },
+    async executeResult(operation, _options) {
+      const waitTime = canExecute();
+      if (waitTime > 0) {
+        return err2(
+          new CircuitOpenError({
+            circuitName: name,
+            state,
+            retryAfterMs: waitTime
+          })
+        );
+      }
+      try {
+        const result = await operation();
+        if (result.ok) {
+          handleSuccess();
+        } else {
+          handleFailure(result.error);
+        }
+        return result;
+      } catch (error) {
+        handleFailure(error);
+        throw error;
+      }
+    },
+    getState() {
+      if (state === "OPEN") {
+        checkOpenToHalfOpen();
+      }
+      return state;
+    },
+    getStats() {
+      cleanupFailures();
+      return {
+        state: this.getState(),
+        failureCount: failures.length,
+        successCount,
+        lastFailureTime,
+        lastSuccessTime,
+        halfOpenSuccesses
+      };
+    },
+    reset() {
+      transitionTo("CLOSED");
+      failures = [];
+      halfOpenSuccesses = 0;
+    },
+    forceOpen() {
+      lastFailureTime = Date.now();
+      transitionTo("OPEN");
+    },
+    recordSuccess() {
+      handleSuccess();
+    },
+    recordFailure(error) {
+      handleFailure(error ?? new Error("Manual failure"));
+    }
+  };
+}
+var circuitBreakerPresets = {
+  /**
+   * Aggressive circuit breaker for critical paths.
+   * Opens quickly (3 failures) and recovers slowly (60s).
+   */
+  critical: {
+    failureThreshold: 3,
+    resetTimeout: 6e4,
+    windowSize: 3e4,
+    halfOpenMax: 1
+  },
+  /**
+   * Standard circuit breaker for typical API calls.
+   * Balanced between stability and availability.
+   */
+  standard: {
+    failureThreshold: 5,
+    resetTimeout: 3e4,
+    windowSize: 6e4,
+    halfOpenMax: 3
+  },
+  /**
+   * Lenient circuit breaker for non-critical operations.
+   * Opens slowly (10 failures) and recovers quickly (15s).
+   */
+  lenient: {
+    failureThreshold: 10,
+    resetTimeout: 15e3,
+    windowSize: 12e4,
+    halfOpenMax: 5
+  }
+};
+
+// src/rate-limiter/index.ts
+function isRateLimitExceededError(error) {
+  return typeof error === "object" && error !== null && error.type === "RATE_LIMIT_EXCEEDED";
+}
+function isQueueFullError(error) {
+  return typeof error === "object" && error !== null && error.type === "QUEUE_FULL";
+}
+function createRateLimiter(name, config) {
+  const { maxPerSecond, strategy = "wait" } = config;
+  const maxTokens = config.burstCapacity ?? maxPerSecond * 2;
+  let tokens = maxTokens;
+  let lastRefill = Date.now();
+  const refillRate = maxPerSecond / 1e3;
+  const waitQueue = [];
+  function refill() {
+    const now = Date.now();
+    const elapsed = now - lastRefill;
+    const tokensToAdd = elapsed * refillRate;
+    tokens = Math.min(maxTokens, tokens + tokensToAdd);
+    lastRefill = now;
+  }
+  function tryConsume() {
+    refill();
+    if (tokens >= 1) {
+      tokens -= 1;
+      return 0;
+    }
+    const tokensNeeded = 1 - tokens;
+    return Math.ceil(tokensNeeded / refillRate);
+  }
+  async function waitForToken() {
+    return new Promise((resolve) => {
+      const check = () => {
+        const waitTime = tryConsume();
+        if (waitTime === 0) {
+          resolve();
+        } else {
+          waitQueue.push(check);
+          setTimeout(() => {
+            const idx = waitQueue.indexOf(check);
+            if (idx !== -1) {
+              waitQueue.splice(idx, 1);
+              check();
+            }
+          }, waitTime);
+        }
+      };
+      check();
+    });
+  }
+  return {
+    async execute(operation) {
+      const waitTime = tryConsume();
+      if (waitTime > 0) {
+        if (strategy === "reject") {
+          throw {
+            type: "RATE_LIMIT_EXCEEDED",
+            limiterName: name,
+            retryAfterMs: waitTime
+          };
+        }
+        await waitForToken();
+      }
+      return operation();
+    },
+    async executeResult(operation) {
+      const waitTime = tryConsume();
+      if (waitTime > 0) {
+        if (strategy === "reject") {
+          return err2({
+            type: "RATE_LIMIT_EXCEEDED",
+            limiterName: name,
+            retryAfterMs: waitTime
+          });
+        }
+        await waitForToken();
+      }
+      return operation();
+    },
+    getStats() {
+      refill();
+      return {
+        availableTokens: Math.floor(tokens),
+        maxTokens,
+        tokensPerSecond: maxPerSecond,
+        waitingCount: waitQueue.length
+      };
+    },
+    reset() {
+      tokens = maxTokens;
+      lastRefill = Date.now();
+      waitQueue.length = 0;
+    }
+  };
+}
+function createConcurrencyLimiter(name, config) {
+  const { maxConcurrent, strategy = "queue", maxQueueSize = Infinity } = config;
+  let activeCount = 0;
+  const queue = [];
+  async function acquire() {
+    if (activeCount < maxConcurrent) {
+      activeCount++;
+      return;
+    }
+    if (strategy === "reject") {
+      throw {
+        type: "QUEUE_FULL",
+        limiterName: name,
+        queueSize: queue.length,
+        maxQueueSize
+      };
+    }
+    if (queue.length >= maxQueueSize) {
+      throw {
+        type: "QUEUE_FULL",
+        limiterName: name,
+        queueSize: queue.length,
+        maxQueueSize
+      };
+    }
+    return new Promise((resolve, reject) => {
+      queue.push({ resolve, reject });
+    });
+  }
+  function release() {
+    activeCount--;
+    if (queue.length > 0 && activeCount < maxConcurrent) {
+      activeCount++;
+      const next = queue.shift();
+      next?.resolve();
+    }
+  }
+  return {
+    async execute(operation) {
+      await acquire();
+      try {
+        return await operation();
+      } finally {
+        release();
+      }
+    },
+    async executeAll(operations) {
+      const results = new Array(operations.length);
+      const executing = [];
+      for (let i = 0; i < operations.length; i++) {
+        const index = i;
+        const promise = this.execute(operations[index]).then((result) => {
+          results[index] = result;
+        });
+        executing.push(promise);
+      }
+      await Promise.all(executing);
+      return results;
+    },
+    async executeResult(operation) {
+      try {
+        await acquire();
+      } catch (error) {
+        if (isQueueFullError(error)) {
+          return err2(error);
+        }
+        throw error;
+      }
+      try {
+        return await operation();
+      } finally {
+        release();
+      }
+    },
+    getStats() {
+      return {
+        activeCount,
+        maxConcurrent,
+        queueSize: queue.length,
+        maxQueueSize
+      };
+    },
+    reset() {
+      activeCount = 0;
+      while (queue.length > 0) {
+        const item = queue.shift();
+        item?.reject(new Error("Limiter reset"));
+      }
+    }
+  };
+}
+function createCombinedLimiter(name, config) {
+  const rate = config.rate ? createRateLimiter(`${name}-rate`, config.rate) : void 0;
+  const concurrency = config.concurrency ? createConcurrencyLimiter(`${name}-concurrency`, config.concurrency) : void 0;
+  return {
+    rate,
+    concurrency,
+    async execute(operation) {
+      let op = operation;
+      if (rate) {
+        const originalOp = op;
+        op = () => rate.execute(originalOp);
+      }
+      if (concurrency) {
+        return concurrency.execute(op);
+      }
+      return op();
+    }
+  };
+}
+function createFixedWindowLimiter(name, config) {
+  const { limit, windowMs = 1e3, strategy = "wait" } = config;
+  let windowStart = Date.now();
+  let requestCount = 0;
+  const waitQueue = [];
+  function checkWindow() {
+    const now = Date.now();
+    const elapsed = now - windowStart;
+    if (elapsed >= windowMs) {
+      windowStart = now;
+      requestCount = 0;
+      return 0;
+    }
+    return windowMs - elapsed;
+  }
+  function tryConsume(cost) {
+    const remainingMs = checkWindow();
+    if (requestCount + cost <= limit) {
+      requestCount += cost;
+      return 0;
+    }
+    return remainingMs;
+  }
+  async function waitForWindow(cost) {
+    return new Promise((resolve) => {
+      const check = () => {
+        const waitTime = tryConsume(cost);
+        if (waitTime === 0) {
+          resolve();
+        } else {
+          waitQueue.push({ resolve: check, cost });
+          setTimeout(() => {
+            const idx = waitQueue.findIndex((w) => w.resolve === check);
+            if (idx !== -1) {
+              waitQueue.splice(idx, 1);
+              check();
+            }
+          }, waitTime);
+        }
+      };
+      check();
+    });
+  }
+  return {
+    async execute(operation, cost = 1) {
+      if (cost > limit) {
+        throw {
+          type: "RATE_LIMIT_EXCEEDED",
+          limiterName: name,
+          retryAfterMs: windowMs
+        };
+      }
+      const waitTime = tryConsume(cost);
+      if (waitTime > 0) {
+        if (strategy === "reject") {
+          throw {
+            type: "RATE_LIMIT_EXCEEDED",
+            limiterName: name,
+            retryAfterMs: waitTime
+          };
+        }
+        await waitForWindow(cost);
+      }
+      return operation();
+    },
+    async executeResult(operation, cost = 1) {
+      if (cost > limit) {
+        return err2({
+          type: "RATE_LIMIT_EXCEEDED",
+          limiterName: name,
+          retryAfterMs: windowMs
+        });
+      }
+      const waitTime = tryConsume(cost);
+      if (waitTime > 0) {
+        if (strategy === "reject") {
+          return err2({
+            type: "RATE_LIMIT_EXCEEDED",
+            limiterName: name,
+            retryAfterMs: waitTime
+          });
+        }
+        await waitForWindow(cost);
+      }
+      return operation();
+    },
+    getStats() {
+      const remainingMs = checkWindow();
+      return {
+        requestCount,
+        limit,
+        windowMs,
+        remainingMs,
+        waitingCount: waitQueue.length
+      };
+    },
+    reset() {
+      windowStart = Date.now();
+      requestCount = 0;
+      waitQueue.length = 0;
+    }
+  };
+}
+function createCostBasedRateLimiter(name, config) {
+  const { tokensPerSecond, strategy = "wait" } = config;
+  const maxTokens = config.maxTokens ?? tokensPerSecond * 2;
+  let tokens = maxTokens;
+  let lastRefill = Date.now();
+  const refillRate = tokensPerSecond / 1e3;
+  const waitQueue = [];
+  function refill() {
+    const now = Date.now();
+    const elapsed = now - lastRefill;
+    const tokensToAdd = elapsed * refillRate;
+    tokens = Math.min(maxTokens, tokens + tokensToAdd);
+    lastRefill = now;
+  }
+  function tryConsume(cost) {
+    refill();
+    if (tokens >= cost) {
+      tokens -= cost;
+      return 0;
+    }
+    const tokensNeeded = cost - tokens;
+    return Math.ceil(tokensNeeded / refillRate);
+  }
+  async function waitForTokens(cost) {
+    return new Promise((resolve) => {
+      const check = () => {
+        const waitTime = tryConsume(cost);
+        if (waitTime === 0) {
+          resolve();
+        } else {
+          waitQueue.push({ check, cost });
+          setTimeout(() => {
+            const idx = waitQueue.findIndex((w) => w.check === check);
+            if (idx !== -1) {
+              waitQueue.splice(idx, 1);
+              check();
+            }
+          }, waitTime);
+        }
+      };
+      check();
+    });
+  }
+  return {
+    async execute(operation, cost = 1) {
+      if (cost > maxTokens) {
+        throw {
+          type: "RATE_LIMIT_EXCEEDED",
+          limiterName: name,
+          retryAfterMs: Math.ceil(cost / refillRate)
+        };
+      }
+      const waitTime = tryConsume(cost);
+      if (waitTime > 0) {
+        if (strategy === "reject") {
+          throw {
+            type: "RATE_LIMIT_EXCEEDED",
+            limiterName: name,
+            retryAfterMs: waitTime
+          };
+        }
+        await waitForTokens(cost);
+      }
+      return operation();
+    },
+    async executeResult(operation, cost = 1) {
+      if (cost > maxTokens) {
+        return err2({
+          type: "RATE_LIMIT_EXCEEDED",
+          limiterName: name,
+          retryAfterMs: Math.ceil(cost / refillRate)
+        });
+      }
+      const waitTime = tryConsume(cost);
+      if (waitTime > 0) {
+        if (strategy === "reject") {
+          return err2({
+            type: "RATE_LIMIT_EXCEEDED",
+            limiterName: name,
+            retryAfterMs: waitTime
+          });
+        }
+        await waitForTokens(cost);
+      }
+      return operation();
+    },
+    getStats() {
+      refill();
+      return {
+        availableTokens: tokens,
+        maxTokens,
+        tokensPerSecond,
+        waitingCount: waitQueue.length
+      };
+    },
+    reset() {
+      tokens = maxTokens;
+      lastRefill = Date.now();
+      waitQueue.length = 0;
+    }
+  };
+}
+var rateLimiterPresets = {
+  /**
+   * Typical API rate limit (10 req/s).
+   */
+  api: {
+    maxPerSecond: 10,
+    burstCapacity: 20,
+    strategy: "wait"
+  },
+  /**
+   * Database pool limit (concurrent connections).
+   */
+  database: {
+    maxConcurrent: 10,
+    strategy: "queue",
+    maxQueueSize: 100
+  },
+  /**
+   * Aggressive rate limit for external APIs (5 req/s).
+   */
+  external: {
+    maxPerSecond: 5,
+    burstCapacity: 10,
+    strategy: "wait"
+  }
+};
+
+// src/cache.ts
+function toMs2(duration) {
+  if (typeof duration === "string") {
+    const parsed = parse(duration);
+    if (!parsed) {
+      throw new Error(`Invalid duration string: ${duration}`);
+    }
+    return parsed.millis;
+  }
+  return duration.millis;
+}
+function cached(fn) {
+  let state = { status: "empty" };
+  return async () => {
+    if (state.status === "filled") {
+      return state.value;
+    }
+    if (state.status === "pending") {
+      return state.promise;
+    }
+    const promise = Promise.resolve(fn()).then((value) => {
+      state = { status: "filled", value };
+      return value;
+    });
+    state = { status: "pending", promise };
+    return promise;
+  };
+}
+function cachedWithTTL(fn, options) {
+  const ttlMs = toMs2(options.ttl);
+  let state = { status: "empty" };
+  return async () => {
+    const now = Date.now();
+    if (state.status === "filled" && now < state.expiresAt) {
+      return state.value;
+    }
+    if (state.status === "pending") {
+      return state.promise;
+    }
+    const promise = Promise.resolve(fn()).then((value) => {
+      state = {
+        status: "filled",
+        value,
+        expiresAt: Date.now() + ttlMs
+      };
+      return value;
+    });
+    state = { status: "pending", promise };
+    return promise;
+  };
+}
+function cachedFunction(fn, options = {}) {
+  const {
+    keyFn = (...args) => JSON.stringify(args),
+    maxSize = Infinity
+  } = options;
+  const ttlMs = options.ttl ? toMs2(options.ttl) : void 0;
+  const cache = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  let hits = 0;
+  let misses = 0;
+  function evictOldest() {
+    if (cache.size <= maxSize) return;
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of cache.entries()) {
+      if (entry.timestamp < oldestTime) {
+        oldestTime = entry.timestamp;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey) {
+      cache.delete(oldestKey);
+    }
+  }
+  const memoized = async (...args) => {
+    const key = keyFn(...args);
+    const now = Date.now();
+    const cached2 = cache.get(key);
+    if (cached2) {
+      if (cached2.expiresAt && now >= cached2.expiresAt) {
+        cache.delete(key);
+      } else {
+        hits++;
+        return cached2.value;
+      }
+    }
+    const pendingPromise = pending.get(key);
+    if (pendingPromise) {
+      return pendingPromise;
+    }
+    misses++;
+    const promise = Promise.resolve(fn(...args)).then((value) => {
+      const entry = {
+        value,
+        timestamp: Date.now(),
+        expiresAt: ttlMs ? Date.now() + ttlMs : void 0
+      };
+      cache.set(key, entry);
+      pending.delete(key);
+      evictOldest();
+      return value;
+    });
+    pending.set(key, promise);
+    try {
+      return await promise;
+    } catch (error) {
+      pending.delete(key);
+      throw error;
+    }
+  };
+  memoized.clear = () => {
+    cache.clear();
+    pending.clear();
+  };
+  memoized.delete = (...args) => {
+    const key = keyFn(...args);
+    return cache.delete(key);
+  };
+  memoized.has = (...args) => {
+    const key = keyFn(...args);
+    const entry = cache.get(key);
+    if (!entry) return false;
+    if (entry.expiresAt && Date.now() >= entry.expiresAt) {
+      cache.delete(key);
+      return false;
+    }
+    return true;
+  };
+  memoized.getStats = () => ({
+    hits,
+    misses,
+    size: cache.size
+  });
+  return memoized;
+}
+function once(fn) {
+  let state = { status: "idle" };
+  const onceFn = async () => {
+    if (state.status === "done") {
+      return state.value;
+    }
+    if (state.status === "failed") {
+      throw state.error;
+    }
+    if (state.status === "running") {
+      return state.promise;
+    }
+    const promise = Promise.resolve(fn()).then((value) => {
+      state = { status: "done", value };
+      return value;
+    }).catch((error) => {
+      state = { status: "failed", error };
+      throw error;
+    });
+    state = { status: "running", promise };
+    return promise;
+  };
+  Object.defineProperty(onceFn, "called", {
+    get: () => state.status !== "idle"
+  });
+  Object.defineProperty(onceFn, "completed", {
+    get: () => state.status === "done"
+  });
+  Object.defineProperty(onceFn, "failed", {
+    get: () => state.status === "failed"
+  });
+  onceFn.reset = () => {
+    state = { status: "idle" };
+  };
+  return onceFn;
+}
+function createCache(config = {}) {
+  const { maxSize = Infinity } = config;
+  const defaultTTLMs = config.defaultTTL ? toMs2(config.defaultTTL) : void 0;
+  const store = /* @__PURE__ */ new Map();
+  let hits = 0;
+  let misses = 0;
+  function isExpired(entry) {
+    return entry.expiresAt !== void 0 && Date.now() >= entry.expiresAt;
+  }
+  function evictOldest() {
+    if (store.size <= maxSize) return;
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of store.entries()) {
+      if (entry.timestamp < oldestTime) {
+        oldestTime = entry.timestamp;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey !== null) {
+      store.delete(oldestKey);
+    }
+  }
+  return {
+    get(key) {
+      const entry = store.get(key);
+      if (!entry) {
+        misses++;
+        return void 0;
+      }
+      if (isExpired(entry)) {
+        store.delete(key);
+        misses++;
+        return void 0;
+      }
+      hits++;
+      return entry.value;
+    },
+    set(key, value, options) {
+      const ttlMs = options?.ttl ? toMs2(options.ttl) : defaultTTLMs;
+      const now = Date.now();
+      store.set(key, {
+        value,
+        timestamp: now,
+        expiresAt: ttlMs ? now + ttlMs : void 0
+      });
+      evictOldest();
+    },
+    has(key) {
+      const entry = store.get(key);
+      if (!entry) return false;
+      if (isExpired(entry)) {
+        store.delete(key);
+        return false;
+      }
+      return true;
+    },
+    delete(key) {
+      return store.delete(key);
+    },
+    clear() {
+      store.clear();
+    },
+    get size() {
+      return store.size;
+    },
+    getStats() {
+      return { hits, misses, size: store.size };
+    }
+  };
+}
+
+// src/singleflight.ts
+function singleflight(operation, options) {
+  const inflight = /* @__PURE__ */ new Map();
+  const cache = options.ttl ? /* @__PURE__ */ new Map() : null;
+  return async (...args) => {
+    const key = options.key(...args);
+    if (cache) {
+      const cached2 = cache.get(key);
+      if (cached2 && cached2.expiresAt > Date.now()) {
+        return cached2.result;
+      }
+      if (cached2) {
+        cache.delete(key);
+      }
+    }
+    const existing = inflight.get(key);
+    if (existing) {
+      return existing;
+    }
+    const promise = operation(...args).then((result) => {
+      if (cache && options.ttl && result.ok) {
+        cache.set(key, {
+          result,
+          expiresAt: Date.now() + options.ttl
+        });
+      }
+      return result;
+    }).finally(() => {
+      inflight.delete(key);
+    });
+    inflight.set(key, promise);
+    return promise;
+  };
+}
+function createSingleflightGroup() {
+  const inflight = /* @__PURE__ */ new Map();
+  return {
+    execute: async (key, operation) => {
+      const existing = inflight.get(key);
+      if (existing) {
+        return existing;
+      }
+      const promise = operation().then((result) => result).finally(() => {
+        inflight.delete(key);
+      });
+      inflight.set(key, promise);
+      return promise;
+    },
+    isInflight: (key) => inflight.has(key),
+    size: () => inflight.size,
+    clear: () => inflight.clear()
+  };
+}
+
+// src/policies.ts
+function mergePolicies(...policies) {
+  const result = {};
+  for (const policy of policies) {
+    if (policy.key !== void 0) result.key = policy.key;
+    if (policy.retry !== void 0) {
+      result.retry = result.retry ? { ...result.retry, ...policy.retry } : { ...policy.retry };
+    }
+    if (policy.timeout !== void 0) {
+      result.timeout = result.timeout ? { ...result.timeout, ...policy.timeout } : { ...policy.timeout };
+    }
+  }
+  return result;
+}
+function createPolicyApplier(...basePolicies) {
+  const basePolicy = mergePolicies(...basePolicies);
+  return (stepOptions2) => {
+    const opts = stepOptions2 ?? {};
+    return mergePolicies(basePolicy, opts);
+  };
+}
+function createPolicyBundle(name, ...policies) {
+  return {
+    name,
+    policy: mergePolicies(...policies)
+  };
+}
+function retryPolicy(options) {
+  return { retry: options };
+}
+var retryPolicies = {
+  /**
+   * No retry - fail immediately on error.
+   */
+  none: retryPolicy({ attempts: 1 }),
+  /**
+   * Quick retry for transient errors (3 attempts, fast backoff).
+   */
+  transient: retryPolicy({
+    attempts: 3,
+    backoff: "exponential",
+    initialDelay: 100,
+    maxDelay: 1e3,
+    jitter: true
+  }),
+  /**
+   * Standard retry for API calls (3 attempts, moderate backoff).
+   */
+  standard: retryPolicy({
+    attempts: 3,
+    backoff: "exponential",
+    initialDelay: 200,
+    maxDelay: 5e3,
+    jitter: true
+  }),
+  /**
+   * Aggressive retry for critical operations (5 attempts, longer backoff).
+   */
+  aggressive: retryPolicy({
+    attempts: 5,
+    backoff: "exponential",
+    initialDelay: 500,
+    maxDelay: 3e4,
+    jitter: true
+  }),
+  /**
+   * Fixed interval retry (useful for polling).
+   */
+  fixed: (attempts, delayMs) => retryPolicy({
+    attempts,
+    backoff: "fixed",
+    initialDelay: delayMs,
+    jitter: false
+  }),
+  /**
+   * Linear backoff retry.
+   */
+  linear: (attempts, initialDelay) => retryPolicy({
+    attempts,
+    backoff: "linear",
+    initialDelay,
+    jitter: true
+  }),
+  /**
+   * Custom retry policy builder.
+   */
+  custom: (options) => retryPolicy({
+    backoff: "exponential",
+    initialDelay: 100,
+    maxDelay: 3e4,
+    jitter: true,
+    ...options
+  })
+};
+function timeoutPolicy(options) {
+  return { timeout: options };
+}
+var timeoutPolicies = {
+  /**
+   * No timeout.
+   */
+  none: {},
+  /**
+   * Fast timeout for quick operations (1 second).
+   */
+  fast: timeoutPolicy({ ms: 1e3 }),
+  /**
+   * Standard API timeout (5 seconds).
+   */
+  api: timeoutPolicy({ ms: 5e3 }),
+  /**
+   * Extended timeout for slower operations (30 seconds).
+   */
+  extended: timeoutPolicy({ ms: 3e4 }),
+  /**
+   * Long timeout for batch operations (2 minutes).
+   */
+  long: timeoutPolicy({ ms: 12e4 }),
+  /**
+   * Custom timeout in milliseconds.
+   */
+  ms: (ms) => timeoutPolicy({ ms }),
+  /**
+   * Custom timeout in seconds.
+   */
+  seconds: (seconds2) => timeoutPolicy({ ms: seconds2 * 1e3 }),
+  /**
+   * Timeout with custom error.
+   */
+  withError: (ms, error) => timeoutPolicy({ ms, error }),
+  /**
+   * Timeout with AbortSignal support.
+   */
+  withSignal: (ms) => timeoutPolicy({ ms, signal: true })
+};
+var servicePolicies = {
+  /**
+   * Policy for external HTTP APIs.
+   * - 5 second timeout
+   * - 3 retries with exponential backoff
+   */
+  httpApi: mergePolicies(
+    timeoutPolicies.api,
+    retryPolicies.standard
+  ),
+  /**
+   * Policy for database operations.
+   * - 30 second timeout
+   * - 2 retries for transient errors
+   */
+  database: mergePolicies(
+    timeoutPolicies.extended,
+    retryPolicy({
+      attempts: 2,
+      backoff: "exponential",
+      initialDelay: 100,
+      maxDelay: 2e3,
+      jitter: true
+    })
+  ),
+  /**
+   * Policy for cache operations.
+   * - 1 second timeout
+   * - No retry (cache misses are not errors)
+   */
+  cache: mergePolicies(
+    timeoutPolicies.fast,
+    retryPolicies.none
+  ),
+  /**
+   * Policy for message queue operations.
+   * - 30 second timeout
+   * - 5 retries with longer backoff
+   */
+  messageQueue: mergePolicies(
+    timeoutPolicies.extended,
+    retryPolicies.aggressive
+  ),
+  /**
+   * Policy for file operations.
+   * - 2 minute timeout
+   * - 3 retries
+   */
+  fileSystem: mergePolicies(
+    timeoutPolicies.long,
+    retryPolicies.standard
+  ),
+  /**
+   * Policy for third-party services with rate limits.
+   * - 10 second timeout
+   * - 5 retries with linear backoff
+   */
+  rateLimited: mergePolicies(
+    timeoutPolicy({ ms: 1e4 }),
+    retryPolicy({
+      attempts: 5,
+      backoff: "linear",
+      initialDelay: 1e3,
+      maxDelay: 1e4,
+      jitter: true
+    })
+  )
+};
+function withPolicy(policy, stepOptions2) {
+  const opts = stepOptions2 ?? {};
+  return mergePolicies(policy, opts);
+}
+function withPolicies(policies, stepOptions2) {
+  const opts = stepOptions2 ?? {};
+  return mergePolicies(...policies, opts);
+}
+function conditionalPolicy(condition, policy, elsePolicy = {}) {
+  return condition ? policy : elsePolicy;
+}
+function envPolicy(envPolicies, currentEnv = process.env.NODE_ENV ?? "development", defaultPolicy = {}) {
+  return envPolicies[currentEnv] ?? defaultPolicy;
+}
+function createPolicyRegistry() {
+  const policies = /* @__PURE__ */ new Map();
+  return {
+    register(name, policy) {
+      policies.set(name, policy);
+    },
+    get(name) {
+      return policies.get(name);
+    },
+    has(name) {
+      return policies.has(name);
+    },
+    names() {
+      return Array.from(policies.keys());
+    },
+    apply(policyName, stepOptions2) {
+      const policy = policies.get(policyName);
+      if (!policy) {
+        throw new Error(`Policy not found: ${policyName}`);
+      }
+      return withPolicy(policy, stepOptions2);
+    }
+  };
+}
+function stepOptions() {
+  const policies = [];
+  const builder = {
+    key(key) {
+      policies.push({ key });
+      return builder;
+    },
+    policy(policy) {
+      policies.push(policy);
+      return builder;
+    },
+    timeout(ms) {
+      policies.push(timeoutPolicy({ ms }));
+      return builder;
+    },
+    retry(options) {
+      policies.push(retryPolicy(options));
+      return builder;
+    },
+    retries(attempts) {
+      policies.push(retryPolicies.custom({ attempts }));
+      return builder;
+    },
+    build() {
+      return mergePolicies(...policies);
+    }
+  };
+  return builder;
+}
+
+// src/conditional.ts
+function generateDecisionId() {
+  return `decision_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function emitSkipped(ctx, options, decisionId) {
+  if (!ctx?.onEvent) return;
+  const event = {
+    type: "step_skipped",
+    workflowId: ctx.workflowId,
+    stepKey: options?.key,
+    name: options?.name,
+    reason: options?.reason,
+    decisionId,
+    ts: Date.now()
+  };
+  const eventWithContext = event.context !== void 0 || ctx.context === void 0 ? event : { ...event, context: ctx.context };
+  ctx.onEvent(eventWithContext);
+}
+function when2(condition, operation, options, ctx) {
+  if (condition) {
+    return operation();
+  }
+  const decisionId = generateDecisionId();
+  emitSkipped(ctx, options, decisionId);
+  return void 0;
+}
+function unless(condition, operation, options, ctx) {
+  return when2(!condition, operation, options, ctx);
+}
+function whenOr(condition, operation, defaultValue, options, ctx) {
+  if (condition) {
+    return operation();
+  }
+  const decisionId = generateDecisionId();
+  emitSkipped(ctx, options, decisionId);
+  return defaultValue;
+}
+function unlessOr(condition, operation, defaultValue, options, ctx) {
+  return whenOr(!condition, operation, defaultValue, options, ctx);
+}
+function createConditionalHelpers(ctx) {
+  return {
+    /**
+     * Run a step only if condition is true, return undefined if skipped.
+     */
+    when: (condition, operation, options) => when2(condition, operation, options, ctx),
+    /**
+     * Run a step only if condition is false, return undefined if skipped.
+     */
+    unless: (condition, operation, options) => unless(condition, operation, options, ctx),
+    /**
+     * Run a step only if condition is true, return default value if skipped.
+     */
+    whenOr: (condition, operation, defaultValue, options) => whenOr(condition, operation, defaultValue, options, ctx),
+    /**
+     * Run a step only if condition is false, return default value if skipped.
+     */
+    unlessOr: (condition, operation, defaultValue, options) => unlessOr(condition, operation, defaultValue, options, ctx)
+  };
+}
+export {
+  ALL_SLUGS,
+  AWAITLY_CANCELLED,
+  AWAITLY_SLUGS,
+  AWAITLY_SYSTEM_ERROR_CLASSES,
+  AWAITLY_TIMEOUT,
+  AWAITLY_UNEXPECTED,
+  CircuitBreakerOpenError,
+  CircuitOpenError,
+  CompensationError,
+  DESERIALIZATION_ERROR,
+  Duration,
+  EARLY_EXIT_SYMBOL,
+  Match,
+  NetworkError,
+  NotFoundError,
+  PROMISE_REJECTED,
+  RateLimitError,
+  RetryExhaustedError,
+  STEP_TIMEOUT_MARKER,
+  TaggedError,
+  TimeoutError,
+  UnauthorizedError,
+  UnexpectedError,
+  UnwrapError,
+  ValidationError,
+  add,
+  all,
+  allAsync,
+  allSettled,
+  allSettledAsync,
+  andThen,
+  any,
+  anyAsync,
+  bimap,
+  cached,
+  cachedFunction,
+  cachedWithTTL,
+  circuitBreakerPresets,
+  clamp,
+  conditionalPolicy,
+  createCache,
+  createCircuitBreaker,
+  createCombinedLimiter,
+  createConcurrencyLimiter,
+  createConditionalHelpers,
+  createCostBasedRateLimiter,
+  createEarlyExit,
+  createFixedWindowLimiter,
+  createPolicyApplier,
+  createPolicyBundle,
+  createPolicyRegistry,
+  createRateLimiter,
+  createSingleflightGroup,
+  days,
+  deserialize,
+  divide,
+  envPolicy,
+  equals,
+  err,
+  exhaustive,
+  fallback,
+  flatten,
+  format,
+  from,
+  fromNullable,
+  fromPromise,
+  getStepTimeoutMeta,
+  greaterThan,
+  greaterThanOrEqual,
+  hours,
+  hydrate,
+  infinity,
+  isAwaitlyError,
+  isAwaitlySlug,
+  isCircuitBreakerOpenError,
+  isCircuitOpenError,
+  isCompensationError,
+  isDuration,
+  isEarlyExit,
+  isErr,
+  isFinite,
+  isInfinite,
+  isNetworkError,
+  isNotFoundError,
+  isOk,
+  isOneOf,
+  isPromiseRejectedError,
+  isQueueFullError,
+  isRateLimitError,
+  isRateLimitExceededError,
+  isRetryExhaustedError,
+  isSerializedResult,
+  isStepTimeoutError,
+  is as isTag,
+  isTimeoutError,
+  isUnauthorizedError,
+  isUnexpectedError,
+  isValidationError,
+  isZero,
+  lessThan,
+  lessThanOrEqual,
+  makeError,
+  map,
+  mapError,
+  mapErrorTry,
+  mapTry,
+  match,
+  matchError,
+  matchErrorPartial,
+  orElse2 as matchOrElse,
+  tag as matchTag,
+  tags2 as matchTags,
+  matchValue,
+  max,
+  mergePolicies,
+  millis,
+  min,
+  minutes,
+  multiply,
+  ok,
+  once,
+  orElse,
+  orElseAsync,
+  orElseValue,
+  parse,
+  partition,
+  rateLimiterPresets,
+  recover,
+  recoverAsync,
+  retry,
+  retryPolicies,
+  retryPolicy,
+  run,
+  runOrNull,
+  runOrThrow,
+  runOrThrowAsync,
+  runOrUndefined,
+  seconds,
+  serialize,
+  servicePolicies,
+  singleflight,
+  slugCategory,
+  slugDocsUrl,
+  stepOptions,
+  subtract,
+  tags,
+  tap,
+  tapError,
+  timeout,
+  timeoutPolicies,
+  timeoutPolicy,
+  toDays,
+  toHours,
+  toMillis,
+  toMinutes,
+  toSeconds,
+  tryAsync,
+  unless,
+  unlessOr,
+  unwrap,
+  unwrapOr,
+  unwrapOrElse,
+  when2 as when,
+  whenOr,
+  withDeps,
+  withPolicies,
+  withPolicy,
+  zero,
+  zip,
+  zipAsync
+};
 //# sourceMappingURL=index.js.map