better-effect 0.13.0 → 0.14.0

package/dist/effect-W0IQXY8P.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-W0IQXY8P.mjs","names":["map","mapError","andThen","next","resultMatchError","resultMatchErrorPartial","tap","tapError","matchError","matchErrorPartial","recover","programMap","programMapError","programAndThen","programTap","programTapError","programRecover"],"sources":["../src/effect/task.ts","../src/effect/combinators.ts","../src/effect/program-combinators.ts","../src/effect/program-scheduler.ts","../src/effect/effect.ts"],"sourcesContent":["import { Result } from 'better-result'\n\nimport type { Result as ResultType } from 'better-result'\n\nimport { RuntimeContextNotConfiguredError } from '../runtime/errors'\nimport { currentRuntimeContext } from '../runtime/context'\nimport { getRuntimeTaskSupervisor } from '../runtime/task'\nimport type { AnyService } from '../service'\nimport type { ScopeCloseError } from '../scope'\n\nimport type {\n  Effect as EffectType,\n  EffectError,\n  EffectRequirements,\n  EffectSuccess,\n  Program\n} from './types'\n\ntype AnyProgram = Program<any, any, AnyService>\n\n/** The live state of a Scope-owned task. */\nexport type ScopedTaskState = 'running' | 'succeeded' | 'failed' | 'defected' | 'interrupted'\n\n/** The terminal observation of a Scope-owned task. */\nexport type ScopedTaskExit<A, E> =\n  | {\n      readonly status: 'succeeded'\n      readonly value: A\n      readonly cleanupFailure?: ScopeCloseError\n    }\n  | {\n      readonly status: 'failed'\n      readonly error: E\n      readonly cleanupFailure?: ScopeCloseError\n    }\n  | {\n      readonly status: 'defected'\n      readonly cause: unknown\n      readonly cleanupFailure?: ScopeCloseError\n    }\n  | {\n      readonly status: 'interrupted'\n      readonly reason: unknown\n      readonly cleanupFailure?: ScopeCloseError\n    }\n\n/** A small, immutable handle for a task owned by the current Scope. */\nexport type ScopedTask<out A, out E> = {\n  readonly state: ScopedTaskState\n  await(): Promise<ResultType<A, E>>\n  awaitExit(): Promise<ScopedTaskExit<A, E>>\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Task interruption preserves arbitrary caller-defined reasons.\n  interrupt(reason?: unknown): Promise<void>\n}\n\n/** Start a nominal Program as a child task supervised by the current Scope. */\nexport function forkScoped<Input extends AnyProgram>(\n  program: Input\n): EffectType<\n  ScopedTask<EffectSuccess<Input>, EffectError<Input>>,\n  never,\n  EffectRequirements<Input>\n> {\n  const context = currentRuntimeContext()\n  const resolver = context.resolver\n  const scope = context.scope\n\n  if (!resolver || !scope) {\n    throw new RuntimeContextNotConfiguredError()\n  }\n\n  const supervisor = getRuntimeTaskSupervisor(scope)\n\n  if (!supervisor) {\n    throw new RuntimeContextNotConfiguredError()\n  }\n\n  // SAFETY: Result.ok supplies the runtime Result value; the Effect requirement channel is declaration-only and restored by this cast.\n  return Result.ok(supervisor.forkScoped(program, { ...context, resolver, scope })) as EffectType<\n    ScopedTask<EffectSuccess<Input>, EffectError<Input>>,\n    never,\n    EffectRequirements<Input>\n  >\n}\n","import {\n  matchError as resultMatchError,\n  matchErrorPartial as resultMatchErrorPartial,\n  Result\n} from 'better-result'\n\nimport type { Result as ResultType } from 'better-result'\n\nimport type { AnyService } from '../service'\nimport { isPromiseLike } from '../utils/runtime'\nimport type { Effect, EffectError, EffectRequirements, EffectSuccess } from './types'\n\ntype EffectInput<A, E> = ResultType<A, E> | PromiseLike<ResultType<A, E>>\n\ntype AnyEffectInput = EffectInput<any, any>\ntype AnyEffectValue = ResultType<any, any>\ntype AnyAsyncEffectInput = PromiseLike<ResultType<any, any>>\ntype CombinatorCallback = (value: any) => any\ntype CombinatorInput = AnyEffectInput | CombinatorCallback\n\ntype PreserveAsync<Input, Output> = Input extends PromiseLike<unknown> ? Promise<Output> : Output\n\ntype MappedResult<Input, B> = Effect<B, EffectError<Input>, EffectRequirements<Input>>\n\ntype ErrorMappedResult<Input, E2> = Effect<EffectSuccess<Input>, E2, EffectRequirements<Input>>\n\ntype ChainedResult<First, Next> = Effect<\n  EffectSuccess<Next>,\n  EffectError<First> | EffectError<Next>,\n  EffectRequirements<First> | EffectRequirements<Next>\n>\n\ntype ChainedOutput<First, Next> = ChainedResult<First, Next>\n\ntype AsyncChainedOutput<First, Next> = Promise<ChainedResult<First, Next>>\n\ntype MapOperation<A, B> = {\n  <Input>(effect: Input & EffectInput<A, any>): PreserveAsync<Input, MappedResult<Input, B>>\n}\n\ntype MapErrorOperation<E1, E2> = {\n  <Input>(effect: Input & EffectInput<any, E1>): PreserveAsync<Input, ErrorMappedResult<Input, E2>>\n}\n\ntype AndThenOperation<Next> = {\n  <Input>(effect: Input & AnyEffectValue): ChainedOutput<Input, Next>\n}\n\ntype AndThenAsyncOperation<A, Next> = {\n  <Input>(effect: Input & EffectInput<A, any>): AsyncChainedOutput<Input, Next>\n}\n\ntype TappedResult<Input> = Effect<\n  EffectSuccess<Input>,\n  EffectError<Input>,\n  EffectRequirements<Input>\n>\n\ntype RecoveredResult<Input, Next> = Effect<\n  EffectSuccess<Input> | EffectSuccess<Next>,\n  EffectError<Next>,\n  EffectRequirements<Input> | EffectRequirements<Next>\n>\n\ntype FlattenedResult<Input> = Effect<\n  EffectSuccess<EffectSuccess<Input>>,\n  EffectError<Input> | EffectError<EffectSuccess<Input>>,\n  EffectRequirements<Input> | EffectRequirements<EffectSuccess<Input>>\n>\n\ntype AsResult<Input, Value> = Effect<Value, EffectError<Input>, EffectRequirements<Input>>\n\ntype MatchedResult<Input, OkResult, ErrResult> = Effect<\n  EffectSuccess<OkResult> | EffectSuccess<ErrResult>,\n  EffectError<OkResult> | EffectError<ErrResult>,\n  EffectRequirements<Input> | EffectRequirements<OkResult> | EffectRequirements<ErrResult>\n>\n\ntype AllResult<Results extends readonly AnyEffectValue[]> = Effect<\n  { -readonly [Index in keyof Results]: EffectSuccess<Results[Index]> },\n  EffectError<Results[number]>,\n  EffectRequirements<Results[number]>\n>\n\ntype ZipResult<Left, Right> = Effect<\n  [EffectSuccess<Left>, EffectSuccess<Right>],\n  EffectError<Left> | EffectError<Right>,\n  EffectRequirements<Left> | EffectRequirements<Right>\n>\n\ntype TapOperation = {\n  <Input>(\n    effect: Input & AnyEffectInput,\n    fn: (value: EffectSuccess<Input>) => void\n  ): PreserveAsync<Input, TappedResult<Input>>\n}\n\ntype TapErrorOperation = {\n  <Input>(\n    effect: Input & AnyEffectInput,\n    fn: (error: EffectError<Input>) => void\n  ): PreserveAsync<Input, TappedResult<Input>>\n}\n\ntype TapBothOperation = {\n  <Input>(\n    effect: Input & AnyEffectInput,\n    handlers: {\n      ok: (value: EffectSuccess<Input>) => void\n      err: (error: EffectError<Input>) => void\n    }\n  ): PreserveAsync<Input, TappedResult<Input>>\n}\n\ntype TapAsyncOperation = {\n  <Input>(effect: Input & AnyEffectInput): Promise<TappedResult<Input>>\n}\n\ntype TapErrorAsyncOperation = {\n  <Input>(effect: Input & AnyEffectInput): Promise<TappedResult<Input>>\n}\n\ntype TapBothAsyncOperation = {\n  <Input>(effect: Input & AnyEffectInput): Promise<TappedResult<Input>>\n}\n\ntype TaggedErrorLike = Error & { readonly _tag: string }\n\ntype TaggedErrorHandlers<ErrorValue extends TaggedErrorLike> = {\n  // oxlint-disable-next-line anti-slop/no-unknown-returns -- better-result matchers allow arbitrary handler results.\n  [Tag in ErrorValue['_tag']]: (error: Extract<ErrorValue, { readonly _tag: Tag }>) => unknown\n}\n\ntype TaggedErrorOf<Input> = Extract<EffectError<Input>, TaggedErrorLike>\n\ntype TaggedErrorHandlersFor<Input> = [EffectError<Input>] extends [TaggedErrorLike]\n  ? TaggedErrorHandlers<TaggedErrorOf<Input>>\n  : never\n\ntype HandlerReturn<Handlers> = {\n  [Key in keyof Handlers]-?: NonNullable<Handlers[Key]> extends (error: never) => infer Return\n    ? Return\n    : never\n}[keyof Handlers]\n\ntype RequiredHandlerKeys<Handlers> = {\n  [Key in keyof Handlers]-?: {} extends Pick<Handlers, Key>\n    ? never\n    : undefined extends Handlers[Key]\n      ? never\n      : Key\n}[keyof Handlers]\n\ntype UnhandledTaggedErrors<ErrorValue extends TaggedErrorLike, Handlers> = Exclude<\n  ErrorValue,\n  { readonly _tag: Extract<RequiredHandlerKeys<Handlers>, ErrorValue['_tag']> }\n>\n\ntype MatchErrorResult<Input, Handlers> = Effect<\n  EffectSuccess<Input>,\n  HandlerReturn<Handlers>,\n  EffectRequirements<Input>\n>\n\ntype MatchErrorPartialResult<Input, Handlers> = Effect<\n  EffectSuccess<Input>,\n  HandlerReturn<Handlers> | UnhandledTaggedErrors<TaggedErrorOf<Input>, Handlers>,\n  EffectRequirements<Input>\n>\n\ntype RecoverOperation<Next> = {\n  <Input>(\n    effect: Input & AnyEffectInput,\n    fn: (error: EffectError<Input>) => Next\n  ): PreserveAsync<Input, RecoveredResult<Input, Next>>\n}\n\ntype RecoverAsyncOperation<Next> = {\n  <Input>(\n    effect: Input & AnyEffectInput,\n    fn: (error: EffectError<Input>) => Next\n  ): Promise<RecoveredResult<Input, Next>>\n}\n\nconst asResult = <Value>(value: Value): ResultType<any, any> => {\n  // SAFETY: Effect is the declaration-only Result facade, so every runtime value is a Result.\n  return value as ResultType<any, any>\n}\n\nconst mapResult = <A, B, E, Requirements extends AnyService>(\n  result: ResultType<A, E>,\n  fn: (value: A) => B\n): Effect<B, E, Requirements> => {\n  // SAFETY: Result.map changes only the success channel; the declaration-only Effect marker is restored by this adapter.\n  return Result.map(result, fn) as Effect<B, E, Requirements>\n}\n\nconst mapErrorResult = <A, E1, E2, Requirements extends AnyService>(\n  result: ResultType<A, E1>,\n  fn: (error: E1) => E2\n): Effect<A, E2, Requirements> => {\n  // SAFETY: Result.mapError changes only the error channel; the declaration-only Effect marker is restored by this adapter.\n  return Result.mapError(result, fn) as Effect<A, E2, Requirements>\n}\n\nconst andThenResult = <\n  A,\n  B,\n  E1,\n  E2,\n  Requirements1 extends AnyService,\n  Requirements2 extends AnyService\n>(\n  result: ResultType<A, E1>,\n  next: (value: A) => ResultType<B, E2>\n): Effect<B, E1 | E2, Requirements1 | Requirements2> => {\n  // SAFETY: The public callback returns an Effect, whose only runtime contract is the underlying Result.\n  const resultNext = next as (value: A) => ResultType<B, E2>\n\n  // SAFETY: Result.andThen unions Result errors; the declaration-only Effect marker is restored by this adapter.\n  return Result.andThen(result, resultNext) as Effect<B, E1 | E2, Requirements1 | Requirements2>\n}\n\nconst andThenAsyncResult = <\n  A,\n  B,\n  E1,\n  E2,\n  Requirements1 extends AnyService,\n  Requirements2 extends AnyService\n>(\n  result: ResultType<A, E1>,\n  next: (value: A) => PromiseLike<ResultType<B, E2>>\n): Promise<Effect<B, E1 | E2, Requirements1 | Requirements2>> => {\n  // SAFETY: The public callback returns an Effect, whose only runtime contract is the underlying Result.\n  const resultNext = (value: A) => {\n    // SAFETY: Promise resolution preserves the callback's Result value; only declaration-only Effect metadata is erased.\n    return Promise.resolve(next(value)) as Promise<ResultType<B, E2>>\n  }\n\n  // SAFETY: Result.andThenAsync unions Result errors; the declaration-only Effect marker is restored by this adapter.\n  return Result.andThenAsync(result, resultNext) as Promise<\n    Effect<B, E1 | E2, Requirements1 | Requirements2>\n  >\n}\n\n/**\n * Map the successful value of a Result or Effect result.\n *\n * Supports both data-first and data-last forms and preserves asynchronous\n * results and declaration-only Service requirements.\n *\n * @example\n * ```ts\n * const doubled = Effect.map(Result.ok(2), (value) => value * 2)\n * const toLabel = Effect.map((value: number) => `#${value}`)\n * ```\n */\nexport function map<A, B>(fn: (value: A) => B): MapOperation<A, B>\nexport function map<Input, B>(\n  effect: Input & AnyEffectInput,\n  fn: (value: EffectSuccess<Input>) => B\n): PreserveAsync<Input, MappedResult<Input, B>>\nexport function map(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    // SAFETY: The curried overload accepts a unary mapping callback in this branch.\n    const callback = first as CombinatorCallback\n\n    return (effect: AnyEffectInput) => {\n      // SAFETY: The overload implementation has already established the callback and Effect input positions.\n      return map(effect as never, callback as never)\n    }\n  }\n\n  // SAFETY: The data-first overload requires the second argument to be a unary mapping callback.\n  const fn = second as CombinatorCallback\n\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => {\n      // SAFETY: Result is the runtime representation shared by Effect and better-result.\n      return mapResult(result as ResultType<any, any>, fn)\n    })\n  }\n\n  // SAFETY: The data-first overload supplies a Result-compatible Effect value.\n  return mapResult(first as ResultType<any, any>, fn)\n}\n\n/**\n * Map the error value of a Result or Effect result while preserving its\n * successful value, asynchronous shape, and declaration-only Service requirements.\n *\n * @example\n * ```ts\n * const labelled = Effect.mapError(Result.err('missing'), (error) => ({ error }))\n * ```\n */\nexport function mapError<E1, E2>(fn: (error: E1) => E2): MapErrorOperation<E1, E2>\nexport function mapError<Input, E2>(\n  effect: Input & AnyEffectInput,\n  fn: (error: EffectError<Input>) => E2\n): PreserveAsync<Input, ErrorMappedResult<Input, E2>>\nexport function mapError(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    // SAFETY: The curried overload accepts a unary error-mapping callback in this branch.\n    const callback = first as CombinatorCallback\n\n    return (effect: AnyEffectInput) => {\n      // SAFETY: The overload implementation has already established the callback and Effect input positions.\n      return mapError(effect as never, callback as never)\n    }\n  }\n\n  // SAFETY: The data-first overload requires the second argument to be a unary error-mapping callback.\n  const fn = second as CombinatorCallback\n\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => {\n      // SAFETY: Result is the runtime representation shared by Effect and better-result.\n      return mapErrorResult(result as ResultType<any, any>, fn)\n    })\n  }\n\n  // SAFETY: The data-first overload supplies a Result-compatible Effect value.\n  return mapErrorResult(first as ResultType<any, any>, fn)\n}\n\n/**\n * Chain a synchronous Result-producing operation after a successful result.\n *\n * The next operation is skipped when the input is an error. Both error types\n * and both sets of Service requirements are preserved in the output.\n *\n * @example\n * ```ts\n * const user = Effect.andThen(Result.ok('u1'), (id) => repository.find(id))\n * ```\n */\nexport function andThen<A, Next extends AnyEffectValue>(\n  next: (value: A) => Next\n): AndThenOperation<Next>\nexport function andThen<Input, Next extends AnyEffectValue>(\n  effect: Input & AnyEffectValue,\n  next: (value: EffectSuccess<Input>) => Next\n): ChainedOutput<Input, Next>\nexport function andThen(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    // SAFETY: The curried overload accepts a unary continuation in this branch.\n    const callback = first as CombinatorCallback\n\n    return (effect: AnyEffectInput) => {\n      // SAFETY: The overload implementation has already established the callback and Effect input positions.\n      return andThen(effect as never, callback as never)\n    }\n  }\n\n  // SAFETY: The data-first overload requires the second argument to return a Result.\n  const next = second as CombinatorCallback\n\n  // SAFETY: The data-first overload supplies a Result-compatible Effect value.\n  return andThenResult(first as ResultType<any, any>, next)\n}\n\n/**\n * Chain an asynchronous Result-producing operation after a successful result.\n *\n * The returned value is always a Promise and retains both operations' error\n * and Service-requirement metadata.\n *\n * @example\n * ```ts\n * const user = Effect.andThenAsync(loadUser(), (user) => fetchProfile(user.id))\n * ```\n */\nexport function andThenAsync<A, Next extends AnyAsyncEffectInput>(\n  next: (value: A) => Next\n): AndThenAsyncOperation<A, Next>\nexport function andThenAsync<Input, Next extends AnyAsyncEffectInput>(\n  effect: Input & AnyEffectInput,\n  next: (value: EffectSuccess<Input>) => Next\n): AsyncChainedOutput<Input, Next>\nexport function andThenAsync(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    // SAFETY: The curried overload accepts a unary asynchronous continuation in this branch.\n    const callback = first as CombinatorCallback\n\n    return (effect: AnyEffectInput) => {\n      // SAFETY: The overload implementation has already established the callback and Effect input positions.\n      return andThenAsync(effect as never, callback as never)\n    }\n  }\n\n  // SAFETY: The data-first overload requires the second argument to return a PromiseLike Effect.\n  const next = second as CombinatorCallback\n\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => {\n      // SAFETY: Result is the runtime representation shared by Effect and better-result.\n      return andThenAsyncResult(result as ResultType<any, any>, next)\n    })\n  }\n\n  // SAFETY: The data-first overload supplies a Result-compatible Effect value.\n  return andThenAsyncResult(first as ResultType<any, any>, next)\n}\n\nconst tapResult = <A, E, Requirements extends AnyService>(\n  result: ResultType<A, E>,\n  fn: (value: A) => void\n): Effect<A, E, Requirements> =>\n  // SAFETY: Result.tap preserves the Result value; the declaration-only Effect marker is restored here.\n  Result.tap(result, fn) as Effect<A, E, Requirements>\n\nconst tapErrorResult = <A, E, Requirements extends AnyService>(\n  result: ResultType<A, E>,\n  fn: (error: E) => void\n): Effect<A, E, Requirements> =>\n  // SAFETY: Result.tapError preserves the Result value; the declaration-only Effect marker is restored here.\n  Result.tapError(result, fn) as Effect<A, E, Requirements>\n\nconst tapBothResult = <A, E, Requirements extends AnyService>(\n  result: ResultType<A, E>,\n  handlers: { ok: (value: A) => void; err: (error: E) => void }\n): Effect<A, E, Requirements> =>\n  // SAFETY: Result.tapBoth preserves the Result value; the declaration-only Effect marker is restored here.\n  Result.tapBoth(result, handlers) as Effect<A, E, Requirements>\n\nconst tapAsyncResult = <A, E, Requirements extends AnyService>(\n  result: ResultType<A, E>,\n  fn: (value: A) => PromiseLike<void>\n): Promise<Effect<A, E, Requirements>> =>\n  // SAFETY: Result.tapAsync preserves the Result value and owns observer defect behavior; only the Effect marker is restored here.\n  Result.tapAsync(result, (value) => Promise.resolve(fn(value))) as Promise<\n    Effect<A, E, Requirements>\n  >\n\nconst tapErrorAsyncResult = <A, E, Requirements extends AnyService>(\n  result: ResultType<A, E>,\n  fn: (error: E) => PromiseLike<void>\n): Promise<Effect<A, E, Requirements>> =>\n  // SAFETY: Result.tapErrorAsync preserves the Result value and owns observer defect behavior; only the Effect marker is restored here.\n  Result.tapErrorAsync(result, (error) => Promise.resolve(fn(error))) as Promise<\n    Effect<A, E, Requirements>\n  >\n\nconst tapBothAsyncResult = <A, E, Requirements extends AnyService>(\n  result: ResultType<A, E>,\n  handlers: { ok: (value: A) => PromiseLike<void>; err: (error: E) => PromiseLike<void> }\n): Promise<Effect<A, E, Requirements>> =>\n  // SAFETY: Result.tapBothAsync selects one branch and preserves the Result; only the Effect marker is restored here.\n  Result.tapBothAsync(result, {\n    ok: (value) => Promise.resolve(handlers.ok(value)),\n    err: (error) => Promise.resolve(handlers.err(error))\n  }) as Promise<Effect<A, E, Requirements>>\n\nconst asTaggedResult = (\n  result: ResultType<unknown, unknown>\n): ResultType<unknown, TaggedErrorLike> => {\n  // SAFETY: The public matcher overload restricts error values to TaggedErrorLike before reaching this runtime boundary.\n  return result as ResultType<unknown, TaggedErrorLike>\n}\n\nconst matchErrorResult = <\n  A,\n  E extends TaggedErrorLike,\n  Requirements extends AnyService,\n  Handlers extends TaggedErrorHandlers<E>\n>(\n  result: ResultType<A, E>,\n  handlers: Handlers\n): Effect<A, HandlerReturn<Handlers>, Requirements> => {\n  // SAFETY: Result.mapError selects Err and preserves Ok; the declaration-only Effect marker is restored here.\n  return Result.mapError(result, (error) => resultMatchError(error, handlers)) as Effect<\n    A,\n    HandlerReturn<Handlers>,\n    Requirements\n  >\n}\n\nconst matchErrorPartialResult = <\n  A,\n  E extends TaggedErrorLike,\n  Requirements extends AnyService,\n  Handlers extends Partial<TaggedErrorHandlers<E>>\n>(\n  result: ResultType<A, E>,\n  handlers: Handlers\n): Effect<A, HandlerReturn<Handlers> | UnhandledTaggedErrors<E, Handlers>, Requirements> => {\n  // SAFETY: Result.mapError selects Err and preserves Ok; the declaration-only Effect marker is restored here.\n  return Result.mapError(result, (error) => resultMatchErrorPartial(error, handlers)) as Effect<\n    A,\n    HandlerReturn<Handlers> | UnhandledTaggedErrors<E, Handlers>,\n    Requirements\n  >\n}\n\nconst recoverResult = <\n  A,\n  E,\n  B,\n  E2,\n  Requirements1 extends AnyService,\n  Requirements2 extends AnyService\n>(\n  result: ResultType<A, E>,\n  fn: (error: E) => ResultType<B, E2>\n): Effect<A | B, E2, Requirements1 | Requirements2> =>\n  // SAFETY: Result.tryRecover owns recovery and short-circuiting; only Effect metadata is restored here.\n  Result.tryRecover(result, fn) as Effect<A | B, E2, Requirements1 | Requirements2>\n\nconst recoverAsyncResult = <\n  A,\n  E,\n  B,\n  E2,\n  Requirements1 extends AnyService,\n  Requirements2 extends AnyService\n>(\n  result: ResultType<A, E>,\n  fn: (error: E) => PromiseLike<ResultType<B, E2>>\n): Promise<Effect<A | B, E2, Requirements1 | Requirements2>> =>\n  // SAFETY: Result.tryRecoverAsync owns asynchronous recovery; only Effect metadata is restored here.\n  Result.tryRecoverAsync(result, (error) => Promise.resolve(fn(error))) as Promise<\n    Effect<A | B, E2, Requirements1 | Requirements2>\n  >\n\nconst flattenResult = <\n  A,\n  E1,\n  E2,\n  Requirements1 extends AnyService,\n  Requirements2 extends AnyService\n>(\n  result: ResultType<ResultType<A, E2>, E1>\n): Effect<A, E1 | E2, Requirements1 | Requirements2> =>\n  // SAFETY: Result.flatten removes one Result layer; the outer and inner Effect markers are restored here.\n  Result.flatten(result) as Effect<A, E1 | E2, Requirements1 | Requirements2>\n\nconst matchResult = <A, E, OkResult, ErrResult>(\n  result: ResultType<A, E>,\n  handlers: { ok: (value: A) => OkResult; err: (error: E) => ErrResult }\n): OkResult | ErrResult =>\n  // SAFETY: Result.match invokes only the selected branch; handler Results remain ordinary runtime values.\n  Result.match(result, handlers as never) as OkResult | ErrResult\n\nconst allResult = <const Results extends readonly AnyEffectValue[]>(\n  results: Results\n): AllResult<Results> =>\n  // SAFETY: Result.all preserves tuple order and short-circuiting; the declaration-only channels are restored here.\n  Result.all(results as readonly ResultType<any, any>[]) as AllResult<Results>\n\n/** Observe a successful value without changing the Result. */\nexport function tap(fn: (value: any) => void): TapOperation\nexport function tap<Input>(\n  effect: Input & AnyEffectInput,\n  fn: (value: EffectSuccess<Input>) => void\n): PreserveAsync<Input, TappedResult<Input>>\nexport function tap(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    const callback = first\n    return (effect: AnyEffectInput) => tap(effect, callback)\n  }\n\n  if (second === undefined) {\n    throw new TypeError('Effect.tap requires a callback')\n  }\n\n  const fn = second\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => tapResult(asResult(result), fn))\n  }\n\n  return tapResult(asResult(first), fn)\n}\n\n/** Observe an error value without changing the Result. */\nexport function tapError(fn: (error: any) => void): TapErrorOperation\nexport function tapError<Input>(\n  effect: Input & AnyEffectInput,\n  fn: (error: EffectError<Input>) => void\n): PreserveAsync<Input, TappedResult<Input>>\nexport function tapError(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    const callback = first\n    return (effect: AnyEffectInput) => tapError(effect, callback)\n  }\n\n  if (second === undefined) {\n    throw new TypeError('Effect.tapError requires a callback')\n  }\n\n  const fn = second\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => tapErrorResult(asResult(result), fn))\n  }\n\n  return tapErrorResult(asResult(first), fn)\n}\n\n/** Observe whichever Result branch is active without changing the Result. */\nexport function tapBoth(handlers: {\n  ok: (value: any) => void\n  err: (error: any) => void\n}): TapBothOperation\nexport function tapBoth<Input>(\n  effect: Input & AnyEffectInput,\n  handlers: {\n    ok: (value: EffectSuccess<Input>) => void\n    err: (error: EffectError<Input>) => void\n  }\n): PreserveAsync<Input, TappedResult<Input>>\nexport function tapBoth(first: any, second?: any): any {\n  if (second === undefined) {\n    return (effect: AnyEffectInput) => tapBoth(effect, first)\n  }\n\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => tapBothResult(result, second))\n  }\n\n  return tapBothResult(asResult(first), second)\n}\n\n/** Observe a successful value asynchronously without changing the Result. */\nexport function tapAsync(fn: (value: any) => PromiseLike<void>): TapAsyncOperation\nexport function tapAsync<Input>(\n  effect: Input & AnyEffectInput,\n  fn: (value: EffectSuccess<Input>) => PromiseLike<void>\n): Promise<TappedResult<Input>>\nexport function tapAsync(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    const callback = first\n    return (effect: AnyEffectInput) => tapAsync(effect, callback)\n  }\n\n  if (second === undefined) {\n    throw new TypeError('Effect.tapAsync requires a callback')\n  }\n\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => tapAsyncResult(asResult(result), second))\n  }\n\n  return tapAsyncResult(asResult(first), second)\n}\n\n/** Observe an error value asynchronously without changing the Result. */\nexport function tapErrorAsync(fn: (error: any) => PromiseLike<void>): TapErrorAsyncOperation\nexport function tapErrorAsync<Input>(\n  effect: Input & AnyEffectInput,\n  fn: (error: EffectError<Input>) => PromiseLike<void>\n): Promise<TappedResult<Input>>\nexport function tapErrorAsync(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    const callback = first\n    return (effect: AnyEffectInput) => tapErrorAsync(effect, callback)\n  }\n\n  if (second === undefined) {\n    throw new TypeError('Effect.tapErrorAsync requires a callback')\n  }\n\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => tapErrorAsyncResult(asResult(result), second))\n  }\n\n  return tapErrorAsyncResult(asResult(first), second)\n}\n\n/** Observe the active Result branch asynchronously without changing the Result. */\nexport function tapBothAsync(handlers: {\n  ok: (value: any) => PromiseLike<void>\n  err: (error: any) => PromiseLike<void>\n}): TapBothAsyncOperation\nexport function tapBothAsync<Input>(\n  effect: Input & AnyEffectInput,\n  handlers: {\n    ok: (value: EffectSuccess<Input>) => PromiseLike<void>\n    err: (error: EffectError<Input>) => PromiseLike<void>\n  }\n): Promise<TappedResult<Input>>\nexport function tapBothAsync(first: any, second?: any): any {\n  if (second === undefined) {\n    return (effect: AnyEffectInput) => tapBothAsync(effect, first)\n  }\n\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => tapBothAsyncResult(result, second))\n  }\n\n  return tapBothAsyncResult(asResult(first), second)\n}\n\n/** Match every tagged error variant and map it to a new error value. */\nexport function matchError<Input, Handlers extends TaggedErrorHandlersFor<Input>>(\n  effect: Input & AnyEffectInput,\n  handlers: Handlers\n): PreserveAsync<Input, MatchErrorResult<Input, Handlers>>\n// oxlint-disable-next-line anti-slop/no-unknown-parameters -- overload implementation is narrowed by the typed public signature.\nexport function matchError(first: AnyEffectInput, second?: unknown): any {\n  if (second === undefined) {\n    throw new TypeError('Effect.matchError requires handlers')\n  }\n\n  // SAFETY: The public matcher overload checks the handler map against the source tagged-error union.\n  const handlers = second as TaggedErrorHandlers<TaggedErrorLike>\n\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) =>\n      matchErrorResult(asTaggedResult(asResult(result)), handlers)\n    )\n  }\n\n  return matchErrorResult(asTaggedResult(asResult(first)), handlers)\n}\n\n/** Match selected tagged errors and retain unhandled variants unchanged. */\nexport function matchErrorPartial<Input, Handlers extends Partial<TaggedErrorHandlersFor<Input>>>(\n  effect: Input & AnyEffectInput,\n  handlers: Handlers\n): PreserveAsync<Input, MatchErrorPartialResult<Input, Handlers>>\n// oxlint-disable-next-line anti-slop/no-unknown-parameters -- overload implementation is narrowed by the typed public signature.\nexport function matchErrorPartial(first: AnyEffectInput, second?: unknown): any {\n  if (second === undefined) {\n    throw new TypeError('Effect.matchErrorPartial requires handlers')\n  }\n\n  // SAFETY: The public matcher overload checks the handler map against the source tagged-error union.\n  const handlers = second as Partial<TaggedErrorHandlers<TaggedErrorLike>>\n\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) =>\n      matchErrorPartialResult(asTaggedResult(asResult(result)), handlers)\n    )\n  }\n\n  return matchErrorPartialResult(asTaggedResult(asResult(first)), handlers)\n}\n\n/** Recover an Err with a synchronous Result-producing callback. */\nexport function recover<Next extends AnyEffectValue>(\n  fn: (error: any) => Next\n): RecoverOperation<Next>\nexport function recover<Input, Next extends AnyEffectValue>(\n  effect: Input & AnyEffectInput,\n  fn: (error: EffectError<Input>) => Next\n): PreserveAsync<Input, RecoveredResult<Input, Next>>\nexport function recover(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    const callback = first\n    return (effect: AnyEffectInput) => recover(effect, callback)\n  }\n\n  if (second === undefined) {\n    throw new TypeError('Effect.recover requires a callback')\n  }\n\n  const fn = second\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => recoverResult(asResult(result), fn))\n  }\n\n  return recoverResult(asResult(first), fn)\n}\n\n/** Recover an Err with an asynchronous Result-producing callback. */\nexport function recoverAsync<Next extends AnyAsyncEffectInput>(\n  fn: (error: any) => Next\n): RecoverAsyncOperation<Next>\nexport function recoverAsync<Input, Next extends AnyAsyncEffectInput>(\n  effect: Input & AnyEffectInput,\n  fn: (error: EffectError<Input>) => Next\n): Promise<RecoveredResult<Input, Next>>\nexport function recoverAsync(first: CombinatorInput, second?: CombinatorCallback): any {\n  if (first instanceof Function && second === undefined) {\n    const callback = first\n    return (effect: AnyEffectInput) => recoverAsync(effect, callback)\n  }\n\n  if (second === undefined) {\n    throw new TypeError('Effect.recoverAsync requires a callback')\n  }\n\n  const fn = second\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => recoverAsyncResult(asResult(result), fn))\n  }\n\n  return recoverAsyncResult(asResult(first), fn)\n}\n\n/** Remove one nested Result/Effect layer. */\nexport function flatten<Input>(effect: Input & AnyEffectValue): FlattenedResult<Input> {\n  // SAFETY: flattenResult restores the nested Effect channels after Result.flatten removes one runtime layer.\n  return flattenResult(asResult(effect)) as FlattenedResult<Input>\n}\n\n/** Replace a successful value while preserving errors and requirements. */\nexport function as<Value>(\n  value: Value\n): <Input>(effect: Input & AnyEffectValue) => AsResult<Input, Value>\nexport function as<Input, Value>(\n  effect: Input & AnyEffectValue,\n  value: Value\n): AsResult<Input, Value>\nexport function as(first: any, second?: any): any {\n  if (arguments.length < 2) {\n    return (effect: AnyEffectValue) => as(effect, first)\n  }\n\n  return mapResult(asResult(first), () => second)\n}\n\n/** Replace a successful value with void. */\nexport function asVoid<Input>(effect: Input & AnyEffectValue): AsResult<Input, void> {\n  return mapResult(asResult(effect), () => undefined)\n}\n\n/** Match an Effect and return branch Effects with their channels unioned. */\nexport function match<Input, OkResult extends AnyEffectValue, ErrResult extends AnyEffectValue>(\n  effect: Input & AnyEffectValue,\n  handlers: {\n    ok: (value: EffectSuccess<Input>) => OkResult\n    err: (error: EffectError<Input>) => ErrResult\n  }\n): PreserveAsync<Input, MatchedResult<Input, OkResult, ErrResult>>\nexport function match<Input, OkValue, ErrValue>(\n  effect: Input & AnyEffectValue,\n  handlers: {\n    ok: (value: EffectSuccess<Input>) => OkValue\n    err: (error: EffectError<Input>) => ErrValue\n  }\n): PreserveAsync<Input, OkValue | ErrValue>\nexport function match(first: AnyEffectInput, second?: any): any {\n  if (isPromiseLike(first)) {\n    return Promise.resolve(first).then((result) => match(asResult(result), second))\n  }\n\n  return matchResult(asResult(first), second)\n}\n\n/** Collect already-created Effects in input order. */\nexport function all<const Results extends readonly AnyEffectValue[]>(\n  results: Results\n): AllResult<Results> {\n  return allResult(results)\n}\n\n/** Combine two already-created Effects in input order. */\nexport function zip<Left, Right>(\n  left: Left & AnyEffectValue,\n  right: Right & AnyEffectValue\n): ZipResult<Left, Right> {\n  // SAFETY: Result.all returns the ordered pair; ZipResult restores only the declaration-only Effect channels.\n  return Result.all([left, right]) as ZipResult<Left, Right>\n}\n","import { Result } from 'better-result'\n\nimport type { Result as ResultType } from 'better-result'\n\nimport type { AnyService } from '../service'\nimport { inheritProgramName } from './program-metadata'\nimport { isPromiseLike } from '../utils/runtime'\n\nimport type { EffectError, EffectRequirements, EffectSuccess, Program } from './types'\n\ntype AnyResult = ResultType<any, any>\ntype RuntimeEffect = AnyResult | PromiseLike<AnyResult>\ntype RuntimeProgram = () => RuntimeEffect\ntype RuntimeProgramOutput = RuntimeEffect | RuntimeProgram\ntype RuntimeCallback = (value: any) => any\ntype RuntimeContinuation = (value: any) => RuntimeProgramOutput\ntype AnyProgram = Program<any, any, AnyService>\n\ntype ProgramInput<Input extends RuntimeProgram> = Input &\n  Program<EffectSuccess<Input>, EffectError<Input>, EffectRequirements<Input>>\n\ntype CompatibleSuccess<Input, A> = EffectSuccess<Input> extends A ? unknown : never\ntype CompatibleError<Input, E> = EffectError<Input> extends E ? unknown : never\n\ntype ProgramOutput<Output> =\n  Output extends Program<infer _Success, infer _Error, infer _Requirements extends AnyService>\n    ? Output\n    : Output extends PromiseLike<infer AsyncOutput>\n      ? AsyncOutput extends ResultType<infer _Success, infer _Error>\n        ? Output\n        : never\n      : Output extends ResultType<infer _Success, infer _Error>\n        ? Output\n        : never\n\ntype MappedProgram<Input, B> = Program<B, EffectError<Input>, EffectRequirements<Input>>\n\ntype ErrorMappedProgram<Input, E2> = Program<EffectSuccess<Input>, E2, EffectRequirements<Input>>\n\ntype ChainedProgram<Input, Next> = Program<\n  EffectSuccess<Next>,\n  EffectError<Input> | EffectError<Next>,\n  EffectRequirements<Input> | EffectRequirements<Next>\n>\n\ntype TappedProgram<Input> = Program<\n  EffectSuccess<Input>,\n  EffectError<Input>,\n  EffectRequirements<Input>\n>\n\ntype RecoveredProgram<Input, Next> = Program<\n  EffectSuccess<Input> | EffectSuccess<Next>,\n  EffectError<Next>,\n  EffectRequirements<Input> | EffectRequirements<Next>\n>\n\ntype MapOperation<A, B> = {\n  <Input extends RuntimeProgram>(\n    program: ProgramInput<Input> & CompatibleSuccess<Input, A>\n  ): MappedProgram<Input, B>\n}\n\ntype MapErrorOperation<E1, E2> = {\n  <Input extends RuntimeProgram>(\n    program: ProgramInput<Input> & CompatibleError<Input, E1>\n  ): ErrorMappedProgram<Input, E2>\n}\n\ntype AndThenOperation<A, Next> = {\n  <Input extends RuntimeProgram>(\n    program: ProgramInput<Input> & CompatibleSuccess<Input, A>\n  ): ChainedProgram<Input, Next>\n}\n\ntype TapOperation<A> = {\n  <Input extends RuntimeProgram>(\n    program: ProgramInput<Input> & CompatibleSuccess<Input, A>\n  ): TappedProgram<Input>\n}\n\ntype TapErrorOperation<E> = {\n  <Input extends RuntimeProgram>(\n    program: ProgramInput<Input> & CompatibleError<Input, E>\n  ): TappedProgram<Input>\n}\n\ntype RecoverOperation<E, Next> = {\n  <Input extends RuntimeProgram>(\n    program: ProgramInput<Input> & CompatibleError<Input, E>\n  ): RecoveredProgram<Input, Next>\n}\n\nconst asProgram = <Output extends AnyProgram>(program: RuntimeProgram): Output =>\n  // SAFETY: Program's channels and nominal marker are declaration-only; callers derive them from typed inputs.\n  program as Output\n\nconst isAsyncEffect = (effect: RuntimeEffect): effect is PromiseLike<AnyResult> =>\n  isPromiseLike(effect)\n\nconst mapRuntime = (effect: RuntimeEffect, fn: RuntimeCallback): RuntimeEffect => {\n  if (isAsyncEffect(effect)) {\n    return Promise.resolve(effect).then((result) => Result.map(result, fn))\n  }\n\n  return Result.map(effect, fn)\n}\n\nconst mapErrorRuntime = (effect: RuntimeEffect, fn: RuntimeCallback): RuntimeEffect => {\n  if (isAsyncEffect(effect)) {\n    return Promise.resolve(effect).then((result) => Result.mapError(result, fn))\n  }\n\n  return Result.mapError(effect, fn)\n}\n\nconst tapRuntime = (effect: RuntimeEffect, fn: RuntimeCallback): RuntimeEffect => {\n  if (isAsyncEffect(effect)) {\n    return Promise.resolve(effect).then((result) => Result.tap(result, fn))\n  }\n\n  return Result.tap(effect, fn)\n}\n\nconst tapErrorRuntime = (effect: RuntimeEffect, fn: RuntimeCallback): RuntimeEffect => {\n  if (isAsyncEffect(effect)) {\n    return Promise.resolve(effect).then((result) => Result.tapError(result, fn))\n  }\n\n  return Result.tapError(effect, fn)\n}\n\nconst invoke = (output: RuntimeProgramOutput): RuntimeEffect =>\n  output instanceof Function ? output() : output\n\nconst andThenRuntime = (effect: RuntimeEffect, next: RuntimeContinuation): Promise<AnyResult> => {\n  const continueWith = (value: any) => Promise.resolve(invoke(next(value)))\n\n  if (isAsyncEffect(effect)) {\n    return Promise.resolve(effect).then((result) => Result.andThenAsync(result, continueWith))\n  }\n\n  return Result.andThenAsync(effect, continueWith)\n}\n\nconst recoverRuntime = (\n  effect: RuntimeEffect,\n  recover: RuntimeContinuation\n): Promise<AnyResult> => {\n  const continueWith = (error: any) => Promise.resolve(invoke(recover(error)))\n\n  if (isAsyncEffect(effect)) {\n    return Promise.resolve(effect).then((result) => Result.tryRecoverAsync(result, continueWith))\n  }\n\n  return Result.tryRecoverAsync(effect, continueWith)\n}\n\nconst mapProgram = <Input extends RuntimeProgram, B>(\n  program: ProgramInput<Input>,\n  fn: (value: EffectSuccess<Input>) => B\n): MappedProgram<Input, B> => {\n  const mapped = asProgram<MappedProgram<Input, B>>(() => mapRuntime(program(), fn))\n\n  return inheritProgramName(program, mapped)\n}\n\nconst mapErrorProgram = <Input extends RuntimeProgram, E2>(\n  program: ProgramInput<Input>,\n  fn: (error: EffectError<Input>) => E2\n): ErrorMappedProgram<Input, E2> => {\n  const mapped = asProgram<ErrorMappedProgram<Input, E2>>(() => mapErrorRuntime(program(), fn))\n\n  return inheritProgramName(program, mapped)\n}\n\nconst tapProgram = <Input extends RuntimeProgram>(\n  program: ProgramInput<Input>,\n  fn: (value: EffectSuccess<Input>) => any\n): TappedProgram<Input> => {\n  const tapped = asProgram<TappedProgram<Input>>(() => tapRuntime(program(), fn))\n\n  return inheritProgramName(program, tapped)\n}\n\nconst tapErrorProgram = <Input extends RuntimeProgram>(\n  program: ProgramInput<Input>,\n  fn: (error: EffectError<Input>) => any\n): TappedProgram<Input> => {\n  const tapped = asProgram<TappedProgram<Input>>(() => tapErrorRuntime(program(), fn))\n\n  return inheritProgramName(program, tapped)\n}\n\n/** Lazily map the successful Result value of a Program. */\nexport function map<A, B>(fn: (value: A) => B): MapOperation<A, B>\nexport function map<Input extends RuntimeProgram, B>(\n  program: ProgramInput<Input>,\n  fn: (value: EffectSuccess<Input>) => B\n): MappedProgram<Input, B>\nexport function map(first: RuntimeProgram | RuntimeCallback, second?: RuntimeCallback): any {\n  if (second === undefined) {\n    return (program: RuntimeProgram) => {\n      // SAFETY: The curried overload supplies a Program and a callback that accepts its success channel.\n      return mapProgram(program as ProgramInput<typeof program>, first)\n    }\n  }\n\n  // SAFETY: The data-first overload supplies a Program as its first argument.\n  return mapProgram(first as ProgramInput<RuntimeProgram>, second)\n}\n\n/** Lazily map the error Result value of a Program. */\nexport function mapError<E1, E2>(fn: (error: E1) => E2): MapErrorOperation<E1, E2>\nexport function mapError<Input extends RuntimeProgram, E2>(\n  program: ProgramInput<Input>,\n  fn: (error: EffectError<Input>) => E2\n): ErrorMappedProgram<Input, E2>\nexport function mapError(first: RuntimeProgram | RuntimeCallback, second?: RuntimeCallback): any {\n  if (second === undefined) {\n    return (program: RuntimeProgram) => {\n      // SAFETY: The curried overload supplies a Program and a callback that accepts its error channel.\n      return mapErrorProgram(program as ProgramInput<typeof program>, first)\n    }\n  }\n\n  // SAFETY: The data-first overload supplies a Program as its first argument.\n  return mapErrorProgram(first as ProgramInput<RuntimeProgram>, second)\n}\n\n/** Lazily continue a successful Program with an Effect or Program. */\nexport function andThen<A, Next>(\n  next: (value: A) => Next & ProgramOutput<Next>\n): AndThenOperation<A, Next>\nexport function andThen<Input extends RuntimeProgram, Next>(\n  program: ProgramInput<Input>,\n  next: (value: EffectSuccess<Input>) => Next & ProgramOutput<Next>\n): ChainedProgram<Input, Next>\nexport function andThen(\n  first: RuntimeProgram | RuntimeContinuation,\n  second?: RuntimeContinuation\n): any {\n  if (second === undefined) {\n    return (program: RuntimeProgram) => {\n      // SAFETY: The curried overload supplies a Program and a continuation for its success channel.\n      const chained = () => andThenRuntime(program(), first as RuntimeContinuation)\n\n      return inheritProgramName(program, chained)\n    }\n  }\n\n  // SAFETY: The data-first overload supplies a Program as its first argument.\n  const source = first as RuntimeProgram\n  const chained = () => andThenRuntime(source(), second)\n\n  return inheritProgramName(source, chained)\n}\n\n/** Lazily observe a successful Program value without changing its Result. */\nexport function tap<A>(fn: (value: A) => void): TapOperation<A>\nexport function tap<Input extends RuntimeProgram>(\n  program: ProgramInput<Input>,\n  fn: (value: EffectSuccess<Input>) => void\n): TappedProgram<Input>\nexport function tap(first: RuntimeProgram | RuntimeCallback, second?: RuntimeCallback): any {\n  if (second === undefined) {\n    return (program: RuntimeProgram) => {\n      // SAFETY: The curried overload supplies a Program and a callback that accepts its success channel.\n      return tapProgram(program as ProgramInput<typeof program>, first)\n    }\n  }\n\n  // SAFETY: The data-first overload supplies a Program as its first argument.\n  return tapProgram(first as ProgramInput<RuntimeProgram>, second)\n}\n\n/** Lazily observe a failed Program value without changing its Result. */\nexport function tapError<E>(fn: (error: E) => void): TapErrorOperation<E>\nexport function tapError<Input extends RuntimeProgram>(\n  program: ProgramInput<Input>,\n  fn: (error: EffectError<Input>) => void\n): TappedProgram<Input>\nexport function tapError(first: RuntimeProgram | RuntimeCallback, second?: RuntimeCallback): any {\n  if (second === undefined) {\n    return (program: RuntimeProgram) => {\n      // SAFETY: The curried overload supplies a Program and a callback that accepts its error channel.\n      return tapErrorProgram(program as ProgramInput<typeof program>, first)\n    }\n  }\n\n  // SAFETY: The data-first overload supplies a Program as its first argument.\n  return tapErrorProgram(first as ProgramInput<RuntimeProgram>, second)\n}\n\n/** Lazily recover a failed Program with an Effect or Program. */\nexport function recover<E, Next>(\n  fn: (error: E) => Next & ProgramOutput<Next>\n): RecoverOperation<E, Next>\nexport function recover<Input extends RuntimeProgram, Next>(\n  program: ProgramInput<Input>,\n  recover: (error: EffectError<Input>) => Next & ProgramOutput<Next>\n): RecoveredProgram<Input, Next>\nexport function recover(\n  first: RuntimeProgram | RuntimeContinuation,\n  second?: RuntimeContinuation\n): any {\n  if (second === undefined) {\n    return (program: RuntimeProgram) => {\n      // SAFETY: The curried overload supplies a Program and a recovery callback for its error channel.\n      const recovered = () => recoverRuntime(program(), first as RuntimeContinuation)\n\n      return inheritProgramName(program, recovered)\n    }\n  }\n\n  // SAFETY: The data-first overload supplies a Program as its first argument.\n  const source = first as RuntimeProgram\n  const recovered = () => recoverRuntime(source(), second)\n\n  return inheritProgramName(source, recovered)\n}\n","import { Err } from 'better-result'\n\nimport type { Result as ResultType } from 'better-result'\n\ntype AnyResult = ResultType<any, any>\n\ntype ProgramCollectionFailure =\n  | { readonly kind: 'result'; readonly result: AnyResult }\n  | { readonly kind: 'defect'; readonly cause: unknown }\n\ntype ProgramCollectionDefect = { readonly cause: unknown }\n\ntype ProgramCollectionOutcome = {\n  readonly results: Array<AnyResult | undefined>\n  readonly defects: Array<ProgramCollectionDefect | undefined>\n}\n\nexport type ProgramCollectionOptions = {\n  readonly concurrency: number | undefined\n  readonly stopOnResultError: boolean\n}\n\ntype ProgramTask = (index: number) => AnyResult | PromiseLike<AnyResult>\n\ntype SchedulerState = {\n  nextIndex: number\n  stopScheduling: boolean\n  readonly results: Array<AnyResult | undefined>\n  readonly defects: Array<ProgramCollectionDefect | undefined>\n}\n\n/** Validate the shared bounded-concurrency option before a Program is run. */\nexport const validateProgramConcurrency = (concurrency: number | undefined): void => {\n  if (\n    concurrency !== undefined &&\n    (!Number.isFinite(concurrency) || !Number.isInteger(concurrency) || concurrency <= 0)\n  ) {\n    throw new RangeError('Program.all concurrency must be a positive integer')\n  }\n}\n\nconst runWorker = async (\n  length: number,\n  task: ProgramTask,\n  stopOnResultError: boolean,\n  state: SchedulerState\n): Promise<void> => {\n  while (!state.stopScheduling) {\n    const index = state.nextIndex++\n\n    if (index >= length) {\n      return\n    }\n\n    try {\n      const result = await task(index)\n      state.results[index] = result\n\n      if (result instanceof Err) {\n        state.stopScheduling ||= stopOnResultError\n      }\n    } catch (cause) {\n      state.defects[index] = { cause }\n      state.stopScheduling = true\n    }\n  }\n}\n\n/** Run claimed Programs with a shared FIFO worker pool and no cancellation. */\nexport const runProgramCollection = async (\n  length: number,\n  task: ProgramTask,\n  options: ProgramCollectionOptions\n): Promise<ProgramCollectionOutcome> => {\n  const state: SchedulerState = {\n    nextIndex: 0,\n    stopScheduling: false,\n    results: Array.from({ length }),\n    defects: Array.from({ length })\n  }\n  const workerCount = Math.min(options.concurrency ?? length, length)\n  const workers = Array.from({ length: workerCount }, () =>\n    runWorker(length, task, options.stopOnResultError, state)\n  )\n\n  await Promise.all(workers)\n\n  return state\n}\n\n/** Select the first defect by input index, independent of settlement order. */\nexport const firstProgramDefect = (\n  defects: readonly (ProgramCollectionDefect | undefined)[]\n): ProgramCollectionDefect | undefined => {\n  for (const defect of defects) {\n    if (defect !== undefined) {\n      return defect\n    }\n  }\n\n  return undefined\n}\n\n/** Select the first short-circuiting failure by input index. */\nexport const firstProgramFailure = (\n  results: readonly (AnyResult | undefined)[],\n  defects: readonly (ProgramCollectionDefect | undefined)[]\n): ProgramCollectionFailure | undefined => {\n  const length = Math.max(results.length, defects.length)\n\n  for (let index = 0; index < length; index++) {\n    const defect = defects[index]\n    if (defect !== undefined) {\n      return { kind: 'defect', cause: defect.cause }\n    }\n\n    const result = results[index]\n    if (result instanceof Err) {\n      return { kind: 'result', result }\n    }\n  }\n\n  return undefined\n}\n","import { Result } from 'better-result'\n\nimport type { Err, Result as ResultType, UnhandledException } from 'better-result'\n\nimport { Scope } from '../scope'\n\nimport type { DisposableResource, MaybePromise, ScopeOutcome } from '../scope'\n\nimport { setProgramName } from './program-metadata'\nimport type { AnyService } from '../service'\nimport { forkScoped } from './task'\nimport type { ScopedTask, ScopedTaskExit } from './task'\n\nimport type {\n  AnyEffect,\n  Effect as EffectType,\n  EffectError,\n  EffectFromGenerator,\n  EffectRequirements,\n  EffectSuccess,\n  EffectYield,\n  Program as ProgramType,\n  ProgramFromGenerator\n} from './types'\n\nimport {\n  all,\n  andThen,\n  andThenAsync,\n  as,\n  asVoid,\n  flatten,\n  map,\n  mapError,\n  match,\n  matchError,\n  matchErrorPartial,\n  recover,\n  recoverAsync,\n  tap,\n  tapAsync,\n  tapBoth,\n  tapBothAsync,\n  tapError,\n  tapErrorAsync,\n  zip\n} from './combinators'\nimport {\n  andThen as programAndThen,\n  map as programMap,\n  mapError as programMapError,\n  recover as programRecover,\n  tap as programTap,\n  tapError as programTapError\n} from './program-combinators'\nimport {\n  firstProgramDefect,\n  firstProgramFailure,\n  runProgramCollection,\n  validateProgramConcurrency\n} from './program-scheduler'\n\nexport type Effect<A, E, R extends AnyService = never> = EffectType<A, E, R>\n\ntype LazyProgram<A, E, R extends AnyService = never> = ProgramType<A, E, R>\n\n/** A nominal lazy computation that produces an Effect when invoked. */\nexport type Program<A, E, R extends AnyService = never> = LazyProgram<A, E, R>\n\ntype AnyResult = ResultType<any, any>\n\ntype AnyProgram = ProgramType<any, any, AnyService>\n\ntype ProgramAllSuccess<Programs extends readonly AnyProgram[]> = {\n  -readonly [Index in keyof Programs]: EffectSuccess<Programs[Index]>\n}\n\ntype ProgramAllError<Programs extends readonly AnyProgram[]> = EffectError<Programs[number]>\n\ntype ProgramAllRequirements<Programs extends readonly AnyProgram[]> = EffectRequirements<\n  Programs[number]\n>\n\ntype ProgramAllResult<Programs extends readonly AnyProgram[]> = ProgramType<\n  ProgramAllSuccess<Programs>,\n  ProgramAllError<Programs>,\n  ProgramAllRequirements<Programs>\n>\n\ntype ProgramResultFor<Child> = Child extends AnyProgram\n  ? ResultType<EffectSuccess<Child>, EffectError<Child>>\n  : never\n\ntype ProgramAllResultsSuccess<Programs extends readonly AnyProgram[]> =\n  number extends Programs['length']\n    ? ReadonlyArray<ResultType<EffectSuccess<Programs[number]>, EffectError<Programs[number]>>>\n    : { readonly [Index in keyof Programs]: ProgramResultFor<Programs[Index]> }\n\ntype ProgramAllResultsResult<Programs extends readonly AnyProgram[]> = ProgramType<\n  ProgramAllResultsSuccess<Programs>,\n  never,\n  ProgramAllRequirements<Programs>\n>\n\ntype ProgramForEachResult<Child extends AnyProgram> = ProgramType<\n  ReadonlyArray<EffectSuccess<Child>>,\n  EffectError<Child>,\n  EffectRequirements<Child>\n>\n\nexport type ProgramAllOptions = {\n  readonly concurrency?: number\n  /** Optional diagnostic name for the collection execution. */\n  readonly name?: string\n}\n\ntype EffectGenerator =\n  | (() => Generator<EffectYield, AnyResult, unknown>)\n  | (() => AsyncGenerator<EffectYield, AnyResult, unknown>)\n\ntype RuntimeResultGenerator = (body: EffectGenerator) => AnyResult | Promise<AnyResult>\n\n// SAFETY: Service iterators yield no runtime markers, so Result.gen receives only the Err values that exist at runtime.\nconst runResultGenerator = Result.gen as RuntimeResultGenerator\n\n/**\n * Compose `better-result` operations while preserving Service requirements in\n * a declaration-only type channel.\n *\n * A generator may yield Service tokens and Result operations. It must return a\n * `Result` as its final value; Service yields are resolved by the active\n * Runtime and do not add runtime values to the Result stream.\n * Use `fn` when generator execution should wait for a Runtime boundary.\n *\n * @example\n * ```ts\n * const loadUser = Effect.gen(async function* () {\n *   const database = yield* Database\n *   const user = yield* Result.await(database.findUser('u1'))\n *\n *   return Result.ok(user)\n * })\n * ```\n */\nexport function gen<Yield extends EffectYield, Returned extends AnyResult>(\n  body: () => Generator<Yield, Returned, unknown>\n): EffectFromGenerator<Yield, Returned>\n\nexport function gen<Yield extends EffectYield, Returned extends AnyResult>(\n  body: () => AsyncGenerator<Yield, Returned, unknown>\n): Promise<EffectFromGenerator<Yield, Returned>>\n\nexport function gen(body: EffectGenerator): AnyResult | Promise<AnyResult> {\n  return runResultGenerator(body)\n}\n\n/** Build a lazy Program without running its generator. */\nexport function fn<Yield extends EffectYield, Returned extends AnyResult>(\n  body: () => Generator<Yield, Returned, unknown>\n): ProgramFromGenerator<Yield, Returned>\n\nexport function fn<Yield extends EffectYield, Returned extends AnyResult>(\n  body: () => AsyncGenerator<Yield, Returned, unknown>\n): ProgramFromGenerator<Yield, Returned>\n\nexport function fn(body: EffectGenerator): Program<any, any, AnyService> {\n  const program = () => runResultGenerator(body)\n\n  // SAFETY: The generator overloads derive the Program channels; this cast only adds the declaration-only nominal marker.\n  return program as Program<any, any, AnyService>\n}\n\ntype ProgramNamedOperation = {\n  <Input extends AnyProgram>(program: Input): Input\n}\n\nconst validateProgramName = (name: string): void => {\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate JavaScript callers at the public boundary.\n  if (typeof name !== 'string') {\n    throw new TypeError('Program name must be a string')\n  }\n}\n\n/** Attach a lazy diagnostic name to a Program without invoking it. */\nfunction programNamed(name: string): ProgramNamedOperation\nfunction programNamed<Input extends AnyProgram>(name: string, program: Input): Input\nfunction programNamed(name: string, program?: AnyProgram): AnyProgram | ProgramNamedOperation {\n  validateProgramName(name)\n\n  if (program === undefined) {\n    return (source) => setProgramName(source, name)\n  }\n\n  return setProgramName(program, name)\n}\n\nconst runShortCircuitingCollection = async (\n  length: number,\n  task: (index: number) => AnyResult | PromiseLike<AnyResult>,\n  concurrency: number | undefined\n): Promise<AnyResult> => {\n  const outcome = await runProgramCollection(length, task, {\n    concurrency,\n    stopOnResultError: true\n  })\n  const failure = firstProgramFailure(outcome.results, outcome.defects)\n\n  if (failure?.kind === 'defect') {\n    throw failure.cause\n  }\n\n  if (failure?.kind === 'result') {\n    return failure.result\n  }\n\n  // SAFETY: The scheduler records one Result per claimed index before completing successfully.\n  return Result.all(outcome.results as AnyResult[])\n}\n\nconst runAllResultsCollection = async (\n  length: number,\n  task: (index: number) => AnyResult | PromiseLike<AnyResult>,\n  concurrency: number | undefined\n): Promise<AnyResult> => {\n  const outcome = await runProgramCollection(length, task, {\n    concurrency,\n    stopOnResultError: false\n  })\n  const defect = firstProgramDefect(outcome.defects)\n\n  if (defect !== undefined) {\n    throw defect.cause\n  }\n\n  // SAFETY: The scheduler records each Result object at its input index.\n  return Result.ok(outcome.results as AnyResult[])\n}\n\n/** Build a lazy Program collection with optional bounded concurrency. */\nexport function programAll<const Programs extends readonly AnyProgram[]>(\n  programs: Programs,\n  options: ProgramAllOptions = {}\n): ProgramAllResult<Programs> {\n  const concurrency = options.concurrency\n  const name = options?.name\n  validateProgramConcurrency(concurrency)\n  const program = () =>\n    runShortCircuitingCollection(programs.length, (index) => programs[index]!(), concurrency)\n\n  if (name !== undefined) {\n    validateProgramName(name)\n    setProgramName(program, name)\n  }\n\n  // SAFETY: Program channels are declaration-only and are restored from the input tuple here.\n  return program as ProgramAllResult<Programs>\n}\n\n/** Build a lazy Program collection from an input array and Program factory. */\nexport function programForEach<const Items extends readonly unknown[], Child extends AnyProgram>(\n  items: Items,\n  makeProgram: (item: Items[number], index: number) => Child,\n  options: ProgramAllOptions = {}\n): ProgramForEachResult<Child> {\n  const concurrency = options.concurrency\n  const name = options?.name\n  validateProgramConcurrency(concurrency)\n  const program = () =>\n    runShortCircuitingCollection(\n      items.length,\n      (index) => makeProgram(items[index]!, index)(),\n      concurrency\n    )\n\n  if (name !== undefined) {\n    validateProgramName(name)\n    setProgramName(program, name)\n  }\n\n  // SAFETY: Program channels are declaration-only and are restored from the factory's result type.\n  return program as ProgramForEachResult<Child>\n}\n\n/** Build a lazy Program collection that retains every child Result. */\nexport function programAllResults<const Programs extends readonly AnyProgram[]>(\n  programs: Programs,\n  options: ProgramAllOptions = {}\n): ProgramAllResultsResult<Programs> {\n  const concurrency = options.concurrency\n  const name = options?.name\n  validateProgramConcurrency(concurrency)\n  const program = () =>\n    runAllResultsCollection(programs.length, (index) => programs[index]!(), concurrency)\n\n  if (name !== undefined) {\n    validateProgramName(name)\n    setProgramName(program, name)\n  }\n\n  // SAFETY: Program channels are declaration-only and are restored from the input tuple here.\n  return program as ProgramAllResultsResult<Programs>\n}\n\n/** Value-level namespace for lazy Program combinators. */\nexport const Program = {\n  named: programNamed,\n  all: programAll,\n  forEach: programForEach,\n  allResults: programAllResults,\n  map: programMap,\n  mapError: programMapError,\n  andThen: programAndThen,\n  tap: programTap,\n  tapError: programTapError,\n  recover: programRecover\n} as const\n\n/**\n * Acquire a resource in the current Scope and register its release callback.\n *\n * Acquisition failures are represented in the Effect Result error channel;\n * release failures remain owned by Scope cleanup. The release callback\n * receives the final outcome chosen by the enclosing execution boundary.\n *\n * @example\n * ```ts\n * const connection = yield* Effect.acquireRelease(\n *   () => pool.connect(),\n *   (connection, outcome) => connection.close(outcome)\n * )\n * ```\n */\nexport function acquireRelease<R>(\n  acquire: () => MaybePromise<R>,\n  release: (resource: R, outcome: ScopeOutcome) => MaybePromise<void>\n): AsyncGenerator<Err<never, UnhandledException>, R, unknown> {\n  const scope = Scope.current()\n\n  return Result.await(Result.tryPromise(() => scope.acquire(acquire, release)))\n}\n\nclass AcquireReleaseResultFailure<R, E> {\n  constructor(readonly result: Err<R, E>) {}\n}\n\n/**\n * Acquire a Result-valued resource and register only successful acquisitions.\n *\n * Typed acquisition failures remain unchanged in the Effect error channel;\n * unexpected acquisition and registration failures are normalized by\n * `better-result`. Release failures remain Scope cleanup failures.\n */\nexport function acquireReleaseResult<R, E>(\n  acquire: () => MaybePromise<ResultType<R, E>>,\n  release: (resource: R, outcome: ScopeOutcome) => MaybePromise<void>\n): AsyncGenerator<Err<never, E | UnhandledException>, R, unknown> {\n  const scope = Scope.current()\n  const registered = Result.tryPromise(async (): Promise<ResultType<R, E>> => {\n    try {\n      const resource = await scope.acquire(async () => {\n        const result = await acquire()\n\n        if (Result.isError(result)) {\n          throw new AcquireReleaseResultFailure(result)\n        }\n\n        return result.value\n      }, release)\n\n      return Result.ok(resource)\n    } catch (cause) {\n      if (cause instanceof AcquireReleaseResultFailure) {\n        return cause.result\n      }\n\n      throw cause\n    }\n  })\n\n  return Result.await(registered.then((result) => result.andThen((acquired) => acquired)))\n}\n\n/**\n * Lazily acquire and register a disposable resource in the current Scope.\n *\n * Disposal is delegated to `Scope.add`, including protocol preference,\n * validation, race-safe registration, and cleanup error handling.\n */\nexport function acquireDisposable<R extends DisposableResource>(\n  acquire: () => MaybePromise<R>\n): AsyncGenerator<Err<never, UnhandledException>, R, unknown> {\n  const scope = Scope.current()\n\n  return Result.await(Result.tryPromise(async () => scope.add(await acquire())))\n}\n\n/**\n * Register an already-acquired disposable resource in the current Scope.\n *\n * The resource is not acquired by this helper. Registration failures are\n * represented in the Effect Result error channel; disposal failures remain\n * owned by Scope cleanup.\n *\n * @example\n * ```ts\n * const file = yield* Effect.add(await openFile('notes.txt'))\n * ```\n */\nexport function add<R extends DisposableResource>(\n  resource: R\n): AsyncGenerator<Err<never, UnhandledException>, R, unknown> {\n  const scope = Scope.current()\n\n  return Result.await(Result.tryPromise(() => scope.add(resource)))\n}\n\n/**\n * Effect namespace containing generator, resource, and Result combinators.\n *\n * Prefer these helpers when a program needs typed Service requirements or\n * Scope-aware acquisition and cleanup.\n */\ntype EffectNamespace = {\n  readonly gen: typeof gen\n  readonly fn: typeof fn\n  readonly acquireRelease: typeof acquireRelease\n  readonly acquireReleaseResult: typeof acquireReleaseResult\n  readonly acquireDisposable: typeof acquireDisposable\n  readonly add: typeof add\n  readonly forkScoped: typeof forkScoped\n  readonly map: typeof map\n  readonly mapError: typeof mapError\n  readonly andThen: typeof andThen\n  readonly andThenAsync: typeof andThenAsync\n  readonly tap: typeof tap\n  readonly tapAsync: typeof tapAsync\n  readonly tapError: typeof tapError\n  readonly tapErrorAsync: typeof tapErrorAsync\n  readonly tapBoth: typeof tapBoth\n  readonly tapBothAsync: typeof tapBothAsync\n  readonly matchError: typeof matchError\n  readonly matchErrorPartial: typeof matchErrorPartial\n  readonly recover: typeof recover\n  readonly recoverAsync: typeof recoverAsync\n  readonly flatten: typeof flatten\n  readonly as: typeof as\n  readonly asVoid: typeof asVoid\n  readonly match: typeof match\n  readonly all: typeof all\n  readonly zip: typeof zip\n}\n\nexport const Effect: EffectNamespace = {\n  /** Compose a generator-based Effect program. */\n  gen,\n  /** Build a lazy Program from a generator. */\n  fn,\n  /** Acquire and register a resource in the current Scope. */\n  acquireRelease,\n  /** Acquire a Result-valued resource and register successful acquisitions. */\n  acquireReleaseResult,\n  /** Acquire and register a disposable resource in the current Scope. */\n  acquireDisposable,\n  /** Register an already-acquired disposable in the current Scope. */\n  add,\n  /** Start a child Program owned by the current Scope. */\n  forkScoped,\n  /** Map a successful Effect result. */\n  map,\n  /** Map an Effect error. */\n  mapError,\n  /** Chain a synchronous Effect result. */\n  andThen,\n  /** Chain an asynchronous Effect result. */\n  andThenAsync,\n  /** Observe successful values without changing the Result. */\n  tap,\n  /** Observe successful values asynchronously without changing the Result. */\n  tapAsync,\n  /** Observe error values without changing the Result. */\n  tapError,\n  /** Observe error values asynchronously without changing the Result. */\n  tapErrorAsync,\n  /** Observe the active Result branch without changing the Result. */\n  tapBoth,\n  /** Observe the active Result branch asynchronously without changing the Result. */\n  tapBothAsync,\n  /** Match every tagged error variant and map it to a new error value. */\n  matchError,\n  /** Match selected tagged errors and retain unhandled variants. */\n  matchErrorPartial,\n  /** Recover an error with another Effect. */\n  recover,\n  /** Recover an error asynchronously with another Effect. */\n  recoverAsync,\n  /** Remove one nested Effect layer. */\n  flatten,\n  /** Replace a successful value. */\n  as,\n  /** Replace a successful value with void. */\n  asVoid,\n  /** Match either Result branch. */\n  match,\n  /** Collect Effects in input order. */\n  all,\n  /** Zip two Effects in input order. */\n  zip\n} as const\n\n/** Type-level aliases for inspecting Effect result channels and requirements. */\nexport declare namespace Effect {\n  /** A nominal lazy computation that produces an Effect when invoked. */\n  export type Program<A, E, R extends AnyService = never> = LazyProgram<A, E, R>\n\n  /** Extract the success channel from an Effect result or Promise. */\n  export type Success<T> = EffectSuccess<T>\n\n  /** Extract the error channel from an Effect result or Promise. */\n  export type Error<T> = EffectError<T>\n\n  /** Extract the Service requirements from an Effect result or Promise. */\n  export type Requirements<T> = EffectRequirements<T>\n\n  /** An Effect with erased success, error, and requirements. */\n  export type Any = AnyEffect\n\n  /** A small handle for a Scope-owned child task. */\n  export type Task<A, E> = ScopedTask<A, E>\n\n  /** The terminal observation returned by a Scope-owned child task. */\n  export type TaskExit<A, E> = ScopedTaskExit<A, E>\n}\n"],"mappings":"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"}

package/dist/{errors-BKcsQ0ip.d.mts → errors-CpHMzPiP.d.mts}

@@ -7,6 +7,10 @@ declare class RuntimeContextNotConfiguredError extends Error {
 declare class RuntimeContextOverlapError extends Error {
   constructor();
 }
+/** Thrown when a Runtime executor is requested without an active Runtime. */
+declare class RuntimeExecutorNotConfiguredError extends Error {
+  constructor();
+}
 //#endregion
-export { RuntimeContextOverlapError as n, RuntimeContextNotConfiguredError as t };
-//# sourceMappingURL=errors-BKcsQ0ip.d.mts.map
+export { RuntimeContextOverlapError as n, RuntimeExecutorNotConfiguredError as r, RuntimeContextNotConfiguredError as t };
+//# sourceMappingURL=errors-CpHMzPiP.d.mts.map

package/dist/errors-CpHMzPiP.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-CpHMzPiP.d.mts","names":[],"sources":["../src/runtime/errors.ts"],"mappings":";;cACa,yCAAyC;EACpD;;;cAQW,mCAAmC;EAC9C;;;cAUW,0CAA0C;EACrD"}

package/dist/hono.d.mts

@@ -1,7 +1,6 @@
-import { A as ProgramFromGenerator, C as EffectError, D as EffectYield, E as EffectSuccess, M as AnyService, k as Program } from "./index-AiKM71-u.mjs";
-import { D as ValidateOneOverride, E as ValidateLayerInput, S as MissingServices, T as RequiredEnvironment, j as MissingDependencies, v as ExecutionMissing, w as ProvidedEnvironment, y as LayerInput } from "./outcome-DI8LPIQ4.mjs";
-import { l as Runtime } from "./index-BodMy6rO.mjs";
-import { t as CurrentRequest } from "./current-request-CIU7AHhF.mjs";
+import { At as EffectRequirements, Bt as ServiceContract, Ft as ProgramFromGenerator, It as ServiceRequirement, Kt as ServiceToken, Lt as AnyService, Mt as EffectYield, Nt as InferYieldRequirements, Ot as EffectError, Pt as Program, Ut as ServiceRequirements, Vt as ServiceIdentity, ct as ValidateLayerInput, ft as ProviderEntry, it as MissingServices, jt as EffectSuccess, lt as ValidateOneOverride, ot as ProvidedEnvironment, rt as LayerResult, st as RequiredEnvironment, tt as LayerInput } from "./layer-C2OaqTmB.mjs";
+import { t as CurrentRequest } from "./current-request-Dm-QQ3Xr.mjs";
+import { c as WebEffectStream } from "./types-BFTqCCcw.mjs";
 import { Result } from "better-result";
 import { Context, Env, Handler, HonoRequest, Input, MiddlewareHandler } from "hono";
 //#region src/hono/types.d.ts
@@ -10,6 +9,11 @@ type AnyProgram = Program<any, any, AnyService>;
 type HonoContext = Context<any, any, any>;
 type ResponseLike = Response | Promise<Response>;
 type AnyHonoMiddleware = MiddlewareHandler<any, any, any>;
+/** A builder operation resolved while the application Layer is acquired. */
+interface HonoEffectOperation<A, Requirements extends AnyService = never> {
+  readonly [Symbol.iterator]: () => Generator<ServiceRequirement<Requirements>, A, unknown>;
+  readonly [Symbol.asyncIterator]: () => AsyncGenerator<ServiceRequirement<Requirements>, A, unknown>;
+}
 type MiddlewareInput<Middleware extends AnyHonoMiddleware> = Middleware extends MiddlewareHandler<any, any, infer InputType> ? InputType : Input;
 type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends ((value: infer Intersection) => void) ? Intersection : never;
 type MiddlewareInputs<Middlewares extends readonly AnyHonoMiddleware[]> = Middlewares extends readonly [] ? Input : Input & UnionToIntersection<MiddlewareInput<Middlewares[number]>>;
@@ -42,7 +46,6 @@ type HonoJsonValue = null | boolean | number | string | readonly HonoJsonValue[]
 };
 type DefaultRequestLayer = ReturnType<typeof CurrentRequest.layer>;
 type RequestProvided<RequestLayer extends LayerInput> = ProvidedEnvironment<RequestLayer>;
-type AvailableServices<Provided extends AnyService, RequestLayer extends LayerInput> = Provided | InstanceType<typeof CurrentRequest> | RequestProvided<RequestLayer>;
 type InvalidFailure<Actual, Expected> = {
   readonly __betterEffectInvalidHonoFailure: {
     readonly actual: Actual;
@@ -51,14 +54,14 @@ type InvalidFailure<Actual, Expected> = {
 };
 type FailureCheck<Failure, Actual> = [Actual] extends [Failure] ? unknown : InvalidFailure<Actual, Failure>;
 type ProgramFailure<Failure, Program extends AnyProgram> = FailureCheck<Failure, EffectError<Program>>;
-type RequestLayerMissing<Provided extends AnyService, RequestLayer extends LayerInput> = MissingServices<Extract<RequiredEnvironment<RequestLayer>, AnyService>, Extract<Provided | InstanceType<typeof CurrentRequest>, AnyService>>;
-type RequestLayerChecks<Provided extends AnyService, RequestLayer extends LayerInput> = ValidateLayerInput<RequestLayer> & ValidateOneOverride<DefaultRequestLayer, RequestLayer> & ([RequestLayerMissing<Provided, RequestLayer>] extends [never] ? unknown : MissingDependencies<RequestLayerMissing<Provided, RequestLayer>>);
-/** Validate a request Layer against the Runtime root and built-in CurrentRequest provider. */
-type HonoRequestLayerChecks<Provided extends AnyService, RequestLayer extends LayerInput> = RequestLayerChecks<Provided, RequestLayer>;
-type ProgramMissing<Provided extends AnyService, Program extends AnyProgram> = ExecutionMissing<Provided, Program>;
-type CompleteProgram<Provided extends AnyService, Program extends AnyProgram, Failure = unknown> = Program & ([ProgramMissing<Provided, Program>] extends [never] ? unknown : MissingDependencies<ProgramMissing<Provided, Program>>) & ProgramFailure<Failure, Program>;
+/** Validate a request Layer against the built-in CurrentRequest provider. */
+type HonoRequestLayerChecks<RequestLayer extends LayerInput> = ValidateLayerInput<RequestLayer> & ValidateOneOverride<DefaultRequestLayer, RequestLayer>;
+/** Requirements of a route Program that must be provided by the application Layer. */
+type HonoProgramRequirements<RequestLayer extends LayerInput, Program extends AnyProgram> = Extract<RequiredEnvironment<RequestLayer> | MissingServices<Extract<EffectRequirements<Program>, AnyService>, Extract<InstanceType<typeof CurrentRequest> | RequestProvided<RequestLayer>, AnyService>>, AnyService>;
+/** Validate only a route Program's typed failure channel at the builder boundary. */
+type CompleteProgram<Program extends AnyProgram, Failure = unknown> = Program & ProgramFailure<Failure, Program>;
 type GeneratorBody<ContextType extends object, Yield extends EffectYield, Returned extends AnyResult> = (context: ContextType) => Generator<Yield, Returned, unknown> | AsyncGenerator<Yield, Returned, unknown>;
-type GeneratorChecks<Provided extends AnyService, Yield extends EffectYield, Returned extends AnyResult, Failure = unknown> = ([ProgramMissing<Provided, ProgramFromGenerator<Yield, Returned>>] extends [never] ? unknown : MissingDependencies<ProgramMissing<Provided, ProgramFromGenerator<Yield, Returned>>>) & FailureCheck<Failure, EffectError<ProgramFromGenerator<Yield, Returned>>>;
+type GeneratorChecks<Yield extends EffectYield, Returned extends AnyResult, Failure = unknown> = FailureCheck<Failure, EffectError<ProgramFromGenerator<Yield, Returned>>>;
 type HonoEffectSuccess<A = unknown> = {
   readonly value: A;
   readonly status?: number;
@@ -74,27 +77,40 @@ type HonoEffectRouteOptions<A, ContextType extends HonoContext = HonoContext> =
   readonly serialize?: (value: A) => HonoJsonValue;
   readonly respond?: (value: A, context: ContextType) => ResponseLike;
 };
+/** Options for a managed Hono stream route. */
+type HonoEffectStreamOptions = {
+  /** Cancel an unconsumed or abandoned body after this idle period. */
+  readonly unconsumedTimeoutMs?: number;
+};
+type StreamValueCheck<Program extends AnyProgram> = [EffectSuccess<Program>] extends [WebEffectStream] ? unknown : {
+  readonly __betterEffectInvalidHonoStream: {
+    readonly actual: EffectSuccess<Program>;
+    readonly expected: WebEffectStream;
+  };
+};
+/** Validate a managed stream Program at the Hono builder boundary. */
+type CompleteHonoStreamProgram<Program extends AnyProgram, Failure = unknown> = Program & ProgramFailure<Failure, Program> & StreamValueCheck<Program>;
 //#endregion
-//#region src/hono/hono-effect.d.ts
+//#region src/hono/builder.d.ts
 type HonoRouteArguments<Middlewares extends readonly AnyHonoMiddleware[], Body, Options> = [...middlewares: Middlewares, body: Body] | [...middlewares: Middlewares, body: Body, options: Options | undefined];
-type HonoHandlerFactory<ContextType extends object, Provided extends AnyService, Failure, ProgramFactory extends (context: ContextType) => AnyProgram> = ProgramFactory & ([ReturnType<ProgramFactory>] extends [CompleteProgram<Provided, ReturnType<ProgramFactory>, Failure>] ? unknown : (context: ContextType) => CompleteProgram<Provided, ReturnType<ProgramFactory>, Failure>);
-/** Run Effect Programs inside one Runtime execution per Hono request. */
-declare class HonoEffect<Provided extends AnyService = any, Failure = unknown, RequestLayer extends LayerInput = DefaultRequestLayer> {
-  readonly runtime: Runtime<Provided>;
+type HonoHandlerFactory<ContextType extends object, Failure, ProgramFactory extends (context: ContextType) => AnyProgram> = ProgramFactory & ([ReturnType<ProgramFactory>] extends [CompleteProgram<ReturnType<ProgramFactory>, Failure>] ? unknown : (context: ContextType) => CompleteProgram<ReturnType<ProgramFactory>, Failure>);
+/** Build Hono-native handlers whose Runtime capability is captured by the app Layer. */
+declare class HonoEffectBuilder<Failure, RequestLayer extends LayerInput> {
   private readonly states;
   private readonly onSuccess;
   private readonly onFailure;
   private readonly requestLayer;
-  private constructor();
-  static make<Provided extends AnyService, Failure = unknown, RequestLayer extends LayerInput = DefaultRequestLayer>(runtime: Runtime<Provided>, options?: HonoEffectOptions<Failure, RequestLayer> & HonoRequestLayerChecks<Provided, RequestLayer>): HonoEffect<Provided, Failure, RequestLayer>;
-  middleware<E extends Env = Env, Path extends string = string>(): MiddlewareHandler<E, Path>;
-  handler<E extends Env = Env, Path extends string = string, InputType extends Input = Input, Program extends AnyProgram = AnyProgram>(makeProgram: (context: Context<E, Path, InputType>) => CompleteProgram<AvailableServices<Provided, RequestLayer>, Program, Failure>, options?: HonoEffectRouteOptions<EffectSuccess<Program>, Context<E, Path, InputType>>): Handler<E, Path, InputType, Promise<Response>>;
-  handler<const Middlewares extends readonly AnyHonoMiddleware[], E extends Env = MiddlewareEnvironment<Middlewares>, Path extends string = MiddlewarePath<Middlewares>, const ProgramFactory extends (context: HonoEffectContext<E, Path, MiddlewareInputs<Middlewares>>) => AnyProgram = (context: HonoEffectContext<E, Path, MiddlewareInputs<Middlewares>>) => AnyProgram>(...args: HonoRouteArguments<Middlewares, HonoHandlerFactory<HonoEffectContext<E, Path, MiddlewareInputs<Middlewares>>, AvailableServices<Provided, RequestLayer>, Failure, ProgramFactory>, HonoEffectRouteOptions<EffectSuccess<ReturnType<ProgramFactory>>, Context<E, Path, MiddlewareInputs<Middlewares>>>>): Handler<E, Path, MiddlewareInputs<Middlewares>, Promise<Response>>;
-  gen<E extends Env = Env, Path extends string = string, InputType extends Input = Input, const Yield extends EffectYield = EffectYield, const Returned extends AnyResult = AnyResult>(body: GeneratorBody<Context<E, Path, InputType>, Yield, Returned> & GeneratorChecks<AvailableServices<Provided, RequestLayer>, Yield, Returned, Failure>, options?: HonoEffectRouteOptions<EffectSuccess<ProgramFromGenerator<Yield, Returned>>, Context<E, Path, InputType>>): Handler<E, Path, InputType, Promise<Response>>;
-  gen<const Middlewares extends readonly AnyHonoMiddleware[], E extends Env = MiddlewareEnvironment<Middlewares>, Path extends string = MiddlewarePath<Middlewares>, const Yield extends EffectYield = EffectYield, const Returned extends AnyResult = AnyResult>(...args: HonoRouteArguments<Middlewares, GeneratorBody<HonoEffectContext<E, Path, MiddlewareInputs<Middlewares>>, Yield, Returned> & GeneratorChecks<AvailableServices<Provided, RequestLayer>, Yield, Returned, Failure>, HonoEffectRouteOptions<EffectSuccess<ProgramFromGenerator<Yield, Returned>>, Context<E, Path, MiddlewareInputs<Middlewares>>>>): Handler<E, Path, MiddlewareInputs<Middlewares>, Promise<Response>>;
-  guard<E extends Env = Env, Path extends string = string, InputType extends Input = Input, const Yield extends EffectYield = EffectYield, const Returned extends AnyResult = AnyResult>(body: GeneratorBody<Context<E, Path, InputType>, Yield, Returned> & GeneratorChecks<AvailableServices<Provided, RequestLayer>, Yield, Returned, Failure>): MiddlewareHandler<E, Path>;
-  private recordFailure;
+  constructor(options: HonoEffectOptions<Failure, RequestLayer>);
+  middleware<E extends Env = Env, Path extends string = string>(): HonoEffectOperation<MiddlewareHandler<E, Path>, Extract<RequiredEnvironment<RequestLayer>, AnyService>>;
+  handler<E extends Env = Env, Path extends string = string, InputType extends Input = Input, Program extends AnyProgram = AnyProgram>(makeProgram: (context: Context<E, Path, InputType>) => CompleteProgram<Program, Failure>, options?: HonoEffectRouteOptions<EffectSuccess<Program>, Context<E, Path, InputType>>): HonoEffectOperation<Handler<E, Path, InputType, Promise<Response>>, HonoProgramRequirements<RequestLayer, Program>>;
+  handler<const Middlewares extends readonly AnyHonoMiddleware[], E extends Env = MiddlewareEnvironment<Middlewares>, Path extends string = MiddlewarePath<Middlewares>, const ProgramFactory extends (context: HonoEffectContext<E, Path, MiddlewareInputs<Middlewares>>) => AnyProgram = (context: HonoEffectContext<E, Path, MiddlewareInputs<Middlewares>>) => AnyProgram>(...args: HonoRouteArguments<Middlewares, HonoHandlerFactory<HonoEffectContext<E, Path, MiddlewareInputs<Middlewares>>, Failure, ProgramFactory>, HonoEffectRouteOptions<EffectSuccess<ReturnType<ProgramFactory>>, Context<E, Path, MiddlewareInputs<Middlewares>>>>): HonoEffectOperation<Handler<E, Path, MiddlewareInputs<Middlewares>, Promise<Response>>, HonoProgramRequirements<RequestLayer, ReturnType<ProgramFactory>>>;
+  gen<E extends Env = Env, Path extends string = string, InputType extends Input = Input, const Yield extends EffectYield = EffectYield, const Returned extends AnyResult = AnyResult>(body: GeneratorBody<Context<E, Path, InputType>, Yield, Returned> & GeneratorChecks<Yield, Returned, Failure>, options?: HonoEffectRouteOptions<EffectSuccess<ProgramFromGenerator<Yield, Returned>>, Context<E, Path, InputType>>): HonoEffectOperation<Handler<E, Path, InputType, Promise<Response>>, HonoProgramRequirements<RequestLayer, ProgramFromGenerator<Yield, Returned>>>;
+  gen<const Middlewares extends readonly AnyHonoMiddleware[], E extends Env = MiddlewareEnvironment<Middlewares>, Path extends string = MiddlewarePath<Middlewares>, const Yield extends EffectYield = EffectYield, const Returned extends AnyResult = AnyResult>(...args: HonoRouteArguments<Middlewares, GeneratorBody<HonoEffectContext<E, Path, MiddlewareInputs<Middlewares>>, Yield, Returned> & GeneratorChecks<Yield, Returned, Failure>, HonoEffectRouteOptions<EffectSuccess<ProgramFromGenerator<Yield, Returned>>, Context<E, Path, MiddlewareInputs<Middlewares>>>>): HonoEffectOperation<Handler<E, Path, MiddlewareInputs<Middlewares>, Promise<Response>>, HonoProgramRequirements<RequestLayer, ProgramFromGenerator<Yield, Returned>>>;
+  stream<E extends Env = Env, Path extends string = string, InputType extends Input = Input, Program extends AnyProgram = AnyProgram>(program: CompleteHonoStreamProgram<Program, Failure>, options?: HonoEffectStreamOptions): HonoEffectOperation<Handler<E, Path, InputType, Promise<Response>>, HonoProgramRequirements<RequestLayer, Program>>;
+  stream<const Middlewares extends readonly AnyHonoMiddleware[], E extends Env = MiddlewareEnvironment<Middlewares>, Path extends string = MiddlewarePath<Middlewares>, Program extends AnyProgram = AnyProgram>(...args: HonoRouteArguments<Middlewares, CompleteHonoStreamProgram<Program, Failure>, HonoEffectStreamOptions>): HonoEffectOperation<Handler<E, Path, MiddlewareInputs<Middlewares>, Promise<Response>>, HonoProgramRequirements<RequestLayer, Program>>;
+  guard<E extends Env = Env, Path extends string = string, InputType extends Input = Input, const Yield extends EffectYield = EffectYield, const Returned extends AnyResult = AnyResult>(body: GeneratorBody<Context<E, Path, InputType>, Yield, Returned> & GeneratorChecks<Yield, Returned, Failure>): HonoEffectOperation<MiddlewareHandler<E, Path>, HonoProgramRequirements<RequestLayer, ProgramFromGenerator<Yield, Returned>>>;
   private makeHandler;
+  private makeStreamHandler;
   private handleSuccess;
   private handleFailure;
   private composeInputMiddleware;
@@ -104,5 +120,25 @@ declare class HonoEffectBoundaryMissingError extends Error {
   constructor();
 }
 //#endregion
-export { type HonoContext, HonoEffect, HonoEffectBoundaryMissingError, type HonoEffectOptions, type HonoEffectRouteOptions, type HonoEffectSuccess, type HonoJsonValue };
+//#region src/hono/hono-effect.d.ts
+type HonoFactoryFor<Builder, Returned extends object> = (http: Builder) => Generator<ServiceRequirement<unknown>, Returned, unknown> | AsyncGenerator<ServiceRequirement<unknown>, Returned, unknown>;
+type HonoFactory<Builder> = HonoFactoryFor<Builder, object>;
+type HonoFactoryReturn<Factory> = Factory extends ((...arguments_: any[]) => infer Iterator) ? Iterator extends Generator<any, infer Returned, any> ? Returned extends object ? Returned : never : Iterator extends AsyncGenerator<any, infer Returned, any> ? Returned extends object ? Returned : never : never : never;
+type HonoFactoryYield<Factory> = Factory extends ((...arguments_: any[]) => infer Iterator) ? Iterator extends Generator<infer Yield, object, any> ? Yield : Iterator extends AsyncGenerator<infer Yield, object, any> ? Yield : never : never;
+/** A Hono application Layer with inferred Service requirements. */
+type HonoEffectLayer<Service extends ServiceToken<any, any>, Yield extends ServiceRequirement<unknown>> = LayerResult<ProviderEntry<InstanceType<Service>, Extract<ServiceRequirements<InstanceType<Service>> | InferYieldRequirements<Yield>, AnyService>>>;
+type HonoApplicationToken<Tag extends string, App extends object, Service extends ServiceToken<any, any>, Yield extends ServiceRequirement<unknown>> = ServiceToken<Tag, App & ServiceIdentity<Tag>> & {
+  readonly layer: HonoEffectLayer<Service, Yield>;
+};
+type HonoLiteralTag<Tag extends string> = string extends Tag ? never : Tag extends '' ? never : Tag;
+/** Layer-first Hono integration. The application owns the Runtime composition. */
+declare class HonoEffect {
+  private constructor();
+  /** Create a yieldable Hono application token and its Layer. */
+  static app<const Tag extends string, RequestLayer extends LayerInput = DefaultRequestLayer, Failure = unknown, const Factory extends HonoFactory<HonoEffectBuilder<Failure, RequestLayer>> = HonoFactory<HonoEffectBuilder<Failure, RequestLayer>>>(tag: Tag & HonoLiteralTag<Tag>, options: HonoEffectOptions<Failure, RequestLayer> & HonoRequestLayerChecks<RequestLayer>, factory: Factory): HonoApplicationToken<Tag, HonoFactoryReturn<Factory>, ServiceToken<Tag, HonoFactoryReturn<Factory> & ServiceIdentity<Tag>>, Extract<HonoFactoryYield<Factory>, ServiceRequirement<unknown>>>;
+  /** Provide an application-chosen Service token with a Hono Layer. */
+  static layer<Service extends ServiceToken<any, any>, RequestLayer extends LayerInput = DefaultRequestLayer, Failure = unknown, const Returned extends ServiceContract<InstanceType<Service>> = ServiceContract<InstanceType<Service>>, const Factory extends HonoFactoryFor<HonoEffectBuilder<Failure, RequestLayer>, Returned> = HonoFactoryFor<HonoEffectBuilder<Failure, RequestLayer>, Returned>>(service: Service, options: HonoEffectOptions<Failure, RequestLayer> & HonoRequestLayerChecks<RequestLayer>, factory: Factory): HonoEffectLayer<Service, Extract<HonoFactoryYield<Factory>, ServiceRequirement<unknown>>>;
+}
+//#endregion
+export { type HonoApplicationToken, type HonoContext, HonoEffect, HonoEffectBoundaryMissingError, type HonoEffectLayer, type HonoEffectOperation, type HonoEffectOptions, type HonoEffectRouteOptions, type HonoEffectStreamOptions, type HonoEffectSuccess, type HonoJsonValue };
 //# sourceMappingURL=hono.d.mts.map

package/dist/hono.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"hono.d.mts","names":[],"sources":["../src/hono/types.ts","../src/hono/hono-effect.ts"],"mappings":"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"}
+{"version":3,"file":"hono.d.mts","names":[],"sources":["../src/hono/types.ts","../src/hono/builder.ts","../src/hono/hono-effect.ts"],"mappings":"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"}