awaitly 1.35.0 → 2.0.0

package/dist/testing.js

@@ -1,13 +1,4159 @@
-var It={"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 rt(e){return`https://jagreehal.github.io/awaitly/rules/#${e}`}var mr=Object.keys(It);var We=class extends Error{_tag};function Te(e,t){return class extends We{_tag=e;constructor(n,m){let s=t?.message?t.message(n??{}):e;if(super(s),this.name=e,t?.slug!==void 0){if(!t.hint)throw new TypeError(`TaggedError: 'hint' is required when 'slug' is set (slug: "${t.slug}")`);Object.defineProperty(this,"code",{value:t.slug,enumerable:!0,writable:!1,configurable:!1}),Object.defineProperty(this,"hint",{value:t.hint,enumerable:!0,writable:!1,configurable:!1}),Object.defineProperty(this,"docsUrl",{value:rt(t.slug),enumerable:!0,writable:!1,configurable:!1})}if(Object.setPrototypeOf(this,new.target.prototype),n&&typeof n=="object"){let a;if(t?.slug!==void 0){let{_tag:K,name:I,message:O,stack:r,code:q,hint:L,docsUrl:de,...ne}=n;a=ne}else{let{_tag:K,name:I,message:O,stack:r,...q}=n;a=q}let w=Object.prototype.hasOwnProperty.call(a,"cause"),v=w?a.cause:void 0;w&&delete a.cause;let W=m?.cause!==void 0;if(w&&W)throw new TypeError("TaggedError: cannot provide 'cause' in props when also setting ErrorOptions.cause");Object.assign(this,a),w&&(this.cause=v),W&&(this.cause=m?.cause)}else m?.cause!==void 0&&(this.cause=m.cause)}}}Object.defineProperty(Te,Symbol.hasInstance,{value:e=>e instanceof We});(s=>{function e(a){return a instanceof Error}s.isError=e;function t(a){return a instanceof We}s.isTaggedError=t;function n(a,w){let v=a._tag,W=w[v];return W(a)}s.match=n;function m(a,w,v){let W=a._tag,K=w[W];return K?K(a):v(a)}s.matchPartial=m})(Te||={});var nt=class extends Te("TimeoutError",{slug:"runtime-step-timeout",hint:"Increase the step's timeout option, or check why the upstream operation is slow.",message:t=>t.operation?`TimeoutError: ${t.operation} timed out after ${t.ms}ms`:`TimeoutError: Operation timed out after ${t.ms}ms`}){},ot=class extends Te("RetryExhaustedError",{slug:"runtime-retry-exhausted",hint:"All retry attempts failed. Inspect lastError and decide whether to surface it or compensate.",message:t=>t.operation?`RetryExhaustedError: ${t.operation} failed after ${t.attempts} attempts`:`RetryExhaustedError: Operation failed after ${t.attempts} attempts`}){},st=class extends Te("RateLimitError",{slug:"runtime-rate-limit",hint:"Wait retryAfterMs before retrying, or apply step.cache to deduplicate calls.",message:t=>t.limiterName?`RateLimitError: Rate limit exceeded for ${t.limiterName}${t.retryAfterMs?`, retry after ${t.retryAfterMs}ms`:""}`:`RateLimitError: Rate limit exceeded${t.retryAfterMs?`, retry after ${t.retryAfterMs}ms`:""}`}){},at=class extends Te("CircuitBreakerOpenError",{slug:"runtime-circuit-open",hint:"The circuit is open. Wait for it to half-open or fall back to a degraded path.",message:t=>`CircuitBreakerOpenError: Circuit ${t.circuitName} is ${t.state??"OPEN"}${t.retryAfterMs?`, retry after ${Math.ceil(t.retryAfterMs/1e3)}s`:""}`}){},it=class extends Te("ValidationError",{message:t=>`ValidationError: Invalid ${t.field} - ${t.reason}`}){},ut=class extends Te("NotFoundError",{message:t=>t.id?`NotFoundError: ${t.resource} with id ${t.id} not found`:`NotFoundError: ${t.resource} not found`}){},lt=class extends Te("UnauthorizedError",{message:t=>t.reason?`UnauthorizedError: ${t.reason}`:t.action&&t.resource?`UnauthorizedError: Not authorized to ${t.action} ${t.resource}`:"UnauthorizedError: Access denied"}){},ct=class extends Te("NetworkError",{message:t=>t.url?`NetworkError: ${t.reason} (${t.url})`:`NetworkError: ${t.reason}`}){},pt=class extends Te("CompensationError",{slug:"runtime-saga-compensation",hint:"A saga compensation step failed. Inspect compensationError and ensure compensation is idempotent.",message:t=>`CompensationError: Failed to compensate step ${t.step}`}){},he=class extends Te("UnexpectedError",{slug:"runtime-unexpected",hint:"An unexpected exception escaped a step. Inspect cause; consider returning a typed Result instead of throwing.",message:t=>`UnexpectedError: ${t.cause instanceof Error?t.cause.message:String(t.cause??"unknown")}`}){};function dt(e){return{ok:!0,value:e}}var Ut=e=>typeof e=="object"&&e!==null&&"ok"in e&&typeof e.ok=="boolean"&&(e.ok?"value"in e:"error"in e),Ne=(e,t)=>{let n={},m=new Map;for(let s of Object.keys(e)){let a=e[s];typeof a=="function"&&(n[s]=(...w)=>{let v=(m.get(s)??0)+1;m.set(s,v);let W=v===1?s:`${s}#${v}`;return t(W,async()=>{let K=await a(...w);return Ut(K)?K:dt(K)})})}return n};function Wt(e){let t=e.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i);if(!t)return;let n=parseFloat(t[1]),m=t[2].toLowerCase();return{_tag:"Duration",millis:n*({ms:1,s:1e3,m:6e4,h:36e5,d:864e5}[m]??1)}}function $e(e){return new he({cause:e})}function Z(e){return{ok:!0,value:e}}function j(e,t){let n=t?.cause;return{ok:!1,error:e,...n!==void 0?{cause:n}:{}}}var wt=e=>e.ok;var yt=e=>e instanceof he||typeof e=="object"&&e!==null&&"_tag"in e&&e._tag==="UnexpectedError";function Nt(e){if(e==null)return"unknown";if(typeof e=="string")return e.trim()||"unknown";if(typeof e=="object"){let t=e;if(typeof t._tag=="string"){let n=t._tag.trim();if(n)return n}if(typeof t.tag=="string"){let n=t.tag.trim();if(n)return n}if(typeof t.code=="string"){let n=t.code.trim();if(n)return n}else if(typeof t.code=="number")return String(t.code);if(e instanceof Error&&e.name){let n=e.name.trim();if(n)return n}}return"unknown"}function jt(e,t){if(!(!t||!e))return t[e]}function qe(e){let{intent:t,domain:n,owner:m,tags:s,stateChanges:a,emits:w,calls:v}=e;if(!t&&!n&&!m&&!s?.length&&!a?.length&&!w?.length&&!v?.length)return;let W={};return t&&(W.intent=t),n&&(W.domain=n),m&&(W.owner=m),s?.length&&(W.tags=s),a?.length&&(W.stateChanges=a),w?.length&&(W.emits=w),v?.length&&(W.calls=v),W}function xe(e,t,n,m,s){let a=Nt(e),w=jt(a,t),v={tag:a,origin:n};return w!==void 0&&(v.classification=w),m!==void 0&&(v.attempt=m),s!==void 0&&(v.cumulativeDurationMs=s),v}var Oe=Symbol.for("step_timeout_marker");function mt(e){return typeof e!="object"||e===null?!1:e.type==="STEP_TIMEOUT"?!0:Oe in e}function Kt(e){if(!(typeof e!="object"||e===null)){if(e.type==="STEP_TIMEOUT"){let t=e;return{timeoutMs:t.timeoutMs,stepName:t.stepName,stepKey:t.stepKey,attempt:t.attempt}}if(Oe in e)return e[Oe]}}var kt=Symbol("early-exit");function De(e,t){return{[kt]:!0,error:e,meta:t}}function ve(e){return typeof e=="object"&&e!==null&&e[kt]===!0}var gt=Symbol("mapper-exception");function Ae(e){return{[gt]:!0,thrown:e}}function Ft(e){return typeof e=="object"&&e!==null&&e[gt]===!0}function He(e,t){let{backoff:n,initialDelay:m,maxDelay:s,jitter:a}=t,w;switch(n){case"fixed":w=m;break;case"linear":w=m*e;break;case"exponential":w=m*Math.pow(2,e-1);break}if(w=Math.min(w,s),a){let v=w*.25*Math.random();w=w+v}return Math.floor(w)}function Je(e){return new Promise(t=>setTimeout(t,e))}var Et=Symbol("timeout"),Fe=Symbol("timeout-option");function $t(e){return typeof e=="object"&&e!==null&&e[Fe]===!0}async function Bt(e,t,n,m){let s=new AbortController,a=t.onTimeout??"error",w=()=>typeof a=="function"?a({name:n.name,key:n.key,ms:t.ms}):t.error??{type:"STEP_TIMEOUT",stepName:n.name,stepKey:n.key,timeoutMs:t.ms,attempt:n.attempt},v;m?.aborted&&s.abort(m.reason);let W;m&&!m.aborted&&(W=()=>s.abort(m.reason),m.addEventListener("abort",W,{once:!0}));let K=new Promise((O,r)=>{v=setTimeout(()=>{if(a!=="disconnect"&&s.abort(),a==="option"){r({[Fe]:!0,ms:t.ms});return}r({[Et]:!0,error:w()})},t.ms)}),I;t.signal?I=Promise.resolve(e(s.signal)):I=Promise.resolve(e());try{return await Promise.race([I,K])}catch(O){if(typeof O=="object"&&O!==null&&O[Fe]===!0)throw{[Fe]:!0,ms:t.ms};if(typeof O=="object"&&O!==null&&O[Et]===!0){a==="disconnect"&&I.catch(()=>{});let r=O.error;if(typeof r=="object"&&r!==null&&r.type!=="STEP_TIMEOUT"){let q={timeoutMs:t.ms,stepName:n.name,stepKey:n.key,attempt:n.attempt};Oe in r?r[Oe]=q:Object.defineProperty(r,Oe,{value:q,enumerable:!1,writable:!0,configurable:!1})}throw r}throw O}finally{clearTimeout(v),W&&m&&m.removeEventListener("abort",W)}}var Pe={backoff:"exponential",initialDelay:100,maxDelay:3e4,jitter:!0,shouldRetry:()=>!0,onRetry:()=>{}};async function je(e,t,n){if(typeof e!="function"){let y=e,oe=t;if(typeof oe!="function")throw new TypeError("[awaitly] run(deps, fn) requires a callback as the second argument. Example: run({ getUser }, async (s) => s.getUser(id))");return je(({step:ue})=>oe(Ne(y,ue),{step:ue}),n)}let m=e,s=t,{onError:a,onEvent:w,catchUnexpected:v,workflowId:W,workflowName:K,context:I,_workflowSignal:O}=s&&typeof s=="object"?s:{},r=W??crypto.randomUUID(),q=v??$e,L=[],de=0,ne=y=>y??`step_${++de}`,u=y=>{let oe=y.context!==void 0||I===void 0?y:{...y,context:I},me=K!==void 0&&oe.workflowName===void 0?{...oe,workflowName:K}:oe;if(me.type==="step_success"){let ue=me.stepId;for(let ce=L.length-1;ce>=0;ce--){let F=L[ce];if(F.type==="race"&&!F.winnerId){F.winnerId=ue;break}}}w?.(me,I)},Q=De,we=y=>ve(y),_=(y,oe)=>y,z=y=>typeof y=="function"?!1:!!(y&&typeof y=="object"&&"ok"in y||y&&typeof y=="object"&&"then"in y&&typeof y.then=="function");try{let oe=function(E){let S={};for(let[l,c]of Object.entries(E))if(typeof c=="function")S[l]=c;else if(c&&typeof c=="object"&&"fn"in c)S[l]=c.fn;else throw new TypeError(`step.all: operation "${l}" must be a function or { fn, errors? } object`);return S},me=function(E,S){let l=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let c=performance.now(),o=!1;L.push({scopeId:l,type:"parallel"});let i=()=>{if(o)return;o=!0;let T=L.findIndex(h=>h.scopeId===l);T!==-1&&L.splice(T,1),u({type:"scope_end",workflowId:r,scopeId:l,ts:Date.now(),durationMs:performance.now()-c})};u({type:"scope_start",workflowId:r,scopeId:l,scopeType:"parallel",name:E,ts:Date.now()});try{let T=await S();if(i(),!T.ok)throw a?.(T.error,E,I),Q(T.error,{origin:"result",resultCause:T.cause});return T.value}catch(T){throw i(),T}})()},ue=function(E,S){let l=Object.keys(E),c=S.name??`Parallel(${l.join(", ")})`,o=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let i=performance.now(),T=!1;L.push({scopeId:o,type:"parallel"});let h=()=>{if(T)return;T=!0;let P=L.findIndex(M=>M.scopeId===o);P!==-1&&L.splice(P,1),u({type:"scope_end",workflowId:r,scopeId:o,ts:Date.now(),durationMs:performance.now()-i})};u({type:"scope_start",workflowId:r,scopeId:o,scopeType:"parallel",name:c,ts:Date.now()});try{let P=await new Promise(N=>{if(l.length===0){N([]);return}let H=!1,ae=l.length,B=new Array(l.length);for(let G=0;G<l.length;G++){let V=l[G],Y=G;Promise.resolve(E[V]()).catch(C=>j({type:"PROMISE_REJECTED",cause:C},{cause:{type:"PROMISE_REJECTION",reason:C}})).then(C=>{if(!H){if(!C.ok){H=!0,N([{key:V,result:C}]);return}B[Y]={key:V,result:C},ae--,ae===0&&N(B)}})}});h();let M={};for(let{key:N,result:H}of P){if(!H.ok)throw a?.(H.error,N,I),Q(H.error,{origin:"result",resultCause:H.cause});M[N]=H.value}return M}catch(P){throw h(),P}})()};var ee=oe,pe=me,ye=ue;let y=(E,S,l)=>(async()=>{if(typeof E!="string"||E.length===0)throw new Error('[awaitly] step() requires an explicit string ID as the first argument. Example: step("fetchUser", () => fetchUser(id))');let c=l??{},o=qe(c),i=E,T=c.key??E,h=c.key??E,{description:P,retry:M,timeout:N}=c,H=ne(T),ae=w,B=ae?performance.now():0,V=z(S)?()=>S:S,C={attempts:Math.max(1,M?.attempts??1),backoff:M?.backoff??Pe.backoff,initialDelay:M?.initialDelay??Pe.initialDelay,maxDelay:M?.maxDelay??Pe.maxDelay,jitter:M?.jitter??Pe.jitter,shouldRetry:M?.shouldRetry??Pe.shouldRetry,onRetry:M?.onRetry??Pe.onRetry};w&&u({type:"step_start",workflowId:r,stepId:H,stepKey:T,name:i,description:P,ts:Date.now(),...o&&{metadata:o}});let Re;for(let x=1;x<=C.attempts;x++){let g=ae?performance.now():0;try{let p;if(N?p=await Bt(V,N,{name:i,key:T,attempt:x},O):p=await V(),p.ok){let R=performance.now()-B;return u({type:"step_success",workflowId:r,stepId:H,stepKey:T,name:i,description:P,ts:Date.now(),durationMs:R,...o&&{metadata:o}}),h&&u({type:"step_complete",workflowId:r,stepKey:h,name:i,description:P,ts:Date.now(),durationMs:R,result:p,...o&&{metadata:o}}),p.value}if(Re=p,x<C.attempts&&C.shouldRetry(p.error,x)){let R=He(x,C);u({type:"step_retry",workflowId:r,stepId:H,stepKey:T,name:i,ts:Date.now(),attempt:x+1,maxAttempts:C.attempts,delayMs:R,error:p.error,...o&&{metadata:o},diagnostics:xe(p.error,c.errorMeta,"result",x,performance.now()-B)}),C.onRetry(p.error,x,R),await Je(R);continue}C.attempts>1&&u({type:"step_retries_exhausted",workflowId:r,stepId:H,stepKey:T,name:i,ts:Date.now(),durationMs:performance.now()-B,attempts:x,lastError:p.error,...o&&{metadata:o},diagnostics:xe(p.error,c.errorMeta,"result",x,performance.now()-B)});break}catch(p){let R=performance.now()-g;if($t(p)){let D=p.ms;u({type:"step_timeout",workflowId:r,stepId:H,stepKey:T,name:i,ts:Date.now(),timeoutMs:D,attempt:x,...o&&{metadata:o},diagnostics:xe(p,c.errorMeta,"timeout",x)}),u({type:"step_success",workflowId:r,stepId:H,stepKey:T,name:i,description:P,ts:Date.now(),durationMs:performance.now()-B,...o&&{metadata:o}}),h&&u({type:"step_complete",workflowId:r,stepKey:h,name:i,description:P,ts:Date.now(),durationMs:performance.now()-B,result:Z(void 0),...o&&{metadata:o}});return}if(we(p))throw u({type:"step_aborted",workflowId:r,stepId:H,stepKey:T,name:i,description:P,ts:Date.now(),durationMs:R,...o&&{metadata:o}}),p;if(mt(p)){let D=Kt(p),k=N?.ms??D?.timeoutMs??0;if(u({type:"step_timeout",workflowId:r,stepId:H,stepKey:T,name:i,ts:Date.now(),timeoutMs:k,attempt:x,...o&&{metadata:o},diagnostics:xe(p,c.errorMeta,"timeout",x)}),x<C.attempts&&C.shouldRetry(p,x)){let te=He(x,C);u({type:"step_retry",workflowId:r,stepId:H,stepKey:T,name:i,ts:Date.now(),attempt:x+1,maxAttempts:C.attempts,delayMs:te,error:p,...o&&{metadata:o},diagnostics:xe(p,c.errorMeta,"timeout",x,performance.now()-B)}),C.onRetry(p,x,te),await Je(te);continue}C.attempts>1&&u({type:"step_retries_exhausted",workflowId:r,stepId:H,stepKey:T,name:i,ts:Date.now(),durationMs:performance.now()-B,attempts:x,lastError:p,...o&&{metadata:o},diagnostics:xe(p,c.errorMeta,"timeout",x,performance.now()-B)});let $=performance.now()-B;throw u({type:"step_error",workflowId:r,stepId:H,stepKey:T,name:i,description:P,ts:Date.now(),durationMs:$,error:p,...o&&{metadata:o},diagnostics:xe(p,c.errorMeta,"timeout",x,$)}),h&&u({type:"step_complete",workflowId:r,stepKey:h,name:i,description:P,ts:Date.now(),durationMs:$,result:j(p,{cause:p}),meta:{origin:"throw",thrown:p},...o&&{metadata:o}}),a?.(p,i,I),Q(p,{origin:"throw",thrown:p})}if(x<C.attempts&&C.shouldRetry(p,x)){let D=He(x,C);u({type:"step_retry",workflowId:r,stepId:H,stepKey:T,name:i,ts:Date.now(),attempt:x+1,maxAttempts:C.attempts,delayMs:D,error:p,...o&&{metadata:o},diagnostics:xe(p,c.errorMeta,"throw",x,performance.now()-B)}),C.onRetry(p,x,D),await Je(D);continue}C.attempts>1&&!mt(p)&&u({type:"step_retries_exhausted",workflowId:r,stepId:H,stepKey:T,name:i,ts:Date.now(),durationMs:performance.now()-B,attempts:x,lastError:p,...o&&{metadata:o},diagnostics:xe(p,c.errorMeta,"throw",x,performance.now()-B)});let A=performance.now()-B,b;try{b=q(p)}catch(D){throw Ae(D)}throw u({type:"step_error",workflowId:r,stepId:H,stepKey:T,name:i,description:P,ts:Date.now(),durationMs:A,error:b,...o&&{metadata:o},diagnostics:xe(p,c.errorMeta,"throw",x,A)}),h&&u({type:"step_complete",workflowId:r,stepKey:h,name:i,description:P,ts:Date.now(),durationMs:A,result:j(b,{cause:p}),meta:{origin:"throw",thrown:p},...o&&{metadata:o}}),a?.(b,i,I),Q(b,{origin:"throw",thrown:p})}}let d=Re,f=performance.now()-B,X=_(d.error,{origin:"result",resultCause:d.cause});throw u({type:"step_error",workflowId:r,stepId:H,stepKey:T,name:i,description:P,ts:Date.now(),durationMs:f,error:X,...o&&{metadata:o},diagnostics:xe(d.error,c.errorMeta,"result",C.attempts,f)}),h&&u({type:"step_complete",workflowId:r,stepKey:h,name:i,description:P,ts:Date.now(),durationMs:f,result:d,meta:{origin:"result",resultCause:d.cause},...o&&{metadata:o}}),a?.(X,i,I),Q(X,{origin:"result",resultCause:d.cause})})();y.try=(E,S,l)=>{if(typeof E!="string"||E.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" })');let c="error"in l?()=>l.error:l.onError;if(l.retry||l.timeout)return y.retry(E,async()=>{try{return Z(await S())}catch(P){return j(c(P),{cause:P})}},{attempts:l.retry?.attempts??1,...l.retry??{},key:l.key,timeout:l.timeout});let o=l.key??E,i=E,T=E,h=w;return(async()=>{let P=h?performance.now():0;w&&u({type:"step_start",workflowId:r,stepId:T,stepKey:o,name:i,ts:Date.now()});try{let M=await S(),N=performance.now()-P;return u({type:"step_success",workflowId:r,stepId:T,stepKey:o,name:i,ts:Date.now(),durationMs:N}),o&&u({type:"step_complete",workflowId:r,stepKey:o,name:i,ts:Date.now(),durationMs:N,result:Z(M)}),M}catch(M){let N=c(M),H=performance.now()-P,ae=_(N,{origin:"throw",thrown:M});throw u({type:"step_error",workflowId:r,stepId:T,stepKey:o,name:i,ts:Date.now(),durationMs:H,error:ae}),o&&u({type:"step_complete",workflowId:r,stepKey:o,name:i,ts:Date.now(),durationMs:H,result:j(N,{cause:M}),meta:{origin:"throw",thrown:M}}),a?.(ae,i,I),Q(ae,{origin:"throw",thrown:M})}})()},y.fromResult=(E,S,l)=>{if(typeof E!="string"||E.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" }) })');let c=l.key??E,o=E,i=E,T="error"in l?()=>l.error:l.onError,h=w;return(async()=>{let P=h?performance.now():0;w&&u({type:"step_start",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now()});let M=await S();if(M.ok){let N=performance.now()-P;return u({type:"step_success",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:N}),c&&u({type:"step_complete",workflowId:r,stepKey:c,name:o,ts:Date.now(),durationMs:N,result:Z(M.value)}),M.value}else{let N=T(M.error),H=performance.now()-P,ae=_(N,{origin:"result",resultCause:M.error});throw u({type:"step_error",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:H,error:ae}),c&&u({type:"step_complete",workflowId:r,stepKey:c,name:o,ts:Date.now(),durationMs:H,result:j(N,{cause:M.error}),meta:{origin:"result",resultCause:M.error}}),a?.(ae,o,I),Q(ae,{origin:"result",resultCause:M.error})}})()},y.fromNullable=(E,S,l,c)=>{if(typeof E!="string"||E.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 y(E,async()=>{let o=await S();return o!=null?Z(o):j(l())},c)},y.retry=(E,S,l)=>{if(typeof E!="string"||E.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 y(E,S,{key:l.key??E,retry:{attempts:l.attempts,backoff:l.backoff,initialDelay:l.initialDelay,maxDelay:l.maxDelay,jitter:l.jitter,shouldRetry:l.shouldRetry,onRetry:l.onRetry},timeout:l.timeout})},y.withTimeout=(E,S,l)=>{if(typeof E!="string"||E.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 y(E,S,{key:l.key??E,timeout:l})},y.sleep=(E,S,l)=>{if(typeof E!="string"||E.length===0)throw new Error('[awaitly] step.sleep() requires an explicit string ID as the first argument. Example: step.sleep("delay", "5s")');let c=typeof S=="string"?Wt(S):S;if(!c)throw new Error(`step.sleep: invalid duration '${S}'`);let o=c.millis,i=l?.signal;return y(E,async()=>{if(O?.aborted||i?.aborted){let T=new Error("Sleep aborted");throw T.name="AbortError",T}return new Promise((T,h)=>{let P={timeoutId:void 0},M=()=>{P.timeoutId&&clearTimeout(P.timeoutId);let N=new Error("Sleep aborted");N.name="AbortError",h(N)};O?.addEventListener("abort",M,{once:!0}),i?.addEventListener("abort",M,{once:!0}),P.timeoutId=setTimeout(()=>{O?.removeEventListener("abort",M),i?.removeEventListener("abort",M),T(Z(void 0))},o)})},{key:l?.key??E,description:l?.description})},y.all=((...E)=>{if(typeof E[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() })");let S=E[0],l=E[1];if(typeof l=="function")return me(S,l);if(l&&typeof l=="object"&&!Array.isArray(l)){let o=oe(l);return ue(o,{name:S})}throw new TypeError("step.all(name, ...): second argument must be a function (array form) or an object of operations (object form).")}),y.race=(E,S)=>{let l=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let c=performance.now(),o=!1,i={scopeId:l,type:"race",winnerId:void 0};L.push(i);let T=()=>{if(o)return;o=!0;let h=L.findIndex(P=>P.scopeId===l);h!==-1&&L.splice(h,1),u({type:"scope_end",workflowId:r,scopeId:l,ts:Date.now(),durationMs:performance.now()-c,winnerId:i.winnerId})};u({type:"scope_start",workflowId:r,scopeId:l,scopeType:"race",name:E,ts:Date.now()});try{let h=await S();if(T(),!h.ok)throw a?.(h.error,E,I),Q(h.error,{origin:"result",resultCause:h.cause});return h.value}catch(h){throw T(),h}})()},y.if=(E,S,l)=>l(),y.label=y.if,y.branch=async(E,S)=>{let{condition:l,then:c,else:o}=S;if(l())return await c();if(o)return await o()},y.arm=(E,S)=>({fn:E,errors:S}),y.forEach=async(E,S,l)=>{let c=[],o=l.maxIterations,i=0,T="run"in l,h=Symbol.asyncIterator in S?S:(async function*(){yield*S})();for await(let P of h){if(o!==void 0&&i>=o)break;let M;T?M=await l.run(P,i):M=await l.item.handler(P,i,y),c.push(M),i++}return c},y.item=E=>({__forEachItemHandler:!0,handler:E}),y.dep=(E,S)=>S,y.workflow=(E,S,l)=>y(E,S,l),y.map=async(E,S,l,c)=>{let o=c?.concurrency??S.length;return y(E,()=>o>=S.length?ft(S.map((i,T)=>l(i,T))):(async()=>{let i=[];for(let T=0;T<S.length;T+=o){let h=S.slice(T,T+o),P=await ft(h.map((M,N)=>l(M,T+N)));if(!P.ok)return P;i.push(...P.value)}return Z(i)})(),{key:c?.key})},y.withFallback=(E,S,l)=>{if(typeof E!="string"||E.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) })');let c=l.key??E,o=E,i=ne(c),T=w;return(async()=>{let h=T?performance.now():0;w&&u({type:"step_start",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now()});let P;try{P=await S()}catch(B){if(we(B))throw u({type:"step_aborted",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:performance.now()-h}),B;let G;try{G=q(B)}catch(Y){throw Ae(Y)}if(l.on!==void 0&&l.on!==G){let Y=performance.now()-h;throw u({type:"step_error",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:Y,error:G}),c&&u({type:"step_complete",workflowId:r,stepKey:c,name:o,ts:Date.now(),durationMs:Y,result:j(G,{cause:B}),meta:{origin:"throw",thrown:B}}),a?.(G,o,I),Q(G,{origin:"throw",thrown:B})}let V;try{V=await l.fallback()}catch(Y){if(we(Y))throw u({type:"step_aborted",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:performance.now()-h}),Y;let C;try{C=q(Y)}catch(d){throw Ae(d)}let Re=performance.now()-h;throw u({type:"step_error",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:Re,error:C}),c&&u({type:"step_complete",workflowId:r,stepKey:c,name:o,ts:Date.now(),durationMs:Re,result:j(C,{cause:Y}),meta:{origin:"throw",thrown:Y}}),a?.(C,o,I),Q(C,{origin:"throw",thrown:Y})}if(V.ok){let Y=performance.now()-h;return u({type:"step_success",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:Y}),c&&u({type:"step_complete",workflowId:r,stepKey:c,name:o,ts:Date.now(),durationMs:Y,result:V,meta:{origin:"fallback",fallbackUsed:!0,fallbackReason:String(G)}}),V.value}else{let Y=performance.now()-h,C=_(V.error,{origin:"result",resultCause:V.cause});throw u({type:"step_error",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:Y,error:C}),c&&u({type:"step_complete",workflowId:r,stepKey:c,name:o,ts:Date.now(),durationMs:Y,result:V,meta:{origin:"result",resultCause:V.cause}}),a?.(C,o,I),Q(C,{origin:"result",resultCause:V.cause})}}if(P.ok){let B=performance.now()-h;return u({type:"step_success",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:B}),c&&u({type:"step_complete",workflowId:r,stepKey:c,name:o,ts:Date.now(),durationMs:B,result:P}),P.value}let M=P.error;if(l.on!==void 0&&l.on!==M){let B=performance.now()-h,G=_(M,{origin:"result",resultCause:P.cause});throw u({type:"step_error",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:B,error:G}),c&&u({type:"step_complete",workflowId:r,stepKey:c,name:o,ts:Date.now(),durationMs:B,result:P,meta:{origin:"result",resultCause:P.cause}}),a?.(G,o,I),Q(G,{origin:"result",resultCause:P.cause})}let N;try{N=await l.fallback()}catch(B){if(we(B))throw u({type:"step_aborted",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:performance.now()-h}),B;let G;try{G=q(B)}catch(Y){throw Ae(Y)}let V=performance.now()-h;throw u({type:"step_error",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:V,error:G}),c&&u({type:"step_complete",workflowId:r,stepKey:c,name:o,ts:Date.now(),durationMs:V,result:j(G,{cause:B}),meta:{origin:"throw",thrown:B}}),a?.(G,o,I),Q(G,{origin:"throw",thrown:B})}if(N.ok){let B=performance.now()-h;return u({type:"step_success",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:B}),c&&u({type:"step_complete",workflowId:r,stepKey:c,name:o,ts:Date.now(),durationMs:B,result:N,meta:{origin:"fallback",fallbackUsed:!0,fallbackReason:String(M)}}),N.value}let H=performance.now()-h,ae=_(N.error,{origin:"result",resultCause:N.cause});throw u({type:"step_error",workflowId:r,stepId:i,stepKey:c,name:o,ts:Date.now(),durationMs:H,error:ae}),c&&u({type:"step_complete",workflowId:r,stepKey:c,name:o,ts:Date.now(),durationMs:H,result:N,meta:{origin:"result",resultCause:N.cause}}),a?.(ae,o,I),Q(ae,{origin:"result",resultCause:N.cause})})()},y.withResource=(E,S)=>{if(typeof E!="string"||E.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() })');let l=E,c=E,o=ne(l),i=w;return(async()=>{let T=i?performance.now():0;w&&u({type:"step_start",workflowId:r,stepId:o,stepKey:l,name:c,ts:Date.now()});let h;try{h=await S.acquire()}catch(V){if(we(V))throw u({type:"step_aborted",workflowId:r,stepId:o,stepKey:l,name:c,ts:Date.now(),durationMs:performance.now()-T}),V;let Y;try{Y=q(V)}catch(Re){throw Ae(Re)}let C=performance.now()-T;throw u({type:"step_error",workflowId:r,stepId:o,stepKey:l,name:c,ts:Date.now(),durationMs:C,error:Y}),l&&u({type:"step_complete",workflowId:r,stepKey:l,name:c,ts:Date.now(),durationMs:C,result:j(Y,{cause:V}),meta:{origin:"throw",thrown:V}}),a?.(Y,c,I),Q(Y,{origin:"throw",thrown:V})}if(!h.ok){let V=performance.now()-T,Y=_(h.error,{origin:"result",resultCause:h.cause});throw u({type:"step_error",workflowId:r,stepId:o,stepKey:l,name:c,ts:Date.now(),durationMs:V,error:Y}),l&&u({type:"step_complete",workflowId:r,stepKey:l,name:c,ts:Date.now(),durationMs:V,result:h,meta:{origin:"result",resultCause:h.cause}}),a?.(Y,c,I),Q(Y,{origin:"result",resultCause:h.cause})}let P=h.value,M,N,H=!1;try{M=await S.use(P)}catch(V){if(we(V)){try{await S.release(P)}catch(Y){console.warn(`[awaitly] step.withResource("${E}"): release threw after earlyExit:`,Y)}throw V}N=V,H=!0}try{await S.release(P)}catch(V){console.warn(`[awaitly] step.withResource("${E}"): release threw:`,V)}if(H){let V;try{V=q(N)}catch(C){throw Ae(C)}let Y=performance.now()-T;throw u({type:"step_error",workflowId:r,stepId:o,stepKey:l,name:c,ts:Date.now(),durationMs:Y,error:V}),l&&u({type:"step_complete",workflowId:r,stepKey:l,name:c,ts:Date.now(),durationMs:Y,result:j(V,{cause:N}),meta:{origin:"throw",thrown:N}}),a?.(V,c,I),Q(V,{origin:"throw",thrown:N})}let ae=M;if(ae.ok){let V=performance.now()-T;return u({type:"step_success",workflowId:r,stepId:o,stepKey:l,name:c,ts:Date.now(),durationMs:V}),l&&u({type:"step_complete",workflowId:r,stepKey:l,name:c,ts:Date.now(),durationMs:V,result:ae}),ae.value}let B=performance.now()-T,G=_(ae.error,{origin:"result",resultCause:ae.cause});throw u({type:"step_error",workflowId:r,stepId:o,stepKey:l,name:c,ts:Date.now(),durationMs:B,error:G}),l&&u({type:"step_complete",workflowId:r,stepKey:l,name:c,ts:Date.now(),durationMs:B,result:ae,meta:{origin:"result",resultCause:ae.cause}}),a?.(G,c,I),Q(G,{origin:"result",resultCause:ae.cause})})()};let F=await m({step:y});if(process.env.NODE_ENV!=="production"&&F!==null&&typeof F=="object"&&"ok"in F&&typeof F.ok=="boolean"){let E=F;(E.ok===!0&&"value"in E||E.ok===!1&&"error"in E)&&console.warn(`awaitly: Workflow executor returned a Result-like object. Return raw values, not ok() or err().
+// 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 slugDocsUrl(slug) {
+  return `https://jagreehal.github.io/awaitly/rules/#${slug}`;
+}
+var ALL_SLUGS = Object.keys(
+  AWAITLY_SLUGS
+);
+
+// src/tagged-error.ts
+var InternalTaggedErrorBase = class extends Error {
+  type;
+  /** @deprecated Use `type`. */
+  _tag;
+};
+function TaggedError(tag, options) {
+  return class extends InternalTaggedErrorBase {
+    type = tag;
+    /** @deprecated Use `type`. */
+    _tag = tag;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(props, errorOptions) {
+      const message = options?.message ? options.message(props ?? {}) : tag;
+      super(message);
+      this.name = tag;
+      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 match(error, handlers) {
+    const tag = error._tag;
+    const handler = handlers[tag];
+    return handler(
+      error
+    );
+  }
+  TaggedError2.match = match;
+  function matchPartial(error, handlers, otherwise) {
+    const tag = error._tag;
+    const handler = handlers[tag];
+    if (handler) {
+      return handler(
+        error
+      );
+    }
+    return otherwise(error);
+  }
+  TaggedError2.matchPartial = matchPartial;
+})(TaggedError || (TaggedError = {}));
+
+// src/errors.ts
+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")}`
+})) {
+};
+
+// src/result/index.ts
+function ok(value) {
+  return { ok: true, value };
+}
+
+// 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/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 };
+}
+function toMillis(duration) {
+  return duration.millis;
+}
+function parse(input) {
+  const match = input.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i);
+  if (!match) return void 0;
+  const value = parseFloat(match[1]);
+  const unit = match[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;
+  }
+}
+
+// src/core/index.ts
+function parseDurationString(input) {
+  const match = input.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i);
+  if (!match) return void 0;
+  const value = parseFloat(match[1]);
+  const unit = match[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 err(error, options) {
+  const cause = options?.cause;
+  return { ok: false, error, ...cause !== void 0 ? { cause } : {} };
+}
+var isOk = (r) => r.ok;
+var isUnexpectedError = (e) => e instanceof UnexpectedError || typeof e === "object" && e !== null && "_tag" in e && e._tag === "UnexpectedError";
+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(tag, errorMeta) {
+  if (!errorMeta || !tag) return void 0;
+  return errorMeta[tag];
+}
+function extractStepMetadata(options) {
+  const { intent, domain, owner, tags, stateChanges, emits, calls } = options;
+  if (!intent && !domain && !owner && !tags?.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 (tags?.length) metadata.tags = tags;
+  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 tag = extractErrorTag(error);
+  const classification = lookupErrorClassification(tag, errorMeta);
+  const diagnostics = { tag, 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 err2 = e;
+    return {
+      timeoutMs: err2.timeoutMs,
+      stepName: err2.stepName,
+      stepKey: err2.stepKey,
+      attempt: err2.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 sleep(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) => err(
+                { 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, stepOptions) => {
+      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 = stepOptions ?? {};
+        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 sleep(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 sleep(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: err(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 sleep(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: err(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 err(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: err(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: err(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) : err(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 allAsync(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 allAsync(
+                  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: err(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: err(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: err(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: err(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: err(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 Z(F)}catch(y){if(Ft(y))throw y.thrown;if(we(y)){let me=y.meta.origin==="throw"?y.meta.thrown:y.meta.origin==="result"?y.meta.resultCause:void 0;return j(y.error,{cause:me})}let oe=q(y);return a?.(oe,"unexpected",I),j(oe,{cause:y})}}je.strict=(e,t)=>je(e,t);async function ft(e){return e.length===0?Z([]):new Promise(t=>{let n=!1,m=e.length,s=new Array(e.length);for(let a=0;a<e.length;a++){let w=a;Promise.resolve(e[w]).catch(v=>j({type:"PROMISE_REJECTED",cause:v},{cause:{type:"PROMISE_REJECTION",reason:v}})).then(v=>{if(!n){if(!v.ok){n=!0,t(v);return}s[w]=v.value,m--,m===0&&t(Z(s))}})}})}function Tt(e){return e.type==="step_complete"}function ze(e){return typeof e=="object"&&e!==null&&e.type==="WORKFLOW_CANCELLED"}var Be=class extends Error{constructor(n,m,s){super(n);this.stepId=m;this.originalError=s;this.name="SnapshotDecodeError"}stepId;originalError};function Ye(e){if(e.type==="error"){let t=new Error(e.message);return t.name=e.name,e.stack&&(t.stack=e.stack),e.cause&&(t.cause=Ye(e.cause)),t}return e.value!==void 0?e.value:e.stringRepresentation}function Vt(e){return typeof e=="object"&&e!==null&&e.__cachedMeta===!0}function be(e,t,n){return j(e,{cause:{__cachedMeta:!0,originalCause:n,meta:t}})}function Ke(e){return Vt(e)?e.meta:{origin:"result",resultCause:e}}function Rt(){let e=new Map;return{handleEvent:t=>{Tt(t)&&e.set(t.stepKey,{result:t.result,meta:t.meta})},getResumeState:()=>({steps:new Map(e)}),clear:()=>e.clear()}}var Lt="STREAM_WRITE_ERROR",Ht="STREAM_READ_ERROR",Jt="STREAM_CLOSE_ERROR";var qt="STREAM_ENDED";function Ve(e,t,n){return{type:Lt,reason:e,message:t,...n!==void 0?{cause:n}:{}}}function Ge(e,t,n){return{type:Ht,reason:e,message:t,...n!==void 0?{cause:n}:{}}}function Xe(e,t,n){return{type:Jt,reason:e,message:t,...n!==void 0?{cause:n}:{}}}function Le(e){return{type:qt,finalPosition:e}}function xt(e={}){let t=e.highWaterMark??16,n=e.lowWaterMark??Math.floor(t/2),m=e.onStateChange,s="flowing",a=0,w=[];function v(K){if(s!==K&&(s=K,m?.(K),K==="flowing"&&w.length>0)){let I=w;w=[];for(let O of I)O()}}function W(){s==="flowing"&&a>=t?v("paused"):s==="paused"&&a<=n&&v("flowing")}return{get state(){return s},get bufferedCount(){return a},get highWaterMark(){return t},get lowWaterMark(){return n},increment(){a++,W()},decrement(){a>0&&(a--,W())},setCount(K){a=Math.max(0,K),W()},waitForDrain(){return s==="flowing"?Promise.resolve():new Promise(K=>{w.push(K)})},reset(){a=0,w=[],v("flowing")}}}function zt(e){return{_tag:"Duration",millis:e}}function Yt(e){return{_tag:"Duration",millis:e*1e3}}function Gt(e){return{_tag:"Duration",millis:e*60*1e3}}function Xt(e){return{_tag:"Duration",millis:e*60*60*1e3}}function Zt(e){return{_tag:"Duration",millis:e*24*60*60*1e3}}function St(e){return e.millis}function ht(e){let t=e.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i);if(!t)return;let n=parseFloat(t[1]);switch(t[2].toLowerCase()){case"ms":return zt(n);case"s":return Yt(n);case"m":return Gt(n);case"h":return Xt(n);case"d":return Zt(n);default:return}}async function Ct(e,t){let n=e["~standard"].validate(t),m=n instanceof Promise?await n:n;return m.issues?j({type:"INPUT_VALIDATION_ERROR",issues:m.issues.map(s=>({message:s.message,path:s.path?.map(a=>typeof a=="object"?a.key:a)})),message:`Input validation failed: ${m.issues.map(s=>s.message).join(", ")}`}):Z(m.value)}function Ze(e,t){let n=m=>((...s)=>{let a=s.at(-1),w=s.length>0&&typeof a=="object"&&a!==null&&!Array.isArray(a)&&typeof a!="function",v=w?a:void 0,W=w?s.slice(0,-1):s,K={...t,...v?.deps??{}},I=v?{...v,deps:K}:{deps:K};return e[m](...W,I)});return{run:n("run"),runWithState:n("runWithState"),withDeps(m){return Ze(e,{...t,...m})}}}function Qe(e,t,n){if(typeof e!="string"||e.length===0)throw new TypeError("createWorkflow(workflowName, deps, options?): first argument must be a non-empty string. Example: createWorkflow('checkout', { chargeCard, sendEmail })");let m=t??{},s=n;async function a(K,I,O){let r=K??crypto.randomUUID(),q=O?.deps?{...m,...O.deps}:m,L=[],de=O?.createContext??s?.createContext,ne=de?await de():void 0,u=O?.signal??s?.signal,Q=O?.onEvent??s?.onEvent,we=O?.onError??s?.onError,_=O?.shouldRun??s?.shouldRun,z=O?.onBeforeStart??s?.onBeforeStart,ee=O?.onAfterStep??s?.onAfterStep,pe=O?.resumeState??s?.resumeState,ye=s?.catchUnexpected??$e,y={},oe=(O?.devWarnings??s?.devWarnings)===!0&&process.env.NODE_ENV!=="production",me=new Set,ue=new Set,ce={workflowId:r,onEvent:Q,context:ne!==void 0?ne:void 0,signal:u,input:{},ref:d=>y[d],set:(d,f)=>{oe&&!me.has(d)&&(me.add(d),console.warn(`awaitly: ctx.set('${d}', ...) is deprecated for static analysis. Use step('id', fn, { out: '${d}' }) instead.`)),y[d]=f},get:d=>(oe&&!ue.has(d)&&(ue.add(d),console.warn(`awaitly: ctx.get('${d}') is deprecated for static analysis. Use ctx.ref('${d}') instead for tracked dependencies.`)),y[d])},F=d=>{let f=d.context!==void 0||ne===void 0?d:{...d,context:ne},X=f.workflowName===void 0?{...f,workflowName:e}:f;Q?.(X,ne)},E=(d,f)=>{let X={type:"WORKFLOW_CANCELLED",reason:d,lastStepKey:f};return j(ye(X),{cause:X})};if(u?.aborted){let d=typeof u.reason=="string"?u.reason:u.reason instanceof Error?u.reason.message:void 0;return F({type:"workflow_cancelled",workflowId:r,ts:Date.now(),durationMs:0,reason:d}),E(d)}if(_){let d=performance.now();try{let f=await _(r,ne),X=performance.now()-d;if(F({type:"hook_should_run",workflowId:r,ts:Date.now(),durationMs:X,result:f,skipped:!f}),!f){let x=new Error("Workflow skipped by shouldRun hook");return j(ye(x),{cause:x})}}catch(f){let X=performance.now()-d;return F({type:"hook_should_run_error",workflowId:r,ts:Date.now(),durationMs:X,error:f}),j(ye(f),{cause:f})}}if(z){let d=performance.now();try{let f=await z(r,ne),X=performance.now()-d;if(F({type:"hook_before_start",workflowId:r,ts:Date.now(),durationMs:X,result:f,skipped:!f}),!f){let x=new Error("Workflow skipped by onBeforeStart hook");return j(ye(x),{cause:x})}}catch(f){let X=performance.now()-d;return F({type:"hook_before_start_error",workflowId:r,ts:Date.now(),durationMs:X,error:f}),j(ye(f),{cause:f})}}let S=s?.inputSchema,l=s?.input;if(S){let d=await Ct(S,l);if(!d.ok)return j(d.error);ce.input=d.value}else l!==void 0&&(ce.input=l);let c=Date.now(),o=performance.now();F({type:"workflow_start",workflowId:r,ts:c});let i=O?.cache??s?.cache,T=O?.streamStore??s?.streamStore;if(pe&&!i&&(i=new Map),pe&&i){let d=typeof pe=="function"?await pe():pe;d.steps instanceof Map||(console.warn(`awaitly: resumeState.steps is not a Map (got ${typeof d.steps}). This usually happens when state is serialized with JSON.stringify() directly.
-Use stringifyState() and parseState() from 'awaitly/persistence' instead:
-  import { stringifyState, parseState } from 'awaitly/persistence';
-  const json = stringifyState(state);  // Save this
-  const restored = parseState(json);   // Load this`),typeof d.steps=="object"&&d.steps!==null&&(d.steps=new Map(Object.entries(d.steps))));for(let[f,X]of d.steps){let{result:x,meta:g}=X;if(x.ok)i.set(f,x);else{let p=g??{origin:"result",resultCause:x.cause};i.set(f,be(x.error,p,x.cause))}}}let h=O?.snapshot??s?.snapshot,P=s?.serialization;if(h&&!pe){i||(i=new Map);let d=h,f=P?.decode;for(let[X,x]of Object.entries(d.steps))if(Object.prototype.hasOwnProperty.call(d.steps,X))try{if(x.ok){let g=f?f(x.value):x.value;i.set(X,Z(g))}else{let g=f?f(x.error):x.error,p=Ye(x.cause),R=x.meta?.origin==="throw"?{origin:"throw",thrown:p}:{origin:"result",resultCause:p};i.set(X,be(g,R,p))}}catch(g){throw new Be(`Failed to decode step "${X}": ${g instanceof Error?g.message:String(g)}`,X,g instanceof Error?g:void 0)}}let M=!1,N,H,ae=()=>{M=!0,N=typeof u?.reason=="string"?u.reason:u?.reason instanceof Error?u.reason.message:void 0};u&&!u.aborted&&u.addEventListener("abort",ae,{once:!0});let B=()=>{if(M||u?.aborted)throw{type:"WORKFLOW_CANCELLED",reason:N??(typeof u?.reason=="string"?u.reason:u?.reason instanceof Error?u.reason.message:void 0),lastStepKey:H}},G=async(d,f,X)=>{if(!ee)return;let x=performance.now();try{await ee(d,f,r,ne);let g=performance.now()-x;F({type:"hook_after_step",workflowId:r,stepKey:d,ts:Date.now(),durationMs:g})}catch(g){let p=performance.now()-x;throw F({type:"hook_after_step_error",workflowId:r,stepKey:d,ts:Date.now(),durationMs:p,error:g}),g}},V=d=>{let f=async(g,p,R)=>{if(typeof g!="string")throw new Error('[awaitly] step() requires a string ID as the first argument. Example: step("fetchUser", () => fetchUser(id))');let A=g,b=R??{},D=A,k=Object.prototype.hasOwnProperty.call(b,"key")?b.key:A,{ttl:$,out:te}=b;B();let se=qe(b);if(k&&i&&i.has(k)){F({type:"step_cache_hit",workflowId:r,stepKey:k,name:D,ts:Date.now(),...se&&{metadata:se}});let U=i.get(k);if(U.ok)return H=k,te&&(y[te]=U.value),U.value;let J=Ke(U.cause);throw De(U.error,J)}k&&i&&F({type:"step_cache_miss",workflowId:r,stepKey:k,name:D,ts:Date.now(),...se&&{metadata:se}});try{let U=await d(A,p,b);return te&&(y[te]=U),b.compensate&&L.push({stepName:D,value:U,compensate:b.compensate}),k&&(H=k,i&&i.set(k,Z(U),$?{ttl:$}:void 0),await G(k,Z(U))),U}catch(U){if(k&&ve(U)){let J=U,Ee=J.meta.origin==="result"?J.meta.resultCause:J.meta.origin==="throw"?J.meta.thrown:void 0,re=be(J.error,J.meta,Ee);i&&i.set(k,re,$?{ttl:$}:void 0),await G(k,re,J.meta)}throw U}};f.try=async(g,p,R)=>{let{ttl:A}=R,b=R.key??g,D=g;if(i&&i.has(b)){F({type:"step_cache_hit",workflowId:r,stepKey:b,name:D,ts:Date.now()});let k=i.get(b);if(k.ok)return k.value;let $=Ke(k.cause);throw De(k.error,$)}i&&F({type:"step_cache_miss",workflowId:r,stepKey:b,name:D,ts:Date.now()});try{let k=await d.try(g,p,{...R,key:b});return R.compensate&&L.push({stepName:D,value:k,compensate:R.compensate}),i&&i.set(b,Z(k),A?{ttl:A}:void 0),await G(b,Z(k)),k}catch(k){if(ve(k)){let $=k,te=$.meta.origin==="result"?$.meta.resultCause:$.meta.origin==="throw"?$.meta.thrown:void 0,se=be($.error,$.meta,te);i&&i.set(b,se,A?{ttl:A}:void 0),await G(b,se,$.meta)}throw k}},f.fromResult=async(g,p,R)=>{let{ttl:A}=R,b=R.key??g,D=g;if(i&&i.has(b)){F({type:"step_cache_hit",workflowId:r,stepKey:b,name:D,ts:Date.now()});let k=i.get(b);if(k.ok)return k.value;let $=Ke(k.cause);throw De(k.error,$)}i&&F({type:"step_cache_miss",workflowId:r,stepKey:b,name:D,ts:Date.now()});try{let k=await d.fromResult(g,p,{...R,key:b});return i&&i.set(b,Z(k),A?{ttl:A}:void 0),await G(b,Z(k)),k}catch(k){if(ve(k)){let $=k,te=$.meta.origin==="result"?$.meta.resultCause:$.meta.origin==="throw"?$.meta.thrown:void 0,se=be($.error,$.meta,te);i&&i.set(b,se,A?{ttl:A}:void 0),await G(b,se,$.meta)}throw k}},f.race=d.race,f.withFallback=async(g,p,R)=>{let A=R.key??g,b=g;if(i&&i.has(A)){F({type:"step_cache_hit",workflowId:r,stepKey:A,name:b,ts:Date.now()});let D=i.get(A);if(D.ok)return D.value;let k=Ke(D.cause);throw De(D.error,k)}i&&F({type:"step_cache_miss",workflowId:r,stepKey:A,name:b,ts:Date.now()});try{let D=await d.withFallback(g,p,R);return i&&i.set(A,Z(D)),await G(A,Z(D)),D}catch(D){if(ve(D)){let k=D,$=k.meta.origin==="result"?k.meta.resultCause:k.meta.origin==="throw"?k.meta.thrown:void 0,te=be(k.error,k.meta,$);i&&i.set(A,te),await G(A,te,k.meta)}throw D}},f.withResource=async(g,p)=>{let R=g;try{let A=await d.withResource(g,p);return await G(R,Z(A)),A}catch(A){if(ve(A)){let b=A,D=b.meta.origin==="result"?b.meta.resultCause:b.meta.origin==="throw"?b.meta.thrown:void 0,k=be(b.error,b.meta,D);await G(R,k,b.meta)}throw A}},f.retry=(g,p,R)=>{let A={key:R.key,retry:{attempts:R.attempts,backoff:R.backoff,initialDelay:R.initialDelay,maxDelay:R.maxDelay,jitter:R.jitter,shouldRetry:R.shouldRetry,onRetry:R.onRetry},timeout:R.timeout,ttl:R.ttl};return f(g,p,A)},f.withTimeout=(g,p,R)=>{let A={key:R.key,timeout:R,ttl:R.ttl};return f(g,p,A)},f.sleep=(g,p,R)=>{if(typeof g!="string"||g.length===0)throw new Error('[awaitly] step.sleep() requires an explicit string ID as the first argument. Example: step.sleep("delay", "5s")');let A=typeof p=="string"?ht(p):p;if(!A)throw new Error(`step.sleep: invalid duration '${p}'`);let b=St(A),D=R?.signal;return f(g,async()=>{if(u?.aborted||D?.aborted){let $=new Error("Sleep aborted");throw $.name="AbortError",$}return new Promise(($,te)=>{let se={timeoutId:void 0},U=()=>{se.timeoutId&&clearTimeout(se.timeoutId);let J=new Error("Sleep aborted");J.name="AbortError",te(J)};u?.addEventListener("abort",U,{once:!0}),D?.addEventListener("abort",U,{once:!0}),se.timeoutId=setTimeout(()=>{u?.removeEventListener("abort",U),D?.removeEventListener("abort",U),$(Z(void 0))},b)})},{key:R?.key,ttl:R?.ttl,description:R?.description})};let X=new Map,x=new Map;return f.getWritable=g=>{let p=g?.namespace??"default",R=g?.highWaterMark??16;if(!T)throw new Error("streamStore is required to use getWritable(). Pass a streamStore to createWorkflow options.");let A=`${r}:${p}`,b=X.get(A);if(b&&!b.closed&&!b.aborted)return b.writer;let D=xt({highWaterMark:R,onStateChange:J=>{F({type:"stream_backpressure",workflowId:r,namespace:p,bufferedCount:D.bufferedCount,state:J,ts:Date.now()})}}),k=0,$=!0,te=!1,se=!1;F({type:"stream_created",workflowId:r,namespace:p,ts:Date.now()});let U={async write(J){if(se)return j(Ve("closed","Stream is closed"));if(te)return j(Ve("aborted","Stream was aborted"));D.state==="paused"&&await D.waitForDrain();let Ee={value:J,position:k,ts:Date.now()},re=await T.append(r,p,Ee);return re.ok?(F({type:"stream_write",workflowId:r,namespace:p,position:k,ts:Date.now()}),k++,D.increment(),Z(void 0)):(F({type:"stream_error",workflowId:r,namespace:p,error:re.error,position:k,ts:Date.now()}),j(Ve("store_error",re.error.message,re.error)))},async close(){if(se)return j(Xe("already_closed","Stream is already closed"));let J=await T.closeStream(r,p);return J.ok?(se=!0,$=!1,F({type:"stream_close",workflowId:r,namespace:p,finalPosition:k,ts:Date.now()}),X.delete(A),Z(void 0)):j(Xe("store_error",J.error.message,J.error))},abort(J){te=!0,$=!1,se=!0,F({type:"stream_error",workflowId:r,namespace:p,error:J,position:k,ts:Date.now()}),X.delete(A)},get writable(){return $},get position(){return k},get namespace(){return p}};return X.set(A,{writer:U,backpressure:D,aborted:te,closed:se}),U},f.getReadable=g=>{let p=g?.namespace??"default",R=g?.startIndex??0,A=g?.pollInterval??10,b=g?.pollTimeout??3e4;if(!T)throw new Error("streamStore is required to use getReadable(). Pass a streamStore to createWorkflow options.");let D=`${r}:${p}:${R}`,k=x.get(D);if(k&&!k.closed)return k.reader;let $=()=>{let Se=`${r}:${p}`,le=X.get(Se);le&&le.backpressure.decrement()},te=R,se=!0,U=!1,J=[],Ee=0,re={async read(){if(U)return j(Ge("closed","Reader is closed"));if(Ee<J.length){let ge=J[Ee++];return te=ge.position+1,$(),F({type:"stream_read",workflowId:r,namespace:p,position:ge.position,ts:Date.now()}),Z(ge.value)}let Se=`${r}:${p}`,le=Date.now(),ke=X.has(Se),ie=await T.getMetadata(r,p),fe=ie.ok&&ie.value!==void 0;for(;Date.now()-le<b;){let ge=await T.read(r,p,te,100);if(!ge.ok)return j(Ge("store_error",ge.error.message,ge.error));let Me=ge.value;if(Me.length>0){J=Me,Ee=1;let Ue=Me[0];return te=Ue.position+1,$(),F({type:"stream_read",workflowId:r,namespace:p,position:Ue.position,ts:Date.now()}),Z(Ue.value)}let Ie=X.has(Se),Ce=await T.getMetadata(r,p),tt=Ce.ok&&Ce.value!==void 0;if(Ie&&(ke=!0),tt&&(fe=!0),Ce.ok&&Ce.value?.closed)return se=!1,j(Le(te));if(ke&&!Ie&&!tt)return se=!1,j(Le(te));fe&&!Ie&&Ce.ok&&Ce.value?.closed,await new Promise(Ue=>setTimeout(Ue,A))}return se=!1,j(Le(te))},close(){U=!0,se=!1,J=[],x.delete(D)},get readable(){return se},get position(){return te},get namespace(){return p}};return x.set(D,{reader:re,position:te,closed:U}),re},f.streamForEach=async(g,p,R)=>{let A=R?.checkpointInterval??1,b=R?.concurrency??1,D=[],k=0,$=-1,te=U=>typeof U=="object"&&U!==null&&"read"in U&&typeof U.read=="function",se=async(U,J,Ee,re)=>{let le=A>0&&J%A===0?`stream-foreach:${re}:pos-${Ee}`:void 0,ke=le??`stream-item-${Ee}`,ie=await f(ke,()=>p(U,J),{key:le});return{index:J,position:Ee,result:ie}};if(te(g))if(b<=1){let U=g.position,J=await g.read();for(;J.ok;){let Ee=J.value,{result:re}=await se(Ee,k,U,g.namespace);D.push(re),$=U,k++,U=g.position,J=await g.read()}}else{let U=new Map,J=0,Ee=0,re=new Array(b).fill(null),Se=async()=>{for(let ge=0;ge<re.length;ge++)if(re[ge]===null)return ge;let ie=re.filter(ge=>ge!==null),fe=await Promise.race(ie);return U.set(fe.index,{position:fe.position,result:fe.result}),re[fe.slotIndex]=null,fe.slotIndex},le=g.position,ke=await g.read();for(;ke.ok;){let ie=await Se(),fe=J,ge=le,Me=ke.value,Ie=ie;re[ie]=se(Me,fe,ge,g.namespace).then(Ce=>({slotIndex:Ie,...Ce})),Ee++,J++,le=g.position,ke=await g.read()}for(let ie=0;ie<re.length;ie++)if(re[ie]!==null){let fe=await re[ie];U.set(fe.index,{position:fe.position,result:fe.result})}for(let ie=0;ie<Ee;ie++){let fe=U.get(ie);fe&&(D.push(fe.result),$=fe.position,k++)}}else if(b<=1){let U=0;for await(let J of g){let{result:Ee}=await se(J,U,U,"async-iterable");D.push(Ee),$=U,k++,U++}}else{let U=new Map,J=0,Ee=0,re=new Array(b).fill(null),Se=async()=>{for(let ie=0;ie<re.length;ie++)if(re[ie]===null)return ie;let le=re.filter(ie=>ie!==null),ke=await Promise.race(le);return U.set(ke.index,ke.result),re[ke.slotIndex]=null,ke.slotIndex};for await(let le of g){let ke=await Se(),ie=J,fe=ke;re[ke]=se(le,ie,ie,"async-iterable").then(ge=>({slotIndex:fe,...ge})),Ee++,J++}for(let le=0;le<re.length;le++)if(re[le]!==null){let ke=await re[le];U.set(ke.index,ke.result)}for(let le=0;le<Ee;le++)U.has(le)&&(D.push(U.get(le)),$=le,k++)}return{results:D,processedCount:k,lastPosition:$}},f.if=d.if,f.label=d.label,f.branch=d.branch,f.arm=d.arm,f.forEach=d.forEach,f.item=d.item,f.dep=d.dep,f.workflow=(g,p,R)=>f(g,p,R),f.all=(g,p,R)=>{let A=R!==void 0&&Object.prototype.hasOwnProperty.call(R,"key")?R:{...R,key:void 0};return f(g,async()=>Z(await d.all(g,p)),A)},f.map=(g,p,R,A)=>{let b=A!==void 0&&Object.prototype.hasOwnProperty.call(A,"key")?A:{...A,key:void 0};return f(g,async()=>Z(await d.map(g,p,R,A)),b)},f},Y=({step:d})=>{let f=V(d);return I({step:f,steps:Ne(q??{},f),deps:q,ctx:ce})},C;try{C=await je(Y,{onError:we,onEvent:Q,catchUnexpected:ye,workflowId:r,workflowName:e,context:ne,_workflowSignal:u})}finally{u&&u.removeEventListener("abort",ae)}if(!C.ok&&L.length>0){let d=[];for(let f=L.length-1;f>=0;f--){let X=L[f];try{await X.compensate(X.value)}catch(x){d.push({stepName:X.stepName,error:x})}}if(d.length>0){let f={type:"SAGA_COMPENSATION_ERROR",originalError:C.error,compensationErrors:d};C=j(f,{cause:C.cause})}}let Re=performance.now()-o;if(!C.ok){let d;if(ze(C.cause)&&(d=C.cause),!d&&M&&yt(C.error)){let f=C.cause;f!=null&&typeof f=="object"&&"name"in f&&f.name==="AbortError"&&(d={type:"WORKFLOW_CANCELLED",reason:N??(typeof u?.reason=="string"?u.reason:u?.reason instanceof Error?u.reason.message:void 0),lastStepKey:H})}if(d)return F({type:"workflow_cancelled",workflowId:r,ts:Date.now(),durationMs:Re,reason:d.reason,lastStepKey:d.lastStepKey}),d&&!ze(C.cause)?j(C.error,{cause:d}):C}if(C.ok&&M){let d=N??(typeof u?.reason=="string"?u.reason:u?.reason instanceof Error?u.reason.message:void 0);F({type:"workflow_cancelled",workflowId:r,ts:Date.now(),durationMs:Re,reason:d,lastStepKey:H});let f={type:"WORKFLOW_CANCELLED",reason:d,lastStepKey:H};return j(ye(f),{cause:f})}return C.ok?F({type:"workflow_success",workflowId:r,ts:Date.now(),durationMs:Re}):F({type:"workflow_error",workflowId:r,ts:Date.now(),durationMs:Re,error:C.error}),C}function w(K,I,O){let r,q,L;return typeof K=="string"?(r=K,q=I,L=O):(q=K,L=I),a(r,q,L)}async function v(K,I,O){let r,q,L;typeof K=="string"?(r=K,q=I,L=O):(q=K,L=I);let de=Rt(),ne=L?.onEvent,Q={...L,onEvent:(z,ee)=>{de.handleEvent(z);try{ne?.(z,ee)}catch{}}},we,_;try{we=await a(r,q,Q)}catch(z){let ee=s?.catchUnexpected??$e;we=j(ee(z),{cause:z})}finally{_=de.getResumeState()}return{result:we,resumeState:_}}let W={withDeps:K=>Ze(W,K),run:w,runWithState:v};return W}async function bt(e,t,n){let m=[],s={},a=[],w=O=>{if(m.push(O),O.type==="step_complete"&&O.stepKey){let r={output:O.result.ok?O.result.value:void 0,durationMs:O.durationMs,result:O.result};s[O.stepKey]=r,a.push(O.stepKey)}},v=Qe("test-workflow",e),W=performance.now(),K=await v.run(t,{onEvent:w,signal:n?.signal}),I=performance.now()-W;return{result:K,steps:s,events:m,durationMs:I,stepOrder:a}}function et(e){return typeof e=="object"&&e!==null&&"__earlyExit"in e&&e.__earlyExit===!0}function vt(e,t={}){let{recordInvocations:n=!0,clock:m=Date.now}=t,s=[],a=new Map,w=0,v=[];function W(_){s=[..._],w=0,a.clear()}function K(_,z){a.set(_,z)}function I(_){if(_&&a.has(_))return a.get(_);if(w<s.length)return s[w++]}function O(){let _=async(z,ee,pe)=>{let ye,y,oe;typeof z=="string"?(ye=z,y=ee,oe=pe??{}):(y=z,typeof ee=="string"?(ye=ee,oe={}):(oe=ee??{},ye=oe.key??"step"));let me=m(),ue={name:ye,key:oe.key,order:v.length,timestamp:me};n&&v.push(ue);let ce=I(ye);if(ce)switch(ue.durationMs=m()-me,ce.type){case"ok":return ue.result=Z(ce.value),ce.value;case"err":throw ue.result=j(ce.error),{__earlyExit:!0,error:ce.error};case"throw":throw ce.error}let F=typeof y=="function"?await y():await y;if(ue.durationMs=m()-me,ue.result=F,!F.ok)throw{__earlyExit:!0,error:F.error};return F.value};return _.try=async(z,ee,pe)=>{let ye,y,oe;typeof z=="string"?(ye=z,y=ee,oe=pe):(y=z,oe=ee,ye=oe.key??"step");let me=m(),ue={name:ye,key:"key"in oe?oe.key:void 0,order:v.length,timestamp:me};n&&v.push(ue);let ce=I(ye);if(ce)switch(ue.durationMs=m()-me,ce.type){case"ok":return ue.result=Z(ce.value),ce.value;case"err":throw ue.result=j(ce.error),{__earlyExit:!0,error:ce.error};case"throw":throw ce.error}try{let F=await y();return ue.durationMs=m()-me,ue.result=Z(F),F}catch(F){ue.durationMs=m()-me;let E="error"in oe?oe.error:oe.onError(F);throw ue.result=j(E),{__earlyExit:!0,error:E}}},_}async function r(_){let z=O();try{let ee=await _({step:z,deps:e});return Z(ee)}catch(ee){return et(ee)?j(ee.error):j(new he({cause:ee}))}}async function q(_,z){let ee=O();try{let pe=await z({step:ee,deps:e,input:_});return Z(pe)}catch(pe){return et(pe)?j(pe.error):j(new he({cause:pe}))}}function L(){return[...v]}function de(_){let z=v.map(pe=>pe.name??pe.key??"unnamed").filter(pe=>pe!=="unnamed"),ee=JSON.stringify(z)===JSON.stringify(_);return{passed:ee,message:ee?`Steps invoked in order: ${_.join(", ")}`:`Expected steps [${_.join(", ")}] but got [${z.join(", ")}]`,expected:_,actual:z}}function ne(_){let z=v.some(ee=>ee.name===_||ee.key===_);return{passed:z,message:z?`Step "${_}" was invoked`:`Step "${_}" was NOT invoked`,expected:_,actual:z}}function u(_){let z=v.some(ee=>ee.name===_||ee.key===_);return{passed:!z,message:z?`Step "${_}" was invoked but should not have been`:`Step "${_}" was correctly NOT invoked`,expected:"not called",actual:z?"called":"not called"}}function Q(_,z){let ee=_.ok===z.ok&&(_.ok?JSON.stringify(_.value)===JSON.stringify(z.value):JSON.stringify(_.error)===JSON.stringify(z.error));return{passed:ee,message:ee?"Result matches expected":"Result does not match expected",expected:z,actual:_}}function we(){s=[],a.clear(),w=0,v=[]}return{script:W,scriptStep:K,run:r,runWithInput:q,getInvocations:L,assertSteps:de,assertStepCalled:ne,assertStepNotCalled:u,assertResult:Q,reset:we}}function Qt(){let e,t=[],n=[],m=((...s)=>{if(n.push(s),t.length>0)return Promise.resolve(t.shift());if(e)return Promise.resolve(e);throw new Error("Mock function called without configured return value")});return m.returns=s=>(e=s,m),m.returnsOnce=s=>(t.push(s),m),m.getCalls=()=>[...n],m.getCallCount=()=>n.length,m.reset=()=>{e=void 0,t.length=0,n.length=0},m}function er(e,t,n){let m=e.reduce((s,a)=>s+(a.durationMs??0),0);return{invocations:e.map(s=>({...s,timestamp:0})),result:t,events:n?.map(s=>({...s,ts:0})),durationMs:m}}function tr(e,t){let n=[];e.invocations.length!==t.invocations.length&&n.push(`Invocation count: ${e.invocations.length} vs ${t.invocations.length}`);let m=Math.max(e.invocations.length,t.invocations.length);for(let s=0;s<m;s++){let a=e.invocations[s],w=t.invocations[s];if(!a){n.push(`Step ${s}: missing in first snapshot`);continue}if(!w){n.push(`Step ${s}: missing in second snapshot`);continue}a.name!==w.name&&n.push(`Step ${s} name: "${a.name}" vs "${w.name}"`),a.key!==w.key&&n.push(`Step ${s} key: "${a.key}" vs "${w.key}"`),a.result?.ok!==w.result?.ok&&n.push(`Step ${s} result: ${a.result?.ok?"ok":"err"} vs ${w.result?.ok?"ok":"err"}`)}return e.result.ok!==t.result.ok&&n.push(`Final result: ${e.result.ok?"ok":"err"} vs ${t.result.ok?"ok":"err"}`),{equal:n.length===0,differences:n}}function rr(e=0){let t=e;return{now:()=>t,advance:n=>{t+=n},set:n=>{t=n},reset:()=>{t=e}}}function nr(e){return{type:"ok",value:e}}function or(e){return{type:"err",error:e}}function sr(e){return{type:"throw",error:e}}function ar(e,t={}){let{clock:n=Date.now}=t,m=vt(e,t),s=[],a=[];async function w(q){s=[],a=[];let L={step:async(ne,u)=>{try{let Q=await m.run(async({step:we})=>we("saga-step",ne));if(!Q.ok)throw await de(),{__earlyExit:!0,error:Q.error};return u?.compensate&&a.push({value:Q.value,compensate:u.compensate}),Q.value}catch(Q){throw a.length>0&&await de(),Q}}};async function de(){let ne=[...a].reverse();a=[];for(let{name:u,value:Q,compensate:we}of ne)try{await we(Q),s.push({stepName:u,order:s.length,value:Q,timestamp:n()})}catch(_){console.error(`Compensation failed for step "${u}":`,_)}}try{let ne=await q({saga:L,deps:e});return Z(ne)}catch(ne){return et(ne)?j(ne.error):(await de(),j(new he({cause:ne})))}}function v(){return[...s]}function W(q){let L=s.map(ne=>ne.stepName),de=JSON.stringify(L)===JSON.stringify(q);return{passed:de,message:de?`Compensations ran in order: ${q.join(" \u2192 ")}`:`Expected compensations [${q.join(" \u2192 ")}] but got [${L.join(" \u2192 ")}]`,expected:q,actual:L}}function K(q){let L=s.some(de=>de.stepName===q);return{passed:L,message:L?`Step "${q}" was compensated`:`Step "${q}" was NOT compensated`,expected:q,actual:L}}function I(q){let L=s.some(de=>de.stepName===q);return{passed:!L,message:L?`Step "${q}" was compensated but should not have been`:`Step "${q}" was correctly NOT compensated`,expected:"not compensated",actual:L?"compensated":"not compensated"}}let O=m.reset;function r(){O(),s=[],a=[]}return{...m,reset:r,getCompensations:v,assertCompensationOrder:W,assertCompensated:K,assertNotCompensated:I,runSaga:w}}function ir(e,t,n={}){let{strict:m=!0}=n,s=t.map(W=>{let[K,I]=W.split(":");return{type:K,name:I}}),w=(m?e:e.filter(W=>s.some(K=>W.type===K.type))).map(W=>{let K="name"in W?W.name:void 0,I="stepKey"in W?W.stepKey:void 0,O=K??I;return O?`${W.type}:${O}`:W.type}),v=JSON.stringify(w)===JSON.stringify(t);return{passed:v,message:v?`Event sequence matches: ${t.join(" \u2192 ")}`:`Event sequence mismatch.
-Expected: ${t.join(" \u2192 ")}
-Actual: ${w.join(" \u2192 ")}`,expected:t,actual:w}}function At(e,t){let n=e.find(m=>Object.entries(t).every(([s,a])=>{let w=m[s];return typeof a=="object"&&a!==null?JSON.stringify(w)===JSON.stringify(a):w===a}));return{passed:!!n,message:n?`Event matching ${JSON.stringify(t)} was emitted`:`No event matching ${JSON.stringify(t)} was found`,expected:t,actual:n??"not found"}}function ur(e,t){let n=At(e,t);return{passed:!n.passed,message:n.passed?`Event matching ${JSON.stringify(t)} was found but should not have been`:`Correctly, no event matching ${JSON.stringify(t)} was emitted`,expected:"not emitted",actual:n.actual}}function Pt(e){if(!e.ok)throw new Error(`Expected Ok result, got Err: ${JSON.stringify(e.error,null,2)}`)}function Ot(e){if(e.ok)throw new Error(`Expected Err result, got Ok: ${JSON.stringify(e.value,null,2)}`)}function Dt(e){return Pt(e),e.value}function _t(e){return Ot(e),e.error}async function lr(e){return Dt(await e)}async function cr(e){return _t(await e)}function pr(e){return wt(e)?`Ok(${_e(e.value)})`:`Err(${_e(e.error)})`}function _e(e){if(e===null)return"null";if(e===void 0)return"undefined";if(typeof e=="string")return`'${e}'`;if(typeof e=="number"||typeof e=="boolean")return String(e);if(typeof e=="function")return`[Function: ${e.name||"anonymous"}]`;if(Array.isArray(e))return e.length===0?"[]":e.length<=3?`[${e.map(_e).join(", ")}]`:`[${e.slice(0,3).map(_e).join(", ")}, ... (${e.length} items)]`;if(typeof e=="object"){let t=e,n=Object.keys(t);return n.length===0?"{}":n.length<=4?`{ ${n.map(a=>`${a}: ${_e(t[a])}`).join(", ")} }`:`{ ${n.slice(0,3).map(s=>`${s}: ${_e(t[s])}`).join(", ")}, ... (${n.length} keys) }`}return String(e)}function Mt(e){let t=e.type,n="name"in e?e.name:void 0,m="stepKey"in e?e.stepKey:void 0,s=n??m;return s?`${t}:${s}`:t}function dr(e){return e.map(Mt).join(" \u2192 ")}export{At as assertEventEmitted,ur as assertEventNotEmitted,ir as assertEventSequence,tr as compareSnapshots,Qt as createMockFn,ar as createSagaHarness,er as createSnapshot,rr as createTestClock,vt as createWorkflowHarness,or as errOutcome,Ot as expectErr,Pt as expectOk,Mt as formatEvent,dr as formatEvents,pr as formatResult,nr as okOutcome,bt as testWorkflow,sr as throwOutcome,_t as unwrapErr,cr as unwrapErrAsync,Dt as unwrapOk,lr as unwrapOkAsync};
+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 err(error.error, { cause: originalCause });
+    }
+    const mapped = effectiveCatchUnexpected(error);
+    onError?.(mapped, "unexpected", context);
+    return err(mapped, { cause: error });
+  }
+}
+var runStrict = (fn, options) => {
+  return runFn(fn, options);
+};
+var run = /* @__PURE__ */ Object.assign(runFn, { strict: runStrict });
+async function allAsync(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) => err(
+        { 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/workflow/guards.ts
+function isStepComplete(event) {
+  return event.type === "step_complete";
+}
+function isWorkflowCancelled(error) {
+  return typeof error === "object" && error !== null && error.type === "WORKFLOW_CANCELLED";
+}
+
+// src/persistence.ts
+var SnapshotDecodeError = class extends Error {
+  constructor(message, stepId, originalError) {
+    super(message);
+    this.stepId = stepId;
+    this.originalError = originalError;
+    this.name = "SnapshotDecodeError";
+  }
+  stepId;
+  originalError;
+};
+function deserializeCauseNew(serialized) {
+  if (serialized.type === "error") {
+    const error = new Error(serialized.message);
+    error.name = serialized.name;
+    if (serialized.stack) {
+      error.stack = serialized.stack;
+    }
+    if (serialized.cause) {
+      error.cause = deserializeCauseNew(serialized.cause);
+    }
+    return error;
+  }
+  return serialized.value !== void 0 ? serialized.value : serialized.stringRepresentation;
+}
+
+// src/workflow/cache-encoding.ts
+function isCachedErrorCause(cause) {
+  return typeof cause === "object" && cause !== null && cause.__cachedMeta === true;
+}
+function encodeCachedError(error, meta, originalCause) {
+  return err(error, {
+    cause: { __cachedMeta: true, originalCause, meta }
+  });
+}
+function decodeCachedMeta(cause) {
+  if (isCachedErrorCause(cause)) {
+    return cause.meta;
+  }
+  return { origin: "result", resultCause: cause };
+}
+
+// src/workflow/resume-state.ts
+function createResumeStateCollector() {
+  const steps = /* @__PURE__ */ new Map();
+  return {
+    handleEvent: (event) => {
+      if (isStepComplete(event)) {
+        steps.set(event.stepKey, { result: event.result, meta: event.meta });
+      }
+    },
+    getResumeState: () => ({ steps: new Map(steps) }),
+    clear: () => steps.clear()
+  };
+}
+
+// src/streaming/types.ts
+var STREAM_WRITE_ERROR = "STREAM_WRITE_ERROR";
+var STREAM_READ_ERROR = "STREAM_READ_ERROR";
+var STREAM_CLOSE_ERROR = "STREAM_CLOSE_ERROR";
+var STREAM_ENDED = "STREAM_ENDED";
+function streamWriteError(reason, message, cause) {
+  return {
+    type: STREAM_WRITE_ERROR,
+    reason,
+    message,
+    ...cause !== void 0 ? { cause } : {}
+  };
+}
+function streamReadError(reason, message, cause) {
+  return {
+    type: STREAM_READ_ERROR,
+    reason,
+    message,
+    ...cause !== void 0 ? { cause } : {}
+  };
+}
+function streamCloseError(reason, message, cause) {
+  return {
+    type: STREAM_CLOSE_ERROR,
+    reason,
+    message,
+    ...cause !== void 0 ? { cause } : {}
+  };
+}
+function streamEnded(finalPosition) {
+  return {
+    type: STREAM_ENDED,
+    finalPosition
+  };
+}
+
+// src/streaming/backpressure.ts
+function createBackpressureController(options = {}) {
+  const highWaterMark = options.highWaterMark ?? 16;
+  const lowWaterMark = options.lowWaterMark ?? Math.floor(highWaterMark / 2);
+  const onStateChange = options.onStateChange;
+  let state = "flowing";
+  let bufferedCount = 0;
+  let drainResolvers = [];
+  function updateState(newState) {
+    if (state !== newState) {
+      state = newState;
+      onStateChange?.(newState);
+      if (newState === "flowing" && drainResolvers.length > 0) {
+        const resolvers = drainResolvers;
+        drainResolvers = [];
+        for (const resolve of resolvers) {
+          resolve();
+        }
+      }
+    }
+  }
+  function checkState() {
+    if (state === "flowing" && bufferedCount >= highWaterMark) {
+      updateState("paused");
+    } else if (state === "paused" && bufferedCount <= lowWaterMark) {
+      updateState("flowing");
+    }
+  }
+  return {
+    get state() {
+      return state;
+    },
+    get bufferedCount() {
+      return bufferedCount;
+    },
+    get highWaterMark() {
+      return highWaterMark;
+    },
+    get lowWaterMark() {
+      return lowWaterMark;
+    },
+    increment() {
+      bufferedCount++;
+      checkState();
+    },
+    decrement() {
+      if (bufferedCount > 0) {
+        bufferedCount--;
+        checkState();
+      }
+    },
+    setCount(count) {
+      bufferedCount = Math.max(0, count);
+      checkState();
+    },
+    waitForDrain() {
+      if (state === "flowing") {
+        return Promise.resolve();
+      }
+      return new Promise((resolve) => {
+        drainResolvers.push(resolve);
+      });
+    },
+    reset() {
+      bufferedCount = 0;
+      drainResolvers = [];
+      updateState("flowing");
+    }
+  };
+}
+
+// src/workflow/validation.ts
+async function validateInput(schema, input) {
+  const result = schema["~standard"].validate(input);
+  const resolved = result instanceof Promise ? await result : result;
+  if (resolved.issues) {
+    return err({
+      type: "INPUT_VALIDATION_ERROR",
+      issues: resolved.issues.map((i) => ({
+        message: i.message,
+        path: i.path?.map(
+          (p) => typeof p === "object" ? p.key : p
+        )
+      })),
+      message: `Input validation failed: ${resolved.issues.map((i) => i.message).join(", ")}`
+    });
+  }
+  return ok2(resolved.value);
+}
+
+// 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/workflow/execute.ts
+function createWorkflow(workflowName, deps, options) {
+  if (typeof workflowName !== "string" || workflowName.length === 0) {
+    throw new TypeError(
+      "createWorkflow(workflowName, deps, options?): first argument must be a non-empty string. Example: createWorkflow('checkout', { chargeCard, sendEmail })"
+    );
+  }
+  const depsActual = deps ?? {};
+  const optionsActual = options;
+  async function internalExecute(runName, userFn, config) {
+    const workflowId = runName ?? crypto.randomUUID();
+    const effectiveDeps = config?.deps ? { ...depsActual, ...config.deps } : depsActual;
+    const compensations = [];
+    const createContextFn = config?.createContext ?? optionsActual?.createContext;
+    const context = createContextFn ? await createContextFn() : void 0;
+    const workflowSignal = config?.signal ?? optionsActual?.signal;
+    const onEventHandler = config?.onEvent ?? optionsActual?.onEvent;
+    const onErrorHandler = config?.onError ?? optionsActual?.onError;
+    const shouldRunHook = config?.shouldRun ?? optionsActual?.shouldRun;
+    const onBeforeStartHook = config?.onBeforeStart ?? optionsActual?.onBeforeStart;
+    const onAfterStepHook = config?.onAfterStep ?? optionsActual?.onAfterStep;
+    const resumeStateOption = config?.resumeState ?? optionsActual?.resumeState;
+    const catchUnexpected = optionsActual?.catchUnexpected ?? defaultCatchUnexpected;
+    const declaredGraph = config?.graph ?? optionsActual?.graph;
+    const workflowData = {};
+    const devWarnings = (config?.devWarnings ?? optionsActual?.devWarnings) === true && process.env.NODE_ENV !== "production";
+    const ctxSetWarned = /* @__PURE__ */ new Set();
+    const ctxGetWarned = /* @__PURE__ */ new Set();
+    const workflowContext = {
+      workflowId,
+      onEvent: onEventHandler,
+      context: context !== void 0 ? context : void 0,
+      signal: workflowSignal,
+      // Data store for static analysis
+      input: {},
+      ref: (key) => workflowData[key],
+      set: (key, value) => {
+        if (devWarnings && !ctxSetWarned.has(key)) {
+          ctxSetWarned.add(key);
+          console.warn(
+            `awaitly: ctx.set('${key}', ...) is deprecated for static analysis. Use step('id', fn, { out: '${key}' }) instead.`
+          );
+        }
+        workflowData[key] = value;
+      },
+      get: (key) => {
+        if (devWarnings && !ctxGetWarned.has(key)) {
+          ctxGetWarned.add(key);
+          console.warn(
+            `awaitly: ctx.get('${key}') is deprecated for static analysis. Use ctx.ref('${key}') instead for tracked dependencies.`
+          );
+        }
+        return workflowData[key];
+      }
+    };
+    const emitEvent = (event) => {
+      const eventWithContext = event.context !== void 0 || context === void 0 ? event : { ...event, context };
+      const eventWithName = eventWithContext.workflowName === void 0 ? { ...eventWithContext, workflowName } : eventWithContext;
+      onEventHandler?.(eventWithName, context);
+    };
+    const createCancelledResult = (reason, lastStepKey2) => {
+      const cancelledError = {
+        type: "WORKFLOW_CANCELLED",
+        reason,
+        lastStepKey: lastStepKey2
+      };
+      return err(catchUnexpected(cancelledError), { cause: cancelledError });
+    };
+    if (workflowSignal?.aborted) {
+      const reason = typeof workflowSignal.reason === "string" ? workflowSignal.reason : workflowSignal.reason instanceof Error ? workflowSignal.reason.message : void 0;
+      emitEvent({
+        type: "workflow_cancelled",
+        workflowId,
+        ts: Date.now(),
+        durationMs: 0,
+        reason
+      });
+      return createCancelledResult(reason);
+    }
+    if (shouldRunHook) {
+      const hookStartTime = performance.now();
+      try {
+        const shouldRunResult = await shouldRunHook(workflowId, context);
+        const hookDuration = performance.now() - hookStartTime;
+        emitEvent({
+          type: "hook_should_run",
+          workflowId,
+          ts: Date.now(),
+          durationMs: hookDuration,
+          result: shouldRunResult,
+          skipped: !shouldRunResult
+        });
+        if (!shouldRunResult) {
+          const skipCause = new Error("Workflow skipped by shouldRun hook");
+          return err(catchUnexpected(skipCause), { cause: skipCause });
+        }
+      } catch (thrown) {
+        const hookDuration = performance.now() - hookStartTime;
+        emitEvent({
+          type: "hook_should_run_error",
+          workflowId,
+          ts: Date.now(),
+          durationMs: hookDuration,
+          error: thrown
+        });
+        return err(catchUnexpected(thrown), { cause: thrown });
+      }
+    }
+    if (onBeforeStartHook) {
+      const hookStartTime = performance.now();
+      try {
+        const beforeStartResult = await onBeforeStartHook(workflowId, context);
+        const hookDuration = performance.now() - hookStartTime;
+        emitEvent({
+          type: "hook_before_start",
+          workflowId,
+          ts: Date.now(),
+          durationMs: hookDuration,
+          result: beforeStartResult,
+          skipped: !beforeStartResult
+        });
+        if (!beforeStartResult) {
+          const skipCause = new Error("Workflow skipped by onBeforeStart hook");
+          return err(catchUnexpected(skipCause), { cause: skipCause });
+        }
+      } catch (thrown) {
+        const hookDuration = performance.now() - hookStartTime;
+        emitEvent({
+          type: "hook_before_start_error",
+          workflowId,
+          ts: Date.now(),
+          durationMs: hookDuration,
+          error: thrown
+        });
+        return err(catchUnexpected(thrown), { cause: thrown });
+      }
+    }
+    const inputSchema = optionsActual?.inputSchema;
+    const inputValue = optionsActual?.input;
+    if (inputSchema) {
+      const validationResult = await validateInput(inputSchema, inputValue);
+      if (!validationResult.ok) {
+        return err(validationResult.error);
+      }
+      workflowContext.input = validationResult.value;
+    } else if (inputValue !== void 0) {
+      workflowContext.input = inputValue;
+    }
+    const startTs = Date.now();
+    const startTime = performance.now();
+    emitEvent({
+      type: "workflow_start",
+      workflowId,
+      ts: startTs
+    });
+    let cache = config?.cache ?? optionsActual?.cache;
+    const streamStore = config?.streamStore ?? optionsActual?.streamStore;
+    if (resumeStateOption && !cache) {
+      cache = /* @__PURE__ */ new Map();
+    }
+    if (resumeStateOption && cache) {
+      const resumeState = typeof resumeStateOption === "function" ? await resumeStateOption() : resumeStateOption;
+      if (!(resumeState.steps instanceof Map)) {
+        console.warn(
+          `awaitly: resumeState.steps is not a Map (got ${typeof resumeState.steps}). This usually happens when state is serialized with JSON.stringify() directly.
+Use serializeResumeState() and deserializeResumeState() from 'awaitly/workflow' instead:
+  import { serializeResumeState, deserializeResumeState } from 'awaitly/workflow';
+  const json = JSON.stringify(serializeResumeState(state));  // Save this
+  const restored = deserializeResumeState(JSON.parse(json)); // Load this`
+        );
+        if (typeof resumeState.steps === "object" && resumeState.steps !== null) {
+          resumeState.steps = new Map(Object.entries(resumeState.steps));
+        }
+      }
+      for (const [key, entry] of resumeState.steps) {
+        const { result: result2, meta } = entry;
+        if (result2.ok) {
+          cache.set(key, result2);
+        } else {
+          const effectiveMeta = meta ?? { origin: "result", resultCause: result2.cause };
+          cache.set(key, encodeCachedError(result2.error, effectiveMeta, result2.cause));
+        }
+      }
+    }
+    const snapshotOption = config?.snapshot ?? optionsActual?.snapshot;
+    const snapshotSerialization = optionsActual?.serialization;
+    if (snapshotOption && !resumeStateOption) {
+      if (!cache) {
+        cache = /* @__PURE__ */ new Map();
+      }
+      const snapshot = snapshotOption;
+      const decode = snapshotSerialization?.decode;
+      for (const [stepId, stepResult] of Object.entries(snapshot.steps)) {
+        if (!Object.prototype.hasOwnProperty.call(snapshot.steps, stepId)) {
+          continue;
+        }
+        try {
+          if (stepResult.ok) {
+            const value = decode ? decode(stepResult.value) : stepResult.value;
+            cache.set(stepId, ok2(value));
+          } else {
+            const errorValue = decode ? decode(stepResult.error) : stepResult.error;
+            const deserializedCause = deserializeCauseNew(stepResult.cause);
+            const meta = stepResult.meta?.origin === "throw" ? { origin: "throw", thrown: deserializedCause } : { origin: "result", resultCause: deserializedCause };
+            cache.set(stepId, encodeCachedError(errorValue, meta, deserializedCause));
+          }
+        } catch (e) {
+          throw new SnapshotDecodeError(
+            `Failed to decode step "${stepId}": ${e instanceof Error ? e.message : String(e)}`,
+            stepId,
+            e instanceof Error ? e : void 0
+          );
+        }
+      }
+    }
+    let abortedDuringExecution = false;
+    let abortReason;
+    let lastStepKey;
+    const abortHandler = () => {
+      abortedDuringExecution = true;
+      abortReason = typeof workflowSignal?.reason === "string" ? workflowSignal.reason : workflowSignal?.reason instanceof Error ? workflowSignal.reason.message : void 0;
+    };
+    if (workflowSignal && !workflowSignal.aborted) {
+      workflowSignal.addEventListener("abort", abortHandler, { once: true });
+    }
+    const checkCancellation = () => {
+      if (abortedDuringExecution || workflowSignal?.aborted) {
+        const reason = abortReason ?? (typeof workflowSignal?.reason === "string" ? workflowSignal.reason : workflowSignal?.reason instanceof Error ? workflowSignal.reason.message : void 0);
+        const cancelledError = {
+          type: "WORKFLOW_CANCELLED",
+          reason,
+          lastStepKey
+        };
+        throw cancelledError;
+      }
+    };
+    const callOnAfterStepHook = async (stepKey, result2, _meta) => {
+      if (!onAfterStepHook) return;
+      const hookStartTime = performance.now();
+      try {
+        await onAfterStepHook(stepKey, result2, workflowId, context);
+        const hookDuration = performance.now() - hookStartTime;
+        emitEvent({
+          type: "hook_after_step",
+          workflowId,
+          stepKey,
+          ts: Date.now(),
+          durationMs: hookDuration
+        });
+      } catch (thrown) {
+        const hookDuration = performance.now() - hookStartTime;
+        emitEvent({
+          type: "hook_after_step_error",
+          workflowId,
+          stepKey,
+          ts: Date.now(),
+          durationMs: hookDuration,
+          error: thrown
+        });
+        throw thrown;
+      }
+    };
+    const createCachedStep = (realStep) => {
+      const cachedStepFn = async (idOrOperationOrResult, operationOrOptions, stepOptions) => {
+        if (typeof idOrOperationOrResult !== "string") {
+          throw new Error(
+            '[awaitly] step() requires a string ID as the first argument. Example: step("fetchUser", () => fetchUser(id))'
+          );
+        }
+        const id = idOrOperationOrResult;
+        const opts = stepOptions ?? {};
+        const name = id;
+        const key = Object.prototype.hasOwnProperty.call(opts, "key") ? opts.key : id;
+        const { ttl, out } = opts;
+        checkCancellation();
+        const stepMetadata = extractStepMetadata(opts);
+        if (key && cache && cache.has(key)) {
+          emitEvent({
+            type: "step_cache_hit",
+            workflowId,
+            stepKey: key,
+            name,
+            ts: Date.now(),
+            ...stepMetadata && { metadata: stepMetadata }
+          });
+          const cached = cache.get(key);
+          if (cached.ok) {
+            lastStepKey = key;
+            if (out) {
+              workflowData[out] = cached.value;
+            }
+            return cached.value;
+          }
+          const meta = decodeCachedMeta(cached.cause);
+          throw createEarlyExit(cached.error, meta);
+        }
+        if (key && cache) {
+          emitEvent({
+            type: "step_cache_miss",
+            workflowId,
+            stepKey: key,
+            name,
+            ts: Date.now(),
+            ...stepMetadata && { metadata: stepMetadata }
+          });
+        }
+        try {
+          const value = await realStep(
+            id,
+            operationOrOptions,
+            opts
+          );
+          if (out) {
+            workflowData[out] = value;
+          }
+          if (opts.compensate) {
+            compensations.push({
+              stepName: name,
+              value,
+              compensate: opts.compensate
+            });
+          }
+          if (key) {
+            lastStepKey = key;
+            if (cache) {
+              cache.set(key, ok2(value), ttl ? { ttl } : void 0);
+            }
+            await callOnAfterStepHook(key, ok2(value));
+          }
+          return value;
+        } catch (thrown) {
+          if (key && isEarlyExit(thrown)) {
+            const exit = thrown;
+            const originalCause = exit.meta.origin === "result" ? exit.meta.resultCause : exit.meta.origin === "throw" ? exit.meta.thrown : void 0;
+            const errorResult = encodeCachedError(exit.error, exit.meta, originalCause);
+            if (cache) {
+              cache.set(key, errorResult, ttl ? { ttl } : void 0);
+            }
+            await callOnAfterStepHook(key, errorResult, exit.meta);
+          }
+          throw thrown;
+        }
+      };
+      cachedStepFn.try = async (id, operation, opts) => {
+        const { ttl } = opts;
+        const key = opts.key ?? id;
+        const name = id;
+        if (cache && cache.has(key)) {
+          emitEvent({
+            type: "step_cache_hit",
+            workflowId,
+            stepKey: key,
+            name,
+            ts: Date.now()
+          });
+          const cached = cache.get(key);
+          if (cached.ok) {
+            return cached.value;
+          }
+          const meta = decodeCachedMeta(cached.cause);
+          throw createEarlyExit(cached.error, meta);
+        }
+        if (cache) {
+          emitEvent({
+            type: "step_cache_miss",
+            workflowId,
+            stepKey: key,
+            name,
+            ts: Date.now()
+          });
+        }
+        try {
+          const value = await realStep.try(id, operation, { ...opts, key });
+          if (opts.compensate) {
+            compensations.push({
+              stepName: name,
+              value,
+              compensate: opts.compensate
+            });
+          }
+          if (cache) {
+            cache.set(key, ok2(value), ttl ? { ttl } : void 0);
+          }
+          await callOnAfterStepHook(key, ok2(value));
+          return value;
+        } catch (thrown) {
+          if (isEarlyExit(thrown)) {
+            const exit = thrown;
+            const originalCause = exit.meta.origin === "result" ? exit.meta.resultCause : exit.meta.origin === "throw" ? exit.meta.thrown : void 0;
+            const errorResult = encodeCachedError(exit.error, exit.meta, originalCause);
+            if (cache) {
+              cache.set(key, errorResult, ttl ? { ttl } : void 0);
+            }
+            await callOnAfterStepHook(key, errorResult, exit.meta);
+          }
+          throw thrown;
+        }
+      };
+      cachedStepFn.fromResult = async (id, operation, opts) => {
+        const { ttl } = opts;
+        const key = opts.key ?? id;
+        const name = id;
+        if (cache && cache.has(key)) {
+          emitEvent({
+            type: "step_cache_hit",
+            workflowId,
+            stepKey: key,
+            name,
+            ts: Date.now()
+          });
+          const cached = cache.get(key);
+          if (cached.ok) {
+            return cached.value;
+          }
+          const meta = decodeCachedMeta(cached.cause);
+          throw createEarlyExit(cached.error, meta);
+        }
+        if (cache) {
+          emitEvent({
+            type: "step_cache_miss",
+            workflowId,
+            stepKey: key,
+            name,
+            ts: Date.now()
+          });
+        }
+        try {
+          const value = await realStep.fromResult(id, operation, { ...opts, key });
+          if (cache) {
+            cache.set(key, ok2(value), ttl ? { ttl } : void 0);
+          }
+          await callOnAfterStepHook(key, ok2(value));
+          return value;
+        } catch (thrown) {
+          if (isEarlyExit(thrown)) {
+            const exit = thrown;
+            const originalCause = exit.meta.origin === "result" ? exit.meta.resultCause : exit.meta.origin === "throw" ? exit.meta.thrown : void 0;
+            const errorResult = encodeCachedError(exit.error, exit.meta, originalCause);
+            if (cache) {
+              cache.set(key, errorResult, ttl ? { ttl } : void 0);
+            }
+            await callOnAfterStepHook(key, errorResult, exit.meta);
+          }
+          throw thrown;
+        }
+      };
+      cachedStepFn.race = realStep.race;
+      cachedStepFn.withFallback = async (id, operation, options2) => {
+        const key = options2.key ?? id;
+        const name = id;
+        if (cache && cache.has(key)) {
+          emitEvent({
+            type: "step_cache_hit",
+            workflowId,
+            stepKey: key,
+            name,
+            ts: Date.now()
+          });
+          const cached = cache.get(key);
+          if (cached.ok) {
+            return cached.value;
+          }
+          const meta = decodeCachedMeta(cached.cause);
+          throw createEarlyExit(cached.error, meta);
+        }
+        if (cache) {
+          emitEvent({
+            type: "step_cache_miss",
+            workflowId,
+            stepKey: key,
+            name,
+            ts: Date.now()
+          });
+        }
+        try {
+          const value = await realStep.withFallback(
+            id,
+            operation,
+            options2
+          );
+          if (cache) {
+            cache.set(key, ok2(value));
+          }
+          await callOnAfterStepHook(key, ok2(value));
+          return value;
+        } catch (thrown) {
+          if (isEarlyExit(thrown)) {
+            const exit = thrown;
+            const originalCause = exit.meta.origin === "result" ? exit.meta.resultCause : exit.meta.origin === "throw" ? exit.meta.thrown : void 0;
+            const errorResult = encodeCachedError(exit.error, exit.meta, originalCause);
+            if (cache) {
+              cache.set(key, errorResult);
+            }
+            await callOnAfterStepHook(key, errorResult, exit.meta);
+          }
+          throw thrown;
+        }
+      };
+      cachedStepFn.withResource = async (id, options2) => {
+        const key = id;
+        try {
+          const value = await realStep.withResource(id, options2);
+          await callOnAfterStepHook(key, ok2(value));
+          return value;
+        } catch (thrown) {
+          if (isEarlyExit(thrown)) {
+            const exit = thrown;
+            const originalCause = exit.meta.origin === "result" ? exit.meta.resultCause : exit.meta.origin === "throw" ? exit.meta.thrown : void 0;
+            const errorResult = encodeCachedError(exit.error, exit.meta, originalCause);
+            await callOnAfterStepHook(key, errorResult, exit.meta);
+          }
+          throw thrown;
+        }
+      };
+      cachedStepFn.retry = (id, operation, options2) => {
+        const stepOptions = {
+          key: options2.key,
+          // explicitly pass so undefined = don't cache
+          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,
+          ttl: options2.ttl
+        };
+        return cachedStepFn(id, operation, stepOptions);
+      };
+      cachedStepFn.withTimeout = (id, operation, options2) => {
+        const stepOptions = {
+          key: options2.key,
+          timeout: options2,
+          ttl: options2.ttl
+        };
+        return cachedStepFn(
+          id,
+          operation,
+          stepOptions
+        );
+      };
+      cachedStepFn.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" ? parse(duration) : duration;
+        if (!d) {
+          throw new Error(`step.sleep: invalid duration '${duration}'`);
+        }
+        const ms = toMillis(d);
+        const userSignal = options2?.signal;
+        const sleepOperation = 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);
+          });
+        };
+        return cachedStepFn(id, sleepOperation, {
+          key: options2?.key,
+          ttl: options2?.ttl,
+          description: options2?.description
+        });
+      };
+      const activeWriters = /* @__PURE__ */ new Map();
+      const activeReaders = /* @__PURE__ */ new Map();
+      cachedStepFn.getWritable = (options2) => {
+        const namespace = options2?.namespace ?? "default";
+        const highWaterMark = options2?.highWaterMark ?? 16;
+        if (!streamStore) {
+          throw new Error(
+            "streamStore is required to use getWritable(). Pass a streamStore to createWorkflow options."
+          );
+        }
+        const existingKey = `${workflowId}:${namespace}`;
+        const existing = activeWriters.get(existingKey);
+        if (existing && !existing.closed && !existing.aborted) {
+          return existing.writer;
+        }
+        const backpressure = createBackpressureController({
+          highWaterMark,
+          onStateChange: (state) => {
+            emitEvent({
+              type: "stream_backpressure",
+              workflowId,
+              namespace,
+              bufferedCount: backpressure.bufferedCount,
+              state,
+              ts: Date.now()
+            });
+          }
+        });
+        let position = 0;
+        let writable = true;
+        let aborted = false;
+        let closed = false;
+        emitEvent({
+          type: "stream_created",
+          workflowId,
+          namespace,
+          ts: Date.now()
+        });
+        const writer = {
+          async write(value) {
+            if (closed) {
+              return err(streamWriteError("closed", "Stream is closed"));
+            }
+            if (aborted) {
+              return err(streamWriteError("aborted", "Stream was aborted"));
+            }
+            if (backpressure.state === "paused") {
+              await backpressure.waitForDrain();
+            }
+            const item = {
+              value,
+              position,
+              ts: Date.now()
+            };
+            const result2 = await streamStore.append(workflowId, namespace, item);
+            if (!result2.ok) {
+              emitEvent({
+                type: "stream_error",
+                workflowId,
+                namespace,
+                error: result2.error,
+                position,
+                ts: Date.now()
+              });
+              return err(streamWriteError("store_error", result2.error.message, result2.error));
+            }
+            emitEvent({
+              type: "stream_write",
+              workflowId,
+              namespace,
+              position,
+              ts: Date.now()
+            });
+            position++;
+            backpressure.increment();
+            return ok2(void 0);
+          },
+          async close() {
+            if (closed) {
+              return err(streamCloseError("already_closed", "Stream is already closed"));
+            }
+            const result2 = await streamStore.closeStream(workflowId, namespace);
+            if (!result2.ok) {
+              return err(streamCloseError("store_error", result2.error.message, result2.error));
+            }
+            closed = true;
+            writable = false;
+            emitEvent({
+              type: "stream_close",
+              workflowId,
+              namespace,
+              finalPosition: position,
+              ts: Date.now()
+            });
+            activeWriters.delete(existingKey);
+            return ok2(void 0);
+          },
+          abort(reason) {
+            aborted = true;
+            writable = false;
+            closed = true;
+            emitEvent({
+              type: "stream_error",
+              workflowId,
+              namespace,
+              error: reason,
+              position,
+              ts: Date.now()
+            });
+            activeWriters.delete(existingKey);
+          },
+          get writable() {
+            return writable;
+          },
+          get position() {
+            return position;
+          },
+          get namespace() {
+            return namespace;
+          }
+        };
+        activeWriters.set(existingKey, {
+          writer,
+          backpressure,
+          aborted,
+          closed
+        });
+        return writer;
+      };
+      cachedStepFn.getReadable = (options2) => {
+        const namespace = options2?.namespace ?? "default";
+        const startIndex = options2?.startIndex ?? 0;
+        const pollInterval = options2?.pollInterval ?? 10;
+        const pollTimeout = options2?.pollTimeout ?? 3e4;
+        if (!streamStore) {
+          throw new Error(
+            "streamStore is required to use getReadable(). Pass a streamStore to createWorkflow options."
+          );
+        }
+        const existingKey = `${workflowId}:${namespace}:${startIndex}`;
+        const existing = activeReaders.get(existingKey);
+        if (existing && !existing.closed) {
+          return existing.reader;
+        }
+        const decrementBackpressure = () => {
+          const writerKey = `${workflowId}:${namespace}`;
+          const activeWriter = activeWriters.get(writerKey);
+          if (activeWriter) {
+            activeWriter.backpressure.decrement();
+          }
+        };
+        let position = startIndex;
+        let readable = true;
+        let closed = false;
+        let bufferedItems = [];
+        let bufferIndex = 0;
+        const reader = {
+          async read() {
+            if (closed) {
+              return err(streamReadError("closed", "Reader is closed"));
+            }
+            if (bufferIndex < bufferedItems.length) {
+              const item = bufferedItems[bufferIndex++];
+              position = item.position + 1;
+              decrementBackpressure();
+              emitEvent({
+                type: "stream_read",
+                workflowId,
+                namespace,
+                position: item.position,
+                ts: Date.now()
+              });
+              return ok2(item.value);
+            }
+            const writerKey = `${workflowId}:${namespace}`;
+            const pollStart = Date.now();
+            let hasSeenWriter = activeWriters.has(writerKey);
+            const initialMetaResult = await streamStore.getMetadata(workflowId, namespace);
+            let hasSeenMetadata = initialMetaResult.ok && initialMetaResult.value !== void 0;
+            while (Date.now() - pollStart < pollTimeout) {
+              const result2 = await streamStore.read(workflowId, namespace, position, 100);
+              if (!result2.ok) {
+                return err(streamReadError("store_error", result2.error.message, result2.error));
+              }
+              const items = result2.value;
+              if (items.length > 0) {
+                bufferedItems = items;
+                bufferIndex = 1;
+                const item = items[0];
+                position = item.position + 1;
+                decrementBackpressure();
+                emitEvent({
+                  type: "stream_read",
+                  workflowId,
+                  namespace,
+                  position: item.position,
+                  ts: Date.now()
+                });
+                return ok2(item.value);
+              }
+              const writerActive = activeWriters.has(writerKey);
+              const metaResult = await streamStore.getMetadata(workflowId, namespace);
+              const metadataExists = metaResult.ok && metaResult.value !== void 0;
+              if (writerActive) hasSeenWriter = true;
+              if (metadataExists) hasSeenMetadata = true;
+              if (metaResult.ok && metaResult.value?.closed) {
+                readable = false;
+                return err(streamEnded(position));
+              }
+              if (hasSeenWriter && !writerActive && !metadataExists) {
+                readable = false;
+                return err(streamEnded(position));
+              }
+              if (hasSeenMetadata && !writerActive && metaResult.ok && !metaResult.value?.closed) {
+              }
+              await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            }
+            readable = false;
+            return err(streamEnded(position));
+          },
+          close() {
+            closed = true;
+            readable = false;
+            bufferedItems = [];
+            activeReaders.delete(existingKey);
+          },
+          get readable() {
+            return readable;
+          },
+          get position() {
+            return position;
+          },
+          get namespace() {
+            return namespace;
+          }
+        };
+        activeReaders.set(existingKey, {
+          reader,
+          position,
+          closed
+        });
+        return reader;
+      };
+      cachedStepFn.streamForEach = async (source, processor, options2) => {
+        const checkpointInterval = options2?.checkpointInterval ?? 1;
+        const concurrency = options2?.concurrency ?? 1;
+        const results = [];
+        let processedCount = 0;
+        let lastPosition = -1;
+        const isStreamReader = (s) => {
+          return typeof s === "object" && s !== null && "read" in s && typeof s.read === "function";
+        };
+        const processItem = async (item, itemIndex, itemPosition, namespace) => {
+          const shouldCheckpoint = checkpointInterval > 0 && itemIndex % checkpointInterval === 0;
+          const stepKey = shouldCheckpoint ? `stream-foreach:${namespace}:pos-${itemPosition}` : void 0;
+          const stepId = stepKey ?? `stream-item-${itemPosition}`;
+          const stepResult = await cachedStepFn(
+            stepId,
+            () => processor(item, itemIndex),
+            { key: stepKey }
+          );
+          return { index: itemIndex, position: itemPosition, result: stepResult };
+        };
+        if (isStreamReader(source)) {
+          if (concurrency <= 1) {
+            let itemPosition = source.position;
+            let readResult = await source.read();
+            while (readResult.ok) {
+              const item = readResult.value;
+              const { result: result2 } = await processItem(item, processedCount, itemPosition, source.namespace);
+              results.push(result2);
+              lastPosition = itemPosition;
+              processedCount++;
+              itemPosition = source.position;
+              readResult = await source.read();
+            }
+          } else {
+            const resultsMap = /* @__PURE__ */ new Map();
+            let itemIndex = 0;
+            let totalItems = 0;
+            const slots = new Array(concurrency).fill(null);
+            const getSlot = async () => {
+              for (let i = 0; i < slots.length; i++) {
+                if (slots[i] === null) return i;
+              }
+              const activePromises = slots.filter((s) => s !== null);
+              const completed = await Promise.race(activePromises);
+              resultsMap.set(completed.index, { position: completed.position, result: completed.result });
+              slots[completed.slotIndex] = null;
+              return completed.slotIndex;
+            };
+            let itemPosition = source.position;
+            let readResult = await source.read();
+            while (readResult.ok) {
+              const slotIndex = await getSlot();
+              const currentIndex = itemIndex;
+              const currentPosition = itemPosition;
+              const currentItem = readResult.value;
+              const currentSlot = slotIndex;
+              slots[slotIndex] = processItem(currentItem, currentIndex, currentPosition, source.namespace).then((r) => ({ slotIndex: currentSlot, ...r }));
+              totalItems++;
+              itemIndex++;
+              itemPosition = source.position;
+              readResult = await source.read();
+            }
+            for (let i = 0; i < slots.length; i++) {
+              if (slots[i] !== null) {
+                const result2 = await slots[i];
+                resultsMap.set(result2.index, { position: result2.position, result: result2.result });
+              }
+            }
+            for (let i = 0; i < totalItems; i++) {
+              const entry = resultsMap.get(i);
+              if (entry) {
+                results.push(entry.result);
+                lastPosition = entry.position;
+                processedCount++;
+              }
+            }
+          }
+        } else {
+          if (concurrency <= 1) {
+            let index = 0;
+            for await (const item of source) {
+              const { result: result2 } = await processItem(item, index, index, "async-iterable");
+              results.push(result2);
+              lastPosition = index;
+              processedCount++;
+              index++;
+            }
+          } else {
+            const resultsMap = /* @__PURE__ */ new Map();
+            let itemIndex = 0;
+            let totalItems = 0;
+            const slots = new Array(concurrency).fill(null);
+            const getSlot = async () => {
+              for (let i = 0; i < slots.length; i++) {
+                if (slots[i] === null) return i;
+              }
+              const activePromises = slots.filter((s) => s !== null);
+              const completed = await Promise.race(activePromises);
+              resultsMap.set(completed.index, completed.result);
+              slots[completed.slotIndex] = null;
+              return completed.slotIndex;
+            };
+            for await (const item of source) {
+              const slotIndex = await getSlot();
+              const currentIndex = itemIndex;
+              const currentSlot = slotIndex;
+              slots[slotIndex] = processItem(item, currentIndex, currentIndex, "async-iterable").then((r) => ({ slotIndex: currentSlot, ...r }));
+              totalItems++;
+              itemIndex++;
+            }
+            for (let i = 0; i < slots.length; i++) {
+              if (slots[i] !== null) {
+                const result2 = await slots[i];
+                resultsMap.set(result2.index, result2.result);
+              }
+            }
+            for (let i = 0; i < totalItems; i++) {
+              if (resultsMap.has(i)) {
+                results.push(resultsMap.get(i));
+                lastPosition = i;
+                processedCount++;
+              }
+            }
+          }
+        }
+        return {
+          results,
+          processedCount,
+          lastPosition
+        };
+      };
+      cachedStepFn.if = realStep.if;
+      cachedStepFn.label = realStep.label;
+      cachedStepFn.branch = realStep.branch;
+      cachedStepFn.arm = realStep.arm;
+      cachedStepFn.forEach = realStep.forEach;
+      cachedStepFn.item = realStep.item;
+      cachedStepFn.dep = realStep.dep;
+      cachedStepFn.workflow = (id, getter, options2) => cachedStepFn(id, getter, options2);
+      cachedStepFn.all = (id, shape, options2) => {
+        const opts = options2 !== void 0 && Object.prototype.hasOwnProperty.call(options2, "key") ? options2 : { ...options2, key: void 0 };
+        return cachedStepFn(id, async () => ok2(await realStep.all(id, shape)), opts);
+      };
+      cachedStepFn.map = (id, items, mapper, options2) => {
+        const opts = options2 !== void 0 && Object.prototype.hasOwnProperty.call(options2, "key") ? options2 : { ...options2, key: void 0 };
+        return cachedStepFn(id, async () => ok2(await realStep.map(id, items, mapper, options2)), opts);
+      };
+      return cachedStepFn;
+    };
+    const wrappedFn = ({ step }) => {
+      const cachedStep = createCachedStep(step);
+      return userFn({
+        step: cachedStep,
+        steps: bindSteps(effectiveDeps ?? {}, cachedStep),
+        deps: effectiveDeps,
+        ctx: workflowContext
+      });
+    };
+    let result;
+    try {
+      result = await run(wrappedFn, {
+        onError: onErrorHandler,
+        onEvent: onEventHandler,
+        catchUnexpected,
+        workflowId,
+        workflowName,
+        context,
+        graph: declaredGraph,
+        _workflowSignal: workflowSignal
+      });
+    } finally {
+      if (workflowSignal) {
+        workflowSignal.removeEventListener("abort", abortHandler);
+      }
+    }
+    if (!result.ok && compensations.length > 0) {
+      const compensationErrors = [];
+      for (let i = compensations.length - 1; i >= 0; i--) {
+        const comp = compensations[i];
+        try {
+          await comp.compensate(comp.value);
+        } catch (compErr) {
+          compensationErrors.push({ stepName: comp.stepName, error: compErr });
+        }
+      }
+      if (compensationErrors.length > 0) {
+        const sagaError = {
+          type: "SAGA_COMPENSATION_ERROR",
+          originalError: result.error,
+          compensationErrors
+        };
+        result = err(sagaError, { cause: result.cause });
+      }
+    }
+    const durationMs = performance.now() - startTime;
+    if (!result.ok) {
+      let cancelledError;
+      if (isWorkflowCancelled(result.cause)) {
+        cancelledError = result.cause;
+      }
+      if (!cancelledError && abortedDuringExecution && isUnexpectedError(result.error)) {
+        const thrown = result.cause;
+        const isAbortError = thrown != null && typeof thrown === "object" && "name" in thrown && thrown.name === "AbortError";
+        if (isAbortError) {
+          const reason = abortReason ?? (typeof workflowSignal?.reason === "string" ? workflowSignal.reason : workflowSignal?.reason instanceof Error ? workflowSignal.reason.message : void 0);
+          cancelledError = {
+            type: "WORKFLOW_CANCELLED",
+            reason,
+            lastStepKey
+          };
+        }
+      }
+      if (cancelledError) {
+        emitEvent({
+          type: "workflow_cancelled",
+          workflowId,
+          ts: Date.now(),
+          durationMs,
+          reason: cancelledError.reason,
+          lastStepKey: cancelledError.lastStepKey
+        });
+        if (cancelledError && !isWorkflowCancelled(result.cause)) {
+          return err(result.error, { cause: cancelledError });
+        }
+        return result;
+      }
+    }
+    if (result.ok && abortedDuringExecution) {
+      const reason = abortReason ?? (typeof workflowSignal?.reason === "string" ? workflowSignal.reason : workflowSignal?.reason instanceof Error ? workflowSignal.reason.message : void 0);
+      emitEvent({
+        type: "workflow_cancelled",
+        workflowId,
+        ts: Date.now(),
+        durationMs,
+        reason,
+        lastStepKey
+      });
+      const cancelledError = {
+        type: "WORKFLOW_CANCELLED",
+        reason,
+        lastStepKey
+      };
+      return err(catchUnexpected(cancelledError), { cause: cancelledError });
+    }
+    if (result.ok) {
+      emitEvent({
+        type: "workflow_success",
+        workflowId,
+        ts: Date.now(),
+        durationMs
+      });
+    } else {
+      emitEvent({
+        type: "workflow_error",
+        workflowId,
+        ts: Date.now(),
+        durationMs,
+        error: result.error
+      });
+    }
+    return result;
+  }
+  function runMethod(fnOrName, maybeFnOrConfig, maybeConfig) {
+    let runName;
+    let fn;
+    let config;
+    if (typeof fnOrName === "string") {
+      runName = fnOrName;
+      fn = maybeFnOrConfig;
+      config = maybeConfig;
+    } else {
+      fn = fnOrName;
+      config = maybeFnOrConfig;
+    }
+    return internalExecute(runName, fn, config);
+  }
+  async function runWithStateMethod(fnOrName, maybeFnOrConfig, maybeConfig) {
+    let runName;
+    let fn;
+    let config;
+    if (typeof fnOrName === "string") {
+      runName = fnOrName;
+      fn = maybeFnOrConfig;
+      config = maybeConfig;
+    } else {
+      fn = fnOrName;
+      config = maybeFnOrConfig;
+    }
+    const collector = createResumeStateCollector();
+    const userOnEvent = config?.onEvent;
+    const mergedOnEvent = (event, ctx) => {
+      collector.handleEvent(event);
+      try {
+        userOnEvent?.(event, ctx);
+      } catch {
+      }
+    };
+    const mergedConfig = {
+      ...config,
+      onEvent: mergedOnEvent
+    };
+    let result;
+    let resumeState;
+    try {
+      result = await internalExecute(runName, fn, mergedConfig);
+    } catch (thrown) {
+      const catchUnexpected = optionsActual?.catchUnexpected ?? defaultCatchUnexpected;
+      result = err(catchUnexpected(thrown), { cause: thrown });
+    } finally {
+      resumeState = collector.getResumeState();
+    }
+    return { result, resumeState };
+  }
+  const workflow = {
+    withDeps: (overrides) => withDeps(workflow, overrides),
+    run: runMethod,
+    runWithState: runWithStateMethod
+  };
+  return workflow;
+}
+
+// src/testing/test-runner.ts
+async function testWorkflow(deps, fn, options) {
+  const events = [];
+  const steps = {};
+  const stepOrder = [];
+  const onEvent = (event) => {
+    events.push(event);
+    if (event.type === "step_complete" && event.stepKey) {
+      const stepResult = {
+        output: event.result.ok ? event.result.value : void 0,
+        durationMs: event.durationMs,
+        result: event.result
+      };
+      steps[event.stepKey] = stepResult;
+      stepOrder.push(event.stepKey);
+    }
+  };
+  const workflow = createWorkflow("test-workflow", deps);
+  const start = performance.now();
+  const result = await workflow.run(fn, {
+    onEvent,
+    signal: options?.signal
+  });
+  const durationMs = performance.now() - start;
+  return {
+    result,
+    steps,
+    events,
+    durationMs,
+    stepOrder
+  };
+}
+
+// src/testing/index.ts
+function isTestEarlyExit(e) {
+  return typeof e === "object" && e !== null && "__earlyExit" in e && e.__earlyExit === true;
+}
+function createWorkflowHarness(deps, options = {}) {
+  const { recordInvocations = true, clock = Date.now } = options;
+  let scriptedOutcomes = [];
+  const namedOutcomes = /* @__PURE__ */ new Map();
+  let invocationIndex = 0;
+  let invocations = [];
+  function script(outcomes) {
+    scriptedOutcomes = [...outcomes];
+    invocationIndex = 0;
+    namedOutcomes.clear();
+  }
+  function scriptStep(nameOrKey, outcome) {
+    namedOutcomes.set(nameOrKey, outcome);
+  }
+  function getNextOutcome(nameOrKey) {
+    if (nameOrKey && namedOutcomes.has(nameOrKey)) {
+      return namedOutcomes.get(nameOrKey);
+    }
+    if (invocationIndex < scriptedOutcomes.length) {
+      return scriptedOutcomes[invocationIndex++];
+    }
+    return void 0;
+  }
+  function createMockStep() {
+    const mockStep = async (nameOrOperation, operationOrOptions, maybeOptions) => {
+      let name;
+      let operationOrResult;
+      let opts;
+      if (typeof nameOrOperation === "string") {
+        name = nameOrOperation;
+        operationOrResult = operationOrOptions;
+        opts = maybeOptions ?? {};
+      } else {
+        operationOrResult = nameOrOperation;
+        if (typeof operationOrOptions === "string") {
+          name = operationOrOptions;
+          opts = {};
+        } else {
+          opts = operationOrOptions ?? {};
+          name = opts.key ?? "step";
+        }
+      }
+      const startTime = clock();
+      const invocation = {
+        name,
+        key: opts.key,
+        order: invocations.length,
+        timestamp: startTime
+      };
+      if (recordInvocations) {
+        invocations.push(invocation);
+      }
+      const outcome = getNextOutcome(name);
+      if (outcome) {
+        invocation.durationMs = clock() - startTime;
+        switch (outcome.type) {
+          case "ok":
+            invocation.result = ok2(outcome.value);
+            return outcome.value;
+          case "err":
+            invocation.result = err(outcome.error);
+            throw { __earlyExit: true, error: outcome.error };
+          case "throw":
+            throw outcome.error;
+        }
+      }
+      const result = typeof operationOrResult === "function" ? await operationOrResult() : await operationOrResult;
+      invocation.durationMs = clock() - startTime;
+      invocation.result = result;
+      if (!result.ok) {
+        throw { __earlyExit: true, error: result.error };
+      }
+      return result.value;
+    };
+    mockStep.try = async (nameOrOperation, operationOrOpts, maybeOpts) => {
+      let name;
+      let operation;
+      let opts;
+      if (typeof nameOrOperation === "string") {
+        name = nameOrOperation;
+        operation = operationOrOpts;
+        opts = maybeOpts;
+      } else {
+        operation = nameOrOperation;
+        opts = operationOrOpts;
+        name = opts.key ?? "step";
+      }
+      const startTime = clock();
+      const invocation = {
+        name,
+        key: "key" in opts ? opts.key : void 0,
+        order: invocations.length,
+        timestamp: startTime
+      };
+      if (recordInvocations) {
+        invocations.push(invocation);
+      }
+      const outcome = getNextOutcome(name);
+      if (outcome) {
+        invocation.durationMs = clock() - startTime;
+        switch (outcome.type) {
+          case "ok":
+            invocation.result = ok2(outcome.value);
+            return outcome.value;
+          case "err":
+            invocation.result = err(outcome.error);
+            throw { __earlyExit: true, error: outcome.error };
+          case "throw":
+            throw outcome.error;
+        }
+      }
+      try {
+        const value = await operation();
+        invocation.durationMs = clock() - startTime;
+        invocation.result = ok2(value);
+        return value;
+      } catch (error) {
+        invocation.durationMs = clock() - startTime;
+        const mappedError = "error" in opts ? opts.error : opts.onError(error);
+        invocation.result = err(mappedError);
+        throw { __earlyExit: true, error: mappedError };
+      }
+    };
+    return mockStep;
+  }
+  async function run2(fn) {
+    const mockStep = createMockStep();
+    try {
+      const value = await fn({ step: mockStep, deps });
+      return ok2(value);
+    } catch (error) {
+      if (isTestEarlyExit(error)) {
+        return err(error.error);
+      }
+      return err(new UnexpectedError({ cause: error }));
+    }
+  }
+  async function runWithInput(input, fn) {
+    const mockStep = createMockStep();
+    try {
+      const value = await fn({ step: mockStep, deps, input });
+      return ok2(value);
+    } catch (error) {
+      if (isTestEarlyExit(error)) {
+        return err(error.error);
+      }
+      return err(new UnexpectedError({ cause: error }));
+    }
+  }
+  function getInvocations() {
+    return [...invocations];
+  }
+  function assertSteps(expectedNames) {
+    const actualNames = invocations.map((inv) => inv.name ?? inv.key ?? "unnamed").filter((n) => n !== "unnamed");
+    const passed = JSON.stringify(actualNames) === JSON.stringify(expectedNames);
+    return {
+      passed,
+      message: passed ? `Steps invoked in order: ${expectedNames.join(", ")}` : `Expected steps [${expectedNames.join(", ")}] but got [${actualNames.join(", ")}]`,
+      expected: expectedNames,
+      actual: actualNames
+    };
+  }
+  function assertStepCalled(nameOrKey) {
+    const found = invocations.some(
+      (inv) => inv.name === nameOrKey || inv.key === nameOrKey
+    );
+    return {
+      passed: found,
+      message: found ? `Step "${nameOrKey}" was invoked` : `Step "${nameOrKey}" was NOT invoked`,
+      expected: nameOrKey,
+      actual: found
+    };
+  }
+  function assertStepNotCalled(nameOrKey) {
+    const found = invocations.some(
+      (inv) => inv.name === nameOrKey || inv.key === nameOrKey
+    );
+    return {
+      passed: !found,
+      message: !found ? `Step "${nameOrKey}" was correctly NOT invoked` : `Step "${nameOrKey}" was invoked but should not have been`,
+      expected: "not called",
+      actual: found ? "called" : "not called"
+    };
+  }
+  function assertResult(result, expected) {
+    const passed = result.ok === expected.ok && (result.ok ? JSON.stringify(result.value) === JSON.stringify(expected.value) : JSON.stringify(result.error) === JSON.stringify(expected.error));
+    return {
+      passed,
+      message: passed ? `Result matches expected` : `Result does not match expected`,
+      expected,
+      actual: result
+    };
+  }
+  function reset() {
+    scriptedOutcomes = [];
+    namedOutcomes.clear();
+    invocationIndex = 0;
+    invocations = [];
+  }
+  return {
+    script,
+    scriptStep,
+    run: run2,
+    runWithInput,
+    getInvocations,
+    assertSteps,
+    assertStepCalled,
+    assertStepNotCalled,
+    assertResult,
+    reset
+  };
+}
+function createMockFn() {
+  let defaultReturn;
+  const returnQueue = [];
+  const calls = [];
+  const fn = ((...args) => {
+    calls.push(args);
+    if (returnQueue.length > 0) {
+      return Promise.resolve(returnQueue.shift());
+    }
+    if (defaultReturn) {
+      return Promise.resolve(defaultReturn);
+    }
+    throw new Error("Mock function called without configured return value");
+  });
+  fn.returns = (result) => {
+    defaultReturn = result;
+    return fn;
+  };
+  fn.returnsOnce = (result) => {
+    returnQueue.push(result);
+    return fn;
+  };
+  fn.getCalls = () => [...calls];
+  fn.getCallCount = () => calls.length;
+  fn.reset = () => {
+    defaultReturn = void 0;
+    returnQueue.length = 0;
+    calls.length = 0;
+  };
+  return fn;
+}
+function createSnapshot(invocations, result, events) {
+  const totalDuration = invocations.reduce(
+    (sum, inv) => sum + (inv.durationMs ?? 0),
+    0
+  );
+  return {
+    invocations: invocations.map((inv) => ({
+      ...inv,
+      // Normalize timestamps for comparison
+      timestamp: 0
+    })),
+    result,
+    events: events?.map((e) => ({
+      ...e,
+      ts: 0
+      // Normalize timestamps
+    })),
+    durationMs: totalDuration
+  };
+}
+function compareSnapshots(snapshot1, snapshot2) {
+  const differences = [];
+  if (snapshot1.invocations.length !== snapshot2.invocations.length) {
+    differences.push(
+      `Invocation count: ${snapshot1.invocations.length} vs ${snapshot2.invocations.length}`
+    );
+  }
+  const maxLen = Math.max(
+    snapshot1.invocations.length,
+    snapshot2.invocations.length
+  );
+  for (let i = 0; i < maxLen; i++) {
+    const inv1 = snapshot1.invocations[i];
+    const inv2 = snapshot2.invocations[i];
+    if (!inv1) {
+      differences.push(`Step ${i}: missing in first snapshot`);
+      continue;
+    }
+    if (!inv2) {
+      differences.push(`Step ${i}: missing in second snapshot`);
+      continue;
+    }
+    if (inv1.name !== inv2.name) {
+      differences.push(`Step ${i} name: "${inv1.name}" vs "${inv2.name}"`);
+    }
+    if (inv1.key !== inv2.key) {
+      differences.push(`Step ${i} key: "${inv1.key}" vs "${inv2.key}"`);
+    }
+    if (inv1.result?.ok !== inv2.result?.ok) {
+      differences.push(
+        `Step ${i} result: ${inv1.result?.ok ? "ok" : "err"} vs ${inv2.result?.ok ? "ok" : "err"}`
+      );
+    }
+  }
+  if (snapshot1.result.ok !== snapshot2.result.ok) {
+    differences.push(
+      `Final result: ${snapshot1.result.ok ? "ok" : "err"} vs ${snapshot2.result.ok ? "ok" : "err"}`
+    );
+  }
+  return {
+    equal: differences.length === 0,
+    differences
+  };
+}
+function createTestClock(startTime = 0) {
+  let currentTime = startTime;
+  return {
+    now: () => currentTime,
+    advance: (ms) => {
+      currentTime += ms;
+    },
+    set: (time) => {
+      currentTime = time;
+    },
+    reset: () => {
+      currentTime = startTime;
+    }
+  };
+}
+function okOutcome(value) {
+  return { type: "ok", value };
+}
+function errOutcome(error) {
+  return { type: "err", error };
+}
+function throwOutcome(error) {
+  return { type: "throw", error };
+}
+function createSagaHarness(deps, options = {}) {
+  const { clock = Date.now } = options;
+  const baseHarness = createWorkflowHarness(deps, options);
+  let compensations = [];
+  let compensationStack = [];
+  async function runSaga(fn) {
+    compensations = [];
+    compensationStack = [];
+    const sagaContext = {
+      step: async (operation, stepOptions) => {
+        try {
+          const result = await baseHarness.run(
+            async ({ step }) => step("saga-step", operation)
+          );
+          if (!result.ok) {
+            await runCompensations();
+            throw { __earlyExit: true, error: result.error };
+          }
+          if (stepOptions?.compensate) {
+            compensationStack.push({
+              value: result.value,
+              compensate: stepOptions.compensate
+            });
+          }
+          return result.value;
+        } catch (error) {
+          if (compensationStack.length > 0) {
+            await runCompensations();
+          }
+          throw error;
+        }
+      }
+    };
+    async function runCompensations() {
+      const toCompensate = [...compensationStack].reverse();
+      compensationStack = [];
+      for (const { name, value, compensate } of toCompensate) {
+        try {
+          await compensate(value);
+          compensations.push({
+            stepName: name,
+            order: compensations.length,
+            value,
+            timestamp: clock()
+          });
+        } catch (error) {
+          console.error(`Compensation failed for step "${name}":`, error);
+        }
+      }
+    }
+    try {
+      const value = await fn({ saga: sagaContext, deps });
+      return ok2(value);
+    } catch (error) {
+      if (isTestEarlyExit(error)) {
+        return err(error.error);
+      }
+      await runCompensations();
+      return err(new UnexpectedError({ cause: error }));
+    }
+  }
+  function getCompensations() {
+    return [...compensations];
+  }
+  function assertCompensationOrder(expectedStepNames) {
+    const actualNames = compensations.map((c) => c.stepName);
+    const passed = JSON.stringify(actualNames) === JSON.stringify(expectedStepNames);
+    return {
+      passed,
+      message: passed ? `Compensations ran in order: ${expectedStepNames.join(" \u2192 ")}` : `Expected compensations [${expectedStepNames.join(" \u2192 ")}] but got [${actualNames.join(" \u2192 ")}]`,
+      expected: expectedStepNames,
+      actual: actualNames
+    };
+  }
+  function assertCompensated(stepName) {
+    const found = compensations.some((c) => c.stepName === stepName);
+    return {
+      passed: found,
+      message: found ? `Step "${stepName}" was compensated` : `Step "${stepName}" was NOT compensated`,
+      expected: stepName,
+      actual: found
+    };
+  }
+  function assertNotCompensated(stepName) {
+    const found = compensations.some((c) => c.stepName === stepName);
+    return {
+      passed: !found,
+      message: !found ? `Step "${stepName}" was correctly NOT compensated` : `Step "${stepName}" was compensated but should not have been`,
+      expected: "not compensated",
+      actual: found ? "compensated" : "not compensated"
+    };
+  }
+  const originalReset = baseHarness.reset;
+  function reset() {
+    originalReset();
+    compensations = [];
+    compensationStack = [];
+  }
+  return {
+    ...baseHarness,
+    reset,
+    getCompensations,
+    assertCompensationOrder,
+    assertCompensated,
+    assertNotCompensated,
+    runSaga
+  };
+}
+function assertEventSequence(events, expectedSequence, options = {}) {
+  const { strict = true } = options;
+  const expected = expectedSequence.map((s) => {
+    const [type, name] = s.split(":");
+    return { type, name };
+  });
+  const relevantEvents = strict ? events : events.filter((e) => expected.some((exp) => e.type === exp.type));
+  const actual = relevantEvents.map((e) => {
+    const name = "name" in e ? e.name : void 0;
+    const stepKey = "stepKey" in e ? e.stepKey : void 0;
+    const identifier = name ?? stepKey;
+    return identifier ? `${e.type}:${identifier}` : e.type;
+  });
+  const passed = JSON.stringify(actual) === JSON.stringify(expectedSequence);
+  return {
+    passed,
+    message: passed ? `Event sequence matches: ${expectedSequence.join(" \u2192 ")}` : `Event sequence mismatch.
+Expected: ${expectedSequence.join(" \u2192 ")}
+Actual: ${actual.join(" \u2192 ")}`,
+    expected: expectedSequence,
+    actual
+  };
+}
+function assertEventEmitted(events, expected) {
+  const found = events.find((e) => {
+    return Object.entries(expected).every(([key, value]) => {
+      const eventValue = e[key];
+      if (typeof value === "object" && value !== null) {
+        return JSON.stringify(eventValue) === JSON.stringify(value);
+      }
+      return eventValue === value;
+    });
+  });
+  return {
+    passed: !!found,
+    message: found ? `Event matching ${JSON.stringify(expected)} was emitted` : `No event matching ${JSON.stringify(expected)} was found`,
+    expected,
+    actual: found ?? "not found"
+  };
+}
+function assertEventNotEmitted(events, expected) {
+  const result = assertEventEmitted(events, expected);
+  return {
+    passed: !result.passed,
+    message: result.passed ? `Event matching ${JSON.stringify(expected)} was found but should not have been` : `Correctly, no event matching ${JSON.stringify(expected)} was emitted`,
+    expected: "not emitted",
+    actual: result.actual
+  };
+}
+function expectOk(result) {
+  if (!result.ok) {
+    throw new Error(
+      `Expected Ok result, got Err: ${JSON.stringify(result.error, null, 2)}`
+    );
+  }
+}
+function expectErr(result) {
+  if (result.ok) {
+    throw new Error(
+      `Expected Err result, got Ok: ${JSON.stringify(result.value, null, 2)}`
+    );
+  }
+}
+function unwrapOk(result) {
+  expectOk(result);
+  return result.value;
+}
+function unwrapErr(result) {
+  expectErr(result);
+  return result.error;
+}
+async function unwrapOkAsync(result) {
+  return unwrapOk(await result);
+}
+async function unwrapErrAsync(result) {
+  return unwrapErr(await result);
+}
+function formatResult(result) {
+  if (isOk(result)) {
+    return `Ok(${formatValue(result.value)})`;
+  }
+  return `Err(${formatValue(result.error)})`;
+}
+function formatValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return `'${value}'`;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (typeof value === "function") return `[Function: ${value.name || "anonymous"}]`;
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    if (value.length <= 3) return `[${value.map(formatValue).join(", ")}]`;
+    return `[${value.slice(0, 3).map(formatValue).join(", ")}, ... (${value.length} items)]`;
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj);
+    if (keys.length === 0) return "{}";
+    if (keys.length <= 4) {
+      const entries = keys.map((k) => `${k}: ${formatValue(obj[k])}`).join(", ");
+      return `{ ${entries} }`;
+    }
+    const sample = keys.slice(0, 3).map((k) => `${k}: ${formatValue(obj[k])}`).join(", ");
+    return `{ ${sample}, ... (${keys.length} keys) }`;
+  }
+  return String(value);
+}
+function formatEvent(event) {
+  const type = event.type;
+  const name = "name" in event ? event.name : void 0;
+  const stepKey = "stepKey" in event ? event.stepKey : void 0;
+  const identifier = name ?? stepKey;
+  if (identifier) {
+    return `${type}:${identifier}`;
+  }
+  return type;
+}
+function formatEvents(events) {
+  return events.map(formatEvent).join(" \u2192 ");
+}
+export {
+  assertEventEmitted,
+  assertEventNotEmitted,
+  assertEventSequence,
+  compareSnapshots,
+  createMockFn,
+  createSagaHarness,
+  createSnapshot,
+  createTestClock,
+  createWorkflowHarness,
+  errOutcome,
+  expectErr,
+  expectOk,
+  formatEvent,
+  formatEvents,
+  formatResult,
+  okOutcome,
+  testWorkflow,
+  throwOutcome,
+  unwrapErr,
+  unwrapErrAsync,
+  unwrapOk,
+  unwrapOkAsync
+};
 //# sourceMappingURL=testing.js.map