diff --git a/src/FiberStore.ts b/src/FiberStore.ts
index fcbfe96..48ac637 100644
--- a/src/FiberStore.ts
+++ b/src/FiberStore.ts
@@ -1,7 +1,10 @@
-import type * as Runtime from "@effect/io/Runtime"
+/**
+ * @since 1.0.0
+ */
 import type * as Stream from "@effect/stream/Stream"
 import * as internal from "effect-react/internal/fiberStore"
 import type * as ResultBag from "effect-react/ResultBag"
+import type * as RuntimeContext from "effect-react/RuntimeContext"
 
 /**
  * @since 1.0.0
@@ -18,4 +21,4 @@ export interface FiberStore<R, E, A> {
  * @since 1.0.0
  * @category constructors
  */
-export const make: <R, E, A>(runtime: Runtime.Runtime<R>) => FiberStore<R, E, A> = internal.make
+export const make: <R, E, A>(runtime: RuntimeContext.RuntimeEffect<R>) => FiberStore<R, E, A> = internal.make
diff --git a/src/Hooks.ts b/src/Hooks.ts
new file mode 100644
index 0000000..7de372f
--- /dev/null
+++ b/src/Hooks.ts
@@ -0,0 +1,43 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Stream from "@effect/stream/Stream"
+import * as internal from "effect-react/internal/hooks"
+import type * as ResultBag from "effect-react/ResultBag"
+import type * as RuntimeContext from "effect-react/RuntimeContext"
+import type { DependencyList } from "react"
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make: <R>(
+  runtimeContext: RuntimeContext.ReactContext<R>
+) => {
+  useResult: <R0 extends R, E, A>(
+    evaluate: () => Stream.Stream<R0, E, A>,
+    deps: DependencyList
+  ) => ResultBag.ResultBag<unknown, A>
+  useResultCallback: <Args extends Array<any>, R0 extends R, E, A>(
+    f: (...args: Args) => Stream.Stream<R0, E, A>
+  ) => readonly [ResultBag.ResultBag<unknown, A>, (...args: Args) => void]
+} = internal.make
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeUseResult: <R>(
+  runtimeContext: RuntimeContext.ReactContext<R>
+) => <R0 extends R, E, A>(evaluate: () => Stream.Stream<R0, E, A>, deps: DependencyList) => ResultBag.ResultBag<E, A> =
+  internal.makeUseResult
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeUseResultCallback: <R>(
+  runtimeContext: RuntimeContext.ReactContext<R>
+) => <Args extends Array<any>, R0 extends R, E, A>(
+  f: (...args: Args) => Stream.Stream<R0, E, A>
+) => readonly [ResultBag.ResultBag<E, A>, (...args: Args) => void] = internal.makeUseResultCallback
diff --git a/src/Result.ts b/src/Result.ts
index 256717c..3ae34a8 100644
--- a/src/Result.ts
+++ b/src/Result.ts
@@ -1,3 +1,6 @@
+/**
+ * @since 1.0.0
+ */
 import type * as Data from "@effect/data/Data"
 import type * as Option from "@effect/data/Option"
 import type { Pipeable } from "@effect/data/Pipeable"
diff --git a/src/ResultBag.ts b/src/ResultBag.ts
index 30cec18..997f060 100644
--- a/src/ResultBag.ts
+++ b/src/ResultBag.ts
@@ -1,8 +1,11 @@
+/**
+ * @since 1.0.0
+ */
 import type * as Option from "@effect/data/Option"
 import type * as Cause from "@effect/io/Cause"
 import * as internal from "effect-react/internal/resultBag"
 import type * as Result from "effect-react/Result"
-import type * as TrackedProperties from "effect-react/TrackedProperties"
+import type * as TrackedProperties from "effect-react/ResultBag/TrackedProperties"
 
 /**
  * @since 1.0.0
diff --git a/src/TrackedProperties.ts b/src/ResultBag/TrackedProperties.ts
similarity index 89%
rename from src/TrackedProperties.ts
rename to src/ResultBag/TrackedProperties.ts
index 910e4c3..522ea58 100644
--- a/src/TrackedProperties.ts
+++ b/src/ResultBag/TrackedProperties.ts
@@ -1,6 +1,9 @@
+/**
+ * @since 1.0.0
+ */
 import type * as Option from "@effect/data/Option"
 import type * as Cause from "@effect/io/Cause"
