@effect-app/infra 4.0.0-beta.7 → 4.0.0-beta.71

package/src/adapters/SQL/Model.ts

@@ -7,10 +7,6 @@
 /**
  * @since 1.0.0
  */
-import * as VariantSchema from "effect/unstable/schema/VariantSchema"
-import { SqlClient } from "effect/unstable/sql/SqlClient"
-import * as SqlResolver from "effect/unstable/sql/SqlResolver"
-import * as SqlSchema from "effect/unstable/sql/SqlSchema"
 import crypto from "crypto" // TODO
 import type { Brand } from "effect/Brand"
 import * as DateTime from "effect/DateTime"
@@ -24,6 +20,10 @@ import * as Schema from "effect/Schema"
 import * as Getter from "effect/SchemaGetter"
 import * as Transformation from "effect/SchemaTransformation"
 import type { Scope } from "effect/Scope"
+import * as VariantSchema from "effect/unstable/schema/VariantSchema"
+import { SqlClient } from "effect/unstable/sql/SqlClient"
+import * as SqlResolver from "effect/unstable/sql/SqlResolver"
+import * as SqlSchema from "effect/unstable/sql/SqlSchema"
 
 const {
   Class,
@@ -190,14 +190,13 @@ export const Generated = <S extends Schema.Top>(
  * @since 1.0.0
  * @category generated
  */
-export interface GeneratedByApp<S extends Schema.Top>
-  extends
-    VariantSchema.Field<{
-      readonly select: S
-      readonly insert: S
-      readonly update: S
-      readonly json: S
-    }>
+export interface GeneratedByApp<S extends Schema.Top> extends
+  VariantSchema.Field<{
+    readonly select: S
+    readonly insert: S
+    readonly update: S
+    readonly json: S
+  }>
 {}
 
 /**
@@ -303,8 +302,7 @@ export const FieldOption: <Field extends VariantSchema.Field<any> | Schema.Top>(
 ) => Field extends Schema.Top ? FieldOption<Field>
   : Field extends VariantSchema.Field<infer S> ? VariantSchema.Field<
       {
-        readonly [K in keyof S]: S[K] extends Schema.Top
-          ? K extends VariantsDatabase ? Schema.OptionFromNullOr<S[K]>
+        readonly [K in keyof S]: S[K] extends Schema.Top ? K extends VariantsDatabase ? Schema.OptionFromNullOr<S[K]>
           : optionalOption<S[K]>
           : never
       }
@@ -545,16 +543,15 @@ export const DateTimeUpdateFromNumber: DateTimeUpdateFromNumber = Field({
  * @since 1.0.0
  * @category json
  */
-export interface JsonFromString<S extends Schema.Top>
-  extends
-    VariantSchema.Field<{
-      readonly select: Schema.fromJsonString<S>
-      readonly insert: Schema.fromJsonString<S>
-      readonly update: Schema.fromJsonString<S>
-      readonly json: S
-      readonly jsonCreate: S
-      readonly jsonUpdate: S
-    }>
+export interface JsonFromString<S extends Schema.Top> extends
+  VariantSchema.Field<{
+    readonly select: Schema.fromJsonString<S>
+    readonly insert: Schema.fromJsonString<S>
+    readonly update: Schema.fromJsonString<S>
+    readonly json: S
+    readonly jsonCreate: S
+    readonly jsonUpdate: S
+  }>
 {}
 
 /**
@@ -825,26 +822,28 @@ export const makeDataLoaders = <
     const idColumn = options.idColumn as string
     const setMaxBatchSize = options.maxBatchSize ? RequestResolver.batchN(options.maxBatchSize) : identity
 
-    const insertResolver = SqlResolver.ordered({
-      Request: Model.insert,
-      Result: Model,
-      execute: (request: any) =>
-        sql.onDialectOrElse({
-          mysql: () =>
-            Effect.forEach(request, (request: any) =>
-              sql`insert into ${sql(options.tableName)} ${sql.insert(request)};
+    const insertResolver = SqlResolver
+      .ordered({
+        Request: Model.insert,
+        Result: Model,
+        execute: (request: any) =>
+          sql.onDialectOrElse({
+            mysql: () =>
+              Effect.forEach(request, (request: any) =>
+                sql`insert into ${sql(options.tableName)} ${sql.insert(request)};
 select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID();`
-                .unprepared
-                .pipe(
-                  Effect.map(([, results]) => results![0] as any)
-                ), { concurrency: 10 }),
-          orElse: () => sql`insert into ${sql(options.tableName)} ${sql.insert(request).returning("*")}`
-        })
-    }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
-      RequestResolver.withSpan(`${options.spanPrefix}.insertResolver`)
-    )
+                  .unprepared
+                  .pipe(
+                    Effect.map(([, results]) => results![0] as any)
+                  ), { concurrency: 10 }),
+            orElse: () => sql`insert into ${sql(options.tableName)} ${sql.insert(request).returning("*")}`
+          })
+      })
+      .pipe(
+        RequestResolver.setDelay(options.window),
+        setMaxBatchSize,
+        RequestResolver.withSpan(`${options.spanPrefix}.insertResolver`)
+      )
     const insertExecute = SqlResolver.request(insertResolver)
     const insert = (
       insert: S["insert"]["Type"]
@@ -860,14 +859,16 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
         })
       ) as any
 
-    const insertVoidResolver = SqlResolver.void({
-      Request: Model.insert,
-      execute: (request: any) => sql`insert into ${sql(options.tableName)} ${sql.insert(request)}`
-    }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
-      RequestResolver.withSpan(`${options.spanPrefix}.insertVoidResolver`)
-    )
+    const insertVoidResolver = SqlResolver
+      .void({
+        Request: Model.insert,
+        execute: (request: any) => sql`insert into ${sql(options.tableName)} ${sql.insert(request)}`
+      })
+      .pipe(
+        RequestResolver.setDelay(options.window),
+        setMaxBatchSize,
+        RequestResolver.withSpan(`${options.spanPrefix}.insertVoidResolver`)
+      )
     const insertVoidExecute = SqlResolver.request(insertVoidResolver)
     const insertVoid = (
       insert: S["insert"]["Type"]
@@ -878,18 +879,20 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
         })
       ) as any
 
-    const findByIdResolver = SqlResolver.findById({
-      Id: idSchema,
-      Result: Model,
-      ResultId(request: any) {
-        return request[idColumn]
-      },
-      execute: (ids: any) => sql`select * from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
-    }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
-      RequestResolver.withSpan(`${options.spanPrefix}.findByIdResolver`)
-    )
+    const findByIdResolver = SqlResolver
+      .findById({
+        Id: idSchema,
+        Result: Model,
+        ResultId(request: any) {
+          return request[idColumn]
+        },
+        execute: (ids: any) => sql`select * from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
+      })
+      .pipe(
+        RequestResolver.setDelay(options.window),
+        setMaxBatchSize,
+        RequestResolver.withSpan(`${options.spanPrefix}.findByIdResolver`)
+      )
     const findByIdExecute = SqlResolver.request(findByIdResolver)
     const findById = (
       id: S["fields"][Id]["Type"]
@@ -904,14 +907,16 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
         })
       ) as any
 
-    const deleteResolver = SqlResolver.void({
-      Request: idSchema,
-      execute: (ids: any) => sql`delete from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
-    }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
-      RequestResolver.withSpan(`${options.spanPrefix}.deleteResolver`)
-    )
+    const deleteResolver = SqlResolver
+      .void({
+        Request: idSchema,
+        execute: (ids: any) => sql`delete from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
+      })
+      .pipe(
+        RequestResolver.setDelay(options.window),
+        setMaxBatchSize,
+        RequestResolver.withSpan(`${options.spanPrefix}.deleteResolver`)
+      )
     const deleteExecute = SqlResolver.request(deleteResolver)
     const delete_ = (
       id: S["fields"][Id]["Type"]

package/src/adapters/ServiceBus.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/prefer-promise-reject-errors */
 import { type OperationOptionsBase, type ProcessErrorArgs, ServiceBusClient, type ServiceBusMessage, type ServiceBusMessageBatch, type ServiceBusReceivedMessage, type ServiceBusReceiver } from "@azure/service-bus"
-import { Cause, Effect, Exit, FiberSet, Layer, type Scope, ServiceMap } from "effect-app"
+import { Cause, Context, Effect, Exit, FiberSet, Layer, type Scope } from "effect-app"
 import { InfraLogger } from "../logger.js"
 
 const withSpanAndLog = (name: string) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
@@ -19,7 +19,7 @@ function makeClient(url: string) {
 }
 
 export class ServiceBusClientTag
-  extends ServiceMap.Opaque<ServiceBusClientTag, ServiceBusClient>()("@services/Client", { make: makeClient })
+  extends Context.Opaque<ServiceBusClientTag, ServiceBusClient>()("@services/Client", { make: makeClient })
 {
   static readonly layer = (url: string) => this.toLayer(this.make(url))
 }
@@ -50,7 +50,7 @@ const makeSender = (name: string) =>
     return { name, sendMessages }
   })
 
