@jagreehal/workflow 1.6.0 → 1.8.0

package/README.md

@@ -154,6 +154,102 @@ const result = await processPayment(async (step) => {
 });
 ```
 
+### 💾 Save & Resume (Persist Workflows Across Restarts)
+
+Save workflow state to a database and resume later from exactly where you left off. Perfect for long-running workflows, crash recovery, or pausing for approvals.
+
+**Step 1: Collect state during execution**
+
+```typescript
+import { createWorkflow, createStepCollector } from '@jagreehal/workflow';
+
+// Create a collector to automatically capture step results
+const collector = createStepCollector();
+
+const workflow = createWorkflow({ fetchUser, fetchPosts }, {
+  onEvent: collector.handleEvent, // Automatically collects step_complete events
+});
+
+await workflow(async (step) => {
+  // Only steps with keys are saved
+  const user = await step(() => fetchUser("1"), { key: "user:1" });
+  const posts = await step(() => fetchPosts(user.id), { key: `posts:${user.id}` });
+  return { user, posts };
+});
+
+// Get the collected state
+const state = collector.getState(); // Returns ResumeState
+```
+
+**Step 2: Save to database**
+
+```typescript
+import { stringifyState, parseState } from '@jagreehal/workflow';
+
+// Serialize to JSON
+const json = stringifyState(state, { workflowId: "123", timestamp: Date.now() });
+
+// Save to your database
+await db.workflowStates.create({
+  id: workflowId,
+  state: json,
+  createdAt: new Date(),
+});
+```
+
+**Step 3: Resume from saved state**
+
+```typescript
+// Load from database
+const saved = await db.workflowStates.findUnique({ where: { id: workflowId } });
+const savedState = parseState(saved.state);
+
+// Resume workflow - cached steps skip execution
+const workflow = createWorkflow({ fetchUser, fetchPosts }, {
+  resumeState: savedState, // Pre-populates cache from saved state
+});
+
+await workflow(async (step) => {
+  const user = await step(() => fetchUser("1"), { key: "user:1" }); // ✅ Cache hit - no fetchUser call
+  const posts = await step(() => fetchPosts(user.id), { key: `posts:${user.id}` }); // ✅ Cache hit
+  return { user, posts };
+});
+```
+
+**With database adapter (Redis, DynamoDB, etc.)**
+
+```typescript
+import { createStatePersistence } from '@jagreehal/workflow';
+import { createClient } from 'redis';
+
+const redis = createClient();
+await redis.connect();
+
+// Create persistence adapter
+const persistence = createStatePersistence({
+  get: (key) => redis.get(key),
+  set: (key, value) => redis.set(key, value),
+  delete: (key) => redis.del(key).then(n => n > 0),
+  exists: (key) => redis.exists(key).then(n => n > 0),
+  keys: (pattern) => redis.keys(pattern),
+}, 'workflow:state:');
+
+// Save
+await persistence.save(runId, state, { metadata: { userId: 'user-1' } });
+
+// Load
+const savedState = await persistence.load(runId);
+
+// Resume
+const workflow = createWorkflow(deps, { resumeState: savedState });
+```
+
+**Key points:**
+- Only steps with `key` options are saved (unkeyed steps execute fresh on resume)
+- Error results are preserved with metadata for proper replay
+- You can also pass an async function: `resumeState: async () => await loadFromDB()`
+- Works seamlessly with HITL approvals and crash recovery
+
 ### 🧑‍💻 Human-in-the-Loop
 
 Pause for manual approvals (large transfers, deployments, refunds) and resume exactly where you left off.
@@ -281,6 +377,82 @@ That's the foundation. Now let's build on it.
 
 ---
 
+## Persistence Quickstart
+
+Save workflow state to a database and resume later. Perfect for crash recovery, long-running workflows, or pausing for approvals.
+
+### Basic Save & Resume
+
+```typescript
+import { createWorkflow, createStepCollector, stringifyState, parseState } from '@jagreehal/workflow';
+
+// 1. Collect state during execution
+const collector = createStepCollector();
+const workflow = createWorkflow({ fetchUser, fetchPosts }, {
+  onEvent: collector.handleEvent,
+});
+
+await workflow(async (step) => {
+  const user = await step(() => fetchUser("1"), { key: "user:1" });
+  const posts = await step(() => fetchPosts(user.id), { key: `posts:${user.id}` });
+  return { user, posts };
+});
+
+// 2. Save to database
+const state = collector.getState();
+const json = stringifyState(state, { workflowId: "123" });
+await db.workflowStates.create({ id: "123", state: json });
+
+// 3. Resume later
+const saved = await db.workflowStates.findUnique({ where: { id: "123" } });
+const savedState = parseState(saved.state);
+
+const resumed = createWorkflow({ fetchUser, fetchPosts }, {
+  resumeState: savedState,
+});
+
+// Cached steps skip execution automatically
+await resumed(async (step) => {
+  const user = await step(() => fetchUser("1"), { key: "user:1" }); // ✅ Cache hit
+  const posts = await step(() => fetchPosts(user.id), { key: `posts:${user.id}` }); // ✅ Cache hit
+  return { user, posts };
+});
+```
+
+### With Database Adapter (Redis, DynamoDB, etc.)
+
+```typescript
+import { createStatePersistence } from '@jagreehal/workflow';
+import { createClient } from 'redis';
+
+const redis = createClient();
+await redis.connect();
+
+// Create persistence adapter
+const persistence = createStatePersistence({
+  get: (key) => redis.get(key),
+  set: (key, value) => redis.set(key, value),
+  delete: (key) => redis.del(key).then(n => n > 0),
+  exists: (key) => redis.exists(key).then(n => n > 0),
+  keys: (pattern) => redis.keys(pattern),
+}, 'workflow:state:');
+
+// Save
+const collector = createStepCollector();
+const workflow = createWorkflow(deps, { onEvent: collector.handleEvent });
+await workflow(async (step) => { /* ... */ });
+
+await persistence.save('run-123', collector.getState(), { userId: 'user-1' });
+
+// Load and resume
+const savedState = await persistence.load('run-123');
+const resumed = createWorkflow(deps, { resumeState: savedState });
+```
+
+**See the [Save & Resume](#-save--resume-persist-workflows-across-restarts) section for more details.**
+
+---
+
 ## Guided Tutorial
 
 We'll take a single workflow through four stages - from basic to production-ready. Each stage builds on the last, so you'll see how features compose naturally.
@@ -356,29 +528,37 @@ Pause long-running workflows until an operator approves, then resume using persi
 import {
   createApprovalStep,
   createWorkflow,
+  createStepCollector,
   injectApproval,
   isPendingApproval,
-  isStepComplete,
-  type ResumeStateEntry,
 } from '@jagreehal/workflow';
 
-const savedSteps = new Map<string, ResumeStateEntry>();
+// Use collector to automatically capture state
+const collector = createStepCollector();
 const requireApproval = createApprovalStep({
   key: 'approval:deploy',
   checkApproval: async () => ({ status: 'pending' }),
 });
 
 const gatedWorkflow = createWorkflow({ requireApproval }, {
-  onEvent: (event) => {
-    if (isStepComplete(event)) savedSteps.set(event.stepKey, { result: event.result, meta: event.meta });
-  },
+  onEvent: collector.handleEvent, // Automatically collects step results
 });
 
 const result = await gatedWorkflow(async (step) => step(requireApproval, { key: 'approval:deploy' }));
 
 if (!result.ok && isPendingApproval(result.error)) {
-  // later
-  injectApproval({ steps: savedSteps }, { stepKey: 'approval:deploy', value: { approvedBy: 'ops' } });
+  // Get collected state
+  const state = collector.getState();
+  
+  // Later, when approval is granted, inject it and resume
+  const updatedState = injectApproval(state, {
+    stepKey: 'approval:deploy',
+    value: { approvedBy: 'ops' },
+  });
+
+  // Resume with approval injected
+  const resumed = createWorkflow({ requireApproval }, { resumeState: updatedState });
+  await resumed(async (step) => step(requireApproval, { key: 'approval:deploy' })); // Uses injected approval
 }
 ```
 
