effect 4.0.0-rc.118 → 4.0.0

package/src/internal/schema/toCodec.ts

@@ -33,22 +33,9 @@ function validateCanonicalObjectPropertyNames(ast: SchemaAST.Objects): void {
 
 function makeReorder(getPriority: (ast: SchemaAST.AST) => number) {
   return (types: ReadonlyArray<SchemaAST.AST>): ReadonlyArray<SchemaAST.AST> => {
-    // Create a map of original indices for O(1) lookup
-    const indexMap = new Map<SchemaAST.AST, number>()
-    for (let i = 0; i < types.length; i++) {
-      indexMap.set(SchemaAST.toEncoded(types[i]), i)
-    }
-
-    // Create a sorted copy of the types array
-    const sortedTypes = [...types].sort((a, b) => {
-      a = SchemaAST.toEncoded(a)
-      b = SchemaAST.toEncoded(b)
-      const pa = getPriority(a)
-      const pb = getPriority(b)
-      if (pa !== pb) return pa - pb
-      // If priorities are equal, maintain original order (stable sort)
-      return indexMap.get(a)! - indexMap.get(b)!
-    })
+    const sortedTypes = [...types].sort((a, b) =>
+      getPriority(SchemaAST.toEncoded(a)) - getPriority(SchemaAST.toEncoded(b))
+    )
 
     // Check if order changed by comparing arrays
     const orderChanged = sortedTypes.some((ast, index) => ast !== types[index])

package/src/internal/schema/toEquivalence.ts

@@ -136,13 +136,12 @@ function recur(ast: SchemaAST.AST): Equivalence.Equivalence<any> {
     }
     case "Union": {
       const types = SchemaAST.toType(ast).types
-      const compiled = new Map(
-        types.map((candidate, i) => [candidate, [SchemaParser._is(candidate), recur(ast.types[i])] as const] as const)
-      )
+      const index = SchemaAST.getCandidateIndex(types)
+      const compiled = types.map((candidate, i) => [SchemaParser._is(candidate), recur(ast.types[i])] as const)
       return Equivalence.make((a, b) => {
-        const candidates = SchemaAST.getCandidates(a, types)
+        const candidates = index(a, false)
         for (let i = 0; i < candidates.length; i++) {
-          const [is, equivalence] = compiled.get(candidates[i])!
+          const [is, equivalence] = compiled[candidates[i]]
           if (is(a) && is(b)) {
             return equivalence(a, b)
           }

package/src/internal/schema/toFormatter.ts

@@ -217,14 +217,12 @@ export function toFormatter<T>(ast: SchemaAST.AST, options?: {
       }
       case "Union": {
         const types = SchemaAST.toType(ast).types
-        const getCandidates = (value: any) => SchemaAST.getCandidates(value, types)
-        const compiled = new Map(
-          types.map((candidate, i) => [candidate, [SchemaParser._is(candidate), recur(ast.types[i])] as const] as const)
-        )
+        const index = SchemaAST.getCandidateIndex(types)
+        const compiled = types.map((candidate, i) => [SchemaParser._is(candidate), recur(ast.types[i])] as const)
         return (value) => {
-          const candidates = getCandidates(value)
+          const candidates = index(value, false)
           for (let i = 0; i < candidates.length; i++) {
-            const [is, formatter] = compiled.get(candidates[i])!
+            const [is, formatter] = compiled[candidates[i]]
             if (is(value)) {
               return formatter(value)
             }

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,
@@ -1051,9 +1051,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 +1149,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 +1250,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/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,