-export class Sender extends ServiceMap.Opaque<Sender, {
+export class Sender extends Context.Opaque<Sender, {
   name: string
   sendMessages: (
     messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
@@ -61,12 +61,12 @@ export class Sender extends ServiceMap.Opaque<Sender, {
 }
 
 export const SenderTag = <Id>() => <Key extends string>(queueName: Key) => {
-  const tag = ServiceMap.Service<Id, Sender>(`ServiceBus.Sender.${queueName}`)
+  const tag = Context.Service<Id, Sender>(`ServiceBus.Sender.${queueName}`)
 
   return Object.assign(tag, {
     layer: Layer.effect(
       tag,
-      Sender.make(queueName).pipe(Effect.map((_) => Sender.of(_)))
+      Sender.make(queueName).pipe(Effect.map(Sender.of))
     )
   })
 }
@@ -163,7 +163,7 @@ const makeReceiver = (name: string) =>
     }
   })
 
-export class Receiver extends ServiceMap.Opaque<Receiver, {
+export class Receiver extends Context.Opaque<Receiver, {
   name: string
   make: (waitTillEmpty: Effect.Effect<void>) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
   makeSession: (
@@ -180,12 +180,12 @@ export class Receiver extends ServiceMap.Opaque<Receiver, {
 }
 
 export const ReceiverTag = <Id>() => <Key extends string>(queueName: Key) => {
-  const tag = ServiceMap.Service<Id, Receiver>(`ServiceBus.Receiver.${queueName}`)
+  const tag = Context.Service<Id, Receiver>(`ServiceBus.Receiver.${queueName}`)
 
   return Object.assign(tag, {
     layer: Layer.effect(
       tag,
-      makeReceiver(queueName).pipe(Effect.map((_) => Receiver.of(_)))
+      makeReceiver(queueName).pipe(Effect.map(Receiver.of))
     )
   })
 }

package/src/adapters/cosmos-client.ts

@@ -1,12 +1,12 @@
 import { CosmosClient as ComosClient_ } from "@azure/cosmos"
-import { Effect, Layer, ServiceMap } from "effect-app"
+import { Context, Effect, Layer } from "effect-app"
 
 const withClient = (url: string) => Effect.sync(() => new ComosClient_(url))
 
 export const makeCosmosClient = (url: string, dbName: string) =>
   Effect.map(withClient(url), (x) => ({ db: x.database(dbName) }))
 
-export class CosmosClient extends ServiceMap.Service<CosmosClient, {
+export class CosmosClient extends Context.Service<CosmosClient, {
   readonly db: ReturnType<InstanceType<typeof ComosClient_>["database"]>
 }>()("@services/CosmosClient") {}
 

package/src/adapters/memQueue.ts

@@ -1,4 +1,4 @@
-import { Effect, type Queue, ServiceMap } from "effect-app"
+import { Context, Effect, type Queue } from "effect-app"
 import * as Q from "effect/Queue"
 
 const make = Effect
@@ -16,6 +16,6 @@ const make = Effect
     }
   })
 
-export class MemQueue extends ServiceMap.Opaque<MemQueue>()("effect-app/MemQueue", { make }) {
+export class MemQueue extends Context.Opaque<MemQueue>()("effect-app/MemQueue", { make }) {
   static readonly Live = this.toLayer(this.make)
 }

package/src/adapters/mongo-client.ts

@@ -1,4 +1,4 @@
-import { Effect, Layer, ServiceMap } from "effect-app"
+import { Context, Effect, Layer } from "effect-app"
 import { MongoClient as MongoClient_ } from "mongodb"
 
 // TODO: we should probably share a single client...
@@ -15,7 +15,7 @@ const withClient = (url: string) =>
 
 const makeMongoClient = (url: string, dbName?: string) => Effect.map(withClient(url), (x) => ({ db: x.db(dbName) }))
 
-export class MongoClient extends ServiceMap.Service<MongoClient, {
+export class MongoClient extends Context.Service<MongoClient, {
   readonly db: ReturnType<InstanceType<typeof MongoClient_>["db"]>
 }>()("@services/MongoClient") {}
 

package/src/adapters/redis-client.ts

@@ -1,4 +1,4 @@
-import { Data, Effect, Layer, Option, ServiceMap } from "effect-app"
+import { Context, Data, Effect, Layer, Option } from "effect-app"
 import type { RedisClient as Client } from "redis"
 import Redlock from "redlock"
 
@@ -90,7 +90,7 @@ export const makeRedisClient = (makeClient: () => Client) =>
         .pipe(Effect.uninterruptible, Effect.orDie)
   )
 
-export class RedisClient extends ServiceMap.Service<RedisClient, {
+export class RedisClient extends Context.Service<RedisClient, {
   readonly client: Client
   readonly lock: Redlock
   readonly get: (key: string) => Effect.Effect<Option.Option<string>, ConnectionException>

package/src/api/ContextProvider.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Layer, type NonEmptyReadonlyArray, pipe, type Scope, ServiceMap } from "effect-app"
+import { Context, Effect, Layer, type NonEmptyReadonlyArray, pipe, type Scope } from "effect-app"
 
 import { type HttpRouter } from "effect-app/http"
 import { type EffectGenUtils } from "effect-app/utils/gen"
@@ -23,7 +23,7 @@ type TDepsArr<TDeps extends ReadonlyArray<any>> = {
   // E = never => the context provided cannot trigger errors
   // TODO: remove HttpLayerRouter.Provided - it's not even relevant outside of Http context, while ContextProviders are for anywhere. Only support Scope.Scope?
   //  _R extends HttpLayerRouter.Provided => the context provided can only have what HttpLayerRouter.Provided provides as requirements
-  ContextTagWithDefault.Base<Effect.Effect<ServiceMap.ServiceMap<infer _1>, never, infer _R>> // & { _tag: infer _2 }>
+  ContextTagWithDefault.Base<Effect.Effect<Context.Context<infer _1>, never, infer _R>> // & { _tag: infer _2 }>
     ? [_R] extends [HttpRouter.Provided] ? TDeps[K]
     : `HttpLayerRouter.Provided is the only requirement ${TDeps[K]["Service"][
       "_tag"
@@ -58,9 +58,9 @@ export const mergeContextProviders = <
     Effect.Effect<
       // we need to merge all contexts into one
       // v4: Service.Shape extracts the service value type (v3's Tag.Identifier)
-      ServiceMap.ServiceMap<GetContext<EffectGenUtils.Success<ServiceMap.Service.Shape<TDeps[number]>>>>,
+      Context.Context<GetContext<EffectGenUtils.Success<Context.Service.Shape<TDeps[number]>>>>,
       never,
-      EffectGenUtils.ServiceMap<ServiceMap.Service.Shape<TDeps[number]>>
+      EffectGenUtils.Context<Context.Service.Shape<TDeps[number]>>
     >,
     LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
@@ -78,14 +78,14 @@ export const mergeContextProviders = <
             handle: handle[Symbol.toStringTag] === "GeneratorFunction" ? Effect.fnUntraced(handle)() : handle
           }
         ))
-        // services are effects which return some ServiceMap.ServiceMap<...>
+        // services are effects which return some Context.Context<...>
         const context = yield* mergeContexts(services as any)
         return context
       })
   }) as any
 })
 
-// Effect Rpc Middleware: for single tag providing, we could use Provides, for providing ServiceMap or Layer (bad boy) we could use Wrap..
+// Effect Rpc Middleware: for single tag providing, we could use Provides, for providing Context or Layer (bad boy) we could use Wrap..
 export const ContextProvider = <
   ContextProviderA,
   MakeContextProviderE,
@@ -107,7 +107,7 @@ export const ContextProvider = <
     dependencies?: Dependencies
   }
 ) => {
-  const ctx = ServiceMap.Service<
+  const ctx = Context.Service<
     ContextProviderId,
     Effect.Effect<ContextProviderA, never, ContextProviderR>
   >(
@@ -146,17 +146,17 @@ export const MergedContextProvider = <
     Effect.Effect<
       // we need to merge all contexts into one
       // v4: Service.Shape extracts the service value type (v3's Tag.Identifier)
-      ServiceMap.ServiceMap<GetContext<EffectGenUtils.Success<ServiceMap.Service.Shape<TDeps[number]>>>>,
+      Context.Context<GetContext<EffectGenUtils.Success<Context.Service.Shape<TDeps[number]>>>>,
       never,
-      EffectGenUtils.ServiceMap<ServiceMap.Service.Shape<TDeps[number]>>
+      EffectGenUtils.Context<Context.Service.Shape<TDeps[number]>>
     >,
     LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     // v4: Identifier here is correct — it's the nominal service identity for layer provide/exclude
     | Exclude<
-      ServiceMap.Service.Identifier<TDeps[number]>,
+      Context.Service.Identifier<TDeps[number]>,
       LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
     >
     | LayerUtils.GetLayersContext<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
   >
 
-export const EmptyContextProvider = ContextProvider({ effect: Effect.succeed(Effect.succeed(ServiceMap.empty())) })
+export const EmptyContextProvider = ContextProvider({ effect: Effect.succeed(Effect.succeed(Context.empty())) })

package/src/api/internal/events.ts

@@ -16,7 +16,7 @@ export const makeSSE = <A extends { id: any }, SI, SR>(
   Effect
     .gen(function*() {
       const id = connId++
-      const ctx = yield* Effect.services<R | SR>()
+      const ctx = yield* Effect.context<R | SR>()
       const res = HttpServerResponse.stream(
         // workaround for different scoped behaviour for streams in Bun
         // https://discord.com/channels/795981131316985866/1098177242598756412/1389646879675125861
@@ -28,19 +28,20 @@ export const makeSSE = <A extends { id: any }, SI, SR>(
 
             const enc = new TextEncoder()
 
-            const encode = S.encodeEffect(schema)
+            const encode = S.encodeEffect(S.fromJsonString(S.toCodecJson(schema)))
 
             const eventStream = Stream.mapEffect(
               events,
               (_) =>
                 encode(_.evt)
-                  .pipe(Effect.map((evt) => `id: ${_.evt.id}\ndata: ${JSON.stringify(evt)}`))
+                  .pipe(Effect.map((data) => `id: ${_.evt.id}\ndata: ${data}`))
             )
 
             const stream = pipe(
               setRetry,
               Stream.merge(keepAlive),
-              Stream.merge(eventStream, { haltStrategy: "either" }),
+              // Keep this unary so pipe receives a function, not a Stream value.
+              (self) => Stream.merge(self, eventStream, { haltStrategy: "either" }),
               Stream.tapCause((cause) => Effect.logError("SSE error", cause)),
               Stream.map((_) => enc.encode(_ + "\n\n"))
             )

package/src/api/layerUtils.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, type Layer, type NonEmptyReadonlyArray, Option, ServiceMap } from "effect-app"
+import { Context, Effect, type Layer, type NonEmptyReadonlyArray, Option } from "effect-app"
 import { InfraLogger } from "../logger.js"
 
 // TODO: These LayerUtils are flaky, like in dependencies as a readonly array, it breaks when there are two entries
@@ -27,7 +27,7 @@ export namespace LayerUtils {
 }
 
 export type ContextTagWithDefault<Id, A, LayerE, LayerR> =
-  & ServiceMap.Service<Id, A>
+  & Context.Service<Id, A>
   & {
     Default: Layer.Layer<Id, LayerE, LayerR>
   }
@@ -36,29 +36,29 @@ export namespace ContextTagWithDefault {
   export type Base<A> = ContextTagWithDefault<any, A, any, any>
 }
 
-export type GetContext<T> = T extends ServiceMap.ServiceMap<infer Y> ? Y : never
+export type GetContext<T> = T extends Context.Context<infer Y> ? Y : never
 
 export const mergeContexts = Effect.fnUntraced(
   function*<
     T extends readonly {
       maker: any
-      handle: Effect.Effect<ServiceMap.ServiceMap<any> | Option.Option<ServiceMap.ServiceMap<any>>>
+      handle: Effect.Effect<Context.Context<any> | Option.Option<Context.Context<any>>>
     }[]
   >(
     makers: T
   ) {
-    let context = ServiceMap.empty()
+    let context = Context.empty()
     for (const mw of makers) {
       const ctx = yield* mw.handle.pipe(Effect.provide(context))
-      const moreContext = ServiceMap.isServiceMap(ctx) ? Option.some(ctx) : ctx
+      const moreContext = Context.isContext(ctx) ? Option.some(ctx) : ctx
       yield* InfraLogger.logDebug(
         "Built dynamic context for middleware" + (mw.maker.key ?? mw.maker),
         Option.map(moreContext, (c) => (c as any).toJSON().services)
       )
       if (moreContext.value) {
-        context = ServiceMap.merge(context, moreContext.value)
+        context = Context.merge(context, moreContext.value)
       }
     }
-    return context as ServiceMap.ServiceMap<Effect.Success<T[number]["handle"]>>
+    return context as Context.Context<Effect.Success<T[number]["handle"]>>
   }
 )

package/src/api/routing/middleware/RouterMiddleware.ts

@@ -1,13 +1,13 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { type Layer, type ServiceMap } from "effect-app"
+import { type Context, type Layer } from "effect-app"
 import { type GetContextConfig, type RpcContextMap } from "effect-app/rpc/RpcContextMap"
 import { type RpcMiddlewareV4 } from "effect-app/rpc/RpcMiddleware"
 // module:
 //
 
-// v4: middleware tags are ServiceMap.Service (not Effect) — they carry the RpcMiddlewareV4 as their service Shape
+// v4: middleware tags are Context.Service (not Effect) — they carry the RpcMiddlewareV4 as their service Shape
 export type RouterMiddleware<
   Self,
   RequestContextMap extends Record<string, RpcContextMap.Any>, // what services will the middlware provide dynamically to the next, or raise errors.
@@ -18,9 +18,9 @@ export type RouterMiddleware<
   _ContextProviderR, // what the context provider requires
   RequestContextId
 > =
-  & ServiceMap.Service<Self, RpcMiddlewareV4<ContextProviderA, ContextProviderE, never>>
+  & Context.Service<Self, RpcMiddlewareV4<ContextProviderA, ContextProviderE, never>>
   & {
     readonly Default: Layer.Layer<Self, MakeMiddlewareE, MakeMiddlewareR>
-    readonly requestContext: ServiceMap.Service<RequestContextId, GetContextConfig<RequestContextMap>>
+    readonly requestContext: Context.Service<RequestContextId, GetContextConfig<RequestContextMap>>
     readonly requestContextMap: RequestContextMap
   }

package/src/api/routing/schema/jwt.ts

@@ -15,8 +15,7 @@ export const parseJwt = <Sch extends S.Top>(
       (s, _options) =>
         Effect.try({
           try: () => jwtDecode(s, options),
-          catch: (e: any) =>
-            new S.SchemaIssue.InvalidValue(Option.some(s), { message: e?.message })
+          catch: (e: any) => new S.SchemaIssue.InvalidValue(Option.some(s), { message: e?.message })
         })
     )
-    .pipe(S.decodeTo(schema) as any) as any as S.decodeTo<Sch, S.String>
+    .pipe(S.decodeTo(schema) as any)

package/src/api/routing.ts

@@ -194,7 +194,8 @@ export const makeRouter = <
     > = (
       req: S.Schema.Type<Action>
     ) => Generator<
-      Yieldable<any,
+      Yieldable<
+        any,
         any,
         S.Schema.Type<GetFailure<Action>> | S.SchemaError,
         // the actual implementation of the handler may just require the dynamic context provided by the middleware
@@ -319,7 +320,7 @@ export const makeRouter = <
               ? Impl[K]["raw"] extends (...args: any[]) => Effect.Effect<any, any, infer R> ? R
               : Impl[K]["raw"] extends Effect.Effect<any, any, infer R> ? R
               : Impl[K]["raw"] extends (...args: any[]) => Generator<
-                Yieldable<any,any, any, infer R>,
+                Yieldable<any, any, any, infer R>,
                 any,
                 any
               > ? R
@@ -327,7 +328,7 @@ export const makeRouter = <
               : Impl[K] extends (...args: any[]) => Effect.Effect<any, any, infer R> ? R
               : Impl[K] extends Effect.Effect<any, any, infer R> ? R
               : Impl[K] extends (...args: any[]) => Generator<
-                Yieldable<any,any, any, infer R>,
+                Yieldable<any, any, any, infer R>,
                 any,
                 any
               > ? R

package/src/errorReporter.ts

@@ -1,5 +1,5 @@
 import * as Sentry from "@sentry/node"
-import { Cause, Effect, LogLevel } from "effect-app"
+import { Cause, Effect, type LogLevel } from "effect-app"
 import { dropUndefined, LogLevelToSentry } from "effect-app/utils"
 import { getRC } from "./api/setupRequest.js"
 import { CauseException, tryToJson, tryToReport } from "./errors.js"

package/src/fileUtil.ts

@@ -119,7 +119,7 @@ export function withFileLock<A, E, R>(
       // ensure lock is released
       yield* Effect.addFinalizer(() =>
         Effect
-           // we have to make sure we use a thunk, or the library will cause problems because effect passes abortsignal as first argument
+          // we have to make sure we use a thunk, or the library will cause problems because effect passes abortsignal as first argument
           .tryPromise(() => release())
           .pipe(Effect.orDie)
       )

package/src/rateLimit.ts

@@ -56,7 +56,7 @@ export function batchPar<R, E, A, R2, E2, A2, T>(
       (_, i) =>
         Effect
           .forEach(_, (_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
-          .pipe(Effect.flatMap((_) => forEachBatch(_ as NonEmptyArray<A>, i))),
+          .pipe(Effect.flatMap((_) => forEachBatch(_, i))),
       { concurrency: "inherit" }
     )
 }
@@ -72,7 +72,7 @@ export function batch<R, E, A, R2, E2, A2, T>(
       (_, i) =>
         Effect
           .forEach(_, (_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
-          .pipe(Effect.flatMap((_) => forEachBatch(_ as NonEmptyArray<A>, i)))
+          .pipe(Effect.flatMap((_) => forEachBatch(_, i)))
     )
 }
 

package/test/contextProvider.test.ts

@@ -1,12 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { expectTypeOf, it } from "@effect/vitest"
-import { Effect, Layer, Scope, ServiceMap } from "effect-app"
+import { Effect, Layer, Scope, Context } from "effect-app"
 import { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/api/ContextProvider.js"
 import { CustomError1, Some, SomeElse, SomeService } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class MyContextProvider extends ServiceMap.Service<MyContextProvider>()(
+class MyContextProvider extends Context.Service<MyContextProvider>()(
   "MyContextProvider",
   {
     make: Effect.gen(function*() {
@@ -28,7 +28,7 @@ class MyContextProvider extends ServiceMap.Service<MyContextProvider>()(
   static readonly Default = Layer.effect(this, this.make)
 }
 
-class MyContextProvider2 extends ServiceMap.Service<MyContextProvider2>()(
+class MyContextProvider2 extends Context.Service<MyContextProvider2>()(
   "MyContextProvider2",
   {
     make: Effect.gen(function*() {
@@ -45,7 +45,7 @@ class MyContextProvider2 extends ServiceMap.Service<MyContextProvider2>()(
   static readonly Default = Layer.effect(this, this.make)
 }
 
-class MyContextProvider2Gen extends ServiceMap.Service<MyContextProvider2Gen>()(
+class MyContextProvider2Gen extends Context.Service<MyContextProvider2Gen>()(
   "MyContextProvider2Gen",
   {
     make: Effect.gen(function*() {
@@ -63,7 +63,7 @@ class MyContextProvider2Gen extends ServiceMap.Service<MyContextProvider2Gen>()(
 }
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class MyContextProviderGen extends ServiceMap.Service<MyContextProviderGen>()(
+class MyContextProviderGen extends Context.Service<MyContextProviderGen>()(
   "MyContextProviderGen",
   {
     make: Effect.gen(function*() {