{"version":3,"file":"index.mjs","names":[],"sources":["../src/core/builders.ts","../src/execution/fan-out.ts","../src/plan/combinators.ts","../src/core/combinators.ts","../src/index.ts"],"sourcesContent":["import { UnhandledException } from \"../errors.js\";\nimport { makeBoundPlanOp, makeUnboundPlanOp, makeSyncValueOp } from \"./shell.js\";\nimport { genPlan } from \"../plan/model.js\";\nimport type { AnyExitFn } from \"./lifecycle.js\";\nimport type { AsArgs, OpInterface, TrackedErr } from \"./surface.js\";\nimport type {\n  InferInstructionErr,\n  InferInstructionMeta,\n  Instruction,\n  RuntimeInstruction,\n} from \"../execution/instructions.js\";\nimport type { EmptyMeta } from \"./metadata.js\";\nimport type { Op } from \"../index.js\";\nimport {\n  NestedOpInstruction,\n  RegisterExitFinalizerInstruction,\n  SuspendInstruction,\n} from \"../execution/instructions.js\";\nimport { Result } from \"../result.js\";\nimport { isAwaited, sleepWithSignal, unsafeCoerce } from \"@prodkit/shared/runtime\";\n\n/** Builds a nullary generator leaf op backed by the internal plan model. */\nexport function makeCoreOp<T, E, M = EmptyMeta>(\n  gen: () => Generator<Instruction<E, M>, T, unknown>,\n): Op<T, TrackedErr<E>, [], M> {\n  return makeBoundPlanOp(() => genPlan(gen));\n}\n\nexport function succeed<T>(value: T | PromiseLike<T>): Op<Awaited<T>, never, [], EmptyMeta> {\n  if (!isAwaited(value)) {\n    return _try(() => value);\n  }\n\n  return makeSyncValueOp(value);\n}\n\n/*\n * Lifts a value into an operation that always fails\n */\nexport function fail<E>(value: E): Op<never, E, [], EmptyMeta> {\n  return makeCoreOp(function* () {\n    return yield* Result.err(value);\n  });\n}\n\nexport function defer(finalize: AnyExitFn): Op<void, never, [], EmptyMeta> {\n  return makeCoreOp(function* () {\n    yield new RegisterExitFinalizerInstruction(\n      (ctx) => Promise.resolve(finalize(ctx)).then(() => {}),\n      undefined,\n    );\n  });\n}\n\nexport function sleep(ms: number): Op<void, never, [], EmptyMeta> {\n  return _try((signal) => sleepWithSignal(ms, signal));\n}\n\n/*\n * Suspends until a promise settles, then continues with its value or a mapped failure\n *\n * `onError` may return a value or promise. Program-shaped values are used as the mapped typed\n * error value and are not driven.\n */\nexport function _try<T, E = UnhandledException>(\n  f: (signal: AbortSignal) => T,\n  onError?: (e: unknown) => E | PromiseLike<E>,\n): Op<Awaited<T>, TrackedErr<Awaited<E>>, [], EmptyMeta> {\n  return makeCoreOp(function* () {\n    const result: Result<\n      Awaited<T>,\n      Awaited<E> | UnhandledException\n    > = yield* new SuspendInstruction(async (context) =>\n      Promise.resolve()\n        .then(() => f(context.signal))\n        .then(\n          (a) => Result.ok(a),\n          async (cause) => {\n            if (!onError) return Result.err(new UnhandledException({ cause }));\n            const mapped = await onError(cause);\n            return Result.err(mapped);\n          },\n        ),\n    );\n\n    if (result.isErr()) return yield* result;\n    return result.value;\n  });\n}\n\nfunction bindArityArgsToFinalizers<T, M>(\n  iterator: Generator<RuntimeInstruction<unknown, M>, T, unknown>,\n  args: readonly unknown[],\n): Generator<RuntimeInstruction<unknown, M>, T, unknown> {\n  const bindStep = (\n    step: IteratorResult<RuntimeInstruction<unknown, M>, T>,\n  ): IteratorResult<RuntimeInstruction<unknown, M>, T> => {\n    if (step.done) return step;\n    if (step.value instanceof NestedOpInstruction) {\n      const nested = step.value;\n      if (nested.finalizerArgs !== undefined) return step;\n      return {\n        done: false,\n        value: new NestedOpInstruction(nested.iterate, args),\n      };\n    }\n    if (!(step.value instanceof RegisterExitFinalizerInstruction)) return step;\n    if (step.value.args !== undefined) return step;\n    return {\n      done: false,\n      value: new RegisterExitFinalizerInstruction(step.value.finalize, args),\n    };\n  };\n\n  return {\n    next: (value?: unknown) => bindStep(iterator.next(value)),\n    return: (value: T) => bindStep(iterator.return(value)),\n    throw: (error?: unknown) => bindStep(iterator.throw(error)),\n    [Symbol.iterator]() {\n      return this;\n    },\n  };\n}\n\n/**\n * Turns a generator function into an {@link Op}\n */\nexport function fromGenFn<Y extends Instruction<unknown, unknown>, T, A>(\n  f: (...args: AsArgs<A>) => Generator<Y, T, unknown>,\n): Op<T, InferInstructionErr<Y>, A, InferInstructionMeta<Y>> {\n  // We intentionally always build through the tuple-arity lifting path, including for `A = []`.\n  // This keeps runtime behavior uniform while preserving exact tuple signatures at the type level.\n  const bindPlan = (...args: AsArgs<A>) =>\n    genPlan(() =>\n      // SAFETY: user generators use instruction subtype Y; runtime iterator is the internal Instruction supertype.\n      unsafeCoerce<\n        Generator<RuntimeInstruction<InferInstructionErr<Y>, InferInstructionMeta<Y>>, T, unknown>\n      >(bindArityArgsToFinalizers(f(...args), args)),\n    );\n\n  const op: OpInterface<T, InferInstructionErr<Y>, A, InferInstructionMeta<Y>> = makeUnboundPlanOp(\n    bindPlan,\n    () =>\n      bindPlan(\n        // SAFETY: yield* iterable is nullary (A=[]); bindPlan([]) matches AsArgs<A> for that branch.\n        ...unsafeCoerce<AsArgs<A>>([]),\n      ),\n  );\n\n  return op;\n}\n","import { ErrorGroup, UnhandledException } from \"../errors.js\";\nimport { Result, type Err } from \"../result.js\";\nimport type { RunContext } from \"./runtime.js\";\nimport { createFanOutChildren } from \"./child-run.js\";\nimport { type Plan } from \"../plan/model.js\";\nimport { Settlement } from \"./settlement.js\";\nimport { unsafeCoerce } from \"@prodkit/shared/runtime\";\n\ntype ExecuteChildPlan = (\n  plan: Plan<unknown, unknown, unknown>,\n  context: RunContext<readonly unknown[]>,\n) => Promise<Result<unknown, unknown | UnhandledException>>;\n\ntype FanOutSettleControls = {\n  abortSiblingsExcept(keepIndex: number): void;\n  abortActive(): void;\n};\n\ntype DriveFanOutConfig<T, E> = {\n  executeChild: ExecuteChildPlan;\n  poolSize: number;\n  shouldScheduleMore: () => boolean;\n  onChildSettled?: (\n    result: Result<T, E | UnhandledException>,\n    index: number,\n    controls: FanOutSettleControls,\n  ) => void;\n};\n\nasync function driveFanOutPlans<T, E>(\n  plans: readonly Plan<T, E, unknown>[],\n  outerContext: RunContext<readonly unknown[]>,\n  config: DriveFanOutConfig<T, E>,\n): Promise<Array<Result<T, E | UnhandledException> | undefined>> {\n  const children = createFanOutChildren(outerContext);\n  const results: Array<Result<T, E | UnhandledException> | undefined> = Array(plans.length);\n  const runningByIndex: Array<{ abort(): void } | undefined> = Array(plans.length);\n\n  const abortSiblingsExcept = (keepIndex: number) => {\n    for (let index = 0; index < runningByIndex.length; index += 1) {\n      if (index === keepIndex) continue;\n      const child = runningByIndex[index];\n      if (child !== undefined) child.abort();\n    }\n  };\n\n  const abortActive = () => {\n    children.abortActive();\n  };\n\n  const controls = { abortSiblingsExcept, abortActive };\n  const settleChild = (\n    res: Result<T, E | UnhandledException>,\n    index: number,\n    slot: { release(): void },\n  ) => {\n    runningByIndex[index] = undefined;\n    slot.release();\n    results[index] = res;\n    config.onChildSettled?.(res, index, controls);\n  };\n\n  try {\n    if (config.poolSize >= plans.length) {\n      const runs = plans.map((plan, index) => {\n        const child = children.spawn();\n        runningByIndex[index] = child;\n        return config.executeChild(plan, child.context).then((result) => {\n          // SAFETY: ExecuteChildPlan types results as unknown; every plan here is Plan<T, E, ...> at this site.\n          const res: Result<T, E | UnhandledException> = unsafeCoerce(result);\n          settleChild(res, index, child);\n          return res;\n        });\n      });\n\n      await Promise.all(runs);\n      return results;\n    }\n\n    let nextIndex = 0;\n    const workerCount = Math.min(config.poolSize, plans.length);\n    const worker = async () => {\n      while (config.shouldScheduleMore()) {\n        const i = nextIndex;\n        nextIndex += 1;\n        const plan = plans[i];\n        if (plan === undefined) return;\n\n        const child = children.spawn();\n        runningByIndex[i] = child;\n        // SAFETY: ExecuteChildPlan types results as unknown; every plan here is Plan<T, E, ...> at this site.\n        const res: Result<T, E | UnhandledException> = unsafeCoerce(\n          await config.executeChild(plan, child.context),\n        );\n        settleChild(res, i, child);\n      }\n    };\n\n    await Promise.all(Array.from({ length: workerCount }, worker));\n    return results;\n  } finally {\n    children.detach();\n  }\n}\n\nexport function concurrencyLimit(\n  concurrency: number | undefined,\n  size: number,\n): Result<number, UnhandledException> {\n  if (concurrency === undefined) return Result.ok(size);\n\n  if (!Number.isInteger(concurrency) || concurrency < 1) {\n    const cause = new RangeError(\"concurrency must be a positive integer\");\n    return Result.err(new UnhandledException({ cause }));\n  }\n\n  return Result.ok(Math.min(concurrency, size));\n}\n\nfunction missingResultError(index: number): UnhandledException {\n  return new UnhandledException({\n    cause: new Error(`Op combinator invariant violation: missing result at index ${index}`),\n  });\n}\n\nexport function collectAllOk<T, E>(\n  results: readonly (Result<T, E | UnhandledException> | undefined)[],\n): Result<T[], E | UnhandledException> {\n  const values: T[] = [];\n\n  for (let index = 0; index < results.length; index += 1) {\n    const result = results[index];\n    if (result === undefined) return Result.err(missingResultError(index));\n    if (result.isErr()) return result;\n    values.push(result.value);\n  }\n\n  return Result.ok(values);\n}\n\nconst executeInterruptingPlan: ExecuteChildPlan = (plan, context) =>\n  Settlement.interrupting.runPlan(plan, context);\n\nasync function driveAllUntilFirstError<T, E>(\n  plans: readonly Plan<T, E, unknown>[],\n  outerContext: RunContext<readonly unknown[]>,\n  config: {\n    poolSize: number;\n    onFirstError: (controls: FanOutSettleControls, index: number) => void;\n  },\n): Promise<Result<T[], E | UnhandledException>> {\n  let firstErr: Err<T, E | UnhandledException> | undefined;\n  const results = await driveFanOutPlans(plans, outerContext, {\n    poolSize: config.poolSize,\n    executeChild: executeInterruptingPlan,\n    shouldScheduleMore: () => firstErr === undefined,\n    onChildSettled: (result, index, controls) => {\n      if (result.isErr() && firstErr === undefined) {\n        firstErr = result;\n        config.onFirstError(controls, index);\n      }\n    },\n  });\n\n  if (firstErr !== undefined) return firstErr;\n\n  return collectAllOk(results);\n}\n\nasync function driveAllUnboundedPlans<T, E>(\n  plans: readonly Plan<T, E, unknown>[],\n  outerContext: RunContext<readonly unknown[]>,\n): Promise<Result<T[], E | UnhandledException>> {\n  return driveAllUntilFirstError(plans, outerContext, {\n    poolSize: plans.length,\n    onFirstError: ({ abortSiblingsExcept }, index) => abortSiblingsExcept(index),\n  });\n}\n\nexport async function driveAllPlans<T, E>(\n  plans: readonly Plan<T, E, unknown>[],\n  outerContext: RunContext<readonly unknown[]>,\n  concurrency: number | undefined,\n): Promise<Result<T[], E | UnhandledException>> {\n  const limit = concurrencyLimit(concurrency, plans.length);\n\n  if (limit.isErr()) return limit;\n\n  if (plans.length === 0) return Result.ok([]);\n\n  if (limit.value >= plans.length) return driveAllUnboundedPlans(plans, outerContext);\n\n  return driveAllUntilFirstError(plans, outerContext, {\n    poolSize: limit.value,\n    onFirstError: ({ abortActive }) => abortActive(),\n  });\n}\n\nexport const executeCooperativePlan: ExecuteChildPlan = (plan, context) =>\n  Settlement.cooperative.runPlan(plan, context);\n\nexport function collectAllSettled<T, E>(\n  results: ReadonlyArray<Result<T, E | UnhandledException> | undefined>,\n): Result<Result<T, E | UnhandledException>[], UnhandledException> {\n  const settled: Result<T, E | UnhandledException>[] = [];\n\n  for (let index = 0; index < results.length; index += 1) {\n    const result = results[index];\n    if (result === undefined) return Result.err(missingResultError(index));\n    settled.push(result);\n  }\n\n  return Result.ok(settled);\n}\n\nexport async function driveAllSettledPlans<T, E>(\n  plans: readonly Plan<T, E, unknown>[],\n  outerContext: RunContext<readonly unknown[]>,\n  concurrency: number | undefined,\n): Promise<Result<Result<T, E | UnhandledException>[], UnhandledException>> {\n  const limit = concurrencyLimit(concurrency, plans.length);\n\n  if (limit.isErr()) return limit;\n\n  if (plans.length === 0) return Result.ok([]);\n\n  const results = await driveFanOutPlans(plans, outerContext, {\n    poolSize: limit.value >= plans.length ? plans.length : limit.value,\n    executeChild: executeCooperativePlan,\n    shouldScheduleMore: () => true,\n  });\n\n  if (limit.value >= plans.length) {\n    // SAFETY: driveFanOutPlans types results as unknown; every child plan matches T and E at this site.\n    const settled: Result<T, E | UnhandledException>[] = unsafeCoerce(results);\n    return Result.ok(settled);\n  }\n\n  return collectAllSettled(results);\n}\n\nexport async function driveRacePlans<T, E>(\n  plans: readonly Plan<T, E, unknown>[],\n  outerContext: RunContext<readonly unknown[]>,\n): Promise<Result<T, E | UnhandledException>> {\n  if (plans.length === 0) {\n    const cause = new Error(\"Op.race requires at least one operation\");\n    return Promise.resolve(Result.err(new UnhandledException({ cause })));\n  }\n\n  let winnerClaimed = false;\n  let winner: Result<T, E | UnhandledException> | undefined;\n  await driveFanOutPlans(plans, outerContext, {\n    poolSize: plans.length,\n    executeChild: executeInterruptingPlan,\n    shouldScheduleMore: () => true,\n    onChildSettled: (result, index, { abortSiblingsExcept }) => {\n      if (!winnerClaimed) {\n        winnerClaimed = true;\n        winner = result;\n        abortSiblingsExcept(index);\n      }\n    },\n  });\n\n  if (winner !== undefined) return winner;\n\n  const cause = new Error(\"Op.race failed to produce a winner\");\n  return Result.err(new UnhandledException({ cause }));\n}\n\nexport async function driveAnyPlans<T, E>(\n  plans: readonly Plan<T, E, unknown>[],\n  outerContext: RunContext<readonly unknown[]>,\n): Promise<Result<T, ErrorGroup<E | UnhandledException>>> {\n  if (plans.length === 0) {\n    return Promise.resolve(\n      Result.err(new ErrorGroup([], \"Op.any requires at least one operation\")),\n    );\n  }\n\n  let winnerClaimed = false;\n  let winner: { value: T } | undefined;\n  const results = await driveFanOutPlans(plans, outerContext, {\n    poolSize: plans.length,\n    executeChild: executeInterruptingPlan,\n    shouldScheduleMore: () => true,\n    onChildSettled: (result, index, { abortSiblingsExcept }) => {\n      if (!winnerClaimed && result.isOk()) {\n        winnerClaimed = true;\n        winner = { value: result.value };\n        abortSiblingsExcept(index);\n      }\n    },\n  });\n\n  if (winner !== undefined) return Result.ok(winner.value);\n\n  const errors: Array<E | UnhandledException> = [];\n  for (let index = 0; index < results.length; index += 1) {\n    const result = results[index];\n    if (result !== undefined && Result.isError(result)) errors.push(result.error);\n  }\n  return Result.err(new ErrorGroup(errors, \"Op.any failed because all operations failed\"));\n}\n","import { UnhandledException } from \"../errors.js\";\nimport { Result } from \"../result.js\";\nimport { SuspendInstruction } from \"../execution/instructions.js\";\nimport { Settlement } from \"../execution/settlement.js\";\nimport type { RunContext } from \"../execution/runtime.js\";\nimport { createPlan, createUnaryPlan, type Plan, type PlanRewriter } from \"./model.js\";\nimport {\n  driveAllPlans,\n  driveAllSettledPlans,\n  driveAnyPlans,\n  driveRacePlans,\n} from \"../execution/fan-out.js\";\n\nfunction rewritePlanChildren<T, E, M>(\n  snapshot: readonly Plan<T, E, M>[],\n  rewriter: PlanRewriter,\n): Plan<T, E, M>[] {\n  return snapshot.map((child) => child.rewrite(rewriter));\n}\n\nfunction* interruptingFanOutPlan<T, E>(\n  drive: (\n    outerContext: RunContext<readonly unknown[]>,\n  ) => Promise<Result<T, E | UnhandledException>>,\n) {\n  const result: Result<T, E | UnhandledException> =\n    yield* Settlement.interruptingAndDraining.suspend(drive);\n\n  if (result.isErr()) return yield* result;\n  return result.value;\n}\n\nexport function allPlan<T, E, M>(\n  children: readonly Plan<T, E, M>[],\n  concurrency?: number,\n): Plan<T[], E, M> {\n  const snapshot = children.slice();\n\n  return createPlan(\n    function* () {\n      return yield* interruptingFanOutPlan((outerContext) =>\n        driveAllPlans(snapshot, outerContext, concurrency),\n      );\n    },\n    {\n      rewrite: (_self, rewriter) => allPlan(rewritePlanChildren(snapshot, rewriter), concurrency),\n    },\n  );\n}\n\nexport function racePlan<T, E, M>(children: readonly Plan<T, E, M>[]): Plan<T, E, M> {\n  const snapshot = children.slice();\n\n  return createPlan(\n    function* () {\n      return yield* interruptingFanOutPlan((outerContext) =>\n        driveRacePlans(snapshot, outerContext),\n      );\n    },\n    {\n      rewrite: (_self, rewriter) => racePlan(rewritePlanChildren(snapshot, rewriter)),\n    },\n  );\n}\n\nexport function anyPlan<T, E, M>(children: readonly Plan<T, E, M>[]): Plan<T, E, M> {\n  const snapshot = children.slice();\n\n  return createPlan(\n    function* () {\n      return yield* interruptingFanOutPlan((outerContext) => driveAnyPlans(snapshot, outerContext));\n    },\n    {\n      rewrite: (_self, rewriter) => anyPlan(rewritePlanChildren(snapshot, rewriter)),\n    },\n  );\n}\n\nexport function settlePlan<T, E, M>(\n  source: Plan<T, E, M>,\n): Plan<Result<T, E | UnhandledException>, never, M> {\n  return createUnaryPlan(\n    function* () {\n      const child: Result<T, E | UnhandledException> =\n        yield* Settlement.cooperative.suspendPlan(source);\n\n      return child;\n    },\n    source,\n    settlePlan,\n  );\n}\n\nexport function allSettledPlan<T, E, M>(\n  children: readonly Plan<T, E, M>[],\n  concurrency?: number,\n): Plan<Result<T, E | UnhandledException>[], UnhandledException, M> {\n  const snapshot = children.slice();\n\n  return createPlan(\n    function* () {\n      const result: Result<Result<T, E | UnhandledException>[], UnhandledException> =\n        yield* new SuspendInstruction((outerContext: RunContext<readonly unknown[]>) =>\n          driveAllSettledPlans(snapshot, outerContext, concurrency),\n        );\n\n      if (result.isErr()) return yield* result;\n      return result.value;\n    },\n    {\n      rewrite: (_self, rewriter) =>\n        allSettledPlan(rewritePlanChildren(snapshot, rewriter), concurrency),\n    },\n  );\n}\n","import type { AnyNullaryOp, InferOpMeta, InferOpOk, InferOpErr } from \"./surface.js\";\nimport type { Op } from \"../index.js\";\nimport { allPlan, allSettledPlan, anyPlan, racePlan, settlePlan } from \"../plan/combinators.js\";\nimport { getPlan } from \"../plan/bridge.js\";\nimport { makeBoundPlanOp } from \"./shell.js\";\nimport { Result } from \"../result.js\";\nimport type { EmptyMeta, MergeMeta } from \"./metadata.js\";\nimport { unsafeCoerce } from \"@prodkit/shared/runtime\";\nimport { ErrorGroup, UnhandledException } from \"../errors.js\";\n\ntype MergeOpsMeta<Ops extends readonly AnyNullaryOp[]> = Ops extends readonly [\n  infer Head extends AnyNullaryOp,\n  ...infer Tail extends readonly AnyNullaryOp[],\n]\n  ? MergeMeta<InferOpMeta<Head>, MergeOpsMeta<Tail>>\n  : EmptyMeta;\n\ntype AllOpOk<Ops extends readonly AnyNullaryOp[]> = { [K in keyof Ops]: InferOpOk<Ops[K]> };\ntype AllOpErr<Ops extends readonly AnyNullaryOp[]> = InferOpErr<Ops[number]>;\n\nexport function allOp<const Ops extends readonly AnyNullaryOp[]>(\n  ops: Ops,\n  concurrency?: number,\n): Op<AllOpOk<Ops>, AllOpErr<Ops>, [], MergeOpsMeta<Ops>> {\n  const snapshot = ops.slice();\n  const bindAllPlan = () =>\n    allPlan(\n      snapshot.map((op) => getPlan(op, [])),\n      concurrency,\n    );\n\n  // SAFETY: makeBoundPlanOp omits merged metadata in its return; bindAllPlan was built from the typed snapshot ops.\n  return unsafeCoerce(makeBoundPlanOp(bindAllPlan));\n}\n\ntype AllSettledOpOk<Ops extends readonly AnyNullaryOp[]> = {\n  [K in keyof Ops]: Result<InferOpOk<Ops[K]>, InferOpErr<Ops[K]> | UnhandledException>;\n};\nexport function allSettledOp<const Ops extends readonly AnyNullaryOp[]>(\n  ops: Ops,\n  concurrency?: number,\n): Op<AllSettledOpOk<Ops>, never, [], MergeOpsMeta<Ops>> {\n  const snapshot = ops.slice();\n  const bindAllSettledPlan = () =>\n    allSettledPlan(\n      snapshot.map((op) => getPlan(op, [])),\n      concurrency,\n    );\n\n  // SAFETY: makeBoundPlanOp omits merged metadata in its return; bindAllSettledPlan was built from the typed snapshot ops.\n  return unsafeCoerce(makeBoundPlanOp(bindAllSettledPlan));\n}\n\nexport function settleOp<T, E, M>(\n  op: Op<T, E, [], M>,\n): Op<Result<T, E | UnhandledException>, never, [], M> {\n  const bindSettlePlan = () => settlePlan(getPlan(op, []));\n\n  // SAFETY: makeBoundPlanOp omits metadata in its return; bindSettlePlan was built from the typed source op.\n  return unsafeCoerce(makeBoundPlanOp(bindSettlePlan));\n}\n\n/**\n * helper to check if any op in the list has an infallible error type\n */\ntype HasInfallibleOp<Ops extends readonly AnyNullaryOp[]> = Ops extends readonly [\n  infer Head extends AnyNullaryOp,\n  ...infer Tail extends readonly AnyNullaryOp[],\n]\n  ? [InferOpErr<Head>] extends [never]\n    ? true\n    : HasInfallibleOp<Tail>\n  : false;\n\ntype AnyOpOk<Ops extends readonly AnyNullaryOp[]> = InferOpOk<Ops[number]>;\ntype AnyOpErr<Ops extends readonly AnyNullaryOp[]> =\n  HasInfallibleOp<Ops> extends true ? never : ErrorGroup<InferOpErr<Ops[number]>>;\n\nexport function anyOp<const Ops extends readonly AnyNullaryOp[]>(\n  ops: Ops,\n): Op<AnyOpOk<Ops>, AnyOpErr<Ops>, [], MergeOpsMeta<Ops>> {\n  const snapshot = ops.slice();\n  const bindAnyPlan = () => anyPlan(snapshot.map((op) => getPlan(op, [])));\n\n  // SAFETY: makeBoundPlanOp omits merged metadata in its return; bindAnyPlan was built from the typed snapshot ops.\n  return unsafeCoerce(makeBoundPlanOp(bindAnyPlan));\n}\n\ntype RaceOpOk<Ops extends readonly AnyNullaryOp[]> = InferOpOk<Ops[number]>;\ntype RaceOpErr<Ops extends readonly AnyNullaryOp[]> = InferOpErr<Ops[number]>;\nexport function raceOp<const Ops extends readonly AnyNullaryOp[]>(\n  ops: Ops,\n): Op<RaceOpOk<Ops>, RaceOpErr<Ops>, [], MergeOpsMeta<Ops>> {\n  const snapshot = ops.slice();\n  const bindRacePlan = () => racePlan(snapshot.map((op) => getPlan(op, [])));\n\n  // SAFETY: makeBoundPlanOp omits merged metadata in its return; bindRacePlan was built from the typed snapshot ops.\n  return unsafeCoerce(makeBoundPlanOp(bindRacePlan));\n}\n","import { defer, fail, fromGenFn, sleep, succeed, _try } from \"./core/builders.js\";\nimport { allOp, allSettledOp, anyOp, raceOp, settleOp } from \"./core/combinators.js\";\nimport { ErrorGroup, TimeoutError, type UnhandledException } from \"./errors.js\";\nimport type { EnterContext, OpLifecycleHook } from \"./core/lifecycle.js\";\nimport type { OpInterface, AsArgs } from \"./core/surface.js\";\nimport type { EmptyMeta, IsRunnable } from \"./core/metadata.js\";\nimport type { ExitContext } from \"./execution/runtime.js\";\nimport { runOp } from \"./execution/runtime.js\";\nimport { Tagged } from \"./tagged.js\";\nimport { type Result } from \"./result.js\";\n\nconst empty: Op<void, never, []> = succeed(undefined);\n\n/**\n * An operation that can be run and composed with other operations.\n *\n * - Runtime factory and namespace for building and composing operations.\n * - Call `Op(function* (...) { ... })` to build generator-based operations.\n * - Use static helpers (`Op.of`, `Op.fail`, `Op.try`, `Op.all`, `Op.any`, etc.)\n *   for common patterns.\n *\n * Use `Op.run(op)` to execute an operation directly. For external cancellation,\n *   compose with `.with(Policy.cancel(signal))` first and then run.\n *\n * @example\n * const op = Op(function* () {\n *   if (Math.random() > 0.5) {\n *     return yield* Op.fail(\"error\");\n *   }\n *   return yield* Op.of(69);\n * });\n * const result = await op.run();\n * console.log(result);\n */\nexport const Op = Object.assign(fromGenFn, {\n  /** Type discriminant for the `Op` factory namespace value. */\n  _tag: \"OpFactory\" as const,\n  /**\n   * Executes an operation with its runtime arguments and resolves to its `Result<T, E | UnhandledException>`.\n   *\n   * @example\n   * const value = await Op.run(Op.of(1));\n   */\n  run: <T, E, A, M>(\n    op: [IsRunnable<M>] extends [false] ? never : Op<T, E, A, M>,\n    ...args: AsArgs<A>\n  ): Promise<Result<T, E | UnhandledException>> => {\n    return runOp(op(...args));\n  },\n  /**\n   * Creates an operation that always succeeds with the provided value.\n   *\n   * Promise inputs are awaited before producing the success value.\n   *\n   * @example\n   * const value = Op.of(69);\n   */\n  of: succeed,\n  /**\n   * Creates an operation that always fails with the provided typed error value.\n   *\n   * @example\n   * const failed = Op.fail(\"bad-input\" as const);\n   */\n  fail,\n  /**\n   * Registers an exit finalizer for the current run via `yield* Op.defer(...)`.\n   *\n   * If any callback throws during unwind, `run` fails with {@link UnhandledException} whose `cause`\n   * is an {@link ErrorGroup} (message `Operation cleanup failed`). Cleanup failures are exact\n   * thrown values in LIFO execution order. When the body already failed, its error is the first\n   * group entry.\n   *\n   * **Important**: Op.defer *must* be `yield*`ed or it will do nothing\n   *\n   * @note Should always be used inside an `Op(function* () { ... })` body.\n   *\n   * @example\n   * const program = Op(function* () {\n   *   yield* Op.defer(() => console.log(\"cleanup\"));\n   *   return 1;\n   * });\n   */\n  defer,\n  /**\n   * Suspends the current operation for `ms` milliseconds.\n   *\n   * Negative durations are normalized to `0`. Non-finite durations fail at run time\n   * with `UnhandledException`.\n   * The sleep observes surrounding cancellation from `.with(Policy.cancel(...))`,\n   * `.with(Policy.timeout(...))`, and combinators.\n   *\n   * @example\n   * const delayed = Op(function* () {\n   *   yield* Op.sleep(100);\n   *   return \"ready\";\n   * });\n   */\n  sleep,\n  /**\n   * Lifts a sync or async callback into an operation.\n   *\n   * - Fulfillment returns `Ok`.\n   * - Throw/reject is normalized to `UnhandledException` when `onError` is omitted.\n   * - With `onError`, failures are mapped to your typed error.\n   *\n   * @example\n   * const fetched = Op.try(() => fetch(\"/health\"));\n   *\n   * @example\n   * const fetched = Op.try(\n   *   () => fetch(\"/health\"),\n   *   (cause) => new FetchError({ cause }),\n   * );\n   */\n  try: _try,\n  /**\n   * Runs nullary operations concurrently and preserves input order on success.\n   *\n   * `Op.all` fails fast on the first observed error, aborts remaining siblings,\n   * and still waits for active losers to settle so cleanup/finalizers complete.\n   *\n   * @example\n   * const pair = Op.all([Op.of(1), Op.of(\"ok\")]);\n   */\n  all: allOp,\n  /**\n   * Runs all branches and returns per-branch `Result` values in input order.\n   *\n   * Branch failures do not abort siblings. Invalid `concurrency` (non-integer or\n   * less than 1) returns `Err(UnhandledException)` at run time.\n   *\n   * @example\n   * const settled = Op.allSettled([Op.of(1), Op.fail(\"nope\" as const)]);\n   */\n  allSettled: allSettledOp,\n  /**\n   * Converts one operation into an infallible wrapper that returns `Result` as data.\n   *\n   * @example\n   * const settled = Op.settle(Op.try(() => JSON.parse(\"{}\")));\n   */\n  settle: settleOp,\n  /**\n   * Resolves with the first successful branch and aborts the rest.\n   *\n   * If every branch fails, returns `Err(ErrorGroup<...>)` with errors retained\n   * in input order.\n   *\n   * @example\n   * const fastestSuccess = Op.any([Op.fail(\"x\"), Op.of(2)]);\n   */\n  any: anyOp,\n  /**\n   * Returns the first branch to settle (`Ok` or `Err`) and aborts the rest.\n   *\n   * @example\n   * const firstSettler = Op.race([Op.of(1), Op.try(() => Promise.resolve(2))]);\n   */\n  race: raceOp,\n  /**\n   * Shared no-op operation that succeeds with `undefined`.\n   *\n   * @example\n   * const noop = Op.empty;\n   */\n  empty,\n});\n\nexport type Op<T, E, A, M = EmptyMeta> = OpInterface<T, E, A, M> & Tagged<\"Op\">;\n\nexport type { EnterContext, ExitContext, OpLifecycleHook };\n\nexport { TimeoutError, ErrorGroup };\n"],"mappings":"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"}