effect 4.0.0-beta.0 → 4.0.0-beta.10

package/src/unstable/persistence/PersistedQueue.ts

@@ -9,6 +9,7 @@ import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import { flow } from "../../Function.ts"
 import * as Iterable from "../../Iterable.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as MutableRef from "../../MutableRef.ts"
 import * as Queue from "../../Queue.ts"
@@ -235,14 +236,14 @@ export const layerStoreMemory: Layer.Layer<
   }
   const ids = new Set<string>()
   const queues = new Map<string, {
-    latch: Effect.Latch
+    latch: Latch.Latch
     items: Set<Entry>
   }>()
   const getOrCreateQueue = (name: string) => {
     let queue = queues.get(name)
     if (!queue) {
       queue = {
-        latch: Effect.makeLatchUnsafe(false),
+        latch: Latch.makeUnsafe(false),
         items: new Set()
       }
       queues.set(name, queue)
@@ -294,26 +295,26 @@ export const layerStoreMemory: Layer.Layer<
 export const makeStoreRedis = Effect.fnUntraced(function*(
   options?: {
     readonly prefix?: string | undefined
-    readonly pollInterval?: Duration.DurationInput | undefined
-    readonly lockRefreshInterval?: Duration.DurationInput | undefined
-    readonly lockExpiration?: Duration.DurationInput | undefined
+    readonly pollInterval?: Duration.Input | undefined
+    readonly lockRefreshInterval?: Duration.Input | undefined
+    readonly lockExpiration?: Duration.Input | undefined
   }
 ) {
   const redis = yield* Redis.Redis
 
   const pollInterval = Duration.max(
-    options?.pollInterval ? Duration.fromDurationInputUnsafe(options.pollInterval) : Duration.seconds(1),
+    options?.pollInterval ? Duration.fromInputUnsafe(options.pollInterval) : Duration.seconds(1),
     Duration.millis(1)
   )
   const lockRefreshMillis = Math.max(
     options?.lockRefreshInterval
-      ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.lockRefreshInterval))
+      ? Duration.toMillis(Duration.fromInputUnsafe(options.lockRefreshInterval))
       : 30_000,
     1
   )
   const lockExpirationMillis = Math.max(
     options?.lockExpiration
-      ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.lockExpiration))
+      ? Duration.toMillis(Duration.fromInputUnsafe(options.lockExpiration))
       : 90_000,
     1
   )
@@ -345,8 +346,8 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
       const pendingKey = keyPending(name)
       const queue = yield* Queue.make<Element>()
       const takers = MutableRef.make(0)
