awaitly 1.34.0 → 2.0.0

package/dist/testing.cjs

@@ -1,13 +1,4207 @@
-"use strict";var Ve=Object.defineProperty;var Jt=Object.getOwnPropertyDescriptor;var zt=Object.getOwnPropertyNames;var Yt=Object.prototype.hasOwnProperty;var Gt=(e,t)=>{for(var r in t)Ve(e,r,{get:t[r],enumerable:!0})},Xt=(e,t,r,m)=>{if(t&&typeof t=="object"||typeof t=="function")for(let a of zt(t))!Yt.call(e,a)&&a!==r&&Ve(e,a,{get:()=>t[a],enumerable:!(m=Jt(t,a))||m.enumerable});return e};var Qt=e=>Xt(Ve({},"__esModule",{value:!0}),e);var yr={};Gt(yr,{assertEventEmitted:()=>nt,assertEventNotEmitted:()=>Lt,assertEventSequence:()=>$t,compareSnapshots:()=>Wt,createMockFn:()=>Mt,createSagaHarness:()=>Kt,createSnapshot:()=>It,createTestClock:()=>Ut,createWorkflowHarness:()=>rt,errOutcome:()=>jt,expectErr:()=>st,expectOk:()=>ot,formatEvent:()=>ut,formatEvents:()=>qt,formatResult:()=>Ht,okOutcome:()=>Nt,testWorkflow:()=>et,throwOutcome:()=>Ft,unwrapErr:()=>it,unwrapErrAsync:()=>Vt,unwrapOk:()=>at,unwrapOkAsync:()=>Bt});module.exports=Qt(yr);var Zt={"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 ct(e){return`https://jagreehal.github.io/awaitly/rules/#${e}`}var gr=Object.keys(Zt);var Ue=class extends Error{_tag};function ye(e,t){return class extends Ue{_tag=e;constructor(r,m){let a=t?.message?t.message(r??{}):e;if(super(a),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:ct(t.slug),enumerable:!0,writable:!1,configurable:!1})}if(Object.setPrototypeOf(this,new.target.prototype),r&&typeof r=="object"){let d;if(t?.slug!==void 0){let{_tag:i,name:Y,message:b,stack:x,code:G,hint:l,docsUrl:q,...Q}=r;d=Q}else{let{_tag:i,name:Y,message:b,stack:x,...G}=r;d=G}let S=Object.prototype.hasOwnProperty.call(d,"cause"),g=S?d.cause:void 0;S&&delete d.cause;let I=m?.cause!==void 0;if(S&&I)throw new TypeError("TaggedError: cannot provide 'cause' in props when also setting ErrorOptions.cause");Object.assign(this,d),S&&(this.cause=g),I&&(this.cause=m?.cause)}else m?.cause!==void 0&&(this.cause=m.cause)}}}Object.defineProperty(ye,Symbol.hasInstance,{value:e=>e instanceof Ue});(a=>{function e(d){return d instanceof Error}a.isError=e;function t(d){return d instanceof Ue}a.isTaggedError=t;function r(d,S){let g=d._tag,I=S[g];return I(d)}a.match=r;function m(d,S,g){let I=d._tag,i=S[I];return i?i(d):g(d)}a.matchPartial=m})(ye||={});var pt=class extends ye("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`}){},mt=class extends ye("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`}){},dt=class extends ye("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`:""}`}){},ft=class extends ye("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`:""}`}){},Et=class extends ye("ValidationError",{message:t=>`ValidationError: Invalid ${t.field} - ${t.reason}`}){},wt=class extends ye("NotFoundError",{message:t=>t.id?`NotFoundError: ${t.resource} with id ${t.id} not found`:`NotFoundError: ${t.resource} not found`}){},yt=class extends ye("UnauthorizedError",{message:t=>t.reason?`UnauthorizedError: ${t.reason}`:t.action&&t.resource?`UnauthorizedError: Not authorized to ${t.action} ${t.resource}`:"UnauthorizedError: Access denied"}){},kt=class extends ye("NetworkError",{message:t=>t.url?`NetworkError: ${t.reason} (${t.url})`:`NetworkError: ${t.reason}`}){},gt=class extends ye("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}`}){},Se=class extends ye("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 er(e){let t=e.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i);if(!t)return;let r=parseFloat(t[1]),m=t[2].toLowerCase();return{_tag:"Duration",millis:r*({ms:1,s:1e3,m:6e4,h:36e5,d:864e5}[m]??1)}}function Ke(e){return new Se({cause:e})}function X(e){return{ok:!0,value:e}}function U(e,t){let r=t?.cause;return{ok:!1,error:e,...r!==void 0?{cause:r}:{}}}var St=e=>e.ok;var ht=e=>e instanceof Se||typeof e=="object"&&e!==null&&"_tag"in e&&e._tag==="UnexpectedError";function tr(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 r=t._tag.trim();if(r)return r}if(typeof t.tag=="string"){let r=t.tag.trim();if(r)return r}if(typeof t.code=="string"){let r=t.code.trim();if(r)return r}else if(typeof t.code=="number")return String(t.code);if(e instanceof Error&&e.name){let r=e.name.trim();if(r)return r}}return"unknown"}function rr(e,t){if(!(!t||!e))return t[e]}function Je(e){let{intent:t,domain:r,owner:m,tags:a,stateChanges:d,emits:S,calls:g}=e;if(!t&&!r&&!m&&!a?.length&&!d?.length&&!S?.length&&!g?.length)return;let I={};return t&&(I.intent=t),r&&(I.domain=r),m&&(I.owner=m),a?.length&&(I.tags=a),d?.length&&(I.stateChanges=d),S?.length&&(I.emits=S),g?.length&&(I.calls=g),I}function ge(e,t,r,m,a){let d=tr(e),S=rr(d,t),g={tag:d,origin:r};return S!==void 0&&(g.classification=S),m!==void 0&&(g.attempt=m),a!==void 0&&(g.cumulativeDurationMs=a),g}var _e=Symbol.for("step_timeout_marker");function Tt(e){return typeof e!="object"||e===null?!1:e.type==="STEP_TIMEOUT"?!0:_e in e}function nr(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(_e in e)return e[_e]}}var Ct=Symbol("early-exit");function De(e,t){return{[Ct]:!0,error:e,meta:t}}function ve(e){return typeof e=="object"&&e!==null&&e[Ct]===!0}var bt=Symbol("mapper-exception");function Ae(e){return{[bt]:!0,thrown:e}}function or(e){return typeof e=="object"&&e!==null&&e[bt]===!0}function He(e,t){let{backoff:r,initialDelay:m,maxDelay:a,jitter:d}=t,S;switch(r){case"fixed":S=m;break;case"linear":S=m*e;break;case"exponential":S=m*Math.pow(2,e-1);break}if(S=Math.min(S,a),d){let g=S*.25*Math.random();S=S+g}return Math.floor(S)}function qe(e){return new Promise(t=>setTimeout(t,e))}var Rt=Symbol("timeout"),je=Symbol("timeout-option");function sr(e){return typeof e=="object"&&e!==null&&e[je]===!0}async function ar(e,t,r,m){let a=new AbortController,d=t.onTimeout??"error",S=()=>typeof d=="function"?d({name:r.name,key:r.key,ms:t.ms}):t.error??{type:"STEP_TIMEOUT",stepName:r.name,stepKey:r.key,timeoutMs:t.ms,attempt:r.attempt},g;m?.aborted&&a.abort(m.reason);let I;m&&!m.aborted&&(I=()=>a.abort(m.reason),m.addEventListener("abort",I,{once:!0}));let i=new Promise((b,x)=>{g=setTimeout(()=>{if(d!=="disconnect"&&a.abort(),d==="option"){x({[je]:!0,ms:t.ms});return}x({[Rt]:!0,error:S()})},t.ms)}),Y;t.signal?Y=Promise.resolve(e(a.signal)):Y=Promise.resolve(e());try{return await Promise.race([Y,i])}catch(b){if(typeof b=="object"&&b!==null&&b[je]===!0)throw{[je]:!0,ms:t.ms};if(typeof b=="object"&&b!==null&&b[Rt]===!0){d==="disconnect"&&Y.catch(()=>{});let x=b.error;if(typeof x=="object"&&x!==null&&x.type!=="STEP_TIMEOUT"){let G={timeoutMs:t.ms,stepName:r.name,stepKey:r.key,attempt:r.attempt};_e in x?x[_e]=G:Object.defineProperty(x,_e,{value:G,enumerable:!1,writable:!0,configurable:!1})}throw x}throw b}finally{clearTimeout(g),I&&m&&m.removeEventListener("abort",I)}}var Oe={backoff:"exponential",initialDelay:100,maxDelay:3e4,jitter:!0,shouldRetry:()=>!0,onRetry:()=>{}};async function Fe(e,t){let{onError:r,onEvent:m,catchUnexpected:a,workflowId:d,workflowName:S,context:g,_workflowSignal:I}=t&&typeof t=="object"?t:{},i=d??crypto.randomUUID(),Y=a??Ke,b=[],x=0,G=f=>f??`step_${++x}`,l=f=>{let ee=f.context!==void 0||g===void 0?f:{...f,context:g},ae=S!==void 0&&ee.workflowName===void 0?{...ee,workflowName:S}:ee;if(ae.type==="step_success"){let me=ae.stepId;for(let ue=b.length-1;ue>=0;ue--){let le=b[ue];if(le.type==="race"&&!le.winnerId){le.winnerId=me;break}}}m?.(ae,g)},q=De,Q=f=>ve(f),W=(f,ee)=>f,fe=f=>typeof f=="function"?!1:!!(f&&typeof f=="object"&&"ok"in f||f&&typeof f=="object"&&"then"in f&&typeof f.then=="function");try{let ee=function(c){let y={};for(let[n,u]of Object.entries(c))if(typeof u=="function")y[n]=u;else if(u&&typeof u=="object"&&"fn"in u)y[n]=u.fn;else throw new TypeError(`step.all: operation "${n}" must be a function or { fn, errors? } object`);return y},ae=function(c,y){let n=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let u=performance.now(),o=!1;b.push({scopeId:n,type:"parallel"});let k=()=>{if(o)return;o=!0;let h=b.findIndex(A=>A.scopeId===n);h!==-1&&b.splice(h,1),l({type:"scope_end",workflowId:i,scopeId:n,ts:Date.now(),durationMs:performance.now()-u})};l({type:"scope_start",workflowId:i,scopeId:n,scopeType:"parallel",name:c,ts:Date.now()});try{let h=await y();if(k(),!h.ok)throw r?.(h.error,c,g),q(h.error,{origin:"result",resultCause:h.cause});return h.value}catch(h){throw k(),h}})()},me=function(c,y){let n=Object.keys(c),u=y.name??`Parallel(${n.join(", ")})`,o=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let k=performance.now(),h=!1;b.push({scopeId:o,type:"parallel"});let A=()=>{if(h)return;h=!0;let p=b.findIndex(_=>_.scopeId===o);p!==-1&&b.splice(p,1),l({type:"scope_end",workflowId:i,scopeId:o,ts:Date.now(),durationMs:performance.now()-k})};l({type:"scope_start",workflowId:i,scopeId:o,scopeType:"parallel",name:u,ts:Date.now()});try{let p=await new Promise(F=>{if(n.length===0){F([]);return}let J=!1,re=n.length,N=new Array(n.length);for(let Z=0;Z<n.length;Z++){let K=n[Z],H=Z;Promise.resolve(c[K]()).catch(P=>U({type:"PROMISE_REJECTED",cause:P},{cause:{type:"PROMISE_REJECTION",reason:P}})).then(P=>{if(!J){if(!P.ok){J=!0,F([{key:K,result:P}]);return}N[H]={key:K,result:P},re--,re===0&&F(N)}})}});A();let _={};for(let{key:F,result:J}of p){if(!J.ok)throw r?.(J.error,F,g),q(J.error,{origin:"result",resultCause:J.cause});_[F]=J.value}return _}catch(p){throw A(),p}})()};var ke=ee,$=ae,V=me;let f=(c,y,n)=>(async()=>{if(typeof c!="string"||c.length===0)throw new Error('[awaitly] step() requires an explicit string ID as the first argument. Example: step("fetchUser", () => fetchUser(id))');let u=n??{},o=Je(u),k=c,h=u.key??c,A=u.key??c,{description:p,retry:_,timeout:F}=u,J=G(h),re=m,N=re?performance.now():0,K=fe(y)?()=>y:y,P={attempts:Math.max(1,_?.attempts??1),backoff:_?.backoff??Oe.backoff,initialDelay:_?.initialDelay??Oe.initialDelay,maxDelay:_?.maxDelay??Oe.maxDelay,jitter:_?.jitter??Oe.jitter,shouldRetry:_?.shouldRetry??Oe.shouldRetry,onRetry:_?.onRetry??Oe.onRetry};m&&l({type:"step_start",workflowId:i,stepId:J,stepKey:h,name:k,description:p,ts:Date.now(),...o&&{metadata:o}});let Re;for(let s=1;s<=P.attempts;s++){let w=re?performance.now():0;try{let E;if(F?E=await ar(K,F,{name:k,key:h,attempt:s},I):E=await K(),E.ok){let z=performance.now()-N;return l({type:"step_success",workflowId:i,stepId:J,stepKey:h,name:k,description:p,ts:Date.now(),durationMs:z,...o&&{metadata:o}}),A&&l({type:"step_complete",workflowId:i,stepKey:A,name:k,description:p,ts:Date.now(),durationMs:z,result:E,...o&&{metadata:o}}),E.value}if(Re=E,s<P.attempts&&P.shouldRetry(E.error,s)){let z=He(s,P);l({type:"step_retry",workflowId:i,stepId:J,stepKey:h,name:k,ts:Date.now(),attempt:s+1,maxAttempts:P.attempts,delayMs:z,error:E.error,...o&&{metadata:o},diagnostics:ge(E.error,u.errorMeta,"result",s,performance.now()-N)}),P.onRetry(E.error,s,z),await qe(z);continue}P.attempts>1&&l({type:"step_retries_exhausted",workflowId:i,stepId:J,stepKey:h,name:k,ts:Date.now(),durationMs:performance.now()-N,attempts:s,lastError:E.error,...o&&{metadata:o},diagnostics:ge(E.error,u.errorMeta,"result",s,performance.now()-N)});break}catch(E){let z=performance.now()-w;if(sr(E)){let C=E.ms;l({type:"step_timeout",workflowId:i,stepId:J,stepKey:h,name:k,ts:Date.now(),timeoutMs:C,attempt:s,...o&&{metadata:o},diagnostics:ge(E,u.errorMeta,"timeout",s)}),l({type:"step_success",workflowId:i,stepId:J,stepKey:h,name:k,description:p,ts:Date.now(),durationMs:performance.now()-N,...o&&{metadata:o}}),A&&l({type:"step_complete",workflowId:i,stepKey:A,name:k,description:p,ts:Date.now(),durationMs:performance.now()-N,result:X(void 0),...o&&{metadata:o}});return}if(Q(E))throw l({type:"step_aborted",workflowId:i,stepId:J,stepKey:h,name:k,description:p,ts:Date.now(),durationMs:z,...o&&{metadata:o}}),E;if(Tt(E)){let C=nr(E),D=F?.ms??C?.timeoutMs??0;if(l({type:"step_timeout",workflowId:i,stepId:J,stepKey:h,name:k,ts:Date.now(),timeoutMs:D,attempt:s,...o&&{metadata:o},diagnostics:ge(E,u.errorMeta,"timeout",s)}),s<P.attempts&&P.shouldRetry(E,s)){let j=He(s,P);l({type:"step_retry",workflowId:i,stepId:J,stepKey:h,name:k,ts:Date.now(),attempt:s+1,maxAttempts:P.attempts,delayMs:j,error:E,...o&&{metadata:o},diagnostics:ge(E,u.errorMeta,"timeout",s,performance.now()-N)}),P.onRetry(E,s,j),await qe(j);continue}P.attempts>1&&l({type:"step_retries_exhausted",workflowId:i,stepId:J,stepKey:h,name:k,ts:Date.now(),durationMs:performance.now()-N,attempts:s,lastError:E,...o&&{metadata:o},diagnostics:ge(E,u.errorMeta,"timeout",s,performance.now()-N)});let O=performance.now()-N;throw l({type:"step_error",workflowId:i,stepId:J,stepKey:h,name:k,description:p,ts:Date.now(),durationMs:O,error:E,...o&&{metadata:o},diagnostics:ge(E,u.errorMeta,"timeout",s,O)}),A&&l({type:"step_complete",workflowId:i,stepKey:A,name:k,description:p,ts:Date.now(),durationMs:O,result:U(E,{cause:E}),meta:{origin:"throw",thrown:E},...o&&{metadata:o}}),r?.(E,k,g),q(E,{origin:"throw",thrown:E})}if(s<P.attempts&&P.shouldRetry(E,s)){let C=He(s,P);l({type:"step_retry",workflowId:i,stepId:J,stepKey:h,name:k,ts:Date.now(),attempt:s+1,maxAttempts:P.attempts,delayMs:C,error:E,...o&&{metadata:o},diagnostics:ge(E,u.errorMeta,"throw",s,performance.now()-N)}),P.onRetry(E,s,C),await qe(C);continue}P.attempts>1&&!Tt(E)&&l({type:"step_retries_exhausted",workflowId:i,stepId:J,stepKey:h,name:k,ts:Date.now(),durationMs:performance.now()-N,attempts:s,lastError:E,...o&&{metadata:o},diagnostics:ge(E,u.errorMeta,"throw",s,performance.now()-N)});let T=performance.now()-N,v;try{v=Y(E)}catch(C){throw Ae(C)}throw l({type:"step_error",workflowId:i,stepId:J,stepKey:h,name:k,description:p,ts:Date.now(),durationMs:T,error:v,...o&&{metadata:o},diagnostics:ge(E,u.errorMeta,"throw",s,T)}),A&&l({type:"step_complete",workflowId:i,stepKey:A,name:k,description:p,ts:Date.now(),durationMs:T,result:U(v,{cause:E}),meta:{origin:"throw",thrown:E},...o&&{metadata:o}}),r?.(v,k,g),q(v,{origin:"throw",thrown:E})}}let Te=Re,ce=performance.now()-N,he=W(Te.error,{origin:"result",resultCause:Te.cause});throw l({type:"step_error",workflowId:i,stepId:J,stepKey:h,name:k,description:p,ts:Date.now(),durationMs:ce,error:he,...o&&{metadata:o},diagnostics:ge(Te.error,u.errorMeta,"result",P.attempts,ce)}),A&&l({type:"step_complete",workflowId:i,stepKey:A,name:k,description:p,ts:Date.now(),durationMs:ce,result:Te,meta:{origin:"result",resultCause:Te.cause},...o&&{metadata:o}}),r?.(he,k,g),q(he,{origin:"result",resultCause:Te.cause})})();f.try=(c,y,n)=>{if(typeof c!="string"||c.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 u="error"in n?()=>n.error:n.onError;if(n.retry||n.timeout)return f.retry(c,async()=>{try{return X(await y())}catch(p){return U(u(p),{cause:p})}},{attempts:n.retry?.attempts??1,...n.retry??{},key:n.key,timeout:n.timeout});let o=n.key??c,k=c,h=c,A=m;return(async()=>{let p=A?performance.now():0;m&&l({type:"step_start",workflowId:i,stepId:h,stepKey:o,name:k,ts:Date.now()});try{let _=await y(),F=performance.now()-p;return l({type:"step_success",workflowId:i,stepId:h,stepKey:o,name:k,ts:Date.now(),durationMs:F}),o&&l({type:"step_complete",workflowId:i,stepKey:o,name:k,ts:Date.now(),durationMs:F,result:X(_)}),_}catch(_){let F=u(_),J=performance.now()-p,re=W(F,{origin:"throw",thrown:_});throw l({type:"step_error",workflowId:i,stepId:h,stepKey:o,name:k,ts:Date.now(),durationMs:J,error:re}),o&&l({type:"step_complete",workflowId:i,stepKey:o,name:k,ts:Date.now(),durationMs:J,result:U(F,{cause:_}),meta:{origin:"throw",thrown:_}}),r?.(re,k,g),q(re,{origin:"throw",thrown:_})}})()},f.fromResult=(c,y,n)=>{if(typeof c!="string"||c.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 u=n.key??c,o=c,k=c,h="error"in n?()=>n.error:n.onError,A=m;return(async()=>{let p=A?performance.now():0;m&&l({type:"step_start",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now()});let _=await y();if(_.ok){let F=performance.now()-p;return l({type:"step_success",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:F}),u&&l({type:"step_complete",workflowId:i,stepKey:u,name:o,ts:Date.now(),durationMs:F,result:X(_.value)}),_.value}else{let F=h(_.error),J=performance.now()-p,re=W(F,{origin:"result",resultCause:_.error});throw l({type:"step_error",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:J,error:re}),u&&l({type:"step_complete",workflowId:i,stepKey:u,name:o,ts:Date.now(),durationMs:J,result:U(F,{cause:_.error}),meta:{origin:"result",resultCause:_.error}}),r?.(re,o,g),q(re,{origin:"result",resultCause:_.error})}})()},f.fromNullable=(c,y,n,u)=>{if(typeof c!="string"||c.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 f(c,async()=>{let o=await y();return o!=null?X(o):U(n())},u)},f.retry=(c,y,n)=>{if(typeof c!="string"||c.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 f(c,y,{key:n.key??c,retry:{attempts:n.attempts,backoff:n.backoff,initialDelay:n.initialDelay,maxDelay:n.maxDelay,jitter:n.jitter,shouldRetry:n.shouldRetry,onRetry:n.onRetry},timeout:n.timeout})},f.withTimeout=(c,y,n)=>{if(typeof c!="string"||c.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 f(c,y,{key:n.key??c,timeout:n})},f.sleep=(c,y,n)=>{if(typeof c!="string"||c.length===0)throw new Error('[awaitly] step.sleep() requires an explicit string ID as the first argument. Example: step.sleep("delay", "5s")');let u=typeof y=="string"?er(y):y;if(!u)throw new Error(`step.sleep: invalid duration '${y}'`);let o=u.millis,k=n?.signal;return f(c,async()=>{if(I?.aborted||k?.aborted){let h=new Error("Sleep aborted");throw h.name="AbortError",h}return new Promise((h,A)=>{let p={timeoutId:void 0},_=()=>{p.timeoutId&&clearTimeout(p.timeoutId);let F=new Error("Sleep aborted");F.name="AbortError",A(F)};I?.addEventListener("abort",_,{once:!0}),k?.addEventListener("abort",_,{once:!0}),p.timeoutId=setTimeout(()=>{I?.removeEventListener("abort",_),k?.removeEventListener("abort",_),h(X(void 0))},o)})},{key:n?.key??c,description:n?.description})},f.all=((...c)=>{if(typeof c[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 y=c[0],n=c[1];if(typeof n=="function")return ae(y,n);if(n&&typeof n=="object"&&!Array.isArray(n)){let o=ee(n);return me(o,{name:y})}throw new TypeError("step.all(name, ...): second argument must be a function (array form) or an object of operations (object form).")}),f.race=(c,y)=>{let n=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let u=performance.now(),o=!1,k={scopeId:n,type:"race",winnerId:void 0};b.push(k);let h=()=>{if(o)return;o=!0;let A=b.findIndex(p=>p.scopeId===n);A!==-1&&b.splice(A,1),l({type:"scope_end",workflowId:i,scopeId:n,ts:Date.now(),durationMs:performance.now()-u,winnerId:k.winnerId})};l({type:"scope_start",workflowId:i,scopeId:n,scopeType:"race",name:c,ts:Date.now()});try{let A=await y();if(h(),!A.ok)throw r?.(A.error,c,g),q(A.error,{origin:"result",resultCause:A.cause});return A.value}catch(A){throw h(),A}})()},f.if=(c,y,n)=>n(),f.label=f.if,f.branch=async(c,y)=>{let{condition:n,then:u,else:o}=y;if(n())return await u();if(o)return await o()},f.arm=(c,y)=>({fn:c,errors:y}),f.forEach=async(c,y,n)=>{let u=[],o=n.maxIterations,k=0,h="run"in n,A=Symbol.asyncIterator in y?y:(async function*(){yield*y})();for await(let p of A){if(o!==void 0&&k>=o)break;let _;h?_=await n.run(p,k):_=await n.item.handler(p,k,f),u.push(_),k++}return u},f.item=c=>({__forEachItemHandler:!0,handler:c}),f.dep=(c,y)=>y,f.workflow=(c,y,n)=>f(c,y,n),f.map=async(c,y,n,u)=>{let o=u?.concurrency??y.length;return f(c,()=>o>=y.length?xt(y.map((k,h)=>n(k,h))):(async()=>{let k=[];for(let h=0;h<y.length;h+=o){let A=y.slice(h,h+o),p=await xt(A.map((_,F)=>n(_,h+F)));if(!p.ok)return p;k.push(...p.value)}return X(k)})(),{key:u?.key})},f.withFallback=(c,y,n)=>{if(typeof c!="string"||c.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 u=n.key??c,o=c,k=G(u),h=m;return(async()=>{let A=h?performance.now():0;m&&l({type:"step_start",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now()});let p;try{p=await y()}catch(N){if(Q(N))throw l({type:"step_aborted",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:performance.now()-A}),N;let Z;try{Z=Y(N)}catch(H){throw Ae(H)}if(n.on!==void 0&&n.on!==Z){let H=performance.now()-A;throw l({type:"step_error",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:H,error:Z}),u&&l({type:"step_complete",workflowId:i,stepKey:u,name:o,ts:Date.now(),durationMs:H,result:U(Z,{cause:N}),meta:{origin:"throw",thrown:N}}),r?.(Z,o,g),q(Z,{origin:"throw",thrown:N})}let K;try{K=await n.fallback()}catch(H){if(Q(H))throw l({type:"step_aborted",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:performance.now()-A}),H;let P;try{P=Y(H)}catch(Te){throw Ae(Te)}let Re=performance.now()-A;throw l({type:"step_error",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:Re,error:P}),u&&l({type:"step_complete",workflowId:i,stepKey:u,name:o,ts:Date.now(),durationMs:Re,result:U(P,{cause:H}),meta:{origin:"throw",thrown:H}}),r?.(P,o,g),q(P,{origin:"throw",thrown:H})}if(K.ok){let H=performance.now()-A;return l({type:"step_success",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:H}),u&&l({type:"step_complete",workflowId:i,stepKey:u,name:o,ts:Date.now(),durationMs:H,result:K,meta:{origin:"fallback",fallbackUsed:!0,fallbackReason:String(Z)}}),K.value}else{let H=performance.now()-A,P=W(K.error,{origin:"result",resultCause:K.cause});throw l({type:"step_error",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:H,error:P}),u&&l({type:"step_complete",workflowId:i,stepKey:u,name:o,ts:Date.now(),durationMs:H,result:K,meta:{origin:"result",resultCause:K.cause}}),r?.(P,o,g),q(P,{origin:"result",resultCause:K.cause})}}if(p.ok){let N=performance.now()-A;return l({type:"step_success",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:N}),u&&l({type:"step_complete",workflowId:i,stepKey:u,name:o,ts:Date.now(),durationMs:N,result:p}),p.value}let _=p.error;if(n.on!==void 0&&n.on!==_){let N=performance.now()-A,Z=W(_,{origin:"result",resultCause:p.cause});throw l({type:"step_error",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:N,error:Z}),u&&l({type:"step_complete",workflowId:i,stepKey:u,name:o,ts:Date.now(),durationMs:N,result:p,meta:{origin:"result",resultCause:p.cause}}),r?.(Z,o,g),q(Z,{origin:"result",resultCause:p.cause})}let F;try{F=await n.fallback()}catch(N){if(Q(N))throw l({type:"step_aborted",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:performance.now()-A}),N;let Z;try{Z=Y(N)}catch(H){throw Ae(H)}let K=performance.now()-A;throw l({type:"step_error",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:K,error:Z}),u&&l({type:"step_complete",workflowId:i,stepKey:u,name:o,ts:Date.now(),durationMs:K,result:U(Z,{cause:N}),meta:{origin:"throw",thrown:N}}),r?.(Z,o,g),q(Z,{origin:"throw",thrown:N})}if(F.ok){let N=performance.now()-A;return l({type:"step_success",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:N}),u&&l({type:"step_complete",workflowId:i,stepKey:u,name:o,ts:Date.now(),durationMs:N,result:F,meta:{origin:"fallback",fallbackUsed:!0,fallbackReason:String(_)}}),F.value}let J=performance.now()-A,re=W(F.error,{origin:"result",resultCause:F.cause});throw l({type:"step_error",workflowId:i,stepId:k,stepKey:u,name:o,ts:Date.now(),durationMs:J,error:re}),u&&l({type:"step_complete",workflowId:i,stepKey:u,name:o,ts:Date.now(),durationMs:J,result:F,meta:{origin:"result",resultCause:F.cause}}),r?.(re,o,g),q(re,{origin:"result",resultCause:F.cause})})()},f.withResource=(c,y)=>{if(typeof c!="string"||c.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 n=c,u=c,o=G(n),k=m;return(async()=>{let h=k?performance.now():0;m&&l({type:"step_start",workflowId:i,stepId:o,stepKey:n,name:u,ts:Date.now()});let A;try{A=await y.acquire()}catch(K){if(Q(K))throw l({type:"step_aborted",workflowId:i,stepId:o,stepKey:n,name:u,ts:Date.now(),durationMs:performance.now()-h}),K;let H;try{H=Y(K)}catch(Re){throw Ae(Re)}let P=performance.now()-h;throw l({type:"step_error",workflowId:i,stepId:o,stepKey:n,name:u,ts:Date.now(),durationMs:P,error:H}),n&&l({type:"step_complete",workflowId:i,stepKey:n,name:u,ts:Date.now(),durationMs:P,result:U(H,{cause:K}),meta:{origin:"throw",thrown:K}}),r?.(H,u,g),q(H,{origin:"throw",thrown:K})}if(!A.ok){let K=performance.now()-h,H=W(A.error,{origin:"result",resultCause:A.cause});throw l({type:"step_error",workflowId:i,stepId:o,stepKey:n,name:u,ts:Date.now(),durationMs:K,error:H}),n&&l({type:"step_complete",workflowId:i,stepKey:n,name:u,ts:Date.now(),durationMs:K,result:A,meta:{origin:"result",resultCause:A.cause}}),r?.(H,u,g),q(H,{origin:"result",resultCause:A.cause})}let p=A.value,_,F,J=!1;try{_=await y.use(p)}catch(K){if(Q(K)){try{await y.release(p)}catch(H){console.warn(`[awaitly] step.withResource("${c}"): release threw after earlyExit:`,H)}throw K}F=K,J=!0}try{await y.release(p)}catch(K){console.warn(`[awaitly] step.withResource("${c}"): release threw:`,K)}if(J){let K;try{K=Y(F)}catch(P){throw Ae(P)}let H=performance.now()-h;throw l({type:"step_error",workflowId:i,stepId:o,stepKey:n,name:u,ts:Date.now(),durationMs:H,error:K}),n&&l({type:"step_complete",workflowId:i,stepKey:n,name:u,ts:Date.now(),durationMs:H,result:U(K,{cause:F}),meta:{origin:"throw",thrown:F}}),r?.(K,u,g),q(K,{origin:"throw",thrown:F})}let re=_;if(re.ok){let K=performance.now()-h;return l({type:"step_success",workflowId:i,stepId:o,stepKey:n,name:u,ts:Date.now(),durationMs:K}),n&&l({type:"step_complete",workflowId:i,stepKey:n,name:u,ts:Date.now(),durationMs:K,result:re}),re.value}let N=performance.now()-h,Z=W(re.error,{origin:"result",resultCause:re.cause});throw l({type:"step_error",workflowId:i,stepId:o,stepKey:n,name:u,ts:Date.now(),durationMs:N,error:Z}),n&&l({type:"step_complete",workflowId:i,stepKey:n,name:u,ts:Date.now(),durationMs:N,result:re,meta:{origin:"result",resultCause:re.cause}}),r?.(Z,u,g),q(Z,{origin:"result",resultCause:re.cause})})()};let le=await e({step:f});if(process.env.NODE_ENV!=="production"&&le!==null&&typeof le=="object"&&"ok"in le&&typeof le.ok=="boolean"){let c=le;(c.ok===!0&&"value"in c||c.ok===!1&&"error"in c)&&console.warn(`awaitly: Workflow executor returned a Result-like object. Return raw values, not ok() or err().
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/testing-entry.ts
+var testing_entry_exports = {};
+__export(testing_entry_exports, {
+  assertEventEmitted: () => assertEventEmitted,
+  assertEventNotEmitted: () => assertEventNotEmitted,
+  assertEventSequence: () => assertEventSequence,
+  compareSnapshots: () => compareSnapshots,
+  createMockFn: () => createMockFn,
+  createSagaHarness: () => createSagaHarness,
+  createSnapshot: () => createSnapshot,
+  createTestClock: () => createTestClock,
+  createWorkflowHarness: () => createWorkflowHarness,
+  errOutcome: () => errOutcome,
+  expectErr: () => expectErr,
+  expectOk: () => expectOk,
+  formatEvent: () => formatEvent,
+  formatEvents: () => formatEvents,
+  formatResult: () => formatResult,
+  okOutcome: () => okOutcome,
+  testWorkflow: () => testWorkflow,
+  throwOutcome: () => throwOutcome,
+  unwrapErr: () => unwrapErr,
+  unwrapErrAsync: () => unwrapErrAsync,
+  unwrapOk: () => unwrapOk,
+  unwrapOkAsync: () => unwrapOkAsync
+});
+module.exports = __toCommonJS(testing_entry_exports);
+
+// 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 X(le)}catch(f){if(or(f))throw f.thrown;if(Q(f)){let ae=f.meta.origin==="throw"?f.meta.thrown:f.meta.origin==="result"?f.meta.resultCause:void 0;return U(f.error,{cause:ae})}let ee=Y(f);return r?.(ee,"unexpected",g),U(ee,{cause:f})}}Fe.strict=(e,t)=>Fe(e,t);async function xt(e){return e.length===0?X([]):new Promise(t=>{let r=!1,m=e.length,a=new Array(e.length);for(let d=0;d<e.length;d++){let S=d;Promise.resolve(e[S]).catch(g=>U({type:"PROMISE_REJECTED",cause:g},{cause:{type:"PROMISE_REJECTION",reason:g}})).then(g=>{if(!r){if(!g.ok){r=!0,t(g);return}a[S]=g.value,m--,m===0&&t(X(a))}})}})}function vt(e){return e.type==="step_complete"}function ze(e){return typeof e=="object"&&e!==null&&e.type==="WORKFLOW_CANCELLED"}var $e=class extends Error{constructor(r,m,a){super(r);this.stepId=m;this.originalError=a;this.name="SnapshotDecodeError"}};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 ir(e){return typeof e=="object"&&e!==null&&e.__cachedMeta===!0}function be(e,t,r){return U(e,{cause:{__cachedMeta:!0,originalCause:r,meta:t}})}function Ne(e){return ir(e)?e.meta:{origin:"result",resultCause:e}}function At(){let e=new Map;return{handleEvent:t=>{vt(t)&&e.set(t.stepKey,{result:t.result,meta:t.meta})},getResumeState:()=>({steps:new Map(e)}),clear:()=>e.clear()}}var ur="STREAM_WRITE_ERROR",lr="STREAM_READ_ERROR",cr="STREAM_CLOSE_ERROR";var pr="STREAM_ENDED";function Le(e,t,r){return{type:ur,reason:e,message:t,...r!==void 0?{cause:r}:{}}}function Ge(e,t,r){return{type:lr,reason:e,message:t,...r!==void 0?{cause:r}:{}}}function Xe(e,t,r){return{type:cr,reason:e,message:t,...r!==void 0?{cause:r}:{}}}function Be(e){return{type:pr,finalPosition:e}}function Ot(e={}){let t=e.highWaterMark??16,r=e.lowWaterMark??Math.floor(t/2),m=e.onStateChange,a="flowing",d=0,S=[];function g(i){if(a!==i&&(a=i,m?.(i),i==="flowing"&&S.length>0)){let Y=S;S=[];for(let b of Y)b()}}function I(){a==="flowing"&&d>=t?g("paused"):a==="paused"&&d<=r&&g("flowing")}return{get state(){return a},get bufferedCount(){return d},get highWaterMark(){return t},get lowWaterMark(){return r},increment(){d++,I()},decrement(){d>0&&(d--,I())},setCount(i){d=Math.max(0,i),I()},waitForDrain(){return a==="flowing"?Promise.resolve():new Promise(i=>{S.push(i)})},reset(){d=0,S=[],g("flowing")}}}function mr(e){return{_tag:"Duration",millis:e}}function dr(e){return{_tag:"Duration",millis:e*1e3}}function fr(e){return{_tag:"Duration",millis:e*60*1e3}}function Er(e){return{_tag:"Duration",millis:e*60*60*1e3}}function wr(e){return{_tag:"Duration",millis:e*24*60*60*1e3}}function _t(e){return e.millis}function Dt(e){let t=e.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i);if(!t)return;let r=parseFloat(t[1]);switch(t[2].toLowerCase()){case"ms":return mr(r);case"s":return dr(r);case"m":return fr(r);case"h":return Er(r);case"d":return wr(r);default:return}}async function Pt(e,t){let r=e["~standard"].validate(t),m=r instanceof Promise?await r:r;return m.issues?U({type:"INPUT_VALIDATION_ERROR",issues:m.issues.map(a=>({message:a.message,path:a.path?.map(d=>typeof d=="object"?d.key:d)})),message:`Input validation failed: ${m.issues.map(a=>a.message).join(", ")}`}):X(m.value)}function Qe(e,t){let r=m=>((...a)=>{let d=a.at(-1),S=a.length>0&&typeof d=="object"&&d!==null&&!Array.isArray(d)&&typeof d!="function",g=S?d:void 0,I=S?a.slice(0,-1):a,i={...t,...g?.deps??{}},Y=g?{...g,deps:i}:{deps:i};return e[m](...I,Y)});return{run:r("run"),runWithState:r("runWithState"),withDeps(m){return Qe(e,{...t,...m})}}}function Ze(e,t,r){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??{},a=r;async function d(i,Y,b){let x=i??crypto.randomUUID(),G=b?.deps?{...m,...b.deps}:m,l=[],q=b?.createContext??a?.createContext,Q=q?await q():void 0,W=b?.signal??a?.signal,fe=b?.onEvent??a?.onEvent,ke=b?.onError??a?.onError,$=b?.shouldRun??a?.shouldRun,V=b?.onBeforeStart??a?.onBeforeStart,f=b?.onAfterStep??a?.onAfterStep,ee=b?.resumeState??a?.resumeState,ae=a?.catchUnexpected??Ke,me={},ue=(b?.devWarnings??a?.devWarnings)===!0&&process.env.NODE_ENV!=="production",le=new Set,c=new Set,y={workflowId:x,onEvent:fe,context:Q!==void 0?Q:void 0,signal:W,input:{},ref:s=>me[s],set:(s,w)=>{ue&&!le.has(s)&&(le.add(s),console.warn(`awaitly: ctx.set('${s}', ...) is deprecated for static analysis. Use step('id', fn, { out: '${s}' }) instead.`)),me[s]=w},get:s=>(ue&&!c.has(s)&&(c.add(s),console.warn(`awaitly: ctx.get('${s}') is deprecated for static analysis. Use ctx.ref('${s}') instead for tracked dependencies.`)),me[s])},n=s=>{let w=s.context!==void 0||Q===void 0?s:{...s,context:Q},E=w.workflowName===void 0?{...w,workflowName:e}:w;fe?.(E,Q)},u=(s,w)=>{let E={type:"WORKFLOW_CANCELLED",reason:s,lastStepKey:w};return U(ae(E),{cause:E})};if(W?.aborted){let s=typeof W.reason=="string"?W.reason:W.reason instanceof Error?W.reason.message:void 0;return n({type:"workflow_cancelled",workflowId:x,ts:Date.now(),durationMs:0,reason:s}),u(s)}if($){let s=performance.now();try{let w=await $(x,Q),E=performance.now()-s;if(n({type:"hook_should_run",workflowId:x,ts:Date.now(),durationMs:E,result:w,skipped:!w}),!w){let z=new Error("Workflow skipped by shouldRun hook");return U(ae(z),{cause:z})}}catch(w){let E=performance.now()-s;return n({type:"hook_should_run_error",workflowId:x,ts:Date.now(),durationMs:E,error:w}),U(ae(w),{cause:w})}}if(V){let s=performance.now();try{let w=await V(x,Q),E=performance.now()-s;if(n({type:"hook_before_start",workflowId:x,ts:Date.now(),durationMs:E,result:w,skipped:!w}),!w){let z=new Error("Workflow skipped by onBeforeStart hook");return U(ae(z),{cause:z})}}catch(w){let E=performance.now()-s;return n({type:"hook_before_start_error",workflowId:x,ts:Date.now(),durationMs:E,error:w}),U(ae(w),{cause:w})}}let o=a?.inputSchema,k=a?.input;if(o){let s=await Pt(o,k);if(!s.ok)return U(s.error);y.input=s.value}else k!==void 0&&(y.input=k);let h=Date.now(),A=performance.now();n({type:"workflow_start",workflowId:x,ts:h});let p=b?.cache??a?.cache,_=b?.streamStore??a?.streamStore;if(ee&&!p&&(p=new Map),ee&&p){let s=typeof ee=="function"?await ee():ee;s.steps instanceof Map||(console.warn(`awaitly: resumeState.steps is not a Map (got ${typeof s.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 s.steps=="object"&&s.steps!==null&&(s.steps=new Map(Object.entries(s.steps))));for(let[w,E]of s.steps){let{result:z,meta:T}=E;if(z.ok)p.set(w,z);else{let v=T??{origin:"result",resultCause:z.cause};p.set(w,be(z.error,v,z.cause))}}}let F=b?.snapshot??a?.snapshot,J=a?.serialization;if(F&&!ee){p||(p=new Map);let s=F,w=J?.decode;for(let[E,z]of Object.entries(s.steps))if(Object.prototype.hasOwnProperty.call(s.steps,E))try{if(z.ok){let T=w?w(z.value):z.value;p.set(E,X(T))}else{let T=w?w(z.error):z.error,v=Ye(z.cause),C=z.meta?.origin==="throw"?{origin:"throw",thrown:v}:{origin:"result",resultCause:v};p.set(E,be(T,C,v))}}catch(T){throw new $e(`Failed to decode step "${E}": ${T instanceof Error?T.message:String(T)}`,E,T instanceof Error?T:void 0)}}let re=!1,N,Z,K=()=>{re=!0,N=typeof W?.reason=="string"?W.reason:W?.reason instanceof Error?W.reason.message:void 0};W&&!W.aborted&&W.addEventListener("abort",K,{once:!0});let H=()=>{if(re||W?.aborted)throw{type:"WORKFLOW_CANCELLED",reason:N??(typeof W?.reason=="string"?W.reason:W?.reason instanceof Error?W.reason.message:void 0),lastStepKey:Z}},P=async(s,w,E)=>{if(!f)return;let z=performance.now();try{await f(s,w,x,Q);let T=performance.now()-z;n({type:"hook_after_step",workflowId:x,stepKey:s,ts:Date.now(),durationMs:T})}catch(T){let v=performance.now()-z;throw n({type:"hook_after_step_error",workflowId:x,stepKey:s,ts:Date.now(),durationMs:v,error:T}),T}},Re=s=>{let w=async(T,v,C)=>{if(typeof T!="string")throw new Error('[awaitly] step() requires a string ID as the first argument. Example: step("fetchUser", () => fetchUser(id))');let D=T,O=C??{},j=D,R=Object.prototype.hasOwnProperty.call(O,"key")?O.key:D,{ttl:L,out:oe}=O;H();let ne=Je(O);if(R&&p&&p.has(R)){n({type:"step_cache_hit",workflowId:x,stepKey:R,name:j,ts:Date.now(),...ne&&{metadata:ne}});let M=p.get(R);if(M.ok)return Z=R,oe&&(me[oe]=M.value),M.value;let B=Ne(M.cause);throw De(M.error,B)}R&&p&&n({type:"step_cache_miss",workflowId:x,stepKey:R,name:j,ts:Date.now(),...ne&&{metadata:ne}});try{let M=await s(D,v,O);return oe&&(me[oe]=M),O.compensate&&l.push({stepName:j,value:M,compensate:O.compensate}),R&&(Z=R,p&&p.set(R,X(M),L?{ttl:L}:void 0),await P(R,X(M))),M}catch(M){if(R&&ve(M)){let B=M,pe=B.meta.origin==="result"?B.meta.resultCause:B.meta.origin==="throw"?B.meta.thrown:void 0,te=be(B.error,B.meta,pe);p&&p.set(R,te,L?{ttl:L}:void 0),await P(R,te,B.meta)}throw M}};w.try=async(T,v,C)=>{let{ttl:D}=C,O=C.key??T,j=T;if(p&&p.has(O)){n({type:"step_cache_hit",workflowId:x,stepKey:O,name:j,ts:Date.now()});let R=p.get(O);if(R.ok)return R.value;let L=Ne(R.cause);throw De(R.error,L)}p&&n({type:"step_cache_miss",workflowId:x,stepKey:O,name:j,ts:Date.now()});try{let R=await s.try(T,v,{...C,key:O});return C.compensate&&l.push({stepName:j,value:R,compensate:C.compensate}),p&&p.set(O,X(R),D?{ttl:D}:void 0),await P(O,X(R)),R}catch(R){if(ve(R)){let L=R,oe=L.meta.origin==="result"?L.meta.resultCause:L.meta.origin==="throw"?L.meta.thrown:void 0,ne=be(L.error,L.meta,oe);p&&p.set(O,ne,D?{ttl:D}:void 0),await P(O,ne,L.meta)}throw R}},w.fromResult=async(T,v,C)=>{let{ttl:D}=C,O=C.key??T,j=T;if(p&&p.has(O)){n({type:"step_cache_hit",workflowId:x,stepKey:O,name:j,ts:Date.now()});let R=p.get(O);if(R.ok)return R.value;let L=Ne(R.cause);throw De(R.error,L)}p&&n({type:"step_cache_miss",workflowId:x,stepKey:O,name:j,ts:Date.now()});try{let R=await s.fromResult(T,v,{...C,key:O});return p&&p.set(O,X(R),D?{ttl:D}:void 0),await P(O,X(R)),R}catch(R){if(ve(R)){let L=R,oe=L.meta.origin==="result"?L.meta.resultCause:L.meta.origin==="throw"?L.meta.thrown:void 0,ne=be(L.error,L.meta,oe);p&&p.set(O,ne,D?{ttl:D}:void 0),await P(O,ne,L.meta)}throw R}},w.race=s.race,w.withFallback=async(T,v,C)=>{let D=C.key??T,O=T;if(p&&p.has(D)){n({type:"step_cache_hit",workflowId:x,stepKey:D,name:O,ts:Date.now()});let j=p.get(D);if(j.ok)return j.value;let R=Ne(j.cause);throw De(j.error,R)}p&&n({type:"step_cache_miss",workflowId:x,stepKey:D,name:O,ts:Date.now()});try{let j=await s.withFallback(T,v,C);return p&&p.set(D,X(j)),await P(D,X(j)),j}catch(j){if(ve(j)){let R=j,L=R.meta.origin==="result"?R.meta.resultCause:R.meta.origin==="throw"?R.meta.thrown:void 0,oe=be(R.error,R.meta,L);p&&p.set(D,oe),await P(D,oe,R.meta)}throw j}},w.withResource=async(T,v)=>{let C=T;try{let D=await s.withResource(T,v);return await P(C,X(D)),D}catch(D){if(ve(D)){let O=D,j=O.meta.origin==="result"?O.meta.resultCause:O.meta.origin==="throw"?O.meta.thrown:void 0,R=be(O.error,O.meta,j);await P(C,R,O.meta)}throw D}},w.retry=(T,v,C)=>{let D={key:C.key,retry:{attempts:C.attempts,backoff:C.backoff,initialDelay:C.initialDelay,maxDelay:C.maxDelay,jitter:C.jitter,shouldRetry:C.shouldRetry,onRetry:C.onRetry},timeout:C.timeout,ttl:C.ttl};return w(T,v,D)},w.withTimeout=(T,v,C)=>{let D={key:C.key,timeout:C,ttl:C.ttl};return w(T,v,D)},w.sleep=(T,v,C)=>{if(typeof T!="string"||T.length===0)throw new Error('[awaitly] step.sleep() requires an explicit string ID as the first argument. Example: step.sleep("delay", "5s")');let D=typeof v=="string"?Dt(v):v;if(!D)throw new Error(`step.sleep: invalid duration '${v}'`);let O=_t(D),j=C?.signal;return w(T,async()=>{if(W?.aborted||j?.aborted){let L=new Error("Sleep aborted");throw L.name="AbortError",L}return new Promise((L,oe)=>{let ne={timeoutId:void 0},M=()=>{ne.timeoutId&&clearTimeout(ne.timeoutId);let B=new Error("Sleep aborted");B.name="AbortError",oe(B)};W?.addEventListener("abort",M,{once:!0}),j?.addEventListener("abort",M,{once:!0}),ne.timeoutId=setTimeout(()=>{W?.removeEventListener("abort",M),j?.removeEventListener("abort",M),L(X(void 0))},O)})},{key:C?.key,ttl:C?.ttl,description:C?.description})};let E=new Map,z=new Map;return w.getWritable=T=>{let v=T?.namespace??"default",C=T?.highWaterMark??16;if(!_)throw new Error("streamStore is required to use getWritable(). Pass a streamStore to createWorkflow options.");let D=`${x}:${v}`,O=E.get(D);if(O&&!O.closed&&!O.aborted)return O.writer;let j=Ot({highWaterMark:C,onStateChange:B=>{n({type:"stream_backpressure",workflowId:x,namespace:v,bufferedCount:j.bufferedCount,state:B,ts:Date.now()})}}),R=0,L=!0,oe=!1,ne=!1;n({type:"stream_created",workflowId:x,namespace:v,ts:Date.now()});let M={async write(B){if(ne)return U(Le("closed","Stream is closed"));if(oe)return U(Le("aborted","Stream was aborted"));j.state==="paused"&&await j.waitForDrain();let pe={value:B,position:R,ts:Date.now()},te=await _.append(x,v,pe);return te.ok?(n({type:"stream_write",workflowId:x,namespace:v,position:R,ts:Date.now()}),R++,j.increment(),X(void 0)):(n({type:"stream_error",workflowId:x,namespace:v,error:te.error,position:R,ts:Date.now()}),U(Le("store_error",te.error.message,te.error)))},async close(){if(ne)return U(Xe("already_closed","Stream is already closed"));let B=await _.closeStream(x,v);return B.ok?(ne=!0,L=!1,n({type:"stream_close",workflowId:x,namespace:v,finalPosition:R,ts:Date.now()}),E.delete(D),X(void 0)):U(Xe("store_error",B.error.message,B.error))},abort(B){oe=!0,L=!1,ne=!0,n({type:"stream_error",workflowId:x,namespace:v,error:B,position:R,ts:Date.now()}),E.delete(D)},get writable(){return L},get position(){return R},get namespace(){return v}};return E.set(D,{writer:M,backpressure:j,aborted:oe,closed:ne}),M},w.getReadable=T=>{let v=T?.namespace??"default",C=T?.startIndex??0,D=T?.pollInterval??10,O=T?.pollTimeout??3e4;if(!_)throw new Error("streamStore is required to use getReadable(). Pass a streamStore to createWorkflow options.");let j=`${x}:${v}:${C}`,R=z.get(j);if(R&&!R.closed)return R.reader;let L=()=>{let xe=`${x}:${v}`,ie=E.get(xe);ie&&ie.backpressure.decrement()},oe=C,ne=!0,M=!1,B=[],pe=0,te={async read(){if(M)return U(Ge("closed","Reader is closed"));if(pe<B.length){let we=B[pe++];return oe=we.position+1,L(),n({type:"stream_read",workflowId:x,namespace:v,position:we.position,ts:Date.now()}),X(we.value)}let xe=`${x}:${v}`,ie=Date.now(),Ee=E.has(xe),se=await _.getMetadata(x,v),de=se.ok&&se.value!==void 0;for(;Date.now()-ie<O;){let we=await _.read(x,v,oe,100);if(!we.ok)return U(Ge("store_error",we.error.message,we.error));let Me=we.value;if(Me.length>0){B=Me,pe=1;let We=Me[0];return oe=We.position+1,L(),n({type:"stream_read",workflowId:x,namespace:v,position:We.position,ts:Date.now()}),X(We.value)}let Ie=E.has(xe),Ce=await _.getMetadata(x,v),lt=Ce.ok&&Ce.value!==void 0;if(Ie&&(Ee=!0),lt&&(de=!0),Ce.ok&&Ce.value?.closed)return ne=!1,U(Be(oe));if(Ee&&!Ie&&!lt)return ne=!1,U(Be(oe));de&&!Ie&&Ce.ok&&Ce.value?.closed,await new Promise(We=>setTimeout(We,D))}return ne=!1,U(Be(oe))},close(){M=!0,ne=!1,B=[],z.delete(j)},get readable(){return ne},get position(){return oe},get namespace(){return v}};return z.set(j,{reader:te,position:oe,closed:M}),te},w.streamForEach=async(T,v,C)=>{let D=C?.checkpointInterval??1,O=C?.concurrency??1,j=[],R=0,L=-1,oe=M=>typeof M=="object"&&M!==null&&"read"in M&&typeof M.read=="function",ne=async(M,B,pe,te)=>{let ie=D>0&&B%D===0?`stream-foreach:${te}:pos-${pe}`:void 0,Ee=ie??`stream-item-${pe}`,se=await w(Ee,()=>v(M,B),{key:ie});return{index:B,position:pe,result:se}};if(oe(T))if(O<=1){let M=T.position,B=await T.read();for(;B.ok;){let pe=B.value,{result:te}=await ne(pe,R,M,T.namespace);j.push(te),L=M,R++,M=T.position,B=await T.read()}}else{let M=new Map,B=0,pe=0,te=new Array(O).fill(null),xe=async()=>{for(let we=0;we<te.length;we++)if(te[we]===null)return we;let se=te.filter(we=>we!==null),de=await Promise.race(se);return M.set(de.index,{position:de.position,result:de.result}),te[de.slotIndex]=null,de.slotIndex},ie=T.position,Ee=await T.read();for(;Ee.ok;){let se=await xe(),de=B,we=ie,Me=Ee.value,Ie=se;te[se]=ne(Me,de,we,T.namespace).then(Ce=>({slotIndex:Ie,...Ce})),pe++,B++,ie=T.position,Ee=await T.read()}for(let se=0;se<te.length;se++)if(te[se]!==null){let de=await te[se];M.set(de.index,{position:de.position,result:de.result})}for(let se=0;se<pe;se++){let de=M.get(se);de&&(j.push(de.result),L=de.position,R++)}}else if(O<=1){let M=0;for await(let B of T){let{result:pe}=await ne(B,M,M,"async-iterable");j.push(pe),L=M,R++,M++}}else{let M=new Map,B=0,pe=0,te=new Array(O).fill(null),xe=async()=>{for(let se=0;se<te.length;se++)if(te[se]===null)return se;let ie=te.filter(se=>se!==null),Ee=await Promise.race(ie);return M.set(Ee.index,Ee.result),te[Ee.slotIndex]=null,Ee.slotIndex};for await(let ie of T){let Ee=await xe(),se=B,de=Ee;te[Ee]=ne(ie,se,se,"async-iterable").then(we=>({slotIndex:de,...we})),pe++,B++}for(let ie=0;ie<te.length;ie++)if(te[ie]!==null){let Ee=await te[ie];M.set(Ee.index,Ee.result)}for(let ie=0;ie<pe;ie++)M.has(ie)&&(j.push(M.get(ie)),L=ie,R++)}return{results:j,processedCount:R,lastPosition:L}},w.if=s.if,w.label=s.label,w.branch=s.branch,w.arm=s.arm,w.forEach=s.forEach,w.item=s.item,w.dep=s.dep,w.workflow=(T,v,C)=>w(T,v,C),w.all=(T,v,C)=>{let D=C!==void 0&&Object.prototype.hasOwnProperty.call(C,"key")?C:{...C,key:void 0};return w(T,async()=>X(await s.all(T,v)),D)},w.map=(T,v,C,D)=>{let O=D!==void 0&&Object.prototype.hasOwnProperty.call(D,"key")?D:{...D,key:void 0};return w(T,async()=>X(await s.map(T,v,C,D)),O)},w},Te=({step:s})=>Y({step:Re(s),deps:G,ctx:y}),ce;try{ce=await Fe(Te,{onError:ke,onEvent:fe,catchUnexpected:ae,workflowId:x,workflowName:e,context:Q,_workflowSignal:W})}finally{W&&W.removeEventListener("abort",K)}if(!ce.ok&&l.length>0){let s=[];for(let w=l.length-1;w>=0;w--){let E=l[w];try{await E.compensate(E.value)}catch(z){s.push({stepName:E.stepName,error:z})}}if(s.length>0){let w={type:"SAGA_COMPENSATION_ERROR",originalError:ce.error,compensationErrors:s};ce=U(w,{cause:ce.cause})}}let he=performance.now()-A;if(!ce.ok){let s;if(ze(ce.cause)&&(s=ce.cause),!s&&re&&ht(ce.error)){let w=ce.cause;w!=null&&typeof w=="object"&&"name"in w&&w.name==="AbortError"&&(s={type:"WORKFLOW_CANCELLED",reason:N??(typeof W?.reason=="string"?W.reason:W?.reason instanceof Error?W.reason.message:void 0),lastStepKey:Z})}if(s)return n({type:"workflow_cancelled",workflowId:x,ts:Date.now(),durationMs:he,reason:s.reason,lastStepKey:s.lastStepKey}),s&&!ze(ce.cause)?U(ce.error,{cause:s}):ce}if(ce.ok&&re){let s=N??(typeof W?.reason=="string"?W.reason:W?.reason instanceof Error?W.reason.message:void 0);n({type:"workflow_cancelled",workflowId:x,ts:Date.now(),durationMs:he,reason:s,lastStepKey:Z});let w={type:"WORKFLOW_CANCELLED",reason:s,lastStepKey:Z};return U(ae(w),{cause:w})}return ce.ok?n({type:"workflow_success",workflowId:x,ts:Date.now(),durationMs:he}):n({type:"workflow_error",workflowId:x,ts:Date.now(),durationMs:he,error:ce.error}),ce}function S(i,Y,b){let x,G,l;return typeof i=="string"?(x=i,G=Y,l=b):(G=i,l=Y),d(x,G,l)}async function g(i,Y,b){let x,G,l;typeof i=="string"?(x=i,G=Y,l=b):(G=i,l=Y);let q=At(),Q=l?.onEvent,fe={...l,onEvent:(V,f)=>{q.handleEvent(V);try{Q?.(V,f)}catch{}}},ke,$;try{ke=await d(x,G,fe)}catch(V){let f=a?.catchUnexpected??Ke;ke=U(f(V),{cause:V})}finally{$=q.getResumeState()}return{result:ke,resumeState:$}}let I={withDeps:i=>Qe(I,i),run:S,runWithState:g};return I}async function et(e,t,r){let m=[],a={},d=[],S=b=>{if(m.push(b),b.type==="step_complete"&&b.stepKey){let x={output:b.result.ok?b.result.value:void 0,durationMs:b.durationMs,result:b.result};a[b.stepKey]=x,d.push(b.stepKey)}},g=Ze("test-workflow",e),I=performance.now(),i=await g.run(t,{onEvent:S,signal:r?.signal}),Y=performance.now()-I;return{result:i,steps:a,events:m,durationMs:Y,stepOrder:d}}function tt(e){return typeof e=="object"&&e!==null&&"__earlyExit"in e&&e.__earlyExit===!0}function rt(e,t={}){let{recordInvocations:r=!0,clock:m=Date.now}=t,a=[],d=new Map,S=0,g=[];function I($){a=[...$],S=0,d.clear()}function i($,V){d.set($,V)}function Y($){if($&&d.has($))return d.get($);if(S<a.length)return a[S++]}function b(){let $=async(V,f,ee)=>{let ae,me,ue;typeof V=="string"?(ae=V,me=f,ue=ee??{}):(me=V,typeof f=="string"?(ae=f,ue={}):(ue=f??{},ae=ue.key??"step"));let le=m(),c={name:ae,key:ue.key,order:g.length,timestamp:le};r&&g.push(c);let y=Y(ae);if(y)switch(c.durationMs=m()-le,y.type){case"ok":return c.result=X(y.value),y.value;case"err":throw c.result=U(y.error),{__earlyExit:!0,error:y.error};case"throw":throw y.error}let n=typeof me=="function"?await me():await me;if(c.durationMs=m()-le,c.result=n,!n.ok)throw{__earlyExit:!0,error:n.error};return n.value};return $.try=async(V,f,ee)=>{let ae,me,ue;typeof V=="string"?(ae=V,me=f,ue=ee):(me=V,ue=f,ae=ue.key??"step");let le=m(),c={name:ae,key:"key"in ue?ue.key:void 0,order:g.length,timestamp:le};r&&g.push(c);let y=Y(ae);if(y)switch(c.durationMs=m()-le,y.type){case"ok":return c.result=X(y.value),y.value;case"err":throw c.result=U(y.error),{__earlyExit:!0,error:y.error};case"throw":throw y.error}try{let n=await me();return c.durationMs=m()-le,c.result=X(n),n}catch(n){c.durationMs=m()-le;let u="error"in ue?ue.error:ue.onError(n);throw c.result=U(u),{__earlyExit:!0,error:u}}},$}async function x($){let V=b();try{let f=await $({step:V,deps:e});return X(f)}catch(f){return tt(f)?U(f.error):U(new Se({cause:f}))}}async function G($,V){let f=b();try{let ee=await V({step:f,deps:e,input:$});return X(ee)}catch(ee){return tt(ee)?U(ee.error):U(new Se({cause:ee}))}}function l(){return[...g]}function q($){let V=g.map(ee=>ee.name??ee.key??"unnamed").filter(ee=>ee!=="unnamed"),f=JSON.stringify(V)===JSON.stringify($);return{passed:f,message:f?`Steps invoked in order: ${$.join(", ")}`:`Expected steps [${$.join(", ")}] but got [${V.join(", ")}]`,expected:$,actual:V}}function Q($){let V=g.some(f=>f.name===$||f.key===$);return{passed:V,message:V?`Step "${$}" was invoked`:`Step "${$}" was NOT invoked`,expected:$,actual:V}}function W($){let V=g.some(f=>f.name===$||f.key===$);return{passed:!V,message:V?`Step "${$}" was invoked but should not have been`:`Step "${$}" was correctly NOT invoked`,expected:"not called",actual:V?"called":"not called"}}function fe($,V){let f=$.ok===V.ok&&($.ok?JSON.stringify($.value)===JSON.stringify(V.value):JSON.stringify($.error)===JSON.stringify(V.error));return{passed:f,message:f?"Result matches expected":"Result does not match expected",expected:V,actual:$}}function ke(){a=[],d.clear(),S=0,g=[]}return{script:I,scriptStep:i,run:x,runWithInput:G,getInvocations:l,assertSteps:q,assertStepCalled:Q,assertStepNotCalled:W,assertResult:fe,reset:ke}}function Mt(){let e,t=[],r=[],m=((...a)=>{if(r.push(a),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=a=>(e=a,m),m.returnsOnce=a=>(t.push(a),m),m.getCalls=()=>[...r],m.getCallCount=()=>r.length,m.reset=()=>{e=void 0,t.length=0,r.length=0},m}function It(e,t,r){let m=e.reduce((a,d)=>a+(d.durationMs??0),0);return{invocations:e.map(a=>({...a,timestamp:0})),result:t,events:r?.map(a=>({...a,ts:0})),durationMs:m}}function Wt(e,t){let r=[];e.invocations.length!==t.invocations.length&&r.push(`Invocation count: ${e.invocations.length} vs ${t.invocations.length}`);let m=Math.max(e.invocations.length,t.invocations.length);for(let a=0;a<m;a++){let d=e.invocations[a],S=t.invocations[a];if(!d){r.push(`Step ${a}: missing in first snapshot`);continue}if(!S){r.push(`Step ${a}: missing in second snapshot`);continue}d.name!==S.name&&r.push(`Step ${a} name: "${d.name}" vs "${S.name}"`),d.key!==S.key&&r.push(`Step ${a} key: "${d.key}" vs "${S.key}"`),d.result?.ok!==S.result?.ok&&r.push(`Step ${a} result: ${d.result?.ok?"ok":"err"} vs ${S.result?.ok?"ok":"err"}`)}return e.result.ok!==t.result.ok&&r.push(`Final result: ${e.result.ok?"ok":"err"} vs ${t.result.ok?"ok":"err"}`),{equal:r.length===0,differences:r}}function Ut(e=0){let t=e;return{now:()=>t,advance:r=>{t+=r},set:r=>{t=r},reset:()=>{t=e}}}function Nt(e){return{type:"ok",value:e}}function jt(e){return{type:"err",error:e}}function Ft(e){return{type:"throw",error:e}}function Kt(e,t={}){let{clock:r=Date.now}=t,m=rt(e,t),a=[],d=[];async function S(G){a=[],d=[];let l={step:async(Q,W)=>{try{let fe=await m.run(async({step:ke})=>ke("saga-step",Q));if(!fe.ok)throw await q(),{__earlyExit:!0,error:fe.error};return W?.compensate&&d.push({value:fe.value,compensate:W.compensate}),fe.value}catch(fe){throw d.length>0&&await q(),fe}}};async function q(){let Q=[...d].reverse();d=[];for(let{name:W,value:fe,compensate:ke}of Q)try{await ke(fe),a.push({stepName:W,order:a.length,value:fe,timestamp:r()})}catch($){console.error(`Compensation failed for step "${W}":`,$)}}try{let Q=await G({saga:l,deps:e});return X(Q)}catch(Q){return tt(Q)?U(Q.error):(await q(),U(new Se({cause:Q})))}}function g(){return[...a]}function I(G){let l=a.map(Q=>Q.stepName),q=JSON.stringify(l)===JSON.stringify(G);return{passed:q,message:q?`Compensations ran in order: ${G.join(" \u2192 ")}`:`Expected compensations [${G.join(" \u2192 ")}] but got [${l.join(" \u2192 ")}]`,expected:G,actual:l}}function i(G){let l=a.some(q=>q.stepName===G);return{passed:l,message:l?`Step "${G}" was compensated`:`Step "${G}" was NOT compensated`,expected:G,actual:l}}function Y(G){let l=a.some(q=>q.stepName===G);return{passed:!l,message:l?`Step "${G}" was compensated but should not have been`:`Step "${G}" was correctly NOT compensated`,expected:"not compensated",actual:l?"compensated":"not compensated"}}let b=m.reset;function x(){b(),a=[],d=[]}return{...m,reset:x,getCompensations:g,assertCompensationOrder:I,assertCompensated:i,assertNotCompensated:Y,runSaga:S}}function $t(e,t,r={}){let{strict:m=!0}=r,a=t.map(I=>{let[i,Y]=I.split(":");return{type:i,name:Y}}),S=(m?e:e.filter(I=>a.some(i=>I.type===i.type))).map(I=>{let i="name"in I?I.name:void 0,Y="stepKey"in I?I.stepKey:void 0,b=i??Y;return b?`${I.type}:${b}`:I.type}),g=JSON.stringify(S)===JSON.stringify(t);return{passed:g,message:g?`Event sequence matches: ${t.join(" \u2192 ")}`:`Event sequence mismatch.
-Expected: ${t.join(" \u2192 ")}
-Actual: ${S.join(" \u2192 ")}`,expected:t,actual:S}}function nt(e,t){let r=e.find(m=>Object.entries(t).every(([a,d])=>{let S=m[a];return typeof d=="object"&&d!==null?JSON.stringify(S)===JSON.stringify(d):S===d}));return{passed:!!r,message:r?`Event matching ${JSON.stringify(t)} was emitted`:`No event matching ${JSON.stringify(t)} was found`,expected:t,actual:r??"not found"}}function Lt(e,t){let r=nt(e,t);return{passed:!r.passed,message:r.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:r.actual}}function ot(e){if(!e.ok)throw new Error(`Expected Ok result, got Err: ${JSON.stringify(e.error,null,2)}`)}function st(e){if(e.ok)throw new Error(`Expected Err result, got Ok: ${JSON.stringify(e.value,null,2)}`)}function at(e){return ot(e),e.value}function it(e){return st(e),e.error}async function Bt(e){return at(await e)}async function Vt(e){return it(await e)}function Ht(e){return St(e)?`Ok(${Pe(e.value)})`:`Err(${Pe(e.error)})`}function Pe(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(Pe).join(", ")}]`:`[${e.slice(0,3).map(Pe).join(", ")}, ... (${e.length} items)]`;if(typeof e=="object"){let t=e,r=Object.keys(t);return r.length===0?"{}":r.length<=4?`{ ${r.map(d=>`${d}: ${Pe(t[d])}`).join(", ")} }`:`{ ${r.slice(0,3).map(a=>`${a}: ${Pe(t[a])}`).join(", ")}, ... (${r.length} keys) }`}return String(e)}function ut(e){let t=e.type,r="name"in e?e.name:void 0,m="stepKey"in e?e.stepKey:void 0,a=r??m;return a?`${t}:${a}`:t}function qt(e){return e.map(ut).join(" \u2192 ")}0&&(module.exports={assertEventEmitted,assertEventNotEmitted,assertEventSequence,compareSnapshots,createMockFn,createSagaHarness,createSnapshot,createTestClock,createWorkflowHarness,errOutcome,expectErr,expectOk,formatEvent,formatEvents,formatResult,okOutcome,testWorkflow,throwOutcome,unwrapErr,unwrapErrAsync,unwrapOk,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 ");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertEventEmitted,
+  assertEventNotEmitted,
+  assertEventSequence,
+  compareSnapshots,
+  createMockFn,
+  createSagaHarness,
+  createSnapshot,
+  createTestClock,
+  createWorkflowHarness,
+  errOutcome,
+  expectErr,
+  expectOk,
+  formatEvent,
+  formatEvents,
+  formatResult,
+  okOutcome,
+  testWorkflow,
+  throwOutcome,
+  unwrapErr,
+  unwrapErrAsync,
+  unwrapOk,
+  unwrapOkAsync
+});
 //# sourceMappingURL=testing.cjs.map