awaitly 2.0.0 → 3.0.0

package/dist/run.js

@@ -0,0 +1,2247 @@
+// src/slugs.ts
+var AWAITLY_SLUGS = {
+  // --- step-* ---
+  "step-require-id": "step-require-id",
+  "step-no-immediate-execution": "step-no-immediate-execution",
+  "step-require-thunk-for-key": "step-require-thunk-for-key",
+  "step-no-bare-await": "step-no-bare-await",
+  "step-no-try-catch-wrap": "step-no-try-catch-wrap",
+  "step-stable-cache-keys": "step-stable-cache-keys",
+  // --- workflow-* ---
+  "workflow-no-floating": "workflow-no-floating",
+  "workflow-options-position": "workflow-options-position",
+  "workflow-callback-shape": "workflow-callback-shape",
+  "workflow-no-callable-form": "workflow-no-callable-form",
+  "workflow-no-dynamic-import": "workflow-no-dynamic-import",
+  "workflow-prefer-step-if": "workflow-prefer-step-if",
+  "workflow-prefer-step-foreach": "workflow-prefer-step-foreach",
+  // --- result-* ---
+  "result-no-floating": "result-no-floating",
+  "result-require-handling": "result-require-handling",
+  "result-no-double-wrap": "result-no-double-wrap",
+  "result-no-manual-propagation": "result-no-manual-propagation",
+  "result-no-direct-ok-err": "result-no-direct-ok-err",
+  // --- error-* ---
+  "error-check-unexpected-first": "error-check-unexpected-first",
+  "error-access-cause": "error-access-cause",
+  "error-normalize": "error-normalize",
+  "error-no-throw-in-deps": "error-no-throw-in-deps",
+  // --- concurrency-* ---
+  "concurrency-no-promise-all": "concurrency-no-promise-all",
+  "concurrency-no-promise-race": "concurrency-no-promise-race",
+  "concurrency-no-promise-allsettled": "concurrency-no-promise-allsettled",
+  // --- runtime-* ---
+  "runtime-step-timeout": "runtime-step-timeout",
+  "runtime-step-aborted": "runtime-step-aborted",
+  "runtime-retry-exhausted": "runtime-retry-exhausted",
+  "runtime-rate-limit": "runtime-rate-limit",
+  "runtime-circuit-open": "runtime-circuit-open",
+  "runtime-unexpected": "runtime-unexpected",
+  "runtime-resolver-not-found": "runtime-resolver-not-found",
+  "runtime-saga-compensation": "runtime-saga-compensation"
+};
+function slugDocsUrl(slug) {
+  return `https://jagreehal.github.io/awaitly/rules/#${slug}`;
+}
+var ALL_SLUGS = Object.keys(
+  AWAITLY_SLUGS
+);
+
+// src/tagged-error.ts
+var InternalTaggedErrorBase = class extends Error {
+  type;
+  /** @deprecated Use `type`. */
+  _tag;
+};
+function TaggedError(tag, options) {
+  return class extends InternalTaggedErrorBase {
+    type = tag;
+    /** @deprecated Use `type`. */
+    _tag = tag;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(props, errorOptions) {
+      const message = options?.message ? options.message(props ?? {}) : tag;
+      super(message);
+      this.name = tag;
+      if (options?.slug !== void 0) {
+        if (!options.hint) {
+          throw new TypeError(
+            `TaggedError: 'hint' is required when 'slug' is set (slug: "${options.slug}")`
+          );
+        }
+        Object.defineProperty(this, "code", {
+          value: options.slug,
+          enumerable: true,
+          writable: false,
+          configurable: false
+        });
+        Object.defineProperty(this, "hint", {
+          value: options.hint,
+          enumerable: true,
+          writable: false,
+          configurable: false
+        });
+        Object.defineProperty(this, "docsUrl", {
+          value: slugDocsUrl(options.slug),
+          enumerable: true,
+          writable: false,
+          configurable: false
+        });
+      }
+      Object.setPrototypeOf(this, new.target.prototype);
+      if (props && typeof props === "object") {
+        let safeProps;
+        if (options?.slug !== void 0) {
+          const {
+            _tag: _,
+            type: _t,
+            name: _n,
+            message: _m,
+            stack: _s,
+            code: _c,
+            hint: _h,
+            docsUrl: _d,
+            ...rest
+          } = props;
+          safeProps = rest;
+        } else {
+          const {
+            _tag: _,
+            type: _t,
+            name: _n,
+            message: _m,
+            stack: _s,
+            ...rest
+          } = props;
+          safeProps = rest;
+        }
+        const hasUserCause = Object.prototype.hasOwnProperty.call(
+          safeProps,
+          "cause"
+        );
+        const userCause = hasUserCause ? safeProps.cause : void 0;
+        if (hasUserCause) {
+          delete safeProps.cause;
+        }
+        const hasOptionsCause = errorOptions?.cause !== void 0;
+        if (hasUserCause && hasOptionsCause) {
+          throw new TypeError(
+            "TaggedError: cannot provide 'cause' in props when also setting ErrorOptions.cause"
+          );
+        }
+        Object.assign(this, safeProps);
+        if (hasUserCause) {
+          this.cause = userCause;
+        }
+        if (hasOptionsCause) {
+          this.cause = errorOptions?.cause;
+        }
+      } else if (errorOptions?.cause !== void 0) {
+        this.cause = errorOptions.cause;
+      }
+    }
+  };
+}
+Object.defineProperty(TaggedError, Symbol.hasInstance, {
+  value: (instance) => instance instanceof InternalTaggedErrorBase
+});
+((TaggedError2) => {
+  function isError(value) {
+    return value instanceof Error;
+  }
+  TaggedError2.isError = isError;
+  function isTaggedError(value) {
+    return value instanceof InternalTaggedErrorBase;
+  }
+  TaggedError2.isTaggedError = isTaggedError;
+  function match(error, handlers) {
+    const tag = error._tag;
+    const handler = handlers[tag];
+    return handler(
+      error
+    );
+  }
+  TaggedError2.match = match;
+  function matchPartial(error, handlers, otherwise) {
+    const tag = error._tag;
+    const handler = handlers[tag];
+    if (handler) {
+      return handler(
+        error
+      );
+    }
+    return otherwise(error);
+  }
+  TaggedError2.matchPartial = matchPartial;
+})(TaggedError || (TaggedError = {}));
+
+// src/errors.ts
+var TimeoutError = class extends (/* @__PURE__ */ TaggedError("TimeoutError", {
+  slug: "runtime-step-timeout",
+  hint: "Increase the step's timeout option, or check why the upstream operation is slow.",
+  message: (p) => p.operation ? `TimeoutError: ${p.operation} timed out after ${p.ms}ms` : `TimeoutError: Operation timed out after ${p.ms}ms`
+})) {
+};
+var UnexpectedError = class extends (/* @__PURE__ */ TaggedError("UnexpectedError", {
+  slug: "runtime-unexpected",
+  hint: "An unexpected exception escaped a step. Inspect cause; consider returning a typed Result instead of throwing.",
+  message: (p) => `UnexpectedError: ${p.cause instanceof Error ? p.cause.message : String(p.cause ?? "unknown")}`
+})) {
+};
+
+// src/result/index.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error, options) {
+  const cause = options?.cause;
+  return { ok: false, error, ...cause !== void 0 ? { cause } : {} };
+}
+
+// src/core/bound-steps.ts
+var isDepResultShaped = (value) => typeof value === "object" && value !== null && "ok" in value && typeof value.ok === "boolean" && (value.ok ? "value" in value : "error" in value);
+var bindSteps = (deps, step) => {
+  const steps = {};
+  const invocationCounts = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(deps)) {
+    const dep = deps[key];
+    if (typeof dep !== "function") continue;
+    steps[key] = (...args) => {
+      const count = (invocationCounts.get(key) ?? 0) + 1;
+      invocationCounts.set(key, count);
+      const stepKey = count === 1 ? key : `${key}#${count}`;
+      return step(stepKey, async () => {
+        const value = await dep(...args);
+        return isDepResultShaped(value) ? value : ok(value);
+      });
+    };
+  }
+  return steps;
+};
+
+// src/duration.ts
+function toMillis(duration) {
+  return duration.millis;
+}
+
+// src/core/policies.ts
+var toMs = (d) => typeof d === "number" ? d : toMillis(d);
+var attemptCall = async (fn, args) => {
+  try {
+    const value = await fn(...args);
+    if (isDepResultShaped(value)) {
+      return value.ok ? { kind: "ok", value: value.value } : { kind: "err", error: value.error, result: value };
+    }
+    return { kind: "ok", value };
+  } catch (thrown) {
+    return { kind: "threw", thrown };
+  }
+};
+var named = (wrapped, source) => {
+  const name = source.name;
+  if (name) {
+    Object.defineProperty(wrapped, "name", { value: name, configurable: true });
+  }
+  return wrapped;
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function retry(fn, options) {
+  const attempts = Math.max(1, Math.trunc(options.attempts));
+  const baseDelay = options.delay === void 0 ? 0 : toMs(options.delay);
+  const maxDelay = options.maxDelay === void 0 ? Infinity : toMs(options.maxDelay);
+  const backoff = options.backoff ?? "fixed";
+  const delayFor = (attempt) => {
+    const raw = backoff === "exponential" ? baseDelay * 2 ** (attempt - 1) : backoff === "linear" ? baseDelay * attempt : baseDelay;
+    return Math.min(raw, maxDelay);
+  };
+  const wrapped = async (...args) => {
+    let last = { kind: "threw", thrown: void 0 };
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      last = await attemptCall(fn, args);
+      if (last.kind === "ok") return ok(last.value);
+      const failure = last.kind === "err" ? last.error : last.thrown;
+      if (options.retryIf && !options.retryIf(failure)) break;
+      if (attempt < attempts) {
+        options.onRetry?.({ attempt, failure });
+        const ms = delayFor(attempt);
+        if (ms > 0) await sleep(ms);
+      }
+    }
+    if (last.kind === "err") return last.result;
+    throw last.thrown;
+  };
+  return named(wrapped, fn);
+}
+function timeout(fn, after) {
+  const ms = toMs(after);
+  const TIMED_OUT = /* @__PURE__ */ Symbol("timed-out");
+  const wrapped = async (...args) => {
+    let timer;
+    try {
+      const outcome = await Promise.race([
+        attemptCall(fn, args),
+        new Promise((resolve) => {
+          timer = setTimeout(() => resolve(TIMED_OUT), ms);
+        })
+      ]);
+      if (outcome === TIMED_OUT) {
+        return err(new TimeoutError({ operation: fn.name || void 0, ms }));
+      }
+      if (outcome.kind === "ok") return ok(outcome.value);
+      if (outcome.kind === "err") return outcome.result;
+      throw outcome.thrown;
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  };
+  return named(wrapped, fn);
+}
+function fallback(fn, onFailure) {
+  const wrapped = async (...args) => {
+    const outcome = await attemptCall(fn, args);
+    if (outcome.kind === "ok") return ok(outcome.value);
+    const failure = outcome.kind === "err" ? outcome.error : new UnexpectedError({ cause: outcome.thrown });
+    const recovered = await attemptCall(onFailure, [failure, ...args]);
+    if (recovered.kind === "ok") return ok(recovered.value);
+    if (recovered.kind === "err") return recovered.result;
+    throw recovered.thrown;
+  };
+  return named(wrapped, fn);
+}
+
+// src/core/index.ts
+function parseDurationString(input) {
+  const match = input.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i);
+  if (!match) return void 0;
+  const value = parseFloat(match[1]);
+  const unit = match[2].toLowerCase();
+  const multipliers = { ms: 1, s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+  return { _tag: "Duration", millis: value * (multipliers[unit] ?? 1) };
+}
+function defaultCatchUnexpected(cause) {
+  return new UnexpectedError({ cause });
+}
+function ok2(value) {
+  return { ok: true, value };
+}
+function err2(error, options) {
+  const cause = options?.cause;
+  return { ok: false, error, ...cause !== void 0 ? { cause } : {} };
+}
+function extractErrorTag(error) {
+  if (error == null) return "unknown";
+  if (typeof error === "string") return error.trim() || "unknown";
+  if (typeof error === "object") {
+    const tagged = error;
+    if (typeof tagged._tag === "string") {
+      const trimmed = tagged._tag.trim();
+      if (trimmed) return trimmed;
+    }
+    if (typeof tagged.tag === "string") {
+      const trimmed = tagged.tag.trim();
+      if (trimmed) return trimmed;
+    }
+    if (typeof tagged.code === "string") {
+      const trimmed = tagged.code.trim();
+      if (trimmed) return trimmed;
+    } else if (typeof tagged.code === "number") {
+      return String(tagged.code);
+    }
+    if (error instanceof Error && error.name) {
+      const trimmed = error.name.trim();
+      if (trimmed) return trimmed;
+    }
+  }
+  return "unknown";
+}
+function lookupErrorClassification(tag, errorMeta) {
+  if (!errorMeta || !tag) return void 0;
+  return errorMeta[tag];
+}
+function extractStepMetadata(options) {
+  const { intent, domain, owner, tags, stateChanges, emits, calls } = options;
+  if (!intent && !domain && !owner && !tags?.length && !stateChanges?.length && !emits?.length && !calls?.length) {
+    return void 0;
+  }
+  const metadata = {};
+  if (intent) metadata.intent = intent;
+  if (domain) metadata.domain = domain;
+  if (owner) metadata.owner = owner;
+  if (tags?.length) metadata.tags = tags;
+  if (stateChanges?.length) metadata.stateChanges = stateChanges;
+  if (emits?.length) metadata.emits = emits;
+  if (calls?.length) metadata.calls = calls;
+  return metadata;
+}
+function buildStepErrorPayload(error, errorMeta, origin, attempt, cumulativeDurationMs) {
+  const tag = extractErrorTag(error);
+  const classification = lookupErrorClassification(tag, errorMeta);
+  const diagnostics = { tag, origin };
+  if (classification !== void 0) diagnostics.classification = classification;
+  if (attempt !== void 0) diagnostics.attempt = attempt;
+  if (cumulativeDurationMs !== void 0) diagnostics.cumulativeDurationMs = cumulativeDurationMs;
+  return diagnostics;
+}
+var STEP_TIMEOUT_MARKER = /* @__PURE__ */ Symbol.for("step_timeout_marker");
+function isStepTimeoutError(e) {
+  if (typeof e !== "object" || e === null) {
+    return false;
+  }
+  if (e.type === "STEP_TIMEOUT") {
+    return true;
+  }
+  return STEP_TIMEOUT_MARKER in e;
+}
+function getStepTimeoutMeta(e) {
+  if (typeof e !== "object" || e === null) {
+    return void 0;
+  }
+  if (e.type === "STEP_TIMEOUT") {
+    const err3 = e;
+    return {
+      timeoutMs: err3.timeoutMs,
+      stepName: err3.stepName,
+      stepKey: err3.stepKey,
+      attempt: err3.attempt
+    };
+  }
+  if (STEP_TIMEOUT_MARKER in e) {
+    return e[STEP_TIMEOUT_MARKER];
+  }
+  return void 0;
+}
+var EARLY_EXIT_SYMBOL = /* @__PURE__ */ Symbol("early-exit");
+function createEarlyExit(error, meta) {
+  return {
+    [EARLY_EXIT_SYMBOL]: true,
+    error,
+    meta
+  };
+}
+function isEarlyExit(e) {
+  return typeof e === "object" && e !== null && e[EARLY_EXIT_SYMBOL] === true;
+}
+var MAPPER_EXCEPTION_SYMBOL = /* @__PURE__ */ Symbol("mapper-exception");
+function createMapperException(thrown) {
+  return { [MAPPER_EXCEPTION_SYMBOL]: true, thrown };
+}
+function isMapperException(e) {
+  return typeof e === "object" && e !== null && e[MAPPER_EXCEPTION_SYMBOL] === true;
+}
+function calculateRetryDelay(attempt, options) {
+  const { backoff, initialDelay, maxDelay, jitter } = options;
+  let delay;
+  switch (backoff) {
+    case "fixed":
+      delay = initialDelay;
+      break;
+    case "linear":
+      delay = initialDelay * attempt;
+      break;
+    case "exponential":
+      delay = initialDelay * Math.pow(2, attempt - 1);
+      break;
+  }
+  delay = Math.min(delay, maxDelay);
+  if (jitter) {
+    const jitterAmount = delay * 0.25 * Math.random();
+    delay = delay + jitterAmount;
+  }
+  return Math.floor(delay);
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var TIMEOUT_SYMBOL = /* @__PURE__ */ Symbol("timeout");
+var TIMEOUT_OPTION_SYMBOL = /* @__PURE__ */ Symbol("timeout-option");
+function isTimeoutOptionMarker(value) {
+  return typeof value === "object" && value !== null && value[TIMEOUT_OPTION_SYMBOL] === true;
+}
+async function executeWithTimeout(operation, options, stepInfo, externalSignal) {
+  const controller = new AbortController();
+  const behavior = options.onTimeout ?? "error";
+  const createTimeoutError = () => {
+    if (typeof behavior === "function") {
+      return behavior({
+        name: stepInfo.name,
+        key: stepInfo.key,
+        ms: options.ms
+      });
+    }
+    return options.error ?? {
+      type: "STEP_TIMEOUT",
+      stepName: stepInfo.name,
+      stepKey: stepInfo.key,
+      timeoutMs: options.ms,
+      attempt: stepInfo.attempt
+    };
+  };
+  let timeoutId;
+  if (externalSignal?.aborted) {
+    controller.abort(externalSignal.reason);
+  }
+  let externalAbortHandler;
+  if (externalSignal && !externalSignal.aborted) {
+    externalAbortHandler = () => controller.abort(externalSignal.reason);
+    externalSignal.addEventListener("abort", externalAbortHandler, { once: true });
+  }
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      if (behavior !== "disconnect") {
+        controller.abort();
+      }
+      if (behavior === "option") {
+        reject({ [TIMEOUT_OPTION_SYMBOL]: true, ms: options.ms });
+        return;
+      }
+      reject({ [TIMEOUT_SYMBOL]: true, error: createTimeoutError() });
+    }, options.ms);
+  });
+  let operationPromise;
+  if (options.signal) {
+    operationPromise = Promise.resolve(
+      operation(controller.signal)
+    );
+  } else {
+    operationPromise = Promise.resolve(operation());
+  }
+  try {
+    const result = await Promise.race([operationPromise, timeoutPromise]);
+    return result;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && error[TIMEOUT_OPTION_SYMBOL] === true) {
+      throw { [TIMEOUT_OPTION_SYMBOL]: true, ms: options.ms };
+    }
+    if (typeof error === "object" && error !== null && error[TIMEOUT_SYMBOL] === true) {
+      if (behavior === "disconnect") {
+        operationPromise.catch(() => {
+        });
+      }
+      const errorToThrow = error.error;
+      if (typeof errorToThrow === "object" && errorToThrow !== null && errorToThrow.type !== "STEP_TIMEOUT") {
+        const meta = {
+          timeoutMs: options.ms,
+          stepName: stepInfo.name,
+          stepKey: stepInfo.key,
+          attempt: stepInfo.attempt
+        };
+        if (STEP_TIMEOUT_MARKER in errorToThrow) {
+          errorToThrow[STEP_TIMEOUT_MARKER] = meta;
+        } else {
+          Object.defineProperty(errorToThrow, STEP_TIMEOUT_MARKER, {
+            value: meta,
+            enumerable: false,
+            writable: true,
+            configurable: false
+          });
+        }
+      }
+      throw errorToThrow;
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
+    if (externalAbortHandler && externalSignal) {
+      externalSignal.removeEventListener("abort", externalAbortHandler);
+    }
+  }
+}
+var DEFAULT_RETRY_CONFIG = {
+  backoff: "exponential",
+  initialDelay: 100,
+  maxDelay: 3e4,
+  jitter: true,
+  shouldRetry: () => true,
+  onRetry: () => {
+  }
+};
+async function runFn(fnOrDeps, optionsOrFn, maybeOptions) {
+  if (typeof fnOrDeps !== "function") {
+    const deps = fnOrDeps;
+    const boundFn = optionsOrFn;
+    if (typeof boundFn !== "function") {
+      throw new TypeError(
+        "[awaitly] run(deps, fn) requires a callback as the second argument. Example: run({ getUser }, async (s) => s.getUser(id))"
+      );
+    }
+    const classicRun = runFn;
+    return classicRun(
+      ({ step }) => boundFn(bindSteps(deps, step), { step }),
+      maybeOptions
+    );
+  }
+  const fn = fnOrDeps;
+  const options = optionsOrFn;
+  const {
+    onError,
+    onEvent,
+    catchUnexpected,
+    workflowId: providedWorkflowId,
+    workflowName,
+    context,
+    graph,
+    _workflowSignal
+  } = options && typeof options === "object" ? options : {};
+  const workflowId = providedWorkflowId ?? crypto.randomUUID();
+  const declaredIds = graph ? new Set(
+    Array.isArray(graph) ? graph : graph.states.map((state) => state.semanticId ?? state.id)
+  ) : void 0;
+  const declaredPatterns = declaredIds ? [...declaredIds].filter((id) => id.includes("{")).map(
+    (id) => new RegExp(
+      `^${id.replaceAll(/[.*+?^$()[\]\\|]/g, String.raw`\$&`).replaceAll(/\{[^}]*\}/g, ".+")}$`
+    )
+  ) : void 0;
+  const assertDeclared = (id, kind) => {
+    if (!declaredIds || declaredIds.has(id)) return;
+    if (declaredPatterns?.some((re) => re.test(id))) return;
+    throw new Error(
+      `[awaitly] ${kind} id "${id}" is not in the declared workflow graph. Declared ids: ${[...declaredIds].join(", ")}. Either add it to the graph or remove the graph option.`
+    );
+  };
+  const effectiveCatchUnexpected = catchUnexpected ?? defaultCatchUnexpected;
+  const activeScopeStack = [];
+  let stepIdCounter = 0;
+  const generateStepId = (stepKey) => {
+    return stepKey ?? `step_${++stepIdCounter}`;
+  };
+  const emitEvent = (event) => {
+    const eventWithContext = event.context !== void 0 || context === void 0 ? event : { ...event, context };
+    const eventWithName = workflowName !== void 0 && eventWithContext.workflowName === void 0 ? { ...eventWithContext, workflowName } : eventWithContext;
+    if (eventWithName.type === "step_success") {
+      const stepId = eventWithName.stepId;
+      for (let i = activeScopeStack.length - 1; i >= 0; i--) {
+        const scope = activeScopeStack[i];
+        if (scope.type === "race" && !scope.winnerId) {
+          scope.winnerId = stepId;
+          break;
+        }
+      }
+    }
+    onEvent?.(eventWithName, context);
+  };
+  const earlyExit = createEarlyExit;
+  const isEarlyExitE = (e) => isEarlyExit(e);
+  const wrapForStep = (error, _meta) => {
+    return error;
+  };
+  const isResultLike = (value) => {
+    if (typeof value === "function") return false;
+    if (value && typeof value === "object" && "ok" in value) return true;
+    if (value && typeof value === "object" && "then" in value && typeof value.then === "function") return true;
+    return false;
+  };
+  try {
+    let normalizeParallelOperations2 = function(rawOperations) {
+      const out = {};
+      for (const [key, value2] of Object.entries(rawOperations)) {
+        if (typeof value2 === "function") {
+          out[key] = value2;
+        } else if (value2 && typeof value2 === "object" && "fn" in value2) {
+          out[key] = value2.fn;
+        } else {
+          throw new TypeError(`step.all: operation "${key}" must be a function or { fn, errors? } object`);
+        }
+      }
+      return out;
+    }, executeParallelArray2 = function(name, operation) {
+      const scopeId = `scope_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      return (async () => {
+        const startTime = performance.now();
+        let scopeEnded = false;
+        activeScopeStack.push({ scopeId, type: "parallel" });
+        const emitScopeEnd = () => {
+          if (scopeEnded) return;
+          scopeEnded = true;
+          const idx = activeScopeStack.findIndex((s) => s.scopeId === scopeId);
+          if (idx !== -1) activeScopeStack.splice(idx, 1);
+          emitEvent({
+            type: "scope_end",
+            workflowId,
+            scopeId,
+            ts: Date.now(),
+            durationMs: performance.now() - startTime
+          });
+        };
+        emitEvent({
+          type: "scope_start",
+          workflowId,
+          scopeId,
+          scopeType: "parallel",
+          name,
+          ts: Date.now()
+        });
+        try {
+          const result = await operation();
+          emitScopeEnd();
+          if (!result.ok) {
+            onError?.(result.error, name, context);
+            throw earlyExit(result.error, {
+              origin: "result",
+              resultCause: result.cause
+            });
+          }
+          return result.value;
+        } catch (error) {
+          emitScopeEnd();
+          throw error;
+        }
+      })();
+    }, executeParallelNamed2 = function(operations, options2) {
+      const keys = Object.keys(operations);
+      const name = options2.name ?? `Parallel(${keys.join(", ")})`;
+      const scopeId = `scope_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      return (async () => {
+        const startTime = performance.now();
+        let scopeEnded = false;
+        activeScopeStack.push({ scopeId, type: "parallel" });
+        const emitScopeEnd = () => {
+          if (scopeEnded) return;
+          scopeEnded = true;
+          const idx = activeScopeStack.findIndex((s) => s.scopeId === scopeId);
+          if (idx !== -1) activeScopeStack.splice(idx, 1);
+          emitEvent({
+            type: "scope_end",
+            workflowId,
+            scopeId,
+            ts: Date.now(),
+            durationMs: performance.now() - startTime
+          });
+        };
+        emitEvent({
+          type: "scope_start",
+          workflowId,
+          scopeId,
+          scopeType: "parallel",
+          name,
+          ts: Date.now()
+        });
+        try {
+          const results = await new Promise((resolve) => {
+            if (keys.length === 0) {
+              resolve([]);
+              return;
+            }
+            let settled = false;
+            let pendingCount = keys.length;
+            const resultArray = new Array(keys.length);
+            for (let i = 0; i < keys.length; i++) {
+              const key = keys[i];
+              const index = i;
+              Promise.resolve(operations[key]()).catch((reason) => err2(
+                { type: "PROMISE_REJECTED", cause: reason },
+                { cause: { type: "PROMISE_REJECTION", reason } }
+              )).then((result) => {
+                if (settled) return;
+                if (!result.ok) {
+                  settled = true;
+                  resolve([{ key, result }]);
+                  return;
+                }
+                resultArray[index] = { key, result };
+                pendingCount--;
+                if (pendingCount === 0) {
+                  resolve(resultArray);
+                }
+              });
+            }
+          });
+          emitScopeEnd();
+          const output = {};
+          for (const { key, result } of results) {
+            if (!result.ok) {
+              onError?.(result.error, key, context);
+              throw earlyExit(result.error, {
+                origin: "result",
+                resultCause: result.cause
+              });
+            }
+            output[key] = result.value;
+          }
+          return output;
+        } catch (error) {
+          emitScopeEnd();
+          throw error;
+        }
+      })();
+    };
+    var normalizeParallelOperations = normalizeParallelOperations2, executeParallelArray = executeParallelArray2, executeParallelNamed = executeParallelNamed2;
+    const stepFn = (id, operationOrResult, stepOptions) => {
+      return (async () => {
+        if (typeof id !== "string" || id.length === 0) {
+          throw new Error(
+            '[awaitly] step() requires an explicit string ID as the first argument. Example: step("fetchUser", () => fetchUser(id))'
+          );
+        }
+        assertDeclared(id, "step");
+        const parsedOptions = stepOptions ?? {};
+        const stepMetadata = extractStepMetadata(parsedOptions);
+        const stepName = id;
+        const stepKey = parsedOptions.key ?? id;
+        const explicitKey = parsedOptions.key ?? id;
+        const { description: stepDescription, retry: retryConfig, timeout: timeoutConfig } = parsedOptions;
+        const stepId = generateStepId(stepKey);
+        const hasEventListeners = onEvent;
+        const overallStartTime = hasEventListeners ? performance.now() : 0;
+        const isDirectResult = isResultLike(operationOrResult);
+        const operation = isDirectResult ? () => operationOrResult : operationOrResult;
+        const maxAttempts = Math.max(1, retryConfig?.attempts ?? 1);
+        const effectiveRetry = {
+          attempts: maxAttempts,
+          backoff: retryConfig?.backoff ?? DEFAULT_RETRY_CONFIG.backoff,
+          initialDelay: retryConfig?.initialDelay ?? DEFAULT_RETRY_CONFIG.initialDelay,
+          maxDelay: retryConfig?.maxDelay ?? DEFAULT_RETRY_CONFIG.maxDelay,
+          jitter: retryConfig?.jitter ?? DEFAULT_RETRY_CONFIG.jitter,
+          shouldRetry: retryConfig?.shouldRetry ?? DEFAULT_RETRY_CONFIG.shouldRetry,
+          onRetry: retryConfig?.onRetry ?? DEFAULT_RETRY_CONFIG.onRetry
+        };
+        if (onEvent) {
+          emitEvent({
+            type: "step_start",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            description: stepDescription,
+            ts: Date.now(),
+            ...stepMetadata && { metadata: stepMetadata }
+          });
+        }
+        let lastResult;
+        for (let attempt = 1; attempt <= effectiveRetry.attempts; attempt++) {
+          const attemptStartTime = hasEventListeners ? performance.now() : 0;
+          try {
+            let result;
+            if (timeoutConfig) {
+              result = await executeWithTimeout(
+                operation,
+                timeoutConfig,
+                { name: stepName, key: stepKey, attempt },
+                _workflowSignal
+              );
+            } else {
+              result = await operation();
+            }
+            if (result.ok) {
+              const durationMs = performance.now() - overallStartTime;
+              emitEvent({
+                type: "step_success",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                description: stepDescription,
+                ts: Date.now(),
+                durationMs,
+                ...stepMetadata && { metadata: stepMetadata }
+              });
+              if (explicitKey) {
+                emitEvent({
+                  type: "step_complete",
+                  workflowId,
+                  stepKey: explicitKey,
+                  name: stepName,
+                  description: stepDescription,
+                  ts: Date.now(),
+                  durationMs,
+                  result,
+                  ...stepMetadata && { metadata: stepMetadata }
+                });
+              }
+              return result.value;
+            }
+            lastResult = result;
+            if (attempt < effectiveRetry.attempts && effectiveRetry.shouldRetry(result.error, attempt)) {
+              const delay = calculateRetryDelay(attempt, effectiveRetry);
+              emitEvent({
+                type: "step_retry",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                attempt: attempt + 1,
+                maxAttempts: effectiveRetry.attempts,
+                delayMs: delay,
+                error: result.error,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(result.error, parsedOptions.errorMeta, "result", attempt, performance.now() - overallStartTime)
+              });
+              effectiveRetry.onRetry(result.error, attempt, delay);
+              await sleep2(delay);
+              continue;
+            }
+            if (effectiveRetry.attempts > 1) {
+              emitEvent({
+                type: "step_retries_exhausted",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: performance.now() - overallStartTime,
+                attempts: attempt,
+                lastError: result.error,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(result.error, parsedOptions.errorMeta, "result", attempt, performance.now() - overallStartTime)
+              });
+            }
+            break;
+          } catch (thrown) {
+            const durationMs = performance.now() - attemptStartTime;
+            if (isTimeoutOptionMarker(thrown)) {
+              const timeoutMs = thrown.ms;
+              emitEvent({
+                type: "step_timeout",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                timeoutMs,
+                attempt,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "timeout", attempt)
+              });
+              emitEvent({
+                type: "step_success",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                description: stepDescription,
+                ts: Date.now(),
+                durationMs: performance.now() - overallStartTime,
+                ...stepMetadata && { metadata: stepMetadata }
+              });
+              if (explicitKey) {
+                emitEvent({
+                  type: "step_complete",
+                  workflowId,
+                  stepKey: explicitKey,
+                  name: stepName,
+                  description: stepDescription,
+                  ts: Date.now(),
+                  durationMs: performance.now() - overallStartTime,
+                  result: ok2(void 0),
+                  ...stepMetadata && { metadata: stepMetadata }
+                });
+              }
+              return void 0;
+            }
+            if (isEarlyExitE(thrown)) {
+              emitEvent({
+                type: "step_aborted",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                description: stepDescription,
+                ts: Date.now(),
+                durationMs,
+                ...stepMetadata && { metadata: stepMetadata }
+              });
+              throw thrown;
+            }
+            if (isStepTimeoutError(thrown)) {
+              const timeoutMeta = getStepTimeoutMeta(thrown);
+              const timeoutMs = timeoutConfig?.ms ?? timeoutMeta?.timeoutMs ?? 0;
+              emitEvent({
+                type: "step_timeout",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                timeoutMs,
+                attempt,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "timeout", attempt)
+              });
+              if (attempt < effectiveRetry.attempts && effectiveRetry.shouldRetry(thrown, attempt)) {
+                const delay = calculateRetryDelay(attempt, effectiveRetry);
+                emitEvent({
+                  type: "step_retry",
+                  workflowId,
+                  stepId,
+                  stepKey,
+                  name: stepName,
+                  ts: Date.now(),
+                  attempt: attempt + 1,
+                  maxAttempts: effectiveRetry.attempts,
+                  delayMs: delay,
+                  error: thrown,
+                  ...stepMetadata && { metadata: stepMetadata },
+                  diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "timeout", attempt, performance.now() - overallStartTime)
+                });
+                effectiveRetry.onRetry(thrown, attempt, delay);
+                await sleep2(delay);
+                continue;
+              }
+              if (effectiveRetry.attempts > 1) {
+                emitEvent({
+                  type: "step_retries_exhausted",
+                  workflowId,
+                  stepId,
+                  stepKey,
+                  name: stepName,
+                  ts: Date.now(),
+                  durationMs: performance.now() - overallStartTime,
+                  attempts: attempt,
+                  lastError: thrown,
+                  ...stepMetadata && { metadata: stepMetadata },
+                  diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "timeout", attempt, performance.now() - overallStartTime)
+                });
+              }
+              const totalDurationMs3 = performance.now() - overallStartTime;
+              emitEvent({
+                type: "step_error",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                description: stepDescription,
+                ts: Date.now(),
+                durationMs: totalDurationMs3,
+                error: thrown,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "timeout", attempt, totalDurationMs3)
+              });
+              if (explicitKey) {
+                emitEvent({
+                  type: "step_complete",
+                  workflowId,
+                  stepKey: explicitKey,
+                  name: stepName,
+                  description: stepDescription,
+                  ts: Date.now(),
+                  durationMs: totalDurationMs3,
+                  result: err2(thrown, { cause: thrown }),
+                  meta: { origin: "throw", thrown },
+                  ...stepMetadata && { metadata: stepMetadata }
+                });
+              }
+              onError?.(thrown, stepName, context);
+              throw earlyExit(thrown, { origin: "throw", thrown });
+            }
+            if (attempt < effectiveRetry.attempts && effectiveRetry.shouldRetry(thrown, attempt)) {
+              const delay = calculateRetryDelay(attempt, effectiveRetry);
+              emitEvent({
+                type: "step_retry",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                attempt: attempt + 1,
+                maxAttempts: effectiveRetry.attempts,
+                delayMs: delay,
+                error: thrown,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "throw", attempt, performance.now() - overallStartTime)
+              });
+              effectiveRetry.onRetry(thrown, attempt, delay);
+              await sleep2(delay);
+              continue;
+            }
+            if (effectiveRetry.attempts > 1 && !isStepTimeoutError(thrown)) {
+              emitEvent({
+                type: "step_retries_exhausted",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: performance.now() - overallStartTime,
+                attempts: attempt,
+                lastError: thrown,
+                ...stepMetadata && { metadata: stepMetadata },
+                diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "throw", attempt, performance.now() - overallStartTime)
+              });
+            }
+            const totalDurationMs2 = performance.now() - overallStartTime;
+            let mappedError;
+            try {
+              mappedError = effectiveCatchUnexpected(thrown);
+            } catch (mapperError) {
+              throw createMapperException(mapperError);
+            }
+            emitEvent({
+              type: "step_error",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              description: stepDescription,
+              ts: Date.now(),
+              durationMs: totalDurationMs2,
+              error: mappedError,
+              ...stepMetadata && { metadata: stepMetadata },
+              diagnostics: buildStepErrorPayload(thrown, parsedOptions.errorMeta, "throw", attempt, totalDurationMs2)
+            });
+            if (explicitKey) {
+              emitEvent({
+                type: "step_complete",
+                workflowId,
+                stepKey: explicitKey,
+                name: stepName,
+                description: stepDescription,
+                ts: Date.now(),
+                durationMs: totalDurationMs2,
+                result: err2(mappedError, { cause: thrown }),
+                meta: { origin: "throw", thrown },
+                ...stepMetadata && { metadata: stepMetadata }
+              });
+            }
+            onError?.(mappedError, stepName, context);
+            throw earlyExit(mappedError, { origin: "throw", thrown });
+          }
+        }
+        const errorResult = lastResult;
+        const totalDurationMs = performance.now() - overallStartTime;
+        const wrappedError = wrapForStep(errorResult.error, {
+          origin: "result",
+          resultCause: errorResult.cause
+        });
+        emitEvent({
+          type: "step_error",
+          workflowId,
+          stepId,
+          stepKey,
+          name: stepName,
+          description: stepDescription,
+          ts: Date.now(),
+          durationMs: totalDurationMs,
+          error: wrappedError,
+          ...stepMetadata && { metadata: stepMetadata },
+          diagnostics: buildStepErrorPayload(errorResult.error, parsedOptions.errorMeta, "result", effectiveRetry.attempts, totalDurationMs)
+        });
+        if (explicitKey) {
+          emitEvent({
+            type: "step_complete",
+            workflowId,
+            stepKey: explicitKey,
+            name: stepName,
+            description: stepDescription,
+            ts: Date.now(),
+            durationMs: totalDurationMs,
+            result: errorResult,
+            meta: { origin: "result", resultCause: errorResult.cause },
+            ...stepMetadata && { metadata: stepMetadata }
+          });
+        }
+        onError?.(wrappedError, stepName, context);
+        throw earlyExit(wrappedError, {
+          origin: "result",
+          resultCause: errorResult.cause
+        });
+      })();
+    };
+    stepFn.try = (id, operation, opts) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.try() requires an explicit string ID as the first argument. Example: step.try("parse", () => JSON.parse(str), { error: "PARSE_ERROR" })'
+        );
+      }
+      assertDeclared(id, "step");
+      const mapToError = "error" in opts ? () => opts.error : opts.onError;
+      if (opts.retry || opts.timeout) {
+        return stepFn.retry(
+          id,
+          async () => {
+            try {
+              return ok2(await operation());
+            } catch (cause) {
+              return err2(mapToError(cause), { cause });
+            }
+          },
+          {
+            attempts: opts.retry?.attempts ?? 1,
+            ...opts.retry ?? {},
+            key: opts.key,
+            timeout: opts.timeout
+          }
+        );
+      }
+      const stepKey = opts.key ?? id;
+      const stepName = id;
+      const stepId = id;
+      const hasEventListeners = onEvent;
+      return (async () => {
+        const startTime = hasEventListeners ? performance.now() : 0;
+        if (onEvent) {
+          emitEvent({
+            type: "step_start",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now()
+          });
+        }
+        try {
+          const value2 = await operation();
+          const durationMs = performance.now() - startTime;
+          emitEvent({
+            type: "step_success",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs,
+              result: ok2(value2)
+            });
+          }
+          return value2;
+        } catch (error) {
+          const mapped = mapToError(error);
+          const durationMs = performance.now() - startTime;
+          const wrappedError = wrapForStep(mapped, { origin: "throw", thrown: error });
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs,
+            error: wrappedError
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs,
+              result: err2(mapped, { cause: error }),
+              meta: { origin: "throw", thrown: error }
+            });
+          }
+          onError?.(wrappedError, stepName, context);
+          throw earlyExit(wrappedError, { origin: "throw", thrown: error });
+        }
+      })();
+    };
+    stepFn.fromResult = (id, operation, opts) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.fromResult() requires an explicit string ID as the first argument. Example: step.fromResult("callProvider", () => callProvider(input), { onError: (e) => ({ type: "FAILED" }) })'
+        );
+      }
+      assertDeclared(id, "step");
+      const stepKey = opts.key ?? id;
+      const stepName = id;
+      const stepId = id;
+      const mapToError = "error" in opts ? () => opts.error : opts.onError;
+      const hasEventListeners = onEvent;
+      return (async () => {
+        const startTime = hasEventListeners ? performance.now() : 0;
+        if (onEvent) {
+          emitEvent({
+            type: "step_start",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now()
+          });
+        }
+        const result = await operation();
+        if (result.ok) {
+          const durationMs = performance.now() - startTime;
+          emitEvent({
+            type: "step_success",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs,
+              result: ok2(result.value)
+            });
+          }
+          return result.value;
+        } else {
+          const mapped = mapToError(result.error);
+          const durationMs = performance.now() - startTime;
+          const wrappedError = wrapForStep(mapped, {
+            origin: "result",
+            resultCause: result.error
+          });
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs,
+            error: wrappedError
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs,
+              result: err2(mapped, { cause: result.error }),
+              meta: { origin: "result", resultCause: result.error }
+            });
+          }
+          onError?.(wrappedError, stepName, context);
+          throw earlyExit(wrappedError, {
+            origin: "result",
+            resultCause: result.error
+          });
+        }
+      })();
+    };
+    stepFn.fromNullable = (id, operation, onNull, options2) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.fromNullable() requires an explicit string ID as the first argument. Example: step.fromNullable("getUser", () => db.find(id), () => ({ type: "NOT_FOUND" }))'
+        );
+      }
+      return stepFn(
+        id,
+        async () => {
+          const value2 = await operation();
+          return value2 != null ? ok2(value2) : err2(onNull());
+        },
+        options2
+      );
+    };
+    stepFn.retry = (id, operation, options2) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.retry() requires an explicit string ID as the first argument. Example: step.retry("fetchData", () => fetchData(), { attempts: 3 })'
+        );
+      }
+      return stepFn(id, operation, {
+        key: options2.key ?? id,
+        retry: {
+          attempts: options2.attempts,
+          backoff: options2.backoff,
+          initialDelay: options2.initialDelay,
+          maxDelay: options2.maxDelay,
+          jitter: options2.jitter,
+          shouldRetry: options2.shouldRetry,
+          onRetry: options2.onRetry
+        },
+        timeout: options2.timeout
+      });
+    };
+    stepFn.withTimeout = (id, operation, options2) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.withTimeout() requires an explicit string ID as the first argument. Example: step.withTimeout("slowOp", () => slowOp(), { ms: 5000 })'
+        );
+      }
+      return stepFn(
+        id,
+        operation,
+        {
+          key: options2.key ?? id,
+          timeout: options2
+        }
+      );
+    };
+    stepFn.sleep = (id, duration, options2) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.sleep() requires an explicit string ID as the first argument. Example: step.sleep("delay", "5s")'
+        );
+      }
+      const d = typeof duration === "string" ? parseDurationString(duration) : duration;
+      if (!d) {
+        throw new Error(`step.sleep: invalid duration '${duration}'`);
+      }
+      const ms = d.millis;
+      const userSignal = options2?.signal;
+      return stepFn(
+        id,
+        async () => {
+          if (_workflowSignal?.aborted || userSignal?.aborted) {
+            const e = new Error("Sleep aborted");
+            e.name = "AbortError";
+            throw e;
+          }
+          return new Promise((resolve, reject) => {
+            const state = { timeoutId: void 0 };
+            const onAbort = () => {
+              if (state.timeoutId) clearTimeout(state.timeoutId);
+              const e = new Error("Sleep aborted");
+              e.name = "AbortError";
+              reject(e);
+            };
+            _workflowSignal?.addEventListener("abort", onAbort, { once: true });
+            userSignal?.addEventListener("abort", onAbort, { once: true });
+            state.timeoutId = setTimeout(() => {
+              _workflowSignal?.removeEventListener("abort", onAbort);
+              userSignal?.removeEventListener("abort", onAbort);
+              resolve(ok2(void 0));
+            }, ms);
+          });
+        },
+        {
+          key: options2?.key ?? id,
+          description: options2?.description
+        }
+      );
+    };
+    stepFn.all = ((...args) => {
+      if (typeof args[0] !== "string") {
+        throw new TypeError(
+          "step.all(name, ...): first argument must be a string (step name). Example: step.all('Fetch data', { user: () => fetchUser(), posts: () => fetchPosts() })"
+        );
+      }
+      const name = args[0];
+      const second = args[1];
+      if (typeof second === "function") {
+        return executeParallelArray2(name, second);
+      }
+      if (second && typeof second === "object" && !Array.isArray(second)) {
+        const rawOperations = second;
+        const normalizedOperations = normalizeParallelOperations2(rawOperations);
+        return executeParallelNamed2(normalizedOperations, { name });
+      }
+      throw new TypeError(
+        "step.all(name, ...): second argument must be a function (array form) or an object of operations (object form)."
+      );
+    });
+    stepFn.race = (name, operation) => {
+      const scopeId = `scope_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      return (async () => {
+        const startTime = performance.now();
+        let scopeEnded = false;
+        const scopeEntry = { scopeId, type: "race", winnerId: void 0 };
+        activeScopeStack.push(scopeEntry);
+        const emitScopeEnd = () => {
+          if (scopeEnded) return;
+          scopeEnded = true;
+          const idx = activeScopeStack.findIndex((s) => s.scopeId === scopeId);
+          if (idx !== -1) activeScopeStack.splice(idx, 1);
+          emitEvent({
+            type: "scope_end",
+            workflowId,
+            scopeId,
+            ts: Date.now(),
+            durationMs: performance.now() - startTime,
+            winnerId: scopeEntry.winnerId
+          });
+        };
+        emitEvent({
+          type: "scope_start",
+          workflowId,
+          scopeId,
+          scopeType: "race",
+          name,
+          ts: Date.now()
+        });
+        try {
+          const result = await operation();
+          emitScopeEnd();
+          if (!result.ok) {
+            onError?.(result.error, name, context);
+            throw earlyExit(result.error, {
+              origin: "result",
+              resultCause: result.cause
+            });
+          }
+          return result.value;
+        } catch (error) {
+          emitScopeEnd();
+          throw error;
+        }
+      })();
+    };
+    stepFn.if = (id, conditionLabel, condition) => {
+      assertDeclared(id, "decision");
+      const value2 = condition();
+      emitEvent({
+        type: "decision",
+        workflowId,
+        decisionId: id,
+        label: conditionLabel,
+        branch: value2 ? "then" : "else",
+        value: value2,
+        ts: Date.now()
+      });
+      return value2;
+    };
+    stepFn.label = stepFn.if;
+    stepFn.branch = async (id, options2) => {
+      const { condition, then: thenFn, else: elseFn } = options2;
+      assertDeclared(id, "decision");
+      const conditionResult = condition();
+      const branch = conditionResult ? "then" : "else";
+      const startTime = performance.now();
+      emitEvent({
+        type: "decision",
+        workflowId,
+        decisionId: id,
+        label: options2.conditionLabel,
+        branch,
+        value: conditionResult,
+        phase: "start",
+        ts: Date.now()
+      });
+      const emitEnd = () => {
+        emitEvent({
+          type: "decision",
+          workflowId,
+          decisionId: id,
+          label: options2.conditionLabel,
+          branch,
+          value: conditionResult,
+          phase: "end",
+          durationMs: performance.now() - startTime,
+          ts: Date.now()
+        });
+      };
+      try {
+        if (conditionResult) {
+          return await thenFn();
+        } else if (elseFn) {
+          return await elseFn();
+        }
+        return void 0;
+      } finally {
+        emitEnd();
+      }
+    };
+    stepFn.arm = (fn2, errors) => {
+      return { fn: fn2, errors };
+    };
+    stepFn.forEach = async (_id, items, options2) => {
+      const results = [];
+      const maxIterations = options2.maxIterations;
+      let index = 0;
+      const isRunForm = "run" in options2;
+      const asyncItems = Symbol.asyncIterator in items ? items : (async function* () {
+        yield* items;
+      })();
+      for await (const item of asyncItems) {
+        if (maxIterations !== void 0 && index >= maxIterations) {
+          break;
+        }
+        let result;
+        if (isRunForm) {
+          const runOptions = options2;
+          result = await runOptions.run(item, index);
+        } else {
+          const itemOptions = options2;
+          result = await itemOptions.item.handler(item, index, stepFn);
+        }
+        results.push(result);
+        index++;
+      }
+      return results;
+    };
+    stepFn.item = (handler) => {
+      return {
+        __forEachItemHandler: true,
+        handler
+      };
+    };
+    stepFn.dep = (_name, fn2) => {
+      return fn2;
+    };
+    stepFn.workflow = (id, getter, options2) => {
+      return stepFn(id, getter, options2);
+    };
+    stepFn.map = async (id, items, mapper, options2) => {
+      const concurrency = options2?.concurrency ?? items.length;
+      return stepFn(
+        id,
+        () => {
+          if (concurrency >= items.length) {
+            return allAsync(items.map((item, index) => mapper(item, index)));
+          } else {
+            return (async () => {
+              const results = [];
+              for (let i = 0; i < items.length; i += concurrency) {
+                const batch = items.slice(i, i + concurrency);
+                const batchResult = await allAsync(
+                  batch.map((item, batchIndex) => mapper(item, i + batchIndex))
+                );
+                if (!batchResult.ok) {
+                  return batchResult;
+                }
+                results.push(...batchResult.value);
+              }
+              return ok2(results);
+            })();
+          }
+        },
+        { key: options2?.key }
+      );
+    };
+    stepFn.withFallback = (id, operation, options2) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.withFallback() requires an explicit string ID as the first argument. Example: step.withFallback("getUser", () => fetchUser(id), { fallback: () => fetchFromCache(id) })'
+        );
+      }
+      assertDeclared(id, "step");
+      const stepKey = options2.key ?? id;
+      const stepName = id;
+      const stepId = generateStepId(stepKey);
+      const hasEventListeners = onEvent;
+      return (async () => {
+        const startTime = hasEventListeners ? performance.now() : 0;
+        if (onEvent) {
+          emitEvent({
+            type: "step_start",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now()
+          });
+        }
+        let primaryResult;
+        try {
+          primaryResult = await operation();
+        } catch (thrown) {
+          if (isEarlyExitE(thrown)) {
+            emitEvent({
+              type: "step_aborted",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: performance.now() - startTime
+            });
+            throw thrown;
+          }
+          let mappedError;
+          try {
+            mappedError = effectiveCatchUnexpected(thrown);
+          } catch (mapperError) {
+            throw createMapperException(mapperError);
+          }
+          if (options2.on !== void 0 && options2.on !== mappedError) {
+            const durationMs2 = performance.now() - startTime;
+            emitEvent({
+              type: "step_error",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              error: mappedError
+            });
+            if (stepKey) {
+              emitEvent({
+                type: "step_complete",
+                workflowId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: durationMs2,
+                result: err2(mappedError, { cause: thrown }),
+                meta: { origin: "throw", thrown }
+              });
+            }
+            onError?.(mappedError, stepName, context);
+            throw earlyExit(mappedError, { origin: "throw", thrown });
+          }
+          let fallbackResultFromThrow;
+          try {
+            fallbackResultFromThrow = await options2.fallback();
+          } catch (fallbackThrown) {
+            if (isEarlyExitE(fallbackThrown)) {
+              emitEvent({
+                type: "step_aborted",
+                workflowId,
+                stepId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: performance.now() - startTime
+              });
+              throw fallbackThrown;
+            }
+            let fallbackMappedError;
+            try {
+              fallbackMappedError = effectiveCatchUnexpected(fallbackThrown);
+            } catch (mapperError) {
+              throw createMapperException(mapperError);
+            }
+            const durationMs2 = performance.now() - startTime;
+            emitEvent({
+              type: "step_error",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              error: fallbackMappedError
+            });
+            if (stepKey) {
+              emitEvent({
+                type: "step_complete",
+                workflowId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: durationMs2,
+                result: err2(fallbackMappedError, { cause: fallbackThrown }),
+                meta: { origin: "throw", thrown: fallbackThrown }
+              });
+            }
+            onError?.(fallbackMappedError, stepName, context);
+            throw earlyExit(fallbackMappedError, { origin: "throw", thrown: fallbackThrown });
+          }
+          if (fallbackResultFromThrow.ok) {
+            const durationMs2 = performance.now() - startTime;
+            emitEvent({
+              type: "step_success",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2
+            });
+            if (stepKey) {
+              emitEvent({
+                type: "step_complete",
+                workflowId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: durationMs2,
+                result: fallbackResultFromThrow,
+                meta: { origin: "fallback", fallbackUsed: true, fallbackReason: String(mappedError) }
+              });
+            }
+            return fallbackResultFromThrow.value;
+          } else {
+            const durationMs2 = performance.now() - startTime;
+            const wrappedError2 = wrapForStep(fallbackResultFromThrow.error, {
+              origin: "result",
+              resultCause: fallbackResultFromThrow.cause
+            });
+            emitEvent({
+              type: "step_error",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              error: wrappedError2
+            });
+            if (stepKey) {
+              emitEvent({
+                type: "step_complete",
+                workflowId,
+                stepKey,
+                name: stepName,
+                ts: Date.now(),
+                durationMs: durationMs2,
+                result: fallbackResultFromThrow,
+                meta: { origin: "result", resultCause: fallbackResultFromThrow.cause }
+              });
+            }
+            onError?.(wrappedError2, stepName, context);
+            throw earlyExit(wrappedError2, {
+              origin: "result",
+              resultCause: fallbackResultFromThrow.cause
+            });
+          }
+        }
+        if (primaryResult.ok) {
+          const durationMs2 = performance.now() - startTime;
+          emitEvent({
+            type: "step_success",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: primaryResult
+            });
+          }
+          return primaryResult.value;
+        }
+        const primaryError = primaryResult.error;
+        if (options2.on !== void 0 && options2.on !== primaryError) {
+          const durationMs2 = performance.now() - startTime;
+          const wrappedError2 = wrapForStep(primaryError, {
+            origin: "result",
+            resultCause: primaryResult.cause
+          });
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2,
+            error: wrappedError2
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: primaryResult,
+              meta: { origin: "result", resultCause: primaryResult.cause }
+            });
+          }
+          onError?.(wrappedError2, stepName, context);
+          throw earlyExit(wrappedError2, {
+            origin: "result",
+            resultCause: primaryResult.cause
+          });
+        }
+        let fallbackResult;
+        try {
+          fallbackResult = await options2.fallback();
+        } catch (thrown) {
+          if (isEarlyExitE(thrown)) {
+            emitEvent({
+              type: "step_aborted",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: performance.now() - startTime
+            });
+            throw thrown;
+          }
+          let mappedError;
+          try {
+            mappedError = effectiveCatchUnexpected(thrown);
+          } catch (mapperError) {
+            throw createMapperException(mapperError);
+          }
+          const durationMs2 = performance.now() - startTime;
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2,
+            error: mappedError
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: err2(mappedError, { cause: thrown }),
+              meta: { origin: "throw", thrown }
+            });
+          }
+          onError?.(mappedError, stepName, context);
+          throw earlyExit(mappedError, { origin: "throw", thrown });
+        }
+        if (fallbackResult.ok) {
+          const durationMs2 = performance.now() - startTime;
+          emitEvent({
+            type: "step_success",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: fallbackResult,
+              meta: { origin: "fallback", fallbackUsed: true, fallbackReason: String(primaryError) }
+            });
+          }
+          return fallbackResult.value;
+        }
+        const durationMs = performance.now() - startTime;
+        const wrappedError = wrapForStep(fallbackResult.error, {
+          origin: "result",
+          resultCause: fallbackResult.cause
+        });
+        emitEvent({
+          type: "step_error",
+          workflowId,
+          stepId,
+          stepKey,
+          name: stepName,
+          ts: Date.now(),
+          durationMs,
+          error: wrappedError
+        });
+        if (stepKey) {
+          emitEvent({
+            type: "step_complete",
+            workflowId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs,
+            result: fallbackResult,
+            meta: { origin: "result", resultCause: fallbackResult.cause }
+          });
+        }
+        onError?.(wrappedError, stepName, context);
+        throw earlyExit(wrappedError, {
+          origin: "result",
+          resultCause: fallbackResult.cause
+        });
+      })();
+    };
+    stepFn.withResource = (id, options2) => {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new Error(
+          '[awaitly] step.withResource() requires an explicit string ID as the first argument. Example: step.withResource("useDb", { acquire: () => connect(), use: (db) => query(db), release: (db) => db.close() })'
+        );
+      }
+      assertDeclared(id, "step");
+      const stepKey = id;
+      const stepName = id;
+      const stepId = generateStepId(stepKey);
+      const hasEventListeners = onEvent;
+      return (async () => {
+        const startTime = hasEventListeners ? performance.now() : 0;
+        if (onEvent) {
+          emitEvent({
+            type: "step_start",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now()
+          });
+        }
+        let acquireResult;
+        try {
+          acquireResult = await options2.acquire();
+        } catch (thrown) {
+          if (isEarlyExitE(thrown)) {
+            emitEvent({
+              type: "step_aborted",
+              workflowId,
+              stepId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: performance.now() - startTime
+            });
+            throw thrown;
+          }
+          let mappedError;
+          try {
+            mappedError = effectiveCatchUnexpected(thrown);
+          } catch (mapperError) {
+            throw createMapperException(mapperError);
+          }
+          const durationMs2 = performance.now() - startTime;
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2,
+            error: mappedError
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: err2(mappedError, { cause: thrown }),
+              meta: { origin: "throw", thrown }
+            });
+          }
+          onError?.(mappedError, stepName, context);
+          throw earlyExit(mappedError, { origin: "throw", thrown });
+        }
+        if (!acquireResult.ok) {
+          const durationMs2 = performance.now() - startTime;
+          const wrappedError2 = wrapForStep(acquireResult.error, {
+            origin: "result",
+            resultCause: acquireResult.cause
+          });
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2,
+            error: wrappedError2
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: acquireResult,
+              meta: { origin: "result", resultCause: acquireResult.cause }
+            });
+          }
+          onError?.(wrappedError2, stepName, context);
+          throw earlyExit(wrappedError2, {
+            origin: "result",
+            resultCause: acquireResult.cause
+          });
+        }
+        const resource = acquireResult.value;
+        let useResult;
+        let useThrown;
+        let useThrewNonResult = false;
+        try {
+          useResult = await options2.use(resource);
+        } catch (thrown) {
+          if (isEarlyExitE(thrown)) {
+            try {
+              await options2.release(resource);
+            } catch (releaseErr) {
+              console.warn(
+                `[awaitly] step.withResource("${id}"): release threw after earlyExit:`,
+                releaseErr
+              );
+            }
+            throw thrown;
+          }
+          useThrown = thrown;
+          useThrewNonResult = true;
+        }
+        try {
+          await options2.release(resource);
+        } catch (releaseErr) {
+          console.warn(
+            `[awaitly] step.withResource("${id}"): release threw:`,
+            releaseErr
+          );
+        }
+        if (useThrewNonResult) {
+          let mappedError;
+          try {
+            mappedError = effectiveCatchUnexpected(useThrown);
+          } catch (mapperError) {
+            throw createMapperException(mapperError);
+          }
+          const durationMs2 = performance.now() - startTime;
+          emitEvent({
+            type: "step_error",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2,
+            error: mappedError
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result: err2(mappedError, { cause: useThrown }),
+              meta: { origin: "throw", thrown: useThrown }
+            });
+          }
+          onError?.(mappedError, stepName, context);
+          throw earlyExit(mappedError, { origin: "throw", thrown: useThrown });
+        }
+        const result = useResult;
+        if (result.ok) {
+          const durationMs2 = performance.now() - startTime;
+          emitEvent({
+            type: "step_success",
+            workflowId,
+            stepId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs: durationMs2
+          });
+          if (stepKey) {
+            emitEvent({
+              type: "step_complete",
+              workflowId,
+              stepKey,
+              name: stepName,
+              ts: Date.now(),
+              durationMs: durationMs2,
+              result
+            });
+          }
+          return result.value;
+        }
+        const durationMs = performance.now() - startTime;
+        const wrappedError = wrapForStep(result.error, {
+          origin: "result",
+          resultCause: result.cause
+        });
+        emitEvent({
+          type: "step_error",
+          workflowId,
+          stepId,
+          stepKey,
+          name: stepName,
+          ts: Date.now(),
+          durationMs,
+          error: wrappedError
+        });
+        if (stepKey) {
+          emitEvent({
+            type: "step_complete",
+            workflowId,
+            stepKey,
+            name: stepName,
+            ts: Date.now(),
+            durationMs,
+            result,
+            meta: { origin: "result", resultCause: result.cause }
+          });
+        }
+        onError?.(wrappedError, stepName, context);
+        throw earlyExit(wrappedError, {
+          origin: "result",
+          resultCause: result.cause
+        });
+      })();
+    };
+    const step = stepFn;
+    const value = await fn({ step });
+    if (process.env.NODE_ENV !== "production" && value !== null && typeof value === "object" && "ok" in value && typeof value.ok === "boolean") {
+      const maybeResult = value;
+      if (maybeResult.ok === true && "value" in maybeResult || maybeResult.ok === false && "error" in maybeResult) {
+        console.warn(
+          `awaitly: Workflow executor returned a Result-like object. Return raw values, not ok() or err().
+
+  Incorrect: return ok({ data });
+  Correct:   return { data };
+
+See: https://jagreehal.github.io/awaitly/guides/troubleshooting/#returning-ok-from-workflow-executor-double-wrapping`
+        );
+      }
+    }
+    return ok2(value);
+  } catch (error) {
+    if (isMapperException(error)) {
+      throw error.thrown;
+    }
+    if (isEarlyExitE(error)) {
+      const originalCause = error.meta.origin === "throw" ? error.meta.thrown : error.meta.origin === "result" ? error.meta.resultCause : void 0;
+      return err2(error.error, { cause: originalCause });
+    }
+    const mapped = effectiveCatchUnexpected(error);
+    onError?.(mapped, "unexpected", context);
+    return err2(mapped, { cause: error });
+  }
+}
+var runStrict = (fn, options) => {
+  return runFn(fn, options);
+};
+var run = /* @__PURE__ */ Object.assign(runFn, { strict: runStrict });
+async function allAsync(results) {
+  if (results.length === 0) {
+    return ok2([]);
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    let pendingCount = results.length;
+    const values = new Array(results.length);
+    for (let i = 0; i < results.length; i++) {
+      const index = i;
+      Promise.resolve(results[index]).catch((reason) => err2(
+        { type: "PROMISE_REJECTED", cause: reason },
+        { cause: { type: "PROMISE_REJECTION", reason } }
+      )).then((result) => {
+        if (settled) return;
+        if (!result.ok) {
+          settled = true;
+          resolve(result);
+          return;
+        }
+        values[index] = result.value;
+        pendingCount--;
+        if (pendingCount === 0) {
+          resolve(ok2(values));
+        }
+      });
+    }
+  });
+}
+export {
+  EARLY_EXIT_SYMBOL,
+  STEP_TIMEOUT_MARKER,
+  createEarlyExit,
+  fallback,
+  getStepTimeoutMeta,
+  isEarlyExit,
+  isStepTimeoutError,
+  retry,
+  run,
+  timeout
+};
+//# sourceMappingURL=run.js.map