import { t as HKT } from "./hkt-C84w3kEn.mjs";
import { Err, Result, UnhandledException } from "better-result";

//#region src/tagged.d.ts
interface Tagged<Tag extends string> {
  readonly _tag: Tag;
}
type AbstractCtor = abstract new (...args: readonly never[]) => object;
type TaggedConstructor<Tag extends string, Base extends AbstractCtor | undefined> = Base extends undefined ? new () => Tagged<Tag> : Base extends AbstractCtor ? new (...args: ConstructorParameters<Base>) => InstanceType<Base> & Tagged<Tag> : never;
declare function Tagged<Tag extends string>(tag: Tag): TaggedConstructor<Tag, undefined>;
declare function Tagged<Tag extends string, Base extends AbstractCtor>(tag: Tag, Base: Base): TaggedConstructor<Tag, Base>;
//#endregion
//#region src/errors.d.ts
declare const TimeoutError_base: import("better-result").TaggedErrorClass<"TimeoutError">;
/**
 * Built-in typed error emitted when an operation exceeds a timeout budget
 */
declare class TimeoutError extends TimeoutError_base<{
  message: string;
  timeoutMs: number;
}> {
  constructor({
    timeoutMs
  }: {
    timeoutMs: number;
  });
}
declare const ErrorGroup_base: new (errors: Iterable<any>, message?: string | undefined, options?: ErrorOptions | undefined) => AggregateError & Tagged<"ErrorGroup">;
/** A typed aggregate error used when an operation must preserve multiple failures. */
declare class ErrorGroup<E> extends ErrorGroup_base {
  readonly errors: E[];
  constructor(errors: Iterable<E>, message: string);
  [Symbol.iterator](): Generator<Err<never, this>, never, unknown>;
  static is(value: unknown): value is ErrorGroup<unknown>;
}
//#endregion
//#region src/execution/abort-settlement.d.ts
/**
 * Driver-level abort mechanics for suspended work and nested plan execution.
 *
 * Contributor call sites declare intent through `Settlement` in `settlement.ts`.
 * Suspend work wrapped with {@link withAbortDrain} maps to
 * {@link AbortSettlement.interruptAndDrainOnAbort} when the enclosing suspend uses
 * {@link AbortSettlement.interruptOnAbort} (see {@link settlementForSuspendedWork}).
 */
type AbortSettlement = {
  readonly kind: "passThrough";
} | {
  readonly kind: "rejectOnAbort";
  readonly getAbortReason: () => unknown;
} | {
  readonly kind: "interruptOnAbort";
  readonly getAbortReason: () => unknown;
} | {
  readonly kind: "interruptAndDrainOnAbort";
  readonly getAbortReason: () => unknown;
};
declare const AbortSettlement: {
  passThrough: {
    readonly kind: "passThrough";
  };
  rejectOnAbort(getAbortReason: () => unknown): AbortSettlement;
  interruptOnAbort(getAbortReason: () => unknown): AbortSettlement;
  interruptAndDrainOnAbort(getAbortReason: () => unknown): AbortSettlement;
};
declare const ABORT_DRAINED_WORK: unique symbol;
declare const ABORT_OWNED_WORK: unique symbol;
type AbortDrainedWork<T> = {
  readonly [ABORT_DRAINED_WORK]: true;
  readonly promise: PromiseLike<T>;
};
type AbortOwnedWork<T> = {
  readonly [ABORT_OWNED_WORK]: true;
  readonly promise: PromiseLike<T>;
};
/** Suspend callback return type: plain, drain-on-abort, or abort-owned work. */
type SuspendWork<T> = PromiseLike<T> | AbortDrainedWork<T> | AbortOwnedWork<T>;
//#endregion
//#region src/core/metadata.d.ts
declare const EMPTY_META: unique symbol;
declare const BLOCKING: unique symbol;
/**
 * Metadata merge algebra for composed operations.
 *
 * Operations carry extension metadata on `M`. When they compose (`flatMap`, combinators,
 * yielded custom instructions), {@link MergeMeta} accumulates requirements from both sides.
 *
 * {@link EmptyMeta} is the identity element: merging with empty metadata leaves the other
 * operand unchanged.
 *
 * Per-key merge outcomes:
 * - Keys present on only one side are kept as-is.
 * - Plain values at the same key union (requirements accumulate).
 * - When either side at a key is {@link Blocking}, the merged value is `Blocking` with
 *   payloads unioned. `Blocking` takes precedence over plain values at that key.
 *
 * {@link MergeMetaObjects} merges two object shapes key-by-key. {@link MergeUnionMeta} applies
 * the same rules when a generator yields multiple custom instructions. {@link CollectBlockingPayload}
 * extracts `Blocking` payload types during union merges so blocking requirements stay branded.
 */
