@effect-app/vue 2.94.0 → 4.0.0-beta.1

package/src/mutate.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as Result from "@effect-atom/atom/Result"
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { type InvalidateOptions, type InvalidateQueryFilters, type QueryClient, useQueryClient } from "@tanstack/vue-query"
 import { type Cause, Effect, type Exit, Option } from "effect-app"
 import { type Req } from "effect-app/client"
@@ -19,7 +19,7 @@ export const getQueryKey = (h: { id: string; options?: ClientForOptions }) => {
 }
 
 export function mutationResultToVue<A, E>(
-  mutationResult: Result.Result<A, E>
+  mutationResult: AsyncResult.AsyncResult<A, E>
 ): Res<A, E> {
   switch (mutationResult._tag) {
     case "Initial": {
@@ -49,20 +49,20 @@ export interface Res<A, E> {
 }
 
 export function make<A, E, R>(self: Effect.Effect<A, E, R>) {
-  const result = shallowRef(Result.initial() as Result.Result<A, E>)
+  const result = shallowRef(AsyncResult.initial() as AsyncResult.AsyncResult<A, E>)
 
   const execute = Effect
     .sync(() => {
-      result.value = Result.waiting(result.value)
+      result.value = AsyncResult.waiting(result.value)
     })
     .pipe(
       Effect.andThen(self),
       Effect.exit,
-      Effect.andThen(Result.fromExit),
+      Effect.map(AsyncResult.fromExit),
       Effect.flatMap((r) => Effect.sync(() => result.value = r))
     )
 
-  const latestSuccess = computed(() => Option.getOrUndefined(Result.value(result.value)))
+  const latestSuccess = computed(() => Option.getOrUndefined(AsyncResult.value(result.value)))
 
   return tuple(result, latestSuccess, execute)
 }
@@ -103,38 +103,38 @@ export interface MutationOptions<A, E, R, A2 = A, E2 = E, R2 = R, I = void> exte
 export const asResult: {
   <A, E, R>(
     handler: Effect.Effect<A, E, R>
-  ): readonly [ComputedRef<Result.Result<A, E>>, Effect.Effect<Exit.Exit<A, E>, never, R>]
+  ): readonly [ComputedRef<AsyncResult.AsyncResult<A, E>>, Effect.Effect<Exit.Exit<A, E>, never, R>]
   <Args extends readonly any[], A, E, R>(
     handler: (...args: Args) => Effect.Effect<A, E, R>
-  ): readonly [ComputedRef<Result.Result<A, E>>, (...args: Args) => Effect.Effect<Exit.Exit<A, E>, never, R>]
+  ): readonly [ComputedRef<AsyncResult.AsyncResult<A, E>>, (...args: Args) => Effect.Effect<Exit.Exit<A, E>, never, R>]
 } = <Args extends readonly any[], A, E, R>(
   handler: Effect.Effect<A, E, R> | ((...args: Args) => Effect.Effect<A, E, R>)
 ) => {
-  const state = shallowRef<Result.Result<A, E>>(Result.initial())
+  const state = shallowRef<AsyncResult.AsyncResult<A, E>>(AsyncResult.initial())
 
   const act = Effect.isEffect(handler)
     ? Effect
       .sync(() => {
-        state.value = Result.initial(true)
+        state.value = AsyncResult.initial(true)
       })
       .pipe(
-        Effect.zipRight(Effect.suspend(() =>
+        Effect.andThen(Effect.suspend(() =>
           handler.pipe(
             Effect.exit,
-            Effect.tap((exit) => Effect.sync(() => (state.value = Result.fromExit(exit))))
+            Effect.tap((exit) => Effect.sync(() => (state.value = AsyncResult.fromExit(exit))))
           )
         ))
       )
     : (...args: Args) =>
       Effect
         .sync(() => {
-          state.value = Result.initial(true)
+          state.value = AsyncResult.initial(true)
         })
         .pipe(
-          Effect.zipRight(Effect.suspend(() =>
+          Effect.andThen(Effect.suspend(() =>
             handler(...args).pipe(
               Effect.exit,
-              Effect.tap((exit) => Effect.sync(() => (state.value = Result.fromExit(exit))))
+              Effect.tap((exit) => Effect.sync(() => (state.value = AsyncResult.fromExit(exit))))
             )
           ))
         )
@@ -171,7 +171,7 @@ export const invalidateQueries = (
           Effect.annotateCurrentSpan({ queryKey, opts }),
           Effect.forEach(opts, (_) => invalidateQueries(_.filters, _.options), { concurrency: "inherit" })
         )
-        .pipe(Effect.withSpan("client.query.invalidation", { captureStackTrace: false }))
+        .pipe(Effect.withSpan("client.query.invalidation", {}, { captureStackTrace: false }))
     }
 
     if (!queryKey) return Effect.void
@@ -187,12 +187,11 @@ export const invalidateQueries = (
           // TODO: should we do this in general on any mutation, regardless of invalidation?
           Effect.sleep(0)
         ),
-        Effect.withSpan("client.query.invalidation", { captureStackTrace: false })
+        Effect.withSpan("client.query.invalidation", {}, { captureStackTrace: false })
       )
   })
 
-  const handle = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    Effect.tapBoth(self, { onFailure: () => invalidateCache, onSuccess: () => invalidateCache })
+  const handle = <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.ensuring(self, invalidateCache)
 
   return handle
 }

package/src/query.ts

@@ -2,14 +2,14 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import * as Result from "@effect-atom/atom/Result"
-import { isHttpClientError } from "@effect/platform/HttpClientError"
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { type DefaultError, type Enabled, type InitialDataFunction, type NonUndefinedGuard, type PlaceholderDataFunction, type QueryKey, type QueryObserverOptions, type QueryObserverResult, type RefetchOptions, useQuery as useTanstackQuery, useQueryClient, type UseQueryDefinedReturnType, type UseQueryReturnType } from "@tanstack/vue-query"
-import { Array, Cause, Effect, Option, Runtime, S } from "effect-app"
+import { Array, Cause, Effect, Exit, flow, Option, S, type ServiceMap } from "effect-app"
 import { type Req } from "effect-app/client"
 import type { RequestHandler, RequestHandlerWithInput } from "effect-app/client/clientFor"
 import { ServiceUnavailableError } from "effect-app/client/errors"
 import { type Span } from "effect/Tracer"
+import { isHttpClientError } from "effect/unstable/http/HttpClientError"
 import { computed, type ComputedRef, type MaybeRefOrGetter, ref, shallowRef, watch, type WatchSource } from "vue"
 import { makeQueryKey, reportRuntimeError } from "./lib.js"
 
@@ -74,11 +74,15 @@ export interface CustomDefinedPlaceholderQueryOptions<
     | PlaceholderDataFunction<NonFunctionGuard<TQueryData>, TError, NonFunctionGuard<TQueryData>, TQueryKey>
 }
 