-import * as internal from "effect-react/internal/trackedProperties"
+import * as internal from "effect-react/internal/resultBag/trackedProperties"
 import type * as Result from "effect-react/Result"
 
 /**
diff --git a/src/RuntimeContext.ts b/src/RuntimeContext.ts
new file mode 100644
index 0000000..30b1b3c
--- /dev/null
+++ b/src/RuntimeContext.ts
@@ -0,0 +1,187 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Context from "@effect/data/Context"
+import { dual, pipe } from "@effect/data/Function"
+import * as Effect from "@effect/io/Effect"
+import * as Exit from "@effect/io/Exit"
+import * as Fiber from "@effect/io/Fiber"
+import * as Layer from "@effect/io/Layer"
+import * as Runtime from "@effect/io/Runtime"
+import * as Scope from "@effect/io/Scope"
+import * as React from "react"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const RuntimeContextTypeId = Symbol.for("@effect/react/RuntimeContext")
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type RuntimeContextTypeId = typeof RuntimeContextTypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface RuntimeContext<R> extends ReactContext<R> {
+  readonly [RuntimeContextTypeId]: {
+    readonly scope: Scope.CloseableScope
+    readonly context: Effect.Effect<never, never, Context.Context<R>>
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type ReactContext<R> = React.Context<Effect.Effect<never, never, Runtime.Runtime<R>>>
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type RuntimeEffect<R> = Effect.Effect<never, never, Runtime.Runtime<R>>
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fromContext = <R>(
+  context: Context.Context<R>
+): RuntimeContext<R> => fromContextEffect(Effect.succeed(context))
+
+const makeRuntimeEffect = <R>(context: Effect.Effect<never, never, Context.Context<R>>): RuntimeEffect<R> => {
+  const runtime = pipe(
+    context,
+    Effect.flatMap((context) => Effect.provideContext(Effect.runtime<R>(), context)),
+    Effect.cached,
+    Effect.runSync
+  )
+  Effect.runFork(runtime) // prime cache
+  return runtime
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fromContextEffect = <R, E>(
+  effect: Effect.Effect<Scope.Scope, E, Context.Context<R>>
+): RuntimeContext<R> => {
+  const scope = Effect.runSync(Scope.make())
+  const error = new Error()
+  const context = Scope.use(
+    Effect.orDieWith(effect, (e) => {
+      error.message = `Could not build RuntimeContext: ${e}`
+      return error
+    }),
+    scope
+  )
+  const runtime = makeRuntimeEffect(context)
+  const RuntimeContext = React.createContext(runtime)
+  return new Proxy(RuntimeContext, {
+    has(target, p) {
+      return p === RuntimeContextTypeId || p in target
+    },
+    get(target, p, _receiver) {
+      if (p === RuntimeContextTypeId) {
+        return {
+          scope,
+          context
+        }
+      }
+      return (target as any)[p]
+    }
+  }) as any
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fromLayer = <R, E>(layer: Layer.Layer<never, E, R>): RuntimeContext<R> =>
+  fromContextEffect(Effect.runSync(Effect.cached(Layer.build(layer))))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const provideMerge = dual<
+  <R, RX extends R, R2, E>(
+    layer: Layer.Layer<RX, E, R2>
+  ) => (self: RuntimeContext<R>) => RuntimeContext<R | R2>,
+  <R, RX extends R, R2, E>(
+    self: RuntimeContext<R>,
+    layer: Layer.Layer<RX, E, R2>
+  ) => RuntimeContext<R | R2>
+>(2, (self, layer) => {
+  const context = self[RuntimeContextTypeId].context
+  return fromLayer(Layer.provideMerge(Layer.effectContext(context), layer))
+})
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const toRuntimeEffect = <R>(
+  self: RuntimeContext<R>
+): RuntimeEffect<R> => makeRuntimeEffect(self[RuntimeContextTypeId].context)
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const overrideLayer = dual<
+  <R, RX extends R, E>(
+    layer: Layer.Layer<never, E, RX>
+  ) => (self: RuntimeContext<R>) => readonly [React.ExoticComponent<React.PropsWithChildren>, Scope.CloseableScope],
+  <R, E>(
+    self: RuntimeContext<R>,
+    layer: Layer.Layer<never, E, R>
+  ) => readonly [React.ExoticComponent<React.PropsWithChildren>, Scope.CloseableScope]
+>(2, (self, layer) => {
+  const context = fromLayer(layer)
+  const runtime = toRuntimeEffect(context)
+  return [
+    (props: React.PropsWithChildren) => React.createElement(self.Provider, { value: runtime }, props.children),
+    context[RuntimeContextTypeId].scope
+  ] as any
+})
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const closeEffect = <R>(self: RuntimeContext<R>): Effect.Effect<never, never, void> =>
+  Scope.close(self[RuntimeContextTypeId].scope, Exit.unit)
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const close = <R>(self: RuntimeContext<R>): () => void => {
+  const effect = closeEffect(self)
+  return () => {
+    Effect.runFork(effect)
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category execution
+ */
+export const runForkJoin = <R>(
+  runtime: RuntimeEffect<R>
+) =>
+  <RX extends R, E, A>(effect: Effect.Effect<RX, E, A>): Effect.Effect<never, E, A> =>
+    Effect.flatMap(
+      runtime,
+      (runtime) => {
+        const fiber = Runtime.runFork(runtime)(effect)
+        return Fiber.join(fiber)
+      }
+    )
diff --git a/src/RuntimeProvider.ts b/src/RuntimeProvider.ts
deleted file mode 100644
index f6982d9..0000000
--- a/src/RuntimeProvider.ts
+++ /dev/null
@@ -1,100 +0,0 @@
-"use client"
-import type { LazyArg } from "@effect/data/Function"
-import { pipe } from "@effect/data/Function"
-import * as Effect from "@effect/io/Effect"
-import * as Layer from "@effect/io/Layer"
-import type * as Runtime from "@effect/io/Runtime"
-import * as Scope from "@effect/io/Scope"
-import type * as Stream from "@effect/stream/Stream"
-import * as internalUseResult from "effect-react/internal/hooks/useResult"
-import * as internalUseResultCallback from "effect-react/internal/hooks/useResultCallback"
-import type * as ResultBag from "effect-react/ResultBag"
-import type { DependencyList } from "react"
-import { createContext } from "react"
-
-/**
- * @since 1.0.0
- * @category models
- */
-export type RuntimeContext<R> = React.Context<Runtime.Runtime<R>>
-
-/**
- * @since 1.0.0
- * @category hooks
- */
-export type UseResult<R> = <R0 extends R, E, A>(
-  evaluate: LazyArg<Stream.Stream<R0, E, A>>,
-  deps: DependencyList
-) => ResultBag.ResultBag<E, A>
-
-/**
- * @since 1.0.0
- * @category hooks
- */
-export type UseResultCallback<R> = <Args extends Array<any>, R0 extends R, E, A>(
-  f: (...args: Args) => Stream.Stream<R0, E, A>
-) => readonly [ResultBag.ResultBag<E, A>, (...args: Args) => void]
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface ReactEffectBag<R> {
-  readonly RuntimeContext: React.Context<Runtime.Runtime<R>>
-  readonly useResultCallback: UseResultCallback<R>
-  readonly useResult: UseResult<R>
-}
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const makeFromLayer = <R, E>(
-  layer: Layer.Layer<never, E, R>
-): ReactEffectBag<R> => {
-  const scope = Effect.runSync(Scope.make())
-
-  const runtime = pipe(
-    Layer.toRuntime(layer),
-    Effect.provideService(Scope.Scope, scope),
-    Effect.runSync
-  )
-
-  const RuntimeContext = createContext(runtime)
-
-  return {
-    RuntimeContext,
-    useResultCallback: internalUseResultCallback.make(RuntimeContext),
-    useResult: internalUseResult.make(RuntimeContext)
-  }
-}
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const makeFromRuntime = <R>(
-  runtime: Runtime.Runtime<R>
-): ReactEffectBag<R> => {
-  const RuntimeContext = createContext(runtime)
-
-  return {
-    RuntimeContext,
-    useResultCallback: internalUseResultCallback.make(RuntimeContext),
-    useResult: internalUseResult.make(RuntimeContext)
-  }
-}
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const makeFromRuntimeContext = <R>(
-  RuntimeContext: React.Context<Runtime.Runtime<R>>
-): ReactEffectBag<R> => {
-  return {
-    RuntimeContext,
-    useResultCallback: internalUseResultCallback.make(RuntimeContext),
-    useResult: internalUseResult.make(RuntimeContext)
-  }
-}
diff --git a/src/internal/fiberStore.ts b/src/internal/fiberStore.ts
index 88ebd96..6220bef 100644
--- a/src/internal/fiberStore.ts
+++ b/src/internal/fiberStore.ts
@@ -2,21 +2,21 @@ import { pipe } from "@effect/data/Function"
 import * as Effect from "@effect/io/Effect"
 import type * as Fiber from "@effect/io/Fiber"
 import * as Ref from "@effect/io/Ref"
