@effect-app/infra 3.10.0 → 4.0.0-beta.1

package/src/adapters/ServiceBus.ts

@@ -1,11 +1,11 @@
 /* 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, Context, Effect, Exit, FiberSet, Layer, type Scope } from "effect-app"
+import { Cause, Effect, Exit, FiberSet, Layer, type Scope, ServiceMap } from "effect-app"
 import { InfraLogger } from "../logger.js"
 
 const withSpanAndLog = (name: string) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
   Effect.logInfo(name).pipe(
-    Effect.zipRight(self),
+    Effect.andThen(self),
     Effect.tap(Effect.logInfo(name + " done")),
     Effect.withLogSpan(name),
     Effect.withSpan(name)
@@ -18,9 +18,10 @@ function makeClient(url: string) {
   )
 }
 
-export class ServiceBusClientTag extends Context.Tag("@services/Client")<ServiceBusClientTag, ServiceBusClient>() {
-  static readonly make = makeClient
-  static readonly layer = (url: string) => Layer.scoped(this, makeClient(url))
+export class ServiceBusClientTag
+  extends ServiceMap.Opaque<ServiceBusClientTag, ServiceBusClient>()("@services/Client", { make: makeClient })
+{
+  static readonly layer = (url: string) => this.toLayer(this.make(url))
 }
 
 function makeSender_(queueName: string) {
@@ -49,27 +50,23 @@ const makeSender = (name: string) =>
     return { name, sendMessages }
   })
 
-export class Sender extends Context.TagId("Sender")<Sender, {
+export class Sender extends ServiceMap.Opaque<Sender, {
   name: string
   sendMessages: (
     messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
     options?: Omit<OperationOptionsBase, "abortSignal">
   ) => Effect.Effect<void, never, never>
-}>() {
-  static readonly make = makeSender
-  static readonly layer = (name: string) => this.toLayerScoped(makeSender(name))
+}>()("Sender", { make: makeSender }) {
+  static readonly layer = (name: string) => this.toLayer(this.make(name))
 }
 
 export const SenderTag = <Id>() => <Key extends string>(queueName: Key) => {
-  const tag = Context.Tag(`ServiceBus.Sender.${queueName}`)<
-    Id,
-    Sender
-  >()
+  const tag = ServiceMap.Service<Id, Sender>(`ServiceBus.Sender.${queueName}`)
 
   return Object.assign(tag, {
-    layer: Layer.scoped(
+    layer: Layer.effect(
       tag,
-      makeSender(queueName).pipe(Effect.map((_) => Sender.of(_)))
+      Sender.make(queueName).pipe(Effect.map((_) => Sender.of(_)))
     )
   })
 }
@@ -133,7 +130,7 @@ const makeReceiver = (name: string) =>
                   resolve(exit.value)
                 } else {
                   // disable @typescript-eslint/prefer-promise-reject-errors
-                  reject(Cause.pretty(exit.cause, { renderErrorCause: true }))
+                  reject(Cause.pretty(exit.cause))
                 }
               })
           )
@@ -148,7 +145,7 @@ const makeReceiver = (name: string) =>
                       hndlr
                         .processError(err)
                         .pipe(
-                          Effect.catchAllCause((cause) => Effect.logError(`ServiceBus Error ${sessionId}`, cause))
+                          Effect.catchCause((cause) => Effect.logError(`ServiceBus Error ${sessionId}`, cause))
                         )
                     ),
                   processMessage: (msg) => runEffect(hndlr.processMessage(msg))
@@ -166,7 +163,7 @@ const makeReceiver = (name: string) =>
     }
   })
 
-export class Receiver extends Context.TagId("Receiver")<Receiver, {
+export class Receiver extends ServiceMap.Opaque<Receiver, {
   name: string
   make: (waitTillEmpty: Effect.Effect<void>) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
   makeSession: (
@@ -177,13 +174,13 @@ export class Receiver extends Context.TagId("Receiver")<Receiver, {
     hndlr: MessageHandlers<RMsg, RErr>,
     sessionId?: string
   ): Effect.Effect<void, never, Scope.Scope | RMsg | RErr>
-}>() {
+}>()("Receiver") {
   static readonly make = makeReceiver
   static readonly layer = (name: string) => this.toLayer(makeReceiver(name))
 }
 
 export const ReceiverTag = <Id>() => <Key extends string>(queueName: Key) => {
-  const tag = Context.Tag(`ServiceBus.Receiver.${queueName}`)<Id, Receiver>()
+  const tag = ServiceMap.Service<Id, Receiver>(`ServiceBus.Receiver.${queueName}`)
 
   return Object.assign(tag, {
     layer: Layer.effect(

package/src/adapters/cosmos-client.ts

@@ -1,16 +1,16 @@
 import { CosmosClient as ComosClient_ } from "@azure/cosmos"
-import { Context, Effect, Layer } from "effect-app"
+import { Effect, Layer, ServiceMap } 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 interface CosmosClient extends Effect.Effect.Success<ReturnType<typeof makeCosmosClient>> {}
+export class CosmosClient extends ServiceMap.Service<CosmosClient, {
+  readonly db: ReturnType<InstanceType<typeof ComosClient_>["database"]>
+}>()("@services/CosmosClient") {}
 
-export const CosmosClient = Context.GenericTag<CosmosClient>("@services/CosmosClient")
-
-export const db = Effect.map(CosmosClient, (_) => _.db)
+export const db = CosmosClient.asEffect().pipe(Effect.map((_) => _.db))
 
 export const CosmosClientLayer = (cosmosUrl: string, dbName: string) =>
   Layer.effect(CosmosClient, makeCosmosClient(cosmosUrl, dbName))

package/src/adapters/memQueue.ts

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

package/src/adapters/mongo-client.ts

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

package/src/adapters/redis-client.ts

@@ -1,4 +1,4 @@
-import { Context, Data, Effect, Layer, Option } from "effect-app"
+import { Data, Effect, Layer, Option, ServiceMap } from "effect-app"
 import type { RedisClient as Client } from "redis"
 import Redlock from "redlock"
 
@@ -17,21 +17,21 @@ export const makeRedisClient = (makeClient: () => Client) =>
 
         function get(key: string) {
           return Effect
-            .async<Option.Option<string>, ConnectionException>((res) => {
+            .callback<Option.Option<string>, ConnectionException>((res) => {
               client.get(key, (err, v) =>
                 err
-                  ? res(new ConnectionException(err))
-                  : res(Effect.sync(() => Option.fromNullable(v))))
+                  ? res(Effect.fail(new ConnectionException(err)))
+                  : res(Effect.sync(() => Option.fromNullishOr(v))))
             })
             .pipe(Effect.uninterruptible)
         }
 
         function set(key: string, val: string) {
           return Effect
-            .async<void, ConnectionException>((res) => {
+            .callback<void, ConnectionException>((res) => {
               client.set(key, val, (err) =>
                 err
-                  ? res(new ConnectionException(err))
+                  ? res(Effect.fail(new ConnectionException(err)))
                   : res(Effect.sync(() => void 0)))
             })
             .pipe(Effect.uninterruptible)
@@ -39,10 +39,10 @@ export const makeRedisClient = (makeClient: () => Client) =>
 
         function hset(key: string, field: string, value: string) {
           return Effect
-            .async<void, ConnectionException>((res) => {
+            .callback<void, ConnectionException>((res) => {
               client.hset(key, field, value, (err) =>
                 err
-                  ? res(new ConnectionException(err))
+                  ? res(Effect.fail(new ConnectionException(err)))
                   : res(Effect.sync(() => void 0)))
             })
             .pipe(Effect.uninterruptible)
@@ -50,22 +50,22 @@ export const makeRedisClient = (makeClient: () => Client) =>
 
         function hget(key: string, field: string) {
           return Effect
-            .async<Option.Option<string>, ConnectionException>((res) => {
+            .callback<Option.Option<string>, ConnectionException>((res) => {
               client.hget(key, field, (err, v) =>
                 err
-                  ? res(new ConnectionException(err))
-                  : res(Effect.sync(() => Option.fromNullable(v))))
+                  ? res(Effect.fail(new ConnectionException(err)))
+                  : res(Effect.sync(() => Option.fromNullishOr(v))))
             })
             .pipe(Effect.uninterruptible)
         }
         function hmgetAll(key: string) {
           return Effect
-            .async<Option.Option<{ [key: string]: string }>, ConnectionException>(
+            .callback<Option.Option<{ [key: string]: string }>, ConnectionException>(
               (res) => {
                 client.hgetall(key, (err, v) =>
                   err
-                    ? res(new ConnectionException(err))
-                    : res(Effect.sync(() => Option.fromNullable(v))))
+                    ? res(Effect.fail(new ConnectionException(err)))
+                    : res(Effect.sync(() => Option.fromNullishOr(v))))
               }
             )
             .pipe(Effect.uninterruptible)
@@ -84,18 +84,24 @@ export const makeRedisClient = (makeClient: () => Client) =>
       }),
     (cl) =>
       Effect
-        .async<void, Error>((res) => {
+        .callback<void, Error>((res) => {
           cl.client.quit((err) => res(err ? Effect.fail(err) : Effect.void))
         })
         .pipe(Effect.uninterruptible, Effect.orDie)
   )
 
-export interface RedisClient extends Effect.Effect.Success<ReturnType<typeof makeRedisClient>> {}
-
-export const RedisClient = Context.GenericTag<RedisClient>("@services/RedisClient")
+export class RedisClient extends ServiceMap.Service<RedisClient, {
+  readonly client: Client
+  readonly lock: Redlock
+  readonly get: (key: string) => Effect.Effect<Option.Option<string>, ConnectionException>
+  readonly hget: (key: string, field: string) => Effect.Effect<Option.Option<string>, ConnectionException>
+  readonly hset: (key: string, field: string, value: string) => Effect.Effect<void, ConnectionException>
+  readonly hmgetAll: (key: string) => Effect.Effect<Option.Option<{ [key: string]: string }>, ConnectionException>
+  readonly set: (key: string, val: string) => Effect.Effect<void, ConnectionException>
+}>()("@services/RedisClient") {}
 
 export const RedisClientLayer = (storageUrl: string) =>
-  Layer.scoped(RedisClient, makeRedisClient(makeRedis(storageUrl)))
+  Layer.effect(RedisClient, makeRedisClient(makeRedis(storageUrl)))
 
 function createClient(makeClient: () => Client) {
   const client = makeClient()

package/src/api/ContextProvider.ts

@@ -1,25 +1,15 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Context, Effect, Layer, type NonEmptyReadonlyArray, pipe, type Scope } from "effect-app"
+import { Effect, Layer, type NonEmptyReadonlyArray, pipe, type Scope, ServiceMap } from "effect-app"
 
-import { type HttpLayerRouter } from "effect-app/http"
+import { type HttpRouter } from "effect-app/http"
 import { type EffectGenUtils } from "effect-app/utils/gen"
-import { type Tag } from "effect/Context"
-import { type YieldWrap } from "effect/Utils"
+import { type Yieldable } from "effect/Effect"
 import { type ContextTagWithDefault, type GetContext, type LayerUtils, mergeContexts } from "./layerUtils.js"
 
-// // the context provider provides additional stuff
-// export type ContextProviderShape<ContextProviderA, ContextProviderR> = Effect.Effect<
-//   Context.Context<ContextProviderA>,
-//   never, // no errors are allowed
-//   ContextProviderR
-// >
-
 export interface ContextProviderId {
   _tag: "ContextProvider"
 }
 
-//  ContextTagWithDefault.Base<Effect.Effect<Context.Context<infer _1>, never, infer _R> & { _tag: infer _2 }>
-
 /**
  * TDeps is an array of services with Default implementation
  * each service is an effect which builds some context for each request
@@ -33,25 +23,22 @@ 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<Context.Context<infer _1>, never, infer _R> & { _tag: infer _2 }>
-  ) ? [_R] extends [HttpLayerRouter.Provided] ? TDeps[K]
+  ContextTagWithDefault.Base<Effect.Effect<ServiceMap.ServiceMap<infer _1>, never, infer _R>> // & { _tag: infer _2 }>
+    ? [_R] extends [HttpRouter.Provided] ? TDeps[K]
     : `HttpLayerRouter.Provided is the only requirement ${TDeps[K]["Service"][
       "_tag"
     ]}'s returned effect can have`
     : TDeps[K] extends (
       ContextTagWithDefault.Base<
-        & (() => Generator<
+        (() => Generator<
           infer _YW,
           infer _1,
           infer _2
         >)
-        & { _tag: infer _3 }
-      >
+      > // & { _tag: infer _3 }
     ) // [_YW] extends [never] if no yield* is used and just some context is returned
       ? [_YW] extends [never] ? TDeps[K]
-      : [_YW] extends [YieldWrap<Effect.Effect<infer _2, never, infer _R>>]
-        ? [_R] extends [HttpLayerRouter.Provided] ? TDeps[K]
+      : [_YW] extends [Yieldable<any, infer _2, never, infer _R>] ? [_R] extends [HttpRouter.Provided] ? TDeps[K]
         : `HttpLayerRouter.Provided is the only requirement ${TDeps[K]["Service"][
           "_tag"
         ]}'s returned effect can have`
@@ -70,9 +57,10 @@ export const mergeContextProviders = <
   effect: Effect.Effect<
     Effect.Effect<
       // we need to merge all contexts into one
-      Context.Context<GetContext<EffectGenUtils.Success<Tag.Identifier<TDeps[number]>>>>,
+      // v4: Service.Shape extracts the service value type (v3's Tag.Identifier)
+      ServiceMap.ServiceMap<GetContext<EffectGenUtils.Success<ServiceMap.Service.Shape<TDeps[number]>>>>,
       never,
-      EffectGenUtils.Context<Tag.Identifier<TDeps[number]>>
+      EffectGenUtils.ServiceMap<ServiceMap.Service.Shape<TDeps[number]>>
     >,
     LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
@@ -90,26 +78,26 @@ export const mergeContextProviders = <
             handle: handle[Symbol.toStringTag] === "GeneratorFunction" ? Effect.fnUntraced(handle)() : handle
           }
         ))
-        // services are effects which return some Context.Context<...>
+        // services are effects which return some ServiceMap.ServiceMap<...>
         const context = yield* mergeContexts(services as any)
         return context
       })
   }) as any
 })
 
-// Effect Rpc Middleware: for single tag providing, we could use Provides, for providing Context or Layer (bad boy) we could use Wrap..
+// Effect Rpc Middleware: for single tag providing, we could use Provides, for providing ServiceMap or Layer (bad boy) we could use Wrap..
 export const ContextProvider = <
   ContextProviderA,
   MakeContextProviderE,
   MakeContextProviderR,
   ContextProviderR extends Scope.Scope,
-  Dependencies extends NonEmptyReadonlyArray<Layer.Layer.Any>
+  Dependencies extends NonEmptyReadonlyArray<Layer.Any>
 >(
   input: {
     effect: Effect.Effect<
       | Effect.Effect<ContextProviderA, never, ContextProviderR>
       | (() => Generator<
-        YieldWrap<Effect.Effect<any, never, ContextProviderR>>,
+        Yieldable<any, any, never, ContextProviderR>,
         ContextProviderA,
         any
       >),
@@ -119,7 +107,7 @@ export const ContextProvider = <
     dependencies?: Dependencies
   }
 ) => {
-  const ctx = Context.GenericTag<
+  const ctx = ServiceMap.Service<
     ContextProviderId,
     Effect.Effect<ContextProviderA, never, ContextProviderR>
   >(
@@ -128,10 +116,10 @@ export const ContextProvider = <
   const e = input.effect.pipe(
     Effect.map((eg) => (eg as any)[Symbol.toStringTag] === "GeneratorFunction" ? Effect.fnUntraced(eg as any)() : eg)
   )
-  const l = Layer.scoped(ctx, e as any)
+  const l = Layer.effect(ctx, e as any)
   return Object.assign(ctx, {
     Default: l.pipe(
-      input.dependencies ? Layer.provide(input.dependencies) as any : (_) => _
+      input.dependencies ? Layer.provide([...input.dependencies] as [Layer.Any, ...Layer.Any[]]) as any : (_: any) => _
     ) satisfies Layer.Layer<
       ContextProviderId,
       | MakeContextProviderE
@@ -157,16 +145,18 @@ export const MergedContextProvider = <
     ContextProviderId,
     Effect.Effect<
       // we need to merge all contexts into one
-      Context.Context<GetContext<EffectGenUtils.Success<Tag.Identifier<TDeps[number]>>>>,
+      // v4: Service.Shape extracts the service value type (v3's Tag.Identifier)
+      ServiceMap.ServiceMap<GetContext<EffectGenUtils.Success<ServiceMap.Service.Shape<TDeps[number]>>>>,
       never,
-      EffectGenUtils.Context<Tag.Identifier<TDeps[number]>>
+      EffectGenUtils.ServiceMap<ServiceMap.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<
-      Tag.Identifier<TDeps[number]>,
+      ServiceMap.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(Context.empty())) })
+export const EmptyContextProvider = ContextProvider({ effect: Effect.succeed(Effect.succeed(ServiceMap.empty())) })

package/src/api/codec.ts

@@ -4,6 +4,6 @@ export function makeCodec<
   From,
   To extends { id: Id },
   Id
->(self: S.Schema<To, From>) {
+>(self: S.Codec<To, From>) {
   return [S.decodeSync(self), S.encodeSync(self)] as const
 }

package/src/api/internal/auth.ts

@@ -12,28 +12,28 @@ type Config = Parameters<typeof auth>[0]
 export const checkJWTI = (config: Config) => {
   const mw = auth(config)
   return Effect.fnUntraced(function*(headers: HttpHeaders.Headers) {
-    return yield* Effect.async<
+    return yield* Effect.callback<
       void,
       InsufficientScopeError | InvalidRequestError | InvalidTokenError | UnauthorizedError
     >(
-      (cb) => {
+      (resume) => {
         const next = (err?: unknown) => {
-          if (!err) return cb(Effect.void)
+          if (!err) return resume(Effect.void)
           if (
             err instanceof InsufficientScopeError
             || err instanceof InvalidRequestError
             || err instanceof InvalidTokenError
             || err instanceof UnauthorizedError
           ) {
-            return cb(Effect.fail(err))
+            return resume(Effect.fail(err))
           }
-          return cb(Effect.die(err))
+          return resume(Effect.die(err))
         }
         const r = { headers, query: {}, body: {}, is: () => false, method: "POST" } // is("urlencoded")
         try {
           mw(r as any, {} as any, next)
         } catch (e) {
-          return cb(Effect.die(e))
+          return resume(Effect.die(e))
         }
       }
     )
@@ -45,13 +45,11 @@ export const checkJwt = (config: Config) => {
   return HttpMiddleware.make((app) =>
     Effect.gen(function*() {
       const req = yield* HttpServerRequest.HttpServerRequest
-      const response = yield* check(req.headers).pipe(Effect.catchAll((e) =>
-        Effect.succeed(
-          HttpServerResponse.unsafeJson({ message: e.message }, {
-            status: e.status,
-            headers: HttpHeaders.fromInput(e.headers)
-          })
-        )
+      const response = yield* check(req.headers).pipe(Effect.catch((e) =>
+        HttpServerResponse.json({ message: e.message }, {
+          status: e.status,
+          headers: HttpHeaders.fromInput(e.headers)
+        })
       ))
       if (response) {
         return response

package/src/api/internal/events.ts

@@ -5,18 +5,18 @@ import { setupRequestContextFromCurrent } from "../setupRequest.js"
 
 // Tell the client to retry every 10 seconds if connectivity is lost
 const setRetry = Stream.succeed("retry: 10000")
-const keepAlive = Stream.repeat(Effect.succeed(":keep-alive"), Schedule.fixed(Duration.seconds(15)))
+const keepAlive = Stream.fromEffectSchedule(Effect.succeed(":keep-alive"), Schedule.fixed(Duration.seconds(15)))
 
 let connId = BigInt(0)
 
 export const makeSSE = <A extends { id: any }, SI, SR>(
-  schema: S.Schema<A, SI, SR>
+  schema: S.Codec<A, SI, SR>
 ) =>
 <E, R>(events: Stream.Stream<{ evt: A; namespace: string }, E, R>) =>
   Effect
     .gen(function*() {
       const id = connId++
-      const ctx = yield* Effect.context<R | SR>()
+      const ctx = yield* Effect.services<R | SR>()
       const res = HttpServerResponse.stream(
         // workaround for different scoped behaviour for streams in Bun
         // https://discord.com/channels/795981131316985866/1098177242598756412/1389646879675125861
@@ -28,29 +28,29 @@ export const makeSSE = <A extends { id: any }, SI, SR>(
 
             const enc = new TextEncoder()
 
-            const encode = S.encode(schema)
+            const encode = S.encodeEffect(schema)
 
-            const eventStream = Stream.flatMap(
+            const eventStream = Stream.mapEffect(
               events,
               (_) =>
                 encode(_.evt)
-                  .pipe(Effect.andThen((evt) => `id: ${_.evt.id}\ndata: ${JSON.stringify(evt)}`))
+                  .pipe(Effect.map((evt) => `id: ${_.evt.id}\ndata: ${JSON.stringify(evt)}`))
             )
 
             const stream = pipe(
               setRetry,
               Stream.merge(keepAlive),
               Stream.merge(eventStream, { haltStrategy: "either" }),
-              Stream.tapErrorCause((cause) => Effect.logError("SSE error", cause)),
+              Stream.tapCause((cause) => Effect.logError("SSE error", cause)),
               Stream.map((_) => enc.encode(_ + "\n\n"))
             )
 
             return stream
           })
           .pipe(
-            Stream.unwrapScoped,
-            Stream.tapErrorCause(reportError("Request")),
-            Stream.provideContext(ctx)
+            Stream.unwrap,
+            Stream.tapCause(reportError("Request")),
+            Stream.provide(ctx)
           ),
         {
           contentType: "text/event-stream",
@@ -64,4 +64,4 @@ export const makeSSE = <A extends { id: any }, SI, SR>(
       )
       return res
     })
-    .pipe(Effect.tapErrorCause(reportError("Request")), setupRequestContextFromCurrent("events"))
+    .pipe(Effect.tapCause(reportError("Request")), setupRequestContextFromCurrent("events"))

package/src/api/internal/health.ts

@@ -1,5 +1,5 @@
 import { HttpMiddleware, HttpServerResponse } from "effect-app/http"
 
 export function serverHealth(version: string) {
-  return HttpServerResponse.unsafeJson({ version }).pipe(HttpMiddleware.withLoggerDisabled)
+  return HttpServerResponse.json({ version }).pipe(HttpMiddleware.withLoggerDisabled)
 }

package/src/api/layerUtils.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Context, Effect, type Layer, type NonEmptyReadonlyArray, Option } from "effect-app"
+import { Effect, type Layer, type NonEmptyReadonlyArray, Option, ServiceMap } 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
@@ -7,27 +7,27 @@ import { InfraLogger } from "../logger.js"
 // and in general make sure `dependencies` are NonEmptyReadonlyArrays, so they infer to consts.
 
 export namespace LayerUtils {
-  export type GetLayersSuccess<Layers extends ReadonlyArray<Layer.Layer.Any>> = Layers extends
-    NonEmptyReadonlyArray<Layer.Layer.Any> ? {
-      [k in keyof Layers]: Layer.Layer.Success<Layers[k]>
+  export type GetLayersSuccess<Layers extends ReadonlyArray<Layer.Any>> = Layers extends
+    NonEmptyReadonlyArray<Layer.Any> ? {
+      [k in keyof Layers]: Layer.Success<Layers[k]>
     }[number]
-    : Layer.Layer.Success<Layers[number]>
+    : Layer.Success<Layers[number]>
 
-  export type GetLayersContext<Layers extends ReadonlyArray<Layer.Layer.Any>> = Layers extends
-    NonEmptyReadonlyArray<Layer.Layer.Any> ? {
-      [k in keyof Layers]: Layer.Layer.Context<Layers[k]>
+  export type GetLayersContext<Layers extends ReadonlyArray<Layer.Any>> = Layers extends
+    NonEmptyReadonlyArray<Layer.Any> ? {
+      [k in keyof Layers]: Layer.Services<Layers[k]>
     }[number]
-    : Layer.Layer.Context<Layers[number]>
+    : Layer.Services<Layers[number]>
 
-  export type GetLayersError<Layers extends ReadonlyArray<Layer.Layer.Any>> = Layers extends
-    NonEmptyReadonlyArray<Layer.Layer.Any> ? {
-      [k in keyof Layers]: Layer.Layer.Error<Layers[k]>
+  export type GetLayersError<Layers extends ReadonlyArray<Layer.Any>> = Layers extends NonEmptyReadonlyArray<Layer.Any>
+    ? {
+      [k in keyof Layers]: Layer.Error<Layers[k]>
     }[number]
-    : Layer.Layer.Error<Layers[number]>
+    : Layer.Error<Layers[number]>
 }
 
 export type ContextTagWithDefault<Id, A, LayerE, LayerR> =
-  & Context.Tag<Id, A>
+  & ServiceMap.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 Context.Context<infer Y> ? Y : never
+export type GetContext<T> = T extends ServiceMap.ServiceMap<infer Y> ? Y : never
 
 export const mergeContexts = Effect.fnUntraced(
   function*<
     T extends readonly {
       maker: any
-      handle: Effect.Effect<Context.Context<any> | Option.Option<Context.Context<any>>>
+      handle: Effect.Effect<ServiceMap.ServiceMap<any> | Option.Option<ServiceMap.ServiceMap<any>>>
     }[]
   >(
     makers: T
   ) {
-    let context = Context.empty()
+    let context = ServiceMap.empty()
     for (const mw of makers) {
       const ctx = yield* mw.handle.pipe(Effect.provide(context))
-      const moreContext = Context.isContext(ctx) ? Option.some(ctx) : ctx
+      const moreContext = ServiceMap.isServiceMap(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 = Context.merge(context, moreContext.value)
+        context = ServiceMap.merge(context, moreContext.value)
       }
     }
-    return context as Context.Context<Effect.Effect.Success<T[number]["handle"]>>
+    return context as ServiceMap.ServiceMap<Effect.Success<T[number]["handle"]>>
   }
 )