{"version":3,"file":"shell-BvfnSdtw.mjs","names":[],"sources":["../src/plan/bridge.ts","../src/plan/lifecycle.ts","../src/plan/transforms.ts","../src/core/shell.ts"],"sourcesContent":["import { unsafeCoerce } from \"@prodkit/shared/runtime\";\nimport type { Op } from \"../index.js\";\nimport type { AsArgs, OpInterface } from \"../core/surface.js\";\nimport type { Plan } from \"./model.js\";\n\nexport const OP_PLAN_BIND: unique symbol = Symbol(\"prodkit.op.plan-bind\");\n\nexport type PlanBinder<T, E, A, M> = (...args: AsArgs<A>) => Plan<T, E, M>;\n\nexport type PlanBackedOp<T, E, A, M> = OpInterface<T, E, A, M> & {\n  readonly [OP_PLAN_BIND]: PlanBinder<T, E, A, M>;\n};\n\nexport function getPlan<T, E, A, M>(op: Op<T, E, A, M>, args: AsArgs<A>): Plan<T, E, M> {\n  // SAFETY: Op's public type intentionally hides its internal plan binder.\n  const bindPlan = unsafeCoerce<Partial<PlanBackedOp<T, E, A, M>>>(op)[OP_PLAN_BIND];\n  if (typeof bindPlan !== \"function\") {\n    throw new TypeError(\"Expected an Op created by @prodkit/op\");\n  }\n  return bindPlan(...args);\n}\n","import { UnhandledException } from \"../errors.js\";\nimport { Result } from \"../result.js\";\nimport { unsafeCoerce } from \"@prodkit/shared/runtime\";\nimport { RegisterExitFinalizerInstruction, SuspendInstruction } from \"../execution/instructions.js\";\nimport { Settlement } from \"../execution/settlement.js\";\nimport type { EnterContext, EnterFn, ExitFn } from \"../core/lifecycle.js\";\nimport type { ExitContext } from \"../execution/runtime.js\";\nimport { createUnaryPlan, type Plan } from \"./model.js\";\n\nexport function onEnterPlan<T, E, A, M>(\n  source: Plan<T, E, M>,\n  initialize: EnterFn<A>,\n): Plan<T, E, M> {\n  return createUnaryPlan(\n    function* () {\n      yield new SuspendInstruction(async (context) => {\n        const enterCtx: EnterContext<A> = {\n          signal: context.signal,\n          // SAFETY: RunContext stores args as readonly unknown[]; they are the tuple from this op's invocation.\n          args: unsafeCoerce(context.args),\n        };\n        await Promise.resolve(initialize(enterCtx));\n      });\n\n      const result: Result<T, E | UnhandledException> =\n        yield* Settlement.cooperative.suspendPlan(source);\n\n      if (result.isErr()) return yield* result;\n      return result.value;\n    },\n    source,\n    (inner) => onEnterPlan(inner, initialize),\n  );\n}\n\nexport function onExitPlan<T, E, A, M>(\n  source: Plan<T, E, M>,\n  finalize: ExitFn<T, E, A>,\n): Plan<T, E, M> {\n  return createUnaryPlan(\n    function* () {\n      yield new RegisterExitFinalizerInstruction(async (ctx) => {\n        const exitCtx: ExitContext<T, E, A> = {\n          signal: ctx.signal,\n          // SAFETY: ExitFinalizerContext erases result; this hook is registered by the enclosing plan for T, E.\n          result: unsafeCoerce(ctx.result),\n          // SAFETY: RunContext stores args as readonly unknown[]; they are the tuple from this op's invocation.\n          args: unsafeCoerce(ctx.args),\n        };\n        await Promise.resolve(finalize(exitCtx));\n      }, undefined);\n\n      const result: Result<T, E | UnhandledException> =\n        yield* Settlement.cooperative.suspendPlan(source);\n\n      if (result.isErr()) return yield* result;\n      return result.value;\n    },\n    source,\n    (inner) => onExitPlan(inner, finalize),\n  );\n}\n","import { unsafeCoerce } from \"@prodkit/shared/runtime\";\nimport { TimeoutError, UnhandledException } from \"../errors.js\";\nimport { Result } from \"../result.js\";\nimport { SuspendInstruction } from \"../execution/instructions.js\";\nimport { Settlement } from \"../execution/settlement.js\";\nimport type {\n  AnyNullaryOp,\n  BypassedErr,\n  InferOpErr,\n  InferOpMeta,\n  InferOpOk,\n  TrackedErr,\n} from \"../core/surface.js\";\nimport type { MergeMeta } from \"../core/metadata.js\";\nimport { getPlan } from \"./bridge.js\";\nimport { createPlan, createUnaryPlan, type Plan } from \"./model.js\";\n\nfunction isRuntimeBypass(error: unknown): error is UnhandledException | TimeoutError {\n  return UnhandledException.is(error) || TimeoutError.is(error);\n}\n\nfunction trackedDomainError<E>(error: unknown): TrackedErr<E> | undefined {\n  if (isRuntimeBypass(error)) return undefined;\n  // SAFETY: TS cannot narrow E to TrackedErr<E> after the bypass guard; bypass faults return above.\n  return unsafeCoerce(error);\n}\n\nexport function mapPlan<T, E, U, M>(\n  source: Plan<T, E, M>,\n  transform: (value: T) => U,\n): Plan<Awaited<U>, E, M> {\n  return createUnaryPlan(\n    function* () {\n      const result: Result<T, E | UnhandledException> =\n        yield* Settlement.cooperative.suspendPlan(source);\n\n      if (result.isErr()) return yield* result;\n\n      const mapped: Awaited<U> = yield* new SuspendInstruction(() =>\n        Promise.resolve(transform(result.value)),\n      );\n\n      return mapped;\n    },\n    source,\n    (inner) => mapPlan(inner, transform),\n  );\n}\n\n/**\n * No `rewrite` override: policies wrap the whole `flatMap` node via `rewriter.apply` so retry\n * re-executes source and bind together (see `fluent.test.ts`, flatMap + Policy.retry).\n */\nexport function flatMapPlan<T, E, R extends AnyNullaryOp, M>(\n  source: Plan<T, E, M>,\n  bind: (value: T) => R,\n): Plan<InferOpOk<R>, E | InferOpErr<R>, MergeMeta<M, InferOpMeta<R>>> {\n  return createPlan(function* () {\n    const first: Result<T, E | UnhandledException> =\n      yield* Settlement.cooperative.suspendPlan(source);\n\n    if (first.isErr()) return yield* first;\n\n    const second: Result<\n      InferOpOk<R>,\n      InferOpErr<R> | UnhandledException\n    > = yield* Settlement.cooperative.suspendPlan(getPlan(bind(first.value), []));\n\n    if (second.isErr()) return yield* second;\n    return second.value;\n  });\n}\n\nexport function tapPlan<T, E, R, M>(\n  source: Plan<T, E, M>,\n  observe: (value: T) => R,\n): Plan<T, E, M> {\n  return createUnaryPlan(\n    function* () {\n      const sourceResult: Result<T, E | UnhandledException> =\n        yield* Settlement.cooperative.suspendPlan(source);\n\n      if (sourceResult.isErr()) return yield* sourceResult;\n\n      yield* new SuspendInstruction(() => Promise.resolve(observe(sourceResult.value)));\n      return sourceResult.value;\n    },\n    source,\n    (inner) => tapPlan(inner, observe),\n  );\n}\n\nexport function mapErrPlan<T, E, E2, M>(\n  source: Plan<T, E, M>,\n  transform: (error: TrackedErr<E>) => E2,\n): Plan<T, E2 | BypassedErr<E>, M> {\n  return createUnaryPlan(\n    function* () {\n      const result: Result<T, E | UnhandledException> =\n        yield* Settlement.cooperative.suspendPlan(source);\n\n      if (result.isOk()) return result.value;\n\n      const domainError = trackedDomainError<E>(result.error);\n      if (domainError === undefined) return yield* result;\n\n      const mapped: E2 = yield* new SuspendInstruction(() =>\n        Promise.resolve(transform(domainError)),\n      );\n\n      return yield* Result.err(mapped);\n    },\n    source,\n    (inner) => mapErrPlan(inner, transform),\n  );\n}\n\nexport function tapErrPlan<T, E, R, M>(\n  source: Plan<T, E, M>,\n  observe: (error: TrackedErr<E>) => R,\n): Plan<T, TrackedErr<E> | BypassedErr<E>, M> {\n  return createUnaryPlan(\n    function* () {\n      const sourceResult: Result<T, E | UnhandledException> =\n        yield* Settlement.cooperative.suspendPlan(source);\n\n      if (sourceResult.isOk()) return sourceResult.value;\n\n      const domainError = trackedDomainError<E>(sourceResult.error);\n      if (domainError === undefined) return yield* sourceResult;\n\n      yield* new SuspendInstruction(() => Promise.resolve(observe(domainError)));\n      return yield* sourceResult;\n    },\n    source,\n    (inner) => tapErrPlan(inner, observe),\n  );\n}\n\nexport function recoverPlan<T, E, ECaught extends TrackedErr<E>, R, M>(\n  source: Plan<T, E, M>,\n  predicate: (error: TrackedErr<E>) => error is ECaught,\n  handler: (error: ECaught) => R,\n): Plan<T | Awaited<R>, TrackedErr<E, ECaught> | BypassedErr<E>, M> {\n  return createUnaryPlan(\n    function* () {\n      const result: Result<T, E | UnhandledException> =\n        yield* Settlement.cooperative.suspendPlan(source);\n\n      if (result.isOk()) return result.value;\n\n      const error = trackedDomainError<E>(result.error);\n      if (error === undefined) return yield* result;\n\n      if (!predicate(error)) return yield* result;\n\n      const recovered: Awaited<R> = yield* new SuspendInstruction(() =>\n        Promise.resolve(handler(error)),\n      );\n\n      return recovered;\n    },\n    source,\n    (inner) => recoverPlan(inner, predicate, handler),\n  );\n}\n","import { Result } from \"../result.js\";\nimport { unsafeCoerce } from \"@prodkit/shared/runtime\";\nimport { createRunContext } from \"../execution/runtime.js\";\nimport { Settlement } from \"../execution/settlement.js\";\nimport {\n  NestedOpInstruction,\n  SuspendInstruction,\n  type RuntimeInstruction,\n} from \"../execution/instructions.js\";\nimport type { UnhandledException } from \"../errors.js\";\nimport type { Op } from \"../index.js\";\nimport type { OpPolicy, OpPolicyInput, OpPolicySource } from \"../policy/types.js\";\nimport type { HKT } from \"../hkt.js\";\nimport type { EnterFn, ExitFn, OpLifecycleHook } from \"./lifecycle.js\";\nimport type { AnyNullaryOp, AsArgs, OpInterface, TrackedErr } from \"./surface.js\";\nimport type { RunContext } from \"../execution/runtime.js\";\nimport type { EmptyMeta } from \"./metadata.js\";\nimport {\n  appendPlanTransform,\n  createPlan,\n  type ErasedPlanFactory,\n  type ErasedPlanTransform,\n  type Plan,\n  type PlanRewriter,\n  type TransformKind,\n} from \"../plan/model.js\";\nimport { OP_PLAN_BIND, type PlanBackedOp, type PlanBinder } from \"../plan/bridge.js\";\nimport { onEnterPlan, onExitPlan } from \"../plan/lifecycle.js\";\nimport {\n  flatMapPlan,\n  mapErrPlan,\n  mapPlan,\n  recoverPlan,\n  tapErrPlan,\n  tapPlan,\n} from \"../plan/transforms.js\";\n\ntype PlanShellContext<T, E, A, M> = {\n  bindArgs: PlanBinder<T, E, A, M>;\n  makeIterable: () => Plan<T, E, M>;\n  bound: boolean;\n};\n\ntype PolicyWrapFn = <TNext, ENext, MNext>(\n  transform: (plan: Plan<unknown, unknown, unknown>) => Plan<TNext, ENext, MNext>,\n  kind: TransformKind,\n) => unknown;\n\nclass PolicySourceImpl {\n  wrapPlan: PolicyWrapFn;\n\n  constructor(wrapPlan: PolicyWrapFn) {\n    this.wrapPlan = wrapPlan;\n  }\n\n  wrap<T, E, A, M, TNext, ENext, MNext>(\n    transform: (plan: Plan<T, E, M>) => Plan<TNext, ENext, MNext>,\n  ): Op<TNext, ENext, AsArgs<A>, MNext> {\n    // SAFETY: PolicyWrapFn returns unknown; wrapPlanTransform builds an Op shell with TNext, ENext, and A.\n    return unsafeCoerce<Op<TNext, ENext, AsArgs<A>, MNext>>(\n      this.wrapPlan(\n        // SAFETY: PolicyWrapFn erases plan generics; transform closes over the source plan's T, E, M.\n        unsafeCoerce(transform),\n        \"boundary\",\n      ),\n    );\n  }\n\n  rewrite<A, TNext, ENext, MNext>(rewriter: PlanRewriter): Op<TNext, ENext, AsArgs<A>, MNext> {\n    // SAFETY: PolicyWrapFn returns unknown; rewrite already targeted TNext, ENext, MNext on the inner plan.\n    return unsafeCoerce<Op<TNext, ENext, AsArgs<A>, MNext>>(\n      this.wrapPlan((plan) => plan.rewrite<TNext, ENext, MNext>(rewriter), \"pushPolicy\"),\n    );\n  }\n\n  around<T, E, A, M, TNext, ENext, MNext = M>(\n    run: (\n      next: (context: RunContext<readonly unknown[]>) => Promise<Result<T, E | UnhandledException>>,\n      context: RunContext<readonly unknown[]>,\n    ) => PromiseLike<Result<TNext, ENext | UnhandledException>>,\n  ): Op<TNext, ENext, AsArgs<A>, MNext> {\n    // SAFETY: PolicyWrapFn returns unknown; around() middleware was typed against the source plan's T, E, M.\n    return unsafeCoerce<Op<TNext, ENext, AsArgs<A>, MNext>>(\n      this.wrapPlan((plan) => {\n        // SAFETY: PolicyWrapFn erases plan to unknown; around() closes over T, E, M and only runs typedPlan.\n        const typedPlan: Plan<T, E, M> = unsafeCoerce(plan);\n        return createPlan<TNext, ENext, MNext>(function* () {\n          const result: Result<TNext, ENext | UnhandledException> = yield* new SuspendInstruction(\n            (context) =>\n              run((nextContext) => Settlement.cooperative.runPlan(typedPlan, nextContext), context),\n          );\n\n          if (result.isErr()) return yield* result;\n          return result.value;\n        });\n      }, \"boundary\"),\n    );\n  }\n}\n\nfunction wrapPlanTransform<T, E, A, M, Yieldable extends boolean, TNext, ENext, MNext>(\n  ctx: PlanShellContext<T, E, A, M>,\n  transform: (plan: Plan<T, E, M>) => Plan<TNext, ENext, MNext>,\n  kind: TransformKind,\n): OpInterface<TNext, ENext, A, MNext, Yieldable> {\n  const bindArgs = appendPlanBinder(ctx.bindArgs, transform, kind);\n  const makeIterable = appendPlanProvider(ctx.makeIterable, transform, kind);\n\n  return planOpShell<TNext, ENext, A, MNext, Yieldable>(bindArgs, ctx.bound, makeIterable);\n}\n\nfunction appendPlanBinder<T, E, A, M, TNext, ENext, MNext>(\n  bindArgs: PlanBinder<T, E, A, M>,\n  transform: (plan: Plan<T, E, M>) => Plan<TNext, ENext, MNext>,\n  kind: TransformKind,\n): PlanBinder<TNext, ENext, A, MNext> {\n  // SAFETY: transform chains erase plan generics until bind time, then restore the typed binder surface.\n  const erasedBindArgs: ErasedPlanFactory = unsafeCoerce(bindArgs);\n  // SAFETY: transform closes over the source plan generics; the erased chain preserves transform order only.\n  const erasedTransform: ErasedPlanTransform = unsafeCoerce(transform);\n  const appended = appendPlanTransform(erasedBindArgs, erasedTransform, kind);\n  // SAFETY: appended binder keeps the original args tuple and returns the transform's next plan type.\n  return unsafeCoerce(appended);\n}\n\nfunction appendPlanProvider<T, E, M, TNext, ENext, MNext>(\n  provider: () => Plan<T, E, M>,\n  transform: (plan: Plan<T, E, M>) => Plan<TNext, ENext, MNext>,\n  kind: TransformKind,\n): () => Plan<TNext, ENext, MNext> {\n  // SAFETY: iterable providers are nullary plan factories; only plan generics are erased in the chain.\n  const erasedProvider: ErasedPlanFactory = unsafeCoerce(provider);\n  // SAFETY: transform closes over the source plan generics; the erased chain preserves transform order only.\n  const erasedTransform: ErasedPlanTransform = unsafeCoerce(transform);\n  const appended = appendPlanTransform(erasedProvider, erasedTransform, kind);\n  // SAFETY: appended provider returns the transform's next plan type.\n  return unsafeCoerce(appended);\n}\n\nfunction* nestedPlanIterator<T, E, M>(\n  iterate: () => Generator<RuntimeInstruction<E, M>, T, unknown>,\n): Generator<RuntimeInstruction<E, M>, T, unknown> {\n  // SAFETY: the driver resumes NestedOpInstruction with the completed child iterator value T.\n  return unsafeCoerce<T>(yield new NestedOpInstruction(iterate));\n}\n\nfunction fluentMethodsForContext<T, E, A, M, Yieldable extends boolean>(\n  ctx: PlanShellContext<T, E, A, M>,\n) {\n  const wrap = <TNext, ENext, MNext>(\n    transform: (plan: Plan<T, E, M>) => Plan<TNext, ENext, MNext>,\n    kind: TransformKind = \"unaryWrap\",\n  ) => wrapPlanTransform<T, E, A, M, Yieldable, TNext, ENext, MNext>(ctx, transform, kind);\n\n  // SAFETY: PolicySourceImpl is structural but unbranded; methods delegate through wrap with the same generics.\n  const policySource: OpPolicySource<T, E, AsArgs<A>, M> = unsafeCoerce(new PolicySourceImpl(wrap));\n\n  return {\n    with: <F extends HKT>(policy: OpPolicy<OpPolicyInput<T, E, AsArgs<A>, M>, F>) =>\n      policy.apply(policySource),\n    on: (event: OpLifecycleHook, handler: unknown) => {\n      if (event === \"enter\") {\n        // SAFETY: on() types handler as unknown; the enter branch only runs when event === \"enter\".\n        const initialize: EnterFn<A> = unsafeCoerce(handler);\n        return wrap((plan) => onEnterPlan(plan, initialize));\n      }\n\n      if (event === \"exit\") {\n        // SAFETY: on() types handler as unknown; the exit branch only runs when event === \"exit\".\n        const finalize: ExitFn<T, E, A> = unsafeCoerce(handler);\n        return wrap((plan) => onExitPlan(plan, finalize));\n      }\n\n      throw new Error(`Invalid event: ${event}`);\n    },\n    map: <U>(transform: (value: T) => U) => wrap((plan) => mapPlan(plan, transform)),\n    mapErr: <E2>(transform: (error: TrackedErr<E>) => E2) =>\n      wrap((plan) => mapErrPlan(plan, transform)),\n    flatMap: <R extends AnyNullaryOp>(bind: (value: T) => R) =>\n      wrap((plan) => flatMapPlan(plan, bind), \"boundary\"),\n    tap: <R>(observe: (value: T) => R) => wrap((plan) => tapPlan(plan, observe)),\n    tapErr: <R>(observe: (error: TrackedErr<E>) => R) => wrap((plan) => tapErrPlan(plan, observe)),\n    recover: <ECaught extends TrackedErr<E>, R>(\n      predicate: (error: TrackedErr<E>) => error is ECaught,\n      handler: (error: ECaught) => R,\n    ) => wrap((plan) => recoverPlan(plan, predicate, handler)),\n  };\n}\n\nfunction syncValueShellContext<T>(\n  self: SyncValueOpShell<T>,\n): PlanShellContext<T, never, [], EmptyMeta> {\n  return {\n    bindArgs: () => self[OP_PLAN_BIND](),\n    makeIterable: () => self[OP_PLAN_BIND](),\n    bound: true,\n  };\n}\n\nfunction createSyncValueFluentPrototype(): PropertyDescriptorMap {\n  type FluentMethod = keyof ReturnType<\n    typeof fluentMethodsForContext<unknown, never, [], EmptyMeta, true>\n  >;\n\n  const bindMethod = <K extends FluentMethod>(name: K): PropertyDescriptor => ({\n    value(this: SyncValueOpShell<unknown>, ...args: unknown[]) {\n      const methods = fluentMethodsForContext<unknown, never, [], EmptyMeta, true>(\n        syncValueShellContext(this),\n      );\n\n      // SAFETY: prototype dispatch erases generics; name is a FluentMethod key from the same methods table.\n      const method: (...methodArgs: unknown[]) => unknown = unsafeCoerce(methods[name]);\n      return method(...args);\n    },\n  });\n\n  const methodNames = [\n    \"with\",\n    \"on\",\n    \"map\",\n    \"mapErr\",\n    \"flatMap\",\n    \"tap\",\n    \"tapErr\",\n    \"recover\",\n  ] as const satisfies readonly FluentMethod[];\n\n  return Object.fromEntries(methodNames.map((name) => [name, bindMethod(name)]));\n}\n\nfunction planOpShell<\n  T,\n  E,\n  A,\n  M = EmptyMeta,\n  Yieldable extends boolean = A extends [] ? true : false,\n>(\n  bindArgs: PlanBinder<T, E, A, M>,\n  bound: boolean,\n  makeIterable: () => Plan<T, E, M>,\n): OpInterface<T, E, A, M, Yieldable> {\n  let self: OpInterface<T, E, A, M, Yieldable>;\n  const invoke = bound\n    ? () => self\n    : (...args: AsArgs<A>) => makeBoundPlanOp(() => bindArgs(...args));\n\n  const shellContext: PlanShellContext<T, E, A, M> = {\n    bindArgs,\n    makeIterable,\n    bound,\n  };\n\n  // SAFETY: Object.assign builds a callable Object without Op branding; invoke/run/methods match generic inputs.\n  self = unsafeCoerce(\n    Object.assign(invoke, {\n      [OP_PLAN_BIND]: bindArgs,\n      run: (...args: AsArgs<A>) =>\n        bindArgs(...args).execute(createRunContext(new AbortController().signal, args)),\n      ...fluentMethodsForContext<T, E, A, M, Yieldable>(shellContext),\n      [Symbol.iterator]: () => nestedPlanIterator(makeIterable().iterate),\n      _tag: \"Op\" as const,\n    }),\n  );\n\n  return self;\n}\n\n/** Builds a bound nullary Op shell backed by the internal plan model. */\nexport function makeBoundPlanOp<T, E, M>(\n  bindArgs: PlanBinder<T, E, [], M>,\n): OpInterface<T, E, [], M, true> {\n  return planOpShell(bindArgs, true, () => bindArgs());\n}\n\n/** Builds an unbound Op shell with an explicit yield* iterable provider. */\nexport function makeUnboundPlanOp<T, E, A, M = EmptyMeta>(\n  bindArgs: PlanBinder<T, E, A, M>,\n  makeIterable: () => Plan<T, E, M>,\n): OpInterface<T, E, A, M, A extends [] ? true : false> {\n  return planOpShell(bindArgs, false, makeIterable);\n}\n\ntype SyncValueOpShell<T> = (() => SyncValueOpShell<T>) &\n  PlanBackedOp<T, never, [], EmptyMeta> &\n  OpInterface<T, never, [], EmptyMeta, true> & {\n    readonly [SYNC_VALUE]: T;\n    readonly [SYNC_RUN]?: () => Promise<Result<T, never>>;\n  };\n\nconst SYNC_VALUE: unique symbol = Symbol(\"prodkit.op.sync-value\");\nconst SYNC_RUN: unique symbol = Symbol(\"prodkit.op.sync-run\");\n\nfunction* syncValueIterator<T>(value: T): Generator<never, T, unknown> {\n  return value;\n}\n\nfunction getSyncValueRun<T>(this: SyncValueOpShell<T>): () => Promise<Result<T, never>> {\n  const cached = this[SYNC_RUN];\n  if (cached !== undefined) return cached;\n\n  const value = this[SYNC_VALUE];\n  const run = () => Promise.resolve(Result.ok(value));\n  Object.defineProperty(this, SYNC_RUN, { value: run });\n  return run;\n}\n\nfunction syncValueIterable<T>(this: SyncValueOpShell<T>): Generator<never, T, unknown> {\n  return syncValueIterator(this[SYNC_VALUE]);\n}\n\nfunction createSyncValuePlan<T>(value: T): Plan<T, never, EmptyMeta> {\n  let plan: Plan<T, never, EmptyMeta>;\n  plan = {\n    execute: () => Promise.resolve(Result.ok(value)),\n    iterate: () => syncValueIterator(value),\n    rewrite: (rewriter) => {\n      // SAFETY: sync value plans have no local error channel; the rewriter owns the rewritten generics.\n      return unsafeCoerce(rewriter.apply(plan));\n    },\n  };\n  return plan;\n}\n\nconst SYNC_VALUE_OP_PROTOTYPE: SyncValueOpShell<unknown> = Object.create(null, {\n  ...createSyncValueFluentPrototype(),\n  run: { get: getSyncValueRun },\n});\n\n/**\n * Builds a bound nullary Op for an already-awaited sync success value.\n *\n * Hot paths (`.run()`, `yield*`, hidden plan execution) skip the full generator driver.\n * Fluent transforms upgrade through the normal plan shell on demand.\n */\nexport function makeSyncValueOp<T>(value: T): OpInterface<T, never, [], EmptyMeta, true> {\n  const bindPlan = () => createSyncValuePlan(value);\n\n  const invoke = () => self;\n  let self: SyncValueOpShell<T>;\n\n  // SAFETY: Object.assign builds the same shell shape as makeBoundPlanOp; sync values skip generator drive only.\n  self = unsafeCoerce(\n    Object.assign(invoke, {\n      [SYNC_VALUE]: value,\n      [OP_PLAN_BIND]: bindPlan,\n      [Symbol.iterator]: syncValueIterable,\n      _tag: \"Op\" as const,\n    }),\n  );\n  Object.setPrototypeOf(self, SYNC_VALUE_OP_PROTOTYPE);\n\n  return self;\n}\n"],"mappings":"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"}