effect 4.0.0-beta.19 → 4.0.0-beta.20

package/src/ServiceMap.ts

@@ -24,6 +24,24 @@ import type * as Types from "./Types.ts"
 
 const ServiceTypeId = "~effect/ServiceMap/Service" as const
 
+/**
+ * The base type used for all ServiceMap keys.
+ *
+ * @since 4.0.0
+ * @category Models
+ */
+export interface Key<in out Identifier, in out Shape> extends Pipeable, Inspectable {
+  readonly [ServiceTypeId]: {
+    readonly _Service: Types.Invariant<Shape>
+    readonly _Identifier: Types.Invariant<Identifier>
+  }
+  readonly Service: Shape
+  readonly Identifier: Identifier
+  readonly key: string
+  readonly stack?: string | undefined
+  asEffect(): Effect<Shape, never, Identifier>
+}
+
 /**
  * @example
  * ```ts
@@ -42,21 +60,12 @@ const ServiceTypeId = "~effect/ServiceMap/Service" as const
  * @category Models
  */
 export interface Service<in out Identifier, in out Shape>
-  extends Pipeable, Inspectable, Yieldable<Service<Identifier, Shape>, Shape, never, Identifier>
+  extends Key<Identifier, Shape>, Yieldable<Service<Identifier, Shape>, Shape, never, Identifier>
 {
-  readonly [ServiceTypeId]: {
-    readonly _Service: Types.Invariant<Shape>
-    readonly _Identifier: Types.Invariant<Identifier>
-  }
-  readonly Service: Shape
-  readonly Identifier: Identifier
   of(self: Shape): Shape
   serviceMap(self: Shape): ServiceMap<Identifier>
   use<A, E, R>(f: (service: Shape) => Effect<A, E, R>): Effect<A, E, R | Identifier>
   useSync<A>(f: (service: Shape) => A): Effect<A, never, Identifier>
-
-  readonly stack?: string | undefined
-  readonly key: string
 }
 
 /**
@@ -368,7 +377,7 @@ export declare namespace Service {
    * @since 4.0.0
    * @category Models
    */
-  export type Any = Service<never, any> | Service<any, any>
+  export type Any = Key<never, any> | Key<any, any>
 
   /**
    * @example
@@ -508,20 +517,20 @@ const Proto: Omit<ServiceMap<never>, "mapUnsafe"> = {
 export const isServiceMap = (u: unknown): u is ServiceMap<never> => hasProperty(u, TypeId)
 
 /**
- * Checks if the provided argument is a `Service`.
+ * Checks if the provided argument is a `Key`.
  *
  * @example
  * ```ts
  * import { ServiceMap } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.strictEqual(ServiceMap.isService(ServiceMap.Service("Service")), true)
+ * assert.strictEqual(ServiceMap.isKey(ServiceMap.Service("Service")), true)
  * ```
  *
  * @since 4.0.0
  * @category Guards
  */
-export const isService = (u: unknown): u is Service<any, any> => hasProperty(u, ServiceTypeId)
+export const isKey = (u: unknown): u is Key<any, any> => hasProperty(u, ServiceTypeId)
 
 /**
  * Checks if the provided argument is a `Reference`.
@@ -580,7 +589,7 @@ const emptyServiceMap = makeUnsafe(new Map())
  * @category Constructors
  */
 export const make = <I, S>(
-  key: Service<I, S>,
+  key: Key<I, S>,
   service: Types.NoInfer<S>
 ): ServiceMap<I> => makeUnsafe(new Map([[key.key, service]]))
 
