@effect-app/vue 1.22.5 → 1.23.0

package/src/mutate.ts

@@ -1,17 +1,15 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { tuple } from "@effect-app/core/Function"
 import * as Result from "@effect-rx/rx/Result"
-import type * as HttpClient from "@effect/platform/HttpClient"
 import type { InvalidateOptions, InvalidateQueryFilters } from "@tanstack/vue-query"
 import { useQueryClient } from "@tanstack/vue-query"
-import { Cause, Effect, Exit, Option } from "effect-app"
-import type { ApiConfig } from "effect-app/client"
+import { Cause, Effect, Exit, Option, Runtime } from "effect-app"
 import { dropUndefinedT } from "effect-app/utils"
 import { InterruptedException } from "effect/Cause"
 import * as Either from "effect/Either"
 import type { ComputedRef, Ref } from "vue"
 import { computed, ref, shallowRef } from "vue"
-import { makeQueryKey, reportRuntimeError, run } from "./internal.js"
+import { makeQueryKey, reportRuntimeError } from "./internal.js"
 
 export type WatchSource<T = any> = Ref<T> | ComputedRef<T> | (() => T)
 export function make<A, E, R>(self: Effect<A, E, R>) {
@@ -53,12 +51,6 @@ export interface MutationError<E> {
 
 export type MutationResult<A, E> = MutationInitial | MutationLoading | MutationSuccess<A> | MutationError<E>
 
-type HandlerWithInput<I, A, E> = {
-  handler: (i: I) => Effect<A, E, ApiConfig | HttpClient.HttpClient>
-  name: string
-}
-type Handler<A, E> = { handler: Effect<A, E, ApiConfig | HttpClient.HttpClient>; name: string }
-
 export type MaybeRef<T> = Ref<T> | ComputedRef<T> | T
 type MaybeRefDeep<T> = MaybeRef<
   // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
@@ -97,125 +89,138 @@ export const getQueryKey = (name: string) => {
                 // }
                 */
 
-/**
- * Pass a function that returns an Effect, e.g from a client action, or an Effect
- * Returns a tuple with state ref and execution function which reports errors as Toast.
- */
-export const useSafeMutation: {
-  <I, E, A>(self: HandlerWithInput<I, A, E>, options?: MutationOptions<A, I>): readonly [
-    Readonly<Ref<MutationResult<A, E>>>,
-    (
-      i: I,
-      signal?: AbortSignal
-    ) => Promise<Either.Either<A, E>>
-  ]
-  <E, A>(self: Handler<A, E>, options?: MutationOptions<A>): readonly [
-    Readonly<Ref<MutationResult<A, E>>>,
-    (
-      signal?: AbortSignal
-    ) => Promise<Either.Either<A, E>>
-  ]
-} = <I, E, A>(
-  self: {
-    handler:
-      | HandlerWithInput<I, A, E>["handler"]
-      | Handler<A, E>["handler"]
+export const makeMutation = <R>(runtime: Runtime.Runtime<R>) => {
+  type HandlerWithInput<I, A, E> = {
+    handler: (i: I) => Effect<A, E, R>
     name: string
-  },
-  options?: MutationOptions<A>
-) => {
-  const queryClient = useQueryClient()
-  const state: Ref<MutationResult<A, E>> = ref<MutationResult<A, E>>({ _tag: "Initial" }) as any
-  const onSuccess = options?.onSuccess
-
-  const invalidateQueries = (
-    filters?: MaybeRefDeep<InvalidateQueryFilters>,
-    options?: MaybeRefDeep<InvalidateOptions>
-  ) => Effect.promise(() => queryClient.invalidateQueries(filters, options))
-
-  function handleExit(exit: Exit.Exit<A, E>): Effect<Either.Either<A, E>, never, never> {
-    return Effect.sync(() => {
-      if (Exit.isSuccess(exit)) {
-        state.value = { _tag: "Success", data: exit.value }
-        return Either.right(exit.value)
-      }
+  }
+  type Handler<A, E> = { handler: Effect<A, E, R>; name: string }
+
+  const runPromise = Runtime.runPromise(runtime)
+  /**
+   * Pass a function that returns an Effect, e.g from a client action, or an Effect
+   * Returns a tuple with state ref and execution function which reports errors as Toast.
+   */
+  const useSafeMutation: {
+    <I, E, A>(self: HandlerWithInput<I, A, E>, options?: MutationOptions<A, I>): readonly [
+      Readonly<Ref<MutationResult<A, E>>>,
+      (
+        i: I,
+        signal?: AbortSignal
+      ) => Promise<Either.Either<A, E>>
+    ]
+    <E, A>(self: Handler<A, E>, options?: MutationOptions<A>): readonly [
+      Readonly<Ref<MutationResult<A, E>>>,
+      (
+        signal?: AbortSignal
+      ) => Promise<Either.Either<A, E>>
+    ]
+  } = <I, E, A>(
+    self: {
+      handler:
+        | HandlerWithInput<I, A, E>["handler"]
+        | Handler<A, E>["handler"]
+      name: string
+    },
+    options?: MutationOptions<A>
+  ) => {
+    const queryClient = useQueryClient()
+    const state: Ref<MutationResult<A, E>> = ref<MutationResult<A, E>>({ _tag: "Initial" }) as any
+    const onSuccess = options?.onSuccess
+
+    const invalidateQueries = (
+      filters?: MaybeRefDeep<InvalidateQueryFilters>,
+      options?: MaybeRefDeep<InvalidateOptions>
+    ) => Effect.promise(() => queryClient.invalidateQueries(filters, options))
+
+    function handleExit(exit: Exit.Exit<A, E>): Effect<Either.Either<A, E>, never, never> {
+      return Effect.sync(() => {
+        if (Exit.isSuccess(exit)) {
+          state.value = { _tag: "Success", data: exit.value }
+          return Either.right(exit.value)
+        }
+
+        const err = Cause.failureOption(exit.cause)
+        if (Option.isSome(err)) {
+          state.value = { _tag: "Error", error: err.value }
+          return Either.left(err.value)
+        }
+
+        const died = Cause.dieOption(exit.cause)
+        if (Option.isSome(died)) {
+          throw died.value
+        }
+        const interrupted = Cause.interruptOption(exit.cause)
+        if (Option.isSome(interrupted)) {
+          throw new InterruptedException()
+        }
+        throw new Error("Invalid state")
+      })
+    }
 
-      const err = Cause.failureOption(exit.cause)
-      if (Option.isSome(err)) {
-        state.value = { _tag: "Error", error: err.value }
-        return Either.left(err.value)
+    const exec = (fst?: I | AbortSignal, snd?: AbortSignal) => {
+      let effect: Effect<A, E, R>
+      let signal: AbortSignal | undefined
+      if (Effect.isEffect(self.handler)) {
+        effect = self.handler as any
+        signal = fst as AbortSignal | undefined
+      } else {
+        effect = self.handler(fst as I)
+        signal = snd
       }
 
-      const died = Cause.dieOption(exit.cause)
-      if (Option.isSome(died)) {
-        throw died.value
-      }
-      const interrupted = Cause.interruptOption(exit.cause)
-      if (Option.isSome(interrupted)) {
-        throw new InterruptedException()
-      }
-      throw new Error("Invalid state")
-    })
-  }
+      return runPromise(
+        Effect
+          .sync(() => {
+            state.value = { _tag: "Loading" }
+          })
+          .pipe(
+            Effect.andThen(effect),
+            Effect.tap(() =>
+              Effect
+                .suspend(() => {
+                  const queryKey = getQueryKey(self.name)
+
+                  if (options?.queryInvalidation) {
+                    const opts = options.queryInvalidation(queryKey, self.name)
+                    if (!opts.length) {
+                      return Effect.void
+                    }
+                    return Effect
+                      .andThen(
+                        Effect.annotateCurrentSpan({ queryKey, opts }),
+                        Effect.forEach(opts, (_) => invalidateQueries(_.filters, _.options), { concurrency: "inherit" })
+                      )
+                      .pipe(Effect.withSpan("client.query.invalidation", { captureStackTrace: false }))
+                  }
 
-  const exec = (fst?: I | AbortSignal, snd?: AbortSignal) => {
-    let effect: Effect<A, E, ApiConfig | HttpClient.HttpClient>
-    let signal: AbortSignal | undefined
-    if (Effect.isEffect(self.handler)) {
-      effect = self.handler as any
-      signal = fst as AbortSignal | undefined
-    } else {
-      effect = self.handler(fst as I)
-      signal = snd
-    }
+                  if (!queryKey) return Effect.void
 
-    return run.value(
-      Effect
-        .sync(() => {
-          state.value = { _tag: "Loading" }
-        })
-        .pipe(
-          Effect.andThen(effect),
-          Effect.tap(() =>
-            Effect
-              .suspend(() => {
-                const queryKey = getQueryKey(self.name)
-
-                if (options?.queryInvalidation) {
-                  const opts = options.queryInvalidation(queryKey, self.name)
-                  if (!opts.length) {
-                    return Effect.void
-                  }
                   return Effect
                     .andThen(
-                      Effect.annotateCurrentSpan({ queryKey, opts }),
-                      Effect.forEach(opts, (_) => invalidateQueries(_.filters, _.options), { concurrency: "inherit" })
+                      Effect.annotateCurrentSpan({ queryKey }),
+                      invalidateQueries({ queryKey })
                     )
                     .pipe(Effect.withSpan("client.query.invalidation", { captureStackTrace: false }))
-                }
-
-                if (!queryKey) return Effect.void
-
-                return Effect
-                  .andThen(
-                    Effect.annotateCurrentSpan({ queryKey }),
-                    invalidateQueries({ queryKey })
-                  )
-                  .pipe(Effect.withSpan("client.query.invalidation", { captureStackTrace: false }))
-              })
+                })
+            ),
+            Effect.tapDefect(reportRuntimeError),
+            Effect.tap((i) => onSuccess ? Effect.promise(() => onSuccess(i)) : Effect.void),
+            Effect.exit,
+            Effect.flatMap(handleExit),
+            Effect.withSpan(`mutation ${self.name}`, { captureStackTrace: false })
           ),
-          Effect.tapDefect(reportRuntimeError),
-          Effect.tap((i) => onSuccess ? Effect.promise(() => onSuccess(i)) : Effect.void),
-          Effect.exit,
-          Effect.flatMap(handleExit),
-          Effect.withSpan(`mutation ${self.name}`, { captureStackTrace: false })
-        ),
-      dropUndefinedT({ signal })
+        dropUndefinedT({ signal })
+      )
+    }
+
+    return tuple(
+      state,
+      exec
     )
   }
-
-  return tuple(
-    state,
-    exec
-  )
+  return useSafeMutation
 }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface MakeMutation<R> extends ReturnType<typeof makeMutation<R>> {}

package/src/query.ts

@@ -13,11 +13,10 @@ import type {
 } from "@tanstack/vue-query"
 import { useQuery } from "@tanstack/vue-query"
 import { Cause, Effect, Option, Runtime, S } from "effect-app"
-import { type ApiConfig, ServiceUnavailableError } from "effect-app/client"
-import type { HttpClient } from "effect-app/http"
+import { ServiceUnavailableError } from "effect-app/client"
 import { computed, ref } from "vue"
 import type { ComputedRef, WatchSource } from "vue"
-import { makeQueryKey, reportRuntimeError, run } from "./internal.js"
+import { makeQueryKey, reportRuntimeError } from "./internal.js"
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface QueryObserverOptionsCustom<
@@ -31,190 +30,196 @@ export interface QueryObserverOptionsCustom<
   Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, "queryKey" | "queryFn">
 {}
 
-export function useSafeQuery<E, A>(
-  self: {
-    handler: Effect<A, E, ApiConfig | HttpClient.HttpClient>
-    mapPath: string
-    name: string
-  },
-  options?: QueryObserverOptionsCustom // TODO
-): readonly [
-  ComputedRef<Result.Result<A, E>>,
-  ComputedRef<A | undefined>,
-  (options?: RefetchOptions) => Promise<QueryObserverResult<any, any>>,
-  UseQueryReturnType<any, any>
-]
-export function useSafeQuery<Arg, E, A>(
-  self: {
-    handler: (arg: Arg) => Effect<A, E, ApiConfig | HttpClient.HttpClient>
-    mapPath: (arg: Arg) => string
-    name: string
-  },
-  arg: Arg | WatchSource<Arg>,
-  options?: QueryObserverOptionsCustom // TODO
-): readonly [
-  ComputedRef<Result.Result<A, E>>,
-  ComputedRef<A | undefined>,
-  (options?: RefetchOptions) => Promise<QueryObserverResult<any, any>>,
-  UseQueryReturnType<any, any>
-]
-export function useSafeQuery(
-  self: any,
-  /*
-  q:
-    | {
-      handler: (
-        req: I
-      ) => Effect<
-        A,
-        E,
-        ApiConfig | HttpClient.HttpClient
-      >
-      mapPath: (req: I) => string
-      name: string
-    }
-    | {
-      handler: Effect<
-        A,
-        E,
-        ApiConfig | HttpClient.HttpClient
-      >
-      mapPath: string
-      name: string
-    },
-  */
-  argOrOptions?: any,
-  options?: any
-) {
-  return Effect.isEffect(self.handler)
-    ? useSafeQuery_(self, undefined, argOrOptions)
-    : useSafeQuery_(self, argOrOptions, options)
-}
-
 export interface KnownFiberFailure<E> extends Runtime.FiberFailure {
   readonly [Runtime.FiberFailureCauseId]: Cause.Cause<E>
 }
 
-// TODO: options
-// declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryReturnType<TData, TError>;
-// declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryDefinedReturnType<TData, TError>;
-// declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, queryClient?: QueryClient): UseQueryReturnType<TData, TError>;
-export const useSafeQuery_ = <I, A, E>(
+export const makeQuery = <R>(runtime: Runtime.Runtime<R>) => {
+  const runPromise = Runtime.runPromise(runtime)
+  // TODO: options
+  // declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryReturnType<TData, TError>;
+  // declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryDefinedReturnType<TData, TError>;
+  // declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, queryClient?: QueryClient): UseQueryReturnType<TData, TError>;
+  const useSafeQuery_ = <I, A, E>(
+    q:
+      | {
+        readonly handler: (
+          req: I
+        ) => Effect<
+          A,
+          E,
+          R
+        >
+        mapPath: (req: I) => string
+        name: string
+      }
+      | {
+        readonly handler: Effect<
+          A,
+          E,
+          R
+        >
+        mapPath: string
+        name: string
+      },
+    arg?: I | WatchSource<I>,
+    options: QueryObserverOptionsCustom<unknown, KnownFiberFailure<E>, A> = {} // TODO
+  ) => {
+    const arr = arg
+    const req: { value: I } = !arg
+      ? undefined
+      : typeof arr === "function"
+      ? ({
+        get value() {
+          return (arr as any)()
+        }
+      } as any)
+      : ref(arg)
+    const queryKey = makeQueryKey(q.name)
+    const handler = q.handler
+    const r = useQuery<unknown, KnownFiberFailure<E>, A>(
+      Effect.isEffect(handler)
+        ? {
+          ...options,
+          retry: (retryCount, error) => {
+            if (Runtime.isFiberFailure(error)) {
+              const cause = error[Runtime.FiberFailureCauseId]
+              const sq = Cause.squash(cause)
+              if (!isHttpRequestError(sq) && !isHttpResponseError(sq) && !S.is(ServiceUnavailableError)(sq)) {
+                return false
+              }
+            }
+
+            return retryCount < 5
+          },
+          queryKey,
+          queryFn: ({ signal }) =>
+            runPromise(
+              handler
+                .pipe(
+                  Effect.tapDefect(reportRuntimeError),
+                  Effect.withSpan(`query ${q.name}`, { captureStackTrace: false })
+                ),
+              { signal }
+            )
+        }
+        : {
+          ...options,
+          retry: (retryCount, error) => {
+            if (Runtime.isFiberFailure(error)) {
+              const cause = error[Runtime.FiberFailureCauseId]
+              const sq = Cause.squash(cause)
+              if (!isHttpRequestError(sq) && !isHttpResponseError(sq) && !S.is(ServiceUnavailableError)(sq)) {
+                return false
+              }
+            }
+
+            return retryCount < 5
+          },
+          queryKey: [...queryKey, req],
+          queryFn: ({ signal }) =>
+            runPromise(
+              handler(req.value)
+                .pipe(
+                  Effect.tapDefect(reportRuntimeError),
+                  Effect.withSpan(`query ${q.name}`, { captureStackTrace: false })
+                ),
+              { signal }
+            )
+        }
+    )
+
+    const result = computed(() =>
+      swrToQuery({
+        error: r.error.value ?? undefined,
+        data: r.data.value,
+        isValidating: r.isFetching.value
+      })
+    )
+    const latestSuccess = computed(() => Option.getOrUndefined(Result.value(result.value)))
+    return [result, latestSuccess, r.refetch, r] as const
+  }
+
+  function swrToQuery<E, A>(r: {
+    error: KnownFiberFailure<E> | undefined
+    data: A | undefined
+    isValidating: boolean
+  }): Result.Result<A, E> {
+    if (r.error) {
+      return Result.failureWithPrevious(
+        r.error[Runtime.FiberFailureCauseId],
+        r.data === undefined ? Option.none() : Option.some(Result.success(r.data)),
+        r.isValidating
+      )
+    }
+    if (r.data !== undefined) {
+      return Result.success<A, E>(r.data, r.isValidating)
+    }
+
+    return Result.initial(r.isValidating)
+  }
+
+  function useSafeQuery<E, A>(
+    self: {
+      handler: Effect<A, E, R>
+      mapPath: string
+      name: string
+    },
+    options?: QueryObserverOptionsCustom // TODO
+  ): readonly [
+    ComputedRef<Result.Result<A, E>>,
+    ComputedRef<A | undefined>,
+    (options?: RefetchOptions) => Promise<QueryObserverResult<any, any>>,
+    UseQueryReturnType<any, any>
+  ]
+  function useSafeQuery<Arg, E, A>(
+    self: {
+      handler: (arg: Arg) => Effect<A, E, R>
+      mapPath: (arg: Arg) => string
+      name: string
+    },
+    arg: Arg | WatchSource<Arg>,
+    options?: QueryObserverOptionsCustom // TODO
+  ): readonly [
+    ComputedRef<Result.Result<A, E>>,
+    ComputedRef<A | undefined>,
+    (options?: RefetchOptions) => Promise<QueryObserverResult<any, any>>,
+    UseQueryReturnType<any, any>
+  ]
+  function useSafeQuery(
+    self: any,
+    /*
   q:
     | {
-      readonly handler: (
+      handler: (
         req: I
       ) => Effect<
         A,
         E,
-        ApiConfig | HttpClient.HttpClient
+        R
       >
       mapPath: (req: I) => string
       name: string
     }
     | {
-      readonly handler: Effect<
+      handler: Effect<
         A,
         E,
-        ApiConfig | HttpClient.HttpClient
+        R
       >
       mapPath: string
       name: string
     },
-  arg?: I | WatchSource<I>,
-  options: QueryObserverOptionsCustom<unknown, KnownFiberFailure<E>, A> = {} // TODO
-) => {
-  const arr = arg
-  const req: { value: I } = !arg
-    ? undefined
-    : typeof arr === "function"
-    ? ({
-      get value() {
-        return (arr as any)()
-      }
-    } as any)
-    : ref(arg)
-  const queryKey = makeQueryKey(q.name)
-  const handler = q.handler
-  const r = useQuery<unknown, KnownFiberFailure<E>, A>(
-    Effect.isEffect(handler)
-      ? {
-        ...options,
-        retry: (retryCount, error) => {
-          if (Runtime.isFiberFailure(error)) {
-            const cause = error[Runtime.FiberFailureCauseId]
-            const sq = Cause.squash(cause)
-            if (!isHttpRequestError(sq) && !isHttpResponseError(sq) && !S.is(ServiceUnavailableError)(sq)) {
-              return false
-            }
-          }
-
-          return retryCount < 5
-        },
-        queryKey,
-        queryFn: ({ signal }) =>
-          run.value(
-            handler
-              .pipe(
-                Effect.tapDefect(reportRuntimeError),
-                Effect.withSpan(`query ${q.name}`, { captureStackTrace: false })
-              ),
-            { signal }
-          )
-      }
-      : {
-        ...options,
-        retry: (retryCount, error) => {
-          if (Runtime.isFiberFailure(error)) {
-            const cause = error[Runtime.FiberFailureCauseId]
-            const sq = Cause.squash(cause)
-            if (!isHttpRequestError(sq) && !isHttpResponseError(sq) && !S.is(ServiceUnavailableError)(sq)) {
-              return false
-            }
-          }
-
-          return retryCount < 5
-        },
-        queryKey: [...queryKey, req],
-        queryFn: ({ signal }) =>
-          run
-            .value(
-              handler(req.value)
-                .pipe(
-                  Effect.tapDefect(reportRuntimeError),
-                  Effect.withSpan(`query ${q.name}`, { captureStackTrace: false })
-                ),
-              { signal }
-            )
-      }
-  )
-
-  const result = computed(() =>
-    swrToQuery({
-      error: r.error.value ?? undefined,
-      data: r.data.value,
-      isValidating: r.isFetching.value
-    })
-  )
-  const latestSuccess = computed(() => Option.getOrUndefined(Result.value(result.value)))
-  return [result, latestSuccess, r.refetch, r] as const
-}
-
-function swrToQuery<E, A>(r: {
-  error: KnownFiberFailure<E> | undefined
-  data: A | undefined
-  isValidating: boolean
-}): Result.Result<A, E> {
-  if (r.error) {
-    return Result.failureWithPrevious(
-      r.error[Runtime.FiberFailureCauseId],
-      r.data === undefined ? Option.none() : Option.some(Result.success(r.data)),
-      r.isValidating
-    )
-  }
-  if (r.data !== undefined) {
-    return Result.success<A, E>(r.data, r.isValidating)
+  */
+    argOrOptions?: any,
+    options?: any
+  ) {
+    return Effect.isEffect(self.handler)
+      ? useSafeQuery_(self, undefined, argOrOptions)
+      : useSafeQuery_(self, argOrOptions, options)
   }
-
-  return Result.initial(r.isValidating)
+  return useSafeQuery
 }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface MakeQuery<R> extends ReturnType<typeof makeQuery<R>> {}

package/src/runtime.ts

@@ -4,9 +4,6 @@ import { Config, Exit, Runtime } from "effect"
 import { Effect, Layer, Logger } from "effect-app"
 import { ApiConfig } from "effect-app/client"
 import * as Scope from "effect/Scope"
-import { initRuntime } from "./internal.js"
-
-export { initRuntime } from "./internal.js"
 
 export const DefaultApiConfig = Config.all({
   apiUrl: Config.string("apiUrl").pipe(Config.withDefault("/api")),
@@ -48,7 +45,6 @@ export function makeAppRuntime<R, E, A>(layer: Layer<A, E, R>) {
 
 export function initializeSync<E, A>(layer: Layer<A | ApiConfig | HttpClient.HttpClient, E, never>) {
   const { clean, runtime } = Effect.runSync(makeAppRuntime(layer))
-  initRuntime(runtime)
   return {
     runtime,
     clean: () => Effect.runSync(clean)
@@ -59,7 +55,6 @@ export function initializeAsync<E, A>(layer: Layer<A | ApiConfig | HttpClient.Ht
   return Effect
     .runPromise(makeAppRuntime(layer))
     .then(({ clean, runtime }) => {
-      initRuntime(runtime)
       return {
         runtime,
         clean: () => Effect.runPromise(clean)