-import * as Runtime from "@effect/io/Runtime"
 import * as Stream from "@effect/stream/Stream"
 import type * as FiberStore from "effect-react/FiberStore"
 import * as Result from "effect-react/Result"
 import * as ResultBag from "effect-react/ResultBag"
-import * as TrackedProperties from "effect-react/TrackedProperties"
+import * as TrackedProperties from "effect-react/ResultBag/TrackedProperties"
+import * as RuntimeContext from "effect-react/RuntimeContext"
 
 /** @internal */
 export const make = <R, E, A>(
-  runtime: Runtime.Runtime<R>
+  runtime: RuntimeContext.RuntimeEffect<R>
 ): FiberStore.FiberStore<R, E, A> => new FiberStoreImpl(runtime)
 
 class FiberStoreImpl<R, E, A> implements FiberStore.FiberStore<R, E, A> {
   constructor(
-    readonly runtime: Runtime.Runtime<R>
+    readonly runtime: RuntimeContext.RuntimeEffect<R>
   ) {}
 
   // listeners
@@ -82,8 +82,9 @@ class FiberStoreImpl<R, E, A> implements FiberStore.FiberStore<R, E, A> {
         return stream
       }),
       Stream.runForEach((_) => maybeSetResult(Result.success(_))),
+      RuntimeContext.runForkJoin(this.runtime),
       Effect.catchAllCause((cause) => maybeSetResult(Result.failCause(cause))),