type MergeBlockingValue<VA, VB> = VA extends Blocking<infer TA> ? VB extends Blocking<infer TB> ? Blocking<TA | TB> : Blocking<TA> : VB extends Blocking<infer TB> ? Blocking<TB> : VA | VB;
type MergeMetaValue<A, B, K extends PropertyKey> = K extends keyof StripEmpty<A> & keyof StripEmpty<B> ? MergeBlockingValue<StripEmpty<A>[K], StripEmpty<B>[K]> : K extends keyof StripEmpty<A> ? StripEmpty<A>[K] : K extends keyof StripEmpty<B> ? StripEmpty<B>[K] : never;
type MergeMetaObjects<A, B> = NormalizeMeta<{ [K in keyof StripEmpty<A> | keyof StripEmpty<B>]: MergeMetaValue<A, B, K> }>;
type UnionMetaValueAt<U, K extends PropertyKey> = U extends Record<K, infer V> ? V : never;
type CollectBlockingPayload<U, K extends PropertyKey> = U extends Record<K, Blocking<infer R>> ? R : never;
type MergeUnionMetaValue<U, K extends PropertyKey> = [CollectBlockingPayload<U, K>] extends [never] ? UnionMetaValueAt<U, K> : Blocking<CollectBlockingPayload<U, K>>;
type MergeUnionMeta<U> = NormalizeMeta<[U] extends [never] ? EmptyMeta : { [K in AllMetaKeys<U>]: MergeUnionMetaValue<U, K> }>;
/** Merges metadata accumulated across two composed operations. See merge algebra above. */
type MergeMeta<A, B> = IsAny<A> extends true ? any : IsAny<B> extends true ? any : [A] extends [EmptyMeta] ? NormalizeMeta<B> : [B] extends [EmptyMeta] ? NormalizeMeta<A> : MergeMetaObjects<A, MergeMetaRight<B>>;
type SetBlockingMeta<M, K extends PropertyKey, T> = NormalizeMeta<Simplify<StripEmpty<M> & { [P in K]: Blocking<T> }>>;
/** An operation that is not ready for top-level `.run()`. */
type BlockingOp<T, E, A, M = EmptyMeta, K extends PropertyKey = string, P = true> = Op<T, E, A, SetBlockingMeta<M, K, P>>;
/**
 * Marks an operation as needing extension-specific preconditions before
 * top-level `.run()` by placing `Blocking<P>` on a metadata key.
 */
declare function withBlocking<T, E, A, M, const K extends PropertyKey, P = true>(op: Op<T, E, A, M>, _key: K): BlockingOp<T, E, A, M, K, P>;
/**
 * Runnable gating from metadata.
 *
 * Top-level {@link BaseOp.run} is available only when every metadata key is satisfied.
 * {@link HasBlocking} is true when any key still carries {@link Blocking} with a non-empty
 * payload. {@link IsRunnable} is false in that case, so `.run()` is not on the operation type.
 *
 * Extension packages block `.run()` by attaching `Blocking` to metadata keys (or via
 * `withBlocking(...)`). Callers satisfy those requirements through extension-specific runners
 * first; clearing or replacing blocking metadata is what makes `.run()` type-check again.
 */
type IsRunnable<M> = IsAny<M> extends true ? true : [HasBlocking<M>] extends [true] ? false : true;
/** True when metadata still carries an unsatisfied {@link Blocking} requirement on any key. */
type HasBlocking<M> = keyof StripEmpty<M> extends never ? false : { [K in keyof StripEmpty<M>]: StripEmpty<M>[K] extends Blocking<infer R> ? [R] extends [never] ? false : true : false }[keyof StripEmpty<M>] extends true ? true : false;
/**
 * Empty metadata; the merge identity element.
 *
 * Operations with no extension requirements use `EmptyMeta`. Merging with `EmptyMeta` leaves
 * the other operand unchanged in both directions.
 */
type EmptyMeta = {
  readonly [EMPTY_META]: true;
};
/**
 * Branded metadata value that blocks top-level `.run()` until its payload is satisfied.
 *
 * During metadata merge, `Blocking` at a key takes precedence over plain values and unions
 * payloads with other `Blocking` values at the same key.
 */
