awaitly 1.34.0 → 2.0.0

package/dist/conditional.cjs

@@ -1,2 +0,0 @@
-"use strict";var d=Object.defineProperty;var c=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var O=Object.prototype.hasOwnProperty;var w=(o,n)=>{for(var t in n)d(o,t,{get:n[t],enumerable:!0})},x=(o,n,t,e)=>{if(n&&typeof n=="object"||typeof n=="function")for(let i of f(n))!O.call(o,i)&&i!==t&&d(o,i,{get:()=>n[i],enumerable:!(e=c(n,i))||e.enumerable});return o};var y=o=>x(d({},"__esModule",{value:!0}),o);var k={};w(k,{createConditionalHelpers:()=>u,unless:()=>s,unlessOr:()=>C,when:()=>a,whenOr:()=>r});module.exports=y(k);function l(){return`decision_${Date.now()}_${Math.random().toString(36).slice(2,8)}`}function p(o,n,t){if(!o?.onEvent)return;let e={type:"step_skipped",workflowId:o.workflowId,stepKey:n?.key,name:n?.name,reason:n?.reason,decisionId:t,ts:Date.now()},i=e.context!==void 0||o.context===void 0?e:{...e,context:o.context};o.onEvent(i)}function a(o,n,t,e){if(o)return n();let i=l();p(e,t,i)}function s(o,n,t,e){return a(!o,n,t,e)}function r(o,n,t,e,i){if(o)return n();let T=l();return p(i,e,T),t}function C(o,n,t,e,i){return r(!o,n,t,e,i)}function u(o){return{when:(n,t,e)=>a(n,t,e,o),unless:(n,t,e)=>s(n,t,e,o),whenOr:(n,t,e,i)=>r(n,t,e,i,o),unlessOr:(n,t,e,i)=>C(n,t,e,i,o)}}0&&(module.exports={createConditionalHelpers,unless,unlessOr,when,whenOr});
-//# sourceMappingURL=conditional.cjs.map

