effect 3.13.4 → 3.13.7

package/src/STM.ts

@@ -14,7 +14,7 @@ import * as stm from "./internal/stm/stm.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
-import type { Covariant, MergeRecord, NoInfer } from "./Types.js"
+import type { Covariant, MergeRecord, NoExcessProperties, NoInfer } from "./Types.js"
 import type * as Unify from "./Unify.js"
 import type { YieldWrap } from "./Utils.js"
 
@@ -248,7 +248,10 @@ export declare namespace All {
    * @category utils
    */
   export interface Signature {
-    <Arg extends ReadonlyArray<STMAny> | Iterable<STMAny> | Record<string, STMAny>, O extends Options>(
+    <
+      Arg extends ReadonlyArray<STMAny> | Iterable<STMAny> | Record<string, STMAny>,
+      O extends NoExcessProperties<Options, O>
+    >(
       arg: Narrow<Arg>,
       options?: O
     ): [Arg] extends [ReadonlyArray<STMAny>] ? ReturnTuple<Arg, IsDiscard<O>>

package/src/Schema.ts

@@ -3469,18 +3469,13 @@ const intersectTypeLiterals = (
   throw new Error(errors_.getSchemaExtendErrorMessage(x, y, path))
 }
 
-const preserveRefinementAnnotations = AST.blackListAnnotations([
-  AST.IdentifierAnnotationId
-])
+const preserveRefinementAnnotations = AST.blackListAnnotations([AST.IdentifierAnnotationId])
 
 const addRefinementToMembers = (refinement: AST.Refinement, asts: ReadonlyArray<AST.AST>): Array<AST.Refinement> =>
   asts.map((ast) => new AST.Refinement(ast, refinement.filter, preserveRefinementAnnotations(refinement)))
 
-const extendAST = (
-  x: AST.AST,
-  y: AST.AST,
-  path: ReadonlyArray<PropertyKey>
-): AST.AST => AST.Union.make(intersectUnionMembers([x], [y], path))
+const extendAST = (x: AST.AST, y: AST.AST, path: ReadonlyArray<PropertyKey>): AST.AST =>
+  AST.Union.make(intersectUnionMembers([x], [y], path))
 
 const getTypes = (ast: AST.AST): ReadonlyArray<AST.AST> => AST.isUnion(ast) ? ast.types : [ast]
 
@@ -3555,59 +3550,63 @@ const intersectUnionMembers = (
             case "TypeLiteral":
               return [intersectTypeLiterals(x, y, path)]
             case "Transformation": {
-              if (AST.isTypeLiteralTransformation(x.transformation)) {
-                return [
-                  new AST.Transformation(
-                    intersectTypeLiterals(x.from, y, path),
-                    intersectTypeLiterals(x.to, AST.typeAST(y), path),
-                    new AST.TypeLiteralTransformation(
-                      x.transformation.propertySignatureTransformations
+              const transformation = x.transformation
+              const from = intersectTypeLiterals(x.from, y, path)
+              const to = intersectTypeLiterals(x.to, AST.typeAST(y), path)
+              switch (transformation._tag) {
+                case "TypeLiteralTransformation":
+                  return [
+                    new AST.Transformation(
+                      from,
+                      to,
+                      new AST.TypeLiteralTransformation(transformation.propertySignatureTransformations)
                     )
-                  )
-                ]
+                  ]
+                case "ComposeTransformation":
+                  return [new AST.Transformation(from, to, AST.composeTransformation)]
+                case "FinalTransformation":
+                  return [
+                    new AST.Transformation(
+                      from,
+                      to,
+                      new AST.FinalTransformation(
+                        (fromA, options, ast, fromI) =>
+                          ParseResult.map(
+                            transformation.decode(fromA, options, ast, fromI),
+                            (partial) => ({ ...fromA, ...partial })
+                          ),
+                        (toI, options, ast, toA) =>
+                          ParseResult.map(
+                            transformation.encode(toI, options, ast, toA),
+                            (partial) => ({ ...toI, ...partial })
+                          )
+                      )
+                    )
+                  ]
               }
-              break
             }
           }
           break
         }
         case "Transformation": {
-          if (AST.isTypeLiteralTransformation(y.transformation)) {
-            switch (x._tag) {
-              case "Union":
-                return intersectUnionMembers(x.types, [y], path)
-              case "Suspend":
-                return [new AST.Suspend(() => extendAST(x.f(), y, path))]
-              case "Refinement":
-                return addRefinementToMembers(x, intersectUnionMembers(getTypes(x.from), [y], path))
-              case "TypeLiteral":
-                return [
-                  new AST.Transformation(
-                    intersectTypeLiterals(x, y.from, path),
-                    intersectTypeLiterals(AST.typeAST(x), y.to, path),
-                    new AST.TypeLiteralTransformation(
-                      y.transformation.propertySignatureTransformations
+          if (AST.isTransformation(x)) {
+            if (
+              AST.isTypeLiteralTransformation(y.transformation) && AST.isTypeLiteralTransformation(x.transformation)
+            ) {
+              return [
+                new AST.Transformation(
+                  intersectTypeLiterals(x.from, y.from, path),
+                  intersectTypeLiterals(x.to, y.to, path),
+                  new AST.TypeLiteralTransformation(
+                    y.transformation.propertySignatureTransformations.concat(
+                      x.transformation.propertySignatureTransformations
                     )
                   )
-                ]
-              case "Transformation":
-                {
-                  if (AST.isTypeLiteralTransformation(x.transformation)) {
-                    return [
-                      new AST.Transformation(
-                        intersectTypeLiterals(x.from, y.from, path),
-                        intersectTypeLiterals(x.to, y.to, path),
-                        new AST.TypeLiteralTransformation(
-                          y.transformation.propertySignatureTransformations.concat(
-                            x.transformation.propertySignatureTransformations
-                          )
-                        )
-                      )
-                    ]
-                  }
-                }
-                break
+                )
+              ]
             }
+          } else {
+            return intersectUnionMembers([y], [x], path)
           }
           break
         }
@@ -9385,7 +9384,7 @@ const makeClass = <Fields extends Struct.Fields>(
       }
 
       const declaration: Schema.Any = declare(
-        [typeSide],
+        [schema],
         {
           decode: () => (input, _, ast) =>
             input instanceof this || fallbackInstanceOf(input)

package/src/Types.ts

@@ -251,7 +251,7 @@ export type Mutable<T> = {
  */
 export type DeepMutable<T> = T extends ReadonlyMap<infer K, infer V> ? Map<DeepMutable<K>, DeepMutable<V>>
   : T extends ReadonlySet<infer V> ? Set<DeepMutable<V>>
-  : [keyof T] extends [never] ? T
+  : T extends string | number | boolean | bigint | symbol ? T
   : { -readonly [K in keyof T]: DeepMutable<T[K]> }
 
 /**

package/src/internal/configProvider.ts

@@ -102,9 +102,9 @@ export const fromFlat = (flat: ConfigProvider.ConfigProvider.Flat): ConfigProvid
 
 /** @internal */
 export const fromEnv = (
-  config?: Partial<ConfigProvider.ConfigProvider.FromEnvConfig>
+  options?: Partial<ConfigProvider.ConfigProvider.FromEnvConfig>
 ): ConfigProvider.ConfigProvider => {
-  const { pathDelim, seqDelim } = Object.assign({}, { pathDelim: "_", seqDelim: "," }, config)
+  const { pathDelim, seqDelim } = Object.assign({}, { pathDelim: "_", seqDelim: "," }, options)
   const makePathString = (path: ReadonlyArray<string>): string => pipe(path, Arr.join(pathDelim))
   const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)
 

package/src/internal/effect/circular.ts

@@ -805,12 +805,12 @@ export const bindAll: {
   <
     A extends object,
     X extends Record<string, Effect.Effect<any, any, any>>,
-    O extends {
+    O extends Types.NoExcessProperties<{
       readonly concurrency?: Types.Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly mode?: "default" | "validate" | "either" | undefined
       readonly concurrentFinalizers?: boolean | undefined
-    }
+    }, O>
   >(
     f: (a: A) => [Extract<keyof X, keyof A>] extends [never] ? X : `Duplicate keys`,
     options?: undefined | O
@@ -832,12 +832,12 @@ export const bindAll: {
   <
     A extends object,
     X extends Record<string, Effect.Effect<any, any, any>>,
-    O extends {
+    O extends Types.NoExcessProperties<{
       readonly concurrency?: Types.Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
       readonly mode?: "default" | "validate" | "either" | undefined
       readonly concurrentFinalizers?: boolean | undefined
-    },
+    }, O>,
     E1,
     R1
   >(
@@ -864,12 +864,12 @@ export const bindAll: {
 } = dual((args) => core.isEffect(args[0]), <
   A extends object,
   X extends Record<string, Effect.Effect<any, any, any>>,
-  O extends {
+  O extends Types.NoExcessProperties<{
     readonly concurrency?: Types.Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
     readonly mode?: "default" | "validate" | "either" | undefined
     readonly concurrentFinalizers?: boolean | undefined
-  },
+  }, O>,
   E1,
   R1
 >(

package/src/internal/fiberRuntime.ts

@@ -43,7 +43,7 @@ import { currentScheduler, type Scheduler } from "../Scheduler.js"
 import type * as Scope from "../Scope.js"
 import type * as Supervisor from "../Supervisor.js"
 import type * as Tracer from "../Tracer.js"
-import type { Concurrency, NoInfer } from "../Types.js"
+import type { Concurrency, NoExcessProperties, NoInfer } from "../Types.js"
 import { internalCall, yieldWrapGet } from "../Utils.js"
 import * as RequestBlock_ from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
@@ -1945,13 +1945,13 @@ const allEither = (
 /* @internal */
 export const all = <
   const Arg extends Iterable<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>,
-  O extends {
+  O extends NoExcessProperties<{
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
     readonly discard?: boolean | undefined
     readonly mode?: "default" | "validate" | "either" | undefined
     readonly concurrentFinalizers?: boolean | undefined
-  }
+  }, O>
 >(
   arg: Arg,
   options?: O
@@ -1974,13 +1974,13 @@ export const all = <
 
 /* @internal */
 export const allWith = <
-  O extends {
+  O extends NoExcessProperties<{
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
     readonly discard?: boolean | undefined
     readonly mode?: "default" | "validate" | "either" | undefined
     readonly concurrentFinalizers?: boolean | undefined
-  }
+  }, O>
 >(options?: O) =>
 <const Arg extends Iterable<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>>(
   arg: Arg

package/src/internal/matcher.ts

@@ -321,38 +321,47 @@ export const whenAnd = <
 }
 
 /** @internal */
-export const discriminator =
-  <D extends string>(field: D) =>
-  <R, P extends Types.Tags<D, R> & string, Ret, B extends Ret>(
-    ...pattern: [
-      first: P,
-      ...values: Array<P>,
-      f: (_: Extract<R, Record<D, P>>) => B
-    ]
-  ) => {
-    const f = pattern[pattern.length - 1]
-    const values: Array<P> = pattern.slice(0, -1) as any
-    const pred = values.length === 1
-      ? (_: any) => _[field] === values[0]
-      : (_: any) => values.includes(_[field])
-
-    return <I, F, A, Pr>(
-      self: Matcher<I, F, R, A, Pr, Ret>
-    ): Matcher<
-      I,
-      Types.AddWithout<F, Extract<R, Record<D, P>>>,
-      Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<D, P>>>>,
-      A | B,
-      Pr,
-      Ret
-    > => (self as any).add(makeWhen(pred, f as any)) as any
-  }
+export const discriminator = <D extends string>(field: D) =>
+<
+  R,
+  P extends Types.Tags<D, R> & string,
+  Ret,
+  Fn extends (_: Extract<R, Record<D, P>>) => Ret
+>(
+  ...pattern: [
+    first: P,
+    ...values: Array<P>,
+    f: Fn
+  ]
+) => {
+  const f = pattern[pattern.length - 1]
+  const values: Array<P> = pattern.slice(0, -1) as any
+  const pred = values.length === 1
+    ? (_: any) => _[field] === values[0]
+    : (_: any) => values.includes(_[field])
+
+  return <I, F, A, Pr>(
+    self: Matcher<I, F, R, A, Pr, Ret>
+  ): Matcher<
+    I,
+    Types.AddWithout<F, Extract<R, Record<D, P>>>,
+    Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<D, P>>>>,
+    A | ReturnType<Fn>,
+    Pr,
+    Ret
+  > => (self as any).add(makeWhen(pred, f as any)) as any
+}
 
 /** @internal */
 export const discriminatorStartsWith = <D extends string>(field: D) =>
-<R, P extends string, Ret, B extends Ret>(
+<
+  R,
+  P extends string,
+  Ret,
+  Fn extends (_: Extract<R, Record<D, `${P}${string}`>>) => Ret
+>(
   pattern: P,
-  f: (_: Extract<R, Record<D, `${P}${string}`>>) => B
+  f: Fn
 ) => {
   const pred = (_: any) => typeof _[field] === "string" && _[field].startsWith(pattern)
 
@@ -365,7 +374,7 @@ export const discriminatorStartsWith = <D extends string>(field: D) =>
       I,
       Types.AddWithout<F, Extract<R, Record<D, `${P}${string}`>>>
     >,
-    A | B,
+    A | ReturnType<Fn>,
     Pr,
     Ret
   > => (self as any).add(makeWhen(pred, f as any)) as any
@@ -427,11 +436,16 @@ export const discriminatorsExhaustive: <D extends string>(
   }
 
 /** @internal */
-export const tag: <R, P extends Types.Tags<"_tag", R> & string, Ret, B extends Ret>(
+export const tag: <
+  R,
+  P extends Types.Tags<"_tag", R> & string,
+  Ret,
+  Fn extends (_: Extract<R, Record<"_tag", P>>) => Ret
+>(
   ...pattern: [
     first: P,
     ...values: Array<P>,
-    f: (_: Extract<R, Record<"_tag", P>>) => B
+    f: Fn
   ]
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret>
@@ -439,7 +453,7 @@ export const tag: <R, P extends Types.Tags<"_tag", R> & string, Ret, B extends R
   I,
   Types.AddWithout<F, Extract<R, Record<"_tag", P>>>,
   Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<"_tag", P>>>>,
-  B | A,
+  ReturnType<Fn> | A,
   Pr,
   Ret
 > = discriminator("_tag")

package/src/internal/schedule.ts

@@ -1810,14 +1810,14 @@ export const repeat_Effect = dual<
 
 /** @internal */
 export const repeat_combined = dual<{
-  <O extends Effect.Repeat.Options<A>, A>(
+  <O extends Types.NoExcessProperties<Effect.Repeat.Options<A>, O>, A>(
     options: O
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Repeat.Return<R, E, A, O>
   <B, A, R1>(
     schedule: Schedule.Schedule<B, A, R1>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R | R1>
 }, {
-  <A, E, R, O extends Effect.Repeat.Options<A>>(
+  <A, E, R, O extends Types.NoExcessProperties<Effect.Repeat.Options<A>, O>>(
     self: Effect.Effect<A, E, R>,
     options: O
   ): Effect.Repeat.Return<R, E, A, O>
@@ -1907,7 +1907,7 @@ export const retry_Effect = dual<
 
 /** @internal */
 export const retry_combined: {
-  <E, O extends Effect.Retry.Options<E>>(
+  <E, O extends Types.NoExcessProperties<Effect.Retry.Options<E>, O>>(
     options: O
   ): <A, R>(
     self: Effect.Effect<A, E, R>
@@ -1915,7 +1915,7 @@ export const retry_combined: {
   <B, E, R1>(
     policy: Schedule.Schedule<B, Types.NoInfer<E>, R1>
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R1 | R>
-  <A, E, R, O extends Effect.Retry.Options<E>>(
+  <A, E, R, O extends Types.NoExcessProperties<Effect.Retry.Options<E>, O>>(
     self: Effect.Effect<A, E, R>,
     options: O
   ): Effect.Retry.Return<R, E, A, O>

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.13.4"
+let moduleVersion = "3.13.7"
 
 export const getCurrentVersion = () => moduleVersion