effect 4.0.0-beta.4 → 4.0.0-beta.40

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

@@ -4,6 +4,7 @@
 import type * as Cause from "../../Cause.ts"
 import type { Effect } from "../../Effect.ts"
 import type { Exit as Exit_ } from "../../Exit.ts"
+import * as Option from "../../Option.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
@@ -61,7 +62,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
@@ -132,7 +133,7 @@ export interface Rpc<
    * Add an annotation on the rpc.
    */
   annotate<I, S>(
-    tag: ServiceMap.Service<I, S>,
+    tag: ServiceMap.Key<I, S>,
     value: S
   ): Rpc<Tag, Payload, Success, Error, Middleware, Requires>
 
@@ -183,7 +184,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
@@ -406,9 +407,7 @@ export type MiddlewareClient<R> = R extends Rpc<
   infer _Error,
   infer _Middleware,
   infer _Requires
-> ?
-  _Middleware extends { readonly requiredForClient: true }
-    ? RpcMiddleware.ForClient<ServiceMap.Service.Identifier<_Middleware>>
+> ? _Middleware extends { readonly requiredForClient: true } ? RpcMiddleware.ForClient<_Middleware["Identifier"]>
   : never
   : never
 
@@ -521,7 +520,7 @@ export type ExtractProvides<R extends Any, Tag extends string> = R extends Rpc<
   infer _Error,
   infer _Middleware,
   infer _Requires
-> ? RpcMiddleware.Provides<_Middleware> :
+> ? RpcMiddleware.Provides<_Middleware["Identifier"]> :
   never
 
 /**
@@ -660,7 +659,7 @@ const Proto = {
       middlewares: this.middlewares
     })
   },
-  annotate(this: AnyWithProps, tag: ServiceMap.Service<any, any>, value: any) {
+  annotate(this: AnyWithProps, tag: ServiceMap.Key<any, any>, value: any) {
     return makeProto({
       _tag: this._tag,
       payloadSchema: this.payloadSchema,
@@ -696,7 +695,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> => {
@@ -782,14 +781,14 @@ export const exitSchema = <R extends Any>(
   const rpc = self as any as AnyWithProps
   const failures = new Set<Schema.Top>([rpc.errorSchema])
   const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
-  if (streamSchemas) {
-    failures.add(streamSchemas.error)
+  if (Option.isSome(streamSchemas)) {
+    failures.add(streamSchemas.value.error)
   }
   for (const middleware of rpc.middlewares) {
     failures.add(middleware.error)
   }
   const schema = Schema.Exit(
-    streamSchemas ? Schema.Void : rpc.successSchema,
+    Option.isSome(streamSchemas) ? Schema.Void : rpc.successSchema,
     Schema.Union([...failures]),
     rpc.defectSchema
   )

package/src/unstable/rpc/RpcClient.ts

@@ -8,6 +8,7 @@ import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { constVoid, dual, flow, identity } from "../../Function.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import * as Pool from "../../Pool.ts"
@@ -20,7 +21,6 @@ import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Struct from "../../Struct.ts"
 import type { Span } from "../../Tracer.ts"
-import type { Mutable } from "../../Types.ts"
 import * as Headers from "../http/Headers.ts"
 import * as HttpBody from "../http/HttpBody.ts"
 import * as HttpClient from "../http/HttpClient.ts"
@@ -45,16 +45,7 @@ import { withRun } from "./Utils.ts"
  * @since 4.0.0
  * @category client
  */
-export type RpcClient<Rpcs extends Rpc.Any, E = never> = Struct.Simplify<
-  & RpcClient.From<RpcClient.NonPrefixed<Rpcs>, E, "">
-  & {
-    readonly [CurrentPrefix in RpcClient.Prefixes<Rpcs>]: RpcClient.From<
-      RpcClient.Prefixed<Rpcs, CurrentPrefix>,
-      E,
-      CurrentPrefix
-    >
-  }
->
+export type RpcClient<Rpcs extends Rpc.Any, E = never> = Struct.Simplify<RpcClient.From<Rpcs, E>>
 
 /**
  * @since 4.0.0
@@ -65,34 +56,8 @@ export declare namespace RpcClient {
    * @since 4.0.0
    * @category client
    */