package/dist/conditional.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/conditional-entry.ts","../src/conditional.ts"],"sourcesContent":["/**\n * awaitly/conditional\n *\n * Conditional execution helpers: when/unless for cleaner branching logic.\n *\n * @example\n * ```typescript\n * import { when, unless } from 'awaitly/conditional';\n *\n * const result = await workflow(async ({ step }) => {\n *   const user = await step(fetchUser(id));\n *   await when(user.isAdmin, () => step(logAdminAccess(user)));\n *   return user;\n * });\n * ```\n */\n\nexport {\n  // Types\n  type ConditionalOptions,\n  type ConditionalContext,\n\n  // Functions\n  when,\n  unless,\n  whenOr,\n  unlessOr,\n  createConditionalHelpers,\n} from \"./conditional\";\n","/**\n * awaitly/conditional\n *\n * Conditional step execution helpers for workflows.\n * These helpers allow you to conditionally execute steps based on runtime conditions,\n * with proper event emission for skipped steps.\n */\n\nimport type { WorkflowEvent } from \"./core\";\n\n// =============================================================================\n// Types\n// =============================================================================\n\n/**\n * Options for conditional execution.\n */\nexport type ConditionalOptions = {\n  /**\n   * Human-readable name for the conditional step.\n   * Used in step_skipped events for debugging and visualization.\n   */\n  name?: string;\n\n  /**\n   * Stable identity key for the conditional step.\n   * Used in step_skipped events for tracking and visualization.\n   */\n  key?: string;\n\n  /**\n   * Optional reason explaining why the step was skipped.\n   * Included in step_skipped events.\n   */\n  reason?: string;\n};\n\n/**\n * Context for conditional execution, used to emit events.\n */\nexport type ConditionalContext<C = unknown> = {\n  /**\n   * The workflow ID for event emission.\n   */\n  workflowId: string;\n\n  /**\n   * Event emitter function.\n   */\n  onEvent?: (event: WorkflowEvent<unknown, C>) => void;\n\n  /**\n   * Optional context value to include in emitted events.\n   * When provided, this context is automatically added to step_skipped events.\n   */\n  context?: C;\n};\n\n/**\n * Type for operations that can be either sync or async.\n */\ntype MaybeAsync<T> = T | Promise<T>;\n\n/**\n * Type for the operation function passed to conditional helpers.\n */\ntype Operation<T> = () => MaybeAsync<T>;\n\n// =============================================================================\n// Internal Helpers\n// =============================================================================\n\n/**\n * Generate a unique decision ID for tracking conditional decisions.\n * @internal\n */\nfunction generateDecisionId(): string {\n  return `decision_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;\n}\n\n/**\n * Emit a step_skipped event.\n * @internal\n */\nfunction emitSkipped<C = unknown>(\n  ctx: ConditionalContext<C> | undefined,\n  options: ConditionalOptions | undefined,\n  decisionId: string\n): void {\n  if (!ctx?.onEvent) return;\n\n  // Create event with context if provided (similar to emitEvent logic)\n  const event: WorkflowEvent<unknown, C> = {\n    type: \"step_skipped\",\n    workflowId: ctx.workflowId,\n    stepKey: options?.key,\n    name: options?.name,\n    reason: options?.reason,\n    decisionId,\n    ts: Date.now(),\n  };\n\n  // Add context to event only if:\n  // 1. Event doesn't already have context (preserves replayed events)\n  // 2. Context is actually provided (don't add context: undefined property)\n  const eventWithContext =\n    event.context !== undefined || ctx.context === undefined\n      ? event\n      : ({ ...event, context: ctx.context } as WorkflowEvent<unknown, C>);\n\n  ctx.onEvent(eventWithContext);\n}\n\n// =============================================================================\n// Conditional Helpers\n// =============================================================================\n\n/**\n * Run a step only if condition is true, return undefined if skipped.\n *\n * Use this when you want to conditionally execute a step and handle\n * the undefined case yourself. For a version with a default value,\n * use `whenOr`.\n *\n * @param condition - Boolean condition to evaluate\n * @param operation - Function that performs the step (only called if condition is true)\n * @param options - Optional configuration for the conditional step\n * @param ctx - Optional context for event emission\n * @returns The result of the operation if condition is true, undefined otherwise\n *\n * @example\n * ```typescript\n * const result = await workflow(async ({ step }) => {\n *   const user = await step('fetchUser', () => fetchUser(id));\n *\n *   // Only runs if user is premium\n *   const premium = await when(\n *     user.isPremium,\n *     () => step('fetchPremiumData', () => fetchPremiumData(user.id)),\n *     { name: 'check-premium', reason: 'User is not premium' }\n *   );\n *\n *   return { user, premium };\n * });\n * ```\n */\nexport function when<T, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): Promise<T | undefined>;\n\n/**\n * Synchronous overload for when the operation returns a non-Promise value.\n */\nexport function when<T, C = unknown>(\n  condition: boolean,\n  operation: () => T,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): T | undefined | Promise<T | undefined>;\n\nexport function when<T, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): MaybeAsync<T | undefined> {\n  if (condition) {\n    return operation();\n  }\n\n  const decisionId = generateDecisionId();\n  emitSkipped(ctx, options, decisionId);\n  return undefined;\n}\n\n/**\n * Run a step only if condition is false, return undefined if skipped.\n *\n * Use this when you want to conditionally execute a step when a condition\n * is NOT met. For a version with a default value, use `unlessOr`.\n *\n * @param condition - Boolean condition to evaluate\n * @param operation - Function that performs the step (only called if condition is false)\n * @param options - Optional configuration for the conditional step\n * @param ctx - Optional context for event emission\n * @returns The result of the operation if condition is false, undefined otherwise\n *\n * @example\n * ```typescript\n * const result = await workflow(async ({ step }) => {\n *   const user = await step(fetchUser(id));\n *\n *   // Only runs if user is NOT verified\n *   const verification = await unless(\n *     user.isVerified,\n *     () => step(() => sendVerificationEmail(user.email), { name: 'send-verification' }),\n *     { name: 'check-verification', reason: 'User is already verified' }\n *   );\n *\n *   return { user, verification };\n * });\n * ```\n */\nexport function unless<T, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): Promise<T | undefined>;\n\n/**\n * Synchronous overload for unless when the operation returns a non-Promise value.\n */\nexport function unless<T, C = unknown>(\n  condition: boolean,\n  operation: () => T,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): T | undefined | Promise<T | undefined>;\n\nexport function unless<T, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): MaybeAsync<T | undefined> {\n  return when(!condition, operation, options, ctx);\n}\n\n/**\n * Run a step only if condition is true, return default value if skipped.\n *\n * Use this when you want to conditionally execute a step and provide\n * a fallback value when the condition is not met.\n *\n * @param condition - Boolean condition to evaluate\n * @param operation - Function that performs the step (only called if condition is true)\n * @param defaultValue - Value to return if condition is false\n * @param options - Optional configuration for the conditional step\n * @param ctx - Optional context for event emission\n * @returns The result of the operation if condition is true, defaultValue otherwise\n *\n * @example\n * ```typescript\n * const result = await workflow(async ({ step }) => {\n *   const user = await step(fetchUser(id));\n *\n *   // Get premium limits or use default for non-premium users\n *   const limits = await whenOr(\n *     user.isPremium,\n *     () => step(() => fetchPremiumLimits(user.id), { name: 'premium-limits' }),\n *     { maxRequests: 100, maxStorage: 1000 }, // default for non-premium\n *     { name: 'check-premium-limits', reason: 'Using default limits for non-premium user' }\n *   );\n *\n *   return { user, limits };\n * });\n * ```\n */\nexport function whenOr<T, D, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  defaultValue: D,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): Promise<T | D>;\n\n/**\n * Synchronous overload for whenOr when the operation returns a non-Promise value.\n */\nexport function whenOr<T, D, C = unknown>(\n  condition: boolean,\n  operation: () => T,\n  defaultValue: D,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): T | D | Promise<T | D>;\n\nexport function whenOr<T, D, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  defaultValue: D,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): MaybeAsync<T | D> {\n  if (condition) {\n    return operation();\n  }\n\n  const decisionId = generateDecisionId();\n  emitSkipped(ctx, options, decisionId);\n  return defaultValue;\n}\n\n/**\n * Run a step only if condition is false, return default value if skipped.\n *\n * Use this when you want to conditionally execute a step when a condition\n * is NOT met, with a fallback value for when the condition is true.\n *\n * @param condition - Boolean condition to evaluate\n * @param operation - Function that performs the step (only called if condition is false)\n * @param defaultValue - Value to return if condition is true\n * @param options - Optional configuration for the conditional step\n * @param ctx - Optional context for event emission\n * @returns The result of the operation if condition is false, defaultValue otherwise\n *\n * @example\n * ```typescript\n * const result = await workflow(async ({ step }) => {\n *   const user = await step(fetchUser(id));\n *\n *   // Generate new token if user is NOT authenticated, otherwise use existing\n *   const token = await unlessOr(\n *     user.isAuthenticated,\n *     () => step(() => generateNewToken(user.id), { name: 'generate-token' }),\n *     user.existingToken, // use existing token if authenticated\n *     { name: 'check-auth-for-token', reason: 'Using existing token for authenticated user' }\n *   );\n *\n *   return { user, token };\n * });\n * ```\n */\nexport function unlessOr<T, D, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  defaultValue: D,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): Promise<T | D>;\n\n/**\n * Synchronous overload for unlessOr when the operation returns a non-Promise value.\n */\nexport function unlessOr<T, D, C = unknown>(\n  condition: boolean,\n  operation: () => T,\n  defaultValue: D,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): T | D | Promise<T | D>;\n\nexport function unlessOr<T, D, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  defaultValue: D,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): MaybeAsync<T | D> {\n  return whenOr(!condition, operation, defaultValue, options, ctx);\n}\n\n// =============================================================================\n// Factory Functions for Workflow Integration\n// =============================================================================\n\n/**\n * Create a set of conditional helpers bound to a workflow context.\n *\n * Use this factory when you want to automatically emit step_skipped events\n * to the workflow's event stream without passing context manually.\n *\n * @param ctx - The workflow context containing workflowId, onEvent, and optional context\n * @returns Object with bound when, unless, whenOr, and unlessOr functions\n *\n * @example\n * ```typescript\n * // With run() - context is automatically included in events\n * const result = await run(async ({ step }) => {\n *   const ctx = { workflowId, onEvent, context: requestContext };\n *   const { when, whenOr } = createConditionalHelpers(ctx);\n *\n *   const user = await step(fetchUser(id));\n *\n *   const premium = await when(\n *     user.isPremium,\n *     () => step(() => fetchPremiumData(user.id)),\n *     { name: 'premium-data' }\n *   );\n *\n *   return { user, premium };\n * }, { onEvent, workflowId, context: requestContext });\n * \n * // With createWorkflow - access context from onEvent callback\n * const workflow = createWorkflow({ fetchUser }, {\n *   createContext: () => ({ requestId: 'req-123' }),\n *   onEvent: (event, ctx) => {\n *     // ctx is available here, can be passed to conditional helpers\n *   }\n * });\n * ```\n */\nexport function createConditionalHelpers<C = unknown>(ctx: ConditionalContext<C>) {\n  return {\n    /**\n     * Run a step only if condition is true, return undefined if skipped.\n     */\n    when: <T>(\n      condition: boolean,\n      operation: Operation<T>,\n      options?: ConditionalOptions\n    ): MaybeAsync<T | undefined> => when(condition, operation, options, ctx),\n\n    /**\n     * Run a step only if condition is false, return undefined if skipped.\n     */\n    unless: <T>(\n      condition: boolean,\n      operation: Operation<T>,\n      options?: ConditionalOptions\n    ): MaybeAsync<T | undefined> => unless(condition, operation, options, ctx),\n\n    /**\n     * Run a step only if condition is true, return default value if skipped.\n     */\n    whenOr: <T, D>(\n      condition: boolean,\n      operation: Operation<T>,\n      defaultValue: D,\n      options?: ConditionalOptions\n    ): MaybeAsync<T | D> => whenOr(condition, operation, defaultValue, options, ctx),\n\n    /**\n     * Run a step only if condition is false, return default value if skipped.\n     */\n    unlessOr: <T, D>(\n      condition: boolean,\n      operation: Operation<T>,\n      defaultValue: D,\n      options?: ConditionalOptions\n    ): MaybeAsync<T | D> => unlessOr(condition, operation, defaultValue, options, ctx),\n  };\n}\n"],"mappings":"yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,8BAAAE,EAAA,WAAAC,EAAA,aAAAC,EAAA,SAAAC,EAAA,WAAAC,IAAA,eAAAC,EAAAP,GC4EA,SAASQ,GAA6B,CACpC,MAAO,YAAY,KAAK,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,EAAG,CAAC,CAAC,EACzE,CAMA,SAASC,EACPC,EACAC,EACAC,EACM,CACN,GAAI,CAACF,GAAK,QAAS,OAGnB,IAAMG,EAAmC,CACvC,KAAM,eACN,WAAYH,EAAI,WAChB,QAASC,GAAS,IAClB,KAAMA,GAAS,KACf,OAAQA,GAAS,OACjB,WAAAC,EACA,GAAI,KAAK,IAAI,CACf,EAKME,EACJD,EAAM,UAAY,QAAaH,EAAI,UAAY,OAC3CG,EACC,CAAE,GAAGA,EAAO,QAASH,EAAI,OAAQ,EAExCA,EAAI,QAAQI,CAAgB,CAC9B,CAoDO,SAASC,EACdC,EACAC,EACAN,EACAD,EAC2B,CAC3B,GAAIM,EACF,OAAOC,EAAU,EAGnB,IAAML,EAAaJ,EAAmB,EACtCC,EAAYC,EAAKC,EAASC,CAAU,CAEtC,CA+CO,SAASM,EACdF,EACAC,EACAN,EACAD,EAC2B,CAC3B,OAAOK,EAAK,CAACC,EAAWC,EAAWN,EAASD,CAAG,CACjD,CAmDO,SAASS,EACdH,EACAC,EACAG,EACAT,EACAD,EACmB,CACnB,GAAIM,EACF,OAAOC,EAAU,EAGnB,IAAML,EAAaJ,EAAmB,EACtC,OAAAC,EAAYC,EAAKC,EAASC,CAAU,EAC7BQ,CACT,CAmDO,SAASC,EACdL,EACAC,EACAG,EACAT,EACAD,EACmB,CACnB,OAAOS,EAAO,CAACH,EAAWC,EAAWG,EAAcT,EAASD,CAAG,CACjE,CA0CO,SAASY,EAAsCZ,EAA4B,CAChF,MAAO,CAIL,KAAM,CACJM,EACAC,EACAN,IAC8BI,EAAKC,EAAWC,EAAWN,EAASD,CAAG,EAKvE,OAAQ,CACNM,EACAC,EACAN,IAC8BO,EAAOF,EAAWC,EAAWN,EAASD,CAAG,EAKzE,OAAQ,CACNM,EACAC,EACAG,EACAT,IACsBQ,EAAOH,EAAWC,EAAWG,EAAcT,EAASD,CAAG,EAK/E,SAAU,CACRM,EACAC,EACAG,EACAT,IACsBU,EAASL,EAAWC,EAAWG,EAAcT,EAASD,CAAG,CACnF,CACF","names":["conditional_entry_exports","__export","createConditionalHelpers","unless","unlessOr","when","whenOr","__toCommonJS","generateDecisionId","emitSkipped","ctx","options","decisionId","event","eventWithContext","when","condition","operation","unless","whenOr","defaultValue","unlessOr","createConditionalHelpers"]}

package/dist/conditional.d.cts

@@ -1,252 +0,0 @@
-import { ag as WorkflowEvent } from './run-entry-D2MmJFj9.cjs';
-import './errors.cjs';
-import './tagged-error.cjs';
-import './slugs.cjs';
-
-/**
- * awaitly/conditional
- *
- * Conditional step execution helpers for workflows.
- * These helpers allow you to conditionally execute steps based on runtime conditions,
- * with proper event emission for skipped steps.
- */
-
-/**
- * Options for conditional execution.
- */
-type ConditionalOptions = {
-    /**
-     * Human-readable name for the conditional step.
-     * Used in step_skipped events for debugging and visualization.
-     */
-    name?: string;
-    /**
-     * Stable identity key for the conditional step.
-     * Used in step_skipped events for tracking and visualization.
-     */
-    key?: string;
-    /**
-     * Optional reason explaining why the step was skipped.
-     * Included in step_skipped events.
-     */
-    reason?: string;
-};
-/**
- * Context for conditional execution, used to emit events.
- */
-type ConditionalContext<C = unknown> = {
-    /**
-     * The workflow ID for event emission.
-     */
-    workflowId: string;
-    /**
-     * Event emitter function.
-     */
-    onEvent?: (event: WorkflowEvent<unknown, C>) => void;
-    /**
-     * Optional context value to include in emitted events.
-     * When provided, this context is automatically added to step_skipped events.
-     */
-    context?: C;
-};
-/**
- * Type for operations that can be either sync or async.
- */
-type MaybeAsync<T> = T | Promise<T>;
-/**
- * Type for the operation function passed to conditional helpers.
- */
-type Operation<T> = () => MaybeAsync<T>;
-/**
- * Run a step only if condition is true, return undefined if skipped.
- *
- * Use this when you want to conditionally execute a step and handle
- * the undefined case yourself. For a version with a default value,
- * use `whenOr`.
- *
- * @param condition - Boolean condition to evaluate
- * @param operation - Function that performs the step (only called if condition is true)
- * @param options - Optional configuration for the conditional step
- * @param ctx - Optional context for event emission
- * @returns The result of the operation if condition is true, undefined otherwise
- *
- * @example
- * ```typescript
- * const result = await workflow(async ({ step }) => {
- *   const user = await step('fetchUser', () => fetchUser(id));
- *
- *   // Only runs if user is premium
- *   const premium = await when(
- *     user.isPremium,
- *     () => step('fetchPremiumData', () => fetchPremiumData(user.id)),
- *     { name: 'check-premium', reason: 'User is not premium' }
- *   );
- *
- *   return { user, premium };
- * });
- * ```
- */
-declare function when<T, C = unknown>(condition: boolean, operation: Operation<T>, options?: ConditionalOptions, ctx?: ConditionalContext<C>): Promise<T | undefined>;
-/**
- * Synchronous overload for when the operation returns a non-Promise value.
- */
-declare function when<T, C = unknown>(condition: boolean, operation: () => T, options?: ConditionalOptions, ctx?: ConditionalContext<C>): T | undefined | Promise<T | undefined>;
-/**
- * Run a step only if condition is false, return undefined if skipped.
- *
- * Use this when you want to conditionally execute a step when a condition
- * is NOT met. For a version with a default value, use `unlessOr`.
- *
- * @param condition - Boolean condition to evaluate
- * @param operation - Function that performs the step (only called if condition is false)
- * @param options - Optional configuration for the conditional step
- * @param ctx - Optional context for event emission
- * @returns The result of the operation if condition is false, undefined otherwise
- *
- * @example
- * ```typescript
- * const result = await workflow(async ({ step }) => {
- *   const user = await step(fetchUser(id));
- *
- *   // Only runs if user is NOT verified
- *   const verification = await unless(
- *     user.isVerified,
- *     () => step(() => sendVerificationEmail(user.email), { name: 'send-verification' }),
- *     { name: 'check-verification', reason: 'User is already verified' }
- *   );
- *
- *   return { user, verification };
- * });
- * ```
- */
-declare function unless<T, C = unknown>(condition: boolean, operation: Operation<T>, options?: ConditionalOptions, ctx?: ConditionalContext<C>): Promise<T | undefined>;
-/**
- * Synchronous overload for unless when the operation returns a non-Promise value.
- */
-declare function unless<T, C = unknown>(condition: boolean, operation: () => T, options?: ConditionalOptions, ctx?: ConditionalContext<C>): T | undefined | Promise<T | undefined>;
-/**
- * Run a step only if condition is true, return default value if skipped.
- *
- * Use this when you want to conditionally execute a step and provide
- * a fallback value when the condition is not met.
- *
- * @param condition - Boolean condition to evaluate
- * @param operation - Function that performs the step (only called if condition is true)
- * @param defaultValue - Value to return if condition is false
- * @param options - Optional configuration for the conditional step
- * @param ctx - Optional context for event emission
- * @returns The result of the operation if condition is true, defaultValue otherwise
- *
- * @example
- * ```typescript
- * const result = await workflow(async ({ step }) => {
- *   const user = await step(fetchUser(id));
- *
- *   // Get premium limits or use default for non-premium users
- *   const limits = await whenOr(
- *     user.isPremium,
- *     () => step(() => fetchPremiumLimits(user.id), { name: 'premium-limits' }),
- *     { maxRequests: 100, maxStorage: 1000 }, // default for non-premium
- *     { name: 'check-premium-limits', reason: 'Using default limits for non-premium user' }
- *   );
- *
- *   return { user, limits };
- * });
- * ```
- */
-declare function whenOr<T, D, C = unknown>(condition: boolean, operation: Operation<T>, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext<C>): Promise<T | D>;
-/**
- * Synchronous overload for whenOr when the operation returns a non-Promise value.
- */
-declare function whenOr<T, D, C = unknown>(condition: boolean, operation: () => T, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext<C>): T | D | Promise<T | D>;
-/**
- * Run a step only if condition is false, return default value if skipped.
- *
- * Use this when you want to conditionally execute a step when a condition
- * is NOT met, with a fallback value for when the condition is true.
- *
- * @param condition - Boolean condition to evaluate
- * @param operation - Function that performs the step (only called if condition is false)
- * @param defaultValue - Value to return if condition is true
- * @param options - Optional configuration for the conditional step
- * @param ctx - Optional context for event emission
- * @returns The result of the operation if condition is false, defaultValue otherwise
- *
- * @example
- * ```typescript
- * const result = await workflow(async ({ step }) => {
- *   const user = await step(fetchUser(id));
- *
- *   // Generate new token if user is NOT authenticated, otherwise use existing
- *   const token = await unlessOr(
- *     user.isAuthenticated,
- *     () => step(() => generateNewToken(user.id), { name: 'generate-token' }),
- *     user.existingToken, // use existing token if authenticated
- *     { name: 'check-auth-for-token', reason: 'Using existing token for authenticated user' }
- *   );
- *
- *   return { user, token };
- * });
- * ```
- */
-declare function unlessOr<T, D, C = unknown>(condition: boolean, operation: Operation<T>, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext<C>): Promise<T | D>;
-/**
- * Synchronous overload for unlessOr when the operation returns a non-Promise value.
- */
-declare function unlessOr<T, D, C = unknown>(condition: boolean, operation: () => T, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext<C>): T | D | Promise<T | D>;
-/**
- * Create a set of conditional helpers bound to a workflow context.
- *
- * Use this factory when you want to automatically emit step_skipped events
- * to the workflow's event stream without passing context manually.
- *
- * @param ctx - The workflow context containing workflowId, onEvent, and optional context
- * @returns Object with bound when, unless, whenOr, and unlessOr functions
- *
- * @example
- * ```typescript
- * // With run() - context is automatically included in events
- * const result = await run(async ({ step }) => {
- *   const ctx = { workflowId, onEvent, context: requestContext };
- *   const { when, whenOr } = createConditionalHelpers(ctx);
- *
- *   const user = await step(fetchUser(id));
- *
- *   const premium = await when(
- *     user.isPremium,
- *     () => step(() => fetchPremiumData(user.id)),
- *     { name: 'premium-data' }
- *   );
- *
- *   return { user, premium };
- * }, { onEvent, workflowId, context: requestContext });
- *
- * // With createWorkflow - access context from onEvent callback
- * const workflow = createWorkflow({ fetchUser }, {
- *   createContext: () => ({ requestId: 'req-123' }),
- *   onEvent: (event, ctx) => {
- *     // ctx is available here, can be passed to conditional helpers
- *   }
- * });
- * ```
- */
-declare function createConditionalHelpers<C = unknown>(ctx: ConditionalContext<C>): {
-    /**
-     * Run a step only if condition is true, return undefined if skipped.
-     */
-    when: <T>(condition: boolean, operation: Operation<T>, options?: ConditionalOptions) => MaybeAsync<T | undefined>;
-    /**
-     * Run a step only if condition is false, return undefined if skipped.
-     */
-    unless: <T>(condition: boolean, operation: Operation<T>, options?: ConditionalOptions) => MaybeAsync<T | undefined>;
-    /**
-     * Run a step only if condition is true, return default value if skipped.
-     */
-    whenOr: <T, D>(condition: boolean, operation: Operation<T>, defaultValue: D, options?: ConditionalOptions) => MaybeAsync<T | D>;
-    /**
-     * Run a step only if condition is false, return default value if skipped.
-     */
-    unlessOr: <T, D>(condition: boolean, operation: Operation<T>, defaultValue: D, options?: ConditionalOptions) => MaybeAsync<T | D>;
-};
-
-export { type ConditionalContext, type ConditionalOptions, createConditionalHelpers, unless, unlessOr, when, whenOr };

package/dist/conditional.d.ts

@@ -1,252 +0,0 @@
-import { ag as WorkflowEvent } from './run-entry-Dduz-is2.js';
-import './errors.js';
-import './tagged-error.js';
-import './slugs.js';
-
-/**
- * awaitly/conditional
- *
- * Conditional step execution helpers for workflows.
- * These helpers allow you to conditionally execute steps based on runtime conditions,
- * with proper event emission for skipped steps.
- */
-
-/**
- * Options for conditional execution.
- */
-type ConditionalOptions = {
-    /**
-     * Human-readable name for the conditional step.
-     * Used in step_skipped events for debugging and visualization.
-     */
-    name?: string;
-    /**
-     * Stable identity key for the conditional step.
-     * Used in step_skipped events for tracking and visualization.
-     */
-    key?: string;
-    /**
-     * Optional reason explaining why the step was skipped.
-     * Included in step_skipped events.
-     */
-    reason?: string;
-};
-/**
- * Context for conditional execution, used to emit events.
- */
-type ConditionalContext<C = unknown> = {
-    /**
-     * The workflow ID for event emission.
-     */
-    workflowId: string;
-    /**
-     * Event emitter function.
-     */
-    onEvent?: (event: WorkflowEvent<unknown, C>) => void;
-    /**
-     * Optional context value to include in emitted events.
-     * When provided, this context is automatically added to step_skipped events.
-     */
-    context?: C;
-};
-/**
- * Type for operations that can be either sync or async.
- */
-type MaybeAsync<T> = T | Promise<T>;
-/**
- * Type for the operation function passed to conditional helpers.
- */
-type Operation<T> = () => MaybeAsync<T>;
-/**
- * Run a step only if condition is true, return undefined if skipped.
- *
- * Use this when you want to conditionally execute a step and handle
- * the undefined case yourself. For a version with a default value,
- * use `whenOr`.
- *
- * @param condition - Boolean condition to evaluate
- * @param operation - Function that performs the step (only called if condition is true)
- * @param options - Optional configuration for the conditional step
- * @param ctx - Optional context for event emission
- * @returns The result of the operation if condition is true, undefined otherwise
- *
- * @example
- * ```typescript
- * const result = await workflow(async ({ step }) => {
- *   const user = await step('fetchUser', () => fetchUser(id));
- *
- *   // Only runs if user is premium
- *   const premium = await when(
- *     user.isPremium,
- *     () => step('fetchPremiumData', () => fetchPremiumData(user.id)),
- *     { name: 'check-premium', reason: 'User is not premium' }
- *   );
- *
- *   return { user, premium };
- * });
- * ```
- */
-declare function when<T, C = unknown>(condition: boolean, operation: Operation<T>, options?: ConditionalOptions, ctx?: ConditionalContext<C>): Promise<T | undefined>;
-/**
- * Synchronous overload for when the operation returns a non-Promise value.
- */
-declare function when<T, C = unknown>(condition: boolean, operation: () => T, options?: ConditionalOptions, ctx?: ConditionalContext<C>): T | undefined | Promise<T | undefined>;
-/**
- * Run a step only if condition is false, return undefined if skipped.
- *
- * Use this when you want to conditionally execute a step when a condition
- * is NOT met. For a version with a default value, use `unlessOr`.
- *
- * @param condition - Boolean condition to evaluate
- * @param operation - Function that performs the step (only called if condition is false)
- * @param options - Optional configuration for the conditional step
- * @param ctx - Optional context for event emission
- * @returns The result of the operation if condition is false, undefined otherwise
- *
- * @example
- * ```typescript
- * const result = await workflow(async ({ step }) => {
- *   const user = await step(fetchUser(id));
- *
- *   // Only runs if user is NOT verified
- *   const verification = await unless(
- *     user.isVerified,
- *     () => step(() => sendVerificationEmail(user.email), { name: 'send-verification' }),
- *     { name: 'check-verification', reason: 'User is already verified' }
- *   );
- *
- *   return { user, verification };
- * });
- * ```
- */
-declare function unless<T, C = unknown>(condition: boolean, operation: Operation<T>, options?: ConditionalOptions, ctx?: ConditionalContext<C>): Promise<T | undefined>;
-/**
- * Synchronous overload for unless when the operation returns a non-Promise value.
- */
-declare function unless<T, C = unknown>(condition: boolean, operation: () => T, options?: ConditionalOptions, ctx?: ConditionalContext<C>): T | undefined | Promise<T | undefined>;
-/**
- * Run a step only if condition is true, return default value if skipped.
- *
- * Use this when you want to conditionally execute a step and provide
- * a fallback value when the condition is not met.
- *
- * @param condition - Boolean condition to evaluate
- * @param operation - Function that performs the step (only called if condition is true)
- * @param defaultValue - Value to return if condition is false
- * @param options - Optional configuration for the conditional step
- * @param ctx - Optional context for event emission
- * @returns The result of the operation if condition is true, defaultValue otherwise
- *
- * @example
- * ```typescript
- * const result = await workflow(async ({ step }) => {
- *   const user = await step(fetchUser(id));
- *
- *   // Get premium limits or use default for non-premium users
- *   const limits = await whenOr(
- *     user.isPremium,
- *     () => step(() => fetchPremiumLimits(user.id), { name: 'premium-limits' }),
- *     { maxRequests: 100, maxStorage: 1000 }, // default for non-premium
- *     { name: 'check-premium-limits', reason: 'Using default limits for non-premium user' }
- *   );
- *
- *   return { user, limits };
- * });
- * ```
- */
-declare function whenOr<T, D, C = unknown>(condition: boolean, operation: Operation<T>, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext<C>): Promise<T | D>;
-/**
- * Synchronous overload for whenOr when the operation returns a non-Promise value.
- */
-declare function whenOr<T, D, C = unknown>(condition: boolean, operation: () => T, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext<C>): T | D | Promise<T | D>;
-/**
- * Run a step only if condition is false, return default value if skipped.
- *
- * Use this when you want to conditionally execute a step when a condition
- * is NOT met, with a fallback value for when the condition is true.
- *
- * @param condition - Boolean condition to evaluate
- * @param operation - Function that performs the step (only called if condition is false)
- * @param defaultValue - Value to return if condition is true
- * @param options - Optional configuration for the conditional step
- * @param ctx - Optional context for event emission
- * @returns The result of the operation if condition is false, defaultValue otherwise
- *
- * @example
- * ```typescript
- * const result = await workflow(async ({ step }) => {
- *   const user = await step(fetchUser(id));
- *
- *   // Generate new token if user is NOT authenticated, otherwise use existing
- *   const token = await unlessOr(
- *     user.isAuthenticated,
- *     () => step(() => generateNewToken(user.id), { name: 'generate-token' }),
- *     user.existingToken, // use existing token if authenticated
- *     { name: 'check-auth-for-token', reason: 'Using existing token for authenticated user' }
- *   );
- *
- *   return { user, token };
- * });
- * ```
- */
-declare function unlessOr<T, D, C = unknown>(condition: boolean, operation: Operation<T>, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext<C>): Promise<T | D>;
-/**
- * Synchronous overload for unlessOr when the operation returns a non-Promise value.
- */
-declare function unlessOr<T, D, C = unknown>(condition: boolean, operation: () => T, defaultValue: D, options?: ConditionalOptions, ctx?: ConditionalContext<C>): T | D | Promise<T | D>;
-/**
- * Create a set of conditional helpers bound to a workflow context.
- *
- * Use this factory when you want to automatically emit step_skipped events
- * to the workflow's event stream without passing context manually.
- *
- * @param ctx - The workflow context containing workflowId, onEvent, and optional context
- * @returns Object with bound when, unless, whenOr, and unlessOr functions
- *
- * @example
- * ```typescript
- * // With run() - context is automatically included in events
- * const result = await run(async ({ step }) => {
- *   const ctx = { workflowId, onEvent, context: requestContext };
- *   const { when, whenOr } = createConditionalHelpers(ctx);
- *
- *   const user = await step(fetchUser(id));
- *
- *   const premium = await when(
- *     user.isPremium,
- *     () => step(() => fetchPremiumData(user.id)),
- *     { name: 'premium-data' }
- *   );
- *
- *   return { user, premium };
- * }, { onEvent, workflowId, context: requestContext });
- *
- * // With createWorkflow - access context from onEvent callback
- * const workflow = createWorkflow({ fetchUser }, {
- *   createContext: () => ({ requestId: 'req-123' }),
- *   onEvent: (event, ctx) => {
- *     // ctx is available here, can be passed to conditional helpers
- *   }
- * });
- * ```
- */
-declare function createConditionalHelpers<C = unknown>(ctx: ConditionalContext<C>): {
-    /**
-     * Run a step only if condition is true, return undefined if skipped.
-     */
-    when: <T>(condition: boolean, operation: Operation<T>, options?: ConditionalOptions) => MaybeAsync<T | undefined>;
-    /**
-     * Run a step only if condition is false, return undefined if skipped.
-     */
-    unless: <T>(condition: boolean, operation: Operation<T>, options?: ConditionalOptions) => MaybeAsync<T | undefined>;
-    /**
-     * Run a step only if condition is true, return default value if skipped.
-     */
-    whenOr: <T, D>(condition: boolean, operation: Operation<T>, defaultValue: D, options?: ConditionalOptions) => MaybeAsync<T | D>;
-    /**
-     * Run a step only if condition is false, return default value if skipped.
-     */
-    unlessOr: <T, D>(condition: boolean, operation: Operation<T>, defaultValue: D, options?: ConditionalOptions) => MaybeAsync<T | D>;
-};
-
-export { type ConditionalContext, type ConditionalOptions, createConditionalHelpers, unless, unlessOr, when, whenOr };

package/dist/conditional.js

@@ -1,2 +0,0 @@
-function d(){return`decision_${Date.now()}_${Math.random().toString(36).slice(2,8)}`}function s(t,n,e){if(!t?.onEvent)return;let o={type:"step_skipped",workflowId:t.workflowId,stepKey:n?.key,name:n?.name,reason:n?.reason,decisionId:e,ts:Date.now()},i=o.context!==void 0||t.context===void 0?o:{...o,context:t.context};t.onEvent(i)}function a(t,n,e,o){if(t)return n();let i=d();s(o,e,i)}function C(t,n,e,o){return a(!t,n,e,o)}function r(t,n,e,o,i){if(t)return n();let p=d();return s(i,o,p),e}function l(t,n,e,o,i){return r(!t,n,e,o,i)}function u(t){return{when:(n,e,o)=>a(n,e,o,t),unless:(n,e,o)=>C(n,e,o,t),whenOr:(n,e,o,i)=>r(n,e,o,i,t),unlessOr:(n,e,o,i)=>l(n,e,o,i,t)}}export{u as createConditionalHelpers,C as unless,l as unlessOr,a as when,r as whenOr};
-//# sourceMappingURL=conditional.js.map

package/dist/conditional.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/conditional.ts"],"sourcesContent":["/**\n * awaitly/conditional\n *\n * Conditional step execution helpers for workflows.\n * These helpers allow you to conditionally execute steps based on runtime conditions,\n * with proper event emission for skipped steps.\n */\n\nimport type { WorkflowEvent } from \"./core\";\n\n// =============================================================================\n// Types\n// =============================================================================\n\n/**\n * Options for conditional execution.\n */\nexport type ConditionalOptions = {\n  /**\n   * Human-readable name for the conditional step.\n   * Used in step_skipped events for debugging and visualization.\n   */\n  name?: string;\n\n  /**\n   * Stable identity key for the conditional step.\n   * Used in step_skipped events for tracking and visualization.\n   */\n  key?: string;\n\n  /**\n   * Optional reason explaining why the step was skipped.\n   * Included in step_skipped events.\n   */\n  reason?: string;\n};\n\n/**\n * Context for conditional execution, used to emit events.\n */\nexport type ConditionalContext<C = unknown> = {\n  /**\n   * The workflow ID for event emission.\n   */\n  workflowId: string;\n\n  /**\n   * Event emitter function.\n   */\n  onEvent?: (event: WorkflowEvent<unknown, C>) => void;\n\n  /**\n   * Optional context value to include in emitted events.\n   * When provided, this context is automatically added to step_skipped events.\n   */\n  context?: C;\n};\n\n/**\n * Type for operations that can be either sync or async.\n */\ntype MaybeAsync<T> = T | Promise<T>;\n\n/**\n * Type for the operation function passed to conditional helpers.\n */\ntype Operation<T> = () => MaybeAsync<T>;\n\n// =============================================================================\n// Internal Helpers\n// =============================================================================\n\n/**\n * Generate a unique decision ID for tracking conditional decisions.\n * @internal\n */\nfunction generateDecisionId(): string {\n  return `decision_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;\n}\n\n/**\n * Emit a step_skipped event.\n * @internal\n */\nfunction emitSkipped<C = unknown>(\n  ctx: ConditionalContext<C> | undefined,\n  options: ConditionalOptions | undefined,\n  decisionId: string\n): void {\n  if (!ctx?.onEvent) return;\n\n  // Create event with context if provided (similar to emitEvent logic)\n  const event: WorkflowEvent<unknown, C> = {\n    type: \"step_skipped\",\n    workflowId: ctx.workflowId,\n    stepKey: options?.key,\n    name: options?.name,\n    reason: options?.reason,\n    decisionId,\n    ts: Date.now(),\n  };\n\n  // Add context to event only if:\n  // 1. Event doesn't already have context (preserves replayed events)\n  // 2. Context is actually provided (don't add context: undefined property)\n  const eventWithContext =\n    event.context !== undefined || ctx.context === undefined\n      ? event\n      : ({ ...event, context: ctx.context } as WorkflowEvent<unknown, C>);\n\n  ctx.onEvent(eventWithContext);\n}\n\n// =============================================================================\n// Conditional Helpers\n// =============================================================================\n\n/**\n * Run a step only if condition is true, return undefined if skipped.\n *\n * Use this when you want to conditionally execute a step and handle\n * the undefined case yourself. For a version with a default value,\n * use `whenOr`.\n *\n * @param condition - Boolean condition to evaluate\n * @param operation - Function that performs the step (only called if condition is true)\n * @param options - Optional configuration for the conditional step\n * @param ctx - Optional context for event emission\n * @returns The result of the operation if condition is true, undefined otherwise\n *\n * @example\n * ```typescript\n * const result = await workflow(async ({ step }) => {\n *   const user = await step('fetchUser', () => fetchUser(id));\n *\n *   // Only runs if user is premium\n *   const premium = await when(\n *     user.isPremium,\n *     () => step('fetchPremiumData', () => fetchPremiumData(user.id)),\n *     { name: 'check-premium', reason: 'User is not premium' }\n *   );\n *\n *   return { user, premium };\n * });\n * ```\n */\nexport function when<T, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): Promise<T | undefined>;\n\n/**\n * Synchronous overload for when the operation returns a non-Promise value.\n */\nexport function when<T, C = unknown>(\n  condition: boolean,\n  operation: () => T,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): T | undefined | Promise<T | undefined>;\n\nexport function when<T, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): MaybeAsync<T | undefined> {\n  if (condition) {\n    return operation();\n  }\n\n  const decisionId = generateDecisionId();\n  emitSkipped(ctx, options, decisionId);\n  return undefined;\n}\n\n/**\n * Run a step only if condition is false, return undefined if skipped.\n *\n * Use this when you want to conditionally execute a step when a condition\n * is NOT met. For a version with a default value, use `unlessOr`.\n *\n * @param condition - Boolean condition to evaluate\n * @param operation - Function that performs the step (only called if condition is false)\n * @param options - Optional configuration for the conditional step\n * @param ctx - Optional context for event emission\n * @returns The result of the operation if condition is false, undefined otherwise\n *\n * @example\n * ```typescript\n * const result = await workflow(async ({ step }) => {\n *   const user = await step(fetchUser(id));\n *\n *   // Only runs if user is NOT verified\n *   const verification = await unless(\n *     user.isVerified,\n *     () => step(() => sendVerificationEmail(user.email), { name: 'send-verification' }),\n *     { name: 'check-verification', reason: 'User is already verified' }\n *   );\n *\n *   return { user, verification };\n * });\n * ```\n */\nexport function unless<T, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): Promise<T | undefined>;\n\n/**\n * Synchronous overload for unless when the operation returns a non-Promise value.\n */\nexport function unless<T, C = unknown>(\n  condition: boolean,\n  operation: () => T,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): T | undefined | Promise<T | undefined>;\n\nexport function unless<T, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): MaybeAsync<T | undefined> {\n  return when(!condition, operation, options, ctx);\n}\n\n/**\n * Run a step only if condition is true, return default value if skipped.\n *\n * Use this when you want to conditionally execute a step and provide\n * a fallback value when the condition is not met.\n *\n * @param condition - Boolean condition to evaluate\n * @param operation - Function that performs the step (only called if condition is true)\n * @param defaultValue - Value to return if condition is false\n * @param options - Optional configuration for the conditional step\n * @param ctx - Optional context for event emission\n * @returns The result of the operation if condition is true, defaultValue otherwise\n *\n * @example\n * ```typescript\n * const result = await workflow(async ({ step }) => {\n *   const user = await step(fetchUser(id));\n *\n *   // Get premium limits or use default for non-premium users\n *   const limits = await whenOr(\n *     user.isPremium,\n *     () => step(() => fetchPremiumLimits(user.id), { name: 'premium-limits' }),\n *     { maxRequests: 100, maxStorage: 1000 }, // default for non-premium\n *     { name: 'check-premium-limits', reason: 'Using default limits for non-premium user' }\n *   );\n *\n *   return { user, limits };\n * });\n * ```\n */\nexport function whenOr<T, D, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  defaultValue: D,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): Promise<T | D>;\n\n/**\n * Synchronous overload for whenOr when the operation returns a non-Promise value.\n */\nexport function whenOr<T, D, C = unknown>(\n  condition: boolean,\n  operation: () => T,\n  defaultValue: D,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): T | D | Promise<T | D>;\n\nexport function whenOr<T, D, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  defaultValue: D,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): MaybeAsync<T | D> {\n  if (condition) {\n    return operation();\n  }\n\n  const decisionId = generateDecisionId();\n  emitSkipped(ctx, options, decisionId);\n  return defaultValue;\n}\n\n/**\n * Run a step only if condition is false, return default value if skipped.\n *\n * Use this when you want to conditionally execute a step when a condition\n * is NOT met, with a fallback value for when the condition is true.\n *\n * @param condition - Boolean condition to evaluate\n * @param operation - Function that performs the step (only called if condition is false)\n * @param defaultValue - Value to return if condition is true\n * @param options - Optional configuration for the conditional step\n * @param ctx - Optional context for event emission\n * @returns The result of the operation if condition is false, defaultValue otherwise\n *\n * @example\n * ```typescript\n * const result = await workflow(async ({ step }) => {\n *   const user = await step(fetchUser(id));\n *\n *   // Generate new token if user is NOT authenticated, otherwise use existing\n *   const token = await unlessOr(\n *     user.isAuthenticated,\n *     () => step(() => generateNewToken(user.id), { name: 'generate-token' }),\n *     user.existingToken, // use existing token if authenticated\n *     { name: 'check-auth-for-token', reason: 'Using existing token for authenticated user' }\n *   );\n *\n *   return { user, token };\n * });\n * ```\n */\nexport function unlessOr<T, D, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  defaultValue: D,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): Promise<T | D>;\n\n/**\n * Synchronous overload for unlessOr when the operation returns a non-Promise value.\n */\nexport function unlessOr<T, D, C = unknown>(\n  condition: boolean,\n  operation: () => T,\n  defaultValue: D,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): T | D | Promise<T | D>;\n\nexport function unlessOr<T, D, C = unknown>(\n  condition: boolean,\n  operation: Operation<T>,\n  defaultValue: D,\n  options?: ConditionalOptions,\n  ctx?: ConditionalContext<C>\n): MaybeAsync<T | D> {\n  return whenOr(!condition, operation, defaultValue, options, ctx);\n}\n\n// =============================================================================\n// Factory Functions for Workflow Integration\n// =============================================================================\n\n/**\n * Create a set of conditional helpers bound to a workflow context.\n *\n * Use this factory when you want to automatically emit step_skipped events\n * to the workflow's event stream without passing context manually.\n *\n * @param ctx - The workflow context containing workflowId, onEvent, and optional context\n * @returns Object with bound when, unless, whenOr, and unlessOr functions\n *\n * @example\n * ```typescript\n * // With run() - context is automatically included in events\n * const result = await run(async ({ step }) => {\n *   const ctx = { workflowId, onEvent, context: requestContext };\n *   const { when, whenOr } = createConditionalHelpers(ctx);\n *\n *   const user = await step(fetchUser(id));\n *\n *   const premium = await when(\n *     user.isPremium,\n *     () => step(() => fetchPremiumData(user.id)),\n *     { name: 'premium-data' }\n *   );\n *\n *   return { user, premium };\n * }, { onEvent, workflowId, context: requestContext });\n * \n * // With createWorkflow - access context from onEvent callback\n * const workflow = createWorkflow({ fetchUser }, {\n *   createContext: () => ({ requestId: 'req-123' }),\n *   onEvent: (event, ctx) => {\n *     // ctx is available here, can be passed to conditional helpers\n *   }\n * });\n * ```\n */\nexport function createConditionalHelpers<C = unknown>(ctx: ConditionalContext<C>) {\n  return {\n    /**\n     * Run a step only if condition is true, return undefined if skipped.\n     */\n    when: <T>(\n      condition: boolean,\n      operation: Operation<T>,\n      options?: ConditionalOptions\n    ): MaybeAsync<T | undefined> => when(condition, operation, options, ctx),\n\n    /**\n     * Run a step only if condition is false, return undefined if skipped.\n     */\n    unless: <T>(\n      condition: boolean,\n      operation: Operation<T>,\n      options?: ConditionalOptions\n    ): MaybeAsync<T | undefined> => unless(condition, operation, options, ctx),\n\n    /**\n     * Run a step only if condition is true, return default value if skipped.\n     */\n    whenOr: <T, D>(\n      condition: boolean,\n      operation: Operation<T>,\n      defaultValue: D,\n      options?: ConditionalOptions\n    ): MaybeAsync<T | D> => whenOr(condition, operation, defaultValue, options, ctx),\n\n    /**\n     * Run a step only if condition is false, return default value if skipped.\n     */\n    unlessOr: <T, D>(\n      condition: boolean,\n      operation: Operation<T>,\n      defaultValue: D,\n      options?: ConditionalOptions\n    ): MaybeAsync<T | D> => unlessOr(condition, operation, defaultValue, options, ctx),\n  };\n}\n"],"mappings":"AA4EA,SAASA,GAA6B,CACpC,MAAO,YAAY,KAAK,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,EAAG,CAAC,CAAC,EACzE,CAMA,SAASC,EACPC,EACAC,EACAC,EACM,CACN,GAAI,CAACF,GAAK,QAAS,OAGnB,IAAMG,EAAmC,CACvC,KAAM,eACN,WAAYH,EAAI,WAChB,QAASC,GAAS,IAClB,KAAMA,GAAS,KACf,OAAQA,GAAS,OACjB,WAAAC,EACA,GAAI,KAAK,IAAI,CACf,EAKME,EACJD,EAAM,UAAY,QAAaH,EAAI,UAAY,OAC3CG,EACC,CAAE,GAAGA,EAAO,QAASH,EAAI,OAAQ,EAExCA,EAAI,QAAQI,CAAgB,CAC9B,CAoDO,SAASC,EACdC,EACAC,EACAN,EACAD,EAC2B,CAC3B,GAAIM,EACF,OAAOC,EAAU,EAGnB,IAAML,EAAaJ,EAAmB,EACtCC,EAAYC,EAAKC,EAASC,CAAU,CAEtC,CA+CO,SAASM,EACdF,EACAC,EACAN,EACAD,EAC2B,CAC3B,OAAOK,EAAK,CAACC,EAAWC,EAAWN,EAASD,CAAG,CACjD,CAmDO,SAASS,EACdH,EACAC,EACAG,EACAT,EACAD,EACmB,CACnB,GAAIM,EACF,OAAOC,EAAU,EAGnB,IAAML,EAAaJ,EAAmB,EACtC,OAAAC,EAAYC,EAAKC,EAASC,CAAU,EAC7BQ,CACT,CAmDO,SAASC,EACdL,EACAC,EACAG,EACAT,EACAD,EACmB,CACnB,OAAOS,EAAO,CAACH,EAAWC,EAAWG,EAAcT,EAASD,CAAG,CACjE,CA0CO,SAASY,EAAsCZ,EAA4B,CAChF,MAAO,CAIL,KAAM,CACJM,EACAC,EACAN,IAC8BI,EAAKC,EAAWC,EAAWN,EAASD,CAAG,EAKvE,OAAQ,CACNM,EACAC,EACAN,IAC8BO,EAAOF,EAAWC,EAAWN,EAASD,CAAG,EAKzE,OAAQ,CACNM,EACAC,EACAG,EACAT,IACsBQ,EAAOH,EAAWC,EAAWG,EAAcT,EAASD,CAAG,EAK/E,SAAU,CACRM,EACAC,EACAG,EACAT,IACsBU,EAASL,EAAWC,EAAWG,EAAcT,EAASD,CAAG,CACnF,CACF","names":["generateDecisionId","emitSkipped","ctx","options","decisionId","event","eventWithContext","when","condition","operation","unless","whenOr","defaultValue","unlessOr","createConditionalHelpers"]}