{"version":3,"file":"model-Cy-6sUGC.mjs","names":["chainable"],"sources":["../src/errors.ts","../src/execution/cleanup.ts","../src/execution/runtime.ts","../src/execution/settlement.ts","../src/plan/model.ts"],"sourcesContent":["import type { Err } from \"./result.js\";\nimport { Result } from \"./result.js\";\nimport { Tagged } from \"./tagged.js\";\nimport { TaggedError, UnhandledException, type TaggedErrorInstance } from \"better-result\";\n\nexport { TaggedError, UnhandledException, type TaggedErrorInstance };\n\nexport const CLEANUP_FAILURE_MESSAGE = \"Operation cleanup failed\";\n\n/**\n * Built-in typed error emitted when an operation exceeds a timeout budget\n */\nexport class TimeoutError extends TaggedError(\"TimeoutError\")<{\n  message: string;\n  timeoutMs: number;\n}> {\n  constructor({ timeoutMs }: { timeoutMs: number }) {\n    super({ message: `Operation timed out after ${timeoutMs}ms`, timeoutMs });\n  }\n}\n\n/** A typed aggregate error used when an operation must preserve multiple failures. */\nexport class ErrorGroup<E> extends Tagged(\"ErrorGroup\", AggregateError) {\n  declare readonly errors: E[];\n  constructor(errors: Iterable<E>, message: string) {\n    super(errors, message);\n    this.name = this._tag;\n  }\n\n  *[Symbol.iterator](): Generator<Err<never, this>, never, unknown> {\n    return yield* Result.err(this);\n  }\n\n  static is(value: unknown): value is ErrorGroup<unknown> {\n    return value instanceof ErrorGroup;\n  }\n}\n","import type { Result } from \"../result.js\";\n\n/**\n * Cleanup registry for ADR-0003's three teardown channels.\n *\n * These helpers are shared infrastructure; they do not merge the channels.\n *\n * 1. **Generator finalization** (`closeGenerator`): best-effort `iterator.return()` so native\n *    generator `finally` runs. Swallows `return()` faults so the body settlement already chosen\n *    by `drive` is preserved.\n *\n * 2. **Registered exit finalizers** (`runFinalizersSafely`): effectful cleanup via\n *    `RegisterExitFinalizerInstruction` (`Op.defer`, `.on(\"exit\")`, and release hooks registered\n *    after success). Unwind is LIFO; every handler runs; faults take precedence at settlement\n *    (see op-invariants.md Invariants 1 and 2).\n *\n * 3. **Success-gated release** (`releasePlan` in `packages/op/src/policy/plan.ts`): drives the\n *    inner plan first, schedules a single exit finalizer only on success. Not implemented here;\n *    documented so callers do not conflate it with generator finalization or unconditional defer.\n */\n\n/** Context passed to each registered exit finalizer at unwind (see `ExitContext` in `runtime.ts`). */\nexport interface ExitFinalizerContext {\n  readonly signal: AbortSignal;\n  readonly args: readonly unknown[];\n  readonly result: Result<unknown, unknown>;\n}\n\nexport type ExitFinalizer = (ctx: ExitFinalizerContext) => PromiseLike<void>;\n\n/** Best-effort generator `return()`; swallows faults so body settlement is preserved. */\nexport function closeGenerator(iterator: Iterator<unknown, unknown, unknown>) {\n  try {\n    // we intentionally ignore the return payload bc only generator finalization matters\n    iterator.return?.(undefined);\n  } catch {\n    // ignore cleanup faults so the original result/error is preserved\n  }\n}\n\n/**\n * Run every finalizer LIFO and preserve each exact thrown value in execution order.\n *\n * The array shape distinguishes no fault from a finalizer that throws `undefined`.\n */\nexport async function runFinalizersSafely(\n  finalizers: readonly ExitFinalizer[],\n  ctx: ExitFinalizerContext,\n): Promise<readonly unknown[]> {\n  const faults: unknown[] = [];\n  for (let index = finalizers.length - 1; index >= 0; index -= 1) {\n    const finalize = finalizers[index];\n    if (finalize !== undefined) {\n      try {\n        await finalize(ctx);\n      } catch (e) {\n        faults.push(e);\n      }\n    }\n  }\n  return faults;\n}\n","import { CLEANUP_FAILURE_MESSAGE, ErrorGroup, UnhandledException } from \"../errors.js\";\nimport { Result } from \"../result.js\";\nimport { isRecordLike, unsafeCoerce } from \"@prodkit/shared/runtime\";\nimport {\n  CUSTOM_INSTRUCTION_META,\n  isErrInstruction,\n  NestedOpInstruction,\n  RegisterExitFinalizerInstruction,\n  SuspendInstruction,\n  type CustomInstruction,\n  type RuntimeInstruction,\n} from \"./instructions.js\";\nimport {\n  AbortSettlement,\n  awaitWithAbort,\n  drainInFlightWork,\n  settlementForSuspendedWork,\n} from \"./abort-settlement.js\";\nimport type { Op } from \"../index.js\";\nimport type { Plan } from \"../plan/model.js\";\nimport { closeGenerator, runFinalizersSafely, type ExitFinalizer } from \"./cleanup.js\";\n\nexport { closeGenerator } from \"./cleanup.js\";\n\n/** Runtime execution context threaded through internal driver/suspend boundaries. */\nexport interface RunContext<A = []> {\n  readonly signal: AbortSignal;\n  readonly args: A;\n  readonly extensions: ReadonlyMap<unknown, unknown>;\n}\n\n/**\n * Passed to {@link ExitFn} when the run unwinds.\n *\n * - `args` are the runtime inputs for this run\n * - `result` is the operation's pre-finalizer settlement result\n *   (including {@link UnhandledException} on the error channel when relevant).\n *   If a finalizer throws, `.run()` returns a new cleanup-failure result instead.\n */\nexport interface ExitContext<T, E, A = []> {\n  readonly signal: AbortSignal;\n  readonly args: A;\n  readonly result: Result<T, E | UnhandledException>;\n}\n\nexport function createRunContext(\n  signal: AbortSignal,\n  args: readonly unknown[] = [],\n  extensions: ReadonlyMap<unknown, unknown> = new Map(),\n): RunContext<readonly unknown[]> {\n  return { signal, args, extensions };\n}\n\ntype ErasedPlan = Plan<unknown, unknown, unknown>;\ntype PlanExecutionJob = {\n  readonly plan: ErasedPlan;\n  readonly context: RunContext<readonly unknown[]>;\n  readonly settlement: AbortSettlement;\n  readonly resolve: (result: Result<unknown, unknown | UnhandledException>) => void;\n  readonly reject: (cause: unknown) => void;\n};\n\nlet activePlanExecutionCount = 0;\nconst planExecutionQueue: PlanExecutionJob[] = [];\nlet planExecutionPumpScheduled = false;\nconst MAX_SYNC_PLAN_EXECUTION_DEPTH = 128;\n\nexport function executePlan<T, E, M>(\n  plan: Plan<T, E, M>,\n  context: RunContext<readonly unknown[]>,\n  settlement: AbortSettlement = AbortSettlement.passThrough,\n): Promise<Result<T, E | UnhandledException>> {\n  if (activePlanExecutionCount < MAX_SYNC_PLAN_EXECUTION_DEPTH) {\n    return executePlanDirect(plan, context, settlement);\n  }\n\n  return enqueuePlanExecution(plan, context, settlement);\n}\n\nasync function executePlanDirect<T, E, M>(\n  plan: Plan<T, E, M>,\n  context: RunContext<readonly unknown[]>,\n  settlement: AbortSettlement,\n): Promise<Result<T, E | UnhandledException>> {\n  activePlanExecutionCount += 1;\n  try {\n    // SAFETY: driveIterator may return UnhandledException; executePlan widens E for settlement faults.\n    return unsafeCoerce(await driveIterator(plan.iterate(), context, settlement));\n  } finally {\n    activePlanExecutionCount -= 1;\n  }\n}\n\nfunction enqueuePlanExecution<T, E, M>(\n  plan: Plan<T, E, M>,\n  context: RunContext<readonly unknown[]>,\n  settlement: AbortSettlement,\n): Promise<Result<T, E | UnhandledException>> {\n  return new Promise((resolve, reject) => {\n    // SAFETY: queued jobs erase plan generics and restore them through the typed promise returned by executePlan.\n    const erasedPlan: ErasedPlan = unsafeCoerce(plan);\n    // SAFETY: the queued result is the same Result shape, with generics erased at the queue boundary only.\n    const erasedResolve: PlanExecutionJob[\"resolve\"] = unsafeCoerce(resolve);\n    planExecutionQueue.push({\n      plan: erasedPlan,\n      context,\n      settlement,\n      resolve: erasedResolve,\n      reject,\n    });\n    schedulePlanExecutionPump();\n  });\n}\n\nfunction schedulePlanExecutionPump() {\n  if (planExecutionPumpScheduled) return;\n  planExecutionPumpScheduled = true;\n  queueMicrotask(pumpPlanExecutionQueue);\n}\n\nfunction pumpPlanExecutionQueue() {\n  planExecutionPumpScheduled = false;\n\n  while (true) {\n    const job = planExecutionQueue.shift();\n    if (job === undefined) return;\n\n    void executePlanDirect(job.plan, job.context, job.settlement).then(job.resolve, job.reject);\n  }\n}\n\nfunction isCustomInstruction(value: unknown): value is CustomInstruction<unknown, unknown> {\n  return (\n    isRecordLike(value) && CUSTOM_INSTRUCTION_META in value && typeof value.resolve === \"function\"\n  );\n}\n\nexport async function drive<T, E, M>(\n  op: Op<T, E, [], M>,\n  context: RunContext<readonly unknown[]>,\n): Promise<Result<T, E | UnhandledException>> {\n  return driveInternal(op, context, AbortSettlement.passThrough);\n}\n\ntype RuntimeIterator<E, M> = Iterator<RuntimeInstruction<E, M>, unknown, unknown>;\ntype RuntimeIteratorStep<E, M> = IteratorResult<RuntimeInstruction<E, M>, unknown>;\ntype RuntimeIteratorFrame<E, M> = {\n  readonly iterator: RuntimeIterator<E, M>;\n  readonly finalizerArgs: readonly unknown[] | undefined;\n};\n\nasync function resolveSuspendedInstruction(\n  instruction: SuspendInstruction,\n  context: RunContext<readonly unknown[]>,\n  driveSettlement: AbortSettlement,\n): Promise<unknown> {\n  const suspendWork = instruction.suspend(context);\n  const { settlement, suspended } = settlementForSuspendedWork(driveSettlement, suspendWork);\n  try {\n    return await awaitWithAbort(suspended, context.signal, settlement);\n  } catch (cause) {\n    if (settlement.kind === \"interruptAndDrainOnAbort\") {\n      await drainInFlightWork(suspended);\n    }\n    throw cause;\n  }\n}\n\nasync function resolveCustomInstruction(\n  instruction: CustomInstruction<unknown, unknown>,\n  context: RunContext<readonly unknown[]>,\n  driveSettlement: AbortSettlement,\n): Promise<unknown> {\n  return awaitWithAbort(\n    Promise.resolve(instruction.resolve(context)),\n    context.signal,\n    driveSettlement,\n  );\n}\n\nfunction registerExitFinalizerInstruction(\n  instruction: RegisterExitFinalizerInstruction,\n  runArgs: readonly unknown[],\n  frameArgs: readonly unknown[] | undefined,\n  finalizers: ExitFinalizer[],\n) {\n  const argsAtRegistration = instruction.args ?? frameArgs ?? runArgs;\n  finalizers.push((ctx) =>\n    instruction.finalize({\n      signal: ctx.signal,\n      result: ctx.result,\n      args: argsAtRegistration,\n    }),\n  );\n}\n\nfunction throwIntoIterator<E, M>(\n  iterator: RuntimeIterator<E, M>,\n  cause: unknown,\n): RuntimeIteratorStep<E, M> {\n  if (iterator.throw === undefined) throw cause;\n  return iterator.throw(cause);\n}\n\nfunction advanceIteratorFrames<E, M>(\n  frames: RuntimeIteratorFrame<E, M>[],\n  throwing: boolean,\n  initialValue: unknown,\n): RuntimeIteratorStep<E, M> {\n  let value = initialValue;\n\n  while (true) {\n    const frame = frames[frames.length - 1];\n    if (frame === undefined) {\n      throw new Error(\"Nested Op iterator stack lost its current frame\");\n    }\n\n    try {\n      return throwing ? throwIntoIterator(frame.iterator, value) : frame.iterator.next(value);\n    } catch (cause) {\n      if (frames.length === 1) throw cause;\n      frames.pop();\n      throwing = true;\n      value = cause;\n    }\n  }\n}\n\nfunction enterNestedFrame<E, M>(\n  frames: RuntimeIteratorFrame<E, M>[],\n  parent: RuntimeIteratorFrame<E, M>,\n  instruction: NestedOpInstruction<unknown, E, M>,\n): RuntimeIteratorStep<E, M> {\n  let iterator: RuntimeIterator<E, M>;\n  try {\n    iterator = instruction.iterate();\n  } catch (cause) {\n    return advanceIteratorFrames(frames, true, cause);\n  }\n\n  frames.push({\n    iterator,\n    finalizerArgs: instruction.finalizerArgs ?? parent.finalizerArgs,\n  });\n  return advanceIteratorFrames(frames, false, undefined);\n}\n\nasync function settleIteratorWithCleanup<T, E, M>(\n  frames: readonly RuntimeIteratorFrame<E, M>[],\n  context: RunContext<readonly unknown[]>,\n  finalizers: readonly ExitFinalizer[],\n  result: Result<T, E | UnhandledException>,\n): Promise<Result<T, E | UnhandledException>> {\n  for (let index = frames.length - 1; index >= 0; index -= 1) {\n    const frame = frames[index];\n    if (frame !== undefined) closeGenerator(frame.iterator);\n  }\n  const exitCtx: ExitContext<T, E, readonly unknown[]> = {\n    signal: context.signal,\n    args: context.args,\n    result,\n  };\n  const cleanupFaults = await runFinalizersSafely(finalizers, exitCtx);\n  if (cleanupFaults.length > 0) {\n    const failures = result.isErr() ? [result.error, ...cleanupFaults] : cleanupFaults;\n    const cause = new ErrorGroup(failures, CLEANUP_FAILURE_MESSAGE);\n    const cleanupError = new UnhandledException({ cause });\n    return Result.err(cleanupError);\n  }\n  return result;\n}\n\nexport async function driveIterator<T, E, M>(\n  iter: Iterator<RuntimeInstruction<E, M>, T, unknown>,\n  context: RunContext<readonly unknown[]>,\n  settlement: AbortSettlement = AbortSettlement.passThrough,\n): Promise<Result<T, E | UnhandledException>> {\n  const finalizers: ExitFinalizer[] = [];\n  const rootFrame: RuntimeIteratorFrame<E, M> = {\n    iterator: iter,\n    finalizerArgs: undefined,\n  };\n  const frames: RuntimeIteratorFrame<E, M>[] = [rootFrame];\n  const settle = (result: Result<T, E | UnhandledException>) =>\n    settleIteratorWithCleanup(frames, context, finalizers, result);\n\n  try {\n    let step = advanceIteratorFrames(frames, false, undefined);\n    while (true) {\n      const current = frames[frames.length - 1];\n      if (current === undefined) {\n        throw new Error(\"Nested Op iterator stack lost its current frame\");\n      }\n\n      if (step.done) {\n        if (frames.length === 1) {\n          // SAFETY: only the root iterator remains, so its completed value has the declared T.\n          const value = await unsafeCoerce<T>(step.value);\n          return settle(Result.ok(value));\n        }\n\n        frames.pop();\n        step = advanceIteratorFrames(frames, false, step.value);\n        continue;\n      }\n\n      try {\n        if (step.value instanceof SuspendInstruction) {\n          const value = await resolveSuspendedInstruction(step.value, context, settlement);\n          step = advanceIteratorFrames(frames, false, value);\n          continue;\n        }\n        const instr = step.value;\n        if (instr instanceof RegisterExitFinalizerInstruction) {\n          registerExitFinalizerInstruction(instr, context.args, current.finalizerArgs, finalizers);\n          step = advanceIteratorFrames(frames, false, undefined);\n          continue;\n        }\n        if (instr instanceof NestedOpInstruction) {\n          step = enterNestedFrame(frames, current, instr);\n          continue;\n        }\n        if (isCustomInstruction(instr)) {\n          const value = await resolveCustomInstruction(instr, context, settlement);\n          step = advanceIteratorFrames(frames, false, value);\n          continue;\n        }\n        if (isErrInstruction<E>(instr)) {\n          return settle(Result.err(instr.error));\n        }\n        const invalidErr = new UnhandledException({\n          cause: new TypeError(\"Op generator yielded an invalid instruction\"),\n        });\n        return settle(Result.err(invalidErr));\n      } catch (cause) {\n        const unhandled = new UnhandledException({ cause });\n        return settle(Result.err(unhandled));\n      }\n    }\n  } catch (cause) {\n    const unhandled = new UnhandledException({ cause });\n    return settle(Result.err(unhandled));\n  }\n}\n\nasync function driveInternal<T, E, M>(\n  op: Op<T, E, [], M>,\n  context: RunContext<readonly unknown[]>,\n  settlement: AbortSettlement,\n): Promise<Result<T, E | UnhandledException>> {\n  try {\n    const ef = typeof op === \"function\" ? op() : op;\n    const iter = ef[Symbol.iterator]();\n    return driveIterator(iter, context, settlement);\n  } catch (cause) {\n    const unhandled = new UnhandledException({ cause });\n    return Result.err(unhandled);\n  }\n}\n\nexport function runOp<T, E, M>(op: Op<T, E, [], M>): Promise<Result<T, E | UnhandledException>> {\n  return drive(op, createRunContext(new AbortController().signal));\n}\n","import { abortReason } from \"@prodkit/shared/runtime\";\nimport { UnhandledException } from \"../errors.js\";\nimport { Result } from \"../result.js\";\nimport type { Plan } from \"../plan/model.js\";\nimport { SuspendInstruction } from \"./instructions.js\";\nimport type { RunContext } from \"./runtime.js\";\nimport {\n  AbortSettlement,\n  awaitWithAbort,\n  withAbortDrain,\n  withAbortOwnership,\n} from \"./abort-settlement.js\";\n\ntype MapChildContext = (parent: RunContext<readonly unknown[]>) => RunContext<readonly unknown[]>;\n\nfunction runPlan<T, E, M>(\n  plan: Plan<T, E, M>,\n  context: RunContext<readonly unknown[]>,\n  settlement: AbortSettlement,\n): Promise<Result<T, E | UnhandledException>> {\n  return plan.execute(context, settlement);\n}\n\nfunction interruptOnAbort(signal: AbortSignal): AbortSettlement {\n  return AbortSettlement.interruptOnAbort(() => abortReason(signal));\n}\n\n/**\n * Named settlement operations for nested plans, observed suspend work, and DI lazy resolve.\n *\n * Contributor call sites choose one operation directly. Driver-only abort mechanics remain in\n * `abort-settlement.ts`.\n */\nexport const Settlement = {\n  abortOwned: {\n    suspend<T>(\n      start: (context: RunContext<readonly unknown[]>) => PromiseLike<T>,\n    ): SuspendInstruction {\n      return new SuspendInstruction((context) => withAbortOwnership(start(context)));\n    },\n  },\n\n  cooperative: {\n    runPlan<T, E, M>(\n      plan: Plan<T, E, M>,\n      context: RunContext<readonly unknown[]>,\n    ): Promise<Result<T, E | UnhandledException>> {\n      return runPlan(plan, context, AbortSettlement.passThrough);\n    },\n\n    suspendPlan<T, E, M>(plan: Plan<T, E, M>): SuspendInstruction {\n      return new SuspendInstruction((context) =>\n        runPlan(plan, context, AbortSettlement.passThrough),\n      );\n    },\n  },\n\n  rejecting: {\n    awaitWork<T>(work: PromiseLike<T>, signal: AbortSignal): PromiseLike<T> {\n      return awaitWithAbort(\n        work,\n        signal,\n        AbortSettlement.rejectOnAbort(() => abortReason(signal)),\n      );\n    },\n  },\n\n  interrupting: {\n    runPlan<T, E, M>(\n      plan: Plan<T, E, M>,\n      context: RunContext<readonly unknown[]>,\n    ): Promise<Result<T, E | UnhandledException>> {\n      return runPlan(plan, context, interruptOnAbort(context.signal));\n    },\n  },\n\n  interruptingAndDraining: {\n    suspend<T>(\n      start: (context: RunContext<readonly unknown[]>) => PromiseLike<T>,\n    ): SuspendInstruction {\n      return new SuspendInstruction((context) => withAbortDrain(start(context)));\n    },\n\n    suspendPlan<T, E, M>(plan: Plan<T, E, M>, mapContext?: MapChildContext): SuspendInstruction {\n      return new SuspendInstruction((context) => {\n        const mapped = mapContext?.(context) ?? context;\n        const work = runPlan(plan, mapped, interruptOnAbort(mapped.signal));\n        return withAbortDrain(work);\n      });\n    },\n  },\n} as const;\n","import { UnhandledException } from \"../errors.js\";\nimport { Result } from \"../result.js\";\nimport { unsafeCoerce } from \"@prodkit/shared/runtime\";\nimport type { TrackedErr } from \"../core/surface.js\";\nimport { executePlan, type RunContext } from \"../execution/runtime.js\";\nimport type { RuntimeInstruction } from \"../execution/instructions.js\";\nimport type { AbortSettlement } from \"../execution/abort-settlement.js\";\nimport type { EmptyMeta } from \"../core/metadata.js\";\n\nconst PLAN_UNARY_REWRITE: unique symbol = Symbol(\"prodkit.op.plan-unary-rewrite\");\nconst PLAN_FACTORY_CHAIN: unique symbol = Symbol(\"prodkit.op.plan-factory-chain\");\n\ntype PlanInstruction<_E, M> = RuntimeInstruction<unknown, M>;\ntype PlanIterator<T, E, M> = Generator<PlanInstruction<E, M>, T, unknown>;\ntype ErasedPlan = Plan<unknown, unknown, unknown>;\nexport type ErasedPlanFactory = (...args: readonly unknown[]) => ErasedPlan;\nexport type ErasedPlanTransform = (plan: ErasedPlan) => ErasedPlan;\nexport type TransformKind = \"unaryWrap\" | \"pushPolicy\" | \"boundary\";\n\ntype UnaryPlanRewrite = {\n  readonly source: ErasedPlan;\n  readonly rebuild: (rewrittenSource: ErasedPlan) => ErasedPlan;\n};\ntype PlanTransformNode = {\n  readonly previous: PlanTransformNode | undefined;\n  readonly transform: ErasedPlanTransform;\n  readonly kind: TransformKind;\n};\ntype PlanFactoryChain = {\n  readonly base: ErasedPlanFactory;\n  readonly tail: PlanTransformNode | undefined;\n};\ntype ChainablePlanFactory = ErasedPlanFactory & {\n  readonly [PLAN_FACTORY_CHAIN]?: PlanFactoryChain;\n};\n\nexport interface Plan<T, E, M = EmptyMeta> {\n  readonly execute: (\n    context: RunContext<readonly unknown[]>,\n    settlement?: AbortSettlement,\n  ) => Promise<Result<T, E | UnhandledException>>;\n  readonly [PLAN_UNARY_REWRITE]?: UnaryPlanRewrite;\n  readonly iterate: () => PlanIterator<T, E, M>;\n  readonly rewrite: <TNext, ENext, MNext>(rewriter: PlanRewriter) => Plan<TNext, ENext, MNext>;\n}\n\n/**\n * Internal rewrite protocol for policy attachment. Built-in policies supply `apply` to wrap leaf\n * plans; wrapper nodes rebuild themselves via `source.rewrite(rewriter)` (see `rewriteUnaryPlan`).\n *\n * When adding a new fluent transform, see \"Adding a fluent plan transform\" in\n * `docs/contributor/runtime-architecture.md`.\n */\nexport interface PlanRewriter {\n  readonly apply: <T, E, M>(source: Plan<T, E, M>) => Plan<unknown, unknown, unknown>;\n}\n\n/** Rebuild a unary wrapper after rewriting its child plan (standard policy push-through). */\nexport function rewriteUnaryPlan<T, E, M>(\n  rewriter: PlanRewriter,\n  source: Plan<T, E, M>,\n  rebuild: (rewrittenSource: Plan<T, E, M>) => Plan<unknown, unknown, unknown>,\n): Plan<unknown, unknown, unknown> {\n  // SAFETY: rewrite metadata erases source generics; the caller-owned rebuild restores the wrapper-local source type.\n  const erasedSource: ErasedPlan = unsafeCoerce(source);\n  const rewritten = rewriteUnaryPlanChain(erasedSource, rewriter);\n  // SAFETY: rewriteUnaryPlanChain rewrites the same source slot captured by this unary wrapper.\n  const typedRewritten: Plan<T, E, M> = unsafeCoerce(rewritten);\n  return rebuild(typedRewritten);\n}\n\ninterface PlanRewriteOverrides<T, E, M> {\n  readonly rewrite?: (\n    self: Plan<T, E, M>,\n    rewriter: PlanRewriter,\n  ) => Plan<unknown, unknown, unknown>;\n}\n\nexport function createPlan<T, E, M>(\n  iterate: () => PlanIterator<T, E, M>,\n  overrides: PlanRewriteOverrides<T, E, M> = {},\n): Plan<T, E, M> {\n  const plan: Plan<T, E, M> = {\n    execute: (context, settlement) => executePlan(plan, context, settlement),\n    iterate,\n    rewrite: (rewriter) => {\n      const rewritten = overrides.rewrite?.(plan, rewriter) ?? rewriter.apply(plan);\n      // SAFETY: rewriter.apply loses rewritten generics; the caller's rewriter targets TNext, ENext, MNext.\n      return unsafeCoerce(rewritten);\n    },\n  };\n  return plan;\n}\n\nexport function createUnaryPlan<T, E, M, TSource, ESource, MSource>(\n  iterate: () => PlanIterator<T, E, M>,\n  source: Plan<TSource, ESource, MSource>,\n  rebuild: (rewrittenSource: Plan<TSource, ESource, MSource>) => Plan<unknown, unknown, unknown>,\n): Plan<T, E, M> {\n  // SAFETY: unary rewrite metadata is intentionally erased so one iterative walk can collect heterogenous frames.\n  const erasedSource: ErasedPlan = unsafeCoerce(source);\n  const erasedRebuild: UnaryPlanRewrite[\"rebuild\"] = (rewrittenSource) => {\n    // SAFETY: rewrittenSource is produced by rewriting the same source slot captured above.\n    const typedSource: Plan<TSource, ESource, MSource> = unsafeCoerce(rewrittenSource);\n    return rebuild(typedSource);\n  };\n  const plan = createPlan(iterate, {\n    rewrite: (_self, rewriter) => rewriteUnaryPlan(rewriter, source, rebuild),\n  });\n  Object.defineProperty(plan, PLAN_UNARY_REWRITE, {\n    value: { source: erasedSource, rebuild: erasedRebuild } satisfies UnaryPlanRewrite,\n  });\n  return plan;\n}\n\ntype UnaryWrapWalk = {\n  readonly base: ErasedPlan;\n  /** innermost-first rebuild callbacks (fluent call order) */\n  readonly rebuilds: ReadonlyArray<UnaryPlanRewrite[\"rebuild\"]>;\n};\n\nfunction walkUnaryWraps(plan: ErasedPlan): UnaryWrapWalk {\n  const collected: UnaryPlanRewrite[\"rebuild\"][] = [];\n  let current = plan;\n\n  while (true) {\n    const unary = current[PLAN_UNARY_REWRITE];\n    if (unary === undefined) break;\n    collected.push(unary.rebuild);\n    current = unary.source;\n  }\n\n  collected.reverse();\n  return { base: current, rebuilds: collected };\n}\n\nfunction rebuildUnaryWraps(\n  base: ErasedPlan,\n  rebuilds: readonly UnaryPlanRewrite[\"rebuild\"][],\n  rewriteBase: (plan: ErasedPlan) => ErasedPlan,\n): ErasedPlan {\n  let rebuilt = rewriteBase(base);\n  for (const rebuild of rebuilds) {\n    rebuilt = rebuild(rebuilt);\n  }\n  return rebuilt;\n}\n\nexport function appendPlanTransform(\n  factory: ErasedPlanFactory,\n  transform: ErasedPlanTransform,\n  kind: TransformKind,\n): ErasedPlanFactory {\n  const chain = getPlanFactoryChain(factory);\n  const tail: PlanTransformNode = { previous: chain.tail, transform, kind };\n  const next: ErasedPlanFactory = (...args) => applyPlanTransforms(chain.base(...args), tail);\n  Object.defineProperty(next, PLAN_FACTORY_CHAIN, {\n    value: { base: chain.base, tail } satisfies PlanFactoryChain,\n  });\n  return next;\n}\n\nfunction getPlanFactoryChain(factory: ErasedPlanFactory): PlanFactoryChain {\n  const chainable: ChainablePlanFactory = factory;\n  return chainable[PLAN_FACTORY_CHAIN] ?? { base: factory, tail: undefined };\n}\n\nfunction applyPlanTransforms(source: ErasedPlan, tail: PlanTransformNode): ErasedPlan {\n  const nodes: PlanTransformNode[] = [];\n  let hasPushPolicy = false;\n  for (let node: PlanTransformNode | undefined = tail; node !== undefined; node = node.previous) {\n    nodes.push(node);\n    if (node.kind === \"pushPolicy\") hasPushPolicy = true;\n  }\n\n  let base = source;\n  const pendingUnaryWraps: ErasedPlanTransform[] = [];\n\n  // Normalize an already-materialized unary entry once so stacked push-through policies do not\n  // repeatedly walk and rebuild the same prefix.\n  if (hasPushPolicy) {\n    const { base: unaryBase, rebuilds } = walkUnaryWraps(source);\n    base = unaryBase;\n    for (const wrap of rebuilds) pendingUnaryWraps.push(wrap);\n  }\n\n  const materialize = () => {\n    for (let index = 0; index < pendingUnaryWraps.length; index += 1) {\n      const wrap = pendingUnaryWraps[index];\n      if (wrap !== undefined) base = wrap(base);\n    }\n    pendingUnaryWraps.length = 0;\n  };\n\n  // nodes is tail..head; iterate head..tail to apply transforms in fluent-call order.\n  for (let index = nodes.length - 1; index >= 0; index -= 1) {\n    const node = nodes[index];\n    if (node === undefined) continue;\n\n    if (node.kind === \"unaryWrap\") {\n      pendingUnaryWraps.push(node.transform);\n      continue;\n    }\n\n    if (node.kind === \"pushPolicy\") {\n      // Deferred unary wraps leave base at the nearest non-unary policy target.\n      base = node.transform(base);\n      continue;\n    }\n\n    materialize();\n    base = node.transform(base);\n  }\n\n  materialize();\n  return base;\n}\n\nfunction rewriteUnaryPlanChain(source: ErasedPlan, rewriter: PlanRewriter): ErasedPlan {\n  const walk = walkUnaryWraps(source);\n  return rebuildUnaryWraps(walk.base, walk.rebuilds, (base) => base.rewrite(rewriter));\n}\n\nexport function genPlan<T, E, M>(\n  gen: () => Generator<RuntimeInstruction<E, M>, T, unknown>,\n): Plan<T, TrackedErr<E>, M> {\n  return createPlan(() => gen());\n}\n"],"mappings":"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"}