effect 4.0.0-beta.3 → 4.0.0-beta.5

package/src/unstable/http/HttpBody.ts

@@ -279,7 +279,7 @@ export class FormData extends Proto {
  * @since 4.0.0
  * @category constructors
  */
-export const makeFormData = (body: globalThis.FormData): FormData => new FormData(body)
+export const formData = (body: globalThis.FormData): FormData => new FormData(body)
 
 /**
  * @since 4.0.0
@@ -308,18 +308,18 @@ const appendFormDataValue = (formData: globalThis.FormData, key: string, value:
  * @since 4.0.0
  * @category constructors
  */
-export const makeFormDataRecord = (entries: FormDataInput): FormData => {
-  const formData = new globalThis.FormData()
+export const formDataRecord = (entries: FormDataInput): FormData => {
+  const data = new globalThis.FormData()
   for (const [key, value] of Object.entries(entries)) {
     if (Array.isArray(value)) {
       for (const item of value) {
-        appendFormDataValue(formData, key, item)
+        appendFormDataValue(data, key, item)
       }
     } else {
-      appendFormDataValue(formData, key, value as FormDataCoercible)
+      appendFormDataValue(data, key, value as FormDataCoercible)
     }
   }
-  return makeFormData(formData)
+  return formData(data)
 }
 
 /**

package/src/unstable/http/HttpClientRequest.ts

@@ -826,7 +826,7 @@ export const bodyFormData: {
    * @category combinators
    */
   (self: HttpClientRequest, body: FormData): HttpClientRequest
-} = dual(2, (self: HttpClientRequest, body: FormData): HttpClientRequest => setBody(self, HttpBody.makeFormData(body)))
+} = dual(2, (self: HttpClientRequest, body: FormData): HttpClientRequest => setBody(self, HttpBody.formData(body)))
 
 /**
  * @since 4.0.0
@@ -846,7 +846,7 @@ export const bodyFormDataRecord: {
 } = dual(
   2,
   (self: HttpClientRequest, entries: HttpBody.FormDataInput): HttpClientRequest =>
-    setBody(self, HttpBody.makeFormDataRecord(entries))
+    setBody(self, HttpBody.formDataRecord(entries))
 )
 
 /**

package/src/unstable/http/HttpServerResponse.ts

@@ -327,7 +327,7 @@ export const formData = (
     statusText: options?.statusText,
     headers: options?.headers && Headers.fromInput(options.headers),
     cookies: options?.cookies,
-    body: Body.makeFormData(body)
+    body: Body.formData(body)
   })
 
 /**

package/src/unstable/persistence/KeyValueStore.ts

@@ -312,7 +312,7 @@ export const layerFileSystem = (
           fs.readFileString(keyPath(key)),
           "PlatformError",
           (cause) =>
-            cause.reason._tag === "SystemError" && cause.reason.kind === "NotFound" ? Effect.undefined : Effect.fail(
+            cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
               new KeyValueStoreError({
                 method: "get",
                 key,
@@ -326,7 +326,7 @@ export const layerFileSystem = (
           fs.readFile(keyPath(key)),
           "PlatformError",
           (cause) =>
-            cause.reason._tag === "SystemError" && cause.reason.kind === "NotFound" ? Effect.undefined : Effect.fail(
+            cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
               new KeyValueStoreError({
                 method: "getUint8Array",
                 key,

package/src/unstable/reactivity/Atom.ts

@@ -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/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

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