{"version":3,"sources":["../src/errors.ts","../src/retry.ts","../src/observability/logger.ts","../src/observability/hooks.ts","../src/utils/clone.ts","../src/storage/memory.ts","../src/utils/sleep.ts","../src/utils/timeout.ts","../src/utils/id.ts","../src/executor.ts","../src/flow.ts"],"names":["list","result"],"mappings":"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","file":"index.cjs","sourcesContent":["import type { SerializedError } from './types.js';\n\n/** Mark an error as permanently fatal — the executor must not retry it. */\nexport class PermanentError extends Error {\n  readonly permanent = true as const;\n  readonly code?: string;\n\n  constructor(message: string, options?: { cause?: unknown; code?: string }) {\n    super(message);\n    this.name = 'PermanentError';\n    if (options?.cause !== undefined) (this as { cause?: unknown }).cause = options.cause;\n    if (options?.code) this.code = options.code;\n  }\n}\n\n/** Mark an error as transient — explicitly eligible for retry. */\nexport class TransientError extends Error {\n  readonly transient = true as const;\n  readonly code?: string;\n\n  constructor(message: string, options?: { cause?: unknown; code?: string }) {\n    super(message);\n    this.name = 'TransientError';\n    if (options?.cause !== undefined) (this as { cause?: unknown }).cause = options.cause;\n    if (options?.code) this.code = options.code;\n  }\n}\n\n/** Thrown when a step exceeds its configured timeout. Retryable by default. */\nexport class StepTimeoutError extends Error {\n  readonly timeout = true as const;\n\n  constructor(\n    public readonly stepName: string,\n    public readonly timeoutMs: number,\n  ) {\n    super(`step \"${stepName}\" timed out after ${timeoutMs}ms`);\n    this.name = 'StepTimeoutError';\n  }\n}\n\n/** Thrown when execution is cancelled via AbortSignal. */\nexport class FlowAbortedError extends Error {\n  readonly aborted = true as const;\n\n  constructor(reason?: unknown) {\n    const msg =\n      reason instanceof Error\n        ? reason.message\n        : typeof reason === 'string'\n          ? reason\n          : 'flow aborted';\n    super(msg);\n    this.name = 'FlowAbortedError';\n    if (reason !== undefined) (this as { cause?: unknown }).cause = reason;\n  }\n}\n\n/**\n * Thrown when the storage adapter cannot acquire a lock within the configured\n * wait timeout — typically because another worker is currently executing the\n * same idempotency key.\n */\nexport class LockAcquisitionError extends Error {\n  constructor(\n    public readonly flowName: string,\n    public readonly flowId: string,\n    reason?: string,\n  ) {\n    super(\n      reason\n        ? `failed to acquire lock for ${flowName}/${flowId}: ${reason}`\n        : `failed to acquire lock for ${flowName}/${flowId}`,\n    );\n    this.name = 'LockAcquisitionError';\n  }\n}\n\n/** Thrown by the executor when a step fails and compensation runs. */\nexport class FlowError extends Error {\n  constructor(\n    message: string,\n    public readonly flowId: string,\n    public readonly flowName: string,\n    public readonly failedStep: string,\n    public readonly originalError: unknown,\n    public readonly compensationErrors: Array<{ step: string; error: unknown }> = [],\n  ) {\n    super(message);\n    this.name = 'FlowError';\n    (this as { cause?: unknown }).cause = originalError;\n  }\n}\n\n/** Heuristic: errors are retryable unless explicitly marked permanent. */\nexport function isPermanent(err: unknown): boolean {\n  return (\n    err instanceof PermanentError ||\n    (typeof err === 'object' && err !== null && (err as { permanent?: boolean }).permanent === true)\n  );\n}\n\nexport function isTransient(err: unknown): boolean {\n  return (\n    err instanceof TransientError ||\n    err instanceof StepTimeoutError ||\n    (typeof err === 'object' && err !== null && (err as { transient?: boolean }).transient === true)\n  );\n}\n\nexport function serializeError(err: unknown): SerializedError {\n  if (err instanceof Error) {\n    const out: SerializedError = { name: err.name, message: err.message };\n    if (err.stack) out.stack = err.stack;\n    const withCode = err as { code?: unknown };\n    if (typeof withCode.code === 'string') out.code = withCode.code;\n    if (isTransient(err)) out.transient = true;\n    return out;\n  }\n  return { name: 'UnknownError', message: String(err) };\n}\n","import type { RetryPolicy } from './types.js';\nimport { isPermanent } from './errors.js';\n\nconst DEFAULTS = {\n  maxAttempts: 1,\n  backoff: 'exponential' as const,\n  initialDelayMs: 100,\n  maxDelayMs: 30_000,\n  multiplier: 2,\n  jitter: true as boolean | number,\n};\n\n/**\n * Compute the delay (ms) before the next attempt. Attempt numbers are 1-based;\n * `attempt` here is the attempt that just failed, so the next attempt is\n * `attempt + 1` and waits for the delay returned here.\n */\nexport function computeDelay(policy: RetryPolicy | undefined, attempt: number): number {\n  const p = { ...DEFAULTS, ...(policy ?? {}) };\n  const n = Math.max(1, attempt);\n\n  let base: number;\n  switch (p.backoff) {\n    case 'fixed':\n      base = p.initialDelayMs;\n      break;\n    case 'linear':\n      base = p.initialDelayMs * n;\n      break;\n    case 'exponential':\n    default:\n      base = p.initialDelayMs * Math.pow(p.multiplier, n - 1);\n      break;\n  }\n\n  base = Math.min(base, p.maxDelayMs);\n\n  if (p.jitter === false) return base;\n  const factor = typeof p.jitter === 'number' ? Math.max(0, Math.min(1, p.jitter)) : 1;\n  // full jitter: random in [base*(1-factor), base]\n  const min = base * (1 - factor);\n  return min + Math.random() * (base - min);\n}\n\n/**\n * Decide whether `error` should trigger another attempt given the current\n * policy and attempt count. Callers still need to enforce maxAttempts.\n */\nexport function shouldRetryError(\n  policy: RetryPolicy | undefined,\n  error: unknown,\n  attempt: number,\n): boolean {\n  if (policy?.shouldRetry) return policy.shouldRetry(error, attempt);\n  if (isPermanent(error)) return false;\n  return true;\n}\n\nexport function getMaxAttempts(policy: RetryPolicy | undefined): number {\n  return policy?.maxAttempts ?? DEFAULTS.maxAttempts;\n}\n","import type { Logger } from '../types.js';\n\n/** Discards all log output. Default when the user configures no logger. */\nexport const silentLogger: Logger = {\n  debug() {},\n  info() {},\n  warn() {},\n  error() {},\n  child() {\n    return silentLogger;\n  },\n};\n\n/** Minimal console-backed logger, useful for local debugging. */\nexport const consoleLogger: Logger = {\n  debug(msg, meta) {\n    // eslint-disable-next-line no-console\n    console.debug(`[kompensa] ${msg}`, meta ?? '');\n  },\n  info(msg, meta) {\n    // eslint-disable-next-line no-console\n    console.info(`[kompensa] ${msg}`, meta ?? '');\n  },\n  warn(msg, meta) {\n    // eslint-disable-next-line no-console\n    console.warn(`[kompensa] ${msg}`, meta ?? '');\n  },\n  error(msg, meta) {\n    // eslint-disable-next-line no-console\n    console.error(`[kompensa] ${msg}`, meta ?? '');\n  },\n  child(meta) {\n    return {\n      debug(m, x) {\n        consoleLogger.debug(m, { ...meta, ...x });\n      },\n      info(m, x) {\n        consoleLogger.info(m, { ...meta, ...x });\n      },\n      warn(m, x) {\n        consoleLogger.warn(m, { ...meta, ...x });\n      },\n      error(m, x) {\n        consoleLogger.error(m, { ...meta, ...x });\n      },\n    };\n  },\n};\n","import type { FlowHooks, Logger } from '../types.js';\n\ntype HookName = keyof FlowHooks;\n\n/**\n * Invoke a hook defensively: await it, catch any error, and log at warn level.\n * Hook failures must never affect the flow's outcome.\n */\nexport async function invokeHook<K extends HookName>(\n  hooks: FlowHooks | undefined,\n  name: K,\n  event: Parameters<NonNullable<FlowHooks[K]>>[0],\n  logger: Logger,\n): Promise<void> {\n  const fn = hooks?.[name] as\n    | ((event: Parameters<NonNullable<FlowHooks[K]>>[0]) => void | Promise<void>)\n    | undefined;\n  if (!fn) return;\n  try {\n    await fn(event);\n  } catch (err) {\n    logger.warn(`hook ${String(name)} threw`, {\n      error: err instanceof Error ? err.message : String(err),\n    });\n  }\n}\n","/**\n * Deep-clone a value for snapshot isolation. Prefers structuredClone (Node 17+,\n * modern browsers, Hermes 0.72+) and falls back to JSON for older runtimes.\n * Flow state is already constrained to serializable shapes.\n */\nexport function deepClone<T>(value: T): T {\n  if (value === undefined || value === null) return value;\n  const sc = (globalThis as { structuredClone?: <V>(v: V) => V }).structuredClone;\n  if (typeof sc === 'function') {\n    return sc(value);\n  }\n  return JSON.parse(JSON.stringify(value)) as T;\n}\n","import type { AcquireLockOptions, FlowState, Lock, StorageAdapter } from '../types.js';\nimport { LockAcquisitionError } from '../errors.js';\nimport { deepClone } from '../utils/clone.js';\n\ntype Waiter = {\n  resolve: () => void;\n  reject: (err: Error) => void;\n  timer: ReturnType<typeof setTimeout>;\n};\n\ntype LockEntry = {\n  released: boolean;\n  ttlTimer: ReturnType<typeof setTimeout>;\n};\n\n/**\n * In-memory storage adapter. Safe default for tests, single-process services,\n * and browser/mobile usage where durability isn't required.\n *\n * Implements in-process locking — sufficient for single-process safety.\n * For multi-worker deployments use a durable adapter (Postgres/Redis) whose\n * locks survive across processes.\n *\n * State is cloned on both read and write so callers can't accidentally mutate\n * stored snapshots.\n */\nexport class MemoryStorage implements StorageAdapter {\n  private readonly store = new Map<string, FlowState>();\n  private readonly locks = new Map<string, LockEntry>();\n  private readonly waiters = new Map<string, Waiter[]>();\n\n  private key(flowName: string, flowId: string): string {\n    return `${flowName}:${flowId}`;\n  }\n\n  async load(flowName: string, flowId: string): Promise<FlowState | null> {\n    const entry = this.store.get(this.key(flowName, flowId));\n    return entry ? deepClone(entry) : null;\n  }\n\n  async save(state: FlowState): Promise<void> {\n    this.store.set(this.key(state.flowName, state.flowId), deepClone(state));\n  }\n\n  async delete(flowName: string, flowId: string): Promise<void> {\n    this.store.delete(this.key(flowName, flowId));\n  }\n\n  async acquireLock(\n    flowName: string,\n    flowId: string,\n    options: AcquireLockOptions,\n  ): Promise<Lock> {\n    const key = this.key(flowName, flowId);\n    const { ttlMs, timeoutMs } = options;\n\n    // Fast path: lock free.\n    if (!this.locks.has(key)) {\n      return this.claim(key, ttlMs);\n    }\n\n    // Fail fast if the caller declined to wait.\n    if (timeoutMs <= 0) {\n      throw new LockAcquisitionError(flowName, flowId, 'lock is held');\n    }\n\n    // Wait for the current holder (or TTL) to release, then claim.\n    await new Promise<void>((resolve, reject) => {\n      const timer = setTimeout(() => {\n        const list = this.waiters.get(key);\n        if (list) {\n          const idx = list.findIndex((w) => w.timer === timer);\n          if (idx >= 0) list.splice(idx, 1);\n          if (list.length === 0) this.waiters.delete(key);\n        }\n        reject(new LockAcquisitionError(flowName, flowId, `wait timeout after ${timeoutMs}ms`));\n      }, timeoutMs);\n\n      const list = this.waiters.get(key) ?? [];\n      list.push({ resolve, reject, timer });\n      this.waiters.set(key, list);\n    });\n\n    // At this point the prior holder has released and we've been selected —\n    // claim synchronously before any other microtask can interleave.\n    return this.claim(key, ttlMs);\n  }\n\n  private claim(key: string, ttlMs: number): Lock {\n    const entry: LockEntry = {\n      released: false,\n      // placeholder; assigned just below so closure can reference `entry`.\n      ttlTimer: null as unknown as ReturnType<typeof setTimeout>,\n    };\n\n    const releaseImpl = (): void => {\n      if (entry.released) return;\n      entry.released = true;\n      clearTimeout(entry.ttlTimer);\n      if (this.locks.get(key) === entry) {\n        this.locks.delete(key);\n      }\n      // Wake the next FIFO waiter, if any.\n      const list = this.waiters.get(key);\n      if (list && list.length > 0) {\n        const next = list.shift()!;\n        if (list.length === 0) this.waiters.delete(key);\n        clearTimeout(next.timer);\n        next.resolve();\n      }\n    };\n\n    entry.ttlTimer = setTimeout(releaseImpl, ttlMs);\n    this.locks.set(key, entry);\n\n    return {\n      async release() {\n        releaseImpl();\n      },\n      async refresh() {\n        if (entry.released) return;\n        clearTimeout(entry.ttlTimer);\n        entry.ttlTimer = setTimeout(releaseImpl, ttlMs);\n      },\n    };\n  }\n\n  /** Return every persisted state (useful for introspection/tests). */\n  snapshot(): FlowState[] {\n    return Array.from(this.store.values(), (s) => deepClone(s));\n  }\n\n  clear(): void {\n    // Cancel all pending waiters and timers so tests don't leak handles.\n    for (const [, entry] of this.locks) clearTimeout(entry.ttlTimer);\n    for (const [, list] of this.waiters) {\n      for (const w of list) {\n        clearTimeout(w.timer);\n        w.reject(new Error('storage cleared'));\n      }\n    }\n    this.store.clear();\n    this.locks.clear();\n    this.waiters.clear();\n  }\n\n  get size(): number {\n    return this.store.size;\n  }\n}\n\nexport function createMemoryStorage(): MemoryStorage {\n  return new MemoryStorage();\n}\n","import { FlowAbortedError } from '../errors.js';\n\n/**\n * Promise-based sleep that respects an AbortSignal. Rejects with\n * FlowAbortedError if the signal fires mid-wait.\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  if (ms <= 0) {\n    if (signal?.aborted) return Promise.reject(new FlowAbortedError(signal.reason));\n    return Promise.resolve();\n  }\n\n  return new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(new FlowAbortedError(signal.reason));\n      return;\n    }\n\n    const timer = setTimeout(() => {\n      signal?.removeEventListener('abort', onAbort);\n      resolve();\n    }, ms);\n\n    const onAbort = () => {\n      clearTimeout(timer);\n      signal?.removeEventListener('abort', onAbort);\n      reject(new FlowAbortedError(signal?.reason));\n    };\n\n    signal?.addEventListener('abort', onAbort, { once: true });\n  });\n}\n","import { StepTimeoutError } from '../errors.js';\n\n/**\n * Race a promise against a timeout and an optional abort signal. Aborts the\n * internal controller to propagate cancellation to the step if it observes it.\n */\nexport function withTimeout<T>(\n  promise: Promise<T>,\n  ms: number,\n  stepName: string,\n): Promise<T> {\n  if (ms <= 0 || !Number.isFinite(ms)) return promise;\n\n  return new Promise<T>((resolve, reject) => {\n    const timer = setTimeout(() => {\n      reject(new StepTimeoutError(stepName, ms));\n    }, ms);\n\n    promise.then(\n      (value) => {\n        clearTimeout(timer);\n        resolve(value);\n      },\n      (err) => {\n        clearTimeout(timer);\n        reject(err);\n      },\n    );\n  });\n}\n","/**\n * Generate a URL-safe random id. Uses Web Crypto where available (Node 18+,\n * modern browsers, Hermes via polyfill); falls back to Math.random.\n */\nexport function generateId(prefix = 'flow'): string {\n  const globalCrypto = (globalThis as { crypto?: Crypto }).crypto;\n  if (globalCrypto?.randomUUID) {\n    return `${prefix}_${globalCrypto.randomUUID()}`;\n  }\n  if (globalCrypto?.getRandomValues) {\n    const bytes = new Uint8Array(16);\n    globalCrypto.getRandomValues(bytes);\n    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');\n    return `${prefix}_${hex}`;\n  }\n  let rand = '';\n  for (let i = 0; i < 32; i++) {\n    rand += Math.floor(Math.random() * 16).toString(16);\n  }\n  return `${prefix}_${rand}`;\n}\n","import type {\n  FlowConfig,\n  FlowHooks,\n  FlowState,\n  Lock,\n  Logger,\n  RetryPolicy,\n  StepContext,\n  StepDefinition,\n  StepState,\n  StorageAdapter,\n  ExecuteOptions,\n} from './types.js';\n\nconst DEFAULT_LOCK_TTL_MS = 5 * 60 * 1000;\nconst DEFAULT_LOCK_WAIT_MS = 30 * 1000;\nimport { FlowAbortedError, FlowError, serializeError } from './errors.js';\nimport { computeDelay, getMaxAttempts, shouldRetryError } from './retry.js';\nimport { silentLogger } from './observability/logger.js';\nimport { invokeHook } from './observability/hooks.js';\nimport { MemoryStorage } from './storage/memory.js';\nimport { sleep } from './utils/sleep.js';\nimport { withTimeout } from './utils/timeout.js';\nimport { generateId } from './utils/id.js';\n\nexport interface RegisteredStep {\n  name: string;\n  /** `'sequential'` (default) or `'parallel'` for fan-out/fan-in groups. */\n  kind?: 'sequential' | 'parallel';\n  /**\n   * For sequential steps this carries the step body. For parallel groups it is\n   * `undefined` — the executor reads `branches`/`parallelOptions` instead.\n   */\n  definition: StepDefinition<unknown, Record<string, unknown>, unknown>;\n  /**\n   * Set only when `kind === 'parallel'`. Map of branch name → branch\n   * definition (same shape as a regular step). The executor runs all branches\n   * concurrently, persisting each one under `state.steps[i].branches[branchName]`.\n   */\n  branches?: Record<string, StepDefinition<unknown, Record<string, unknown>, unknown>>;\n  /** Set only when `kind === 'parallel'`. Group-level options. */\n  parallelOptions?: import('./types.js').ParallelGroupOptions;\n}\n\nfunction errorMessage(err: unknown): string {\n  if (err instanceof Error) return err.message;\n  return String(err);\n}\n\nfunction findFailedStepName(state: FlowState): string {\n  const failed = state.steps.find((s) => s.status === 'failed' || s.status === 'compensated');\n  return failed?.name ?? 'unknown';\n}\n\nfunction hydrateError(serialized?: FlowState['error']): Error {\n  if (!serialized) return new Error('unknown error');\n  const err = new Error(serialized.message);\n  err.name = serialized.name;\n  if (serialized.stack) err.stack = serialized.stack;\n  return err;\n}\n\nfunction createInitialState(\n  flowName: string,\n  flowId: string,\n  steps: RegisteredStep[],\n  input: unknown,\n  metadata: Record<string, unknown>,\n): FlowState {\n  const now = Date.now();\n  return {\n    flowName,\n    flowId,\n    status: 'pending',\n    input,\n    steps: steps.map<StepState>((s) =>\n      s.kind === 'parallel'\n        ? {\n            name: s.name,\n            status: 'pending',\n            attempts: 0,\n            kind: 'parallel',\n            branches: Object.fromEntries(\n              Object.keys(s.branches ?? {}).map((bn) => [\n                bn,\n                { name: bn, status: 'pending', attempts: 0 },\n              ]),\n            ),\n          }\n        : {\n            name: s.name,\n            status: 'pending',\n            attempts: 0,\n          },\n    ),\n    currentStepIndex: 0,\n    metadata,\n    createdAt: now,\n    updatedAt: now,\n  };\n}\n\nfunction buildContext<TInput>(args: {\n  input: TInput;\n  results: Record<string, unknown>;\n  metadata: Record<string, unknown>;\n  attempt: number;\n  signal: AbortSignal;\n  flowId: string;\n  flowName: string;\n  stepName: string;\n  logger: Logger;\n}): StepContext<TInput, Record<string, unknown>> {\n  return {\n    input: args.input,\n    results: args.results,\n    metadata: args.metadata,\n    attempt: args.attempt,\n    signal: args.signal,\n    flowId: args.flowId,\n    flowName: args.flowName,\n    stepName: args.stepName,\n    logger: args.logger,\n  };\n}\n\nasync function runSingleAttempt<TInput>(\n  definition: StepDefinition<unknown, Record<string, unknown>, unknown>,\n  unitName: string,\n  ctx: StepContext<TInput, Record<string, unknown>>,\n  timeoutMs: number | undefined,\n): Promise<unknown> {\n  const exec = Promise.resolve().then(() =>\n    (definition.run as (c: typeof ctx) => unknown | Promise<unknown>)(ctx),\n  );\n  if (timeoutMs && timeoutMs > 0) {\n    return withTimeout(exec, timeoutMs, unitName);\n  }\n  return exec;\n}\n\n/**\n * Generalized retry loop used by both regular sequential steps and individual\n * branches inside a parallel group. The caller supplies the {@link StepState}\n * to mutate, the hook stepName (`group.branch` for branches), and a `persist`\n * callback that saves the parent {@link FlowState}.\n */\nasync function runUnitWithRetry<TInput>(args: {\n  definition: StepDefinition<unknown, Record<string, unknown>, unknown>;\n  hookStepName: string;\n  stepIndex: number;\n  unitState: import('./types.js').StepState;\n  persist: () => Promise<void>;\n  input: TInput;\n  results: Record<string, unknown>;\n  metadata: Record<string, unknown>;\n  signal: AbortSignal;\n  flowId: string;\n  flowName: string;\n  logger: Logger;\n  hooks: FlowHooks | undefined;\n  defaultRetry: RetryPolicy | undefined;\n  defaultTimeout: number | undefined;\n}): Promise<unknown> {\n  const {\n    definition,\n    hookStepName,\n    stepIndex,\n    unitState,\n    persist,\n    input,\n    results,\n    metadata,\n    signal,\n    flowId,\n    flowName,\n    logger,\n    hooks,\n    defaultRetry,\n    defaultTimeout,\n  } = args;\n\n  const policy = definition.retry ?? defaultRetry;\n  const maxAttempts = Math.max(1, getMaxAttempts(policy));\n  const timeout = definition.timeout ?? defaultTimeout;\n\n  let lastError: unknown;\n\n  for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n    if (signal.aborted) throw new FlowAbortedError(signal.reason);\n\n    unitState.attempts = attempt;\n    unitState.status = 'running';\n    if (attempt === 1) unitState.startedAt = Date.now();\n    await persist();\n\n    const ctx = buildContext({\n      input,\n      results,\n      metadata,\n      attempt,\n      signal,\n      flowId,\n      flowName,\n      stepName: hookStepName,\n      logger: logger.child?.({ stepName: hookStepName, attempt }) ?? logger,\n    });\n\n    await invokeHook(\n      hooks,\n      'onStepStart',\n      { flowName, flowId, metadata, stepName: hookStepName, stepIndex, attempt },\n      logger,\n    );\n\n    try {\n      const result = await runSingleAttempt(definition, hookStepName, ctx, timeout);\n      return result;\n    } catch (err) {\n      lastError = err;\n\n      const isLastAttempt = attempt >= maxAttempts;\n      const aborted = signal.aborted || err instanceof FlowAbortedError;\n      const retryable = !aborted && !isLastAttempt && shouldRetryError(policy, err, attempt);\n\n      if (!retryable) throw err;\n\n      const delay = computeDelay(policy, attempt);\n      await invokeHook(\n        hooks,\n        'onStepRetry',\n        {\n          flowName,\n          flowId,\n          metadata,\n          stepName: hookStepName,\n          stepIndex,\n          attempt,\n          error: err,\n          nextDelayMs: delay,\n        },\n        logger,\n      );\n\n      await sleep(delay, signal);\n    }\n  }\n\n  throw lastError;\n}\n\n/**\n * Derive a child AbortSignal that aborts when the parent aborts AND can be\n * aborted independently (used to fail-fast sibling branches when one fails).\n * Hand-rolled instead of `AbortSignal.any` for Node 18 compatibility.\n */\nfunction deriveSignal(parent: AbortSignal): {\n  signal: AbortSignal;\n  abort: (reason?: unknown) => void;\n} {\n  const ctrl = new AbortController();\n  if (parent.aborted) {\n    ctrl.abort(parent.reason);\n  } else {\n    parent.addEventListener('abort', () => ctrl.abort(parent.reason), { once: true });\n  }\n  return { signal: ctrl.signal, abort: (r) => ctrl.abort(r) };\n}\n\n/**\n * Run a parallel step group. Each branch executes concurrently with its own\n * retry loop. Branch state is persisted under `state.steps[stepIndex].branches[name]`\n * so crash recovery can resume only the branches that did not finish.\n *\n * Behavior:\n * - First failure aborts siblings via a derived signal when\n *   `abortOnFailure !== false` (the default).\n * - The whole group is wrapped in a `groupTimeout` if specified.\n * - Returns the merged `{ [branchName]: result }` object on success; throws\n *   the first branch error on failure (with surviving compensations handled\n *   by `runCompensation`).\n */\nasync function runParallelGroup<TInput>(args: {\n  step: RegisteredStep;\n  stepIndex: number;\n  state: FlowState;\n  input: TInput;\n  results: Record<string, unknown>;\n  metadata: Record<string, unknown>;\n  signal: AbortSignal;\n  flowId: string;\n  flowName: string;\n  logger: Logger;\n  hooks: FlowHooks | undefined;\n  defaultRetry: RetryPolicy | undefined;\n  defaultTimeout: number | undefined;\n  storage: StorageAdapter;\n}): Promise<Record<string, unknown>> {\n  const {\n    step,\n    stepIndex,\n    state,\n    input,\n    results,\n    metadata,\n    signal,\n    flowId,\n    flowName,\n    logger,\n    hooks,\n    defaultRetry,\n    defaultTimeout,\n    storage,\n  } = args;\n\n  if (!step.branches) {\n    throw new Error(\n      `kompensa: internal — parallel step \"${step.name}\" missing branches map`,\n    );\n  }\n  const groupOpts = step.parallelOptions ?? {};\n  const abortOnFailure = groupOpts.abortOnFailure !== false;\n\n  const groupState = state.steps[stepIndex]!;\n  groupState.kind = 'parallel';\n  groupState.status = 'running';\n  groupState.startedAt ??= Date.now();\n  groupState.branches ??= {};\n\n  const branchNames = Object.keys(step.branches);\n  // Ensure every branch has its own StepState entry, even on first run.\n  for (const bn of branchNames) {\n    if (!groupState.branches[bn]) {\n      groupState.branches[bn] = { name: bn, status: 'pending', attempts: 0 };\n    }\n  }\n  await storage.save(state);\n\n  const branchResults: Record<string, unknown> = {};\n  // Pre-populate with cached results from previously successful branches so\n  // crash recovery skips them.\n  for (const bn of branchNames) {\n    const bs = groupState.branches[bn]!;\n    if (bs.status === 'success') {\n      branchResults[bn] = bs.result;\n    }\n  }\n\n  const persist = () => storage.save(state);\n  const { signal: groupSignal, abort: abortGroup } = deriveSignal(signal);\n\n  const branchPromises: Promise<void>[] = branchNames.map(async (branchName) => {\n    const bs = groupState.branches![branchName]!;\n    if (bs.status === 'success') return; // resume — already done\n\n    const definition = step.branches![branchName]!;\n    const hookStepName = `${step.name}.${branchName}`;\n    const branchStart = Date.now();\n\n    try {\n      const result = await runUnitWithRetry({\n        definition,\n        hookStepName,\n        stepIndex,\n        unitState: bs,\n        persist,\n        input,\n        results,\n        metadata,\n        signal: groupSignal,\n        flowId,\n        flowName,\n        logger,\n        hooks,\n        defaultRetry,\n        defaultTimeout,\n      });\n      bs.status = 'success';\n      bs.result = result;\n      bs.endedAt = Date.now();\n      branchResults[branchName] = result;\n      await persist();\n\n      await invokeHook(\n        hooks,\n        'onStepEnd',\n        {\n          flowName,\n          flowId,\n          metadata,\n          stepName: hookStepName,\n          stepIndex,\n          status: 'success',\n          attempts: bs.attempts,\n          durationMs: Date.now() - branchStart,\n          result,\n        },\n        logger,\n      );\n    } catch (err) {\n      bs.status = 'failed';\n      bs.error = serializeError(err);\n      bs.endedAt = Date.now();\n      await persist();\n\n      await invokeHook(\n        hooks,\n        'onStepEnd',\n        {\n          flowName,\n          flowId,\n          metadata,\n          stepName: hookStepName,\n          stepIndex,\n          status: 'failed',\n          attempts: bs.attempts,\n          durationMs: Date.now() - branchStart,\n          error: err,\n        },\n        logger,\n      );\n\n      if (abortOnFailure) abortGroup(err);\n      throw err;\n    }\n  });\n\n  const allBranches = Promise.allSettled(branchPromises);\n  const settled = groupOpts.groupTimeout\n    ? await withTimeout(allBranches, groupOpts.groupTimeout, step.name)\n    : await allBranches;\n\n  // Aggregate `attempts` on the group as the max across branches so callers\n  // see a meaningful number even when only some branches retried.\n  groupState.attempts = Math.max(\n    1,\n    ...branchNames.map((bn) => groupState.branches![bn]?.attempts ?? 1),\n  );\n\n  const failures = settled\n    .map((r, idx) => ({ result: r, name: branchNames[idx]! }))\n    .filter((x) => x.result.status === 'rejected') as Array<{\n    result: PromiseRejectedResult;\n    name: string;\n  }>;\n\n  if (failures.length === 0) {\n    return branchResults;\n  }\n\n  // Surface the first failure as the canonical error. Other failures remain\n  // visible via per-branch `error` fields in persisted state.\n  const first = failures[0]!;\n  throw first.result.reason;\n}\n\n/** Compensate a single unit (a regular step or one branch of a parallel group). */\nasync function compensateUnit<TInput>(args: {\n  definition: StepDefinition<unknown, Record<string, unknown>, unknown>;\n  hookStepName: string;\n  stepIndex: number;\n  unitState: import('./types.js').StepState;\n  persist: () => Promise<void>;\n  input: TInput;\n  results: Record<string, unknown>;\n  metadata: Record<string, unknown>;\n  signal: AbortSignal;\n  flowId: string;\n  flowName: string;\n  logger: Logger;\n  hooks: FlowHooks | undefined;\n}): Promise<{ ok: true } | { ok: false; error: unknown }> {\n  const {\n    definition,\n    hookStepName,\n    stepIndex,\n    unitState,\n    persist,\n    input,\n    results,\n    metadata,\n    signal,\n    flowId,\n    flowName,\n    logger,\n    hooks,\n  } = args;\n\n  if (!definition.compensate) return { ok: true };\n  if (unitState.status !== 'success') return { ok: true };\n\n  unitState.status = 'compensating';\n  await persist();\n  await invokeHook(\n    hooks,\n    'onCompensate',\n    { flowName, flowId, metadata, stepName: hookStepName, stepIndex, status: 'compensating' },\n    logger,\n  );\n\n  const ctx = buildContext({\n    input,\n    results,\n    metadata,\n    attempt: 1,\n    signal,\n    flowId,\n    flowName,\n    stepName: hookStepName,\n    logger: logger.child?.({ stepName: hookStepName, phase: 'compensate' }) ?? logger,\n  });\n\n  try {\n    await (definition.compensate as (c: typeof ctx, r: unknown) => unknown | Promise<unknown>)(\n      ctx,\n      unitState.result,\n    );\n    unitState.status = 'compensated';\n    await persist();\n    await invokeHook(\n      hooks,\n      'onCompensate',\n      { flowName, flowId, metadata, stepName: hookStepName, stepIndex, status: 'compensated' },\n      logger,\n    );\n    return { ok: true };\n  } catch (err) {\n    unitState.compensationError = serializeError(err);\n    await persist();\n    await invokeHook(\n      hooks,\n      'onCompensate',\n      {\n        flowName,\n        flowId,\n        metadata,\n        stepName: hookStepName,\n        stepIndex,\n        status: 'failed',\n        error: err,\n      },\n      logger,\n    );\n    return { ok: false, error: err };\n  }\n}\n\nasync function runCompensation<TInput>(args: {\n  steps: RegisteredStep[];\n  state: FlowState;\n  results: Record<string, unknown>;\n  input: TInput;\n  metadata: Record<string, unknown>;\n  logger: Logger;\n  hooks: FlowHooks | undefined;\n  flowId: string;\n  flowName: string;\n  signal: AbortSignal;\n  storage: StorageAdapter;\n}): Promise<Array<{ step: string; error: unknown }>> {\n  const { steps, state, results, input, metadata, logger, hooks, flowId, flowName, signal, storage } =\n    args;\n  const errors: Array<{ step: string; error: unknown }> = [];\n  const persist = () => storage.save(state);\n\n  for (let i = state.currentStepIndex; i >= 0; i--) {\n    const step = steps[i];\n    const stepState = state.steps[i];\n    if (!step || !stepState) continue;\n\n    // ---- Parallel group compensation ----\n    if (step.kind === 'parallel' && step.branches && stepState.branches) {\n      // Only compensate branches that actually succeeded.\n      const successful = Object.entries(stepState.branches).filter(\n        ([, bs]) => bs.status === 'success',\n      );\n      if (successful.length === 0) continue;\n\n      const compensateSerially = step.parallelOptions?.compensateSerially === true;\n      const ordered = compensateSerially\n        ? // Reverse-completion-order rollback: branch that finished last is\n          // compensated first (LIFO on causal chain).\n          [...successful].sort(([, a], [, b]) => (b.endedAt ?? 0) - (a.endedAt ?? 0))\n        : successful;\n\n      stepState.status = 'compensating';\n      await persist();\n\n      const compensateOne = async (branchName: string) => {\n        const bs = stepState.branches![branchName]!;\n        const def = step.branches![branchName]!;\n        const result = await compensateUnit({\n          definition: def,\n          hookStepName: `${step.name}.${branchName}`,\n          stepIndex: i,\n          unitState: bs,\n          persist,\n          input,\n          results,\n          metadata,\n          signal,\n          flowId,\n          flowName,\n          logger,\n          hooks,\n        });\n        if (!result.ok) {\n          errors.push({ step: `${step.name}.${branchName}`, error: result.error });\n        }\n      };\n\n      if (compensateSerially) {\n        for (const [bn] of ordered) {\n          await compensateOne(bn);\n        }\n      } else {\n        await Promise.allSettled(ordered.map(([bn]) => compensateOne(bn)));\n      }\n\n      // Group status: compensated when every successful branch is compensated;\n      // otherwise leave 'compensating' so observers can see partial rollback.\n      const allCompensated = Object.values(stepState.branches).every(\n        (bs) => bs.status !== 'success',\n      );\n      if (allCompensated) stepState.status = 'compensated';\n      await persist();\n      continue;\n    }\n\n    // ---- Sequential step compensation ----\n    if (stepState.status !== 'success') continue;\n    const result = await compensateUnit({\n      definition: step.definition,\n      hookStepName: step.name,\n      stepIndex: i,\n      unitState: stepState,\n      persist,\n      input,\n      results,\n      metadata,\n      signal,\n      flowId,\n      flowName,\n      logger,\n      hooks,\n    });\n    if (!result.ok) {\n      errors.push({ step: step.name, error: result.error });\n    }\n  }\n\n  return errors;\n}\n\nexport async function executeFlow<TInput, TResults extends object>(args: {\n  flowName: string;\n  steps: RegisteredStep[];\n  input: TInput;\n  config: FlowConfig;\n  options: ExecuteOptions;\n}): Promise<TResults> {\n  const { flowName, steps, input, config, options } = args;\n  const startTime = Date.now();\n\n  const storage = config.storage ?? new MemoryStorage();\n  const baseLogger = config.logger ?? silentLogger;\n  const hooks = config.hooks;\n  const defaultRetry = config.defaultRetry;\n  const defaultTimeout = options.timeout ?? config.defaultTimeout;\n  const signal = options.signal ?? new AbortController().signal;\n  const metadata: Record<string, unknown> = { ...(options.metadata ?? {}) };\n\n  const flowId = options.idempotencyKey ?? generateId(flowName);\n  const logger = baseLogger.child?.({ flowName, flowId }) ?? baseLogger;\n\n  // Acquire an exclusive lock for the (flowName, flowId) pair when the storage\n  // adapter supports it. This prevents two workers from racing on the same\n  // idempotency key. If the adapter doesn't implement acquireLock we fall\n  // through — safe for single-process deployments like MemoryStorage in tests.\n  const lockTtlMs = config.lockTtlMs ?? DEFAULT_LOCK_TTL_MS;\n  const lockWaitMs = config.lockWaitMs ?? DEFAULT_LOCK_WAIT_MS;\n  let lock: Lock | null = null;\n  if (storage.acquireLock) {\n    lock = await storage.acquireLock(flowName, flowId, {\n      ttlMs: lockTtlMs,\n      timeoutMs: lockWaitMs,\n    });\n  }\n\n  try {\n    return await runExecution<TInput, TResults>({\n      flowName,\n      flowId,\n      steps,\n      input,\n      config,\n      options,\n      storage,\n      logger,\n      hooks,\n      defaultRetry,\n      defaultTimeout,\n      signal,\n      metadata,\n      startTime,\n    });\n  } finally {\n    if (lock) {\n      try {\n        await lock.release();\n      } catch (err) {\n        logger.warn('lock release failed', {\n          error: err instanceof Error ? err.message : String(err),\n        });\n      }\n    }\n  }\n}\n\ninterface RunExecutionArgs<TInput> {\n  flowName: string;\n  flowId: string;\n  steps: RegisteredStep[];\n  input: TInput;\n  config: FlowConfig;\n  options: ExecuteOptions;\n  storage: StorageAdapter;\n  logger: Logger;\n  hooks: FlowHooks | undefined;\n  defaultRetry: RetryPolicy | undefined;\n  defaultTimeout: number | undefined;\n  signal: AbortSignal;\n  metadata: Record<string, unknown>;\n  startTime: number;\n}\n\nasync function runExecution<TInput, TResults extends object>(\n  args: RunExecutionArgs<TInput>,\n): Promise<TResults> {\n  const {\n    flowName,\n    flowId,\n    steps,\n    input,\n    storage,\n    logger,\n    hooks,\n    defaultRetry,\n    defaultTimeout,\n    signal,\n    metadata,\n    startTime,\n  } = args;\n\n  let state = await storage.load(flowName, flowId);\n\n  // Short-circuit: already succeeded → return cached result.\n  if (state?.status === 'success') {\n    logger.debug('flow already succeeded, returning cached result');\n    return (state.result ?? {}) as TResults;\n  }\n\n  // Already compensated → re-throw historical failure instead of re-running.\n  if (state?.status === 'compensated' || state?.status === 'failed') {\n    const err = hydrateError(state.error);\n    throw new FlowError(\n      `flow \"${flowName}\" previously ${state.status}: ${err.message}`,\n      flowId,\n      flowName,\n      findFailedStepName(state),\n      err,\n    );\n  }\n\n  const resumed = !!state;\n  if (!state) {\n    state = createInitialState(flowName, flowId, steps, input, metadata);\n  } else {\n    // Resume path: keep original input, merge metadata.\n    state.status = 'running';\n    state.metadata = { ...state.metadata, ...metadata };\n    state.updatedAt = Date.now();\n    // Keep state.input as the original — resume must be deterministic.\n  }\n  state.status = 'running';\n  await storage.save(state);\n\n  // Rebuild results map from previously successful steps.\n  const results: Record<string, unknown> = {};\n  for (const s of state.steps) {\n    if (s.status === 'success' || s.status === 'skipped') {\n      results[s.name] = s.result;\n    }\n  }\n\n  // Resume from the first non-complete step.\n  const firstIncomplete = state.steps.findIndex(\n    (s) => s.status !== 'success' && s.status !== 'skipped',\n  );\n  const startIndex = firstIncomplete === -1 ? state.steps.length : firstIncomplete;\n\n  await invokeHook(\n    hooks,\n    'onFlowStart',\n    { flowName, flowId, metadata, input: state.input, resumed },\n    logger,\n  );\n\n  const effectiveInput = state.input as TInput;\n\n  try {\n    for (let i = startIndex; i < steps.length; i++) {\n      const step = steps[i]!;\n      const stepState = state.steps[i]!;\n      state.currentStepIndex = i;\n\n      const stepStart = Date.now();\n      try {\n        if (signal.aborted) throw new FlowAbortedError(signal.reason);\n\n        // skipIf check\n        if (step.definition.skipIf) {\n          const skipCtx = buildContext({\n            input: effectiveInput,\n            results,\n            metadata,\n            attempt: 0,\n            signal,\n            flowId,\n            flowName,\n            stepName: step.name,\n            logger: logger.child?.({ stepName: step.name }) ?? logger,\n          });\n          const skip = await step.definition.skipIf(skipCtx);\n          if (skip) {\n            stepState.status = 'skipped';\n            stepState.startedAt = Date.now();\n            stepState.endedAt = Date.now();\n            await storage.save(state);\n            await invokeHook(\n              hooks,\n              'onStepEnd',\n              {\n                flowName,\n                flowId,\n                metadata,\n                stepName: step.name,\n                stepIndex: i,\n                status: 'skipped',\n                attempts: 0,\n                durationMs: 0,\n              },\n              logger,\n            );\n            continue;\n          }\n        }\n\n        let result: unknown;\n        if (step.kind === 'parallel') {\n          result = await runParallelGroup({\n            step,\n            stepIndex: i,\n            state,\n            input: effectiveInput,\n            results,\n            metadata,\n            signal,\n            flowId,\n            flowName,\n            logger,\n            hooks,\n            defaultRetry,\n            defaultTimeout,\n            storage,\n          });\n        } else {\n          result = await runUnitWithRetry({\n            definition: step.definition,\n            hookStepName: step.name,\n            stepIndex: i,\n            unitState: stepState,\n            persist: () => storage.save(state),\n            input: effectiveInput,\n            results,\n            metadata,\n            signal,\n            flowId,\n            flowName,\n            logger,\n            hooks,\n            defaultRetry,\n            defaultTimeout,\n          });\n        }\n\n        stepState.status = 'success';\n        stepState.result = result;\n        stepState.endedAt = Date.now();\n        results[step.name] = result;\n        await storage.save(state);\n\n        await invokeHook(\n          hooks,\n          'onStepEnd',\n          {\n            flowName,\n            flowId,\n            metadata,\n            stepName: step.name,\n            stepIndex: i,\n            status: 'success',\n            attempts: stepState.attempts,\n            durationMs: Date.now() - stepStart,\n            result,\n          },\n          logger,\n        );\n      } catch (err) {\n        stepState.status = 'failed';\n        stepState.error = serializeError(err);\n        stepState.endedAt = Date.now();\n        state.status = 'compensating';\n        await storage.save(state);\n\n        await invokeHook(\n          hooks,\n          'onStepEnd',\n          {\n            flowName,\n            flowId,\n            metadata,\n            stepName: step.name,\n            stepIndex: i,\n            status: 'failed',\n            attempts: stepState.attempts,\n            durationMs: Date.now() - stepStart,\n            error: err,\n          },\n          logger,\n        );\n\n        const compensationErrors = await runCompensation({\n          steps,\n          state,\n          results,\n          input: effectiveInput,\n          metadata,\n          logger,\n          hooks,\n          flowId,\n          flowName,\n          signal,\n          storage,\n        });\n\n        const finalStatus = err instanceof FlowAbortedError ? 'failed' : 'compensated';\n        state.status = finalStatus;\n        state.error = serializeError(err);\n        state.updatedAt = Date.now();\n        await storage.save(state);\n\n        const flowErr = new FlowError(\n          `flow \"${flowName}\" failed at step \"${step.name}\": ${errorMessage(err)}`,\n          flowId,\n          flowName,\n          step.name,\n          err,\n          compensationErrors,\n        );\n\n        await invokeHook(\n          hooks,\n          'onFlowEnd',\n          {\n            flowName,\n            flowId,\n            metadata,\n            status: finalStatus,\n            error: flowErr,\n            durationMs: Date.now() - startTime,\n          },\n          logger,\n        );\n\n        throw flowErr;\n      }\n    }\n\n    state.status = 'success';\n    state.result = results;\n    state.updatedAt = Date.now();\n    await storage.save(state);\n\n    await invokeHook(\n      hooks,\n      'onFlowEnd',\n      {\n        flowName,\n        flowId,\n        metadata,\n        status: 'success',\n        results,\n        durationMs: Date.now() - startTime,\n      },\n      logger,\n    );\n\n    return results as TResults;\n  } catch (err) {\n    if (err instanceof FlowError) throw err;\n    // Unexpected error path (e.g. abort before any step). Persist and rethrow.\n    state.status = 'failed';\n    state.error = serializeError(err);\n    state.updatedAt = Date.now();\n    await storage.save(state);\n    await invokeHook(\n      hooks,\n      'onFlowEnd',\n      {\n        flowName,\n        flowId,\n        metadata,\n        status: 'failed',\n        error: err,\n        durationMs: Date.now() - startTime,\n      },\n      logger,\n    );\n    throw err;\n  }\n}\n","import type {\n  ExecuteOptions,\n  FlowConfig,\n  ParallelBranchDefinition,\n  ParallelGroupOptions,\n  StepDefinition,\n} from './types.js';\nimport { executeFlow, type RegisteredStep } from './executor.js';\n\n/**\n * Compute the result type of a parallel group from its branches map.\n * For a branches object `{ a: { run: () => A }, b: { run: () => B } }`\n * the inferred type is `{ a: A; b: B }`. Promise return types are unwrapped\n * to match the final `ctx.results.<group>.<branch>` value.\n */\ntype Awaited2<T> = T extends Promise<infer U> ? U : T;\ntype ParallelBranchResults<TBranches> = {\n  [K in keyof TBranches]: TBranches[K] extends { run: (...args: never[]) => infer R }\n    ? Awaited2<R>\n    : never;\n};\n\n/**\n * A Flow is a typed, ordered list of steps. The result type accumulates as\n * steps are added, so each subsequent step's `ctx.results` is statically\n * typed with every prior step's return value.\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport type EmptyResults = {};\n\nexport class Flow<TInput, TResults extends object = EmptyResults> {\n  private readonly _steps: RegisteredStep[] = [];\n\n  constructor(\n    public readonly name: string,\n    public readonly config: FlowConfig = {},\n  ) {}\n\n  /**\n   * Append a step. The step's return value is accumulated into TResults so\n   * every downstream step's `ctx.results.<name>` is statically typed.\n   *\n   * Duplicate step names are rejected at runtime (Flow.step will throw).\n   */\n  step<TName extends string, TResult>(\n    name: TName,\n    definition: StepDefinition<TInput, TResults, TResult>,\n  ): Flow<TInput, TResults & { [K in TName]: TResult }> {\n    if (this._steps.some((s) => s.name === name)) {\n      throw new Error(`kompensa: duplicate step name \"${String(name)}\" in flow \"${this.name}\"`);\n    }\n    this._steps.push({\n      name: name,\n      definition: definition as unknown as RegisteredStep['definition'],\n    });\n    return this as unknown as Flow<TInput, TResults & { [K in TName]: TResult }>;\n  }\n\n  /**\n   * Append a parallel step group (fan-out / fan-in). Each branch runs\n   * concurrently via `Promise.all`. Results merge into a single object keyed\n   * by branch name and become available downstream as\n   * `ctx.results.<groupName>.<branchName>`, fully typed.\n   *\n   * Behavior:\n   * - Branches run concurrently. By default, the first failing branch aborts\n   *   its siblings via a shared `AbortSignal` (`abortOnFailure: true`).\n   * - Compensation runs in parallel by default. Pass\n   *   `{ compensateSerially: true }` when there is a causal dependency\n   *   between branches that requires reverse-order rollback.\n   * - Per-branch `retry`, `timeout`, and `compensate` work exactly like a\n   *   regular step. A group-level `groupTimeout` bounds the entire group.\n   * - Crash recovery resumes only branches that did not finish — already\n   *   `success` branches are skipped, just like sequential steps.\n   *\n   * @example\n   * createFlow<{ orderId: string }>('checkout')\n   *   .parallel('externals', {\n   *     pricing:  { run: (ctx) => api.pricing(ctx.input.orderId) },\n   *     shipping: { run: (ctx) => api.shipping(ctx.input.orderId) },\n   *     tax:      { run: (ctx) => api.tax(ctx.input.orderId), retry: { maxAttempts: 3 } },\n   *   })\n   *   .step('charge', {\n   *     run: (ctx) => charge(ctx.results.externals.pricing.amount),\n   *   })\n   */\n  parallel<\n    TName extends string,\n    TBranches extends Record<string, ParallelBranchDefinition<TInput, TResults, unknown>>,\n  >(\n    name: TName,\n    branches: TBranches,\n    options: ParallelGroupOptions = {},\n  ): Flow<TInput, TResults & { [K in TName]: ParallelBranchResults<TBranches> }> {\n    if (this._steps.some((s) => s.name === name)) {\n      throw new Error(`kompensa: duplicate step name \"${String(name)}\" in flow \"${this.name}\"`);\n    }\n    const branchNames = Object.keys(branches);\n    if (branchNames.length === 0) {\n      throw new Error(\n        `kompensa: parallel group \"${String(name)}\" in flow \"${this.name}\" has no branches`,\n      );\n    }\n    for (const bn of branchNames) {\n      if (!bn || typeof bn !== 'string') {\n        throw new Error(\n          `kompensa: parallel group \"${String(name)}\" has an invalid branch name`,\n        );\n      }\n    }\n\n    // Sentinel definition so the executor never accidentally runs a parallel\n    // group via the sequential code path. The real dispatch lives in the\n    // executor's parallel branch (added in v0.3 executor work). If this stub\n    // ever fires, it means the executor mis-routed — fail loudly.\n    const stubDefinition: StepDefinition<unknown, Record<string, unknown>, unknown> = {\n      run: () => {\n        throw new Error(\n          `kompensa: internal error — parallel group \"${String(name)}\" was routed through the sequential executor`,\n        );\n      },\n    };\n\n    this._steps.push({\n      name,\n      kind: 'parallel',\n      definition: stubDefinition,\n      branches: branches as unknown as RegisteredStep['branches'],\n      parallelOptions: options,\n    });\n\n    return this as unknown as Flow<\n      TInput,\n      TResults & { [K in TName]: ParallelBranchResults<TBranches> }\n    >;\n  }\n\n  /** Expose the registered step list for inspection (read-only copy). */\n  get steps(): ReadonlyArray<{ name: string; kind: 'sequential' | 'parallel'; branches?: string[] }> {\n    return this._steps.map((s) => ({\n      name: s.name,\n      kind: (s.kind ?? 'sequential') as 'sequential' | 'parallel',\n      ...(s.branches ? { branches: Object.keys(s.branches) } : {}),\n    }));\n  }\n\n  /**\n   * Run the flow. Re-running with the same `idempotencyKey` returns the\n   * previously-cached result (if succeeded) or resumes from the last\n   * successful step (if the prior run was interrupted).\n   */\n  async execute(input: TInput, options: ExecuteOptions = {}): Promise<TResults> {\n    if (this._steps.length === 0) {\n      throw new Error(`kompensa: flow \"${this.name}\" has no steps`);\n    }\n    return executeFlow<TInput, TResults>({\n      flowName: this.name,\n      steps: this._steps,\n      input,\n      config: this.config,\n      options,\n    });\n  }\n}\n\n/**\n * Create a new flow. Generic parameter defines the input shape; step results\n * are inferred from `.step()` calls.\n *\n * @example\n * const checkout = createFlow<{ orderId: string }>('checkout')\n *   .step('reserve', { run: async (c) => reserve(c.input.orderId), compensate: release })\n *   .step('charge',  { run: async (c) => charge(c.input.orderId),  compensate: refund  })\n *\n * await checkout.execute({ orderId: '42' }, { idempotencyKey: 'order-42' })\n */\nexport function createFlow<TInput = unknown>(\n  name: string,\n  config: FlowConfig = {},\n): Flow<TInput, EmptyResults> {\n  if (!name || typeof name !== 'string') {\n    throw new Error('kompensa: flow name must be a non-empty string');\n  }\n  return new Flow<TInput, EmptyResults>(name, config);\n}\n"]}