-  export type Prefixes<Rpcs extends Rpc.Any> = Rpcs["_tag"] extends infer Tag
-    ? Tag extends `${infer Prefix}.${string}` ? Prefix : never
-    : never
-
-  /**
-   * @since 4.0.0
-   * @category client
-   */
-  export type NonPrefixed<Rpcs extends Rpc.Any> = Exclude<Rpcs, { readonly _tag: `${string}.${string}` }>
-
-  /**
-   * @since 4.0.0
-   * @category client
-   */
-  export type Prefixed<Rpcs extends Rpc.Any, Prefix extends string> = Extract<
-    Rpcs,
-    { readonly _tag: `${Prefix}.${string}` }
-  >
-
-  /**
-   * @since 4.0.0
-   * @category client
-   */
-  export type From<Rpcs extends Rpc.Any, E = never, Prefix extends string = ""> = {
-    readonly [
-      Current in Rpcs as Current["_tag"] extends `${Prefix}.${infer Method}` ? Method
-        : Current["_tag"]
-    ]: <
+  export type From<Rpcs extends Rpc.Any, E = never> = {
+    readonly [Current in Rpcs as Current["_tag"]]: <
       const AsQueue extends boolean = false,
       const Discard = false
     >(
@@ -401,7 +366,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
             resume(exit) {
               resume(exit)
               if (fiber && !fiber.pollUnsafe()) {
-                parentFiber.currentScheduler.scheduleTask(() => {
+                parentFiber.currentDispatcher.scheduleTask(() => {
                   fiber.interruptUnsafe(parentFiber.id)
                 }, 0)
               }
@@ -614,16 +579,9 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
     }
   } else {
     client = {}
-    for (const rpc of group.requests.values()) {
-      const dot = rpc._tag.indexOf(".")
-      const prefix = dot === -1 ? undefined : rpc._tag.slice(0, dot)
-      if (prefix !== undefined && !(prefix in client)) {
-        ;(client as any)[prefix] = {} as Mutable<RpcClient.Prefixed<Rpcs, typeof prefix>>
-      }
-      const target = prefix !== undefined ? (client as any)[prefix] : client
-      const tag = prefix !== undefined ? rpc._tag.slice(dot + 1) : rpc._tag
-      target[tag] = onRequest(rpc as any)
-    }
+    group.requests.forEach((rpc) => {
+      client[rpc._tag] = onRequest(rpc as any)
+    })
   }
 
   return { client, write } as const
@@ -725,8 +683,8 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
       case "Chunk": {
         const requestId = RequestId(message.requestId)
         const entry = entries.get(requestId)
-        if (!entry || !entry.schemas.decodeChunk) return Effect.void
-        return entry.schemas.decodeChunk(message.values).pipe(
+        if (!entry || Option.isNone(entry.schemas.decodeChunk)) return Effect.void
+        return entry.schemas.decodeChunk.value(message.values).pipe(
           Effect.provideServices(entry.context),
           Effect.orDie,
           Effect.flatMap((chunk) =>
@@ -780,9 +738,9 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
 })
 
 interface RpcSchemas {
-  readonly decodeChunk:
-    | ((chunk: ReadonlyArray<unknown>) => Effect.Effect<NonEmptyReadonlyArray<any>, Schema.SchemaError, unknown>)
-    | undefined
+  readonly decodeChunk: Option.Option<
+    (chunk: ReadonlyArray<unknown>) => Effect.Effect<NonEmptyReadonlyArray<any>, Schema.SchemaError, unknown>
+  >
   readonly encodePayload: (payload: any) => Effect.Effect<any, Schema.SchemaError, unknown>
   readonly decodeExit: (encoded: unknown) => Effect.Effect<Exit.Exit<any, any>, Schema.SchemaError, unknown>
 }
@@ -794,9 +752,10 @@ const rpcSchemas = (rpc: Rpc.AnyWithProps) => {
   }
   const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
   entry = {
-    decodeChunk: streamSchemas ?
-      Schema.decodeUnknownEffect(Schema.toCodecJson(Schema.NonEmptyArray(streamSchemas.success))) :
-      undefined,
+    decodeChunk: Option.map(
+      streamSchemas,
+      (streamSchemas) => Schema.decodeUnknownEffect(Schema.toCodecJson(Schema.NonEmptyArray(streamSchemas.success)))
+    ),
     encodePayload: Schema.encodeEffect(Schema.toCodecJson(rpc.payloadSchema)),
     decodeExit: Schema.decodeUnknownEffect(Schema.toCodecJson(Rpc.exitSchema(rpc as any)))
   }
@@ -1070,7 +1029,7 @@ const defaultRetryPolicy = Schedule.exponential(500, 1.5).pipe(
 
 const makePinger = Effect.fnUntraced(function*<A, E, R>(writePing: Effect.Effect<A, E, R>) {
   let recievedPong = true
-  const latch = Effect.makeLatchUnsafe()
+  const latch = Latch.makeUnsafe()
   const reset = () => {
     recievedPong = true
     latch.closeUnsafe()
@@ -1118,7 +1077,7 @@ export const makeProtocolWorker = (
     readonly maxSize: number
     readonly concurrency?: number | undefined
     readonly targetUtilization?: number | undefined
-    readonly timeToLive: Duration.DurationInput
+    readonly timeToLive: Duration.Input
   }
 ): Effect.Effect<
   Protocol["Service"],
@@ -1133,7 +1092,7 @@ export const makeProtocolWorker = (
 
     const entries = new Map<string, {
       readonly worker: Worker.Worker<FromServerEncoded, FromClientEncoded | RpcWorker.InitialMessage.Encoded>
-      readonly latch: Effect.Latch
+      readonly latch: Latch.Latch
     }>()
 
     const acquire = Effect.gen(function*() {
@@ -1219,7 +1178,7 @@ export const makeProtocolWorker = (
         case "Request": {
           return Pool.get(pool).pipe(
             Effect.flatMap((worker) => {
-              const latch = Effect.makeLatchUnsafe(false)
+              const latch = Latch.makeUnsafe(false)
               entries.set(request.id, { worker, latch })
               return Effect.flatMap(worker.send(request, transferables), () => latch.await)
             }),
@@ -1266,7 +1225,7 @@ export const layerProtocolWorker: (
     readonly maxSize: number
     readonly concurrency?: number | undefined
     readonly targetUtilization?: number | undefined
-    readonly timeToLive: Duration.DurationInput
+    readonly timeToLive: Duration.Input
   }
 ) => Layer.Layer<
   Protocol,

package/src/unstable/rpc/RpcGroup.ts

@@ -131,12 +131,12 @@ export interface RpcGroup<in out R extends Rpc.Any> extends Pipeable {
   /**
    * Annotate the group with a value.
    */
-  annotate<I, S>(service: ServiceMap.Service<I, S>, value: S): RpcGroup<R>
+  annotate<I, S>(service: ServiceMap.Key<I, S>, value: S): RpcGroup<R>
 
   /**
    * Annotate the Rpc's above this point with a value.
    */
-  annotateRpcs<I, S>(service: ServiceMap.Service<I, S>, value: S): RpcGroup<R>
+  annotateRpcs<I, S>(service: ServiceMap.Key<I, S>, value: S): RpcGroup<R>
 
   /**
    * Annotate the group with the provided annotations.
@@ -184,8 +184,8 @@ export type HandlersServices<Rpcs extends Rpc.Any, Handlers> = keyof Handlers ex
  * @since 4.0.0
  * @category groups
  */
-export type HandlerServices<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handler> = [Rpc.IsStream<Rpcs, K>] extends
-  [true] ? Handler extends (...args: any) =>
+export type HandlerServices<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handler> = true extends
+  Rpc.IsStream<Rpcs, K> ? Handler extends (...args: any) =>
     | Stream.Stream<infer _A, infer _E, infer _R>
     | Rpc.Wrapper<Stream.Stream<infer _A, infer _E, infer _R>>
     | Effect.Effect<
@@ -204,7 +204,7 @@ export type HandlerServices<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handle
   Handler extends (
     ...args: any
   ) => Effect.Effect<infer _A, infer _E, infer _R> | Rpc.Wrapper<Effect.Effect<infer _A, infer _E, infer _R>> ?
-    Rpc.ExcludeProvides<_R, Rpcs, K> | Rpc.ExtractRequires<Rpcs, K>
+    Exclude<Rpc.ExcludeProvides<_R, Rpcs, K>, Scope> | Rpc.ExtractRequires<Rpcs, K>
   : never
 
 /**
@@ -314,13 +314,13 @@ const RpcGroupProto = {
       })
     })
   },
-  annotate(this: RpcGroup<any>, service: ServiceMap.Service<any, any>, value: any) {
+  annotate(this: RpcGroup<any>, service: ServiceMap.Key<any, any>, value: any) {
     return makeProto({
       requests: this.requests,
       annotations: ServiceMap.add(this.annotations, service, value)
     })
   },
-  annotateRpcs(this: RpcGroup<any>, service: ServiceMap.Service<any, any>, value: any) {
+  annotateRpcs(this: RpcGroup<any>, service: ServiceMap.Key<any, any>, value: any) {
     return this.annotateRpcsMerge(ServiceMap.make(service, value))
   },
   annotateMerge(this: RpcGroup<any>, context: ServiceMap.ServiceMap<any>) {

package/src/unstable/rpc/RpcMiddleware.ts

@@ -109,7 +109,8 @@ export interface ServiceClass<
   Provides,
   E extends Schema.Top,
   ClientError,
-  Requires
+  Requires,
+  RequiredForClient extends boolean
 > extends ServiceMap.Service<Self, RpcMiddleware<Provides, E["Type"], Requires>> {
   new(_: never): ServiceMap.ServiceClass.Shape<Name, RpcMiddleware<Provides, E["Type"], Requires>> & {
     readonly [TypeId]: {
@@ -121,7 +122,7 @@ export interface ServiceClass<
   }
   readonly [TypeId]: typeof TypeId
   readonly error: E
-  readonly requiredForClient: boolean
+  readonly requiredForClient: RequiredForClient
   readonly "~ClientError": ClientError
 }
 
@@ -173,7 +174,7 @@ export type ErrorServicesDecode<A> = ErrorSchema<A>["DecodingServices"]
  * @since 4.0.0
  * @category models
  */
-export interface AnyService extends ServiceMap.Service<any, any> {
+export interface AnyService extends ServiceMap.Key<any, any> {
   readonly [TypeId]: typeof TypeId
   readonly error: Schema.Top
   readonly requiredForClient: boolean
@@ -184,7 +185,7 @@ export interface AnyService extends ServiceMap.Service<any, any> {
  * @since 4.0.0
  * @category models
  */
-export interface AnyServiceWithProps extends ServiceMap.Service<any, RpcMiddleware<any, any, any>> {
+export interface AnyServiceWithProps extends ServiceMap.Key<any, RpcMiddleware<any, any, any>> {
   readonly [TypeId]: typeof TypeId
   readonly error: Schema.Top
   readonly requiredForClient: boolean
@@ -201,16 +202,20 @@ export const Service = <
     requires?: any
     provides?: any
     clientError?: any
-  } = { requires: never; provides: never; clientError: never }
+  } = {
+    requires: never
+    provides: never
+    clientError: never
+  }
 >(): <
   const Name extends string,
   Error extends Schema.Top = Schema.Never,
-  RequiredForClient extends boolean = false
+  const RequiredForClient extends boolean = false
 >(
   id: Name,
   options?: {
     readonly error?: Error | undefined
-    readonly requiredForClient: RequiredForClient | undefined
+    readonly requiredForClient?: RequiredForClient | undefined
   } | undefined
 ) => ServiceClass<
   Self,
@@ -218,7 +223,8 @@ export const Service = <
   "provides" extends keyof Config ? Config["provides"] : never,
   Error,
   "clientError" extends keyof Config ? Config["clientError"] : never,
-  "requires" extends keyof Config ? Config["requires"] : never
+  "requires" extends keyof Config ? Config["requires"] : never,
+  RequiredForClient
 > =>
 (
   id: string,
@@ -253,7 +259,7 @@ export const Service = <
  * @category client
  */
 export const layerClient = <Id extends AnyId, S, R, EX = never, RX = never>(
-  tag: ServiceMap.Service<Id, S>,
+  tag: ServiceMap.Key<Id, S>,
   service:
     | RpcMiddlewareClient<Id[TypeId]["error"]["Type"], Id[TypeId]["clientError"], R>
     | Effect.Effect<RpcMiddlewareClient<Id[TypeId]["error"]["Type"], Id[TypeId]["clientError"], R>, EX, RX>

package/src/unstable/rpc/RpcSchema.ts

@@ -1,9 +1,13 @@
 /**
  * @since 4.0.0
  */
+import * as Cause from "../../Cause.ts"
+import { constUndefined } from "../../Function.ts"
+import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type * as AST from "../../SchemaAST.ts"
+import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream_ from "../../Stream.ts"
 
 const StreamSchemaTypeId = "~effect/rpc/RpcSchema/StreamSchema"
@@ -17,16 +21,16 @@ export function isStreamSchema(schema: Schema.Top): schema is Stream<Schema.Top,
 }
 
 /** @internal */
-export function getStreamSchemas(schema: Schema.Top): {
+export function getStreamSchemas(schema: Schema.Top): Option.Option<{
   readonly success: Schema.Top
   readonly error: Schema.Top
-} | undefined {
+}> {
   return isStreamSchema(schema) ?
-    {
+    Option.some({
       success: schema.success,
       error: schema.error
-    } :
-    undefined
+    }) :
+    Option.none()
 }
 
 /**
@@ -58,3 +62,17 @@ const schema = Schema.declare(Stream_.isStream)
 export function Stream<A extends Schema.Top, E extends Schema.Top>(success: A, error: E): Stream<A, E> {
   return Schema.make(schema.ast, { [StreamSchemaTypeId]: StreamSchemaTypeId, success, error })
 }
+
+/**
+ * @since 4.0.0
+ * @category Cause annotations
+ */
+export class ClientAbort extends ServiceMap.Service<ClientAbort, true>()("effect/rpc/RpcSchema/ClientAbort") {
+  static annotation = this.serviceMap(true).pipe(
+    ServiceMap.add(Cause.StackTrace, {
+      name: "ClientAbort",
+      stack: constUndefined,
+      parent: undefined
+    })
+  )
+}

package/src/unstable/rpc/RpcSerialization.ts

@@ -37,7 +37,10 @@ export const json: RpcSerialization["Service"] = RpcSerialization.of({
   makeUnsafe: () => {
     const decoder = new TextDecoder()
     return {
-      decode: (bytes) => [JSON.parse(typeof bytes === "string" ? bytes : decoder.decode(bytes))],
+      decode: (bytes) => {
+        const decoded = JSON.parse(typeof bytes === "string" ? bytes : decoder.decode(bytes))
+        return Array.isArray(decoded) ? decoded : [decoded]
+      },
       encode: (response) => JSON.stringify(response)
     }
   }
@@ -107,11 +110,7 @@ export const jsonRpc = (options?: {
           return decodeJsonRpcRaw(decoded, batches)
         },
         encode: (response) => {
-          if (Array.isArray(response)) {
-            if (response.length === 0) return undefined
-            return JSON.stringify(response.map(encodeJsonRpcMessage))
-          }
-          const encoded = encodeJsonRpcRaw(response as any, batches)
+          const encoded = encodeJsonRpcResponse(response as any, batches)
           return encoded && JSON.stringify(encoded)
         }
       }
@@ -146,10 +145,7 @@ export const ndJsonRpc = (options?: {
           return messages
         },
         encode: (response) => {
-          if (Array.isArray(response)) {
-            return parser.encode(response.map(encodeJsonRpcMessage))
-          }
-          const encoded = encodeJsonRpcRaw(response as any, batches)
+          const encoded = encodeJsonRpcResponse(response as any, batches)
           return encoded && parser.encode(encoded)
         }
       })
@@ -171,6 +167,7 @@ function decodeJsonRpcRaw(
     const messages: Array<RpcMessage.FromClientEncoded | RpcMessage.FromServerEncoded> = []
     for (let i = 0; i < decoded.length; i++) {
       const message = decodeJsonRpcMessage(decoded[i])
+      messages.push(message)
       if (message._tag === "Request") {
         batch.size++
         batches.set(message.id, batch)
@@ -178,7 +175,7 @@ function decodeJsonRpcRaw(
     }
     return messages
   }
-  return Array.isArray(decoded) ? decoded.map(decodeJsonRpcMessage) : [decodeJsonRpcMessage(decoded)]
+  return [decodeJsonRpcMessage(decoded)]
 }
 
 function decodeJsonRpcMessage(decoded: JsonRpcMessage): RpcMessage.FromClientEncoded | RpcMessage.FromServerEncoded {
@@ -263,6 +260,47 @@ function encodeJsonRpcRaw(
   return encodeJsonRpcMessage(response)
 }
 
+function encodeJsonRpcResponse(
+  response:
+    | RpcMessage.FromServerEncoded
+    | RpcMessage.FromClientEncoded
+    | Array<RpcMessage.FromServerEncoded | RpcMessage.FromClientEncoded>,
+  batches: Map<string, {
+    readonly size: number
+    readonly responses: Map<string, RpcMessage.FromServerEncoded>
+  }>
+) {
+  if (Array.isArray(response) === false) {
+    return encodeJsonRpcRaw(response, batches)
+  }
+  if (response.length === 0) {
+    return undefined
+  }
+  const encoded: Array<JsonRpcMessage | Array<JsonRpcMessage>> = []
+  for (let i = 0; i < response.length; i++) {
+    const current = encodeJsonRpcRaw(response[i], batches)
+    if (current !== undefined) {
+      encoded.push(current)
+    }
+  }
+  if (encoded.length === 0) {
+    return undefined
+  }
+  if (encoded.length === 1) {
+    return encoded[0]
+  }
+  const messages: Array<JsonRpcMessage> = []
+  for (let i = 0; i < encoded.length; i++) {
+    const current = encoded[i]
+    if (Array.isArray(current)) {
+      messages.push(...current)
+    } else {
+      messages.push(current)
+    }
+  }
+  return messages
+}
+
 function encodeJsonRpcMessage(response: RpcMessage.FromServerEncoded | RpcMessage.FromClientEncoded): JsonRpcMessage {
   switch (response._tag) {
     case "Request":