type Blocking<T> = {
  readonly [BLOCKING]: T;
};
type IsAny<T> = 0 extends 1 & T ? true : false;
type NormalizeMeta<M> = [M] extends [never] ? EmptyMeta : M extends EmptyMeta ? EmptyMeta : M extends object ? keyof M extends never ? EmptyMeta : Simplify<M> : M;
type StripEmpty<M> = [M] extends [never] ? {} : M extends EmptyMeta ? {} : M;
type Simplify<T> = T extends object ? { [K in keyof T]: T[K] } : T;
type WithoutEmptyMeta<M> = M extends EmptyMeta ? never : M;
type MergeMetaRight<B> = [WithoutEmptyMeta<B>] extends [never] ? EmptyMeta : WithoutEmptyMeta<B>;
type AllMetaKeys<U> = U extends unknown ? keyof U : never;
//#endregion
//#region src/execution/instructions.d.ts
declare const CUSTOM_INSTRUCTION_META: unique symbol;
/**
 * Extension protocol for custom generator yield instructions.
 *
 * Implementations are detected at runtime via {@link CUSTOM_INSTRUCTION_META}
 * and executed through {@link CustomInstruction.resolve}.
 *
 * Typed failures should be surfaced by yielding {@link Err} values from
 * `[Symbol.iterator]` or from the enclosing generator; throws from `resolve`
 * surface as {@link UnhandledException}.
 */
interface CustomInstruction<T, M = EmptyMeta> {
  readonly [CUSTOM_INSTRUCTION_META]: M;
  resolve(context: RunContext<readonly unknown[]>): T | PromiseLike<T>;
  [Symbol.iterator](): Generator<this, T, unknown>;
}
type ExtractInstructionMeta<Y> = Y extends CustomInstruction<any, infer M> ? M : never;
type NonEmptyInstructionMeta<Y> = Exclude<ExtractInstructionMeta<Y>, EmptyMeta>;
type InferInstructionMeta<Y> = [NonEmptyInstructionMeta<Y>] extends [never] ? EmptyMeta : MergeUnionMeta<NonEmptyInstructionMeta<Y>>;
type DropUnknown<E> = unknown extends E ? never : E;
type ExtractResultErr<Y> = Y extends Err<unknown, infer E> ? DropUnknown<E> : never;
type InferInstructionErr<Y> = ExtractResultErr<Y>;
type SuspendFn = (ctx: RunContext<readonly unknown[]>) => SuspendWork<unknown>;
declare const SuspendInstruction_base: new () => Tagged<"SuspendInstruction">;
declare class SuspendInstruction extends SuspendInstruction_base {
  readonly suspend: SuspendFn;
  constructor(suspend: SuspendFn);
  [Symbol.iterator](): Generator<Instruction<never, any>, any, unknown>;
}
type FinalizeFn = (ctx: ExitContext<unknown, unknown, readonly unknown[]>) => PromiseLike<void>;
declare const RegisterExitFinalizerInstruction_base: new () => Tagged<"RegisterExitFinalizerInstruction">;
declare class RegisterExitFinalizerInstruction extends RegisterExitFinalizerInstruction_base {
  readonly finalize: FinalizeFn;
  readonly args: readonly unknown[] | undefined;
  constructor(finalize: FinalizeFn, args: readonly unknown[] | undefined);
}
declare const NestedOpInstruction_base: new () => Tagged<"NestedOpInstruction">;
/** Internal driver instruction for direct Op-to-Op generator delegation. */
declare class NestedOpInstruction<T, E, M = EmptyMeta> extends NestedOpInstruction_base {
  readonly iterate: () => Generator<RuntimeInstruction<E, M>, T, unknown>;
  readonly finalizerArgs: readonly unknown[] | undefined;
  constructor(iterate: () => Generator<RuntimeInstruction<E, M>, T, unknown>, finalizerArgs?: readonly unknown[]);
}
type Instruction<E, M = EmptyMeta> = Err<unknown, E> | SuspendInstruction | RegisterExitFinalizerInstruction | CustomInstruction<unknown, M>;
/** Driver instruction set. Kept separate so NestedOpInstruction is not part of the extension API. */
type RuntimeInstruction<E, M = EmptyMeta> = Instruction<E, M> | NestedOpInstruction<unknown, E, M>;
//#endregion
//#region src/policy/retry-policy.d.ts
/**
 * Retry delay configuration for `RetryPolicy.delay`: fixed milliseconds or
 * `(retry, cause) => ms` before an upcoming retry (`retry` is 0-based). For built-in delay
 * functions, use the `Delay` helper namespace (`Delay.fixed`, `Delay.exponential`, and so on).
 */