@@ -635,7 +644,7 @@ export const add: {
    * @since 4.0.0
    * @category Adders
    */
-  <I, S>(key: Service<I, S>, service: Types.NoInfer<S>): <Services>(self: ServiceMap<Services>) => ServiceMap<Services | I>
+  <I, S>(key: Key<I, S>, service: Types.NoInfer<S>): <Services>(self: ServiceMap<Services>) => ServiceMap<Services | I>
   /**
    * Adds a service to a given `ServiceMap`.
    *
@@ -661,10 +670,10 @@ export const add: {
    * @since 4.0.0
    * @category Adders
    */
-  <Services, I, S>(self: ServiceMap<Services>, key: Service<I, S>, service: Types.NoInfer<S>): ServiceMap<Services | I>
+  <Services, I, S>(self: ServiceMap<Services>, key: Key<I, S>, service: Types.NoInfer<S>): ServiceMap<Services | I>
 } = dual(3, <Services, I, S>(
   self: ServiceMap<Services>,
-  key: Service<I, S>,
+  key: Key<I, S>,
   service: Types.NoInfer<S>
 ): ServiceMap<Services | I> => {
   const map = new Map(self.mapUnsafe)
@@ -681,19 +690,19 @@ export const addOrOmit: {
    * @since 4.0.0
    * @category Adders
    */
-  <I, S>(key: Service<I, S>, service: Option.Option<Types.NoInfer<S>>): <Services>(self: ServiceMap<Services>) => ServiceMap<Services | I>
+  <I, S>(key: Key<I, S>, service: Option.Option<Types.NoInfer<S>>): <Services>(self: ServiceMap<Services>) => ServiceMap<Services | I>
   /**
    * @since 4.0.0
    * @category Adders
    */
   <Services, I, S>(
     self: ServiceMap<Services>,
-    key: Service<I, S>,
+    key: Key<I, S>,
     service: Option.Option<Types.NoInfer<S>>
   ): ServiceMap<Services | I>
 } = dual(3, <Services, I, S>(
   self: ServiceMap<Services>,
-  key: Service<I, S>,
+  key: Key<I, S>,
   service: Option.Option<Types.NoInfer<S>>
 ): ServiceMap<Services | I> => {
   const map = new Map(self.mapUnsafe)
@@ -770,7 +779,7 @@ export const getOrElse: {
    * @since 4.0.0
    * @category Getters
    */
-  <S, I, B>(key: Service<I, S>, orElse: LazyArg<B>): <Services>(self: ServiceMap<Services>) => S | B
+  <S, I, B>(key: Key<I, S>, orElse: LazyArg<B>): <Services>(self: ServiceMap<Services>) => S | B
   /**
    * Get a service from the context that corresponds to the given key, or
    * use the fallback value.
@@ -803,8 +812,8 @@ export const getOrElse: {
    * @since 4.0.0
    * @category Getters
    */
-  <Services, S, I, B>(self: ServiceMap<Services>, key: Service<I, S>, orElse: LazyArg<B>): S | B
-} = dual(3, <Services, S, I, B>(self: ServiceMap<Services>, key: Service<I, S>, orElse: LazyArg<B>): S | B => {
+  <Services, S, I, B>(self: ServiceMap<Services>, key: Key<I, S>, orElse: LazyArg<B>): S | B
+} = dual(3, <Services, S, I, B>(self: ServiceMap<Services>, key: Key<I, S>, orElse: LazyArg<B>): S | B => {
   if (self.mapUnsafe.has(key.key)) {
     return self.mapUnsafe.get(key.key)! as any
   }
@@ -820,15 +829,15 @@ export const getOrUndefined: {
    * @since 4.0.0
    * @category Getters
    */
-  <S, I>(key: Service<I, S>): <Services>(self: ServiceMap<Services>) => S | undefined
+  <S, I>(key: Key<I, S>): <Services>(self: ServiceMap<Services>) => S | undefined
   /**
    * @since 4.0.0
    * @category Getters
    */
-  <Services, S, I>(self: ServiceMap<Services>, key: Service<I, S>): S | undefined
+  <Services, S, I>(self: ServiceMap<Services>, key: Key<I, S>): S | undefined
 } = dual(
   2,
-  <Services, S, I>(self: ServiceMap<Services>, key: Service<I, S>): S | undefined => self.mapUnsafe.get(key.key)
+  <Services, S, I>(self: ServiceMap<Services>, key: Key<I, S>): S | undefined => self.mapUnsafe.get(key.key)
 )
 
 /**
@@ -888,7 +897,7 @@ export const getUnsafe: {
    * @since 4.0.0
    * @category unsafe
    */
-  <S, I>(service: Service<I, S>): <Services>(self: ServiceMap<Services>) => S
+  <S, I>(service: Key<I, S>): <Services>(self: ServiceMap<Services>) => S
   /**
    * Get a service from the context that corresponds to the given key.
    *
@@ -917,10 +926,10 @@ export const getUnsafe: {
    * @since 4.0.0
    * @category unsafe
    */
-  <Services, S, I>(self: ServiceMap<Services>, services: Service<I, S>): S
+  <Services, S, I>(self: ServiceMap<Services>, services: Key<I, S>): S
 } = dual(
   2,
-  <Services, I extends Services, S>(self: ServiceMap<Services>, service: Service<I, S>): S => {
+  <Services, I extends Services, S>(self: ServiceMap<Services>, service: Key<I, S>): S => {
     if (!self.mapUnsafe.has(service.key)) {
       if (ReferenceTypeId in service) return getDefaultValue(service as any)
       throw serviceNotFoundError(service)
@@ -980,7 +989,7 @@ export const get: {
    * @since 4.0.0
    * @category Getters
    */
-  <Services, I extends Services, S>(service: Service<I, S>): (self: ServiceMap<Services>) => S
+  <Services, I extends Services, S>(service: Key<I, S>): (self: ServiceMap<Services>) => S
   /**
    * Get a service from the context that corresponds to the given key.
    *
@@ -1006,7 +1015,7 @@ export const get: {
    * @since 4.0.0
    * @category Getters
    */
-  <Services, I extends Services, S>(self: ServiceMap<Services>, service: Service<I, S>): S
+  <Services, I extends Services, S>(self: ServiceMap<Services>, service: Key<I, S>): S
 } = getUnsafe
 
 /**
@@ -1044,7 +1053,7 @@ const getDefaultValue = (ref: Reference<any>) => {
   return (ref as any)[defaultValueCacheKey] = ref.defaultValue()
 }
 
-const serviceNotFoundError = (service: Service<any, any>) => {
+const serviceNotFoundError = (service: Key<any, any>) => {
   const error = new Error(
     `Service not found${service.key ? `: ${String(service.key)}` : ""}`
   )
@@ -1122,7 +1131,7 @@ export const getOption: {
    * @since 4.0.0
    * @category Getters
    */
-  <S, I>(service: Service<I, S>): <Services>(self: ServiceMap<Services>) => Option.Option<S>
+  <S, I>(service: Key<I, S>): <Services>(self: ServiceMap<Services>) => Option.Option<S>
   /**
    * Get the value associated with the specified key from the context wrapped in
    * an `Option` object. If the key is not found, the `Option` object will be
@@ -1151,8 +1160,8 @@ export const getOption: {
    * @since 4.0.0
    * @category Getters
    */
-  <Services, S, I>(self: ServiceMap<Services>, service: Service<I, S>): Option.Option<S>
-} = dual(2, <Services, I extends Services, S>(self: ServiceMap<Services>, service: Service<I, S>): Option.Option<S> => {
+  <Services, S, I>(self: ServiceMap<Services>, service: Key<I, S>): Option.Option<S>
+} = dual(2, <Services, I extends Services, S>(self: ServiceMap<Services>, service: Key<I, S>): Option.Option<S> => {
   if (self.mapUnsafe.has(service.key)) {
     return Option.some(self.mapUnsafe.get(service.key)! as any)
   }
@@ -1320,7 +1329,7 @@ export const mergeAll = <T extends Array<unknown>>(
  * @since 4.0.0
  * @category Utils
  */
-export const pick = <S extends ReadonlyArray<Service<any, any>>>(
+export const pick = <S extends ReadonlyArray<Key<any, any>>>(
   ...services: S
 ) =>
 <Services>(self: ServiceMap<Services>): ServiceMap<Services & Service.Identifier<S[number]>> => {
@@ -1360,7 +1369,7 @@ export const pick = <S extends ReadonlyArray<Service<any, any>>>(
  * @since 4.0.0
  * @category Utils
  */
-export const omit = <S extends ReadonlyArray<Service<any, any>>>(
+export const omit = <S extends ReadonlyArray<Key<any, any>>>(
   ...keys: S
 ) =>
 <Services>(self: ServiceMap<Services>): ServiceMap<Exclude<Services, Service.Identifier<S[number]>>> => {

package/src/Sink.ts

@@ -1834,19 +1834,19 @@ export const provideService: {
    * @since 4.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Service<I, S>, value: Types.NoInfer<S>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, Exclude<R, I>>
+  <I, S>(key: ServiceMap.Key<I, S>, value: Types.NoInfer<S>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, Exclude<R, I>>
   /**
    * @since 4.0.0
    * @category Services
    */
   <A, In, L, E, R, I, S>(
     self: Sink<A, In, L, E, R>,
-    key: ServiceMap.Service<I, S>,
+    key: ServiceMap.Key<I, S>,
     value: Types.NoInfer<S>
   ): Sink<A, In, L, E, Exclude<R, I>>
 } = dual(3, <A, In, L, E, R, I, S>(
   self: Sink<A, In, L, E, R>,
-  key: ServiceMap.Service<I, S>,
+  key: ServiceMap.Key<I, S>,
   value: Types.NoInfer<S>
 ): Sink<A, In, L, E, Exclude<R, I>> =>
   fromTransform((upstream, scope) =>

package/src/Stream.ts

@@ -16086,7 +16086,7 @@ export const provideService: {
    * @since 4.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Service<I, S>, service: NoInfer<S>): <A, E, R>(
+  <I, S>(key: ServiceMap.Key<I, S>, service: NoInfer<S>): <A, E, R>(
     self: Stream<A, E, R>
   ) => Stream<A, E, Exclude<R, I>>
   /**
@@ -16125,10 +16125,10 @@ export const provideService: {
    * @since 4.0.0
    * @category Services
    */
-  <A, E, R, I, S>(self: Stream<A, E, R>, key: ServiceMap.Service<I, S>, service: NoInfer<S>): Stream<A, E, Exclude<R, I>>
+  <A, E, R, I, S>(self: Stream<A, E, R>, key: ServiceMap.Key<I, S>, service: NoInfer<S>): Stream<A, E, Exclude<R, I>>
 } = dual(3, <A, E, R, I, S>(
   self: Stream<A, E, R>,
-  key: ServiceMap.Service<I, S>,
+  key: ServiceMap.Key<I, S>,
   service: NoInfer<S>
 ): Stream<A, E, Exclude<R, I>> => fromChannel(Channel.provideService(self.channel, key, service)))
 
@@ -16209,7 +16209,7 @@ export const provideServiceEffect: {
    * @since 4.0.0
    * @category Services
    */
-  <I, S, ES, RS>(key: ServiceMap.Service<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <A, E, R>(
+  <I, S, ES, RS>(key: ServiceMap.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <A, E, R>(
     self: Stream<A, E, R>
   ) => Stream<A, E | ES, Exclude<R, I> | RS>
   /**
@@ -16252,12 +16252,12 @@ export const provideServiceEffect: {
    */
   <A, E, R, I, S, ES, RS>(
     self: Stream<A, E, R>,
-    key: ServiceMap.Service<I, S>,
+    key: ServiceMap.Key<I, S>,
     service: Effect.Effect<NoInfer<S>, ES, RS>
   ): Stream<A, E | ES, Exclude<R, I> | RS>
 } = dual(3, <A, E, R, I, S, ES, RS>(
   self: Stream<A, E, R>,
-  key: ServiceMap.Service<I, S>,
+  key: ServiceMap.Key<I, S>,
   service: Effect.Effect<NoInfer<S>, ES, RS>
 ): Stream<A, E | ES, Exclude<R, I> | RS> => fromChannel(Channel.provideServiceEffect(self.channel, key, service)))
 
@@ -16442,7 +16442,7 @@ export const updateService: {
    * @since 2.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Service<I, S>, f: (service: NoInfer<S>) => S): <A, E, R>(
+  <I, S>(key: ServiceMap.Key<I, S>, f: (service: NoInfer<S>) => S): <A, E, R>(
     self: Stream<A, E, R>
   ) => Stream<A, E, R | I>
   /**
@@ -16472,12 +16472,12 @@ export const updateService: {
    */
   <A, E, R, I, S>(
     self: Stream<A, E, R>,
-    key: ServiceMap.Service<I, S>,
+    key: ServiceMap.Key<I, S>,
     f: (service: NoInfer<S>) => S
   ): Stream<A, E, R | I>
 } = dual(3, <A, E, R, I, S>(
   self: Stream<A, E, R>,
-  service: ServiceMap.Service<I, S>,
+  service: ServiceMap.Key<I, S>,
   f: (service: NoInfer<S>) => S
 ): Stream<A, E, R | I> =>
   updateServices(self, (services) =>

package/src/index.ts

@@ -2614,7 +2614,7 @@ export * as Optic from "./Optic.ts"
  * **Gotchas**
  *
  * - `Option.some(null)` is a valid `Some`; use {@link fromNullishOr} to treat `null`/`undefined` as `None`
- * - {@link filterMap} is an alias for {@link flatMap}
+ * - {@link filterMap} uses a `Filter` callback that returns `Result`
  * - {@link getOrThrow} throws a generic `Error`; prefer {@link getOrThrowWith} for custom errors
  * - `None` is a singleton; compare with {@link isNone}, not `===`
  * - When yielded in `Effect.gen`, a `None` becomes a `NoSuchElementError` defect

package/src/internal/effect.ts

@@ -1983,17 +1983,17 @@ export const exitFindErrorOption = <A, E>(self: Exit.Exit<A, E>): Option.Option<
 
 /** @internal */
 export const service: {
-  <I, S>(service: ServiceMap.Service<I, S>): Effect.Effect<S, never, I>
+  <I, S>(service: ServiceMap.Key<I, S>): Effect.Effect<S, never, I>
 } = fromYieldable as any
 
 /** @internal */
 export const serviceOption = <I, S>(
-  service: ServiceMap.Service<I, S>
+  service: ServiceMap.Key<I, S>
 ): Effect.Effect<Option.Option<S>> => withFiber((fiber) => succeed(ServiceMap.getOption(fiber.services, service)))
 
 /** @internal */
 export const serviceOptional = <I, S>(
-  service: ServiceMap.Service<I, S>
+  service: ServiceMap.Key<I, S>
 ): Effect.Effect<S, Cause.NoSuchElementError> =>
   withFiber((fiber) =>
     fiber.services.mapUnsafe.has(service.key)
@@ -2031,19 +2031,19 @@ export const updateServices: {
 /** @internal */
 export const updateService: {
   <I, A>(
-    service: ServiceMap.Service<I, A>,
+    service: ServiceMap.Key<I, A>,
     f: (value: A) => A
   ): <XA, E, R>(self: Effect.Effect<XA, E, R>) => Effect.Effect<XA, E, R | I>
   <XA, E, R, I, A>(
     self: Effect.Effect<XA, E, R>,
-    service: ServiceMap.Service<I, A>,
+    service: ServiceMap.Key<I, A>,
     f: (value: A) => A
   ): Effect.Effect<XA, E, R | I>
 } = dual(
   3,
   <XA, E, R, I, A>(
     self: Effect.Effect<XA, E, R>,
-    service: ServiceMap.Service<I, A>,
+    service: ServiceMap.Key<I, A>,
     f: (value: A) => A
   ): Effect.Effect<XA, E, R | I> =>
     updateServices(self, (s) => {
@@ -2088,20 +2088,20 @@ export const provideServices: {
 /** @internal */
 export const provideService: {
   <I, S>(
-    service: ServiceMap.Service<I, S>
+    service: ServiceMap.Key<I, S>
   ): {
     (implementation: S): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, I>>
     <A, E, R>(self: Effect.Effect<A, E, R>, implementation: S): Effect.Effect<A, E, Exclude<R, I>>
   }
   <I, S>(
-    key: ServiceMap.Service<I, S>,
+    key: ServiceMap.Key<I, S>,
     implementation: S
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<A, E, Exclude<R, I>>
   <A, E, R, I, S>(
     self: Effect.Effect<A, E, R>,
-    service: ServiceMap.Service<I, S>,
+    service: ServiceMap.Key<I, S>,
     implementation: S
   ): Effect.Effect<A, E, Exclude<R, I>>
 } = function(this: any) {
@@ -2114,7 +2114,7 @@ export const provideService: {
 
 const provideServiceImpl = <A, E, R, I, S>(
   self: Effect.Effect<A, E, R>,
-  service: ServiceMap.Service<I, S>,
+  service: ServiceMap.Key<I, S>,
   implementation: S
 ): Effect.Effect<A, E, Exclude<R, I>> =>
   updateServices(self, (s) => {
@@ -2126,21 +2126,21 @@ const provideServiceImpl = <A, E, R, I, S>(
 /** @internal */
 export const provideServiceEffect: {
   <I, S, E2, R2>(
-    service: ServiceMap.Service<I, S>,
+    service: ServiceMap.Key<I, S>,
     acquire: Effect.Effect<S, E2, R2>
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<A, E | E2, Exclude<R, I> | R2>
   <A, E, R, I, S, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    service: ServiceMap.Service<I, S>,
+    service: ServiceMap.Key<I, S>,
     acquire: Effect.Effect<S, E2, R2>
   ): Effect.Effect<A, E | E2, Exclude<R, I> | R2>
 } = dual(
   3,
   <A, E, R, I, S, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    service: ServiceMap.Service<I, S>,
+    service: ServiceMap.Key<I, S>,
     acquire: Effect.Effect<S, E2, R2>
   ): Effect.Effect<A, E | E2, Exclude<R, I> | R2> =>
     flatMap(acquire, (implementation) => provideService(self, service, implementation))
@@ -4214,24 +4214,24 @@ export const all = <
 
 /** @internal */
 export const partition: {
-  <A, Pass, Fail, E, R>(
-    filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, E, R, [i: number]>,
+  <A, B, E, R>(
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): (elements: Iterable<A>) => Effect.Effect<[excluded: Array<Fail>, satisfying: Array<Pass>], E, R>
-  <A, Pass, Fail, E, R>(
+  ): (elements: Iterable<A>) => Effect.Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
+  <A, B, E, R>(
     elements: Iterable<A>,
-    filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, E, R, [i: number]>,
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect.Effect<[excluded: Array<Fail>, satisfying: Array<Pass>], E, R>
+  ): Effect.Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
 } = dual(
   (args) => isIterable(args[0]) && !isEffect(args[0]),
-  <A, Pass, Fail, E, R>(
+  <A, B, E, R>(
     elements: Iterable<A>,
-    filter: Filter.FilterEffect<A, Pass, Fail, E, R, [i: number]>,
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect.Effect<[excluded: Array<Fail>, satisfying: Array<Pass>], E, R> =>
+  ): Effect.Effect<[excluded: Array<E>, satisfying: Array<B>], never, R> =>
     map(
-      forEach(elements, filter, options),
+      forEach(elements, (a, i) => result(f(a, i)), options),
       (results) => Arr.partition(results, identity)
     )
 )
@@ -4279,7 +4279,7 @@ export const validate: {
     } | undefined
   ): Effect.Effect<Array<B> | void, Arr.NonEmptyArray<E>, R> =>
     flatMap(
-      partition(elements, (a, i) => result(f(a, i)), { concurrency: options?.concurrency }),
+      partition(elements, f, { concurrency: options?.concurrency }),
       ([excluded, satisfying]) => {
         if (Arr.isArrayNonEmpty(excluded)) {
           return fail(excluded)

package/src/testing/TestSchema.ts

@@ -200,7 +200,7 @@ export class Decoding<S extends Schema.Top> {
    * decoding context.
    */
   provide<Id, Service>(
-    service: ServiceMap.Service<Id, Service>,
+    service: ServiceMap.Key<Id, Service>,
     implementation: Service
   ): Decoding<Schema.middlewareDecoding<S, Exclude<S["DecodingServices"], Id>>> {
     return new Decoding(
@@ -276,7 +276,7 @@ class Encoding<S extends Schema.Top> {
    * encoding context.
    */
   provide<Id, Service>(
-    service: ServiceMap.Service<Id, Service>,
+    service: ServiceMap.Key<Id, Service>,
     implementation: Service
   ): Encoding<Schema.middlewareEncoding<S, Exclude<S["EncodingServices"], Id>>> {
     return new Encoding(