tryharder 0.0.0

package/dist/index.js

@@ -0,0 +1,1223 @@
+import {
+  CancellationError,
+  ControlError,
+  Panic,
+  RetryExhaustedError,
+  TimeoutError,
+  UnhandledException,
+  __callDispose,
+  __using
+} from "./shared/chunk-996eswzx.js";
+
+// src/lib/utils.ts
+function assertUnreachable(value, code) {
+  throw new Panic(code, { message: `Unreachable case: ${String(value)}` });
+}
+function invariant(condition, error) {
+  if (!condition) {
+    throw error;
+  }
+}
+function sleep(ms) {
+  if (ms <= 0) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function checkIsPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+async function resolveWithAbort(signal, promise, createAbortResult) {
+  let __stack = [];
+  try {
+    const disposer = __using(__stack, new DisposableStack, 0);
+    const abortPromise = new Promise((resolve) => {
+      const onAbort = () => {
+        resolve(createAbortResult());
+      };
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+      disposer.defer(() => {
+        signal.removeEventListener("abort", onAbort);
+      });
+    });
+    return await Promise.race([Promise.resolve(promise), abortPromise]);
+  } catch (_catch) {
+    var _err = _catch, _hasErr = 1;
+  } finally {
+    __callDispose(__stack, _err, _hasErr);
+  }
+}
+
+// src/lib/modifiers/retry.ts
+function retryOptions(policy) {
+  const limit = typeof policy === "number" ? policy : policy.limit;
+  invariant(Number.isFinite(limit), new Panic("RETRY_INVALID_LIMIT"));
+  invariant(limit >= 0, new Panic("RETRY_INVALID_LIMIT"));
+  if (typeof policy === "number") {
+    return {
+      backoff: "constant",
+      delayMs: 0,
+      limit: policy
+    };
+  }
+  const base = {
+    delayMs: policy.delayMs ?? 0,
+    jitter: policy.jitter,
+    limit: policy.limit,
+    shouldRetry: policy.shouldRetry
+  };
+  switch (policy.backoff) {
+    case "constant":
+    case "linear":
+      return { ...base, backoff: policy.backoff };
+    case "exponential":
+      return { ...base, backoff: policy.backoff, maxDelayMs: policy.maxDelayMs };
+    default:
+      return assertUnreachable(policy, "UNREACHABLE_RETRY_POLICY_BACKOFF");
+  }
+}
+function calculateRetryDelay(attempt, config) {
+  const policy = config.retry;
+  if (!policy) {
+    return 0;
+  }
+  const baseDelay = policy.delayMs ?? 0;
+  let delay = 0;
+  switch (policy.backoff) {
+    case "constant":
+      delay = baseDelay;
+      break;
+    case "linear":
+      delay = baseDelay * attempt;
+      break;
+    case "exponential":
+      delay = baseDelay * 2 ** (attempt - 1);
+      if (policy.maxDelayMs !== undefined) {
+        delay = Math.min(delay, policy.maxDelayMs);
+      }
+      break;
+  }
+  if (!policy.jitter || delay <= 0) {
+    return delay;
+  }
+  return Math.floor(Math.random() * delay);
+}
+function checkShouldAttemptRetry(error, ctx, config) {
+  const policy = config.retry;
+  if (!policy) {
+    return false;
+  }
+  if (ctx.retry.attempt >= policy.limit) {
+    return false;
+  }
+  if (!policy.shouldRetry) {
+    return true;
+  }
+  return policy.shouldRetry(error, ctx);
+}
+function checkIsRetryExhausted(attempt, config) {
+  return config.retry !== undefined && attempt >= config.retry.limit;
+}
+
+// src/lib/modifiers/signal.ts
+class SignalController {
+  signal;
+  constructor(signals = []) {
+    if (signals.length > 0) {
+      this.signal = AbortSignal.any([...signals]);
+    }
+  }
+  checkDidCancel(cause) {
+    if (!this.signal?.aborted) {
+      return;
+    }
+    if (this.signal.reason instanceof TimeoutError) {
+      return;
+    }
+    return new CancellationError(undefined, { cause: cause ?? this.signal.reason });
+  }
+  async race(promise, cause) {
+    const cancelled = this.checkDidCancel(cause);
+    if (cancelled) {
+      return cancelled;
+    }
+    if (!this.signal) {
+      return promise;
+    }
+    return await resolveWithAbort(this.signal, promise, () => new CancellationError(undefined, { cause: cause ?? this.signal?.reason }));
+  }
+  [Symbol.dispose]() {
+    this.signal;
+  }
+}
+
+// src/lib/modifiers/timeout.ts
+class TimeoutController {
+  signal;
+  #controller;
+  #startedAt = Date.now();
+  #timeoutMs;
+  #timeoutId;
+  constructor(timeoutMs) {
+    this.#timeoutMs = timeoutMs ?? -1;
+    if (timeoutMs === undefined) {
+      return;
+    }
+    invariant(Number.isFinite(timeoutMs), new Panic("TIMEOUT_INVALID_MS"));
+    invariant(timeoutMs >= 0, new Panic("TIMEOUT_INVALID_MS"));
+    this.#controller = new AbortController;
+    this.signal = this.#controller.signal;
+    if (this.#timeoutMs <= 0) {
+      this.#abort();
+      return;
+    }
+    this.#timeoutId = setTimeout(() => {
+      this.#abort();
+    }, this.#timeoutMs);
+  }
+  #abort(cause) {
+    const timeoutError = new TimeoutError(`Execution exceeded timeout of ${this.#timeoutMs}ms`, {
+      cause
+    });
+    if (!this.signal?.aborted) {
+      this.#controller?.abort(timeoutError);
+    }
+    return timeoutError;
+  }
+  get #remaining() {
+    const elapsed = Date.now() - this.#startedAt;
+    return this.#timeoutMs - elapsed;
+  }
+  checkDidTimeout(cause) {
+    if (!this.signal) {
+      return;
+    }
+    if (this.signal.aborted) {
+      const reason = this.signal.reason;
+      if (reason instanceof TimeoutError) {
+        return reason;
+      }
+      return new TimeoutError(`Execution exceeded timeout of ${this.#timeoutMs}ms`, {
+        cause: cause ?? reason
+      });
+    }
+    if (this.#remaining > 0) {
+      return;
+    }
+    return this.#abort(cause);
+  }
+  async race(promise, cause) {
+    if (!this.signal) {
+      return promise;
+    }
+    if (this.#remaining <= 0) {
+      return this.#abort(cause);
+    }
+    const timedOut = this.checkDidTimeout(cause);
+    if (timedOut) {
+      return timedOut;
+    }
+    return await resolveWithAbort(this.signal, promise, () => this.checkDidTimeout(cause) ?? new TimeoutError(`Execution exceeded timeout of ${this.#timeoutMs}ms`, { cause }));
+  }
+  [Symbol.dispose]() {
+    if (this.#timeoutId !== undefined) {
+      clearTimeout(this.#timeoutId);
+    }
+  }
+}
+
+// src/lib/executors/base.ts
+class RetryDirective {
+  decision;
+  constructor(decision) {
+    this.decision = decision;
+  }
+}
+
+class BaseExecution {
+  config;
+  ctx;
+  executionSignal;
+  #wrapCtx;
+  #signalController;
+  #timeoutController;
+  constructor(config, options = {}) {
+    this.config = config;
+    this.#timeoutController = BaseExecution.createTimeoutController(config.timeout);
+    this.#signalController = BaseExecution.createSignalController(config.signals, this.#timeoutController?.signal);
+    this.executionSignal = this.#signalController?.signal;
+    this.ctx = BaseExecution.createContext(config, this.executionSignal, options.retryLimit);
+    this.#wrapCtx = BaseExecution.createWrapContext(this.ctx);
+  }
+  execute() {
+    const wraps = this.config.wraps;
+    if (!wraps || wraps.length === 0) {
+      return this.executeCore();
+    }
+    let next = () => this.executeCore();
+    for (const wrap of wraps.toReversed()) {
+      const previous = next;
+      next = () => wrap(this.#wrapCtx, previous);
+    }
+    return next();
+  }
+  [Symbol.dispose]() {
+    let __stack = [];
+    try {
+      const disposer = __using(__stack, new DisposableStack, 0);
+      if (this.#timeoutController) {
+        disposer.use(this.#timeoutController);
+      }
+      if (this.#signalController) {
+        disposer.use(this.#signalController);
+      }
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      __callDispose(__stack, _err, _hasErr);
+    }
+  }
+  static createContext(config, signal, retryLimit) {
+    return {
+      retry: {
+        attempt: 1,
+        limit: retryLimit ?? config.retry?.limit ?? 1
+      },
+      signal
+    };
+  }
+  static createTimeoutController(timeoutMs) {
+    return timeoutMs === undefined ? undefined : new TimeoutController(timeoutMs);
+  }
+  static createSignalController(signals, timeoutSignal) {
+    const composedSignals = [...signals ?? [], timeoutSignal].filter((value) => value !== undefined);
+    return composedSignals.length > 0 ? new SignalController(composedSignals) : undefined;
+  }
+  static createWrapContext(ctx) {
+    const retry = new Proxy(ctx.retry, {
+      defineProperty: () => false,
+      deleteProperty: () => false,
+      getOwnPropertyDescriptor(target, property) {
+        const descriptor = Reflect.getOwnPropertyDescriptor(target, property);
+        if (!descriptor) {
+          return descriptor;
+        }
+        return {
+          ...descriptor,
+          writable: false
+        };
+      },
+      set: () => false
+    });
+    return new Proxy(ctx, {
+      defineProperty: () => false,
+      deleteProperty: () => false,
+      get(target, property, receiver) {
+        if (property === "retry") {
+          return retry;
+        }
+        return Reflect.get(target, property, receiver);
+      },
+      getOwnPropertyDescriptor(target, property) {
+        const descriptor = Reflect.getOwnPropertyDescriptor(target, property);
+        if (!descriptor) {
+          return descriptor;
+        }
+        if (property === "retry") {
+          return {
+            ...descriptor,
+            value: retry,
+            writable: false
+          };
+        }
+        return {
+          ...descriptor,
+          writable: false
+        };
+      },
+      set: () => false
+    });
+  }
+  checkDidCancel(cause) {
+    return this.#signalController?.checkDidCancel(cause);
+  }
+  raceWithCancellation(promise, cause) {
+    return this.#signalController ? this.#signalController.race(promise, cause) : promise;
+  }
+  checkDidControlFail(cause) {
+    return this.checkDidCancel(cause) ?? this.#timeoutController?.checkDidTimeout(cause);
+  }
+  resolveSyncSuccess(value) {
+    return this.checkDidControlFail() ?? value;
+  }
+  race(promise, cause) {
+    const timeoutController = this.#timeoutController;
+    if (!timeoutController) {
+      return this.raceWithCancellation(promise, cause);
+    }
+    return Promise.resolve(timeoutController.race(this.raceWithCancellation(promise, cause), cause)).then((raced) => {
+      if (raced instanceof TimeoutError) {
+        return this.checkDidCancel(cause) ?? raced;
+      }
+      return raced;
+    });
+  }
+  async waitForRetryDelay(delay) {
+    if (delay <= 0) {
+      return;
+    }
+    const sleepResult = await this.race(sleep(delay));
+    if (sleepResult instanceof CancellationError || sleepResult instanceof TimeoutError) {
+      return sleepResult;
+    }
+    return;
+  }
+  shouldAttemptRetry(error) {
+    return checkShouldAttemptRetry(error, this.ctx, this.config);
+  }
+  retryDelayForCurrentAttempt() {
+    return calculateRetryDelay(this.ctx.retry.attempt, this.config);
+  }
+  checkIsRetryExhaustedCurrentAttempt() {
+    return checkIsRetryExhausted(this.ctx.retry.attempt, this.config);
+  }
+  buildRetryDecision(error) {
+    const shouldAttemptRetry = this.shouldAttemptRetry(error);
+    return {
+      delay: shouldAttemptRetry ? this.retryDelayForCurrentAttempt() : 0,
+      isRetryExhausted: this.checkIsRetryExhaustedCurrentAttempt(),
+      shouldAttemptRetry
+    };
+  }
+}
+
+// src/lib/executors/shared.ts
+class OrchestrationExecution extends BaseExecution {
+  constructor(config) {
+    const unsupportedPolicies = [
+      config.retry === undefined ? undefined : "retry",
+      config.timeout === undefined ? undefined : "timeout"
+    ].filter((value) => value !== undefined);
+    invariant(unsupportedPolicies.length === 0, new Panic("ORCHESTRATION_UNSUPPORTED_POLICY", {
+      message: `Orchestration does not support ${unsupportedPolicies.join(" or ")} policies.`
+    }));
+    super({
+      signals: config.signals,
+      wraps: config.wraps
+    });
+  }
+  async executeCore() {
+    const controlBeforeExecution = this.checkDidControlFail();
+    if (controlBeforeExecution) {
+      throw controlBeforeExecution;
+    }
+    return await this.executeTasks();
+  }
+}
+
+class TaskGraphExecutionBase {
+  tasks;
+  taskNames;
+  results;
+  errors;
+  resolvers;
+  internalController = new AbortController;
+  taskSignal;
+  disposer = new AsyncDisposableStack;
+  firstRejection;
+  constructor(signal, tasks) {
+    this.tasks = tasks;
+    this.taskNames = Object.keys(tasks);
+    this.results = new Map;
+    this.errors = new Map;
+    this.resolvers = new Map;
+    this.taskSignal = signal ? AbortSignal.any([signal, this.internalController.signal]) : this.internalController.signal;
+  }
+  async[Symbol.asyncDispose]() {
+    await this.disposer.disposeAsync();
+  }
+  getTaskHandler(taskName) {
+    const taskFn = this.tasks[taskName];
+    invariant(typeof taskFn === "function", new Panic("TASK_INVALID_HANDLER", {
+      message: `Task "${String(taskName)}" is not a function`
+    }));
+    return taskFn;
+  }
+  createResultProxy(requesterTaskName) {
+    return new Proxy({}, {
+      get: (_, referencedTaskName) => this.waitForResult(referencedTaskName, requesterTaskName)
+    });
+  }
+  waitForResult(taskName, requesterTaskName) {
+    if (requesterTaskName === taskName) {
+      return Promise.reject(new Panic("TASK_SELF_REFERENCE", {
+        message: `Task "${String(taskName)}" cannot await its own result`
+      }));
+    }
+    if (!Object.hasOwn(this.tasks, taskName)) {
+      return Promise.reject(new Panic("TASK_UNKNOWN_REFERENCE", {
+        message: `Unknown task "${String(taskName)}"`
+      }));
+    }
+    if (this.results.has(taskName)) {
+      return Promise.resolve(this.results.get(taskName));
+    }
+    if (this.errors.has(taskName)) {
+      const storedError = this.mapStoredError(this.errors.get(taskName));
+      return Promise.reject(storedError);
+    }
+    return new Promise((resolve, reject) => {
+      const queue = this.resolvers.get(taskName);
+      if (queue) {
+        queue.push([resolve, reject]);
+        return;
+      }
+      this.resolvers.set(taskName, [[resolve, reject]]);
+    });
+  }
+  storeResult(taskName, value) {
+    this.results.set(taskName, value);
+    this.resolveWaiters(taskName, value);
+  }
+  storeError(taskName, error) {
+    const mappedError = this.mapStoredError(error);
+    this.errors.set(taskName, mappedError);
+    this.rejectWaiters(taskName, mappedError);
+  }
+  resolveWaiters(taskName, value) {
+    const fulfilled = this.resolvers.get(taskName);
+    if (fulfilled) {
+      for (const [resolve] of fulfilled) {
+        resolve(value);
+      }
+      this.resolvers.delete(taskName);
+    }
+  }
+  rejectWaiters(taskName, error) {
+    const rejected = this.resolvers.get(taskName);
+    if (rejected) {
+      for (const [, reject] of rejected) {
+        reject(error);
+      }
+      this.resolvers.delete(taskName);
+    }
+  }
+  abortInternal(error) {
+    if (!this.internalController.signal.aborted) {
+      this.internalController.abort(error);
+    }
+  }
+  onTaskResult(_taskName, _value) {
+    this.tasks;
+  }
+  onTaskError(_taskName, _error) {
+    this.tasks;
+  }
+  mapStoredError(error) {
+    this.tasks;
+    return error instanceof Error ? error : new UnhandledException(undefined, { cause: error });
+  }
+  shouldAbortOnTaskError(_error) {
+    this.tasks;
+    return false;
+  }
+  shouldRethrowTaskError(_error) {
+    this.tasks;
+    return true;
+  }
+  setFirstRejection(error) {
+    this.firstRejection ??= error;
+  }
+  async runTask(taskName) {
+    try {
+      const taskFn = this.getTaskHandler(taskName);
+      const resultProxy = this.createResultProxy(taskName);
+      const context = this.createTaskContext(resultProxy);
+      const result = await taskFn.call(context);
+      this.storeResult(taskName, result);
+      this.onTaskResult(taskName, result);
+    } catch (error) {
+      this.setFirstRejection(error);
+      this.storeError(taskName, error);
+      this.onTaskError(taskName, error);
+      if (this.shouldAbortOnTaskError(error)) {
+        this.abortInternal(error);
+      }
+      if (this.shouldRethrowTaskError(error)) {
+        throw error;
+      }
+    }
+  }
+}
+
+class TaskExecution extends TaskGraphExecutionBase {
+  #mode;
+  #returnValue = {};
+  #failedTask;
+  settledPromise;
+  constructor(signal, tasks, mode) {
+    super(signal, tasks);
+    this.#mode = mode;
+  }
+  get failedTask() {
+    return this.#failedTask;
+  }
+  get signal() {
+    return this.taskSignal;
+  }
+  get returnValue() {
+    return this.#returnValue;
+  }
+  async execute() {
+    const promises = this.taskNames.map(async (name) => this.runTask(name));
+    this.settledPromise = Promise.allSettled(promises);
+    if (this.#mode === "settled") {
+      await this.settledPromise;
+      return this.#returnValue;
+    }
+    try {
+      await Promise.all(promises);
+    } catch {
+      throw this.mapStoredError(this.firstRejection);
+    }
+    return this.#returnValue;
+  }
+  async waitForTasksToSettle() {
+    await this.settledPromise;
+  }
+  createTaskContext(resultProxy) {
+    return {
+      $disposer: this.disposer,
+      $result: resultProxy,
+      $signal: this.taskSignal
+    };
+  }
+  onTaskResult(taskName, value) {
+    if (this.#mode === "settled") {
+      this.#returnValue[taskName] = { status: "fulfilled", value };
+    } else {
+      this.#returnValue[taskName] = value;
+    }
+  }
+  onTaskError(taskName, error) {
+    this.#failedTask ??= taskName;
+    if (this.#mode === "settled") {
+      this.#returnValue[taskName] = { reason: error, status: "rejected" };
+    }
+  }
+  shouldAbortOnTaskError() {
+    return this.#mode === "fail-fast";
+  }
+  shouldRethrowTaskError() {
+    return this.#mode === "fail-fast";
+  }
+}
+
+// src/lib/executors/all.ts
+class AllExecution extends OrchestrationExecution {
+  #tasks;
+  #options;
+  constructor(config, tasks, options) {
+    super(config);
+    this.#tasks = tasks;
+    this.#options = options;
+  }
+  async executeTasks() {
+    let __stack = [];
+    try {
+      const execution = __using(__stack, new TaskExecution(this.executionSignal, this.#tasks, "fail-fast"), 1);
+      let result;
+      let threw = false;
+      let thrownError;
+      try {
+        result = await this.raceWithCancellation(execution.execute());
+      } catch (error) {
+        const controlAfterFailure = this.checkDidControlFail(error);
+        const catchFn = this.#options?.catch;
+        if (controlAfterFailure) {
+          threw = true;
+          thrownError = controlAfterFailure;
+        } else if (catchFn) {
+          const context = {
+            failedTask: execution.failedTask,
+            partial: execution.returnValue,
+            signal: execution.signal
+          };
+          try {
+            const mapped = catchFn(error, context);
+            if (checkIsPromiseLike(mapped)) {
+              try {
+                result = await this.raceWithCancellation(Promise.resolve(mapped).catch((catchError) => {
+                  if (catchError instanceof CancellationError) {
+                    throw catchError;
+                  }
+                  throw new Panic("ALL_CATCH_HANDLER_REJECT", { cause: catchError });
+                }), error);
+              } catch (mappedError) {
+                threw = true;
+                thrownError = mappedError;
+              }
+            } else {
+              result = mapped;
+            }
+          } catch (catchError) {
+            threw = true;
+            thrownError = new Panic("ALL_CATCH_HANDLER_THROW", { cause: catchError });
+          }
+        } else {
+          threw = true;
+          thrownError = error;
+        }
+      } finally {
+        await execution.waitForTasksToSettle();
+      }
+      const cancellation = this.checkDidCancel(thrownError);
+      if (cancellation) {
+        throw cancellation;
+      }
+      if (threw) {
+        throw thrownError;
+      }
+      return result;
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      var _promise = __callDispose(__stack, _err, _hasErr);
+      _promise && await _promise;
+    }
+  }
+}
+async function executeAll(config, tasks, options) {
+  let __stack = [];
+  try {
+    const execution = __using(__stack, new AllExecution(config, tasks, options), 0);
+    return await execution.execute();
+  } catch (_catch) {
+    var _err = _catch, _hasErr = 1;
+  } finally {
+    __callDispose(__stack, _err, _hasErr);
+  }
+}
+
+// src/lib/executors/all-settled.ts
+class AllSettledExecution extends OrchestrationExecution {
+  #tasks;
+  constructor(config, tasks) {
+    super(config);
+    this.#tasks = tasks;
+  }
+  async executeTasks() {
+    let __stack = [];
+    try {
+      const execution = __using(__stack, new TaskExecution(this.executionSignal, this.#tasks, "settled"), 1);
+      const result = await this.raceWithCancellation(execution.execute());
+      const cancellation = this.checkDidCancel();
+      if (cancellation) {
+        throw cancellation;
+      }
+      return result;
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      var _promise = __callDispose(__stack, _err, _hasErr);
+      _promise && await _promise;
+    }
+  }
+}
+async function executeAllSettled(config, tasks) {
+  let __stack = [];
+  try {
+    const execution = __using(__stack, new AllSettledExecution(config, tasks), 0);
+    return await execution.execute();
+  } catch (_catch) {
+    var _err = _catch, _hasErr = 1;
+  } finally {
+    __callDispose(__stack, _err, _hasErr);
+  }
+}
+
+// src/lib/executors/flow.ts
+class FlowExitSignal extends Error {
+  value;
+  constructor(value) {
+    super("Flow exited");
+    this.name = "FlowExitSignal";
+    this.value = value;
+  }
+}
+
+class FlowExecution extends TaskGraphExecutionBase {
+  #firstRejectionWaiters = [];
+  #settledPromise;
+  async execute() {
+    const promises = this.taskNames.map(async (name) => this.runTask(name));
+    this.#settledPromise = Promise.allSettled(promises);
+    await Promise.race([this.#settledPromise, this.waitForFirstRejection()]);
+    if (this.firstRejection !== undefined) {
+      if (this.firstRejection instanceof FlowExitSignal) {
+        return this.firstRejection.value;
+      }
+      throw this.firstRejection;
+    }
+    throw new Panic("FLOW_NO_EXIT");
+  }
+  async waitForTasksToSettle() {
+    await this.#settledPromise;
+  }
+  setFirstRejection(error) {
+    const hadFirstRejection = this.firstRejection !== undefined;
+    super.setFirstRejection(error);
+    if (hadFirstRejection || this.firstRejection === undefined) {
+      return;
+    }
+    for (const resolve of this.#firstRejectionWaiters) {
+      resolve();
+    }
+    this.#firstRejectionWaiters = [];
+  }
+  createTaskContext(resultProxy) {
+    return {
+      $disposer: this.disposer,
+      $exit: (value) => {
+        throw new FlowExitSignal(value);
+      },
+      $result: resultProxy,
+      $signal: this.taskSignal
+    };
+  }
+  mapStoredError(error) {
+    if (error instanceof FlowExitSignal) {
+      return error;
+    }
+    return super.mapStoredError(error);
+  }
+  shouldAbortOnTaskError() {
+    this.taskNames;
+    return true;
+  }
+  waitForFirstRejection() {
+    if (this.firstRejection !== undefined) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.#firstRejectionWaiters.push(resolve);
+    });
+  }
+}
+
+class FlowRunnerExecution extends OrchestrationExecution {
+  #tasks;
+  constructor(config, tasks) {
+    super(config);
+    this.#tasks = tasks;
+  }
+  async executeTasks() {
+    let __stack = [];
+    try {
+      const execution = __using(__stack, new FlowExecution(this.executionSignal, this.#tasks), 1);
+      let result;
+      let threw = false;
+      let thrownError;
+      try {
+        result = await this.raceWithCancellation(execution.execute());
+      } catch (error) {
+        threw = true;
+        thrownError = error;
+      } finally {
+        await execution.waitForTasksToSettle();
+      }
+      const cancellation = this.checkDidCancel(thrownError);
+      if (cancellation) {
+        throw cancellation;
+      }
+      if (threw) {
+        throw thrownError;
+      }
+      return result;
+    } catch (_catch) {
+      var _err = _catch, _hasErr = 1;
+    } finally {
+      var _promise = __callDispose(__stack, _err, _hasErr);
+      _promise && await _promise;
+    }
+  }
+}
+async function executeFlow(config, tasks) {
+  let __stack = [];
+  try {
+    const execution = __using(__stack, new FlowRunnerExecution(config, tasks), 0);
+    return await execution.execute();
+  } catch (_catch) {
+    var _err = _catch, _hasErr = 1;
+  } finally {
+    __callDispose(__stack, _err, _hasErr);
+  }
+}
+
+// src/lib/executors/run.ts
+class RunExecution extends BaseExecution {
+  #catchFn;
+  #tryFn;
+  constructor(config, input) {
+    super(config);
+    this.#catchFn = typeof input === "function" ? undefined : input.catch;
+    this.#tryFn = typeof input === "function" ? input : input.try;
+  }
+  executeCore() {
+    return this.#runAttemptLoop(1);
+  }
+  async#resolveFailure(error) {
+    if (error instanceof Panic) {
+      throw error;
+    }
+    if (error instanceof ControlError) {
+      return error;
+    }
+    const controlError = this.checkDidControlFail(error);
+    if (controlError) {
+      return controlError;
+    }
+    const retryDecision = this.buildRetryDecision(error);
+    if (retryDecision.shouldAttemptRetry) {
+      return new RetryDirective(retryDecision);
+    }
+    if (retryDecision.isRetryExhausted) {
+      return new RetryExhaustedError(undefined, { cause: error });
+    }
+    if (!this.#catchFn) {
+      const finalizeControlError = this.checkDidControlFail(error);
+      if (finalizeControlError) {
+        return finalizeControlError;
+      }
+      return new UnhandledException(undefined, { cause: error });
+    }
+    let mapped;
+    try {
+      mapped = this.#catchFn(error);
+    } catch (catchError) {
+      throw new Panic("RUN_CATCH_HANDLER_THROW", { cause: catchError });
+    }
+    if (checkIsPromiseLike(mapped)) {
+      try {
+        return await this.race(mapped, error);
+      } catch (catchError) {
+        throw new Panic("RUN_CATCH_HANDLER_REJECT", { cause: catchError });
+      }
+    }
+    const catchControlError = this.checkDidControlFail(error);
+    if (catchControlError) {
+      return catchControlError;
+    }
+    return mapped;
+  }
+  async#runAttemptLoop(attempt) {
+    let currentAttempt = attempt;
+    let currentDecision;
+    while (true) {
+      const controlBeforeAttempt = this.checkDidControlFail();
+      if (controlBeforeAttempt) {
+        return controlBeforeAttempt;
+      }
+      if (currentDecision) {
+        const delayControlResult = await this.waitForRetryDelay(currentDecision.delay);
+        if (delayControlResult) {
+          return delayControlResult;
+        }
+        currentDecision = undefined;
+      }
+      this.ctx.retry.attempt = currentAttempt;
+      try {
+        const result = this.#tryFn(this.ctx);
+        if (checkIsPromiseLike(result)) {
+          const raced = await this.race(Promise.resolve(result));
+          return raced;
+        }
+        return this.resolveSyncSuccess(result);
+      } catch (attemptError) {
+        const resolved = await this.#resolveFailure(attemptError);
+        if (!(resolved instanceof RetryDirective)) {
+          return resolved;
+        }
+        currentDecision = resolved.decision;
+        currentAttempt += 1;
+      }
+    }
+  }
+}
+async function executeRun(config, input) {
+  let __stack = [];
+  try {
+    const execution = __using(__stack, new RunExecution(config, input), 0);
+    return await execution.execute();
+  } catch (_catch) {
+    var _err = _catch, _hasErr = 1;
+  } finally {
+    __callDispose(__stack, _err, _hasErr);
+  }
+}
+
+// src/lib/executors/run-sync.ts
+function assertNotPromiseLike(value, code, message) {
+  invariant(!checkIsPromiseLike(value), new Panic(code, message === undefined ? undefined : { message }));
+}
+
+class RunSyncExecution extends BaseExecution {
+  #catchFn;
+  #tryFn;
+  constructor(config, input) {
+    super(config);
+    this.#catchFn = typeof input === "function" ? undefined : input.catch;
+    this.#tryFn = typeof input === "function" ? input : input.try;
+  }
+  execute() {
+    const result = super.execute();
+    assertNotPromiseLike(result, "RUN_SYNC_WRAPPED_RESULT_PROMISE");
+    return result;
+  }
+  executeCore() {
+    return this.#runAttemptLoop(1);
+  }
+  #resolveFailure(error) {
+    if (error instanceof Panic) {
+      throw error;
+    }
+    if (error instanceof ControlError) {
+      return error;
+    }
+    const controlError = this.checkDidControlFail(error);
+    if (controlError) {
+      return controlError;
+    }
+    const retryDecision = this.buildRetryDecision(error);
+    if (retryDecision.shouldAttemptRetry) {
+      return new RetryDirective(retryDecision);
+    }
+    if (retryDecision.isRetryExhausted) {
+      return new RetryExhaustedError(undefined, { cause: error });
+    }
+    if (!this.#catchFn) {
+      const finalizeControlError = this.checkDidControlFail(error);
+      if (finalizeControlError) {
+        return finalizeControlError;
+      }
+      return new UnhandledException(undefined, { cause: error });
+    }
+    let mapped;
+    try {
+      mapped = this.#catchFn(error);
+    } catch (catchError) {
+      throw new Panic("RUN_SYNC_CATCH_HANDLER_THROW", { cause: catchError });
+    }
+    assertNotPromiseLike(mapped, "RUN_SYNC_CATCH_PROMISE");
+    const catchControlError = this.checkDidControlFail(error);
+    if (catchControlError) {
+      return catchControlError;
+    }
+    return mapped;
+  }
+  #runAttemptLoop(attempt) {
+    let currentAttempt = attempt;
+    while (true) {
+      const controlBeforeAttempt = this.checkDidControlFail();
+      if (controlBeforeAttempt) {
+        return controlBeforeAttempt;
+      }
+      this.ctx.retry.attempt = currentAttempt;
+      let result;
+      try {
+        result = this.#tryFn(this.ctx);
+      } catch (error) {
+        const resolved = this.#resolveFailure(error);
+        if (resolved instanceof RetryDirective) {
+          if (resolved.decision.delay > 0) {
+            throw new Panic("RUN_SYNC_ASYNC_RETRY_POLICY");
+          }
+          currentAttempt += 1;
+          continue;
+        }
+        return resolved;
+      }
+      assertNotPromiseLike(result, "RUN_SYNC_TRY_PROMISE");
+      return this.resolveSyncSuccess(result);
+    }
+  }
+}
+function executeRunSync(config, input) {
+  let __stack = [];
+  try {
+    const isSyncSafeRetryPolicy = config.retry === undefined || config.retry.backoff === "constant" && !config.retry.jitter && (config.retry.delayMs ?? 0) <= 0;
+    invariant(isSyncSafeRetryPolicy, new Panic("RUN_SYNC_ASYNC_RETRY_POLICY"));
+    const execution = __using(__stack, new RunSyncExecution(config, input), 0);
+    return execution.execute();
+  } catch (_catch) {
+    var _err = _catch, _hasErr = 1;
+  } finally {
+    __callDispose(__stack, _err, _hasErr);
+  }
+}
+
+// src/lib/builder.ts
+class RunBuilder {
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  buildRetryConfig(policy) {
+    const limit = typeof policy === "number" ? policy : policy.limit;
+    invariant(Number.isFinite(limit), new Panic("RETRY_INVALID_LIMIT"));
+    invariant(limit >= 0, new Panic("RETRY_INVALID_LIMIT"));
+    return {
+      ...this.config,
+      retry: retryOptions(policy)
+    };
+  }
+  buildTimeoutConfig(ms) {
+    invariant(Number.isFinite(ms), new Panic("TIMEOUT_INVALID_MS"));
+    invariant(ms >= 0, new Panic("TIMEOUT_INVALID_MS"));
+    return {
+      ...this.config,
+      timeout: ms
+    };
+  }
+  buildSignalConfig(signal) {
+    return {
+      ...this.config,
+      signals: [...this.config.signals ?? [], signal]
+    };
+  }
+  retry(policy) {
+    return new ExecutionBuilder(this.buildRetryConfig(policy));
+  }
+  timeout(ms) {
+    return new ExecutionBuilder(this.buildTimeoutConfig(ms));
+  }
+  signal(signal) {
+    if (this instanceof ExecutionBuilder) {
+      return new ExecutionBuilder(this.buildSignalConfig(signal));
+    }
+    return new RunBuilder(this.buildSignalConfig(signal));
+  }
+  wrap(fn) {
+    return new RunBuilder({
+      ...this.config,
+      wraps: [...this.config.wraps ?? [], fn]
+    });
+  }
+  run(input) {
+    return executeRun(this.config, input);
+  }
+  runSync(input) {
+    return executeRunSync(this.config, input);
+  }
+  all(tasks, options) {
+    return executeAll(this.config, tasks, options);
+  }
+  allSettled(tasks) {
+    return executeAllSettled(this.config, tasks);
+  }
+  flow(tasks) {
+    return executeFlow(this.config, tasks);
+  }
+}
+
+class ExecutionBuilder extends RunBuilder {
+  constructor(config = {}) {
+    super(config);
+    Object.defineProperties(this, {
+      all: { configurable: true, value: undefined, writable: false },
+      allSettled: { configurable: true, value: undefined, writable: false },
+      flow: { configurable: true, value: undefined, writable: false },
+      wrap: { configurable: true, value: undefined, writable: false }
+    });
+  }
+}
+
+// src/lib/dispose.ts
+function dispose() {
+  return new AsyncDisposableStack;
+}
+// src/lib/gen.ts
+function* use(value) {
+  return yield value;
+}
+async function executeAsyncGenerator(iterator, initialStep) {
+  let currentStep = initialStep;
+  while (true) {
+    if (currentStep.done) {
+      if (checkIsPromiseLike(currentStep.value)) {
+        return await currentStep.value;
+      }
+      return currentStep.value;
+    }
+    let currentValue;
+    if (checkIsPromiseLike(currentStep.value)) {
+      try {
+        currentValue = await currentStep.value;
+      } catch (error) {
+        currentStep = iterator.throw(error);
+        continue;
+      }
+    } else {
+      currentValue = currentStep.value;
+    }
+    if (currentValue instanceof Error) {
+      return currentValue;
+    }
+    currentStep = iterator.next(currentValue);
+  }
+}
+function driveGen(factory) {
+  const iterator = factory(use);
+  let currentValue = undefined;
+  while (true) {
+    const step = iterator.next(currentValue);
+    if (step.done) {
+      if (checkIsPromiseLike(step.value)) {
+        return Promise.resolve(step.value);
+      }
+      return step.value;
+    }
+    if (checkIsPromiseLike(step.value)) {
+      return executeAsyncGenerator(iterator, step);
+    }
+    if (step.value instanceof Error) {
+      return step.value;
+    }
+    currentValue = step.value;
+  }
+}
+
+// src/index.ts
+var root = new RunBuilder;
+var all = root.all.bind(root);
+var allSettled = root.allSettled.bind(root);
+var flow = root.flow.bind(root);
+var retry = root.retry.bind(root);
+var run = root.run.bind(root);
+var runSync = root.runSync.bind(root);
+var signal = root.signal.bind(root);
+var timeout = root.timeout.bind(root);
+var wrap = root.wrap.bind(root);
+export {
+  wrap,
+  timeout,
+  signal,
+  runSync,
+  run,
+  retryOptions,
+  retry,
+  driveGen as gen,
+  flow,
+  dispose,
+  allSettled,
+  all
+};
+
+//# debugId=DACEA87E974540E264756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/lib/utils.ts", "src/lib/modifiers/retry.ts", "src/lib/modifiers/signal.ts", "src/lib/modifiers/timeout.ts", "src/lib/executors/base.ts", "src/lib/executors/shared.ts", "src/lib/executors/all.ts", "src/lib/executors/all-settled.ts", "src/lib/executors/flow.ts", "src/lib/executors/run.ts", "src/lib/executors/run-sync.ts", "src/lib/builder.ts", "src/lib/dispose.ts", "src/lib/gen.ts", "src/index.ts"],
  "sourcesContent": [
    "import { Panic, type PanicCode } from \"./errors\"\n\nexport function assertUnreachable(value: never, code: PanicCode): never {\n  throw new Panic(code, { message: `Unreachable case: ${String(value)}` })\n}\n\nexport function invariant(condition: unknown, error: Error): asserts condition {\n  if (!condition) {\n    throw error\n  }\n}\n\nexport function sleep(ms: number): Promise<void> {\n  if (ms <= 0) {\n    return Promise.resolve()\n  }\n\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms)\n  })\n}\n\nexport function checkIsPromiseLike(value: unknown): value is PromiseLike<unknown> {\n  return (\n    (typeof value === \"object\" || typeof value === \"function\") &&\n    value !== null &&\n    typeof (value as { then?: unknown }).then === \"function\"\n  )\n}\n\nexport async function resolveWithAbort<V, E>(\n  signal: AbortSignal,\n  promise: PromiseLike<V>,\n  createAbortResult: () => E\n): Promise<V | E> {\n  using disposer = new DisposableStack()\n\n  const abortPromise = new Promise<E>((resolve) => {\n    const onAbort = () => {\n      resolve(createAbortResult())\n    }\n\n    if (signal.aborted) {\n      onAbort()\n      return\n    }\n\n    signal.addEventListener(\"abort\", onAbort, { once: true })\n    disposer.defer(() => {\n      signal.removeEventListener(\"abort\", onAbort)\n    })\n  })\n\n  return await Promise.race([Promise.resolve(promise), abortPromise])\n}\n",
    "import type { BuilderConfig } from \"../builder\"\nimport type { TryCtx } from \"../executors/shared\"\nimport { Panic } from \"../errors\"\nimport { assertUnreachable, invariant } from \"../utils\"\n\ninterface BaseRetryPolicy {\n  /**\n   * Maximum number of attempts, including the first run.\n   */\n  limit: number\n  /**\n   * Delay in milliseconds between attempts. Defaults to 0.\n   */\n  delayMs?: number\n  /**\n   * Adds random jitter to delays when enabled.\n   */\n  jitter?: boolean\n  /**\n   * Return true to retry after an error, false to stop.\n   */\n  shouldRetry?: (error: unknown, ctx: TryCtx) => boolean\n}\n\ninterface LinearBackoffRetryPolicy extends BaseRetryPolicy {\n  /**\n   * Use linearly increasing delay between attempts.\n   */\n  backoff: \"linear\"\n  /**\n   * Not supported for linear backoff.\n   */\n  maxDelayMs?: never\n}\n\ninterface ExponentialBackoffRetryPolicy extends BaseRetryPolicy {\n  /**\n   * Use exponential delay growth between attempts.\n   */\n  backoff: \"exponential\"\n  /**\n   * Optional cap for exponential delay in milliseconds.\n   */\n  maxDelayMs?: number\n}\n\n/**\n * Retry policy using a constant delay strategy.\n */\ninterface ConstantBackoffRetryPolicy extends BaseRetryPolicy {\n  /**\n   * Required discriminant: use a fixed delay between attempts.\n   */\n  backoff: \"constant\"\n  /**\n   * Not supported for constant backoff.\n   */\n  maxDelayMs?: never\n}\n\n/**\n * Retry configuration object.\n */\nexport type RetryPolicy =\n  | LinearBackoffRetryPolicy\n  | ExponentialBackoffRetryPolicy\n  | ConstantBackoffRetryPolicy\n\n/**\n * Retry shorthand or full retry configuration.\n *\n * - `number`: attempt limit\n * - `RetryPolicy`: detailed retry settings\n */\nexport type RetryOptions = number | RetryPolicy\n\nexport function retryOptions(policy: RetryOptions): RetryPolicy {\n  const limit = typeof policy === \"number\" ? policy : policy.limit\n\n  invariant(Number.isFinite(limit), new Panic(\"RETRY_INVALID_LIMIT\"))\n  invariant(limit >= 0, new Panic(\"RETRY_INVALID_LIMIT\"))\n\n  if (typeof policy === \"number\") {\n    return {\n      backoff: \"constant\",\n      delayMs: 0,\n      limit: policy,\n    }\n  }\n\n  const base = {\n    delayMs: policy.delayMs ?? 0,\n    jitter: policy.jitter,\n    limit: policy.limit,\n    shouldRetry: policy.shouldRetry,\n  }\n\n  switch (policy.backoff) {\n    case \"constant\":\n    case \"linear\":\n      return { ...base, backoff: policy.backoff }\n    case \"exponential\":\n      return { ...base, backoff: policy.backoff, maxDelayMs: policy.maxDelayMs }\n    default:\n      return assertUnreachable(policy, \"UNREACHABLE_RETRY_POLICY_BACKOFF\")\n  }\n}\n\nexport function calculateRetryDelay(attempt: number, config: BuilderConfig): number {\n  const policy = config.retry\n\n  if (!policy) {\n    return 0\n  }\n\n  const baseDelay = policy.delayMs ?? 0\n  let delay = 0\n\n  switch (policy.backoff) {\n    case \"constant\":\n      delay = baseDelay\n      break\n    case \"linear\":\n      delay = baseDelay * attempt\n      break\n    case \"exponential\":\n      delay = baseDelay * 2 ** (attempt - 1)\n\n      if (policy.maxDelayMs !== undefined) {\n        delay = Math.min(delay, policy.maxDelayMs)\n      }\n\n      break\n  }\n\n  if (!policy.jitter || delay <= 0) {\n    return delay\n  }\n\n  return Math.floor(Math.random() * delay)\n}\n\nexport function checkShouldAttemptRetry(\n  error: unknown,\n  ctx: TryCtx,\n  config: BuilderConfig\n): boolean {\n  const policy = config.retry\n\n  if (!policy) {\n    return false\n  }\n\n  if (ctx.retry.attempt >= policy.limit) {\n    return false\n  }\n\n  if (!policy.shouldRetry) {\n    return true\n  }\n\n  return policy.shouldRetry(error, ctx)\n}\n\nexport function checkIsRetryExhausted(attempt: number, config: BuilderConfig): boolean {\n  return config.retry !== undefined && attempt >= config.retry.limit\n}\n",
    "import { CancellationError, TimeoutError } from \"../errors\"\nimport { resolveWithAbort } from \"../utils\"\n\nexport class SignalController {\n  readonly signal?: AbortSignal\n\n  constructor(signals: readonly AbortSignal[] = []) {\n    if (signals.length > 0) {\n      this.signal = AbortSignal.any([...signals])\n    }\n  }\n\n  checkDidCancel(cause?: unknown): CancellationError | undefined {\n    if (!this.signal?.aborted) {\n      return\n    }\n\n    if (this.signal.reason instanceof TimeoutError) {\n      return\n    }\n\n    return new CancellationError(undefined, { cause: cause ?? this.signal.reason })\n  }\n\n  async race<V>(promise: PromiseLike<V>, cause?: unknown): Promise<V | CancellationError> {\n    const cancelled = this.checkDidCancel(cause)\n\n    if (cancelled) {\n      return cancelled\n    }\n\n    if (!this.signal) {\n      return promise\n    }\n\n    return await resolveWithAbort(\n      this.signal,\n      promise,\n      () => new CancellationError(undefined, { cause: cause ?? this.signal?.reason })\n    )\n  }\n\n  [Symbol.dispose](): void {\n    void this.signal\n  }\n}\n",
    "import { Panic, TimeoutError } from \"../errors\"\nimport { invariant, resolveWithAbort } from \"../utils\"\n\nexport class TimeoutController {\n  readonly signal?: AbortSignal\n  readonly #controller?: AbortController\n  readonly #startedAt = Date.now()\n  readonly #timeoutMs: number\n  #timeoutId: ReturnType<typeof setTimeout> | undefined\n\n  constructor(timeoutMs?: number) {\n    this.#timeoutMs = timeoutMs ?? -1\n\n    if (timeoutMs === undefined) {\n      return\n    }\n\n    invariant(Number.isFinite(timeoutMs), new Panic(\"TIMEOUT_INVALID_MS\"))\n    invariant(timeoutMs >= 0, new Panic(\"TIMEOUT_INVALID_MS\"))\n\n    this.#controller = new AbortController()\n    this.signal = this.#controller.signal\n\n    if (this.#timeoutMs <= 0) {\n      this.#abort()\n      return\n    }\n\n    this.#timeoutId = setTimeout(() => {\n      this.#abort()\n    }, this.#timeoutMs)\n  }\n\n  #abort(cause?: unknown) {\n    const timeoutError = new TimeoutError(`Execution exceeded timeout of ${this.#timeoutMs}ms`, {\n      cause,\n    })\n\n    if (!this.signal?.aborted) {\n      this.#controller?.abort(timeoutError)\n    }\n\n    return timeoutError\n  }\n\n  get #remaining() {\n    const elapsed = Date.now() - this.#startedAt\n\n    return this.#timeoutMs - elapsed\n  }\n\n  checkDidTimeout(cause?: unknown): TimeoutError | undefined {\n    if (!this.signal) {\n      return\n    }\n\n    if (this.signal.aborted) {\n      const reason = this.signal.reason\n\n      if (reason instanceof TimeoutError) {\n        return reason\n      }\n\n      return new TimeoutError(`Execution exceeded timeout of ${this.#timeoutMs}ms`, {\n        cause: cause ?? reason,\n      })\n    }\n\n    if (this.#remaining > 0) {\n      return\n    }\n\n    return this.#abort(cause)\n  }\n\n  async race<V>(promise: PromiseLike<V>, cause?: unknown): Promise<V | TimeoutError> {\n    if (!this.signal) {\n      return promise\n    }\n\n    if (this.#remaining <= 0) {\n      return this.#abort(cause)\n    }\n\n    const timedOut = this.checkDidTimeout(cause)\n\n    if (timedOut) {\n      return timedOut\n    }\n\n    return await resolveWithAbort(\n      this.signal,\n      promise,\n      () =>\n        this.checkDidTimeout(cause) ??\n        new TimeoutError(`Execution exceeded timeout of ${this.#timeoutMs}ms`, { cause })\n    )\n  }\n\n  [Symbol.dispose](): void {\n    if (this.#timeoutId !== undefined) {\n      clearTimeout(this.#timeoutId)\n    }\n  }\n}\n",
    "import type { BuilderConfig, WrapCtx } from \"../builder\"\nimport type { RetryExhaustedError, UnhandledException } from \"../errors\"\nimport type { TryCtx } from \"./shared\"\nimport { CancellationError, TimeoutError } from \"../errors\"\nimport {\n  calculateRetryDelay,\n  checkIsRetryExhausted,\n  checkShouldAttemptRetry,\n} from \"../modifiers/retry\"\nimport { SignalController } from \"../modifiers/signal\"\nimport { TimeoutController } from \"../modifiers/timeout\"\nimport { sleep } from \"../utils\"\n\ninterface BaseExecutionOptions {\n  retryLimit?: number\n}\n\nexport type RetryDecision = {\n  delay: number\n  isRetryExhausted: boolean\n  shouldAttemptRetry: boolean\n}\n\nexport type RunnerError =\n  | CancellationError\n  | RetryExhaustedError\n  | TimeoutError\n  | UnhandledException\n\nexport class RetryDirective {\n  readonly decision: RetryDecision\n\n  constructor(decision: RetryDecision) {\n    this.decision = decision\n  }\n}\n\nexport abstract class BaseExecution<TResult = unknown> {\n  protected readonly config: BuilderConfig\n  protected readonly ctx: TryCtx\n  protected readonly executionSignal: AbortSignal | undefined\n  readonly #wrapCtx: WrapCtx\n  readonly #signalController: SignalController | undefined\n  readonly #timeoutController: TimeoutController | undefined\n\n  protected constructor(config: BuilderConfig, options: BaseExecutionOptions = {}) {\n    this.config = config\n    this.#timeoutController = BaseExecution.createTimeoutController(config.timeout)\n    this.#signalController = BaseExecution.createSignalController(\n      config.signals,\n      this.#timeoutController?.signal\n    )\n    this.executionSignal = this.#signalController?.signal\n    this.ctx = BaseExecution.createContext(config, this.executionSignal, options.retryLimit)\n    this.#wrapCtx = BaseExecution.createWrapContext(this.ctx)\n  }\n\n  execute(): TResult {\n    // Wraps cover the full retry scope; `ctx.retry.attempt` may reflect the final\n    // attempt when observed after `next()` resolves.\n    const wraps = this.config.wraps\n\n    if (!wraps || wraps.length === 0) {\n      return this.executeCore()\n    }\n\n    let next = (): unknown => this.executeCore()\n\n    for (const wrap of wraps.toReversed()) {\n      const previous = next\n      next = () => wrap(this.#wrapCtx, previous)\n    }\n\n    return next() as TResult\n  }\n\n  protected abstract executeCore(): TResult\n\n  [Symbol.dispose](): void {\n    using disposer = new DisposableStack()\n    if (this.#timeoutController) {\n      disposer.use(this.#timeoutController)\n    }\n\n    if (this.#signalController) {\n      disposer.use(this.#signalController)\n    }\n  }\n\n  protected static createContext(\n    config: BuilderConfig,\n    signal: AbortSignal | undefined,\n    retryLimit?: number\n  ): TryCtx {\n    return {\n      retry: {\n        attempt: 1,\n        limit: retryLimit ?? config.retry?.limit ?? 1,\n      },\n      signal,\n    }\n  }\n\n  protected static createTimeoutController(\n    timeoutMs: number | undefined\n  ): TimeoutController | undefined {\n    return timeoutMs === undefined ? undefined : new TimeoutController(timeoutMs)\n  }\n\n  protected static createSignalController(\n    signals: readonly AbortSignal[] | undefined,\n    timeoutSignal: AbortSignal | undefined\n  ): SignalController | undefined {\n    const composedSignals = [...(signals ?? []), timeoutSignal].filter(\n      (value): value is AbortSignal => value !== undefined\n    )\n\n    return composedSignals.length > 0 ? new SignalController(composedSignals) : undefined\n  }\n\n  protected static createWrapContext(ctx: TryCtx): WrapCtx {\n    const retry = new Proxy(ctx.retry, {\n      defineProperty: () => false,\n      deleteProperty: () => false,\n      getOwnPropertyDescriptor(target, property) {\n        const descriptor = Reflect.getOwnPropertyDescriptor(target, property)\n\n        if (!descriptor) {\n          return descriptor\n        }\n\n        return {\n          ...descriptor,\n          writable: false,\n        }\n      },\n      set: () => false,\n    }) as WrapCtx[\"retry\"]\n\n    return new Proxy(ctx, {\n      defineProperty: () => false,\n      deleteProperty: () => false,\n      get(target, property, receiver) {\n        if (property === \"retry\") {\n          return retry\n        }\n\n        return Reflect.get(target, property, receiver) as unknown\n      },\n      getOwnPropertyDescriptor(target, property) {\n        const descriptor = Reflect.getOwnPropertyDescriptor(target, property)\n\n        if (!descriptor) {\n          return descriptor\n        }\n\n        if (property === \"retry\") {\n          return {\n            ...descriptor,\n            value: retry,\n            writable: false,\n          }\n        }\n\n        return {\n          ...descriptor,\n          writable: false,\n        }\n      },\n      set: () => false,\n    }) as WrapCtx\n  }\n\n  protected checkDidCancel(cause?: unknown): CancellationError | undefined {\n    return this.#signalController?.checkDidCancel(cause)\n  }\n\n  protected raceWithCancellation<V>(\n    promise: PromiseLike<V>,\n    cause?: unknown\n  ): PromiseLike<V | CancellationError> {\n    return this.#signalController ? this.#signalController.race(promise, cause) : promise\n  }\n\n  protected checkDidControlFail(cause?: unknown): CancellationError | TimeoutError | undefined {\n    return this.checkDidCancel(cause) ?? this.#timeoutController?.checkDidTimeout(cause)\n  }\n\n  protected resolveSyncSuccess<T>(value: T): T | CancellationError | TimeoutError {\n    return this.checkDidControlFail() ?? value\n  }\n\n  protected race<V>(\n    promise: PromiseLike<V>,\n    cause?: unknown\n  ): PromiseLike<V | CancellationError | TimeoutError> {\n    const timeoutController = this.#timeoutController\n\n    if (!timeoutController) {\n      return this.raceWithCancellation(promise, cause)\n    }\n\n    return Promise.resolve(\n      timeoutController.race(this.raceWithCancellation(promise, cause), cause)\n    ).then((raced) => {\n      if (raced instanceof TimeoutError) {\n        return this.checkDidCancel(cause) ?? raced\n      }\n\n      return raced\n    })\n  }\n\n  protected async waitForRetryDelay(\n    delay: number\n  ): Promise<CancellationError | TimeoutError | undefined> {\n    if (delay <= 0) {\n      return undefined\n    }\n\n    const sleepResult = await this.race(sleep(delay))\n\n    if (sleepResult instanceof CancellationError || sleepResult instanceof TimeoutError) {\n      return sleepResult\n    }\n\n    return undefined\n  }\n\n  protected shouldAttemptRetry(error: unknown): boolean {\n    return checkShouldAttemptRetry(error, this.ctx, this.config)\n  }\n\n  protected retryDelayForCurrentAttempt(): number {\n    return calculateRetryDelay(this.ctx.retry.attempt, this.config)\n  }\n\n  protected checkIsRetryExhaustedCurrentAttempt(): boolean {\n    return checkIsRetryExhausted(this.ctx.retry.attempt, this.config)\n  }\n\n  protected buildRetryDecision(error: unknown): RetryDecision {\n    const shouldAttemptRetry = this.shouldAttemptRetry(error)\n\n    return {\n      delay: shouldAttemptRetry ? this.retryDelayForCurrentAttempt() : 0,\n      isRetryExhausted: this.checkIsRetryExhaustedCurrentAttempt(),\n      shouldAttemptRetry,\n    }\n  }\n}\n",
    "import type { BuilderConfig } from \"../builder\"\nimport { Panic, UnhandledException } from \"../errors\"\nimport { invariant } from \"../utils\"\nimport { BaseExecution } from \"./base\"\n\ntype ResolverPair = [(value: unknown) => void, (reason?: unknown) => void]\n\ntype TaskExecutionMode = \"fail-fast\" | \"settled\"\n\n// oxlint-disable-next-line no-explicit-any -- Required for task-map inference\nexport type TaskRecord = Record<string, any>\n\nexport type TaskValidation<T extends TaskRecord> = {\n  // oxlint-disable-next-line no-explicit-any -- Required for function compatibility with contextual `this`\n  [K in keyof T]: T[K] extends (...args: any[]) => any ? T[K] : never\n}\n\n// oxlint-disable-next-line no-explicit-any -- Required for function compatibility with contextual `this`\nexport type TaskResult<T> = T extends (...args: any[]) => infer R ? Awaited<R> : never\n\nexport type ResultProxy<T extends TaskRecord> = {\n  readonly [K in keyof T]: Promise<TaskResult<T[K]>>\n}\n\nexport interface TaskContext<T extends TaskRecord> {\n  $result: ResultProxy<T>\n  $signal: AbortSignal\n  $disposer: AsyncDisposableStack\n}\n\nexport type InferredTaskContext<T extends TaskRecord> = {\n  $result: {\n    readonly [K in keyof T]: ReturnType<T[K]> extends Promise<infer R>\n      ? Promise<R>\n      : Promise<ReturnType<T[K]>>\n  }\n  $signal: AbortSignal\n  $disposer: AsyncDisposableStack\n}\n\nexport type AllValue<T extends TaskRecord> = {\n  [K in keyof T]: TaskResult<T[K]>\n}\n\ninterface AllCatchContext<T extends TaskRecord> {\n  failedTask: (keyof T & string) | undefined\n  partial: Partial<AllValue<T>>\n  signal: AbortSignal\n}\n\ntype AllCatchFn<T extends TaskRecord, C> = (\n  error: unknown,\n  ctx: AllCatchContext<T>\n) => C | Promise<C>\n\nexport interface AllOptions<T extends TaskRecord, C> {\n  catch: AllCatchFn<T, C>\n}\n\nexport interface SettledFulfilled<T> {\n  status: \"fulfilled\"\n  value: T\n}\n\nexport interface SettledRejected {\n  status: \"rejected\"\n  reason: unknown\n}\n\nexport type SettledResult<T> = SettledFulfilled<T> | SettledRejected\n\nexport type AllSettledResult<T extends TaskRecord> = {\n  [K in keyof T]: SettledResult<TaskResult<T[K]>>\n}\n\ninterface RetryInfo {\n  attempt: number\n  limit: number\n}\n\nexport interface BaseTryCtx {\n  signal?: AbortSignal\n}\n\nexport type TryCtxFor<HasRetry extends boolean> = BaseTryCtx &\n  (HasRetry extends true ? { retry: RetryInfo } : Record<never, never>)\n\nexport type TryCtx = TryCtxFor<true>\n\nexport type NonPromise<T> = T extends PromiseLike<unknown> ? never : T\n\nexport abstract class OrchestrationExecution<TResult> extends BaseExecution<Promise<TResult>> {\n  protected constructor(config: BuilderConfig) {\n    const unsupportedPolicies = [\n      config.retry === undefined ? undefined : \"retry\",\n      config.timeout === undefined ? undefined : \"timeout\",\n    ].filter((value): value is \"retry\" | \"timeout\" => value !== undefined)\n\n    invariant(\n      unsupportedPolicies.length === 0,\n      new Panic(\"ORCHESTRATION_UNSUPPORTED_POLICY\", {\n        message: `Orchestration does not support ${unsupportedPolicies.join(\" or \")} policies.`,\n      })\n    )\n\n    super({\n      signals: config.signals,\n      wraps: config.wraps,\n    })\n  }\n\n  protected override async executeCore(): Promise<TResult> {\n    // Orchestration executors still share outer wraps/cancellation checks even\n    // though their task execution strategies differ.\n    const controlBeforeExecution = this.checkDidControlFail()\n\n    if (controlBeforeExecution) {\n      throw controlBeforeExecution\n    }\n\n    return await this.executeTasks()\n  }\n\n  protected abstract executeTasks(): Promise<TResult>\n}\n\nexport abstract class TaskGraphExecutionBase<\n  T extends TaskRecord,\n  TContext extends TaskContext<T>,\n> {\n  protected readonly tasks: T\n  protected readonly taskNames: Array<keyof T & string>\n  protected readonly results!: Map<keyof T, unknown>\n  protected readonly errors!: Map<keyof T, unknown>\n  protected readonly resolvers!: Map<keyof T, ResolverPair[]>\n  protected readonly internalController: AbortController = new AbortController()\n  protected readonly taskSignal: AbortSignal\n  protected readonly disposer: AsyncDisposableStack = new AsyncDisposableStack()\n  protected firstRejection: unknown\n\n  constructor(signal: AbortSignal | undefined, tasks: T) {\n    this.tasks = tasks\n    this.taskNames = Object.keys(tasks) as Array<keyof T & string>\n    this.results = new Map<keyof T, unknown>()\n    this.errors = new Map<keyof T, unknown>()\n    this.resolvers = new Map<keyof T, ResolverPair[]>()\n    this.taskSignal = signal\n      ? AbortSignal.any([signal, this.internalController.signal])\n      : this.internalController.signal\n  }\n\n  async [Symbol.asyncDispose](): Promise<void> {\n    await this.disposer.disposeAsync()\n  }\n\n  protected getTaskHandler(taskName: keyof T) {\n    const taskFn = this.tasks[taskName]\n\n    invariant(\n      typeof taskFn === \"function\",\n      new Panic(\"TASK_INVALID_HANDLER\", {\n        message: `Task \"${String(taskName)}\" is not a function`,\n      })\n    )\n\n    return taskFn as (this: TContext) => unknown\n  }\n\n  protected createResultProxy(requesterTaskName: keyof T): ResultProxy<T> {\n    return new Proxy({} as ResultProxy<T>, {\n      get: (_, referencedTaskName: string) =>\n        this.waitForResult(referencedTaskName as keyof T, requesterTaskName),\n    })\n  }\n\n  protected waitForResult(taskName: keyof T, requesterTaskName?: keyof T): Promise<unknown> {\n    if (requesterTaskName === taskName) {\n      return Promise.reject(\n        new Panic(\"TASK_SELF_REFERENCE\", {\n          message: `Task \"${String(taskName)}\" cannot await its own result`,\n        })\n      )\n    }\n\n    if (!Object.hasOwn(this.tasks, taskName)) {\n      return Promise.reject(\n        new Panic(\"TASK_UNKNOWN_REFERENCE\", {\n          message: `Unknown task \"${String(taskName)}\"`,\n        })\n      )\n    }\n\n    if (this.results.has(taskName)) {\n      return Promise.resolve(this.results.get(taskName))\n    }\n\n    if (this.errors.has(taskName)) {\n      const storedError = this.mapStoredError(this.errors.get(taskName))\n\n      return Promise.reject(storedError)\n    }\n\n    return new Promise((resolve, reject) => {\n      const queue = this.resolvers.get(taskName)\n\n      if (queue) {\n        queue.push([resolve, reject])\n        return\n      }\n\n      this.resolvers.set(taskName, [[resolve, reject]])\n    })\n  }\n\n  protected storeResult(taskName: keyof T, value: unknown): void {\n    this.results.set(taskName, value)\n    this.resolveWaiters(taskName, value)\n  }\n\n  protected storeError(taskName: keyof T, error: unknown): void {\n    const mappedError = this.mapStoredError(error)\n\n    this.errors.set(taskName, mappedError)\n    this.rejectWaiters(taskName, mappedError)\n  }\n\n  protected resolveWaiters(taskName: keyof T, value: unknown): void {\n    const fulfilled = this.resolvers.get(taskName)\n\n    if (fulfilled) {\n      for (const [resolve] of fulfilled) {\n        resolve(value)\n      }\n\n      this.resolvers.delete(taskName)\n    }\n  }\n\n  protected rejectWaiters(taskName: keyof T, error: unknown): void {\n    const rejected = this.resolvers.get(taskName)\n\n    if (rejected) {\n      for (const [, reject] of rejected) {\n        reject(error)\n      }\n\n      this.resolvers.delete(taskName)\n    }\n  }\n\n  protected abortInternal(error: unknown): void {\n    if (!this.internalController.signal.aborted) {\n      this.internalController.abort(error)\n    }\n  }\n\n  protected onTaskResult(_taskName: keyof T, _value: unknown): void {\n    void this.tasks\n    void _taskName\n    void _value\n  }\n\n  protected onTaskError(_taskName: keyof T, _error: unknown): void {\n    void this.tasks\n    void _taskName\n    void _error\n  }\n\n  protected mapStoredError(error: unknown): Error {\n    void this.tasks\n    return error instanceof Error ? error : new UnhandledException(undefined, { cause: error })\n  }\n\n  protected shouldAbortOnTaskError(_error: unknown): boolean {\n    void this.tasks\n    void _error\n    return false\n  }\n\n  protected shouldRethrowTaskError(_error: unknown): boolean {\n    void this.tasks\n    void _error\n    return true\n  }\n\n  protected setFirstRejection(error: unknown): void {\n    this.firstRejection ??= error\n  }\n\n  protected abstract createTaskContext(resultProxy: ResultProxy<T>): TContext\n\n  protected async runTask(taskName: keyof T): Promise<void> {\n    try {\n      const taskFn = this.getTaskHandler(taskName)\n      const resultProxy = this.createResultProxy(taskName)\n      const context = this.createTaskContext(resultProxy)\n      const result = await taskFn.call(context)\n\n      this.storeResult(taskName, result)\n      this.onTaskResult(taskName, result)\n    } catch (error) {\n      this.setFirstRejection(error)\n      this.storeError(taskName, error)\n      this.onTaskError(taskName, error)\n\n      if (this.shouldAbortOnTaskError(error)) {\n        this.abortInternal(error)\n      }\n\n      if (this.shouldRethrowTaskError(error)) {\n        throw error\n      }\n    }\n  }\n}\n\nexport class TaskExecution<T extends TaskRecord> extends TaskGraphExecutionBase<T, TaskContext<T>> {\n  readonly #mode: TaskExecutionMode\n  readonly #returnValue: Record<string, unknown> = {}\n  #failedTask: (keyof T & string) | undefined\n  private settledPromise: Promise<Array<PromiseSettledResult<void>>> | undefined\n\n  constructor(signal: AbortSignal | undefined, tasks: T, mode: TaskExecutionMode) {\n    super(signal, tasks)\n    this.#mode = mode\n  }\n\n  get failedTask(): (keyof T & string) | undefined {\n    return this.#failedTask\n  }\n\n  get signal(): AbortSignal {\n    return this.taskSignal\n  }\n\n  get returnValue(): Record<string, unknown> {\n    return this.#returnValue\n  }\n\n  async execute(): Promise<Record<string, unknown>> {\n    const promises = this.taskNames.map(async (name) => this.runTask(name))\n    this.settledPromise = Promise.allSettled(promises)\n\n    if (this.#mode === \"settled\") {\n      await this.settledPromise\n      return this.#returnValue\n    }\n\n    try {\n      await Promise.all(promises)\n    } catch {\n      throw this.mapStoredError(this.firstRejection)\n    }\n\n    return this.#returnValue\n  }\n\n  async waitForTasksToSettle(): Promise<void> {\n    await this.settledPromise\n  }\n\n  protected override createTaskContext(resultProxy: ResultProxy<T>): TaskContext<T> {\n    return {\n      $disposer: this.disposer,\n      $result: resultProxy,\n      $signal: this.taskSignal,\n    }\n  }\n\n  protected override onTaskResult(taskName: keyof T, value: unknown): void {\n    if (this.#mode === \"settled\") {\n      this.#returnValue[taskName as string] = { status: \"fulfilled\", value }\n    } else {\n      this.#returnValue[taskName as string] = value\n    }\n  }\n\n  protected override onTaskError(taskName: keyof T, error: unknown): void {\n    this.#failedTask ??= taskName as keyof T & string\n\n    if (this.#mode === \"settled\") {\n      this.#returnValue[taskName as string] = { reason: error, status: \"rejected\" }\n    }\n  }\n\n  protected override shouldAbortOnTaskError(): boolean {\n    return this.#mode === \"fail-fast\"\n  }\n\n  protected override shouldRethrowTaskError(): boolean {\n    return this.#mode === \"fail-fast\"\n  }\n}\n",
    "import type { BuilderConfig } from \"../builder\"\nimport type {\n  AllOptions,\n  AllValue,\n  InferredTaskContext,\n  TaskRecord,\n  TaskResult,\n  TaskValidation,\n} from \"./shared\"\nimport { CancellationError, Panic } from \"../errors\"\nimport { checkIsPromiseLike } from \"../utils\"\nimport { OrchestrationExecution, TaskExecution } from \"./shared\"\n\nclass AllExecution<T extends TaskRecord, C> extends OrchestrationExecution<AllValue<T> | C> {\n  readonly #tasks: T\n  readonly #options: AllOptions<T, C> | undefined\n\n  constructor(config: BuilderConfig, tasks: T, options?: AllOptions<T, C>) {\n    super(config)\n    this.#tasks = tasks\n    this.#options = options\n  }\n\n  protected override async executeTasks(): Promise<AllValue<T> | C> {\n    await using execution = new TaskExecution(this.executionSignal, this.#tasks, \"fail-fast\")\n    let result!: AllValue<T> | C\n    let threw = false\n    let thrownError: unknown\n\n    try {\n      result = (await this.raceWithCancellation(execution.execute())) as AllValue<T>\n    } catch (error) {\n      const controlAfterFailure = this.checkDidControlFail(error)\n      const catchFn = this.#options?.catch\n\n      if (controlAfterFailure) {\n        threw = true\n        thrownError = controlAfterFailure\n      } else if (catchFn) {\n        const context = {\n          failedTask: execution.failedTask,\n          partial: execution.returnValue as Partial<AllValue<T>>,\n          signal: execution.signal,\n        }\n\n        try {\n          const mapped = catchFn(error, context)\n          if (checkIsPromiseLike(mapped)) {\n            try {\n              result = (await this.raceWithCancellation(\n                Promise.resolve(mapped).catch((catchError: unknown) => {\n                  if (catchError instanceof CancellationError) {\n                    throw catchError\n                  }\n\n                  throw new Panic(\"ALL_CATCH_HANDLER_REJECT\", { cause: catchError })\n                }),\n                error\n              )) as C\n            } catch (mappedError) {\n              threw = true\n              thrownError = mappedError\n            }\n          } else {\n            result = mapped\n          }\n        } catch (catchError) {\n          threw = true\n          thrownError = new Panic(\"ALL_CATCH_HANDLER_THROW\", { cause: catchError })\n        }\n      } else {\n        threw = true\n        thrownError = error\n      }\n    } finally {\n      await execution.waitForTasksToSettle()\n    }\n\n    const cancellation = this.checkDidCancel(thrownError)\n\n    if (cancellation) {\n      throw cancellation\n    }\n\n    if (threw) {\n      throw thrownError\n    }\n\n    return result\n  }\n}\n\nexport async function executeAll<T extends TaskRecord, C = never>(\n  config: BuilderConfig,\n  tasks: T & TaskValidation<NoInfer<T>> & ThisType<InferredTaskContext<T>>,\n  options?: AllOptions<T, C>\n): Promise<{ [K in keyof T]: TaskResult<T[K]> } | C> {\n  using execution = new AllExecution(config, tasks, options)\n  return (await execution.execute()) as { [K in keyof T]: TaskResult<T[K]> } | C\n}\n",
    "import type { BuilderConfig } from \"../builder\"\nimport type { AllSettledResult, InferredTaskContext, TaskRecord, TaskValidation } from \"./shared\"\nimport { OrchestrationExecution, TaskExecution } from \"./shared\"\n\nclass AllSettledExecution<T extends TaskRecord> extends OrchestrationExecution<\n  AllSettledResult<T>\n> {\n  readonly #tasks: T\n\n  constructor(config: BuilderConfig, tasks: T) {\n    super(config)\n    this.#tasks = tasks\n  }\n\n  protected override async executeTasks(): Promise<AllSettledResult<T>> {\n    await using execution = new TaskExecution(this.executionSignal, this.#tasks, \"settled\")\n    const result = await this.raceWithCancellation(execution.execute())\n    const cancellation = this.checkDidCancel()\n\n    if (cancellation) {\n      throw cancellation\n    }\n\n    return result as AllSettledResult<T>\n  }\n}\n\nexport async function executeAllSettled<T extends TaskRecord>(\n  config: BuilderConfig,\n  tasks: T & TaskValidation<NoInfer<T>> & ThisType<InferredTaskContext<T>>\n): Promise<AllSettledResult<T>> {\n  using execution = new AllSettledExecution(config, tasks)\n  return await execution.execute()\n}\n",
    "import type { BuilderConfig } from \"../builder\"\nimport type {\n  InferredTaskContext,\n  ResultProxy,\n  TaskContext,\n  TaskRecord,\n  TaskResult,\n} from \"./shared\"\nimport { Panic } from \"../errors\"\nimport { OrchestrationExecution, TaskGraphExecutionBase } from \"./shared\"\n\ndeclare const FLOW_EXIT_BRAND: unique symbol\n\nexport type FlowExit<T> = {\n  readonly [FLOW_EXIT_BRAND]: T\n}\n\ntype ExitValue<T> = T extends FlowExit<infer V> ? V : never\n\ntype FlowExitValue<T extends TaskRecord> = {\n  [K in keyof T]: ExitValue<TaskResult<T[K]>>\n}[keyof T]\n\ninterface FlowTaskContext<T extends TaskRecord> extends TaskContext<T> {\n  $exit<V>(value: V): FlowExit<V>\n}\n\nexport type InferredFlowTaskContext<T extends TaskRecord> = InferredTaskContext<T> & {\n  $exit<V>(value: V): FlowExit<V>\n}\n\nexport type FlowResult<T extends TaskRecord> = FlowExitValue<T>\n\nclass FlowExitSignal extends Error {\n  readonly value: unknown\n\n  constructor(value: unknown) {\n    super(\"Flow exited\")\n    this.name = \"FlowExitSignal\"\n    this.value = value\n  }\n}\n\nclass FlowExecution<T extends TaskRecord> extends TaskGraphExecutionBase<T, FlowTaskContext<T>> {\n  #firstRejectionWaiters: Array<() => void> = []\n  #settledPromise: Promise<Array<PromiseSettledResult<void>>> | undefined\n\n  async execute(): Promise<FlowResult<T>> {\n    const promises = this.taskNames.map(async (name) => this.runTask(name))\n    this.#settledPromise = Promise.allSettled(promises)\n\n    // Race Promise.allSettled() against the first rejection recorded by runTask().\n    await Promise.race([this.#settledPromise, this.waitForFirstRejection()])\n\n    if (this.firstRejection !== undefined) {\n      if (this.firstRejection instanceof FlowExitSignal) {\n        return this.firstRejection.value as FlowResult<T>\n      }\n\n      throw this.firstRejection\n    }\n\n    throw new Panic(\"FLOW_NO_EXIT\")\n  }\n\n  async waitForTasksToSettle(): Promise<void> {\n    await this.#settledPromise\n  }\n\n  protected override setFirstRejection(error: unknown): void {\n    const hadFirstRejection = this.firstRejection !== undefined\n\n    super.setFirstRejection(error)\n\n    if (hadFirstRejection || this.firstRejection === undefined) {\n      return\n    }\n\n    for (const resolve of this.#firstRejectionWaiters) {\n      resolve()\n    }\n\n    this.#firstRejectionWaiters = []\n  }\n\n  protected override createTaskContext(resultProxy: ResultProxy<T>): FlowTaskContext<T> {\n    return {\n      $disposer: this.disposer,\n      $exit: (value) => {\n        throw new FlowExitSignal(value)\n      },\n      $result: resultProxy,\n      $signal: this.taskSignal,\n    }\n  }\n\n  protected override mapStoredError(error: unknown): Error {\n    if (error instanceof FlowExitSignal) {\n      return error\n    }\n\n    return super.mapStoredError(error)\n  }\n\n  protected override shouldAbortOnTaskError(): boolean {\n    void this.taskNames\n    return true\n  }\n\n  private waitForFirstRejection(): Promise<void> {\n    if (this.firstRejection !== undefined) {\n      return Promise.resolve()\n    }\n\n    return new Promise((resolve) => {\n      this.#firstRejectionWaiters.push(resolve)\n    })\n  }\n}\n\nclass FlowRunnerExecution<T extends TaskRecord> extends OrchestrationExecution<FlowResult<T>> {\n  readonly #tasks: T\n\n  constructor(config: BuilderConfig, tasks: T) {\n    super(config)\n    this.#tasks = tasks\n  }\n\n  protected override async executeTasks(): Promise<FlowResult<T>> {\n    await using execution = new FlowExecution(this.executionSignal, this.#tasks)\n    let result!: FlowResult<T>\n    let threw = false\n    let thrownError: unknown\n\n    try {\n      result = (await this.raceWithCancellation(execution.execute())) as FlowResult<T>\n    } catch (error) {\n      threw = true\n      thrownError = error\n    } finally {\n      await execution.waitForTasksToSettle()\n    }\n\n    const cancellation = this.checkDidCancel(thrownError)\n\n    if (cancellation) {\n      throw cancellation\n    }\n\n    if (threw) {\n      throw thrownError\n    }\n\n    return result\n  }\n}\n\nexport async function executeFlow<T extends TaskRecord>(\n  config: BuilderConfig,\n  tasks: T & ThisType<InferredFlowTaskContext<T>>\n): Promise<FlowResult<T>> {\n  using execution = new FlowRunnerExecution(config, tasks)\n  return await execution.execute()\n}\n",
    "import type { BuilderConfig } from \"../builder\"\nimport type { BaseTryCtx, NonPromise } from \"./shared\"\nimport { ControlError, Panic, RetryExhaustedError, UnhandledException } from \"../errors\"\nimport { checkIsPromiseLike } from \"../utils\"\nimport { BaseExecution, RetryDirective, type RetryDecision, type RunnerError } from \"./base\"\n\nexport type RunTryFn<T, Ctx extends BaseTryCtx = BaseTryCtx> = (\n  ctx: Ctx\n) => NonPromise<T> | Promise<T>\n\ntype RunCatchFn<E> = (error: unknown) => NonPromise<E> | Promise<E>\n\ninterface RunAsyncOptions<T, E, Ctx extends BaseTryCtx = BaseTryCtx> {\n  try: RunTryFn<T, Ctx>\n  catch: RunCatchFn<E>\n}\n\nexport type AsyncRunInput<T, E, Ctx extends BaseTryCtx = BaseTryCtx> =\n  | RunTryFn<T, Ctx>\n  | RunAsyncOptions<T, E, Ctx>\n\n/** Encapsulates the shared mutable state and logic for a single run execution. */\nclass RunExecution<T, E, Ctx extends BaseTryCtx> extends BaseExecution<\n  Promise<T | E | RunnerError>\n> {\n  #catchFn: RunCatchFn<E> | undefined\n  #tryFn: RunTryFn<T, Ctx>\n\n  constructor(config: BuilderConfig, input: AsyncRunInput<T, E, Ctx>) {\n    super(config)\n\n    this.#catchFn = typeof input === \"function\" ? undefined : input.catch\n    this.#tryFn = typeof input === \"function\" ? input : input.try\n  }\n\n  protected override executeCore(): Promise<T | E | RunnerError> {\n    return this.#runAttemptLoop(1)\n  }\n\n  /** Resolve an attempt error into either a terminal result or a retry decision. */\n  async #resolveFailure(error: unknown): Promise<E | RunnerError | RetryDirective> {\n    if (error instanceof Panic) {\n      throw error\n    }\n\n    if (error instanceof ControlError) {\n      return error\n    }\n\n    const controlError = this.checkDidControlFail(error)\n\n    if (controlError) {\n      return controlError\n    }\n\n    const retryDecision = this.buildRetryDecision(error)\n\n    if (retryDecision.shouldAttemptRetry) {\n      return new RetryDirective(retryDecision)\n    }\n\n    if (retryDecision.isRetryExhausted) {\n      return new RetryExhaustedError(undefined, { cause: error })\n    }\n\n    if (!this.#catchFn) {\n      // Even without a catch handler, cancellation/timeout may have won since\n      // the original failure was first observed.\n      const finalizeControlError = this.checkDidControlFail(error)\n\n      if (finalizeControlError) {\n        return finalizeControlError\n      }\n\n      return new UnhandledException(undefined, { cause: error })\n    }\n\n    let mapped: E | Promise<E>\n\n    try {\n      mapped = this.#catchFn(error)\n    } catch (catchError) {\n      throw new Panic(\"RUN_CATCH_HANDLER_THROW\", { cause: catchError })\n    }\n\n    if (checkIsPromiseLike(mapped)) {\n      try {\n        return await this.race(mapped, error)\n      } catch (catchError) {\n        throw new Panic(\"RUN_CATCH_HANDLER_REJECT\", { cause: catchError })\n      }\n    }\n\n    // Control state can change while the catch handler runs, so check again\n    // before returning a mapped sync value.\n    const catchControlError = this.checkDidControlFail(error)\n\n    if (catchControlError) {\n      return catchControlError\n    }\n\n    return mapped\n  }\n\n  async #runAttemptLoop(attempt: number): Promise<T | E | RunnerError> {\n    let currentAttempt = attempt\n    let currentDecision: RetryDecision | undefined\n\n    // oxlint-disable-next-line typescript/no-unnecessary-condition\n    while (true) {\n      const controlBeforeAttempt = this.checkDidControlFail()\n\n      if (controlBeforeAttempt) {\n        return controlBeforeAttempt\n      }\n\n      if (currentDecision) {\n        // oxlint-disable-next-line no-await-in-loop\n        const delayControlResult = await this.waitForRetryDelay(currentDecision.delay)\n\n        if (delayControlResult) {\n          return delayControlResult\n        }\n\n        currentDecision = undefined\n      }\n\n      this.ctx.retry.attempt = currentAttempt\n\n      try {\n        const result = this.#tryFn(this.ctx as unknown as Ctx)\n\n        if (checkIsPromiseLike(result)) {\n          // oxlint-disable-next-line no-await-in-loop\n          const raced = await this.race(Promise.resolve(result))\n          return raced\n        }\n\n        return this.resolveSyncSuccess(result)\n      } catch (attemptError) {\n        // oxlint-disable-next-line no-await-in-loop\n        const resolved = await this.#resolveFailure(attemptError)\n\n        if (!(resolved instanceof RetryDirective)) {\n          return resolved\n        }\n\n        currentDecision = resolved.decision\n        currentAttempt += 1\n      }\n    }\n  }\n}\n\nexport function executeRun<T, Ctx extends BaseTryCtx>(\n  config: BuilderConfig,\n  input: RunTryFn<T, Ctx>\n): Promise<T | UnhandledException>\nexport function executeRun<T, E, Ctx extends BaseTryCtx>(\n  config: BuilderConfig,\n  input: AsyncRunInput<T, E, Ctx>\n): Promise<T | E | RunnerError>\nexport async function executeRun<T, E, Ctx extends BaseTryCtx>(\n  config: BuilderConfig,\n  input: AsyncRunInput<T, E, Ctx>\n): Promise<T | E | RunnerError> {\n  using execution = new RunExecution<T, E, Ctx>(config, input)\n  return await execution.execute()\n}\n",
    "import type { BuilderConfig } from \"../builder\"\nimport type { RunnerError } from \"./base\"\nimport type { BaseTryCtx, NonPromise } from \"./shared\"\nimport {\n  ControlError,\n  Panic,\n  RetryExhaustedError,\n  UnhandledException,\n  type PanicCode,\n} from \"../errors\"\nimport { checkIsPromiseLike, invariant } from \"../utils\"\nimport { BaseExecution, RetryDirective } from \"./base\"\n\nexport type SyncRunTryFn<T, Ctx extends BaseTryCtx = BaseTryCtx> = (ctx: Ctx) => NonPromise<T>\nexport type SyncRunCatchFn<E> = (error: unknown) => NonPromise<E>\n\nexport interface SyncRunOptions<T, E, Ctx extends BaseTryCtx = BaseTryCtx> {\n  try: SyncRunTryFn<T, Ctx>\n  catch: SyncRunCatchFn<E>\n}\n\nexport type SyncRunInput<T, E, Ctx extends BaseTryCtx = BaseTryCtx> =\n  | SyncRunTryFn<T, Ctx>\n  | SyncRunOptions<T, E, Ctx>\n\nfunction assertNotPromiseLike(value: unknown, code: PanicCode, message?: string): void {\n  invariant(\n    !checkIsPromiseLike(value),\n    new Panic(code, message === undefined ? undefined : { message })\n  )\n}\n\nclass RunSyncExecution<T, E, Ctx extends BaseTryCtx> extends BaseExecution<T | E | RunnerError> {\n  #catchFn: SyncRunCatchFn<E> | undefined\n  #tryFn: SyncRunTryFn<T, Ctx>\n\n  constructor(config: BuilderConfig, input: SyncRunInput<T, E, Ctx>) {\n    super(config)\n\n    this.#catchFn = typeof input === \"function\" ? undefined : input.catch\n    this.#tryFn = typeof input === \"function\" ? input : input.try\n  }\n\n  override execute(): T | E | RunnerError {\n    const result = super.execute()\n    assertNotPromiseLike(result, \"RUN_SYNC_WRAPPED_RESULT_PROMISE\")\n    return result\n  }\n\n  protected override executeCore(): T | E | RunnerError {\n    return this.#runAttemptLoop(1)\n  }\n\n  #resolveFailure(error: unknown): E | RunnerError | RetryDirective {\n    if (error instanceof Panic) {\n      throw error\n    }\n\n    if (error instanceof ControlError) {\n      return error\n    }\n\n    const controlError = this.checkDidControlFail(error)\n\n    if (controlError) {\n      return controlError\n    }\n\n    const retryDecision = this.buildRetryDecision(error)\n\n    if (retryDecision.shouldAttemptRetry) {\n      return new RetryDirective(retryDecision)\n    }\n\n    if (retryDecision.isRetryExhausted) {\n      return new RetryExhaustedError(undefined, { cause: error })\n    }\n\n    if (!this.#catchFn) {\n      // Even without a catch handler, cancellation/timeout may have won since\n      // the original failure was first observed.\n      const finalizeControlError = this.checkDidControlFail(error)\n\n      if (finalizeControlError) {\n        return finalizeControlError\n      }\n\n      return new UnhandledException(undefined, { cause: error })\n    }\n\n    let mapped: E\n\n    try {\n      mapped = this.#catchFn(error)\n    } catch (catchError) {\n      throw new Panic(\"RUN_SYNC_CATCH_HANDLER_THROW\", { cause: catchError })\n    }\n\n    assertNotPromiseLike(mapped, \"RUN_SYNC_CATCH_PROMISE\")\n\n    // Control state can change while the catch handler runs, so check again\n    // before returning a mapped sync value.\n    const catchControlError = this.checkDidControlFail(error)\n\n    if (catchControlError) {\n      return catchControlError\n    }\n\n    return mapped\n  }\n\n  #runAttemptLoop(attempt: number): T | E | RunnerError {\n    let currentAttempt = attempt\n\n    // oxlint-disable-next-line typescript/no-unnecessary-condition\n    while (true) {\n      const controlBeforeAttempt = this.checkDidControlFail()\n\n      if (controlBeforeAttempt) {\n        return controlBeforeAttempt\n      }\n\n      this.ctx.retry.attempt = currentAttempt\n\n      let result: NonPromise<T>\n\n      try {\n        result = this.#tryFn(this.ctx as unknown as Ctx)\n      } catch (error) {\n        const resolved = this.#resolveFailure(error)\n\n        if (resolved instanceof RetryDirective) {\n          if (resolved.decision.delay > 0) {\n            throw new Panic(\"RUN_SYNC_ASYNC_RETRY_POLICY\")\n          }\n\n          currentAttempt += 1\n          continue\n        }\n\n        return resolved\n      }\n\n      assertNotPromiseLike(result, \"RUN_SYNC_TRY_PROMISE\")\n\n      return this.resolveSyncSuccess(result)\n    }\n  }\n}\n\nexport function executeRunSync<T, Ctx extends BaseTryCtx>(\n  config: BuilderConfig,\n  input: SyncRunTryFn<T, Ctx>\n): T | UnhandledException | RunnerError\nexport function executeRunSync<T, E, Ctx extends BaseTryCtx>(\n  config: BuilderConfig,\n  input: SyncRunInput<T, E, Ctx>\n): T | E | RunnerError\nexport function executeRunSync<T, E, Ctx extends BaseTryCtx>(\n  config: BuilderConfig,\n  input: SyncRunInput<T, E, Ctx>\n): T | E | RunnerError {\n  // Builder typing blocks async-only retry policies, but direct executor usage and\n  // unsafe casts still need a runtime guard here.\n  const isSyncSafeRetryPolicy =\n    config.retry === undefined ||\n    (config.retry.backoff === \"constant\" &&\n      !config.retry.jitter &&\n      (config.retry.delayMs ?? 0) <= 0)\n\n  invariant(isSyncSafeRetryPolicy, new Panic(\"RUN_SYNC_ASYNC_RETRY_POLICY\"))\n\n  using execution = new RunSyncExecution<T, E, Ctx>(config, input)\n  return execution.execute()\n}\n",
    "import type {\n  CancellationError,\n  RetryExhaustedError,\n  TimeoutError,\n  UnhandledException,\n} from \"./errors\"\nimport type {\n  InferredTaskContext,\n  TaskRecord,\n  TaskResult,\n  TaskValidation,\n  AllOptions,\n  AllSettledResult,\n  TryCtx,\n  TryCtxFor,\n} from \"./executors/shared\"\nimport type { RetryOptions, RetryPolicy } from \"./modifiers/retry\"\nimport { Panic } from \"./errors\"\nimport { executeAll } from \"./executors/all\"\nimport { executeAllSettled } from \"./executors/all-settled\"\nimport { executeFlow, type FlowResult, type InferredFlowTaskContext } from \"./executors/flow\"\nimport { executeRun, type AsyncRunInput, type RunTryFn } from \"./executors/run\"\nimport { executeRunSync, type SyncRunInput, type SyncRunTryFn } from \"./executors/run-sync\"\nimport { retryOptions } from \"./modifiers/retry\"\nimport { invariant } from \"./utils\"\n\n/**\n * Wraps are observational hooks: they can inspect execution context and\n * surround execution, but they must not mutate context or replace it.\n */\nexport type WrapCtx = Readonly<Omit<TryCtx, \"retry\">> & {\n  readonly retry: Readonly<TryCtx[\"retry\"]>\n}\n\ntype WrapFn = (ctx: WrapCtx, next: () => unknown) => unknown\n\nexport interface BuilderConfig {\n  /**\n   * Retry configuration applied to the run.\n   */\n  retry?: RetryPolicy\n  /**\n   * Timeout configuration applied to the run.\n   */\n  timeout?: number\n  /**\n   * Abort signals used to cancel execution.\n   */\n  signals?: AbortSignal[]\n  /**\n   * Wrapper middleware chain around execution.\n   */\n  wraps?: WrapFn[]\n}\n\ntype ConfigRunErrors = RetryExhaustedError | TimeoutError | CancellationError\ntype OrchestrationMethods = \"all\" | \"allSettled\" | \"flow\"\ntype SignalBuilderHiddenMethods<SupportsOrchestration extends boolean> =\n  | \"runSync\"\n  | \"wrap\"\n  | (SupportsOrchestration extends true ? never : OrchestrationMethods)\ntype ExecutionBuilderSurface<E extends ConfigRunErrors, HasRetry extends boolean> = Omit<\n  RunBuilder<E, HasRetry, false>,\n  OrchestrationMethods | \"wrap\"\n>\ntype AsyncExecutionBuilderSurface<E extends ConfigRunErrors, HasRetry extends boolean> = Omit<\n  RunBuilder<E, HasRetry, false>,\n  OrchestrationMethods | \"runSync\" | \"wrap\"\n>\ntype SignalBuilderSurface<\n  E extends ConfigRunErrors,\n  HasRetry extends boolean,\n  SupportsOrchestration extends boolean,\n> = Omit<\n  RunBuilder<E, HasRetry, SupportsOrchestration>,\n  SignalBuilderHiddenMethods<SupportsOrchestration>\n>\n\nexport class RunBuilder<\n  E extends ConfigRunErrors = never,\n  HasRetry extends boolean = false,\n  SupportsOrchestration extends boolean = true,\n> {\n  protected readonly config: BuilderConfig\n\n  constructor(config: BuilderConfig = {}) {\n    this.config = config\n  }\n\n  protected buildRetryConfig(policy: RetryOptions): BuilderConfig {\n    const limit = typeof policy === \"number\" ? policy : policy.limit\n\n    invariant(Number.isFinite(limit), new Panic(\"RETRY_INVALID_LIMIT\"))\n    invariant(limit >= 0, new Panic(\"RETRY_INVALID_LIMIT\"))\n\n    return {\n      ...this.config,\n      retry: retryOptions(policy),\n    }\n  }\n\n  protected buildTimeoutConfig(ms: number): BuilderConfig {\n    invariant(Number.isFinite(ms), new Panic(\"TIMEOUT_INVALID_MS\"))\n    invariant(ms >= 0, new Panic(\"TIMEOUT_INVALID_MS\"))\n\n    return {\n      ...this.config,\n      timeout: ms,\n    }\n  }\n\n  protected buildSignalConfig(signal: AbortSignal): BuilderConfig {\n    return {\n      ...this.config,\n      signals: [...(this.config.signals ?? []), signal],\n    }\n  }\n\n  retry(policy: number): ExecutionBuilderSurface<E | RetryExhaustedError, true>\n  retry(policy: RetryOptions): AsyncExecutionBuilderSurface<E | RetryExhaustedError, true>\n  retry(policy: RetryOptions): ExecutionBuilderSurface<E | RetryExhaustedError, true> {\n    return new ExecutionBuilder(this.buildRetryConfig(policy))\n  }\n\n  timeout(ms: number): AsyncExecutionBuilderSurface<E | TimeoutError, HasRetry> {\n    return new ExecutionBuilder(this.buildTimeoutConfig(ms))\n  }\n\n  signal(\n    signal: AbortSignal\n  ): SignalBuilderSurface<E | CancellationError, HasRetry, SupportsOrchestration> {\n    if (this instanceof ExecutionBuilder) {\n      return new ExecutionBuilder(\n        this.buildSignalConfig(signal)\n      ) as unknown as SignalBuilderSurface<E | CancellationError, HasRetry, SupportsOrchestration>\n    }\n\n    return new RunBuilder(this.buildSignalConfig(signal)) as unknown as SignalBuilderSurface<\n      E | CancellationError,\n      HasRetry,\n      SupportsOrchestration\n    >\n  }\n\n  wrap(fn: WrapFn): RunBuilder<E, HasRetry, SupportsOrchestration> {\n    return new RunBuilder({\n      ...this.config,\n      wraps: [...(this.config.wraps ?? []), fn],\n    })\n  }\n\n  run<T>(tryFn: RunTryFn<T, TryCtxFor<HasRetry>>): Promise<T | UnhandledException | E>\n  run<T, C>(options: AsyncRunInput<T, C, TryCtxFor<HasRetry>>): Promise<T | C | E>\n  run<T, C>(input: AsyncRunInput<T, C, TryCtxFor<HasRetry>>) {\n    return executeRun(this.config, input)\n  }\n\n  runSync<T>(tryFn: SyncRunTryFn<T, TryCtxFor<HasRetry>>): T | UnhandledException | E\n  runSync<T, C>(input: SyncRunInput<T, C, TryCtxFor<HasRetry>>): T | C | E\n  runSync<T, C>(input: SyncRunInput<T, C, TryCtxFor<HasRetry>>) {\n    return executeRunSync(this.config, input)\n  }\n\n  all<T extends TaskRecord, C = never>(\n    tasks: T & TaskValidation<NoInfer<T>> & ThisType<InferredTaskContext<T>>,\n    options?: AllOptions<T, C>\n  ): Promise<{ [K in keyof T]: TaskResult<T[K]> } | C> {\n    return executeAll(this.config, tasks, options)\n  }\n\n  allSettled<T extends TaskRecord>(\n    tasks: T & TaskValidation<NoInfer<T>> & ThisType<InferredTaskContext<T>>\n  ): Promise<AllSettledResult<T>> {\n    return executeAllSettled(this.config, tasks)\n  }\n\n  flow<T extends TaskRecord>(\n    tasks: T & ThisType<InferredFlowTaskContext<T>>\n  ): Promise<FlowResult<T>> {\n    return executeFlow(this.config, tasks)\n  }\n}\n\nclass ExecutionBuilder<\n  E extends ConfigRunErrors = never,\n  HasRetry extends boolean = false,\n> extends RunBuilder<E, HasRetry, false> {\n  constructor(config: BuilderConfig = {}) {\n    super(config)\n\n    // Retry/timeout chains must not silently keep orchestration entrypoints at\n    // runtime, even though the type surface already removes them.\n    Object.defineProperties(this, {\n      all: { configurable: true, value: undefined, writable: false },\n      allSettled: { configurable: true, value: undefined, writable: false },\n      flow: { configurable: true, value: undefined, writable: false },\n      wrap: { configurable: true, value: undefined, writable: false },\n    })\n  }\n}\n",
    "export function dispose(): AsyncDisposableStack {\n  return new AsyncDisposableStack()\n}\n",
    "import { checkIsPromiseLike } from \"./utils\"\n\ntype GenUnwrap<T> = Exclude<Awaited<T>, Error>\nexport type GenUse = <T>(value: T) => Generator<T, GenUnwrap<T>, GenUnwrap<T>>\n\ntype GenErrors<TYield> = Extract<Awaited<TYield>, Error>\ntype CheckIsAsync<TYield, TReturn> =\n  Extract<TYield | TReturn, PromiseLike<unknown>> extends never ? false : true\n\nexport type GenResult<TYield, TReturn> =\n  CheckIsAsync<TYield, TReturn> extends true\n    ? Promise<Awaited<TReturn> | GenErrors<TYield>>\n    : Awaited<TReturn> | GenErrors<TYield>\n\nfunction* use<T>(value: T): Generator<T, GenUnwrap<T>, GenUnwrap<T>> {\n  return yield value\n}\n\nasync function executeAsyncGenerator<TYield, TReturn>(\n  iterator: Generator<TYield, TReturn, unknown>,\n  initialStep: IteratorResult<TYield, TReturn>\n): Promise<Awaited<TReturn> | GenErrors<TYield>> {\n  let currentStep = initialStep\n\n  // oxlint-disable-next-line typescript/no-unnecessary-condition\n  while (true) {\n    if (currentStep.done) {\n      if (checkIsPromiseLike(currentStep.value)) {\n        // oxlint-disable-next-line no-await-in-loop\n        return await currentStep.value\n      }\n\n      return currentStep.value as Awaited<TReturn>\n    }\n\n    let currentValue: unknown\n\n    if (checkIsPromiseLike(currentStep.value)) {\n      try {\n        // oxlint-disable-next-line no-await-in-loop\n        currentValue = await currentStep.value\n      } catch (error) {\n        currentStep = iterator.throw(error)\n        continue\n      }\n    } else {\n      currentValue = currentStep.value\n    }\n\n    if (currentValue instanceof Error) {\n      return currentValue as GenErrors<TYield>\n    }\n\n    currentStep = iterator.next(currentValue)\n  }\n}\n\nexport function driveGen<TYield, TReturn>(\n  factory: (useFn: GenUse) => Generator<TYield, TReturn, unknown>\n): GenResult<TYield, TReturn> {\n  const iterator = factory(use)\n\n  let currentValue: unknown = undefined\n\n  // oxlint-disable-next-line typescript/no-unnecessary-condition\n  while (true) {\n    const step = iterator.next(currentValue)\n\n    if (step.done) {\n      if (checkIsPromiseLike(step.value)) {\n        return Promise.resolve(step.value) as GenResult<TYield, TReturn>\n      }\n\n      return step.value as GenResult<TYield, TReturn>\n    }\n\n    if (checkIsPromiseLike(step.value)) {\n      return executeAsyncGenerator(iterator, step) as GenResult<TYield, TReturn>\n    }\n\n    if (step.value instanceof Error) {\n      return step.value as GenResult<TYield, TReturn>\n    }\n\n    currentValue = step.value\n  }\n}\n",
    "import { RunBuilder } from \"./lib/builder\"\n\nconst root = new RunBuilder()\n\nexport const all: RunBuilder[\"all\"] = root.all.bind(root)\nexport const allSettled: RunBuilder[\"allSettled\"] = root.allSettled.bind(root)\nexport const flow: RunBuilder[\"flow\"] = root.flow.bind(root)\nexport const retry: RunBuilder[\"retry\"] = root.retry.bind(root)\nexport const run: RunBuilder[\"run\"] = root.run.bind(root)\nexport const runSync: RunBuilder[\"runSync\"] = root.runSync.bind(root)\nexport const signal: RunBuilder[\"signal\"] = root.signal.bind(root)\nexport const timeout: RunBuilder[\"timeout\"] = root.timeout.bind(root)\nexport const wrap: RunBuilder[\"wrap\"] = root.wrap.bind(root)\n\nexport { dispose } from \"./lib/dispose\"\nexport { driveGen as gen } from \"./lib/gen\"\n\nexport { retryOptions } from \"./lib/modifiers/retry\"\n"
  ],
  "mappings": "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",
  "debugId": "DACEA87E974540E264756E2164756E21",
  "names": []
}