type Delay = number | ((retry: number, cause: unknown) => number);
/** Configuration for `Policy.retry(policy)`. `retries` is the post-failure budget; `delay(retry, cause)` uses a 0-based retry index. */
interface RetryPolicy {
  /** How many times to retry after the first failure. */
  retries?: number;
  /** Whether to retry after a failure. Receives the root cause. */
  when?: (cause: unknown) => boolean;
  /** Delay before the next retry: fixed milliseconds or `(retry, cause) => ms`. */
  delay?: Delay;
}
/** Options for `Delay.exponential(options)`. */
interface ExponentialDelayOptions {
  /** Initial delay in milliseconds. */
  baseMs?: number;
  /** Maximum delay in milliseconds. */
  maxMs?: number;
  /** Fraction of the computed delay to randomize, from `0` to `1`. */
  jitter?: number;
}
declare const DELAY_VALIDATE: unique symbol;
type ValidatedDelay = ((retry: number, cause: unknown) => number) & {
  readonly [DELAY_VALIDATE]: () => void;
};
/** Built-in retry delay helpers for `RetryPolicy.delay`. See also the `Delay` type alias. */
declare const Delay: Readonly<{
  /** Constant delay in milliseconds before each retry attempt. */fixed: (ms: number) => ValidatedDelay; /** Exponential backoff: `baseMs * 2 ** retry`, capped at `maxMs`. */
  exponential: (options?: ExponentialDelayOptions) => ValidatedDelay; /** Zero delay between retries. */
  immediate: ValidatedDelay; /** Default exponential backoff used by `Policy.retry()` with no policy argument. */
  defaultRetry: ValidatedDelay;
}>;
//#endregion
//#region src/policy/types.d.ts
declare const OP_POLICY: unique symbol;
declare const OP_POLICY_INPUT: unique symbol;
interface OpPolicyType extends HKT {
  readonly [HKT.TYPE]: Op<HKT.Param<this, 0>, HKT.Param<this, 1>, HKT.Param<this, 2>, HKT.Param<this, 3>>;
}
interface OpPolicyInput<T = unknown, E = unknown, A = unknown, M = unknown> {
  readonly ok: T;
  readonly err: E;
  readonly args: A;
  readonly meta: M;
}
interface OpPolicySource<T, E, A, M> {
  wrap<TNext, ENext, MNext>(transform: (plan: Plan<T, E, M>) => Plan<TNext, ENext, MNext>): Op<TNext, ENext, A, MNext>;
  rewrite<TNext, ENext, MNext>(rewriter: PlanRewriter): Op<TNext, ENext, A, MNext>;
  around<TNext, ENext, MNext = M>(run: (next: (context: RunContext<readonly unknown[]>) => Promise<Result<T, E | UnhandledException>>, context: RunContext<readonly unknown[]>) => PromiseLike<Result<TNext, ENext | UnhandledException>>): Op<TNext, ENext, A, MNext>;
}
interface OpPolicy<Input = unknown, F extends HKT = OpPolicyType> {
  readonly [OP_POLICY]: F;
  readonly [OP_POLICY_INPUT]?: (input: Input) => void;
  apply<T, E, A, M>(source: OpPolicySource<T, E, A, M>): HKT.Apply<F, [T, E, A, M]>;
}
/**
 * Builds a custom policy value for `.with(Policy.define(...))`.
 * Use `source.wrap`, `source.rewrite`, or `source.around` inside `apply` to transform the wrapped op.
 */
