effect 4.0.0-rc.118 → 4.0.1

package/src/reactivity/Atom.ts

@@ -1453,8 +1453,9 @@ function makeResultFn<Arg, E, A>(
           Effect.forkDetach(eff, { startImmediately: true }),
           (fiber) => {
             fibers.add(fiber)
+            const runningFibers = Array.from(fibers)
             fiber.addObserver(() => fibers.delete(fiber))
-            return Effect.map(Fiber.joinAll(fibers), (arr) => arr[0])
+            return Effect.map(Fiber.joinAll(runningFibers), (arr) => arr[0])
           }
         )
       }
@@ -1619,7 +1620,10 @@ export const family = typeof WeakRef === "undefined" || typeof FinalizationRegis
   ): (arg: Arg) => T => {
     const atoms = MutableHashMap.empty<Arg, WeakRef<T>>()
     const registry = new FinalizationRegistry<Arg>((arg) => {
-      MutableHashMap.remove(atoms, arg)
+      const entry = MutableHashMap.get(atoms, arg)
+      if (entry._tag === "Some" && entry.value.deref() === undefined) {
+        MutableHashMap.remove(atoms, arg)
+      }
     })
     return function(arg) {
       const atomEntry = MutableHashMap.get(atoms, arg).pipe(

package/src/reactivity/AtomRpc.ts

@@ -57,8 +57,8 @@ export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any> ex
 
   readonly mutation: <Tag extends Rpc.Tag<Rpcs>>(
     arg: Tag
-  ) => Rpc.ExtractTag<Rpcs, Tag> extends Rpc.Rpc<
-    infer _Tag,
+  ) => Rpcs extends Rpc.Rpc<
+    infer _Tag extends Tag,
     infer _Payload,
     infer _Success,
     infer _Error,
@@ -67,7 +67,7 @@ export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any> ex
   > ? [_Success] extends [RpcSchema.Stream<infer _A, infer _E>] ? never
     : Atom.AtomResultFn<
       {
-        readonly payload: Rpc.PayloadConstructor<Rpc.ExtractTag<Rpcs, Tag>>
+        readonly payload: Rpc.PayloadConstructor<Rpcs>
         readonly reactivityKeys?:
           | ReadonlyArray<unknown>
           | ReadonlyRecord<string, ReadonlyArray<unknown>>
@@ -91,8 +91,8 @@ export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any> ex
       readonly timeToLive?: Duration.Input | undefined
       readonly serializationKey?: string | undefined
     }
-  ) => Rpc.ExtractTag<Rpcs, Tag> extends Rpc.Rpc<
-    infer _Tag,
+  ) => Rpcs extends Rpc.Rpc<
+    infer _Tag extends Tag,
     infer _Payload,
     infer _Success,
     infer _Error,

package/src/rpc/Rpc.ts

@@ -687,14 +687,14 @@ export type IsStream<R extends Any, Tag extends string> = R extends Rpc<
   never
 
 /**
- * Extracts the RPC with the specified tag from an RPC union.
+ * Extracts RPCs whose tags match the given tag or union of tags.
  *
  * @stability unstable
  * @category utility types
  * @since 4.0.0
  */
 export type ExtractTag<R extends Any, Tag extends string> = R extends Rpc<
-  Tag,
+  infer _Tag extends Tag,
   infer _Payload,
   infer _Success,
   infer _Error,

package/src/rpc/RpcClient.ts

@@ -166,8 +166,8 @@ export declare namespace RpcClient {
         readonly context?: Context.Context<never> | undefined
         readonly discard?: Discard | undefined
       }
-  ) => Rpc.ExtractTag<Rpcs, Tag> extends Rpc.Rpc<
-    infer _Tag,
+  ) => Rpcs extends Rpc.Rpc<
+    infer _Tag extends Tag,
     infer _Payload,
     infer _Success,
     infer _Error,
@@ -454,9 +454,11 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
     const id = generateRequestId()
 
     const scope = Context.getUnsafe(fiber.context, Scope.Scope)
