better-effect 0.11.0 → 0.12.0

package/dist/effect-CK4YZaX0.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-CK4YZaX0.mjs","names":["map","mapError","andThen","next","resultMatchError","resultMatchErrorPartial","tap","tapError","matchError","matchErrorPartial","recover","programMap","programMapError","programAndThen","programTap","programTapError","programRecover"],"sources":["../src/effect/combinators.ts","../src/effect/program-combinators.ts","../src/effect/program-scheduler.ts","../src/effect/effect.ts"],"sourcesContent":["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'\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 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  /** 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"],"mappings":"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"}

package/dist/hono.d.mts

@@ -1,7 +1,7 @@
 import { A as ProgramFromGenerator, C as EffectError, D as EffectYield, E as EffectSuccess, M as AnyService, k as Program } from "./index-heuaRmXR.mjs";
-import { E as LayerInput, M as RequiredEnvironment, N as ValidateLayerInput, P as ValidateOneOverride, R as MissingDependencies, T as ExecutionMissing, j as ProvidedEnvironment, k as MissingServices } from "./index-rQhZk3Nt.mjs";
-import { f as Runtime } from "./index-C7Qild0_.mjs";
-import { a as CurrentRequest } from "./index-DStz0JMN.mjs";
+import { A as MissingServices, D as LayerInput, E as ExecutionMissing, F as ValidateOneOverride, M as ProvidedEnvironment, N as RequiredEnvironment, P as ValidateLayerInput, z as MissingDependencies } from "./outcome-CB43bnFW.mjs";
+import { l as Runtime } from "./index-GYJ4qm9K.mjs";
+import { s as CurrentRequest } from "./index-B1nH4luq.mjs";
 import { Result } from "better-result";
 import { Context, Env, Handler, HonoRequest, Input, MiddlewareHandler } from "hono";
 //#region src/hono/types.d.ts

package/dist/hono.mjs

@@ -1,6 +1,6 @@
-import { r as Layer } from "./signal-B97cs85Z.mjs";
-import { t as Effect } from "./effect-2ZcGZI8A.mjs";
-import { a as CurrentRequest } from "./standard-services-BFBq-4lo.mjs";
+import { t as Layer } from "./layer-D56fRdLt.mjs";
+import { t as Effect } from "./effect-CK4YZaX0.mjs";
+import { a as CurrentRequest } from "./standard-services-GBZ32tll.mjs";
 import { Result } from "better-result";
 import { createMiddleware } from "hono/factory";
 //#region src/hono/request-boundary.ts

package/dist/{index-DStz0JMN.d.mts → index-B1nH4luq.d.mts}

@@ -1,6 +1,6 @@
 import { H as ServiceToken, I as ServiceIdentity, b as Service, j as ServiceRequirement } from "./index-heuaRmXR.mjs";
-import { L as ProviderEntry, O as LayerResult } from "./index-rQhZk3Nt.mjs";
-import "./index-C7Qild0_.mjs";
+import { R as ProviderEntry, k as LayerResult } from "./outcome-CB43bnFW.mjs";
+import "./index-GYJ4qm9K.mjs";
 import { Err, StandardSchemaV1, UnhandledException } from "better-result";
 //#region src/standard-services/config.d.ts
 /** Raw string values supplied to a configuration schema. */