declare function define<Input, F extends HKT, Extras extends object = Record<never, never>>(definition: Extras & {
  apply<T, E, A, M>(source: OpPolicySource<T, E, A, M>): HKT.Apply<F, [T, E, A, M]>;
}): OpPolicy<Input, F> & Extras;
interface TimeoutPolicyType extends HKT {
  readonly [HKT.TYPE]: Op<HKT.Param<this, 0>, HKT.Param<this, 1> | TimeoutError, HKT.Param<this, 2>, HKT.Param<this, 3>>;
}
type RetryPolicyAttachment = OpPolicy<unknown, OpPolicyType> & {
  readonly policy: RetryPolicy | undefined;
};
type TimeoutPolicyAttachment = OpPolicy<unknown, TimeoutPolicyType> & {
  readonly timeoutMs: number;
};
type CancelPolicyAttachment = OpPolicy<unknown, OpPolicyType> & {
  readonly abortSignal: AbortSignal;
};
type ReleasePolicyAttachment<T> = OpPolicy<OpPolicyInput<T>, OpPolicyType> & {
  readonly release: ReleaseFn<T>;
};
type BuiltInPolicy<T = unknown> = RetryPolicyAttachment | TimeoutPolicyAttachment | CancelPolicyAttachment | ReleasePolicyAttachment<T>;
//#endregion
//#region src/core/surface.d.ts
type TrackedErr<E, Excluded = never> = E extends UnhandledException ? never : E extends TimeoutError ? never : E extends Excluded ? never : E;
type BypassedErr<E> = E extends TimeoutError ? E : never;
type InferOpOk<R> = R extends Op<infer T, any, [], any> ? T : Awaited<R>;
type InferOpErr<R> = R extends Op<any, infer E, [], any> ? E : never;
type InferOpMeta<R> = R extends Op<any, any, infer _A, infer M> ? NormalizeMeta<M> : EmptyMeta;
type AnyNullaryOp = Op<any, any, [], any>;
interface BaseOp<T, E, A, M = EmptyMeta> {
  /** Type discriminant for an `Op` instance. */
  readonly _tag: "Op";
  /** Provides the operation with runtime arguments. */
  (...args: AsArgs<A>): Op<T, E, [], M>;
  /**
   * Executes the operation with runtime arguments and returns a `Result`.
   *
   * @example
   * const result = await Op.of(1).run();
   */
  run: [IsRunnable<M>] extends [false] ? never : (...args: AsArgs<A>) => Promise<Result<T, E | UnhandledException>>;
}
interface FluentOp<T, E, A, M = EmptyMeta> {
  /**
   * Attaches an execution policy to the operation.
   *
   * @example
   * import { Policy } from "@prodkit/op/policy";
   * const resilient = Op.try(() => fetch("/ping")).with(Policy.retry());
   */
  with<F extends HKT>(policy: OpPolicy<OpPolicyInput<T, E, AsArgs<A>, M>, F>): HKT.Apply<F, [T, E, AsArgs<A>, M]>;
  /**
   * Register a handler that runs before the operation body starts.
   *
   * @example
   * const withEnter = Op.of(1).on("enter", () => console.log("start"));
   */
  on(event: "enter", initialize: EnterFn<A>): Op<T, E, A, M>;
  /**
   * Register a handler that runs after the operation settles.
   *
   * @example
   * const withExit = Op.of(1).on("exit", () => console.log("done"));
   */
  on(event: "exit", finalize: ExitFn<T, E, A>): Op<T, E, A, M>;
  /**
   * Transforms the success value while preserving args and error channel.
   *
   * @example
   * const mapped = Op.of(2).map((n) => n * 2);
   */
  map<U>(transform: (value: T) => U): Op<Awaited<U>, E, A, M>;
  /**
   * Transforms the tracked typed error channel while preserving success values.
   *
   * @example
   * const mappedError = Op.fail("x" as const).mapErr((e) => ({ code: e }));
   */
  mapErr<E2>(transform: (error: TrackedErr<E>) => E2): Op<T, E2 | BypassedErr<E>, A, M>;
  /**
   * Binds the success value into the next operation.
   *
   * @example
   * const chained = Op.of(1).flatMap((n) => Op.of(n + 1));
   */
  flatMap<R extends AnyNullaryOp>(bind: (value: T) => R): Op<InferOpOk<R>, E | InferOpErr<R>, A, MergeMeta<M, InferOpMeta<R>>>;
  /**
   * Observes successful values without changing the success payload.
   *
   * @example
   * const observed = Op.of(1).tap((n) => console.log(n));
   */
  tap<R>(observe: (value: T) => R): Op<T, E, A, M>;
  /**
   * Observes tracked errors without changing the original success payload.
   *
   * @example
   * const observedError = Op.fail("x" as const).tapErr((e) => console.error(e));
   */
  tapErr<R>(observe: (error: TrackedErr<E>) => R): Op<T, TrackedErr<E> | BypassedErr<E>, A, M>;
  /**
   * Recovers selected typed failures into a fallback value.
   * Wrap methods such as `MyError.is` so the tagged-error guard keeps its class receiver.
   *
   * @example
   * class NotFoundError extends TaggedError("NotFoundError") {}
   * const isNotFoundError = (error: unknown) => NotFoundError.is(error);
   * const recovered = Op.fail(new NotFoundError()).recover(
   *   isNotFoundError,
   *   () => ({ id: "fallback" }),
   * );
   */
  recover<ECaught extends TrackedErr<E>, R>(predicate: (error: TrackedErr<E>) => error is ECaught, handler: (error: ECaught) => R): Op<T | Awaited<R>, TrackedErr<E, ECaught> | BypassedErr<E>, A, M>;
}
interface OpIterable<T, E, M = EmptyMeta> {
  [Symbol.iterator](): Generator<Instruction<E, M>, T, unknown>;
}
type OpInterface<T, E, A, M = EmptyMeta, Yieldable extends boolean = (A extends [] ? true : false)> = BaseOp<T, E, A, M> & FluentOp<T, E, A, M> & (Yieldable extends true ? OpIterable<T, E, M> : {});
type AsArgs<T> = T extends readonly unknown[] ? T : never;
//#endregion
//#region src/plan/model.d.ts
declare const PLAN_UNARY_REWRITE: unique symbol;
type PlanInstruction<_E, M> = RuntimeInstruction<unknown, M>;
type PlanIterator<T, E, M> = Generator<PlanInstruction<E, M>, T, unknown>;
type ErasedPlan = Plan<unknown, unknown, unknown>;
type UnaryPlanRewrite = {
  readonly source: ErasedPlan;
  readonly rebuild: (rewrittenSource: ErasedPlan) => ErasedPlan;
};
interface Plan<T, E, M = EmptyMeta> {
  readonly execute: (context: RunContext<readonly unknown[]>, settlement?: AbortSettlement) => Promise<Result<T, E | UnhandledException>>;
  readonly [PLAN_UNARY_REWRITE]?: UnaryPlanRewrite;
  readonly iterate: () => PlanIterator<T, E, M>;
  readonly rewrite: <TNext, ENext, MNext>(rewriter: PlanRewriter) => Plan<TNext, ENext, MNext>;
}
/**
 * Internal rewrite protocol for policy attachment. Built-in policies supply `apply` to wrap leaf
 * plans; wrapper nodes rebuild themselves via `source.rewrite(rewriter)` (see `rewriteUnaryPlan`).
 *
 * When adding a new fluent transform, see "Adding a fluent plan transform" in
 * `docs/contributor/runtime-architecture.md`.
 */