-export interface KnownFiberFailure<E> extends Runtime.FiberFailure {
-  readonly [Runtime.FiberFailureCauseId]: Cause.Cause<E>
+export class KnownFiberFailure<E> extends Error {
+  readonly error: unknown
+  constructor(public effectCause: Cause.Cause<E>) {
+    super("Query failed with cause: " + Cause.squash(effectCause))
+    this.error = Cause.squash(effectCause)
+  }
 }
 
-export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
+export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
   const useQuery_: {
     <I, A, E, Request extends Req, Name extends string>(
       q:
@@ -89,7 +93,7 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
         arg: I | WatchSource<I> | undefined,
         options?: CustomUndefinedInitialQueryOptions<A, E, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData | undefined>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>, never, never>,
         UseQueryDefinedReturnType<TData, KnownFiberFailure<E>>
@@ -99,7 +103,7 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
         arg: I | WatchSource<I> | undefined,
         options: CustomDefinedInitialQueryOptions<A, E, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>, never, never>,
         UseQueryDefinedReturnType<TData, KnownFiberFailure<E>>
@@ -109,7 +113,7 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
         arg: I | WatchSource<I> | undefined,
         options: CustomDefinedPlaceholderQueryOptions<A, E, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>, never, never>,
         UseQueryDefinedReturnType<TData, KnownFiberFailure<E>>
@@ -126,7 +130,14 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
     options?: any
     // TODO
   ) => {
-    const runPromise = Runtime.runPromise(getRuntime())
+    // we wrap into KnownFiberFailure because we want to keep the full cause of the failure.
+    const runPromise = flow(Effect.runPromiseExitWith(getRuntime()), (_) =>
+      _.then(
+        Exit.match({
+          onFailure: (cause) => Promise.reject(new KnownFiberFailure(cause)),
+          onSuccess: (value) => Promise.resolve(value)
+        })
+      ))
     const arr = arg
     const req: { value: I } = !arg
       ? undefined
@@ -145,10 +156,8 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
         ? {
           ...options,
           retry: (retryCount, error) => {
-            if (Runtime.isFiberFailure(error)) {
-              const cause = error[Runtime.FiberFailureCauseId]
-              const sq = Cause.squash(cause)
-              if (!isHttpClientError(sq) && !S.is(ServiceUnavailableError)(sq)) {
+            if (error instanceof KnownFiberFailure) {
+              if (!isHttpClientError(error.error) && !S.is(ServiceUnavailableError)(error.error)) {
                 return false
               }
             }
@@ -160,8 +169,8 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
             runPromise(
               handler
                 .pipe(
-                  Effect.tapDefect(reportRuntimeError),
-                  Effect.withSpan(`query ${q.id}`, { captureStackTrace: false }),
+                  Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause)),
+                  Effect.withSpan(`query ${q.id}`, {}, { captureStackTrace: false }),
                   meta?.["span"] ? Effect.withParentSpan(meta["span"] as Span) : (_) => _
                 ),
               { signal }
@@ -170,10 +179,8 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
         : {
           ...options,
           retry: (retryCount, error) => {
-            if (Runtime.isFiberFailure(error)) {
-              const cause = error[Runtime.FiberFailureCauseId]
-              const sq = Cause.squash(cause)
-              if (!isHttpClientError(sq) && !S.is(ServiceUnavailableError)(sq)) {
+            if (error instanceof KnownFiberFailure) {
+              if (!isHttpClientError(error.error) && !S.is(ServiceUnavailableError)(error.error)) {
                 return false
               }
             }
@@ -185,8 +192,8 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
             runPromise(
               handler(req.value)
                 .pipe(
-                  Effect.tapDefect(reportRuntimeError),
-                  Effect.withSpan(`query ${q.id}`, { captureStackTrace: false }),
+                  Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause)),
+                  Effect.withSpan(`query ${q.id}`, {}, { captureStackTrace: false }),
                   meta?.["span"] ? Effect.withParentSpan(meta["span"] as Span) : (_) => _
                 ),
               { signal }
@@ -195,7 +202,7 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
     )
 
     const latestSuccess = shallowRef<TData>()
-    const result = computed((): Result.Result<TData, E> =>
+    const result = computed((): AsyncResult.AsyncResult<TData, E> =>
       swrToQuery({
         error: r.error.value ?? undefined,
         data: r.data.value === undefined ? latestSuccess.value : r.data.value, // we fall back to existing data, as tanstack query might loose it when the key changes
@@ -203,13 +210,13 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
       })
     )
     // not using `computed` here as we have a circular dependency
-    watch(result, (value) => latestSuccess.value = Option.getOrUndefined(Result.value(value)), { immediate: true })
+    watch(result, (value) => latestSuccess.value = Option.getOrUndefined(AsyncResult.value(value)), { immediate: true })
 
     return [
       result,
       computed(() => latestSuccess.value),
       // one thing to keep in mind is that span will be disconnected as Context does not pass from outside.
-      // TODO: consider how we should handle the Result here which is `QueryObserverResult<A, KnownFiberFailure<E>>`
+      // TODO: consider how we should handle the Result here which is `QueryObserverResult<A, E>`
       // and always ends up in the success channel, even when error..
       (options?: RefetchOptions) =>
         Effect.currentSpan.pipe(
@@ -224,21 +231,21 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
     error: KnownFiberFailure<E> | undefined
     data: A | undefined
     isValidating: boolean
-  }): Result.Result<A, E> {
-    if (r.error) {
-      return Result.failureWithPrevious(
-        r.error[Runtime.FiberFailureCauseId],
+  }): AsyncResult.AsyncResult<A, E> {
+    if (r.error !== undefined) {
+      return AsyncResult.failureWithPrevious(
+        r.error.effectCause,
         {
-          previous: r.data === undefined ? Option.none() : Option.some(Result.success(r.data)),
+          previous: r.data === undefined ? Option.none() : Option.some(AsyncResult.success(r.data)),
           waiting: r.isValidating
         }
       )
     }
     if (r.data !== undefined) {
-      return Result.success<A, E>(r.data, { waiting: r.isValidating })
+      return AsyncResult.success<A, E>(r.data, { waiting: r.isValidating })
     }
 
-    return Result.initial(r.isValidating)
+    return AsyncResult.initial(r.isValidating)
   }
 
   const useQuery: {
@@ -256,7 +263,7 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
       <TData = A>(
         options: CustomDefinedInitialQueryOptions<A, KnownFiberFailure<E>, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
         UseQueryReturnType<any, any>
@@ -264,7 +271,7 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
       <TData = A>(
         options: CustomDefinedPlaceholderQueryOptions<A, E, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>, never, never>,
         UseQueryDefinedReturnType<TData, KnownFiberFailure<E>>
@@ -274,7 +281,7 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
        * Effect results are passed to the caller, including errors.
        */
       <TData = A>(options?: CustomUndefinedInitialQueryOptions<A, KnownFiberFailure<E>, TData>): readonly [
-        ComputedRef<Result.Result<A, E>>,
+        ComputedRef<AsyncResult.AsyncResult<A, E>>,
         ComputedRef<A | undefined>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
         UseQueryReturnType<any, any>
@@ -295,7 +302,7 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
         arg: Arg | WatchSource<Arg>,
         options: CustomDefinedInitialQueryOptions<A, KnownFiberFailure<E>, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
         UseQueryReturnType<any, any>
@@ -308,7 +315,7 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
         arg: Arg | WatchSource<Arg>,
         options: CustomDefinedPlaceholderQueryOptions<A, KnownFiberFailure<E>, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
         UseQueryReturnType<any, any>
@@ -321,7 +328,7 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
         arg: Arg | WatchSource<Arg>,
         options?: CustomUndefinedInitialQueryOptions<A, KnownFiberFailure<E>, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData | undefined>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
         UseQueryReturnType<any, any>
@@ -343,31 +350,31 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface MakeQuery2<R> extends ReturnType<typeof makeQuery<R>> {}
 
-function orPrevious<E, A>(result: Result.Result<A, E>) {
-  return Result.isFailure(result) && Option.isSome(result.previousSuccess)
-    ? Result.success(result.previousSuccess.value, { waiting: result.waiting })
+function orPrevious<E, A>(result: AsyncResult.AsyncResult<A, E>) {
+  return AsyncResult.isFailure(result) && Option.isSome(result.previousSuccess)
+    ? AsyncResult.success(result.previousSuccess.value, { waiting: result.waiting })
     : result
 }
 
 export function composeQueries<
-  R extends Record<string, Result.Result<any, any>>
+  R extends Record<string, AsyncResult.AsyncResult<any, any>>
 >(
   results: R,
   renderPreviousOnFailure?: boolean
-): Result.Result<
+): AsyncResult.AsyncResult<
   {
-    [Property in keyof R]: R[Property] extends Result.Result<infer A, any> ? A
+    [Property in keyof R]: R[Property] extends AsyncResult.AsyncResult<infer A, any> ? A
       : never
   },
   {
-    [Property in keyof R]: R[Property] extends Result.Result<any, infer E> ? E
+    [Property in keyof R]: R[Property] extends AsyncResult.AsyncResult<any, infer E> ? E
       : never
   }[keyof R]
 > {
   const values = renderPreviousOnFailure
     ? Object.values(results).map(orPrevious)
     : Object.values(results)
-  const error = values.find(Result.isFailure)
+  const error = values.find(AsyncResult.isFailure)
   if (error) {
     return error
   }
@@ -375,7 +382,7 @@ export function composeQueries<
   if (initial.value !== undefined) {
     return initial.value
   }
-  const loading = Array.findFirst(values, (x) => Result.isInitial(x) && x.waiting ? Option.some(x) : Option.none())
+  const loading = Array.findFirst(values, (x) => AsyncResult.isInitial(x) && x.waiting ? Option.some(x) : Option.none())
   if (loading.value !== undefined) {
     return loading.value
   }
@@ -383,10 +390,10 @@ export function composeQueries<
   const isRefreshing = values.some((x) => x.waiting)
 
   const r = Object.entries(results).reduce((prev, [key, value]) => {
-    prev[key] = Result.value(value).value
+    prev[key] = AsyncResult.value(value).value
     return prev
   }, {} as any)
-  return Result.success(r, { waiting: isRefreshing })
+  return AsyncResult.success(r, { waiting: isRefreshing })
 }
 
 export const useUpdateQuery = () => {

package/src/routeParams.ts

@@ -12,34 +12,18 @@ export function getQueryParam(search: ParsedQuery, param: string) {
   return v ?? null
 }
 
-export const getQueryParamO = flow(getQueryParam, Option.fromNullable)
+export const getQueryParamO = flow(getQueryParam, Option.fromNullishOr)
 
-export const parseOpt = <E, A>(t: S.Schema<A, E, never>) => {
-  const dec = flow(S.decodeUnknownEither(t), (x) =>
-    x._tag === "Right"
-      ? Option.some(x.right)
-      : Option.none())
-  return dec
-}
-
-export const parseOptUnknown = <E, A>(t: S.Schema<A, E, never>) => {
-  const dec = flow(S.decodeUnknownEither(t), (x) =>
-    x._tag === "Right"
-      ? Option.some(x.right)
-      : Option.none())
-  return dec
-}
-
-export function parseRouteParamsOption<NER extends Record<string, Schema<any, any, never>>>(
-  query: Record<string, any>,
-  t: NER // enforce non empty
+export function parseRouteParamsOption<NER extends Record<string, S.Codec<any, any>>>(query: Record<string, any>, t: NER // enforce non empty
 ): {
   [K in keyof NER]: Option.Option<Schema.Type<NER[K]>>
 } {
   return typedKeysOf(t).reduce(
     (prev, cur) => {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      prev[cur] = getQueryParamO(query, cur as string).pipe(Option.flatMap(parseOpt(t[cur]!)))
+      prev[cur] = getQueryParamO(query, cur as string).pipe(
+        Option.flatMap(S.decodeUnknownOption(t[cur]!))
+      )
 
       return prev
     },
@@ -49,7 +33,7 @@ export function parseRouteParamsOption<NER extends Record<string, Schema<any, an
   )
 }
 
-export function parseRouteParams<NER extends Record<string, Schema<any, any, never>>>(
+export function parseRouteParams<NER extends Record<string, S.Codec<any, any>>>(
   query: Record<string, any>,
   t: NER // enforce non empty
 ): {
@@ -58,7 +42,9 @@ export function parseRouteParams<NER extends Record<string, Schema<any, any, nev
   return typedKeysOf(t).reduce(
     (prev, cur) => {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      prev[cur] = S.decodeUnknownSync(t[cur]!)((query as any)[cur])
+      prev[cur] = S.decodeUnknownSync(t[cur]!)(
+        (query as any)[cur]
+      )
 
       return prev
     },

package/src/runtime.ts

@@ -3,12 +3,12 @@ import { Effect, Layer, Logger } from "effect-app"
 
 export function makeAppRuntime<A, E>(layer: Layer.Layer<A, E>) {
   return Effect.gen(function*() {
-    layer = layer.pipe(
-      Layer.provide(Logger.replace(Logger.defaultLogger, Logger.withSpanAnnotations(Logger.prettyLogger())))
-    )
-    const mrt = ManagedRuntime.make(layer)
-    yield* mrt.runtimeEffect
-    return Object.assign(mrt as ManagedRuntime.ManagedRuntime<A, never>, {
+    const l = layer.pipe(
+      Layer.provide(Logger.layer([Logger.consolePretty()]))
+    ) as Layer.Layer<A, never>
+    const mrt = ManagedRuntime.make(l)
+    yield* mrt.servicesEffect
+    return Object.assign(mrt, {
       [Symbol.dispose]() {
         return Effect.runSync(mrt.disposeEffect)
       },