effect 4.0.0-beta.5 → 4.0.0-beta.50

package/src/unstable/reactivity/Atom.ts

@@ -4,6 +4,7 @@
 import * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
 import * as Channel from "../../Channel.ts"
+import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
@@ -22,10 +23,9 @@ import type { ReadonlyRecord } from "../../Record.ts"
 import * as Scheduler from "../../Scheduler.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as SubscriptionRef from "../../SubscriptionRef.ts"
-import type { NoInfer } from "../../Types.ts"
+import type { Mutable, NoInfer } from "../../Types.ts"
 import * as KeyValueStore from "../persistence/KeyValueStore.ts"
 import * as AsyncResult from "./AsyncResult.ts"
 import { AtomRegistry } from "./AtomRegistry.ts"
@@ -52,10 +52,11 @@ export interface Atom<A> extends Pipeable, Inspectable.Inspectable {
   readonly [TypeId]: TypeId
   readonly keepAlive: boolean
   readonly lazy: boolean
-  readonly read: (get: Context) => A
+  readonly read: (get: AtomContext) => A
   readonly refresh?: (f: <A>(atom: Atom<A>) => void) => void
   readonly label?: readonly [name: string, stack: string]
   readonly idleTTL?: number
+  readonly initialValueTarget?: Atom<A>
 }
 
 /**
@@ -115,35 +116,35 @@ export interface Writable<R, W = R> extends Atom<R> {
  * @since 4.0.0
  * @category context
  */