interface PlanRewriter {
  readonly apply: <T, E, M>(source: Plan<T, E, M>) => Plan<unknown, unknown, unknown>;
}
//#endregion
//#region src/execution/runtime.d.ts
/** Runtime execution context threaded through internal driver/suspend boundaries. */
interface RunContext<A = []> {
  readonly signal: AbortSignal;
  readonly args: A;
  readonly extensions: ReadonlyMap<unknown, unknown>;
}
/**
 * Passed to {@link ExitFn} when the run unwinds.
 *
 * - `args` are the runtime inputs for this run
 * - `result` is the operation's pre-finalizer settlement result
 *   (including {@link UnhandledException} on the error channel when relevant).
 *   If a finalizer throws, `.run()` returns a new cleanup-failure result instead.
 */
interface ExitContext<T, E, A = []> {
  readonly signal: AbortSignal;
  readonly args: A;
  readonly result: Result<T, E | UnhandledException>;
}
//#endregion
//#region src/core/lifecycle.d.ts
/** Passed to {@link EnterFn} when a run starts, before the wrapped operation body begins. */
interface EnterContext<A = []> {
  readonly signal: AbortSignal;
  readonly args: A;
}
type EnterFn<A> = (ctx: EnterContext<A>) => unknown;
type ExitFn<T = unknown, E = unknown, A = []> = (ctx: ExitContext<T, E, A>) => unknown;
/** Widened hook for {@link builders.defer} where enclosing `Op` `T`/`E` are not inferred. */
type AnyExitFn = ExitFn<unknown, unknown, readonly unknown[]>;
type ReleaseFn<T> = (value: T) => unknown;
/** Lifecycle channels exposed by {@link Op}. */
type OpLifecycleHook = "enter" | "exit";
//#endregion
//#region src/core/builders.d.ts
declare function succeed<T>(value: T | PromiseLike<T>): Op<Awaited<T>, never, [], EmptyMeta>;
declare function fail<E>(value: E): Op<never, E, [], EmptyMeta>;
declare function defer(finalize: AnyExitFn): Op<void, never, [], EmptyMeta>;
declare function sleep(ms: number): Op<void, never, [], EmptyMeta>;
declare function _try<T, E = UnhandledException>(f: (signal: AbortSignal) => T, onError?: (e: unknown) => E | PromiseLike<E>): Op<Awaited<T>, TrackedErr<Awaited<E>>, [], EmptyMeta>;
/**
 * Turns a generator function into an {@link Op}
 */