-      Runtime.runFork(this.runtime)
+      Effect.runFork
     )
 
     this.fiberState = {
diff --git a/src/internal/hooks.ts b/src/internal/hooks.ts
new file mode 100644
index 0000000..55e1dac
--- /dev/null
+++ b/src/internal/hooks.ts
@@ -0,0 +1,71 @@
+import * as Hash from "@effect/data/Hash"
+import type * as Stream from "@effect/stream/Stream"
+import * as FiberStore from "effect-react/FiberStore"
+import type * as ResultBag from "effect-react/ResultBag"
+import type * as RuntimeContext from "effect-react/RuntimeContext"
+import type { DependencyList } from "react"
+import { useCallback, useContext, useRef, useSyncExternalStore } from "react"
+
+/** @internal */
+export const make = <R>(
+  runtimeContext: RuntimeContext.ReactContext<R>
+): {
+  useResult: <R0 extends R, E, A>(
+    evaluate: () => Stream.Stream<R0, E, A>,
+    deps: DependencyList
+  ) => ResultBag.ResultBag<unknown, A>
+  useResultCallback: <Args extends Array<any>, R0 extends R, E, A>(
+    f: (...args: Args) => Stream.Stream<R0, E, A>
+  ) => readonly [ResultBag.ResultBag<unknown, A>, (...args: Args) => void]
+} => ({
+  useResult: makeUseResult(runtimeContext),
+  useResultCallback: makeUseResultCallback(runtimeContext)
+})
+
+/** @internal */
+export const makeUseResult = <R>(
+  runtimeContext: RuntimeContext.ReactContext<R>
+) =>
+  <R0 extends R, E, A>(
+    evaluate: () => Stream.Stream<R0, E, A>,
+    deps: DependencyList
+  ): ResultBag.ResultBag<E, A> => {
+    const runtime = useContext(runtimeContext)
+    const storeRef = useRef<FiberStore.FiberStore<R0, E, A>>(undefined as any)
+    if (storeRef.current === undefined) {
+      storeRef.current = FiberStore.make(runtime)
+    }
+    const resultBag = useSyncExternalStore(
+      storeRef.current.subscribe,
+      storeRef.current.snapshot
+    )
+    const depsHash = useRef<number>(null as any)
+    const currentDepsHash = Hash.array(deps)
+    if (depsHash.current !== currentDepsHash) {
+      depsHash.current = currentDepsHash
+      storeRef.current.run(evaluate())
+    }
+    return resultBag
+  }
+
+/** @internal */
+export const makeUseResultCallback = <R>(
+  runtimeContext: RuntimeContext.ReactContext<R>
+) =>
+  <Args extends Array<any>, R0 extends R, E, A>(
+    f: (...args: Args) => Stream.Stream<R0, E, A>
+  ): readonly [ResultBag.ResultBag<E, A>, (...args: Args) => void] => {
+    const runtime = useContext(runtimeContext)
+    const storeRef = useRef<FiberStore.FiberStore<R0, E, A>>(undefined as any)
+    if (storeRef.current === undefined) {
+      storeRef.current = FiberStore.make(runtime)
+    }
+    const resultBag = useSyncExternalStore(
+      storeRef.current.subscribe,
+      storeRef.current.snapshot
+    )
+    const run = useCallback((...args: Args) => {
+      storeRef.current.run(f(...args))
+    }, [f])
+    return [resultBag, run] as const
+  }
diff --git a/src/internal/hooks/useResult.ts b/src/internal/hooks/useResult.ts
deleted file mode 100644
index 5985b5d..0000000
--- a/src/internal/hooks/useResult.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import * as Hash from "@effect/data/Hash"
-import type * as Stream from "@effect/stream/Stream"
-import * as FiberStore from "effect-react/FiberStore"
-import type * as ResultBag from "effect-react/ResultBag"
-import type * as RuntimeProvider from "effect-react/RuntimeProvider"
-import type { DependencyList } from "react"
-import { useContext, useRef, useSyncExternalStore } from "react"
-
-export const make = <R>(
-  runtimeContext: RuntimeProvider.RuntimeContext<R>
-): RuntimeProvider.UseResult<R> =>
-  <R0 extends R, E, A>(
-    evaluate: () => Stream.Stream<R0, E, A>,
-    deps: DependencyList
-  ): ResultBag.ResultBag<E, A> => {
-    const runtime = useContext(runtimeContext)
-    const storeRef = useRef<FiberStore.FiberStore<R0, E, A>>(undefined as any)
-    if (storeRef.current === undefined) {
-      storeRef.current = FiberStore.make(runtime)
-    }
-    const resultBag = useSyncExternalStore(
-      storeRef.current.subscribe,
-      storeRef.current.snapshot
-    )
-    const depsHash = useRef<number>(null as any)
-    const currentDepsHash = Hash.array(deps)
-    if (depsHash.current !== currentDepsHash) {
-      depsHash.current = currentDepsHash
-      storeRef.current.run(evaluate())
-    }
-    return resultBag
-  }
diff --git a/src/internal/hooks/useResultCallback.ts b/src/internal/hooks/useResultCallback.ts
deleted file mode 100644
index 8f4568f..0000000
--- a/src/internal/hooks/useResultCallback.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import type * as Stream from "@effect/stream/Stream"
-import * as FiberStore from "effect-react/FiberStore"
-import type * as ResultBag from "effect-react/ResultBag"
-import type * as RuntimeProvider from "effect-react/RuntimeProvider"
-import { useCallback, useContext, useRef, useSyncExternalStore } from "react"
-
-/** @internal */
-export const make = <R>(
-  runtimeContext: RuntimeProvider.RuntimeContext<R>
-): RuntimeProvider.UseResultCallback<R> =>
-  <Args extends Array<any>, R0 extends R, E, A>(
-    f: (...args: Args) => Stream.Stream<R0, E, A>
-  ): readonly [ResultBag.ResultBag<E, A>, (...args: Args) => void] => {
-    const runtime = useContext(runtimeContext)
-    const storeRef = useRef<FiberStore.FiberStore<R0, E, A>>(undefined as any)
-    if (storeRef.current === undefined) {
-      storeRef.current = FiberStore.make(runtime)
-    }
-    const resultBag = useSyncExternalStore(
-      storeRef.current.subscribe,
-      storeRef.current.snapshot
-    )
-    const run = useCallback((...args: Args) => {
-      storeRef.current.run(f(...args))
-    }, [f])
-    return [resultBag, run] as const
-  }
diff --git a/src/internal/resultBag.ts b/src/internal/resultBag.ts
index bfe16af..a02605f 100644
--- a/src/internal/resultBag.ts
+++ b/src/internal/resultBag.ts
@@ -5,7 +5,7 @@ import * as Order from "@effect/data/Order"
 import type * as Cause from "@effect/io/Cause"
 import * as Result from "effect-react/Result"
 import type * as ResultBag from "effect-react/ResultBag"
-import type * as TrackedProperties from "effect-react/TrackedProperties"
+import type * as TrackedProperties from "effect-react/ResultBag/TrackedProperties"
 
 const optionDateGreaterThan = pipe(
   N.Order,
diff --git a/src/internal/trackedProperties.ts b/src/internal/resultBag/trackedProperties.ts
similarity index 94%
rename from src/internal/trackedProperties.ts
rename to src/internal/resultBag/trackedProperties.ts
index b4f5d6c..dfed889 100644
--- a/src/internal/trackedProperties.ts
+++ b/src/internal/resultBag/trackedProperties.ts
@@ -1,7 +1,7 @@
 import * as Option from "@effect/data/Option"
 import * as Cause from "@effect/io/Cause"
 import type * as Result from "effect-react/Result"
-import type * as TrackedProperties from "effect-react/TrackedProperties"
+import type * as TrackedProperties from "effect-react/ResultBag/TrackedProperties"
 
 /** @internal */
 export const initial = (): TrackedProperties.TrackedProperties => ({
diff --git a/test/hooks/useResult.ts b/test/hooks/useResult.ts
index 04351c9..91f1e2f 100644
--- a/test/hooks/useResult.ts
+++ b/test/hooks/useResult.ts
@@ -3,8 +3,9 @@ import * as Effect from "@effect/io/Effect"
 import * as Layer from "@effect/io/Layer"
 import * as Stream from "@effect/stream/Stream"
 import { renderHook, waitFor } from "@testing-library/react"
+import * as Hooks from "effect-react/Hooks"
 import * as Result from "effect-react/Result"
-import * as RuntimeProvider from "effect-react/RuntimeProvider"
+import * as RuntimeContext from "effect-react/RuntimeContext"
 import { describe, expect, it } from "vitest"
 
 interface Foo {
@@ -12,7 +13,8 @@ interface Foo {
 }
 const foo = Context.Tag<Foo>()
 
-const { useResult } = RuntimeProvider.makeFromLayer(Layer.succeed(foo, { value: 1 }))
+const context = RuntimeContext.fromLayer(Layer.succeed(foo, { value: 1 }))
+const useResult = Hooks.makeUseResult(context)
 
 describe("useResult", () => {
   it("should run effects", async () => {
@@ -21,6 +23,19 @@ describe("useResult", () => {
     expect(Result.isSuccess(result.current.result)).toBe(true)
   })
 
+  it("override Provider value", async () => {
+    const [Override] = RuntimeContext.overrideLayer(context, Layer.succeed(foo, { value: 2 }))
+    const testEffect = Effect.map(foo, (_) => _.value)
+    const { result } = await waitFor(async () =>
+      renderHook(() => useResult(() => testEffect, []), {
+        wrapper: Override
+      })
+    )
+    await waitFor(() => expect(Result.isSuccess(result.current.result)).toBe(true))
+    assert(Result.isSuccess(result.current.result))
+    expect(result.current.result.value).toBe(2)
+  })
+
   it("should provide context", async () => {
     const testEffect = Effect.map(foo, (_) => _.value)
     const { result } = await waitFor(async () => renderHook(() => useResult(() => testEffect, [])))
diff --git a/test/hooks/useResultCallback.ts b/test/hooks/useResultCallback.ts
index 48c121a..18bf0c6 100644
--- a/test/hooks/useResultCallback.ts
+++ b/test/hooks/useResultCallback.ts
@@ -2,8 +2,9 @@ import * as Context from "@effect/data/Context"
 import * as Effect from "@effect/io/Effect"
 import * as Layer from "@effect/io/Layer"
 import { act, renderHook, waitFor } from "@testing-library/react"
+import * as Hooks from "effect-react/Hooks"
 import * as Result from "effect-react/Result"
-import * as RuntimeProvider from "effect-react/RuntimeProvider"
+import * as RuntimeContext from "effect-react/RuntimeContext"
 import { describe, expect, it } from "vitest"
 
 interface Foo {
@@ -11,7 +12,8 @@ interface Foo {
 }
 const foo = Context.Tag<Foo>()
 
-const { useResultCallback } = RuntimeProvider.makeFromLayer(Layer.succeed(foo, { value: 1 }))
+const context = RuntimeContext.fromLayer(Layer.succeed(foo, { value: 1 }))
+const useResultCallback = Hooks.makeUseResultCallback(context)
 
 describe("useResultCallback", () => {
   it("should do good", async () => {
diff --git a/tsconfig.base.json b/tsconfig.base.json
index c4ccf8b..ebd072f 100644
--- a/tsconfig.base.json
+++ b/tsconfig.base.json
@@ -23,6 +23,7 @@
     "noUnusedLocals": true,
     "noUnusedParameters": false,
     "noFallthroughCasesInSwitch": true,
+    "jsx": "react",
     "noEmitOnError": false,
     "noErrorTruncation": false,
     "allowJs": false,