@@ -400,6 +580,250 @@ if (!result.ok && isPendingApproval(result.error)) {
 | **Events** | `onEvent` streams everything - timing, retries, failures - for visualization or logging |
 | **Resume** | Save completed steps, pick up later (great for approvals or crashes) |
 | **UnexpectedError** | Safety net for throws outside your declared union; use `strict` mode to force explicit handling |
+| **TaggedError** | Factory for rich error types with exhaustive pattern matching |
+
+## Tagged Errors: When String Literals Aren't Enough
+
+String literal errors like `'NOT_FOUND'` are perfect for simple cases. But sometimes you need **rich error objects** with contextual data. That's where `TaggedError` shines.
+
+### When to Use What
+
+| Use Case | Recommendation |
+|----------|----------------|
+| Simple, distinct error states | String literals: `'NOT_FOUND' \| 'UNAUTHORIZED'` |
+| Errors with contextual data | TaggedError: `NotFoundError { id, resource }` |
+| Multiple error variants to handle | TaggedError with `match()` for exhaustive handling |
+| API responses or user messages | TaggedError for structured error details |
+
+### String Literals (Simple Cases)
+
+For most workflows, string literals are cleaner and simpler:
+
+```typescript
+const fetchUser = async (id: string): AsyncResult<User, 'NOT_FOUND' | 'DB_ERROR'> =>
+  id ? ok({ id, name: 'Alice' }) : err('NOT_FOUND');
+
+const result = await workflow(async (step) => {
+  const user = await step(fetchUser('123'));
+  return user;
+});
+
+if (!result.ok) {
+  switch (result.error) {
+    case 'NOT_FOUND': return res.status(404).send('User not found');
+    case 'DB_ERROR': return res.status(500).send('Database error');
+  }
+}
+```
+
+### TaggedError (Rich Error Objects)
+
+Use `TaggedError` when you need to carry additional context:
+
+```typescript
+import { TaggedError, ok, err, type AsyncResult } from '@jagreehal/workflow';
+
+// Pattern 1: Props via generic (default message = tag name)
+class NotFoundError extends TaggedError('NotFoundError')<{
+  resource: string;
+  id: string;
+}> {}
+
+// Pattern 2: Type-safe message (Props inferred from callback annotation)
+class ValidationError extends TaggedError('ValidationError', {
+  message: (p: { field: string; reason: string }) => `Validation failed for ${p.field}: ${p.reason}`,
+}) {}
+
+class RateLimitError extends TaggedError('RateLimitError', {
+  message: (p: { retryAfter: number }) => `Rate limited. Retry after ${p.retryAfter}s`,
+}) {}
+
+// Runtime type checks work!
+const error = new NotFoundError({ resource: 'User', id: '123' });
+console.log(error instanceof TaggedError); // true
+
+// Use in your functions
+type UserError = NotFoundError | ValidationError | RateLimitError;
+
+const fetchUser = async (id: string): AsyncResult<User, UserError> => {
+  if (!id) return err(new ValidationError({ field: 'id', reason: 'required' }));
+  if (id === 'limited') return err(new RateLimitError({ retryAfter: 60 }));
+  if (id === 'missing') return err(new NotFoundError({ resource: 'User', id }));
+  return ok({ id, name: 'Alice' });
+};
+```
+
+### Exhaustive Matching with `TaggedError.match()`
+
+TypeScript enforces you handle **every** error variant:
+
+```typescript
+const result = await workflow(async (step) => {
+  const user = await step(fetchUser('123'));
+  return user;
+});
+
+if (!result.ok) {
+  // TypeScript enforces all variants are handled
+  const response = TaggedError.match(result.error, {
+    NotFoundError: (e) => ({
+      status: 404,
+      body: { error: 'not_found', resource: e.resource, id: e.id },
+    }),
+    ValidationError: (e) => ({
+      status: 400,
+      body: { error: 'validation', field: e.field, reason: e.reason },
+    }),
+    RateLimitError: (e) => ({
+      status: 429,
+      body: { error: 'rate_limited', retryAfter: e.retryAfter },
+    }),
+  });
+
+  return res.status(response.status).json(response.body);
+}
+```
+
+**Add a new error type? TypeScript will error until you handle it.** This catches bugs at compile time, not production.
+
+### Partial Matching with Fallback
+
+Handle specific errors and catch-all for the rest:
+
+```typescript
+const message = TaggedError.matchPartial(
+  result.error,
+  {
+    RateLimitError: (e) => `Please wait ${e.retryAfter} seconds`,
+  },
+  (e) => `Something went wrong: ${e.message}`  // Fallback for other errors
+);
+```
+
+### Real-World Example: Payment Errors
+
+```typescript
+// Type-safe message with Props inferred from callback annotation
+class PaymentDeclinedError extends TaggedError('PaymentDeclinedError', {
+  message: (p: {
+    code: string;
+    declineReason: 'insufficient_funds' | 'card_expired' | 'fraud_suspected';
+  }) => `Payment declined: ${p.declineReason}`,
+}) {}
+
+class PaymentProviderError extends TaggedError('PaymentProviderError', {
+  message: (p: { provider: string; statusCode: number }) => `${p.provider} returned ${p.statusCode}`,
+}) {}
+
+type PaymentError = PaymentDeclinedError | PaymentProviderError;
+
+// In your workflow
+if (!result.ok) {
+  TaggedError.match(result.error, {
+    PaymentDeclinedError: (e) => {
+      switch (e.declineReason) {
+        case 'insufficient_funds': notifyUser('Please use a different card');
+        case 'card_expired': notifyUser('Your card has expired');
+        case 'fraud_suspected': alertFraudTeam(e);
+      }
+    },
+    PaymentProviderError: (e) => {
+      logToDatadog({ provider: e.provider, status: e.statusCode });
+      retryWithBackup(e.provider);
+    },
+  });
+}
+```
+
+### Type Helpers
+
+```typescript
+import { type TagOf, type ErrorByTag } from '@jagreehal/workflow';
+
+type PaymentError = PaymentDeclinedError | PaymentProviderError;
+
+// Extract the tag literal type
+type Tags = TagOf<PaymentError>;  // 'PaymentDeclinedError' | 'PaymentProviderError'
+
+// Extract a specific variant from the union
+type Declined = ErrorByTag<PaymentError, 'PaymentDeclinedError'>;  // PaymentDeclinedError
+```
+
+### Reserved Keys & Cause Handling
+
+**Reserved property names** are stripped from props to preserve Error semantics:
+
+| Key | Reason |
+|-----|--------|
+| `_tag` | Discriminant for pattern matching (cannot be forged) |
+| `name` | Error.name (shown in stack traces/logs) |
+| `message` | Error.message (shown in logs/telemetry) |
+| `stack` | Error.stack (the stack trace) |
+
+```typescript
+// These reserved keys are silently stripped - use different names!
+class BadExample extends TaggedError('BadExample')<{
+  message: string;  // ❌ Won't work - use 'details' or 'description' instead
+  id: string;
+}> {}
+
+// Better approach:
+class GoodExample extends TaggedError('GoodExample')<{
+  details: string;  // ✅ Custom prop name
+  id: string;
+}> {}
+```
+
+**The `cause` property** is special - it can be used as a user prop for domain data:
+
+```typescript
+// cause as domain data (e.g., structured validation errors)
+class ValidationError extends TaggedError('ValidationError')<{
+  cause: { field: string; reason: string };  // ✅ Allowed as user prop
+}> {}
+
+const error = new ValidationError({
+  cause: { field: 'email', reason: 'invalid format' },
+});
+console.log(error.cause);  // { field: 'email', reason: 'invalid format' }
+```
+
+**Conflict detection**: You cannot provide `cause` in both props AND ErrorOptions:
+
+```typescript
+// This throws TypeError at runtime!
+const error = new ValidationError(
+  { cause: { field: 'email', reason: 'invalid' } },  // cause in props
+  { cause: new Error('original') }                    // cause in options
+);
+// TypeError: cannot provide 'cause' in props when also setting ErrorOptions.cause
+```
+
+Use ErrorOptions.cause for error chaining (linking to the original error):
+
+```typescript
+class NetworkError extends TaggedError('NetworkError')<{
+  url: string;
+  statusCode: number;
+}> {}
+
+try {
+  await fetch('/api');
+} catch (original) {
+  // Chain to original error via ErrorOptions (not props)
+  throw new NetworkError(
+    { url: '/api', statusCode: 500 },
+    { cause: original }  // ✅ Error chaining
+  );
+}
+```
+
+### Summary
+
+- **String literals**: Simple, great for distinct states without extra data
+- **TaggedError**: Rich errors with context, exhaustive matching, proper stack traces
+- **`match()`**: Forces you to handle every variant (compile-time safety)
+- **`matchPartial()`**: Handle some variants with a catch-all fallback
 
 ## Recipes & Patterns
 
@@ -547,15 +971,24 @@ const result = await validateAndCheckout(async (step) => {
 - **State save & resume** – Persist step completions and resume later.
 
   ```typescript
-  import { createWorkflow, isStepComplete, type ResumeStateEntry } from '@jagreehal/workflow';
+  import { createWorkflow, createStepCollector } from '@jagreehal/workflow';
 
-  const savedSteps = new Map<string, ResumeStateEntry>();
+  // Collect state during execution
+  const collector = createStepCollector();
   const workflow = createWorkflow(deps, {
-    onEvent: (event) => {
-      if (isStepComplete(event)) savedSteps.set(event.stepKey, { result: event.result, meta: event.meta });
-    },
+    onEvent: collector.handleEvent, // Automatically collects step_complete events
   });
-  const resumed = createWorkflow(deps, { resumeState: { steps: savedSteps } });
+
+  await workflow(async (step) => {
+    const user = await step(() => fetchUser("1"), { key: "user:1" });
+    return user;
+  });
+
+  // Get collected state
+  const state = collector.getState();
+
+  // Resume later
+  const resumed = createWorkflow(deps, { resumeState: state });
   ```
 
 - **Human-in-the-loop approvals** – Pause a workflow until someone approves.
@@ -605,16 +1038,25 @@ const result = await validateAndCheckout(async (step) => {
   const data = map(result, ([user, posts]) => ({ user, posts }));
   ```
 
-## Real-World Example: Safe Payment Retries
+## Real-World Example: Safe Payment Retries with Persistence
 
 The scariest failure mode in payments: **charge succeeded, but persistence failed**. If you retry naively, you charge the customer twice.
 
-Step keys solve this. Once a step succeeds, it's cached - retries skip it automatically:
+Step keys + persistence solve this. Save state to a database, and if the workflow crashes, resume from the last successful step:
 
 ```typescript
+import { createWorkflow, createStepCollector, stringifyState, parseState } from '@jagreehal/workflow';
+
 const processPayment = createWorkflow({ validateCard, chargeProvider, persistResult });
 
-const result = await processPayment(async (step) => {
+// Collect state for persistence
+const collector = createStepCollector();
+const workflow = createWorkflow(
+  { validateCard, chargeProvider, persistResult },
+  { onEvent: collector.handleEvent }
+);
+
+const result = await workflow(async (step) => {
   const card = await step(() => validateCard(input), { key: 'validate' });
 
   // This is the dangerous step. Once it succeeds, never repeat it:
@@ -622,15 +1064,53 @@ const result = await processPayment(async (step) => {
     key: `charge:${input.idempotencyKey}`,
   });
 
-  // If THIS fails (DB down), you can rerun the workflow later.
+  // If THIS fails (DB down), save state and rerun later.
   // The charge step is cached - it won't execute again.
   await step(() => persistResult(charge), { key: `persist:${charge.id}` });
 
   return { paymentId: charge.id };
 });
+
+// Save state after each run (or on crash)
+if (result.ok) {
+  const state = collector.getState();
+  const json = stringifyState(state, { orderId: input.orderId });
+  await db.workflowStates.upsert({
+    where: { idempotencyKey: input.idempotencyKey },
+    update: { state: json, updatedAt: new Date() },
+    create: { idempotencyKey: input.idempotencyKey, state: json },
+  });
+}
+```
+
+**Crash recovery:** If the workflow crashes after charging but before persisting:
+
+```typescript
+// On restart, load saved state
+const saved = await db.workflowStates.findUnique({
+  where: { idempotencyKey: input.idempotencyKey },
+});
+
+if (saved) {
+  const savedState = parseState(saved.state);
+  const workflow = createWorkflow(
+    { validateCard, chargeProvider, persistResult },
+    { resumeState: savedState }
+  );
+
+  // Resume - charge step uses cached result, no double-billing!
+  const result = await workflow(async (step) => {
+    const card = await step(() => validateCard(input), { key: 'validate' }); // Cache hit
+    const charge = await step(() => chargeProvider(card), {
+      key: `charge:${input.idempotencyKey}`,
+    }); // Cache hit - returns previous charge result
+    await step(() => persistResult(charge), { key: `persist:${charge.id}` }); // Executes fresh
+    return { paymentId: charge.id };
+  });
+}
 ```
 
-Crash after charging but before persisting? Rerun the workflow. The charge step returns its cached result. No double-billing.
+Crash after charging but before persisting? Resume the workflow. The charge step returns its cached result. No double-billing.
 
 ## Is This Library Right for You?
 

package/dist/core.cjs

@@ -1,2 +1,2 @@
-"use strict";var Y=Object.defineProperty;var pe=Object.getOwnPropertyDescriptor;var le=Object.getOwnPropertyNames;var ce=Object.prototype.hasOwnProperty;var Ee=(e,t)=>{for(var n in t)Y(e,n,{get:t[n],enumerable:!0})},ye=(e,t,n,s)=>{if(t&&typeof t=="object"||typeof t=="function")for(let l of le(t))!ce.call(e,l)&&l!==n&&Y(e,l,{get:()=>t[l],enumerable:!(s=pe(t,l))||s.enumerable});return e};var me=e=>ye(Y({},"__esModule",{value:!0}),e);var $e={};Ee($e,{EARLY_EXIT_SYMBOL:()=>G,STEP_TIMEOUT_MARKER:()=>O,UnwrapError:()=>N,all:()=>Le,allAsync:()=>We,allSettled:()=>Xe,allSettledAsync:()=>Je,andThen:()=>Me,any:()=>Be,anyAsync:()=>qe,bimap:()=>Ke,createEarlyExit:()=>ne,err:()=>T,from:()=>ge,fromNullable:()=>ve,fromPromise:()=>Ae,getStepTimeoutMeta:()=>te,isEarlyExit:()=>re,isErr:()=>Te,isOk:()=>we,isStepTimeoutError:()=>J,isUnexpectedError:()=>ee,map:()=>be,mapError:()=>he,mapErrorTry:()=>De,mapTry:()=>Ue,match:()=>_e,ok:()=>S,orElse:()=>Fe,orElseAsync:()=>je,partition:()=>Ye,recover:()=>Ne,recoverAsync:()=>Ve,run:()=>$,tap:()=>Ie,tapError:()=>Oe,tryAsync:()=>Pe,unwrap:()=>Ce,unwrapOr:()=>xe,unwrapOrElse:()=>Se});module.exports=me($e);var S=e=>({ok:!0,value:e}),T=(e,t)=>({ok:!1,error:e,...t?.cause!==void 0?{cause:t.cause}:{}}),we=e=>e.ok,Te=e=>!e.ok,ee=e=>typeof e=="object"&&e!==null&&e.type==="UNEXPECTED_ERROR",O=Symbol.for("step_timeout_marker");function J(e){return typeof e!="object"||e===null?!1:e.type==="STEP_TIMEOUT"?!0:O in e}function te(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(O in e)return e[O]}}var G=Symbol("early-exit");function ne(e,t){return{[G]:!0,error:e,meta:t}}function re(e){return typeof e=="object"&&e!==null&&e[G]===!0}var oe=Symbol("mapper-exception");function ke(e){return{[oe]:!0,thrown:e}}function de(e){return typeof e=="object"&&e!==null&&e[oe]===!0}function fe(e){return typeof e=="string"?{name:e}:e??{}}function B(e,t){let{backoff:n,initialDelay:s,maxDelay:l,jitter:A}=t,k;switch(n){case"fixed":k=s;break;case"linear":k=s*e;break;case"exponential":k=s*Math.pow(2,e-1);break}if(k=Math.min(k,l),A){let o=k*.25*Math.random();k=k+o}return Math.floor(k)}function q(e){return new Promise(t=>setTimeout(t,e))}var Z=Symbol("timeout");async function Re(e,t,n){let s=new AbortController,l=t.error??{type:"STEP_TIMEOUT",stepName:n.name,stepKey:n.key,timeoutMs:t.ms,attempt:n.attempt},A,k=new Promise((h,x)=>{A=setTimeout(()=>{s.abort(),x({[Z]:!0,error:l})},t.ms)}),o;t.signal?o=Promise.resolve(e(s.signal)):o=Promise.resolve(e());try{return await Promise.race([o,k])}catch(h){if(typeof h=="object"&&h!==null&&h[Z]===!0){let x=h.error;if(typeof x=="object"&&x!==null&&x.type!=="STEP_TIMEOUT"){let K={timeoutMs:t.ms,stepName:n.name,stepKey:n.key,attempt:n.attempt};O in x?x[O]=K:Object.defineProperty(x,O,{value:K,enumerable:!1,writable:!0,configurable:!1})}throw x}throw h}finally{clearTimeout(A)}}var D={backoff:"exponential",initialDelay:100,maxDelay:3e4,jitter:!0,retryOn:()=>!0,onRetry:()=>{}};async function $(e,t){let{onError:n,onEvent:s,catchUnexpected:l,workflowId:A,context:k}=t&&typeof t=="object"?t:{},o=A??crypto.randomUUID(),h=!n&&!l,x=[],K=0,V=r=>r??`step_${++K}`,c=r=>{if(r.type==="step_success"){let b=r.stepId;for(let v=x.length-1;v>=0;v--){let w=x[v];if(w.type==="race"&&!w.winnerId){w.winnerId=b;break}}}s?.(r,k)},M=ne,H=r=>re(r),L=(r,b)=>h?b?.origin==="result"?{type:"UNEXPECTED_ERROR",cause:{type:"STEP_FAILURE",origin:"result",error:r,...b.resultCause!==void 0?{cause:b.resultCause}:{}}}:b?.origin==="throw"?{type:"UNEXPECTED_ERROR",cause:{type:"STEP_FAILURE",origin:"throw",error:r,thrown:b.thrown}}:{type:"UNEXPECTED_ERROR",cause:{type:"STEP_FAILURE",origin:"result",error:r}}:r,se=r=>r.origin==="result"?r.resultCause:r.thrown,ue=r=>({type:"UNEXPECTED_ERROR",cause:r.meta.origin==="result"?{type:"STEP_FAILURE",origin:"result",error:r.error,...r.meta.resultCause!==void 0?{cause:r.meta.resultCause}:{}}:{type:"STEP_FAILURE",origin:"throw",error:r.error,thrown:r.meta.thrown}});try{let r=(w,i)=>(async()=>{let m=fe(i),{name:u,key:a,retry:d,timeout:E}=m,p=V(a),f=s,R=f?performance.now():0;if(!(typeof w=="function")){if(d&&d.attempts>1)throw new Error("step: retry options require a function operation. Direct Promise/Result values cannot be re-executed on retry. Wrap your operation in a function: step(() => yourOperation, { retry: {...} })");if(E)throw new Error("step: timeout options require a function operation. Direct Promise/Result values cannot be wrapped with timeout after they've started. Wrap your operation in a function: step(() => yourOperation, { timeout: {...} })")}let g={attempts:Math.max(1,d?.attempts??1),backoff:d?.backoff??D.backoff,initialDelay:d?.initialDelay??D.initialDelay,maxDelay:d?.maxDelay??D.maxDelay,jitter:d?.jitter??D.jitter,retryOn:d?.retryOn??D.retryOn,onRetry:d?.onRetry??D.onRetry};s&&c({type:"step_start",workflowId:o,stepId:p,stepKey:a,name:u,ts:Date.now()});let z;for(let C=1;C<=g.attempts;C++){let ie=f?performance.now():0;try{let y;if(typeof w=="function"?E?y=await Re(w,E,{name:u,key:a,attempt:C}):y=await w():y=await w,y.ok){let _=performance.now()-R;return c({type:"step_success",workflowId:o,stepId:p,stepKey:a,name:u,ts:Date.now(),durationMs:_}),a&&c({type:"step_complete",workflowId:o,stepKey:a,name:u,ts:Date.now(),durationMs:_,result:y}),y.value}if(z=y,C<g.attempts&&g.retryOn(y.error,C)){let _=B(C,g);c({type:"step_retry",workflowId:o,stepId:p,stepKey:a,name:u,ts:Date.now(),attempt:C+1,maxAttempts:g.attempts,delayMs:_,error:y.error}),g.onRetry(y.error,C,_),await q(_);continue}g.attempts>1&&c({type:"step_retries_exhausted",workflowId:o,stepId:p,stepKey:a,name:u,ts:Date.now(),durationMs:performance.now()-R,attempts:C,lastError:y.error});break}catch(y){let _=performance.now()-ie;if(H(y))throw c({type:"step_aborted",workflowId:o,stepId:p,stepKey:a,name:u,ts:Date.now(),durationMs:_}),y;if(J(y)){let P=te(y),W=E?.ms??P?.timeoutMs??0;if(c({type:"step_timeout",workflowId:o,stepId:p,stepKey:a,name:u,ts:Date.now(),timeoutMs:W,attempt:C}),C<g.attempts&&g.retryOn(y,C)){let X=B(C,g);c({type:"step_retry",workflowId:o,stepId:p,stepKey:a,name:u,ts:Date.now(),attempt:C+1,maxAttempts:g.attempts,delayMs:X,error:y}),g.onRetry(y,C,X),await q(X);continue}g.attempts>1&&c({type:"step_retries_exhausted",workflowId:o,stepId:p,stepKey:a,name:u,ts:Date.now(),durationMs:performance.now()-R,attempts:C,lastError:y})}if(C<g.attempts&&g.retryOn(y,C)){let P=B(C,g);c({type:"step_retry",workflowId:o,stepId:p,stepKey:a,name:u,ts:Date.now(),attempt:C+1,maxAttempts:g.attempts,delayMs:P,error:y}),g.onRetry(y,C,P),await q(P);continue}g.attempts>1&&!J(y)&&c({type:"step_retries_exhausted",workflowId:o,stepId:p,stepKey:a,name:u,ts:Date.now(),durationMs:performance.now()-R,attempts:C,lastError:y});let j=performance.now()-R;if(l){let P;try{P=l(y)}catch(W){throw ke(W)}throw c({type:"step_error",workflowId:o,stepId:p,stepKey:a,name:u,ts:Date.now(),durationMs:j,error:P}),a&&c({type:"step_complete",workflowId:o,stepKey:a,name:u,ts:Date.now(),durationMs:j,result:T(P,{cause:y}),meta:{origin:"throw",thrown:y}}),n?.(P,u),M(P,{origin:"throw",thrown:y})}else{let P={type:"UNEXPECTED_ERROR",cause:{type:"UNCAUGHT_EXCEPTION",thrown:y}};throw c({type:"step_error",workflowId:o,stepId:p,stepKey:a,name:u,ts:Date.now(),durationMs:j,error:P}),a&&c({type:"step_complete",workflowId:o,stepKey:a,name:u,ts:Date.now(),durationMs:j,result:T(P,{cause:y}),meta:{origin:"throw",thrown:y}}),y}}}let I=z,Q=performance.now()-R,ae=L(I.error,{origin:"result",resultCause:I.cause});throw c({type:"step_error",workflowId:o,stepId:p,stepKey:a,name:u,ts:Date.now(),durationMs:Q,error:ae}),a&&c({type:"step_complete",workflowId:o,stepKey:a,name:u,ts:Date.now(),durationMs:Q,result:I,meta:{origin:"result",resultCause:I.cause}}),n?.(I.error,u),M(I.error,{origin:"result",resultCause:I.cause})})();r.try=(w,i)=>{let m=i.name,u=i.key,a=V(u),d="error"in i?()=>i.error:i.onError,E=s;return(async()=>{let p=E?performance.now():0;s&&c({type:"step_start",workflowId:o,stepId:a,stepKey:u,name:m,ts:Date.now()});try{let f=await w(),R=performance.now()-p;return c({type:"step_success",workflowId:o,stepId:a,stepKey:u,name:m,ts:Date.now(),durationMs:R}),u&&c({type:"step_complete",workflowId:o,stepKey:u,name:m,ts:Date.now(),durationMs:R,result:S(f)}),f}catch(f){let R=d(f),U=performance.now()-p,F=L(R,{origin:"throw",thrown:f});throw c({type:"step_error",workflowId:o,stepId:a,stepKey:u,name:m,ts:Date.now(),durationMs:U,error:F}),u&&c({type:"step_complete",workflowId:o,stepKey:u,name:m,ts:Date.now(),durationMs:U,result:T(R,{cause:f}),meta:{origin:"throw",thrown:f}}),n?.(R,m),M(R,{origin:"throw",thrown:f})}})()},r.fromResult=(w,i)=>{let m=i.name,u=i.key,a=V(u),d="error"in i?()=>i.error:i.onError,E=s;return(async()=>{let p=E?performance.now():0;s&&c({type:"step_start",workflowId:o,stepId:a,stepKey:u,name:m,ts:Date.now()});let f=await w();if(f.ok){let R=performance.now()-p;return c({type:"step_success",workflowId:o,stepId:a,stepKey:u,name:m,ts:Date.now(),durationMs:R}),u&&c({type:"step_complete",workflowId:o,stepKey:u,name:m,ts:Date.now(),durationMs:R,result:S(f.value)}),f.value}else{let R=d(f.error),U=performance.now()-p,F=L(R,{origin:"result",resultCause:f.error});throw c({type:"step_error",workflowId:o,stepId:a,stepKey:u,name:m,ts:Date.now(),durationMs:U,error:F}),u&&c({type:"step_complete",workflowId:o,stepKey:u,name:m,ts:Date.now(),durationMs:U,result:T(R,{cause:f.error}),meta:{origin:"result",resultCause:f.error}}),n?.(R,m),M(R,{origin:"result",resultCause:f.error})}})()},r.retry=(w,i)=>r(w,{name:i.name,key:i.key,retry:{attempts:i.attempts,backoff:i.backoff,initialDelay:i.initialDelay,maxDelay:i.maxDelay,jitter:i.jitter,retryOn:i.retryOn,onRetry:i.onRetry},timeout:i.timeout}),r.withTimeout=(w,i)=>r(w,{name:i.name,key:i.key,timeout:i}),r.parallel=(w,i)=>{let m=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let u=performance.now(),a=!1;x.push({scopeId:m,type:"parallel"});let d=()=>{if(a)return;a=!0;let E=x.findIndex(p=>p.scopeId===m);E!==-1&&x.splice(E,1),c({type:"scope_end",workflowId:o,scopeId:m,ts:Date.now(),durationMs:performance.now()-u})};c({type:"scope_start",workflowId:o,scopeId:m,scopeType:"parallel",name:w,ts:Date.now()});try{let E=await i();if(d(),!E.ok)throw n?.(E.error,w),M(E.error,{origin:"result",resultCause:E.cause});return E.value}catch(E){throw d(),E}})()},r.race=(w,i)=>{let m=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let u=performance.now(),a=!1,d={scopeId:m,type:"race",winnerId:void 0};x.push(d);let E=()=>{if(a)return;a=!0;let p=x.findIndex(f=>f.scopeId===m);p!==-1&&x.splice(p,1),c({type:"scope_end",workflowId:o,scopeId:m,ts:Date.now(),durationMs:performance.now()-u,winnerId:d.winnerId})};c({type:"scope_start",workflowId:o,scopeId:m,scopeType:"race",name:w,ts:Date.now()});try{let p=await i();if(E(),!p.ok)throw n?.(p.error,w),M(p.error,{origin:"result",resultCause:p.cause});return p.value}catch(p){throw E(),p}})()},r.allSettled=(w,i)=>{let m=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let u=performance.now(),a=!1;x.push({scopeId:m,type:"allSettled"});let d=()=>{if(a)return;a=!0;let E=x.findIndex(p=>p.scopeId===m);E!==-1&&x.splice(E,1),c({type:"scope_end",workflowId:o,scopeId:m,ts:Date.now(),durationMs:performance.now()-u})};c({type:"scope_start",workflowId:o,scopeId:m,scopeType:"allSettled",name:w,ts:Date.now()});try{let E=await i();if(d(),!E.ok)throw n?.(E.error,w),M(E.error,{origin:"result",resultCause:E.cause});return E.value}catch(E){throw d(),E}})()};let v=await e(r);return S(v)}catch(r){if(de(r))throw r.thrown;if(H(r)){let v=se(r.meta);if(l||n)return T(r.error,{cause:v});if(ee(r.error))return T(r.error,{cause:v});let w=ue(r);return T(w,{cause:v})}if(l){let v=l(r);return n?.(v,"unexpected"),T(v,{cause:r})}let b={type:"UNEXPECTED_ERROR",cause:{type:"UNCAUGHT_EXCEPTION",thrown:r}};return n?.(b,"unexpected"),T(b,{cause:r})}}$.strict=(e,t)=>$(e,t);var N=class extends Error{constructor(n,s){super(`Unwrap called on an error result: ${String(n)}`);this.error=n;this.cause=s;this.name="UnwrapError"}},Ce=e=>{if(e.ok)return e.value;throw new N(e.error,e.cause)},xe=(e,t)=>e.ok?e.value:t,Se=(e,t)=>e.ok?e.value:t(e.error,e.cause);function ge(e,t){try{return S(e())}catch(n){return t?T(t(n),{cause:n}):T(n)}}async function Ae(e,t){try{return S(await e)}catch(n){return t?T(t(n),{cause:n}):T(n)}}async function Pe(e,t){try{return S(await e())}catch(n){return t?T(t(n),{cause:n}):T(n)}}function ve(e,t){return e!=null?S(e):T(t())}function be(e,t){return e.ok?S(t(e.value)):e}function he(e,t){return e.ok?e:T(t(e.error),{cause:e.cause})}function _e(e,t){return e.ok?t.ok(e.value):t.err(e.error,e.cause)}function Me(e,t){return e.ok?t(e.value):e}function Ie(e,t){return e.ok&&t(e.value),e}function Oe(e,t){return e.ok||t(e.error,e.cause),e}function Ue(e,t,n){if(!e.ok)return e;try{return S(t(e.value))}catch(s){return T(n(s),{cause:s})}}function De(e,t,n){if(e.ok)return e;try{return T(t(e.error),{cause:e.cause})}catch(s){return T(n(s),{cause:s})}}function Ke(e,t,n){return e.ok?S(t(e.value)):T(n(e.error),{cause:e.cause})}function Fe(e,t){return e.ok?e:t(e.error,e.cause)}async function je(e,t){let n=await e;return n.ok?n:t(n.error,n.cause)}function Ne(e,t){return e.ok?S(e.value):S(t(e.error,e.cause))}async function Ve(e,t){let n=await e;return n.ok?S(n.value):S(await t(n.error,n.cause))}function Le(e){let t=[];for(let n of e){if(!n.ok)return n;t.push(n.value)}return S(t)}async function We(e){return e.length===0?S([]):new Promise(t=>{let n=!1,s=e.length,l=new Array(e.length);for(let A=0;A<e.length;A++){let k=A;Promise.resolve(e[k]).catch(o=>T({type:"PROMISE_REJECTED",cause:o},{cause:{type:"PROMISE_REJECTION",reason:o}})).then(o=>{if(!n){if(!o.ok){n=!0,t(o);return}l[k]=o.value,s--,s===0&&t(S(l))}})}})}function Xe(e){let t=[],n=[];for(let s of e)s.ok?t.push(s.value):n.push({error:s.error,cause:s.cause});return n.length>0?T(n):S(t)}function Ye(e){let t=[],n=[];for(let s of e)s.ok?t.push(s.value):n.push(s.error);return{values:t,errors:n}}function Be(e){if(e.length===0)return T({type:"EMPTY_INPUT",message:"any() requires at least one Result"});let t=null;for(let n of e){if(n.ok)return n;t||(t=n)}return t}async function qe(e){return e.length===0?T({type:"EMPTY_INPUT",message:"anyAsync() requires at least one Result"}):new Promise(t=>{let n=!1,s=e.length,l=null;for(let A of e)Promise.resolve(A).catch(k=>T({type:"PROMISE_REJECTED",cause:k},{cause:{type:"PROMISE_REJECTION",reason:k}})).then(k=>{if(!n){if(k.ok){n=!0,t(k);return}l||(l=k),s--,s===0&&t(l)}})})}async function Je(e){let t=await Promise.all(e.map(l=>Promise.resolve(l).then(A=>({status:"result",result:A})).catch(A=>({status:"rejected",error:{type:"PROMISE_REJECTED",cause:A},cause:{type:"PROMISE_REJECTION",reason:A}})))),n=[],s=[];for(let l of t)l.status==="rejected"?s.push({error:l.error,cause:l.cause}):l.result.ok?n.push(l.result.value):s.push({error:l.result.error,cause:l.result.cause});return s.length>0?T(s):S(n)}0&&(module.exports={EARLY_EXIT_SYMBOL,STEP_TIMEOUT_MARKER,UnwrapError,all,allAsync,allSettled,allSettledAsync,andThen,any,anyAsync,bimap,createEarlyExit,err,from,fromNullable,fromPromise,getStepTimeoutMeta,isEarlyExit,isErr,isOk,isStepTimeoutError,isUnexpectedError,map,mapError,mapErrorTry,mapTry,match,ok,orElse,orElseAsync,partition,recover,recoverAsync,run,tap,tapError,tryAsync,unwrap,unwrapOr,unwrapOrElse});
+"use strict";var G=Object.defineProperty;var Ee=Object.getOwnPropertyDescriptor;var ye=Object.getOwnPropertyNames;var we=Object.prototype.hasOwnProperty;var me=(e,t)=>{for(var n in t)G(e,n,{get:t[n],enumerable:!0})},Te=(e,t,n,a)=>{if(t&&typeof t=="object"||typeof t=="function")for(let w of ye(t))!we.call(e,w)&&w!==n&&G(e,w,{get:()=>t[w],enumerable:!(a=Ee(t,w))||a.enumerable});return e};var ke=e=>Te(G({},"__esModule",{value:!0}),e);var Qe={};me(Qe,{EARLY_EXIT_SYMBOL:()=>ee,STEP_TIMEOUT_MARKER:()=>D,UnwrapError:()=>X,all:()=>$e,allAsync:()=>Je,allSettled:()=>Be,allSettledAsync:()=>ze,andThen:()=>Ue,any:()=>Ge,anyAsync:()=>He,bimap:()=>Ne,createEarlyExit:()=>se,err:()=>f,from:()=>Pe,fromNullable:()=>ve,fromPromise:()=>he,getStepTimeoutMeta:()=>oe,hydrate:()=>ie,isEarlyExit:()=>ue,isErr:()=>fe,isOk:()=>de,isSerializedResult:()=>Ye,isStepTimeoutError:()=>Q,isUnexpectedError:()=>re,map:()=>Me,mapError:()=>Ie,mapErrorTry:()=>Fe,mapTry:()=>je,match:()=>Oe,ok:()=>g,orElse:()=>Ve,orElseAsync:()=>Le,partition:()=>qe,recover:()=>We,recoverAsync:()=>Xe,run:()=>Z,tap:()=>De,tapError:()=>Ke,tryAsync:()=>_e,unwrap:()=>ge,unwrapOr:()=>Ae,unwrapOrElse:()=>be});module.exports=ke(Qe);var g=e=>({ok:!0,value:e}),f=(e,t)=>({ok:!1,error:e,...t?.cause!==void 0?{cause:t.cause}:{}}),de=e=>e.ok,fe=e=>!e.ok,re=e=>typeof e=="object"&&e!==null&&e.type==="UNEXPECTED_ERROR",D=Symbol.for("step_timeout_marker");function Q(e){return typeof e!="object"||e===null?!1:e.type==="STEP_TIMEOUT"?!0:D in e}function oe(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(D in e)return e[D]}}var ee=Symbol("early-exit");function se(e,t){return{[ee]:!0,error:e,meta:t}}function ue(e){return typeof e=="object"&&e!==null&&e[ee]===!0}var ae=Symbol("mapper-exception");function Re(e){return{[ae]:!0,thrown:e}}function Ce(e){return typeof e=="object"&&e!==null&&e[ae]===!0}function xe(e){return typeof e=="string"?{name:e}:e??{}}function H(e,t){let{backoff:n,initialDelay:a,maxDelay:w,jitter:A}=t,E;switch(n){case"fixed":E=a;break;case"linear":E=a*e;break;case"exponential":E=a*Math.pow(2,e-1);break}if(E=Math.min(E,w),A){let r=E*.25*Math.random();E=E+r}return Math.floor(E)}function z(e){return new Promise(t=>setTimeout(t,e))}var ne=Symbol("timeout");async function Se(e,t,n){let a=new AbortController,w=t.error??{type:"STEP_TIMEOUT",stepName:n.name,stepKey:n.key,timeoutMs:t.ms,attempt:n.attempt},A,E=new Promise((I,C)=>{A=setTimeout(()=>{a.abort(),C({[ne]:!0,error:w})},t.ms)}),r;t.signal?r=Promise.resolve(e(a.signal)):r=Promise.resolve(e());try{return await Promise.race([r,E])}catch(I){if(typeof I=="object"&&I!==null&&I[ne]===!0){let C=I.error;if(typeof C=="object"&&C!==null&&C.type!=="STEP_TIMEOUT"){let L={timeoutMs:t.ms,stepName:n.name,stepKey:n.key,attempt:n.attempt};D in C?C[D]=L:Object.defineProperty(C,D,{value:L,enumerable:!1,writable:!0,configurable:!1})}throw C}throw I}finally{clearTimeout(A)}}var F={backoff:"exponential",initialDelay:100,maxDelay:3e4,jitter:!0,retryOn:()=>!0,onRetry:()=>{}};async function Z(e,t){let{onError:n,onEvent:a,catchUnexpected:w,workflowId:A,context:E}=t&&typeof t=="object"?t:{},r=A??crypto.randomUUID(),I=!n&&!w,C=[],L=0,Y=o=>o??`step_${++L}`,y=o=>{let b=o.context!==void 0||E===void 0?o:{...o,context:E};if(b.type==="step_success"){let M=b.stepId;for(let K=C.length-1;K>=0;K--){let N=C[K];if(N.type==="race"&&!N.winnerId){N.winnerId=M;break}}}a?.(b,E)},O=se,te=o=>ue(o),$=(o,b)=>I?b?.origin==="result"?{type:"UNEXPECTED_ERROR",cause:{type:"STEP_FAILURE",origin:"result",error:o,...b.resultCause!==void 0?{cause:b.resultCause}:{}}}:b?.origin==="throw"?{type:"UNEXPECTED_ERROR",cause:{type:"STEP_FAILURE",origin:"throw",error:o,thrown:b.thrown}}:{type:"UNEXPECTED_ERROR",cause:{type:"STEP_FAILURE",origin:"result",error:o}}:o,pe=o=>o.origin==="result"?o.resultCause:o.thrown,le=o=>({type:"UNEXPECTED_ERROR",cause:o.meta.origin==="result"?{type:"STEP_FAILURE",origin:"result",error:o.error,...o.meta.resultCause!==void 0?{cause:o.meta.resultCause}:{}}:{type:"STEP_FAILURE",origin:"throw",error:o.error,thrown:o.meta.thrown}});try{let b=function(T,p){let i=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let s=performance.now(),u=!1;C.push({scopeId:i,type:"parallel"});let x=()=>{if(u)return;u=!0;let c=C.findIndex(l=>l.scopeId===i);c!==-1&&C.splice(c,1),y({type:"scope_end",workflowId:r,scopeId:i,ts:Date.now(),durationMs:performance.now()-s})};y({type:"scope_start",workflowId:r,scopeId:i,scopeType:"parallel",name:T,ts:Date.now()});try{let c=await p();if(x(),!c.ok)throw n?.(c.error,T,E),O(c.error,{origin:"result",resultCause:c.cause});return c.value}catch(c){throw x(),c}})()},M=function(T,p){let i=Object.keys(T),s=p.name??`Parallel(${i.join(", ")})`,u=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let x=performance.now(),c=!1;C.push({scopeId:u,type:"parallel"});let l=()=>{if(c)return;c=!0;let k=C.findIndex(R=>R.scopeId===u);k!==-1&&C.splice(k,1),y({type:"scope_end",workflowId:r,scopeId:u,ts:Date.now(),durationMs:performance.now()-x})};y({type:"scope_start",workflowId:r,scopeId:u,scopeType:"parallel",name:s,ts:Date.now()});try{let k=await new Promise(h=>{if(i.length===0){h([]);return}let _=!1,S=i.length,V=new Array(i.length);for(let v=0;v<i.length;v++){let j=i[v],J=v;Promise.resolve(T[j]()).catch(d=>f({type:"PROMISE_REJECTED",cause:d},{cause:{type:"PROMISE_REJECTION",reason:d}})).then(d=>{if(!_){if(!d.ok){_=!0,h([{key:j,result:d}]);return}V[J]={key:j,result:d},S--,S===0&&h(V)}})}});l();let R={};for(let{key:h,result:_}of k){if(!_.ok)throw n?.(_.error,h,E),O(_.error,{origin:"result",resultCause:_.cause});R[h]=_.value}return R}catch(k){throw l(),k}})()};var Ze=b,et=M;let o=(T,p)=>(async()=>{let i=xe(p),{name:s,key:u,retry:x,timeout:c}=i,l=Y(u),k=a,R=k?performance.now():0;if(!(typeof T=="function")){if(x&&x.attempts>1)throw new Error("step: retry options require a function operation. Direct Promise/Result values cannot be re-executed on retry. Wrap your operation in a function: step(() => yourOperation, { retry: {...} })");if(c)throw new Error("step: timeout options require a function operation. Direct Promise/Result values cannot be wrapped with timeout after they've started. Wrap your operation in a function: step(() => yourOperation, { timeout: {...} })")}let S={attempts:Math.max(1,x?.attempts??1),backoff:x?.backoff??F.backoff,initialDelay:x?.initialDelay??F.initialDelay,maxDelay:x?.maxDelay??F.maxDelay,jitter:x?.jitter??F.jitter,retryOn:x?.retryOn??F.retryOn,onRetry:x?.onRetry??F.onRetry};a&&y({type:"step_start",workflowId:r,stepId:l,stepKey:u,name:s,ts:Date.now()});let V;for(let d=1;d<=S.attempts;d++){let ce=k?performance.now():0;try{let m;if(typeof T=="function"?c?m=await Se(T,c,{name:s,key:u,attempt:d}):m=await T():m=await T,m.ok){let U=performance.now()-R;return y({type:"step_success",workflowId:r,stepId:l,stepKey:u,name:s,ts:Date.now(),durationMs:U}),u&&y({type:"step_complete",workflowId:r,stepKey:u,name:s,ts:Date.now(),durationMs:U,result:m}),m.value}if(V=m,d<S.attempts&&S.retryOn(m.error,d)){let U=H(d,S);y({type:"step_retry",workflowId:r,stepId:l,stepKey:u,name:s,ts:Date.now(),attempt:d+1,maxAttempts:S.attempts,delayMs:U,error:m.error}),S.onRetry(m.error,d,U),await z(U);continue}S.attempts>1&&y({type:"step_retries_exhausted",workflowId:r,stepId:l,stepKey:u,name:s,ts:Date.now(),durationMs:performance.now()-R,attempts:d,lastError:m.error});break}catch(m){let U=performance.now()-ce;if(te(m))throw y({type:"step_aborted",workflowId:r,stepId:l,stepKey:u,name:s,ts:Date.now(),durationMs:U}),m;if(Q(m)){let P=oe(m),B=c?.ms??P?.timeoutMs??0;if(y({type:"step_timeout",workflowId:r,stepId:l,stepKey:u,name:s,ts:Date.now(),timeoutMs:B,attempt:d}),d<S.attempts&&S.retryOn(m,d)){let q=H(d,S);y({type:"step_retry",workflowId:r,stepId:l,stepKey:u,name:s,ts:Date.now(),attempt:d+1,maxAttempts:S.attempts,delayMs:q,error:m}),S.onRetry(m,d,q),await z(q);continue}S.attempts>1&&y({type:"step_retries_exhausted",workflowId:r,stepId:l,stepKey:u,name:s,ts:Date.now(),durationMs:performance.now()-R,attempts:d,lastError:m})}if(d<S.attempts&&S.retryOn(m,d)){let P=H(d,S);y({type:"step_retry",workflowId:r,stepId:l,stepKey:u,name:s,ts:Date.now(),attempt:d+1,maxAttempts:S.attempts,delayMs:P,error:m}),S.onRetry(m,d,P),await z(P);continue}S.attempts>1&&!Q(m)&&y({type:"step_retries_exhausted",workflowId:r,stepId:l,stepKey:u,name:s,ts:Date.now(),durationMs:performance.now()-R,attempts:d,lastError:m});let W=performance.now()-R;if(w){let P;try{P=w(m)}catch(B){throw Re(B)}throw y({type:"step_error",workflowId:r,stepId:l,stepKey:u,name:s,ts:Date.now(),durationMs:W,error:P}),u&&y({type:"step_complete",workflowId:r,stepKey:u,name:s,ts:Date.now(),durationMs:W,result:f(P,{cause:m}),meta:{origin:"throw",thrown:m}}),n?.(P,s,E),O(P,{origin:"throw",thrown:m})}else{let P={type:"UNEXPECTED_ERROR",cause:{type:"UNCAUGHT_EXCEPTION",thrown:m}};throw y({type:"step_error",workflowId:r,stepId:l,stepKey:u,name:s,ts:Date.now(),durationMs:W,error:P}),u&&y({type:"step_complete",workflowId:r,stepKey:u,name:s,ts:Date.now(),durationMs:W,result:f(P,{cause:m}),meta:{origin:"throw",thrown:m}}),m}}}let v=V,j=performance.now()-R,J=$(v.error,{origin:"result",resultCause:v.cause});throw y({type:"step_error",workflowId:r,stepId:l,stepKey:u,name:s,ts:Date.now(),durationMs:j,error:J}),u&&y({type:"step_complete",workflowId:r,stepKey:u,name:s,ts:Date.now(),durationMs:j,result:v,meta:{origin:"result",resultCause:v.cause}}),n?.(v.error,s,E),O(v.error,{origin:"result",resultCause:v.cause})})();o.try=(T,p)=>{let i=p.name,s=p.key,u=Y(s),x="error"in p?()=>p.error:p.onError,c=a;return(async()=>{let l=c?performance.now():0;a&&y({type:"step_start",workflowId:r,stepId:u,stepKey:s,name:i,ts:Date.now()});try{let k=await T(),R=performance.now()-l;return y({type:"step_success",workflowId:r,stepId:u,stepKey:s,name:i,ts:Date.now(),durationMs:R}),s&&y({type:"step_complete",workflowId:r,stepKey:s,name:i,ts:Date.now(),durationMs:R,result:g(k)}),k}catch(k){let R=x(k),h=performance.now()-l,_=$(R,{origin:"throw",thrown:k});throw y({type:"step_error",workflowId:r,stepId:u,stepKey:s,name:i,ts:Date.now(),durationMs:h,error:_}),s&&y({type:"step_complete",workflowId:r,stepKey:s,name:i,ts:Date.now(),durationMs:h,result:f(R,{cause:k}),meta:{origin:"throw",thrown:k}}),n?.(R,i,E),O(R,{origin:"throw",thrown:k})}})()},o.fromResult=(T,p)=>{let i=p.name,s=p.key,u=Y(s),x="error"in p?()=>p.error:p.onError,c=a;return(async()=>{let l=c?performance.now():0;a&&y({type:"step_start",workflowId:r,stepId:u,stepKey:s,name:i,ts:Date.now()});let k=await T();if(k.ok){let R=performance.now()-l;return y({type:"step_success",workflowId:r,stepId:u,stepKey:s,name:i,ts:Date.now(),durationMs:R}),s&&y({type:"step_complete",workflowId:r,stepKey:s,name:i,ts:Date.now(),durationMs:R,result:g(k.value)}),k.value}else{let R=x(k.error),h=performance.now()-l,_=$(R,{origin:"result",resultCause:k.error});throw y({type:"step_error",workflowId:r,stepId:u,stepKey:s,name:i,ts:Date.now(),durationMs:h,error:_}),s&&y({type:"step_complete",workflowId:r,stepKey:s,name:i,ts:Date.now(),durationMs:h,result:f(R,{cause:k.error}),meta:{origin:"result",resultCause:k.error}}),n?.(R,i,E),O(R,{origin:"result",resultCause:k.error})}})()},o.retry=(T,p)=>o(T,{name:p.name,key:p.key,retry:{attempts:p.attempts,backoff:p.backoff,initialDelay:p.initialDelay,maxDelay:p.maxDelay,jitter:p.jitter,retryOn:p.retryOn,onRetry:p.onRetry},timeout:p.timeout}),o.withTimeout=(T,p)=>o(T,{name:p.name,key:p.key,timeout:p}),o.parallel=((...T)=>{if(typeof T[0]=="string"){let p=T[0],i=T[1];return b(p,i)}else{let p=T[0],i=T[1]??{};return M(p,i)}}),o.race=(T,p)=>{let i=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let s=performance.now(),u=!1,x={scopeId:i,type:"race",winnerId:void 0};C.push(x);let c=()=>{if(u)return;u=!0;let l=C.findIndex(k=>k.scopeId===i);l!==-1&&C.splice(l,1),y({type:"scope_end",workflowId:r,scopeId:i,ts:Date.now(),durationMs:performance.now()-s,winnerId:x.winnerId})};y({type:"scope_start",workflowId:r,scopeId:i,scopeType:"race",name:T,ts:Date.now()});try{let l=await p();if(c(),!l.ok)throw n?.(l.error,T,E),O(l.error,{origin:"result",resultCause:l.cause});return l.value}catch(l){throw c(),l}})()},o.allSettled=(T,p)=>{let i=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let s=performance.now(),u=!1;C.push({scopeId:i,type:"allSettled"});let x=()=>{if(u)return;u=!0;let c=C.findIndex(l=>l.scopeId===i);c!==-1&&C.splice(c,1),y({type:"scope_end",workflowId:r,scopeId:i,ts:Date.now(),durationMs:performance.now()-s})};y({type:"scope_start",workflowId:r,scopeId:i,scopeType:"allSettled",name:T,ts:Date.now()});try{let c=await p();if(x(),!c.ok)throw n?.(c.error,T,E),O(c.error,{origin:"result",resultCause:c.cause});return c.value}catch(c){throw x(),c}})()};let N=await e(o);return g(N)}catch(o){if(Ce(o))throw o.thrown;if(te(o)){let M=pe(o.meta);if(w||n)return f(o.error,{cause:M});if(re(o.error))return f(o.error,{cause:M});let K=le(o);return f(K,{cause:M})}if(w){let M=w(o);return n?.(M,"unexpected",E),f(M,{cause:o})}let b={type:"UNEXPECTED_ERROR",cause:{type:"UNCAUGHT_EXCEPTION",thrown:o}};return n?.(b,"unexpected",E),f(b,{cause:o})}}Z.strict=(e,t)=>Z(e,t);var X=class extends Error{constructor(n,a){super(`Unwrap called on an error result: ${String(n)}`);this.error=n;this.cause=a;this.name="UnwrapError"}},ge=e=>{if(e.ok)return e.value;throw new X(e.error,e.cause)},Ae=(e,t)=>e.ok?e.value:t,be=(e,t)=>e.ok?e.value:t(e.error,e.cause);function Pe(e,t){try{return g(e())}catch(n){return t?f(t(n),{cause:n}):f(n)}}async function he(e,t){try{return g(await e)}catch(n){return t?f(t(n),{cause:n}):f(n)}}async function _e(e,t){try{return g(await e())}catch(n){return t?f(t(n),{cause:n}):f(n)}}function ve(e,t){return e!=null?g(e):f(t())}function Me(e,t){return e.ok?g(t(e.value)):e}function Ie(e,t){return e.ok?e:f(t(e.error),{cause:e.cause})}function Oe(e,t){return e.ok?t.ok(e.value):t.err(e.error,e.cause)}function Ue(e,t){return e.ok?t(e.value):e}function De(e,t){return e.ok&&t(e.value),e}function Ke(e,t){return e.ok||t(e.error,e.cause),e}function je(e,t,n){if(!e.ok)return e;try{return g(t(e.value))}catch(a){return f(n(a),{cause:a})}}function Fe(e,t,n){if(e.ok)return e;try{return f(t(e.error),{cause:e.cause})}catch(a){return f(n(a),{cause:a})}}function Ne(e,t,n){return e.ok?g(t(e.value)):f(n(e.error),{cause:e.cause})}function Ve(e,t){return e.ok?e:t(e.error,e.cause)}async function Le(e,t){let n=await e;return n.ok?n:t(n.error,n.cause)}function We(e,t){return e.ok?g(e.value):g(t(e.error,e.cause))}async function Xe(e,t){let n=await e;return n.ok?g(n.value):g(await t(n.error,n.cause))}function ie(e){return e!==null&&typeof e=="object"&&"ok"in e&&typeof e.ok=="boolean"&&(e.ok===!0&&"value"in e||e.ok===!1&&"error"in e)?e:null}function Ye(e){return ie(e)!==null}function $e(e){let t=[];for(let n of e){if(!n.ok)return n;t.push(n.value)}return g(t)}async function Je(e){return e.length===0?g([]):new Promise(t=>{let n=!1,a=e.length,w=new Array(e.length);for(let A=0;A<e.length;A++){let E=A;Promise.resolve(e[E]).catch(r=>f({type:"PROMISE_REJECTED",cause:r},{cause:{type:"PROMISE_REJECTION",reason:r}})).then(r=>{if(!n){if(!r.ok){n=!0,t(r);return}w[E]=r.value,a--,a===0&&t(g(w))}})}})}function Be(e){let t=[],n=[];for(let a of e)a.ok?t.push(a.value):n.push({error:a.error,cause:a.cause});return n.length>0?f(n):g(t)}function qe(e){let t=[],n=[];for(let a of e)a.ok?t.push(a.value):n.push(a.error);return{values:t,errors:n}}function Ge(e){if(e.length===0)return f({type:"EMPTY_INPUT",message:"any() requires at least one Result"});let t=null;for(let n of e){if(n.ok)return n;t||(t=n)}return t}async function He(e){return e.length===0?f({type:"EMPTY_INPUT",message:"anyAsync() requires at least one Result"}):new Promise(t=>{let n=!1,a=e.length,w=null;for(let A of e)Promise.resolve(A).catch(E=>f({type:"PROMISE_REJECTED",cause:E},{cause:{type:"PROMISE_REJECTION",reason:E}})).then(E=>{if(!n){if(E.ok){n=!0,t(E);return}w||(w=E),a--,a===0&&t(w)}})})}async function ze(e){let t=await Promise.all(e.map(w=>Promise.resolve(w).then(A=>({status:"result",result:A})).catch(A=>({status:"rejected",error:{type:"PROMISE_REJECTED",cause:A},cause:{type:"PROMISE_REJECTION",reason:A}})))),n=[],a=[];for(let w of t)w.status==="rejected"?a.push({error:w.error,cause:w.cause}):w.result.ok?n.push(w.result.value):a.push({error:w.result.error,cause:w.result.cause});return a.length>0?f(a):g(n)}0&&(module.exports={EARLY_EXIT_SYMBOL,STEP_TIMEOUT_MARKER,UnwrapError,all,allAsync,allSettled,allSettledAsync,andThen,any,anyAsync,bimap,createEarlyExit,err,from,fromNullable,fromPromise,getStepTimeoutMeta,hydrate,isEarlyExit,isErr,isOk,isSerializedResult,isStepTimeoutError,isUnexpectedError,map,mapError,mapErrorTry,mapTry,match,ok,orElse,orElseAsync,partition,recover,recoverAsync,run,tap,tapError,tryAsync,unwrap,unwrapOr,unwrapOrElse});
 //# sourceMappingURL=core.cjs.map