declare function fromGenFn<Y extends Instruction<unknown, unknown>, T, A>(f: (...args: AsArgs<A>) => Generator<Y, T, unknown>): Op<T, InferInstructionErr<Y>, A, InferInstructionMeta<Y>>;
//#endregion
//#region src/core/combinators.d.ts
type MergeOpsMeta<Ops extends readonly AnyNullaryOp[]> = Ops extends readonly [infer Head extends AnyNullaryOp, ...infer Tail extends readonly AnyNullaryOp[]] ? MergeMeta<InferOpMeta<Head>, MergeOpsMeta<Tail>> : EmptyMeta;
type AllOpOk<Ops extends readonly AnyNullaryOp[]> = { [K in keyof Ops]: InferOpOk<Ops[K]> };
type AllOpErr<Ops extends readonly AnyNullaryOp[]> = InferOpErr<Ops[number]>;
declare function allOp<const Ops extends readonly AnyNullaryOp[]>(ops: Ops, concurrency?: number): Op<AllOpOk<Ops>, AllOpErr<Ops>, [], MergeOpsMeta<Ops>>;
type AllSettledOpOk<Ops extends readonly AnyNullaryOp[]> = { [K in keyof Ops]: Result<InferOpOk<Ops[K]>, InferOpErr<Ops[K]> | UnhandledException> };
declare function allSettledOp<const Ops extends readonly AnyNullaryOp[]>(ops: Ops, concurrency?: number): Op<AllSettledOpOk<Ops>, never, [], MergeOpsMeta<Ops>>;
declare function settleOp<T, E, M>(op: Op<T, E, [], M>): Op<Result<T, E | UnhandledException>, never, [], M>;
/**
 * helper to check if any op in the list has an infallible error type
 */
type HasInfallibleOp<Ops extends readonly AnyNullaryOp[]> = Ops extends readonly [infer Head extends AnyNullaryOp, ...infer Tail extends readonly AnyNullaryOp[]] ? [InferOpErr<Head>] extends [never] ? true : HasInfallibleOp<Tail> : false;
type AnyOpOk<Ops extends readonly AnyNullaryOp[]> = InferOpOk<Ops[number]>;
type AnyOpErr<Ops extends readonly AnyNullaryOp[]> = HasInfallibleOp<Ops> extends true ? never : ErrorGroup<InferOpErr<Ops[number]>>;
declare function anyOp<const Ops extends readonly AnyNullaryOp[]>(ops: Ops): Op<AnyOpOk<Ops>, AnyOpErr<Ops>, [], MergeOpsMeta<Ops>>;
type RaceOpOk<Ops extends readonly AnyNullaryOp[]> = InferOpOk<Ops[number]>;
type RaceOpErr<Ops extends readonly AnyNullaryOp[]> = InferOpErr<Ops[number]>;
declare function raceOp<const Ops extends readonly AnyNullaryOp[]>(ops: Ops): Op<RaceOpOk<Ops>, RaceOpErr<Ops>, [], MergeOpsMeta<Ops>>;
//#endregion
//#region src/index.d.ts
/**
 * An operation that can be run and composed with other operations.
 *
 * - Runtime factory and namespace for building and composing operations.
 * - Call `Op(function* (...) { ... })` to build generator-based operations.
 * - Use static helpers (`Op.of`, `Op.fail`, `Op.try`, `Op.all`, `Op.any`, etc.)
 *   for common patterns.
 *
 * Use `Op.run(op)` to execute an operation directly. For external cancellation,
 *   compose with `.with(Policy.cancel(signal))` first and then run.
 *
 * @example
 * const op = Op(function* () {
 *   if (Math.random() > 0.5) {
 *     return yield* Op.fail("error");
 *   }
 *   return yield* Op.of(69);
 * });
 * const result = await op.run();
 * console.log(result);
 */