+    const queue = yield* Queue.bounded<any, any>(streamBufferSize)
     yield* Scope.addFinalizerExit(
       scope,
       (exit) => {
+        Queue.shutdownUnsafe(queue)
         if (!entries.has(id)) return Effect.void
         entries.delete(id)
         return sendInterrupt(
@@ -469,7 +471,6 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
       }
     )
 
-    const queue = yield* Queue.bounded<any, any>(streamBufferSize)
     entries.set(id, {
       _tag: "Queue",
       rpc,
@@ -671,6 +672,12 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
   }
   const entries = new Map<RequestId, ClientEntry>()
 
+  const interruptRequest = (requestId: RequestId): Effect.Effect<void, RpcClientError> => {
+    if (!entries.has(requestId)) return Effect.void
+    entries.delete(requestId)
+    return send(clientId, { _tag: "Interrupt", requestId }) as Effect.Effect<void, RpcClientError>
+  }
+
   const { client, write } = yield* makeNoSerialization(group, {
     ...options,
     supportsAck,
@@ -711,13 +718,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
           }) as Effect.Effect<void, RpcClientError>
         }
         case "Interrupt": {
-          const entry = entries.get(message.requestId)
-          if (!entry) return Effect.void
-          entries.delete(message.requestId)
-          return send(clientId, {
-            _tag: "Interrupt",
-            requestId: message.requestId
-          }) as Effect.Effect<void, RpcClientError>
+          return interruptRequest(message.requestId)
         }
         case "Eof": {
           return Effect.void
@@ -732,19 +733,22 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
         const requestId = RequestId(message.requestId)
         const entry = entries.get(requestId)
         if (!entry || Option.isNone(entry.schemas.decodeChunk)) return Effect.void
-        return entry.schemas.decodeChunk.value(message.values).pipe(
-          Effect.provideContext(entry.context),
-          Effect.orDie,
-          Effect.flatMap((chunk) =>
-            write({ _tag: "Chunk", clientId: 0, requestId: RequestId(message.requestId), values: chunk })
-          ),
-          Effect.onError((cause) =>
-            write({
-              _tag: "Exit",
-              clientId: 0,
-              requestId: RequestId(message.requestId),
-              exit: Exit.failCause(cause)
-            })
+        const decodeChunk = entry.schemas.decodeChunk.value
+        return Effect.uninterruptibleMask((restore) =>
+          restore(
+            decodeChunk(message.values).pipe(
+              Effect.provideContext(entry.context),
+              Effect.orDie,
+              Effect.flatMap((chunk) => write({ _tag: "Chunk", clientId: 0, requestId, values: chunk }))
+            )
+          ).pipe(
+            Effect.onError((cause) =>
+              write({ _tag: "Exit", clientId: 0, requestId, exit: Exit.failCause(cause) }).pipe(
+                Effect.andThen(Cause.hasInterrupts(cause) ? Effect.void : Effect.ignore(interruptRequest(requestId)))
+              )
+            ),
+            // a decode failure only ends its own request; interruption still propagates
+            Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), () => Effect.void)
           )
         ) as Effect.Effect<void>
       }
@@ -768,7 +772,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
       case "ClientProtocolError": {
         const exit = Exit.fail(message.error)
         return Effect.forEach(
-          entries.keys(),
+          Array.from(entries.keys()),
           (requestId) => write({ _tag: "Exit", clientId: 0, requestId, exit: exit as any })
         )
       }
@@ -1051,9 +1055,9 @@ export const makeProtocolSocket = (options?: {
   readonly retryPolicy?: Schedule.Schedule<any, Socket.SocketError> | undefined
   /**
    * Runs for each retried `SocketOpenError` when `retryTransientErrors` is enabled.
-   * Ping timeouts are also reported because the protocol classifies them as
-   * `SocketOpenError`. The returned `Effect<void>` cannot fail with a typed error
-   * or require services; defects are logged and ignored so retries can continue.
+   * A missed pong fails in-flight calls and is not reported through this hook.
+   * The returned `Effect<void>` cannot fail with a typed error or require
+   * services; defects are logged and ignored so retries can continue.
    */
   readonly onTransientError?: ((error: RpcClientError) => Effect.Effect<void>) | undefined
 }): Effect.Effect<
@@ -1149,8 +1153,7 @@ export const makeProtocolSocket = (options?: {
           () =>
             Effect.fail(
               new Socket.SocketError({
-                reason: new Socket.SocketOpenError({
-                  kind: "Timeout",
+                reason: new Socket.SocketReadError({
                   cause: new Error("ping timeout")
                 })
               })
@@ -1251,9 +1254,9 @@ export const layerProtocolSocket = (options?: {
   readonly retryTransientErrors?: boolean | undefined
   /**
    * Runs for each retried `SocketOpenError` when `retryTransientErrors` is enabled.
-   * Ping timeouts are also reported because the protocol classifies them as
-   * `SocketOpenError`. The returned `Effect<void>` cannot fail with a typed error
-   * or require services; defects are logged and ignored so retries can continue.
+   * A missed pong fails in-flight calls and is not reported through this hook.
+   * The returned `Effect<void>` cannot fail with a typed error or require
+   * services; defects are logged and ignored so retries can continue.
    */
   readonly onTransientError?: ((error: RpcClientError) => Effect.Effect<void>) | undefined
 }): Layer.Layer<

package/src/rpc/RpcMessage.ts

@@ -297,7 +297,7 @@ export type ExitEncoded<A, E> = {
       readonly defect: unknown
     } | {
       readonly _tag: "Interrupt"
-      readonly fiberId: number | undefined
+      readonly fiberId: number | null | undefined
     }
   >
 }

package/src/rpc/RpcServer.ts

@@ -1392,13 +1392,14 @@ export const makeProtocolStdio = Effect.gen(function*() {
       Effect.sandbox,
       Effect.tapError(Effect.logError),
       Effect.retry(Schedule.spaced(500)),
-      Effect.ensuring(Effect.forkDetach(Fiber.interrupt(fiber), { startImmediately: true })),
+      Effect.andThen(() => writeRequest(0, constEof)),
       Effect.forkScoped
     )
 
     yield* Stream.fromQueue(queue).pipe(
       Stream.run(stdio.stdout()),
       Effect.retry(Schedule.spaced(500)),
+      Effect.ensuring(Effect.forkDetach(Fiber.interrupt(fiber), { startImmediately: true })),
       Effect.forkScoped
     )
 

package/src/rpc/Utils.ts

@@ -1,10 +1,5 @@
 /**
- * Helps RPC protocol services buffer messages until their receive loop starts.
- *
- * Client and server protocol constructors use these helpers to expose a stable
- * service before the active receiver is installed. Writes made before `run`
- * starts are buffered with their current `Context`, then replayed once the
- * receiver is ready.
+ * Buffers RPC protocol messages until their receive loop starts.
  *
  * @stability unstable
  * @since 4.0.0
@@ -16,9 +11,8 @@ import type { Protocol } from "./RpcClient.ts"
 import type { FromServerEncoded } from "./RpcMessage.ts"
 
 /**
- * Builds a service with a `run` method that buffers writes until `run` installs
- * a writer, replays buffered writes with their original contexts, and restores
- * the previous writer when the run ends.
+ * Buffers writes until `run` replays them with their original contexts and
+ * installs the writer. Restores the previous writer when `run` ends.
  *
  * @stability unstable
  * @category services
@@ -43,12 +37,12 @@ export const withRun = <
       run(f) {
         return semaphore.withPermits(1)(Effect.gen(function*() {
           const prev = write
-          write = f
 
           for (const [args, context] of buffer) {
             yield* Effect.provideContext(Effect.suspend(() => f(...args)), context)
           }
           buffer = []
+          write = f
 
           return yield* Effect.onExit(Effect.never, () => {
             write = prev

package/src/schema/SchemaCompiler/runtime.ts

@@ -237,6 +237,21 @@ const invalidEncoding = (
     ? invalidType(ast, value, options)
     : Interpreter.wrapEncoding(ast, input, options, invalidType(ast.encoding[index - 1].to, value, options))
 
+const invalidEncodingChecks = (
+  ast: SchemaAST.AST & { readonly encoding: SchemaAST.Encoding },
+  input: unknown,
+  issues: readonly [SchemaIssue.Issue, ...Array<SchemaIssue.Issue>],
+  options: SchemaAST.ParseOptions
+) => {
+  const source = ast.encoding[ast.encoding.length - 1].to
+  return Interpreter.wrapEncoding(
+    ast,
+    input,
+    options,
+    Effect.fail(new SchemaIssue.Composite(source, issues, input, options))
+  )
+}
+
 /**
  * @internal
  */
@@ -255,6 +270,7 @@ export const runtime = {
   die: Effect.die,
   invalidType,
   invalidEncoding,
+  invalidEncodingChecks,
   getCheckIssues,
   check,
   getExpectedKeys: (ast: SchemaAST.Objects) =>
@@ -262,7 +278,7 @@ export const runtime = {
   hasExcessProperties,
   matchesTemplateLiteral: (ast: SchemaAST.TemplateLiteral, input: unknown, options: SchemaAST.ParseOptions) =>
     typeof input === "string" && ast.matchPart(input, options) !== undefined,
-  getCandidates: SchemaAST.getCandidates,
+  getCandidateIndex: SchemaAST.getCandidateIndex,
   getIndexSignatureKeys: SchemaAST.getIndexSignatureKeys,
   parameterFromPropertyKey: SchemaAST.parameterFromPropertyKey,
   getConstructorDescriptor: SchemaAST.getConstructorDescriptor,