@@ -67,7 +67,59 @@ declare class Config extends Config_base {
 /** The default lazy host-environment Config provider. */
 declare const ConfigLive: LayerResult<ProviderEntry<Config, never>>;
 //#endregion
+//#region src/standard-services/id-generator.d.ts
+/** Thrown when the host does not expose the supported Web Crypto UUID API. */
+declare class IdGeneratorUnavailableError extends Error {
+  constructor();
+}
+/** Thrown when an {@link IdGeneratorTest} queue has no IDs left. */
+declare class IdGeneratorExhaustedError extends Error {
+  readonly generated: number;
+  constructor(generated: number);
+}
+declare const IdGenerator_base: (abstract new () => ServiceIdentity<"IdGenerator">) & {
+  readonly name: string;
+  readonly serviceTag: "IdGenerator";
+} & {
+  readonly of: Service.FactoryOf<IdGenerator, "IdGenerator">;
+  readonly [Symbol.asyncIterator]: (this: ServiceToken<"IdGenerator", IdGenerator & ServiceIdentity<"IdGenerator">>) => AsyncGenerator<ServiceRequirement<IdGenerator>, IdGenerator, unknown>;
+};
+/** Host-backed UUID string ID service. */
+declare class IdGenerator extends IdGenerator_base {
+  /** Generate a cryptographically strong UUID string using the host Web Crypto API. */
+  next(): string;
+}
+/** The default host IdGenerator provider. */
+declare const IdGeneratorLive: LayerResult<ProviderEntry<IdGenerator, never>>;
+type IdFactory = (index: number) => string;
+/** Deterministic queue- or factory-backed IdGenerator implementation for tests. */
+declare class IdGeneratorTest implements Service.Contract<IdGenerator> {
+  private readonly queue;
+  private factory;
+  private generatedCount;
+  constructor(ids?: readonly string[]);
+  /** Number of IDs successfully returned by this test generator. */
+  get generated(): number;
+  /** Number of queued IDs still available, or Infinity for a factory. */
+  get remaining(): number;
+  /** Return the next queued or factory-generated string ID. */
+  next(): string;
+  /**
+   * Create a factory-backed generator. The factory receives a monotonic
+   * zero-based index: the first call receives 0, then 1, and so on.
+   */
+  static from(factory: IdFactory): IdGeneratorTest;
+  /** Create a Layer for this generator, allocating a fresh empty queue by default. */
+  static layer(generator?: IdGeneratorTest): LayerResult<ProviderEntry<IdGenerator, never>>;
+}
+/** Compatible functional shorthand for {@link IdGeneratorTest.layer}. */
+declare const IdGeneratorTestLayer: (generator?: IdGeneratorTest) => LayerResult<ProviderEntry<IdGenerator, never>>;
+//#endregion
 //#region src/standard-services/index.d.ts
+/** Optional cooperative cancellation for a host or test Clock sleep. */
+type ClockSleepOptions = {
+  readonly signal?: AbortSignal;
+};
 declare const Clock_base: (abstract new () => ServiceIdentity<"Clock">) & {
   readonly name: string;
   readonly serviceTag: "Clock";
@@ -78,21 +130,36 @@ declare const Clock_base: (abstract new () => ServiceIdentity<"Clock">) & {
 /** Host-backed time and waiting service. */
 declare class Clock extends Clock_base {
   now(): Date;
-  sleep(milliseconds: number): Promise<void>;
+  /** Rejects with the signal reason, or an AbortError-compatible fallback. */
+  sleep(milliseconds: number, options?: ClockSleepOptions): Promise<void>;
 }
 /** The default host Clock provider. */
 declare const ClockLive: LayerResult<ProviderEntry<Clock, never>>;
+/** Limits deadline advances performed by `ClockTest.runAll`. */
+type ClockTestRunAllOptions = {
+  readonly maxSteps?: number;
+};
 /** Deterministic Clock implementation for tests. */
 declare class ClockTest implements Service.Contract<Clock> {
   private currentTime;
   private readonly waiters;
   constructor(initial?: Date | number);
+  /** Number of sleeps that have not been settled or cancelled. */
+  get pendingSleeps(): number;
   now(): Date;
+  /** Set an absolute time; moving backward leaves existing absolute deadlines unchanged. */
   setTime(value: Date | number): void;
   advance(milliseconds: number): void;
-  sleep(milliseconds: number): Promise<void>;
+  sleep(milliseconds: number, options?: ClockSleepOptions): Promise<void>;
+  /** Advance synchronously; due Promise continuations run after this method returns. */
+  advanceToNext(): boolean;
+  /** Advance all pending deadlines, guarding at 1,000 steps by default. */
+  runAll(options?: ClockTestRunAllOptions): Promise<number>;
   static layer(initial?: Date | number): LayerResult<ProviderEntry<Clock, never>>;
+  private enqueueWaiter;
+  private cancelWaiter;
   private flushWaiters;
+  private finishWaiter;
 }
 declare const ClockTestLayer: (initial?: Date | number) => LayerResult<ProviderEntry<Clock, never>>;
 declare const Random_base: (abstract new () => ServiceIdentity<"Random">) & {
@@ -178,5 +245,5 @@ declare class CurrentRequest extends CurrentRequest_base {
 }
 declare const CurrentRequestLayer: (value: unknown) => LayerResult<ProviderEntry<CurrentRequest, never>>;
 //#endregion
-export { StandardSchemaV1 as A, ConfigLive as C, ConfigSourceOptions as D, ConfigSourceError as E, ConfigValidationError as O, ConfigIssue as S, ConfigSource as T, RandomSeededLayer as _, CurrentRequest as a, ConfigFromEnvOptions as b, LoggerData as c, LoggerLive as d, LoggerTest as f, RandomSeeded as g, RandomLive as h, ClockTestLayer as i, ConfigValue as k, LoggerEvent as l, Random as m, ClockLive as n, CurrentRequestLayer as o, LoggerTestLayer as p, ClockTest as r, Logger as s, Clock as t, LoggerLevel as u, Config as v, ConfigOutput as w, ConfigInput as x, ConfigError as y };
-//# sourceMappingURL=index-DStz0JMN.d.mts.map
+export { ConfigIssue as A, IdGeneratorTest as C, ConfigError as D, Config as E, ConfigSourceOptions as F, ConfigValidationError as I, ConfigValue as L, ConfigOutput as M, ConfigSource as N, ConfigFromEnvOptions as O, ConfigSourceError as P, StandardSchemaV1 as R, IdGeneratorLive as S, IdGeneratorUnavailableError as T, RandomLive as _, ClockTestLayer as a, IdGenerator as b, CurrentRequestLayer as c, LoggerEvent as d, LoggerLevel as f, Random as g, LoggerTestLayer as h, ClockTest as i, ConfigLive as j, ConfigInput as k, Logger as l, LoggerTest as m, ClockLive as n, ClockTestRunAllOptions as o, LoggerLive as p, ClockSleepOptions as r, CurrentRequest as s, Clock as t, LoggerData as u, RandomSeeded as v, IdGeneratorTestLayer as w, IdGeneratorExhaustedError as x, RandomSeededLayer as y };
+//# sourceMappingURL=index-B1nH4luq.d.mts.map

package/dist/index-B1nH4luq.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-B1nH4luq.d.mts","names":[],"sources":["../src/standard-services/config.ts","../src/standard-services/id-generator.ts","../src/standard-services/index.ts"],"mappings":"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"}

package/dist/index-BMdU_Z72.d.mts

@@ -0,0 +1,18 @@
+import { N as AnyServiceToken } from "./index-heuaRmXR.mjs";
+import { S as LayerRegistration, b as LayerBackendDisposeOptions, y as LayerBackend } from "./outcome-CB43bnFW.mjs";
+//#region src/layer/map-layer-backend.d.ts
+/** Native map-backed Layer backend used by Runtime when no adapter is supplied. */
+declare class MapLayerBackend implements LayerBackend {
+  private readonly providers;
+  private readonly instances;
+  private readonly pending;
+  /** Register a provider, rejecting duplicate or colliding Service tags. */
+  register(registration: LayerRegistration): void;
+  /** Resolve and cache a provider instance by Service tag. */
+  resolve<T extends AnyServiceToken>(token: T): Promise<InstanceType<T>>;
+  /** Clear pending acquisitions, cached instances, and provider registrations. */
+  disposeAll(options?: LayerBackendDisposeOptions): Promise<void>;
+}
+//#endregion
+export { MapLayerBackend as t };
+//# sourceMappingURL=index-BMdU_Z72.d.mts.map

package/dist/index-BMdU_Z72.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BMdU_Z72.d.mts","names":[],"sources":["../src/layer/map-layer-backend.ts"],"mappings":";;;;cAca,2BAA2B;mBACrB;mBAEA;mBAEA;;EAGjB,SAAS,cAAc;;EAiBjB,QAAQ,UAAU,iBAAiB,OAAO,IAAI,QAAQ,aAAa;;EA6CnE,WAAW,UAAU,6BAA6B"}

package/dist/{index-C7Qild0_.d.mts → index-CX6iAoCB.d.mts}

@@ -1,95 +1,5 @@
-import { A as ProgramFromGenerator, C as EffectError, D as EffectYield, E as EffectSuccess, M as AnyService, S as Effect$1, T as EffectRequirements, f as DisposableResource, h as ScopeOutcome, k as Program$1, p as MaybePromise$1, w as EffectFromGenerator, x as AnyEffect } from "./index-heuaRmXR.mjs";
-import { C as CompleteExecutionLayer, E as LayerInput, S as CompleteExecution, a as RuntimeShutdownDiagnostic, b as Layer, i as RuntimeRunOptions, j as ProvidedEnvironment, n as RuntimeDisposeOptions, r as RuntimeOptions, v as LayerBackend, w as CompleteInput } from "./index-rQhZk3Nt.mjs";
+import { A as ProgramFromGenerator, C as EffectError, D as EffectYield, E as EffectSuccess, M as AnyService, S as Effect$1, T as EffectRequirements, f as DisposableResource, h as ScopeOutcome, k as Program$1, p as MaybePromise, w as EffectFromGenerator, x as AnyEffect } from "./index-heuaRmXR.mjs";
 import { Err, Result, UnhandledException } from "better-result";
-//#region src/runtime/types.d.ts
-/**
- * Name a Runtime type from a concrete Layer without repeating its provided
- * branded Service instance union.
- *
- * @example
- * ```ts
- * type AppRuntime = RuntimeFor<typeof AppLive>
- * ```
- */
-type RuntimeFor<L extends LayerInput> = Runtime<Layer.Provided<L>>;
-//#endregion
-//#region src/runtime/runtime.d.ts
-/**
- * Long-lived execution environment backed by a complete Layer.
- *
- * A Runtime owns Layer resources until `dispose()` is called. Each `run()` is
- * isolated in a child Scope, while Layer-scoped resources remain shared.
- *
- * @example
- * ```ts
- * const runtime = await Runtime.make(AppLive)
- * const result = await runtime.run(loadUser('u1'))
- * await runtime.dispose()
- * ```
- *
- * @typeParam Provided The branded Service instances supplied by the Layer.
- */
-declare class Runtime<Provided extends AnyService = any> {
-  private readonly handle;
-  private constructor();
-  /**
-   * Create a long-lived Runtime that owns its Layer resources.
-   *
-   * @example
-   * ```ts
-   * const runtime = await Runtime.make(AppLive)
-   * const result = await runtime.run(program)
-   * await runtime.dispose()
-   * ```
-   */
-  static make<L extends LayerInput>(layer: L & CompleteInput<L>, backend: LayerBackend, options?: RuntimeOptions): Promise<Runtime<ProvidedEnvironment<L>>>;
-  static make<L extends LayerInput>(layer: L & CompleteInput<L>, options?: RuntimeOptions): Promise<Runtime<ProvidedEnvironment<L>>>;
-  /**
-   * Run one program and dispose its Layer resources before resolving.
-   *
-   * This is convenient for request-style or command-style execution where a
-   * Runtime should not outlive the operation.
-   */
-  static run<A, L extends LayerInput>(layer: L & CompleteInput<L>, backend: LayerBackend, program: CompleteExecution<ProvidedEnvironment<L>, A>, options?: RuntimeOptions): Promise<Awaited<A>>;
-  static run<A, L extends LayerInput>(layer: L & CompleteInput<L>, program: CompleteExecution<ProvidedEnvironment<L>, A>, options?: RuntimeOptions): Promise<Awaited<A>>;
-  static run<A, L extends LayerInput>(layer: L & CompleteInput<L>, options: RuntimeOptions, program: CompleteExecution<ProvidedEnvironment<L>, A>): Promise<Awaited<A>>;
-  /** Run a callback with a managed Runtime and always dispose it afterward. */
-  static use<A, L extends LayerInput>(layer: L & CompleteInput<L>, use: (runtime: Runtime<ProvidedEnvironment<L>>) => A | PromiseLike<A>, options?: RuntimeOptions): Promise<Awaited<A>>;
-  /** Resolve every Layer provider and dispose the Runtime if warmup fails. */
-  warmup(): Promise<void>;
-  /** Run one execution in this Runtime's child Scope. */
-  run<A>(program: CompleteExecution<Provided, A>, options?: RuntimeRunOptions): Promise<Awaited<A>>;
-  /** Run one execution with a Layer owned by that execution's child Scope. */
-  runWith<Request extends LayerInput, A>(layer: Request & CompleteExecutionLayer<Provided, Request>, program: CompleteExecution<Provided | ProvidedEnvironment<Request>, A>, options?: RuntimeRunOptions): Promise<Awaited<A>>;
-  private runUnchecked;
-  /** Stop new executions and release the Runtime's Layer resources. */
-  dispose(options?: RuntimeDisposeOptions): Promise<void>;
-  /** @deprecated Scope outcomes are kept for internal compatibility. */
-  dispose(outcome: ScopeOutcome): Promise<void>;
-  /** Release Runtime-owned resources through JavaScript's async disposal protocol. */
-  [Symbol.asyncDispose](): Promise<void>;
-  private disposeWithOutcome;
-}
-/** Type-level aliases for naming Runtime handles and shutdown options. */
-declare namespace Runtime {
-  /** Name a Runtime type from a concrete Layer. */
-  type For<L extends LayerInput> = RuntimeFor<L>;
-  /** Optional Runtime shutdown configuration. */
-  type Options = RuntimeOptions;
-  /** Optional signal supplied to one managed Runtime execution. */
-  type RunOptions = RuntimeRunOptions;
-  /** Cooperative shutdown policy for a managed Runtime. */
-  type DisposeOptions = RuntimeDisposeOptions;
-  /** Diagnostic reported for aggregated Runtime shutdown cleanup failures. */
-  type ShutdownDiagnostic = RuntimeShutdownDiagnostic;
-}
-//#endregion
-//#region src/runtime/signal.d.ts
-/** Yieldable access to the signal of the current Runtime execution. */
-declare const CurrentAbortSignal: {
-  readonly [Symbol.iterator]: () => Generator<never, AbortSignal, unknown>;
-};
-//#endregion
 //#region src/effect/combinators.d.ts
 type EffectInput<A, E> = Result<A, E> | PromiseLike<Result<A, E>>;
 type AnyEffectInput = EffectInput<any, any>;
@@ -341,6 +251,8 @@ type ProgramAllResultsResult<Programs extends readonly AnyProgram[]> = Program$1
 type ProgramForEachResult<Child extends AnyProgram> = Program$1<ReadonlyArray<EffectSuccess<Child>>, EffectError<Child>, EffectRequirements<Child>>;
 type ProgramAllOptions = {
   readonly concurrency?: number;
+  /** Optional diagnostic name for the collection execution. */
+  readonly name?: string;
 };
 /**
  * Compose `better-result` operations while preserving Service requirements in
@@ -366,6 +278,12 @@ declare function gen<Yield extends EffectYield, Returned extends AnyResult>(body
 /** Build a lazy Program without running its generator. */
 declare function fn<Yield extends EffectYield, Returned extends AnyResult>(body: () => Generator<Yield, Returned, unknown>): ProgramFromGenerator<Yield, Returned>;
 declare function fn<Yield extends EffectYield, Returned extends AnyResult>(body: () => AsyncGenerator<Yield, Returned, unknown>): ProgramFromGenerator<Yield, Returned>;
+type ProgramNamedOperation = {
+  <Input extends AnyProgram>(program: Input): Input;
+};
+/** Attach a lazy diagnostic name to a Program without invoking it. */
+declare function programNamed(name: string): ProgramNamedOperation;
+declare function programNamed<Input extends AnyProgram>(name: string, program: Input): Input;
 /** Build a lazy Program collection with optional bounded concurrency. */
 declare function programAll<const Programs extends readonly AnyProgram[]>(programs: Programs, options?: ProgramAllOptions): ProgramAllResult<Programs>;
 /** Build a lazy Program collection from an input array and Program factory. */
@@ -374,6 +292,7 @@ declare function programForEach<const Items extends readonly unknown[], Child ex
 declare function programAllResults<const Programs extends readonly AnyProgram[]>(programs: Programs, options?: ProgramAllOptions): ProgramAllResultsResult<Programs>;
 /** Value-level namespace for lazy Program combinators. */
 declare const Program: {
+  readonly named: typeof programNamed;
   readonly all: typeof programAll;
   readonly forEach: typeof programForEach;
   readonly allResults: typeof programAllResults;
@@ -399,7 +318,7 @@ declare const Program: {
  * )
  * ```
  */
-declare function acquireRelease<R>(acquire: () => MaybePromise$1<R>, release: (resource: R, outcome: ScopeOutcome) => MaybePromise$1<void>): AsyncGenerator<Err<never, UnhandledException>, R, unknown>;
+declare function acquireRelease<R>(acquire: () => MaybePromise<R>, release: (resource: R, outcome: ScopeOutcome) => MaybePromise<void>): AsyncGenerator<Err<never, UnhandledException>, R, unknown>;
 /**
  * Acquire a Result-valued resource and register only successful acquisitions.
  *
@@ -407,14 +326,14 @@ declare function acquireRelease<R>(acquire: () => MaybePromise$1<R>, release: (r
  * unexpected acquisition and registration failures are normalized by
  * `better-result`. Release failures remain Scope cleanup failures.
  */
-declare function acquireReleaseResult<R, E>(acquire: () => MaybePromise$1<Result<R, E>>, release: (resource: R, outcome: ScopeOutcome) => MaybePromise$1<void>): AsyncGenerator<Err<never, E | UnhandledException>, R, unknown>;
+declare function acquireReleaseResult<R, E>(acquire: () => MaybePromise<Result<R, E>>, release: (resource: R, outcome: ScopeOutcome) => MaybePromise<void>): AsyncGenerator<Err<never, E | UnhandledException>, R, unknown>;
 /**
  * Lazily acquire and register a disposable resource in the current Scope.
  *
  * Disposal is delegated to `Scope.add`, including protocol preference,
  * validation, race-safe registration, and cleanup error handling.
  */
-declare function acquireDisposable<R extends DisposableResource>(acquire: () => MaybePromise$1<R>): AsyncGenerator<Err<never, UnhandledException>, R, unknown>;
+declare function acquireDisposable<R extends DisposableResource>(acquire: () => MaybePromise<R>): AsyncGenerator<Err<never, UnhandledException>, R, unknown>;
 /**
  * Register an already-acquired disposable resource in the current Scope.
  *
@@ -477,60 +396,5 @@ declare namespace Effect {
   type Any = AnyEffect;
 }
 //#endregion
-//#region src/function/pipe.d.ts
-type Unary<A, B> = (value: A) => B;
-declare function pipe<A>(value: A): A;
-declare function pipe<A, B>(value: A, ab: Unary<A, B>): B;
-declare function pipe<A, B, C>(value: A, ab: Unary<A, B>, bc: Unary<B, C>): C;
-declare function pipe<A, B, C, D>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>): D;
-declare function pipe<A, B, C, D, E>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>): E;
-declare function pipe<A, B, C, D, E, F>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>, ef: Unary<E, F>): F;
-declare function pipe<A, B, C, D, E, F, G>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>, ef: Unary<E, F>, fg: Unary<F, G>): G;
-declare function pipe<A, B, C, D, E, F, G, H>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>, ef: Unary<E, F>, fg: Unary<F, G>, gh: Unary<G, H>): H;
-declare function pipe<A, B, C, D, E, F, G, H, I>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>, ef: Unary<E, F>, fg: Unary<F, G>, gh: Unary<G, H>, hi: Unary<H, I>): I;
-declare function pipe<A, B, C, D, E, F, G, H, I, J>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>, ef: Unary<E, F>, fg: Unary<F, G>, gh: Unary<G, H>, hi: Unary<H, I>, ij: Unary<I, J>): J;
-declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(value: A, ab: Unary<A, B>, bc: Unary<B, C>, cd: Unary<C, D>, de: Unary<D, E>, ef: Unary<E, F>, fg: Unary<F, G>, gh: Unary<G, H>, hi: Unary<H, I>, ij: Unary<I, J>, jk: Unary<J, K>): K;
-//#endregion
-//#region src/resource/errors.d.ts
-declare const ResourceReleaseFailure_base: import("better-result").TaggedErrorClass<"ResourceReleaseFailure">;
-/** Describes a failure encountered while releasing a Resource. */
-declare class ResourceReleaseFailure extends ResourceReleaseFailure_base<{
-  readonly resource: string;
-  readonly cause: unknown;
-  readonly message: string;
-}> {}
-//#endregion
-//#region src/resource/types.d.ts
-/** A value that may be delivered synchronously or through a thenable. */
-type MaybePromise<T> = T | PromiseLike<T>;
-/** A synchronous or asynchronous better-result Result operation. */
-type AsyncResult<T, E> = MaybePromise<Result<T, E>>;
-/** The allowed return value of a custom Resource release callback. */
-type ReleaseOutcome = void | Result<void, unknown>;
-/** Receives release failures for diagnostics without changing error precedence. */
-type ReleaseFailureObserver = (failure: ResourceReleaseFailure) => MaybePromise<void>;
-/** Options controlling `Resource.acquireUseRelease`. */
-type AcquireUseReleaseOptions<R, A, AcquireError, UseError> = {
-  /** Human-readable name included in release failures. */
-  readonly name: string;
-  /** Acquire the resource. A failure skips use and release. */
-  readonly acquire: () => AsyncResult<R, AcquireError>;
-  /** Use the acquired resource. Release is attempted afterward. */
-  readonly use: (resource: R) => AsyncResult<A, UseError>;
-  /** Release the resource, or omit it to use its disposal protocol. */
-  readonly release?: (resource: R) => MaybePromise<ReleaseOutcome>;
-  /**
-   * Observe cleanup failures without changing error precedence. This is most
-   * useful when both `use` and `release` can fail.
-   */
-  readonly onReleaseFailure?: ReleaseFailureObserver;
-};
-//#endregion
-//#region src/resource/resource.d.ts
-declare const Resource: {
-  /** Acquire, use, and release a resource with deterministic error precedence. */
-  readonly acquireUseRelease: <R, A, AcquireError, UseError>({ name, acquire, use, release, onReleaseFailure }: AcquireUseReleaseOptions<R, A, AcquireError, UseError>) => Promise<Result<A, AcquireError | UseError | UnhandledException | ResourceReleaseFailure>>;
-};
-//#endregion
-export { ReleaseOutcome as a, Effect as c, CurrentAbortSignal as d, Runtime as f, ReleaseFailureObserver as i, Program as l, AcquireUseReleaseOptions as n, ResourceReleaseFailure as o, RuntimeFor as p, AsyncResult as r, pipe as s, Resource as t, ProgramAllOptions as u };
-//# sourceMappingURL=index-C7Qild0_.d.mts.map
+export { Program as n, ProgramAllOptions as r, Effect as t };
+//# sourceMappingURL=index-CX6iAoCB.d.mts.map

package/dist/index-CX6iAoCB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CX6iAoCB.d.mts","names":[],"sources":["../src/effect/combinators.ts","../src/effect/program-combinators.ts","../src/effect/effect.ts"],"mappings":";;;KAYK,YAAY,GAAG,KAAK,OAAW,GAAG,KAAK,YAAY,OAAW,GAAG;KAEjE,iBAAiB;KACjB,iBAAiB;KACjB,sBAAsB,YAAY;KAIlC,cAAc,OAAO,UAAU,cAAc,uBAAuB,QAAQ,UAAU;KAEtF,aAAa,OAAO,KAAK,SAAO,GAAG,YAAY,QAAQ,mBAAmB;KAE1E,kBAAkB,OAAO,MAAM,SAAO,cAAc,QAAQ,IAAI,mBAAmB;KAEnF,cAAc,OAAO,QAAQ,SAChC,cAAc,OACd,YAAY,SAAS,YAAY,OACjC,mBAAmB,SAAS,mBAAmB;KAG5C,cAAc,OAAO,QAAQ,cAAc,OAAO;KAElD,mBAAmB,OAAO,QAAQ,QAAQ,cAAc,OAAO;KAE/D,eAAa,GAAG;GAClB,OAAO,QAAQ,QAAQ,YAAY,UAAU,cAAc,OAAO,aAAa,OAAO;;KAGpF,oBAAkB,IAAI;GACxB,OAAO,QAAQ,QAAQ,iBAAiB,MAAM,cAAc,OAAO,kBAAkB,OAAO;;KAG1F,mBAAiB;GACnB,OAAO,QAAQ,QAAQ,iBAAiB,cAAc,OAAO;;KAG3D,sBAAsB,GAAG;GAC3B,OAAO,QAAQ,QAAQ,YAAY,UAAU,mBAAmB,OAAO;;KAGrE,aAAa,SAAS,SACzB,cAAc,QACd,YAAY,QACZ,mBAAmB;KAGhB,gBAAgB,OAAO,QAAQ,SAClC,cAAc,SAAS,cAAc,OACrC,YAAY,OACZ,mBAAmB,SAAS,mBAAmB;KAG5C,gBAAgB,SAAS,SAC5B,cAAc,cAAc,SAC5B,YAAY,SAAS,YAAY,cAAc,SAC/C,mBAAmB,SAAS,mBAAmB,cAAc;KAG1D,SAAS,OAAO,SAAS,SAAO,OAAO,YAAY,QAAQ,mBAAmB;KAE9E,cAAc,OAAO,UAAU,aAAa,SAC/C,cAAc,YAAY,cAAc,YACxC,YAAY,YAAY,YAAY,YACpC,mBAAmB,SAAS,mBAAmB,YAAY,mBAAmB;KAG3E,UAAU,yBAAyB,oBAAoB,sBAC7C,eAAe,UAAU,cAAc,QAAQ,YAC5D,YAAY,kBACZ,mBAAmB;KAGhB,UAAU,MAAM,SAAS,UAC3B,cAAc,OAAO,cAAc,SACpC,YAAY,QAAQ,YAAY,QAChC,mBAAmB,QAAQ,mBAAmB;KAG3C;GACF,OACC,QAAQ,QAAQ,gBAChB,KAAK,OAAO,cAAc,kBACzB,cAAc,OAAO,aAAa;;KAGlC;GACF,OACC,QAAQ,QAAQ,gBAChB,KAAK,OAAO,YAAY,kBACvB,cAAc,OAAO,aAAa;;KAGlC;GACF,OACC,QAAQ,QAAQ,gBAChB;IACE,KAAK,OAAO,cAAc;IAC1B,MAAM,OAAO,YAAY;MAE1B,cAAc,OAAO,aAAa;;KAGlC;GACF,OAAO,QAAQ,QAAQ,iBAAiB,QAAQ,aAAa;;KAG3D;GACF,OAAO,QAAQ,QAAQ,iBAAiB,QAAQ,aAAa;;KAG3D;GACF,OAAO,QAAQ,QAAQ,iBAAiB,QAAQ,aAAa;;KAG3D,kBAAkB;WAAmB;;KAErC,oBAAoB,mBAAmB,sBAEzC,OAAO,sBAAsB,OAAO,QAAQ;WAAuB,MAAM;;KAGvE,cAAc,SAAS,QAAQ,YAAY,QAAQ;KAEnD,uBAAuB,UAAU,YAAY,iBAAiB,mBAC/D,oBAAoB,cAAc;KAGjC,cAAc,eAChB,aAAa,aAAa,YAAY,SAAS,gBAAe,uBAAuB,UAClF,wBAEE;KAEH,oBAAoB,eACtB,aAAa,wBAAwB,KAAK,UAAU,iCAE/B,SAAS,eAEzB,aACA;KAEH,sBAAsB,mBAAmB,iBAAiB,YAAY,QACzE;WACW,MAAM,QAAQ,oBAAoB,WAAW;;KAGrD,iBAAiB,OAAO,YAAY,SACvC,cAAc,QACd,cAAc,WACd,mBAAmB;KAGhB,wBAAwB,OAAO,YAAY,SAC9C,cAAc,QACd,cAAc,YAAY,sBAAsB,cAAc,QAAQ,WACtE,mBAAmB;KAGhB,mBAAiB;GACnB,OACC,QAAQ,QAAQ,gBAChB,KAAK,OAAO,YAAY,WAAW,OAClC,cAAc,OAAO,gBAAgB,OAAO;;KAG5C,sBAAsB;GACxB,OACC,QAAQ,QAAQ,gBAChB,KAAK,OAAO,YAAY,WAAW,OAClC,QAAQ,gBAAgB,OAAO;;;;;;;;;;;;;;iBA6EpB,MAAI,GAAG,GAAG,KAAK,OAAO,MAAM,IAAI,eAAa,GAAG;iBAChD,MAAI,OAAO,GACzB,QAAQ,QAAQ,gBAChB,KAAK,OAAO,cAAc,WAAW,IACpC,cAAc,OAAO,aAAa,OAAO;;;;;;;;;;iBAmC5B,WAAS,IAAI,IAAI,KAAK,OAAO,OAAO,KAAK,oBAAkB,IAAI;iBAC/D,WAAS,OAAO,IAC9B,QAAQ,QAAQ,gBAChB,KAAK,OAAO,YAAY,WAAW,KAClC,cAAc,OAAO,kBAAkB,OAAO;;;;;;;;;;;;iBAqCjC,UAAQ,GAAG,aAAa,gBACtC,OAAO,OAAO,MAAM,OACnB,mBAAiB;iBACJ,UAAQ,OAAO,aAAa,gBAC1C,QAAQ,QAAQ,gBAChB,OAAO,OAAO,cAAc,WAAW,OACtC,cAAc,OAAO;;;;;;;;;;;;iBA8BR,aAAa,GAAG,aAAa,qBAC3C,OAAO,OAAO,MAAM,OACnB,sBAAsB,GAAG;iBACZ,aAAa,OAAO,aAAa,qBAC/C,QAAQ,QAAQ,gBAChB,OAAO,OAAO,cAAc,WAAW,OACtC,mBAAmB,OAAO;;iBA4Kb,MAAI,KAAK,sBAAsB;iBAC/B,MAAI,OAClB,QAAQ,QAAQ,gBAChB,KAAK,OAAO,cAAc,kBACzB,cAAc,OAAO,aAAa;;iBAoBrB,WAAS,KAAK,sBAAsB;iBACpC,WAAS,OACvB,QAAQ,QAAQ,gBAChB,KAAK,OAAO,YAAY,kBACvB,cAAc,OAAO,aAAa;;iBAoBrB,QAAQ;EACtB,KAAK;EACL,MAAM;IACJ;iBACY,QAAQ,OACtB,QAAQ,QAAQ,gBAChB;EACE,KAAK,OAAO,cAAc;EAC1B,MAAM,OAAO,YAAY;IAE1B,cAAc,OAAO,aAAa;;iBAcrB,SAAS,KAAK,eAAe,oBAAoB;iBACjD,SAAS,OACvB,QAAQ,QAAQ,gBAChB,KAAK,OAAO,cAAc,WAAW,oBACpC,QAAQ,aAAa;;iBAmBR,cAAc,KAAK,eAAe,oBAAoB;iBACtD,cAAc,OAC5B,QAAQ,QAAQ,gBAChB,KAAK,OAAO,YAAY,WAAW,oBAClC,QAAQ,aAAa;;iBAmBR,aAAa;EAC3B,KAAK,eAAe;EACpB,MAAM,eAAe;IACnB;iBACY,aAAa,OAC3B,QAAQ,QAAQ,gBAChB;EACE,KAAK,OAAO,cAAc,WAAW;EACrC,MAAM,OAAO,YAAY,WAAW;IAErC,QAAQ,aAAa;;iBAcR,aAAW,OAAO,iBAAiB,uBAAuB,QACxE,QAAQ,QAAQ,gBAChB,UAAU,WACT,cAAc,OAAO,iBAAiB,OAAO;;iBAoBhC,oBAAkB,OAAO,iBAAiB,QAAQ,uBAAuB,SACvF,QAAQ,QAAQ,gBAChB,UAAU,WACT,cAAc,OAAO,wBAAwB,OAAO;;iBAoBvC,UAAQ,aAAa,gBACnC,KAAK,eAAe,OACnB,mBAAiB;iBACJ,UAAQ,OAAO,aAAa,gBAC1C,QAAQ,QAAQ,gBAChB,KAAK,OAAO,YAAY,WAAW,OAClC,cAAc,OAAO,gBAAgB,OAAO;;iBAoB/B,aAAa,aAAa,qBACxC,KAAK,eAAe,OACnB,sBAAsB;iBACT,aAAa,OAAO,aAAa,qBAC/C,QAAQ,QAAQ,gBAChB,KAAK,OAAO,YAAY,WAAW,OAClC,QAAQ,gBAAgB,OAAO;;iBAoBlB,QAAQ,OAAO,QAAQ,QAAQ,iBAAiB,gBAAgB;;iBAMhE,GAAG,OACjB,OAAO,SACL,OAAO,QAAQ,QAAQ,mBAAmB,SAAS,OAAO;iBAC9C,GAAG,OAAO,OACxB,QAAQ,QAAQ,gBAChB,OAAO,QACN,SAAS,OAAO;;iBAUH,OAAO,OAAO,QAAQ,QAAQ,iBAAiB,SAAS;;iBAKxD,MAAM,OAAO,iBAAiB,gBAAgB,kBAAkB,gBAC9E,QAAQ,QAAQ,gBAChB;EACE,KAAK,OAAO,cAAc,WAAW;EACrC,MAAM,OAAO,YAAY,WAAW;IAErC,cAAc,OAAO,cAAc,OAAO,UAAU;iBACvC,MAAM,OAAO,SAAS,UACpC,QAAQ,QAAQ,gBAChB;EACE,KAAK,OAAO,cAAc,WAAW;EACrC,MAAM,OAAO,YAAY,WAAW;IAErC,cAAc,OAAO,UAAU;;iBAUlB,UAAU,yBAAyB,kBACjD,SAAS,UACR,UAAU;;iBAKG,IAAI,MAAM,OACxB,MAAM,OAAO,gBACb,OAAO,QAAQ,iBACd,UAAU,MAAM;;;KC10Bd,cAAY;KACZ,gBAAgB,cAAY,YAAY;KACxC,uBAAuB;KAMvB,aAAa,cAAc,kBAAkB,QAChD,UAAQ,cAAc,QAAQ,YAAY,QAAQ,mBAAmB;KAElE,kBAAkB,OAAO,KAAK,cAAc,eAAe;KAC3D,gBAAgB,OAAO,KAAK,YAAY,eAAe;KAEvD,cAAc,UACjB,eAAe,gBAAc,gBAAgB,cAAc,sBAAsB,cAC7E,SACA,eAAe,kBAAkB,eAC/B,oBAAoB,aAAiB,gBAAgB,UACnD,iBAEF,eAAe,aAAiB,gBAAgB,UAC9C;KAGL,cAAc,OAAO,KAAK,UAAQ,GAAG,YAAY,QAAQ,mBAAmB;KAE5E,mBAAmB,OAAO,MAAM,UAAQ,cAAc,QAAQ,IAAI,mBAAmB;KAErF,eAAe,OAAO,QAAQ,UACjC,cAAc,OACd,YAAY,SAAS,YAAY,OACjC,mBAAmB,SAAS,mBAAmB;KAG5C,cAAc,SAAS,UAC1B,cAAc,QACd,YAAY,QACZ,mBAAmB;KAGhB,iBAAiB,OAAO,QAAQ,UACnC,cAAc,SAAS,cAAc,OACrC,YAAY,OACZ,mBAAmB,SAAS,mBAAmB;KAG5C,aAAa,GAAG;GAClB,cAAc,gBACb,SAAS,aAAa,SAAS,kBAAkB,OAAO,KACvD,cAAc,OAAO;;KAGrB,kBAAkB,IAAI;GACxB,cAAc,gBACb,SAAS,aAAa,SAAS,gBAAgB,OAAO,MACrD,mBAAmB,OAAO;;KAG1B,iBAAiB,GAAG;GACtB,cAAc,gBACb,SAAS,aAAa,SAAS,kBAAkB,OAAO,KACvD,eAAe,OAAO;;KAGtB,aAAa;GACf,cAAc,gBACb,SAAS,aAAa,SAAS,kBAAkB,OAAO,KACvD,cAAc;;KAGd,kBAAkB;GACpB,cAAc,gBACb,SAAS,aAAa,SAAS,gBAAgB,OAAO,KACrD,cAAc;;KAGd,iBAAiB,GAAG;GACtB,cAAc,gBACb,SAAS,aAAa,SAAS,gBAAgB,OAAO,KACrD,iBAAiB,OAAO;;;iBAyGb,IAAI,GAAG,GAAG,KAAK,OAAO,MAAM,IAAI,aAAa,GAAG;iBAChD,IAAI,cAAc,gBAAgB,GAChD,SAAS,aAAa,QACtB,KAAK,OAAO,cAAc,WAAW,IACpC,cAAc,OAAO;;iBAcR,SAAS,IAAI,IAAI,KAAK,OAAO,OAAO,KAAK,kBAAkB,IAAI;iBAC/D,SAAS,cAAc,gBAAgB,IACrD,SAAS,aAAa,QACtB,KAAK,OAAO,YAAY,WAAW,KAClC,mBAAmB,OAAO;;iBAcb,QAAQ,GAAG,MACzB,OAAO,OAAO,MAAM,OAAO,cAAc,QACxC,iBAAiB,GAAG;iBACP,QAAQ,cAAc,gBAAgB,MACpD,SAAS,aAAa,QACtB,OAAO,OAAO,cAAc,WAAW,OAAO,cAAc,QAC3D,eAAe,OAAO;;iBAsBT,IAAI,GAAG,KAAK,OAAO,aAAa,aAAa;iBAC7C,IAAI,cAAc,gBAChC,SAAS,aAAa,QACtB,KAAK,OAAO,cAAc,kBACzB,cAAc;;iBAcD,SAAS,GAAG,KAAK,OAAO,aAAa,kBAAkB;iBACvD,SAAS,cAAc,gBACrC,SAAS,aAAa,QACtB,KAAK,OAAO,YAAY,kBACvB,cAAc;;iBAcD,QAAQ,GAAG,MACzB,KAAK,OAAO,MAAM,OAAO,cAAc,QACtC,iBAAiB,GAAG;iBACP,QAAQ,cAAc,gBAAgB,MACpD,SAAS,aAAa,QACtB,UAAU,OAAO,YAAY,WAAW,OAAO,cAAc,QAC5D,iBAAiB,OAAO;;;KCjPf,OAAO,GAAG,GAAG,UAAU,sBAAsB,SAAW,GAAG,GAAG;KAErE,YAAY,GAAG,GAAG,UAAU,sBAAsB,UAAY,GAAG,GAAG;;KAG7D,QAAQ,GAAG,GAAG,UAAU,sBAAsB,YAAY,GAAG,GAAG;KAEvE,YAAY;KAEZ,aAAa,oBAAsB;KAEnC,kBAAkB,0BAA0B,6BACpC,eAAe,WAAW,cAAc,SAAS;KAGzD,gBAAgB,0BAA0B,gBAAgB,YAAY;KAEtE,uBAAuB,0BAA0B,gBAAgB,mBACpE;KAGG,iBAAiB,0BAA0B,gBAAgB,UAC9D,kBAAkB,WAClB,gBAAgB,WAChB,uBAAuB;KAGpB,iBAAiB,SAAS,cAAc,aACzC,OAAW,cAAc,QAAQ,YAAY;KAG5C,yBAAyB,0BAA0B,+BACvC,qBACX,cAAc,OAAW,cAAc,mBAAmB,YAAY,kCAC1D,eAAe,WAAW,iBAAiB,SAAS;KAEjE,wBAAwB,0BAA0B,gBAAgB,UACrE,yBAAyB,kBAEzB,uBAAuB;KAGpB,qBAAqB,cAAc,cAAc,UACpD,cAAc,cAAc,SAC5B,YAAY,QACZ,mBAAmB;KAGT;WACD;;WAEA;;;;;;;;;;;;;;;;;;;;;iBA+BK,IAAI,cAAc,aAAa,iBAAiB,WAC9D,YAAY,UAAU,OAAO,qBAC5B,oBAAoB,OAAO;iBAEd,IAAI,cAAc,aAAa,iBAAiB,WAC9D,YAAY,eAAe,OAAO,qBACjC,QAAQ,oBAAoB,OAAO;;iBAOtB,GAAG,cAAc,aAAa,iBAAiB,WAC7D,YAAY,UAAU,OAAO,qBAC5B,qBAAqB,OAAO;iBAEf,GAAG,cAAc,aAAa,iBAAiB,WAC7D,YAAY,eAAe,OAAO,qBACjC,qBAAqB,OAAO;KAS1B;GACF,cAAc,YAAY,SAAS,QAAQ;;;iBAWrC,aAAa,eAAe;iBAC5B,aAAa,cAAc,YAAY,cAAc,SAAS,QAAQ;;iBAsD/D,iBAAiB,0BAA0B,cACzD,UAAU,UACV,UAAS,oBACR,iBAAiB;;iBAiBJ,qBAAqB,kCAAkC,cAAc,YACnF,OAAO,OACP,cAAc,MAAM,eAAe,kBAAkB,OACrD,UAAS,oBACR,qBAAqB;;iBAqBR,wBAAwB,0BAA0B,cAChE,UAAU,UACV,UAAS,oBACR,wBAAwB;;cAiBd;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BG,eAAe,GAC7B,eAAe,aAAa,IAC5B,UAAU,UAAU,GAAG,SAAS,iBAAiB,qBAChD,eAAe,WAAW,qBAAqB;;;;;;;;iBAiBlC,qBAAqB,GAAG,GACtC,eAAe,aAAa,OAAW,GAAG,KAC1C,UAAU,UAAU,GAAG,SAAS,iBAAiB,qBAChD,eAAe,WAAW,IAAI,qBAAqB;;;;;;;iBAiCtC,kBAAkB,UAAU,oBAC1C,eAAe,aAAa,KAC3B,eAAe,WAAW,qBAAqB;;;;;;;;;;;;;iBAkBlC,IAAI,UAAU,oBAC5B,UAAU,IACT,eAAe,WAAW,qBAAqB;;;;;;;KAY7C;WACM,YAAY;WACZ,WAAW;WACX,uBAAuB;WACvB,6BAA6B;WAC7B,0BAA0B;WAC1B,YAAY;WACZ,YAAY;WACZ,iBAAiB;WACjB,gBAAgB;WAChB,qBAAqB;WACrB,YAAY;WACZ,iBAAiB;WACjB,iBAAiB;WACjB,sBAAsB;WACtB,gBAAgB;WAChB,qBAAqB;WACrB,mBAAmB;WACnB,0BAA0B;WAC1B,gBAAgB;WAChB,qBAAqB;WACrB,gBAAgB;WAChB,WAAW;WACX,eAAe;WACf,cAAc;WACd,YAAY;WACZ,YAAY;;cAGV,QAAQ;;kBAwDI;;OAEX,QAAQ,GAAG,GAAG,UAAU,sBAAsB,YAAY,GAAG,GAAG;;OAGhE,QAAQ,KAAK,cAAc;;OAG3B,MAAM,KAAK,YAAY;;OAGvB,aAAa,KAAK,mBAAmB;;OAGrC,MAAM"}