declare const Op: typeof fromGenFn & {
  /** Type discriminant for the `Op` factory namespace value. */_tag: "OpFactory";
  /**
   * Executes an operation with its runtime arguments and resolves to its `Result<T, E | UnhandledException>`.
   *
   * @example
   * const value = await Op.run(Op.of(1));
   */
  run: <T, E, A, M>(op: [IsRunnable<M>] extends [false] ? never : Op<T, E, A, M>, ...args: AsArgs<A>) => Promise<Result<T, E | UnhandledException>>;
  /**
   * Creates an operation that always succeeds with the provided value.
   *
   * Promise inputs are awaited before producing the success value.
   *
   * @example
   * const value = Op.of(69);
   */
  of: typeof succeed;
  /**
   * Creates an operation that always fails with the provided typed error value.
   *
   * @example
   * const failed = Op.fail("bad-input" as const);
   */
  fail: typeof fail;
  /**
   * Registers an exit finalizer for the current run via `yield* Op.defer(...)`.
   *
   * If any callback throws during unwind, `run` fails with {@link UnhandledException} whose `cause`
   * is an {@link ErrorGroup} (message `Operation cleanup failed`). Cleanup failures are exact
   * thrown values in LIFO execution order. When the body already failed, its error is the first
   * group entry.
   *
   * **Important**: Op.defer *must* be `yield*`ed or it will do nothing
   *
   * @note Should always be used inside an `Op(function* () { ... })` body.
   *
   * @example
   * const program = Op(function* () {
   *   yield* Op.defer(() => console.log("cleanup"));
   *   return 1;
   * });
   */
  defer: typeof defer;
  /**
   * Suspends the current operation for `ms` milliseconds.
   *
   * Negative durations are normalized to `0`. Non-finite durations fail at run time
   * with `UnhandledException`.
   * The sleep observes surrounding cancellation from `.with(Policy.cancel(...))`,
   * `.with(Policy.timeout(...))`, and combinators.
   *
   * @example
   * const delayed = Op(function* () {
   *   yield* Op.sleep(100);
   *   return "ready";
   * });
   */
  sleep: typeof sleep;
  /**
   * Lifts a sync or async callback into an operation.
   *
   * - Fulfillment returns `Ok`.
   * - Throw/reject is normalized to `UnhandledException` when `onError` is omitted.
   * - With `onError`, failures are mapped to your typed error.
   *
   * @example
   * const fetched = Op.try(() => fetch("/health"));
   *
   * @example
   * const fetched = Op.try(
   *   () => fetch("/health"),
   *   (cause) => new FetchError({ cause }),
   * );
   */
  try: typeof _try;
  /**
   * Runs nullary operations concurrently and preserves input order on success.
   *
   * `Op.all` fails fast on the first observed error, aborts remaining siblings,
   * and still waits for active losers to settle so cleanup/finalizers complete.
   *
   * @example
   * const pair = Op.all([Op.of(1), Op.of("ok")]);
   */
  all: typeof allOp;
  /**
   * Runs all branches and returns per-branch `Result` values in input order.
   *
   * Branch failures do not abort siblings. Invalid `concurrency` (non-integer or
   * less than 1) returns `Err(UnhandledException)` at run time.
   *
   * @example
   * const settled = Op.allSettled([Op.of(1), Op.fail("nope" as const)]);
   */
  allSettled: typeof allSettledOp;
  /**
   * Converts one operation into an infallible wrapper that returns `Result` as data.
   *
   * @example
   * const settled = Op.settle(Op.try(() => JSON.parse("{}")));
   */
  settle: typeof settleOp;
  /**
   * Resolves with the first successful branch and aborts the rest.
   *
   * If every branch fails, returns `Err(ErrorGroup<...>)` with errors retained
   * in input order.
   *
   * @example
   * const fastestSuccess = Op.any([Op.fail("x"), Op.of(2)]);
   */
  any: typeof anyOp;
  /**
   * Returns the first branch to settle (`Ok` or `Err`) and aborts the rest.
   *
   * @example
   * const firstSettler = Op.race([Op.of(1), Op.try(() => Promise.resolve(2))]);
   */
  race: typeof raceOp;
  /**
   * Shared no-op operation that succeeds with `undefined`.
   *
   * @example
   * const noop = Op.empty;
   */
  empty: Op<void, never, [], EmptyMeta>;
};
type Op<T, E, A, M = EmptyMeta> = OpInterface<T, E, A, M> & Tagged<"Op">;
//#endregion
export { EmptyMeta as A, CUSTOM_INSTRUCTION_META as C, Instruction as D, InferInstructionMeta as E, Simplify as F, StripEmpty as I, withBlocking as L, MergeMeta as M, NormalizeMeta as N, Blocking as O, SetBlockingMeta as P, ErrorGroup as R, RetryPolicy as S, InferInstructionErr as T, TimeoutPolicyAttachment as _, ExitContext as a, Delay as b, InferOpMeta as c, OpPolicy as d, OpPolicyInput as f, RetryPolicyAttachment as g, ReleasePolicyAttachment as h, ReleaseFn as i, IsRunnable as j, BlockingOp as k, BuiltInPolicy as l, OpPolicyType as m, EnterContext as n, RunContext as o, OpPolicySource as p, OpLifecycleHook as r, AnyNullaryOp as s, Op as t, CancelPolicyAttachment as u, TimeoutPolicyType as v, CustomInstruction as w, ExponentialDelayOptions as x, define as y, TimeoutError as z };
//# sourceMappingURL=index-BeplSvsa.d.mts.map