-export interface Context {
+export interface AtomContext {
   <A>(atom: Atom<A>): A
-  get<A>(this: Context, atom: Atom<A>): A
-  result<A, E>(this: Context, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: {
+  get<A>(this: AtomContext, atom: Atom<A>): A
+  result<A, E>(this: AtomContext, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: {
     readonly suspendOnWaiting?: boolean | undefined
   }): Effect.Effect<A, E>
-  resultOnce<A, E>(this: Context, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: {
+  resultOnce<A, E>(this: AtomContext, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: {
     readonly suspendOnWaiting?: boolean | undefined
   }): Effect.Effect<A, E>
-  once<A>(this: Context, atom: Atom<A>): A
-  addFinalizer(this: Context, f: () => void): void
-  mount<A>(this: Context, atom: Atom<A>): void
-  refresh<A>(this: Context, atom: Atom<A>): void
-  refreshSelf(this: Context): void
-  self<A>(this: Context): Option.Option<A>
-  setSelf<A>(this: Context, a: A): void
-  set<R, W>(this: Context, atom: Writable<R, W>, value: W): void
-  setResult<A, E, W>(this: Context, atom: Writable<AsyncResult.AsyncResult<A, E>, W>, value: W): Effect.Effect<A, E>
-  some<A>(this: Context, atom: Atom<Option.Option<A>>): Effect.Effect<A>
-  someOnce<A>(this: Context, atom: Atom<Option.Option<A>>): Effect.Effect<A>
-  stream<A>(this: Context, atom: Atom<A>, options?: {
+  once<A>(this: AtomContext, atom: Atom<A>): A
+  addFinalizer(this: AtomContext, f: () => void): void
+  mount<A>(this: AtomContext, atom: Atom<A>): void
+  refresh<A>(this: AtomContext, atom: Atom<A>): void
+  refreshSelf(this: AtomContext): void
+  self<A>(this: AtomContext): Option.Option<A>
+  setSelf<A>(this: AtomContext, a: A): void
+  set<R, W>(this: AtomContext, atom: Writable<R, W>, value: W): void
+  setResult<A, E, W>(this: AtomContext, atom: Writable<AsyncResult.AsyncResult<A, E>, W>, value: W): Effect.Effect<A, E>
+  some<A>(this: AtomContext, atom: Atom<Option.Option<A>>): Effect.Effect<A>
+  someOnce<A>(this: AtomContext, atom: Atom<Option.Option<A>>): Effect.Effect<A>
+  stream<A>(this: AtomContext, atom: Atom<A>, options?: {
     readonly withoutInitialValue?: boolean
     readonly bufferSize?: number
   }): Stream.Stream<A>
-  streamResult<A, E>(this: Context, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: {
+  streamResult<A, E>(this: AtomContext, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: {
     readonly withoutInitialValue?: boolean
     readonly bufferSize?: number
   }): Stream.Stream<A, E>
-  subscribe<A>(this: Context, atom: Atom<A>, f: (_: A) => void, options?: {
+  subscribe<A>(this: AtomContext, atom: Atom<A>, f: (_: A) => void, options?: {
     readonly immediate?: boolean
   }): void
   readonly registry: Registry.AtomRegistry
@@ -169,25 +170,25 @@ export const setIdleTTL: {
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => A
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => A
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): A
+  <A extends Atom<any>>(self: A, duration: Duration.Input): A
 } = dual<
   /**
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput) => <A extends Atom<any>>(self: A) => A,
+  (duration: Duration.Input) => <A extends Atom<any>>(self: A) => A,
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput) => A
+  <A extends Atom<any>>(self: A, duration: Duration.Input) => A
 >(2, (self, durationInput) => {
-  const duration = Duration.fromDurationInputUnsafe(durationInput)
+  const duration = Duration.fromInputUnsafe(durationInput)
   const isFinite = Duration.isFinite(duration)
   return Object.assign(Object.create(Object.getPrototypeOf(self)), {
     ...self,
@@ -332,7 +333,7 @@ export const isWritable = <R, W>(atom: Atom<R>): atom is Writable<R, W> => Writa
  * @category constructors
  */
 export const readable = <A>(
-  read: (get: Context) => A,
+  read: (get: AtomContext) => A,
   refresh?: (f: <A>(atom: Atom<A>) => void) => void
 ): Atom<A> => {
   const self = Object.create(AtomProto)
@@ -348,7 +349,7 @@ export const readable = <A>(
  * @category constructors
  */
 export const writable = <R, W>(
-  read: (get: Context) => R,
+  read: (get: AtomContext) => R,
   write: (ctx: WriteContext<R>, value: W) => void,
   refresh?: (f: <A>(atom: Atom<A>) => void) => void
 ): Writable<R, W> => {
@@ -383,7 +384,7 @@ export const make: {
    * @category constructors
    */
   <A, E>(
-    create: (get: Context) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>,
+    create: (get: AtomContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>,
     options?: {
       readonly initialValue?: A | undefined
       readonly uninterruptible?: boolean | undefined
@@ -413,11 +414,11 @@ export const make: {
    * @category constructors
    */
   <A, E>(
-    create: (get: Context) => Stream.Stream<A, E, AtomRegistry>,
+    create: (get: AtomContext) => Stream.Stream<A, E, AtomRegistry>,
     options?: {
       readonly initialValue?: A
     }
-  ): Atom<AsyncResult.AsyncResult<A, E>>
+  ): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>
   // -----------------------------------------------------------------------------
   // constructors
   // -----------------------------------------------------------------------------
@@ -431,7 +432,7 @@ export const make: {
     options?: {
       readonly initialValue?: A
     }
-  ): Atom<AsyncResult.AsyncResult<A, E>>
+  ): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>
   // -----------------------------------------------------------------------------
   // constructors
   // -----------------------------------------------------------------------------
@@ -440,7 +441,7 @@ export const make: {
    * @since 4.0.0
    * @category constructors
    */
-  <A>(create: (get: Context) => A): Atom<A>
+  <A>(create: (get: AtomContext) => A): Atom<A>
   // -----------------------------------------------------------------------------
   // constructors
   // -----------------------------------------------------------------------------
@@ -469,28 +470,28 @@ const makeRead: {
   <A, E>(effect: Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: {
     readonly initialValue?: A
     readonly uninterruptible?: boolean | undefined
-  }): (get: Context, services?: ServiceMap.ServiceMap<any>) => AsyncResult.AsyncResult<A, E>
-  <A, E>(create: (get: Context) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: {
+  }): (get: AtomContext, services?: Context.Context<any>) => AsyncResult.AsyncResult<A, E>
+  <A, E>(create: (get: AtomContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: {
     readonly initialValue?: A
     readonly uninterruptible?: boolean | undefined
-  }): (get: Context, services?: ServiceMap.ServiceMap<any>) => AsyncResult.AsyncResult<A, E>
+  }): (get: AtomContext, services?: Context.Context<any>) => AsyncResult.AsyncResult<A, E>
   <A, E>(stream: Stream.Stream<A, E, AtomRegistry>, options?: {
     readonly initialValue?: A
     readonly uninterruptible?: boolean | undefined
-  }): (get: Context, services?: ServiceMap.ServiceMap<any>) => AsyncResult.AsyncResult<A, E>
-  <A, E>(create: (get: Context) => Stream.Stream<A, E, AtomRegistry>, options?: {
+  }): (get: AtomContext, services?: Context.Context<any>) => AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>
+  <A, E>(create: (get: AtomContext) => Stream.Stream<A, E, AtomRegistry>, options?: {
     readonly initialValue?: A
     readonly uninterruptible?: boolean | undefined
-  }): (get: Context, services?: ServiceMap.ServiceMap<any>) => AsyncResult.AsyncResult<A, E>
-  <A>(create: (get: Context) => A): (get: Context, services?: ServiceMap.ServiceMap<any>) => A
+  }): (get: AtomContext, services?: Context.Context<any>) => AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>
+  <A>(create: (get: AtomContext) => A): (get: AtomContext, services?: Context.Context<any>) => A
   <A>(initialValue: A): Writable<A>
 } = <A, E>(
   arg:
     | Effect.Effect<A, E, Scope.Scope | AtomRegistry>
-    | ((get: Context) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>)
+    | ((get: AtomContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>)
     | Stream.Stream<A, E, AtomRegistry>
-    | ((get: Context) => Stream.Stream<A, E, AtomRegistry>)
-    | ((get: Context) => A)
+    | ((get: AtomContext) => Stream.Stream<A, E, AtomRegistry>)
+    | ((get: AtomContext) => A)
     | A,
   options?: {
     readonly initialValue?: unknown
@@ -498,8 +499,8 @@ const makeRead: {
   }
 ) => {
   if (typeof arg === "function" && !Effect.isEffect(arg) && !Stream.isStream(arg)) {
-    const create = arg as (get: Context) => any
-    return function(get: Context, providedServices?: ServiceMap.ServiceMap<any>) {
+    const create = arg as (get: AtomContext) => any
+    return function(get: AtomContext, providedServices?: Context.Context<any>) {
       const value = create(get)
       switch (typeof value) {
         case "function":
@@ -517,11 +518,11 @@ const makeRead: {
       }
     }
   } else if (Effect.isEffect(arg)) {
-    return function(get: Context, providedServices?: ServiceMap.ServiceMap<any>) {
+    return function(get: AtomContext, providedServices?: Context.Context<any>) {
       return effect(get, arg as any, options, providedServices)
     }
   } else if (Stream.isStream(arg)) {
-    return function(get: Context, providedServices?: ServiceMap.ServiceMap<any>) {
+    return function(get: AtomContext, providedServices?: Context.Context<any>) {
       return stream(get, arg as any, options, providedServices)
     }
   }
@@ -540,13 +541,13 @@ const state = <A>(
   }, constSetSelf)
 
 const effect = <A, E>(
-  get: Context,
+  get: AtomContext,
   effect: Effect.Effect<A, E, Scope.Scope | AtomRegistry>,
   options?: {
     readonly initialValue?: A
     readonly uninterruptible?: boolean | undefined
   },
-  services?: ServiceMap.ServiceMap<any>
+  services?: Context.Context<any>
 ): AsyncResult.AsyncResult<A, E> => {
   const initialValue = options?.initialValue !== undefined
     ? AsyncResult.success<A, E>(options.initialValue)
@@ -555,10 +556,10 @@ const effect = <A, E>(
 }
 
 function makeEffect<A, E>(
-  ctx: Context,
+  ctx: AtomContext,
   effect: Effect.Effect<A, E, Scope.Scope | AtomRegistry>,
   initialValue: AsyncResult.AsyncResult<A, E>,
-  services = ServiceMap.empty(),
+  services = Context.empty(),
   uninterruptible = false
 ): AsyncResult.AsyncResult<A, E> {
   const previous = ctx.self<AsyncResult.AsyncResult<A, E>>()
@@ -573,7 +574,7 @@ function makeEffect<A, E>(
   let syncResult: AsyncResult.AsyncResult<A, E> | undefined
   let isAsync = false
   const cancel = runCallbackSync(
-    ServiceMap.makeUnsafe<Scope.Scope | AtomRegistry>(servicesMap),
+    Context.makeUnsafe<Scope.Scope | AtomRegistry>(servicesMap),
     effect,
     function(exit) {
       syncResult = AsyncResult.fromExitWithPrevious(exit, previous)
@@ -596,7 +597,7 @@ function makeEffect<A, E>(
 }
 
 function runCallbackSync<R, A, E, ER = never>(
-  services: ServiceMap.ServiceMap<R>,
+  services: Context.Context<R>,
   effect: Effect.Effect<A, E, R>,
   onExit: (exit: Exit.Exit<A, E | ER>) => void,
   uninterruptible = false
@@ -606,11 +607,8 @@ function runCallbackSync<R, A, E, ER = never>(
     return undefined
   }
   const runFork = Effect.runForkWith(services)
-  const scheduler = ServiceMap.get(services, Scheduler.Scheduler)
   const fiber = runFork(effect)
-  if ("flush" in scheduler) {
-    ;(scheduler as Scheduler.MixedScheduler).flush()
-  }
+  fiber.currentDispatcher?.flush()
   const result = fiber.pollUnsafe()
   if (result) {
     onExit(result)
@@ -634,14 +632,14 @@ function runCallbackSync<R, A, E, ER = never>(
  * @since 4.0.0
  * @category models
  */
-export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult<ServiceMap.ServiceMap<R>, ER>> {
+export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult<Context.Context<R>, ER>> {
   readonly factory: RuntimeFactory
 
   readonly layer: Atom<Layer.Layer<R, ER>>
 
   readonly atom: {
     <A, E>(
-      create: (get: Context) => Effect.Effect<A, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>,
+      create: (get: AtomContext) => Effect.Effect<A, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>,
       options?: {
         readonly initialValue?: A
         readonly uninterruptible?: boolean | undefined
@@ -651,12 +649,12 @@ export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult
       readonly initialValue?: A
       readonly uninterruptible?: boolean | undefined
     }): Atom<AsyncResult.AsyncResult<A, E | ER>>
-    <A, E>(create: (get: Context) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: {
+    <A, E>(create: (get: AtomContext) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: {
       readonly initialValue?: A
-    }): Atom<AsyncResult.AsyncResult<A, E | ER>>
+    }): Atom<AsyncResult.AsyncResult<A, E | ER | Cause.NoSuchElementError>>
     <A, E>(stream: Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: {
       readonly initialValue?: A
-    }): Atom<AsyncResult.AsyncResult<A, E | ER>>
+    }): Atom<AsyncResult.AsyncResult<A, E | ER | Cause.NoSuchElementError>>
   }
 
   readonly fn: {
@@ -698,7 +696,7 @@ export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult
 
   readonly pull: <A, E>(
     create:
-      | ((get: Context) => Stream.Stream<A, E, R | AtomRegistry | Reactivity.Reactivity>)
+      | ((get: AtomContext) => Stream.Stream<A, E, R | AtomRegistry | Reactivity.Reactivity>)
       | Stream.Stream<A, E, R | AtomRegistry | Reactivity.Reactivity>,
     options?: {
       readonly disableAccumulation?: boolean
@@ -710,7 +708,7 @@ export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult
     create:
       | Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>
       | ((
-        get: Context
+        get: AtomContext
       ) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>)
   ) => Writable<AsyncResult.AsyncResult<A, E>, A>
 }
@@ -723,7 +721,7 @@ export interface RuntimeFactory {
   <R, E>(
     create:
       | Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>
-      | ((get: Context) => Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>)
+      | ((get: AtomContext) => Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>)
   ): AtomRuntime<R, E>
   readonly memoMap: Layer.MemoMap
   readonly addGlobalLayer: <A, E>(layer: Layer.Layer<A, E, AtomRegistry | Reactivity.Reactivity>) => void
@@ -748,7 +746,7 @@ export const context: (options: {
   function factory<E, R>(
     create:
       | Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>
-      | ((get: Context) => Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>)
+      | ((get: AtomContext) => Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>)
   ): AtomRuntime<R, E> {
     const self = Object.create(RuntimeProto)
     self.keepAlive = false
@@ -763,7 +761,7 @@ export const context: (options: {
     )
     self.layer = layerAtom
 
-    self.read = function read(get: Context) {
+    self.read = function read(get: AtomContext) {
       const layer = get(layerAtom)
       const build = Effect.flatMap(Effect.scope, (scope) => Layer.buildWithMemoMap(layer, options.memoMap, scope))
       return effect(get, build, { uninterruptible: true })
@@ -776,10 +774,10 @@ export const context: (options: {
     globalLayer = Layer.provideMerge(globalLayer, Layer.provide(layer, Reactivity.layer))
   }
   const reactivityAtom = removeTtl(make(
-    Effect.servicesWith((services: ServiceMap.ServiceMap<Scope.Scope>) =>
-      Layer.buildWithMemoMap(Reactivity.layer, options.memoMap, ServiceMap.get(services, Scope.Scope))
+    Effect.contextWith((services: Context.Context<Scope.Scope>) =>
+      Layer.buildWithMemoMap(Reactivity.layer, options.memoMap, Context.get(services, Scope.Scope))
     ).pipe(
-      Effect.map(ServiceMap.get(Reactivity.Reactivity))
+      Effect.map(Context.get(Reactivity.Reactivity))
     )
   ))
   factory.withReactivity =
@@ -792,7 +790,7 @@ export const context: (options: {
         }))
         get.subscribe(atom, (value) => get.setSelf(value))
         return get.once(atom)
-      }) as any as A
+      }, { initialValueTarget: atom }) as any as A
   return factory
 }
 
@@ -824,12 +822,12 @@ export const withReactivity: (
 // -----------------------------------------------------------------------------
 
 const stream = <A, E>(
-  get: Context,
+  get: AtomContext,
   stream: Stream.Stream<A, E, AtomRegistry>,
   options?: {
     readonly initialValue?: A
   },
-  services?: ServiceMap.ServiceMap<any>
+  services?: Context.Context<any>
 ): AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError> => {
   const initialValue = options?.initialValue !== undefined
     ? AsyncResult.success<A, E>(options.initialValue)
@@ -838,13 +836,13 @@ const stream = <A, E>(
 }
 
 function makeStream<A, E>(
-  ctx: Context,
+  ctx: AtomContext,
   stream: Stream.Stream<A, E, AtomRegistry>,
   initialValue: AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>,
-  services = ServiceMap.empty()
+  services = Context.empty()
 ): AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError> {
   const previous = ctx.self<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>()
-  services = ServiceMap.add(services, AtomRegistry, ctx.registry)
+  services = Context.add(services, AtomRegistry, ctx.registry)
 
   const run = Effect.scopedWith((scope) =>
     Effect.flatMap(Channel.toPullScoped(stream.channel, scope), (pull) =>
@@ -886,7 +884,7 @@ function makeStream<A, E>(
   servicesMap.set(Scheduler.Scheduler.key, ctx.registry.scheduler)
 
   const cancel = runCallbackSync(
-    ServiceMap.makeUnsafe<AtomRegistry>(servicesMap),
+    Context.makeUnsafe<AtomRegistry>(servicesMap),
     run,
     constVoid,
     false
@@ -919,7 +917,7 @@ export const subscriptionRef: {
    * @category constructors
    */
   <A>(
-    ref: SubscriptionRef.SubscriptionRef<A> | ((get: Context) => SubscriptionRef.SubscriptionRef<A>)
+    ref: SubscriptionRef.SubscriptionRef<A> | ((get: AtomContext) => SubscriptionRef.SubscriptionRef<A>)
   ): Writable<A>
   // -----------------------------------------------------------------------------
   // constructors - subscription ref
@@ -932,14 +930,14 @@ export const subscriptionRef: {
   <A, E>(
     effect:
       | Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | AtomRegistry>
-      | ((get: Context) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | AtomRegistry>)
+      | ((get: AtomContext) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | AtomRegistry>)
   ): Writable<AsyncResult.AsyncResult<A, E>, A>
 } = (
   ref:
     | SubscriptionRef.SubscriptionRef<any>
-    | ((get: Context) => SubscriptionRef.SubscriptionRef<any>)
+    | ((get: AtomContext) => SubscriptionRef.SubscriptionRef<any>)
     | Effect.Effect<SubscriptionRef.SubscriptionRef<any>, any, Scope.Scope | AtomRegistry>
-    | ((get: Context) => Effect.Effect<SubscriptionRef.SubscriptionRef<any>, any, Scope.Scope | AtomRegistry>)
+    | ((get: AtomContext) => Effect.Effect<SubscriptionRef.SubscriptionRef<any>, any, Scope.Scope | AtomRegistry>)
 ) =>
   makeSubRef(
     readable((get) => {
@@ -952,11 +950,11 @@ export const subscriptionRef: {
   ) as any
 
 const readSubscriptionRef = (
-  get: Context,
+  get: AtomContext,
   sub:
     | SubscriptionRef.SubscriptionRef<any>
     | AsyncResult.AsyncResult<SubscriptionRef.SubscriptionRef<any>, any>,
-  services = ServiceMap.empty()
+  services = Context.empty()
 ) => {
   if (SubscriptionRef.isSubscriptionRef(sub)) {
     get.addFinalizer(
@@ -982,7 +980,7 @@ const makeSubRef = (
     SubscriptionRef.SubscriptionRef<any> | AsyncResult.AsyncResult<SubscriptionRef.SubscriptionRef<any>, any>
   >,
   read: (
-    get: Context,
+    get: AtomContext,
     ref: SubscriptionRef.SubscriptionRef<any> | AsyncResult.Success<SubscriptionRef.SubscriptionRef<any>, any>
   ) => any
 ) => {
@@ -1211,8 +1209,8 @@ function makeResultFn<Arg, E, A>(
     : undefined
 
   function read(
-    get: Context,
-    services?: ServiceMap.ServiceMap<any>
+    get: AtomContext,
+    services?: Context.Context<any>
   ): AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError> {
     const fibers = fibersAtom ? get(fibersAtom) : undefined
     ;(get as any).isFn = true
@@ -1271,7 +1269,7 @@ export type PullResult<A, E = never> = AsyncResult.AsyncResult<{
  * @category constructors
  */
 export const pull = <A, E>(
-  create: ((get: Context) => Stream.Stream<A, E, AtomRegistry>) | Stream.Stream<A, E, AtomRegistry>,
+  create: ((get: AtomContext) => Stream.Stream<A, E, AtomRegistry>) | Stream.Stream<A, E, AtomRegistry>,
   options?: {
     readonly disableAccumulation?: boolean | undefined
   }
@@ -1284,9 +1282,9 @@ export const pull = <A, E>(
 }
 
 const makeStreamPullEffect = <A, E>(
-  get: Context,
+  get: AtomContext,
   pullSignal: Atom<number>,
-  create: Stream.Stream<A, E, AtomRegistry> | ((get: Context) => Stream.Stream<A, E, AtomRegistry>),
+  create: Stream.Stream<A, E, AtomRegistry> | ((get: AtomContext) => Stream.Stream<A, E, AtomRegistry>),
   options?: {
     readonly disableAccumulation?: boolean | undefined
   }
@@ -1299,7 +1297,7 @@ const makeStreamPullEffect = <A, E>(
     Stream.toPull(typeof create === "function" ? create(get) : create),
     (pullChunk) => {
       const fiber = Fiber.getCurrent()!
-      const services = fiber.services as ServiceMap.ServiceMap<AtomRegistry | Scope.Scope>
+      const services = fiber.context as Context.Context<AtomRegistry | Scope.Scope>
       let acc: ReadonlyArray<A> = Arr.empty<A>()
       const pull: Effect.Effect<
         {
@@ -1462,7 +1460,7 @@ export const withFallback: {
     >
   > =>
 {
-  function withFallback(get: Context) {
+  function withFallback(get: AtomContext) {
     const result = get(self)
     if (result._tag === "Initial") {
       return AsyncResult.waiting(get(fallback))
@@ -1600,33 +1598,67 @@ export const transform: {
    * @since 4.0.0
    * @category combinators
    */
-  <R extends Atom<any>, B>(f: (get: Context, atom: R) => B): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
+  <R extends Atom<any>, B>(
+    f: (get: AtomContext, atom: R) => B,
+    options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }
+  ): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <R extends Atom<any>, B>(self: R, f: (get: Context, atom: R) => B): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
+  <R extends Atom<any>, B>(
+    self: R,
+    f: (get: AtomContext, atom: R) => B,
+    options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }
+  ): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>
 } = dual(
-  2,
-  (<A, B>(self: Atom<A>, f: (get: Context, atom: Atom<A>) => B): Atom<B> =>
-    isWritable(self)
-      ? writable(
-        (get) => f(get, self),
-        function(ctx, value) {
-          ctx.set(self, value)
-        },
-        self.refresh ?? function(refresh) {
-          refresh(self)
-        }
-      )
-      : readable(
-        (get) => f(get, self),
-        self.refresh ?? function(refresh) {
-          refresh(self)
-        }
-      )) as any
+  (args) => isAtom(args[0]),
+  (<A, B>(
+    self: Atom<A>,
+    f: (get: AtomContext, atom: Atom<A>, options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }) => B,
+    options?: {
+      readonly initialValueTarget?: Atom<B> | undefined
+    }
+  ): Atom<B> => {
+    const atom = removeTtl(
+      isWritable(self)
+        ? writable(
+          (get) => f(get, self),
+          function(ctx, value) {
+            ctx.set(self, value)
+          },
+          self.refresh ?? function(refresh) {
+            refresh(self)
+          }
+        )
+        : readable(
+          (get) => f(get, self),
+          self.refresh ?? function(refresh) {
+            refresh(self)
+          }
+        )
+    )
+    if (options?.initialValueTarget) {
+      ;(atom as Mutable<Atom<B>>).initialValueTarget = getInitialValueTarget(options.initialValueTarget)
+    }
+    return atom
+  }) as any
 )
 
+const getInitialValueTarget = <A>(atom: Atom<A>): Atom<A> => {
+  let target = atom
+  while (target.initialValueTarget) {
+    target = target.initialValueTarget
+  }
+  return target
+}
+
 /**
  * @since 4.0.0
  * @category combinators
@@ -1684,16 +1716,16 @@ export const debounce: {
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
   /**
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): WithoutSerializable<A>
+  <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>
 } = dual(
   2,
-  <A>(self: Atom<A>, duration: Duration.DurationInput): Atom<A> => {
-    const millis = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+  <A>(self: Atom<A>, duration: Duration.Input): Atom<A> => {
+    const millis = Duration.toMillis(Duration.fromInputUnsafe(duration))
     return transform(self, function(get) {
       let timeout: number | undefined
       let value = get.once(self)
@@ -1710,7 +1742,7 @@ export const debounce: {
         timeout = setTimeout(update, millis) as any
       })
       return value
-    })
+    }, { initialValueTarget: self })
   }
 )
 
@@ -1729,7 +1761,7 @@ export const withRefresh: {
    * @since 4.0.0
    * @category combinators
    */
-  (duration: Duration.DurationInput): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
+  (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>
   /**
    * Ensures that the value of the atom is refreshed at most once per specified
    * duration.
@@ -1737,19 +1769,143 @@ export const withRefresh: {
    * @since 4.0.0
    * @category combinators
    */
-  <A extends Atom<any>>(self: A, duration: Duration.DurationInput): WithoutSerializable<A>
+  <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>
 } = dual(
   2,
-  <A>(self: Atom<A>, duration: Duration.DurationInput): Atom<A> => {
-    const millis = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+  <A>(self: Atom<A>, duration: Duration.Input): Atom<A> => {
+    const millis = Duration.toMillis(Duration.fromInputUnsafe(duration))
     return transform(self, function(get) {
       const handle = setTimeout(() => get.refresh(self), millis) as any
       get.addFinalizer(() => clearTimeout(handle))
       return get(self)
-    })
+    }, { initialValueTarget: self })
   }
 )
 
+/**
+ * Adds stale-while-revalidate refresh behavior to an async result atom.
+ *
+ * Automatic revalidation during reads is skipped while the current value is
+ * fresh within `staleTime`. Manual `refresh` calls remain forceful and always
+ * forward to the wrapped atom.
+ *
+ * Use `revalidateOnMount` to control whether stale data should trigger a
+ * background refresh on first mount. Use `revalidateOnFocus` to control
+ * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
+ *
+ * @since 4.0.0
+ * @category combinators
+ */
+export const swr: {
+  /**
+   * Adds stale-while-revalidate refresh behavior to an async result atom.
+   *
+   * Automatic revalidation during reads is skipped while the current value is
+   * fresh within `staleTime`. Manual `refresh` calls remain forceful and always
+   * forward to the wrapped atom.
+   *
+   * Use `revalidateOnMount` to control whether stale data should trigger a
+   * background refresh on first mount. Use `revalidateOnFocus` to control
+   * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    options: {
+      readonly staleTime: Duration.Input
+      readonly revalidateOnMount?: boolean | undefined
+      readonly revalidateOnFocus?: boolean | "always" | undefined
+      readonly focusSignal?: Atom<any> | undefined
+    }
+  ): <R extends Atom<AsyncResult.AsyncResult<any, any>>>(self: R) => WithoutSerializable<R>
+  /**
+   * Adds stale-while-revalidate refresh behavior to an async result atom.
+   *
+   * Automatic revalidation during reads is skipped while the current value is
+   * fresh within `staleTime`. Manual `refresh` calls remain forceful and always
+   * forward to the wrapped atom.
+   *
+   * Use `revalidateOnMount` to control whether stale data should trigger a
+   * background refresh on first mount. Use `revalidateOnFocus` to control
+   * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  <R extends Atom<AsyncResult.AsyncResult<any, any>>>(
+    self: R,
+    options: {
+      readonly staleTime: Duration.Input
+      readonly revalidateOnMount?: boolean | undefined
+      readonly revalidateOnFocus?: boolean | "always" | undefined
+      readonly focusSignal?: Atom<any> | undefined
+    }
+  ): WithoutSerializable<R>
+} = dual(
+  2,
+  <A, E>(
+    self: Atom<AsyncResult.AsyncResult<A, E>>,
+    options: {
+      readonly staleTime: Duration.Input
+      readonly revalidateOnMount?: boolean | undefined
+      readonly revalidateOnFocus?: boolean | "always" | undefined
+      readonly focusSignal?: Atom<any> | undefined
+    }
+  ): Atom<AsyncResult.AsyncResult<A, E>> => {
+    const staleTime = Duration.toMillis(Duration.fromInputUnsafe(options.staleTime))
+    return transform(self, (get) => {
+      const current = get.once(self)
+      get.subscribe(self, (value) => {
+        get.setSelf(value)
+      })
+      if (options.revalidateOnFocus && options.focusSignal) {
+        get.once(options.focusSignal)
+        get.subscribe(
+          options.focusSignal,
+          options.revalidateOnFocus === "always" ? () => get.refresh(self) : () => {
+            const current = get.once(self)
+            if (shouldRevalidateSWR(current, staleTime)) {
+              get.refresh(self)
+            }
+          }
+        )
+      }
+      const firstRead = Option.isNone(get.self<AsyncResult.AsyncResult<A, E>>())
+      if (firstRead && options.revalidateOnMount === false) {
+        return current
+      }
+      if (shouldRevalidateSWR(current, staleTime)) {
+        get.refresh(self)
+      }
+      return current
+    }, { initialValueTarget: self })
+  }
+) as any
+
+const swrTimestamp = <A, E>(result: AsyncResult.AsyncResult<A, E>): Option.Option<number> => {
+  if (result._tag === "Success") {
+    return Option.some(result.timestamp)
+  }
+  if (result._tag === "Failure") {
+    return Option.map(result.previousSuccess, (success) => success.timestamp)
+  }
+  return Option.none()
+}
+
+const isFreshWithin = (timestamp: number, staleTime: number, now: number): boolean => now - timestamp < staleTime
+
+const shouldRevalidateSWR = <A, E>(result: AsyncResult.AsyncResult<A, E>, staleTime: number): boolean => {
+  if (result.waiting) {
+    return false
+  }
+  const timestamp = Option.getOrUndefined(swrTimestamp(result))
+  if (timestamp === undefined) {
+    return result._tag !== "Initial"
+  }
+  return !isFreshWithin(timestamp, staleTime, Date.now())
+}
+
 /**
  * @since 4.0.0
  * @category Optimistic
@@ -1962,7 +2118,7 @@ export const makeRefreshOnSignal = <_>(signal: Atom<_>) => <A extends Atom<any>>
     get.subscribe(signal, (_) => get.refresh(self))
     get.subscribe(self, (value) => get.setSelf(value))
     return get.once(self)
-  }) as any
+  }, { initialValueTarget: self }) as any
 
 /**
  * @since 4.0.0
@@ -2045,7 +2201,7 @@ export const kvs = <S extends Schema.Codec<any, any>, const Mode extends "sync"
  */
 export const searchParam = <S extends Schema.Codec<any, string> = never>(name: string, options?: {
   readonly schema?: S | undefined
-}): Writable<S extends never ? string : Option.Option<S["Type"]>> => {
+}): Writable<[S] extends [never] ? string : Option.Option<S["Type"]>> => {
   const decode = options?.schema && Schema.decodeExit(options.schema)
   const encode = options?.schema && Schema.encodeExit(options.schema)
   return writable(
@@ -2070,7 +2226,7 @@ export const searchParam = <S extends Schema.Codec<any, string> = never>(name: s
         window.removeEventListener("pushstate", handleUpdate)
       })
       const value = new URLSearchParams(window.location.search).get(name) || ""
-      return decode ? Exit.findErrorOption(decode(value)) : value as any
+      return decode ? Exit.getSuccess(decode(value)) : value as any
     },
     (ctx, value: any) => {
       if (typeof window === "undefined") {