-      const pollLatch = Effect.makeLatchUnsafe()
-      const takenLatch = Effect.makeLatchUnsafe()
+      const pollLatch = Latch.makeUnsafe()
+      const takenLatch = Latch.makeUnsafe()
 
       yield* Effect.addFinalizer(() =>
         Effect.orDie(
@@ -653,9 +654,9 @@ end
 export const layerStoreRedis: (
   options?: {
     readonly prefix?: string | undefined
-    readonly pollInterval?: Duration.DurationInput | undefined
-    readonly lockRefreshInterval?: Duration.DurationInput | undefined
-    readonly lockExpiration?: Duration.DurationInput | undefined
+    readonly pollInterval?: Duration.Input | undefined
+    readonly lockRefreshInterval?: Duration.Input | undefined
+    readonly lockExpiration?: Duration.Input | undefined
   } | undefined
 ) => Layer.Layer<
   PersistedQueueStore,
@@ -670,9 +671,9 @@ export const layerStoreRedis: (
 export const makeStoreSql: (
   options?: {
     readonly tableName?: string | undefined
-    readonly pollInterval?: Duration.DurationInput | undefined
-    readonly lockRefreshInterval?: Duration.DurationInput | undefined
-    readonly lockExpiration?: Duration.DurationInput | undefined
+    readonly pollInterval?: Duration.Input | undefined
+    readonly lockRefreshInterval?: Duration.Input | undefined
+    readonly lockExpiration?: Duration.Input | undefined
   } | undefined
 ) => Effect.Effect<
   PersistedQueueStore["Service"],
@@ -683,15 +684,15 @@ export const makeStoreSql: (
   const tableName = options?.tableName ?? "effect_queue"
   const tableNameSql = sql(tableName)
   const pollInterval = Duration.max(
-    options?.pollInterval ? Duration.fromDurationInputUnsafe(options.pollInterval) : Duration.millis(1000),
+    options?.pollInterval ? Duration.fromInputUnsafe(options.pollInterval) : Duration.millis(1000),
     Duration.millis(1)
   )
   const lockRefreshInterval = Duration.max(
-    options?.lockRefreshInterval ? Duration.fromDurationInputUnsafe(options.lockRefreshInterval) : Duration.seconds(30),
+    options?.lockRefreshInterval ? Duration.fromInputUnsafe(options.lockRefreshInterval) : Duration.seconds(30),
     Duration.millis(1)
   )
   const lockExpiration = Duration.max(
-    options?.lockExpiration ? Duration.fromDurationInputUnsafe(options.lockExpiration) : Duration.minutes(2),
+    options?.lockExpiration ? Duration.fromInputUnsafe(options.lockExpiration) : Duration.minutes(2),
     Duration.millis(1)
   )
   const lockExpirationSql = sql.literal(Math.ceil(Duration.toSeconds(lockExpiration)).toString())
@@ -930,8 +931,8 @@ export const makeStoreSql: (
     lookup: Effect.fnUntraced(function*({ maxAttempts, name }: QueueKey) {
       const queue = yield* Queue.make<Element>()
       const takers = MutableRef.make(0)
-      const pollLatch = Effect.makeLatchUnsafe()
-      const takenLatch = Effect.makeLatchUnsafe()
+      const pollLatch = Latch.makeUnsafe()
+      const takenLatch = Latch.makeUnsafe()
 
       yield* Effect.addFinalizer(() =>
         Effect.flatMap(Queue.clear(queue), (elements) => {
@@ -1098,9 +1099,9 @@ class QueueKey extends Data.Class<{
 export const layerStoreSql: (
   options?: {
     readonly tableName?: string | undefined
-    readonly pollInterval?: Duration.DurationInput | undefined
-    readonly lockRefreshInterval?: Duration.DurationInput | undefined
-    readonly lockExpiration?: Duration.DurationInput | undefined
+    readonly pollInterval?: Duration.Input | undefined
+    readonly lockRefreshInterval?: Duration.Input | undefined
+    readonly lockExpiration?: Duration.Input | undefined
   } | undefined
 ) => Layer.Layer<
   PersistedQueueStore,

package/src/unstable/persistence/Persistence.ts

@@ -42,7 +42,7 @@ export class PersistenceError extends Schema.ErrorClass(ErrorTypeId)({
 export class Persistence extends ServiceMap.Service<Persistence, {
   readonly make: (options: {
     readonly storeId: string
-    readonly timeToLive?: (exit: Exit.Exit<unknown, unknown>, key: Persistable.Any) => Duration.DurationInput
+    readonly timeToLive?: (exit: Exit.Exit<unknown, unknown>, key: Persistable.Any) => Duration.Input
   }) => Effect.Effect<PersistenceStore, never, Scope.Scope>
 }>()("effect/persistence/Persistence") {}
 
@@ -169,7 +169,7 @@ export const layer = Layer.effect(Persistence)(Effect.gen(function*() {
           return out
         }),
         set(key, value) {
-          const ttl = Duration.fromDurationInputUnsafe(timeToLive(value, key))
+          const ttl = Duration.fromInputUnsafe(timeToLive(value, key))
           if (Duration.isZero(ttl) || Duration.isNegative(ttl)) return Effect.void
           return Persistable.serializeExit(key, value).pipe(
             Effect.flatMap((encoded) =>
@@ -180,7 +180,7 @@ export const layer = Layer.effect(Persistence)(Effect.gen(function*() {
         setMany: Effect.fnUntraced(function*(entries) {
           const encodedEntries = Arr.empty<readonly [string, object, Duration.Duration | undefined]>()
           for (const [key, value] of entries) {
-            const ttl = Duration.fromDurationInputUnsafe(timeToLive(value, key))
+            const ttl = Duration.fromInputUnsafe(timeToLive(value, key))
             if (Duration.isZero(ttl) || Duration.isNegative(ttl)) continue
             const encoded = Persistable.serializeExit(key, value)
             const exit = Exit.isExit(encoded)

package/src/unstable/persistence/RateLimiter.ts

@@ -32,7 +32,7 @@ export interface RateLimiter {
   readonly consume: (options: {
     readonly algorithm?: "fixed-window" | "token-bucket" | undefined
     readonly onExceeded?: "delay" | "fail" | undefined
-    readonly window: Duration.DurationInput
+    readonly window: Duration.Input
     readonly limit: number
     readonly key: string
     readonly tokens?: number | undefined
@@ -62,7 +62,7 @@ export const make: Effect.Effect<
       const tokens = options.tokens ?? 1
       const onExceeded = options.onExceeded ?? "fail"
       const algorithm = options.algorithm ?? "fixed-window"
-      const window = Duration.max(Duration.fromDurationInputUnsafe(options.window), Duration.millis(1))
+      const window = Duration.max(Duration.fromInputUnsafe(options.window), Duration.millis(1))
       const windowMillis = Duration.toMillis(window)
       const refillRate = Duration.divideUnsafe(window, options.limit)
       const refillRateMillis = Duration.toMillis(refillRate)
@@ -222,7 +222,7 @@ export const makeWithRateLimiter: Effect.Effect<
   ((options: {
     readonly algorithm?: "fixed-window" | "token-bucket" | undefined
     readonly onExceeded?: "delay" | "fail" | undefined
-    readonly window: Duration.DurationInput
+    readonly window: Duration.Input
     readonly limit: number
     readonly key: string
     readonly tokens?: number | undefined
@@ -266,7 +266,7 @@ export const makeWithRateLimiter: Effect.Effect<
 export const makeSleep: Effect.Effect<
   ((options: {
     readonly algorithm?: "fixed-window" | "token-bucket" | undefined
-    readonly window: Duration.DurationInput
+    readonly window: Duration.Input
     readonly limit: number
     readonly key: string
     readonly tokens?: number | undefined

package/src/unstable/process/ChildProcess.ts

@@ -283,7 +283,7 @@ export interface KillOptions {
    * Defaults to `undefined`, which means that no timeout will be enforced by
    * default.
    */
-  readonly forceKillAfter?: Duration.DurationInput | undefined
+  readonly forceKillAfter?: Duration.Input | undefined
 }
 
 /**
@@ -414,7 +414,7 @@ export interface CommandOptions extends KillOptions {
    * the value of `globalThis.process.env`, prioritizing the values in `env`
    * when conflicts exist.
    */
-  readonly env?: Record<string, string> | undefined
+  readonly env?: Record<string, string | undefined> | undefined
   /**
    * If set to `true`, the child process uses both the values in `env` as well
    * as the values in `globalThis.process.env`, prioritizing the values in `env`

package/src/unstable/process/ChildProcessSpawner.ts

@@ -76,10 +76,16 @@ export interface ChildProcessHandle {
   readonly stdin: Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>
   /**
    * The standard output stream for the child process.
+   *
+   * Note: Using alongside `all` may cause interleaving of output and unexpected
+   * results.
    */
   readonly stdout: Stream.Stream<Uint8Array, PlatformError.PlatformError>
   /**
    * The standard error stream for the child process.
+   *
+   * Note: Using alongside `all` may cause interleaving of output and unexpected
+   * results.
    */
   readonly stderr: Stream.Stream<Uint8Array, PlatformError.PlatformError>
   /**

package/src/unstable/reactivity/Atom.ts

@@ -169,25 +169,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,
@@ -1684,16 +1684,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)
@@ -1729,7 +1729,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,11 +1737,11 @@ 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))
@@ -2291,16 +2291,18 @@ export const serializable: {
 } = dual(2, <R extends Atom<any>, A, I>(self: R, options: {
   readonly key: string
   readonly schema: Schema.Codec<A, I>
-}): R & Serializable<any> =>
-  Object.assign(Object.create(Object.getPrototypeOf(self)), {
+}): R & Serializable<any> => {
+  const codecJson = Schema.toCodecJson(options.schema)
+  return Object.assign(Object.create(Object.getPrototypeOf(self)), {
     ...self,
     label: self.label ?? [options.key, new Error().stack?.split("\n")[5] ?? ""],
     [SerializableTypeId]: {
       key: options.key,
-      encode: Schema.encodeSync(options.schema),
-      decode: Schema.decodeSync(options.schema)
+      encode: Schema.encodeSync(codecJson),
+      decode: Schema.decodeSync(codecJson)
     }
-  }))
+  })
+})
 
 /**
  * @since 4.0.0

package/src/unstable/reactivity/AtomHttpApi.ts

@@ -51,8 +51,8 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
       infer _Name,
       infer _Method,
       infer _Path,
-      infer _PathSchema,
-      infer _UrlParams,
+      infer _Params,
+      infer _Query,
       infer _Payload,
       infer _Headers,
       infer _Success,
@@ -62,7 +62,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
     >
   ] ? Atom.AtomResultFn<
       Simplify<
-        HttpApiEndpoint.ClientRequest<_PathSchema, _UrlParams, _Payload, _Headers, false> & {
+        HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, false> & {
           readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
         }
       >,
@@ -88,8 +88,8 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
         infer _Name,
         infer _Method,
         infer _Path,
-        infer _PathSchema,
-        infer _UrlParams,
+        infer _Params,
+        infer _Query,
         infer _Payload,
         infer _Headers,
         infer _Success,
@@ -98,12 +98,12 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
         infer _RE
       >
     ] ? Simplify<
-        HttpApiEndpoint.ClientRequest<_PathSchema, _UrlParams, _Payload, _Headers, WithResponse> & {
+        HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, WithResponse> & {
           readonly reactivityKeys?:
             | ReadonlyArray<unknown>
             | ReadonlyRecord<string, ReadonlyArray<unknown>>
             | undefined
-          readonly timeToLive?: Duration.DurationInput | undefined
+          readonly timeToLive?: Duration.Input | undefined
         }
       >
       : never
@@ -112,7 +112,8 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
       infer _Name,
       infer _Method,
       infer _Path,
-      infer _UrlParams,
+      infer _Params,
+      infer _Query,
       infer _Payload,
       infer _Headers,
       infer _Success,
@@ -170,8 +171,8 @@ export const Service = <Self>() =>
 
   const mutationFamily = Atom.family(({ endpoint, group, withResponse }: MutationKey) =>
     self.runtime.fn<{
-      path: any
-      urlParams: any
+      params: any
+      query: any
       headers: any
       payload: any
       reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
@@ -217,26 +218,26 @@ export const Service = <Self>() =>
     group: string,
     endpoint: string,
     request: {
-      readonly path?: any
-      readonly urlParams?: any
+      readonly params?: any
+      readonly query?: any
       readonly payload?: any
       readonly headers?: any
       readonly withResponse?: boolean
       readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
-      readonly timeToLive?: Duration.DurationInput | undefined
+      readonly timeToLive?: Duration.Input | undefined
     }
   ) =>
     queryFamily({
       group,
       endpoint,
-      path: request.path,
-      urlParams: request.urlParams,
+      params: request.params,
+      query: request.query,
       payload: request.payload,
       headers: request.headers,
       withResponse: request.withResponse ?? false,
       reactivityKeys: request.reactivityKeys,
       timeToLive: request.timeToLive
-        ? Duration.fromDurationInputUnsafe(request.timeToLive)
+        ? Duration.fromInputUnsafe(request.timeToLive)
         : undefined
     })) as any
 
@@ -252,8 +253,8 @@ interface MutationKey {
 interface QueryKey {
   group: string
   endpoint: string
-  path: any
-  urlParams: any
+  params: any
+  query: any
   headers: any
   payload: any
   withResponse: boolean

package/src/unstable/reactivity/AtomRpc.ts

@@ -71,7 +71,7 @@ export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any, E>
         | ReadonlyArray<unknown>
         | ReadonlyRecord<string, ReadonlyArray<unknown>>
         | undefined
-      readonly timeToLive?: Duration.DurationInput | undefined
+      readonly timeToLive?: Duration.Input | undefined
     }
   ) => Rpc.ExtractTag<Rpcs, Tag> extends Rpc.Rpc<
     infer _Tag,
@@ -208,7 +208,7 @@ export const Service = <Self>() =>
         | ReadonlyArray<unknown>
         | ReadonlyRecord<string, ReadonlyArray<unknown>>
         | undefined
-      readonly timeToLive?: Duration.DurationInput | undefined
+      readonly timeToLive?: Duration.Input | undefined
     }
   ) =>
     queryFamily({
@@ -219,7 +219,7 @@ export const Service = <Self>() =>
         : undefined,
       reactivityKeys: options?.reactivityKeys,
       timeToLive: options?.timeToLive
-        ? Duration.fromDurationInputUnsafe(options.timeToLive)
+        ? Duration.fromInputUnsafe(options.timeToLive)
         : undefined
     }) as any
 

package/src/unstable/reactivity/Hydration.ts

@@ -0,0 +1,112 @@
+/**
+ * @since 4.0.0
+ */
+import * as AsyncResult from "./AsyncResult.ts"
+import * as Atom from "./Atom.ts"
+import type * as AtomRegistry from "./AtomRegistry.ts"
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface DehydratedAtom {
+  readonly "~effect/reactivity/DehydratedAtom": true
+}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface DehydratedAtomValue extends DehydratedAtom {
+  readonly key: string
+  readonly value: unknown
+  readonly dehydratedAt: number
+  readonly resultPromise?: Promise<unknown> | undefined
+}
+
+/**
+ * @since 4.0.0
+ * @category dehydration
+ */
+export const dehydrate = (
+  registry: AtomRegistry.AtomRegistry,
+  options?: {
+    /**
+     * How to encode `AsyncResult.Initial` values. Default is "ignore".
+     */
+    readonly encodeInitialAs?: "ignore" | "promise" | "value-only" | undefined
+  }
+): Array<DehydratedAtom> => {
+  const encodeInitialResultMode = options?.encodeInitialAs ?? "ignore"
+  const arr: Array<DehydratedAtomValue> = []
+  const now = Date.now()
+  registry.getNodes().forEach((node, key) => {
+    if (!Atom.isSerializable(node.atom)) return
+    const atom = node.atom
+    const value = node.value()
+    const isInitial = AsyncResult.isAsyncResult(value) && AsyncResult.isInitial(value)
+    if (encodeInitialResultMode === "ignore" && isInitial) return
+    const encodedValue = atom[Atom.SerializableTypeId].encode(value)
+
+    // Create a promise that resolves when the atom moves out of Initial state
+    let resultPromise: Promise<unknown> | undefined
+    if (encodeInitialResultMode === "promise" && isInitial) {
+      resultPromise = new Promise((resolve) => {
+        const unsubscribe = registry.subscribe(atom, (newValue) => {
+          if (AsyncResult.isAsyncResult(newValue) && !AsyncResult.isInitial(newValue)) {
+            resolve(atom[Atom.SerializableTypeId].encode(newValue))
+            unsubscribe()
+          }
+        })
+      })
+    }
+
+    arr.push({
+      "~effect/reactivity/DehydratedAtom": true,
+      key: key as string,
+      value: encodedValue,
+      dehydratedAt: now,
+      resultPromise
+    })
+  })
+  return arr as any
+}
+
+/**
+ * @since 4.0.0
+ * @category dehydration
+ */
+export const toValues = (state: ReadonlyArray<DehydratedAtom>): Array<DehydratedAtomValue> => state as any
+
+/**
+ * @since 4.0.0
+ * @category hydration
+ */
+export const hydrate = (
+  registry: AtomRegistry.AtomRegistry,
+  dehydratedState: Iterable<DehydratedAtom>
+): void => {
+  for (const datom of (dehydratedState as Iterable<DehydratedAtomValue>)) {
+    registry.setSerializable(datom.key, datom.value)
+
+    // If there's a resultPromise, it means this was in Initial state when dehydrated
+    // and we should wait for it to resolve to a non-Initial state, then update the registry
+    if (!datom.resultPromise) continue
+    datom.resultPromise.then((resolvedValue) => {
+      // Try to update the existing node directly instead of using setSerializable
+      const nodes = registry.getNodes()
+      const node = nodes.get(datom.key)
+      if (node) {
+        // Decode the resolved value using the node's atom serializable decoder
+        const atom = node.atom as any
+        if (atom[Atom.SerializableTypeId]) {
+          const decoded = atom[Atom.SerializableTypeId].decode(resolvedValue)
+          ;(node as any).setValue(decoded)
+        }
+      } else {
+        // Fallback to setSerializable if node doesn't exist yet
+        registry.setSerializable(datom.key, resolvedValue)
+      }
+    })
+  }
+}

package/src/unstable/reactivity/index.ts

@@ -34,6 +34,11 @@ export * as AtomRegistry from "./AtomRegistry.ts"
  */
 export * as AtomRpc from "./AtomRpc.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as Hydration from "./Hydration.ts"
+
 /**
  * @since 4.0.0
  */

package/src/unstable/rpc/Rpc.ts

@@ -61,7 +61,7 @@ export interface Rpc<
   readonly payloadSchema: Payload
   readonly successSchema: Success
   readonly errorSchema: Error
-  readonly defectSchema: DefectSchema
+  readonly defectSchema: Schema.Top
   readonly annotations: ServiceMap.ServiceMap<never>
   readonly middlewares: ReadonlySet<Middleware>
   readonly "~requires": Requires
@@ -183,7 +183,7 @@ export interface AnyWithProps extends Pipeable {
   readonly payloadSchema: Schema.Top
   readonly successSchema: Schema.Top
   readonly errorSchema: Schema.Top
-  readonly defectSchema: DefectSchema
+  readonly defectSchema: Schema.Top
   readonly annotations: ServiceMap.ServiceMap<never>
   readonly middlewares: ReadonlySet<RpcMiddleware.AnyServiceWithProps>
   readonly "~requires": any
@@ -696,7 +696,7 @@ const makeProto = <
   readonly payloadSchema: Payload
   readonly successSchema: Success
   readonly errorSchema: Error
-  readonly defectSchema: DefectSchema
+  readonly defectSchema: Schema.Top
   readonly annotations: ServiceMap.ServiceMap<never>
   readonly middlewares: ReadonlySet<Middleware>
 }): Rpc<Tag, Payload, Success, Error, Middleware, Requires> => {