effect 3.9.0 → 3.9.2

package/src/Array.ts

@@ -5643,7 +5643,7 @@ export const bind: {
    * @category do notation
    * @since 3.2.0
    */
-  <A extends object, N extends string, B>(tag: Exclude<N, keyof A>, f: (a: A) => ReadonlyArray<B>): (
+  <A extends object, N extends string, B>(tag: Exclude<N, keyof A>, f: (a: NoInfer<A>) => ReadonlyArray<B>): (
     self: ReadonlyArray<A>
   ) => Array<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
   /**
@@ -5692,7 +5692,7 @@ export const bind: {
   <A extends object, N extends string, B>(
     self: ReadonlyArray<A>,
     tag: Exclude<N, keyof A>,
-    f: (a: A) => ReadonlyArray<B>
+    f: (a: NoInfer<A>) => ReadonlyArray<B>
   ): Array<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
 } = doNotation.bind<ReadonlyArrayTypeLambda>(map, flatMap) as any
 
@@ -5833,12 +5833,12 @@ export const bindTo: {
 const let_: {
   <N extends string, B, A extends object>(
     tag: Exclude<N, keyof A>,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): (self: ReadonlyArray<A>) => Array<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
   <N extends string, A extends object, B>(
     self: ReadonlyArray<A>,
     tag: Exclude<N, keyof A>,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): Array<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
 } = doNotation.let_<ReadonlyArrayTypeLambda>(map) as any
 

package/src/BigDecimal.ts

@@ -18,7 +18,7 @@ import * as Equal from "./Equal.js"
 import * as equivalence from "./Equivalence.js"
 import { dual, pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
-import { DenoInspectSymbol, type Inspectable, NodeInspectSymbol } from "./Inspectable.js"
+import { type Inspectable, NodeInspectSymbol } from "./Inspectable.js"
 import * as Option from "./Option.js"
 import * as order from "./Order.js"
 import type { Ordering } from "./Ordering.js"
@@ -74,9 +74,6 @@ const BigDecimalProto: Omit<BigDecimal, "value" | "scale" | "normalized"> = {
       scale: this.scale
     }
   },
-  [DenoInspectSymbol](this: BigDecimal) {
-    return this.toJSON()
-  },
   [NodeInspectSymbol](this: BigDecimal) {
     return this.toJSON()
   },

package/src/Chunk.ts

@@ -9,7 +9,7 @@ import * as Equivalence from "./Equivalence.js"
 import { dual, identity, pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
 import type { TypeLambda } from "./HKT.js"
-import { DenoInspectSymbol, format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
+import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
 import type { NonEmptyIterable } from "./NonEmptyIterable.js"
 import type { Option } from "./Option.js"
 import * as O from "./Option.js"
@@ -135,9 +135,6 @@ const ChunkProto: Omit<Chunk<unknown>, "backing" | "depth" | "left" | "length" |
       values: toReadonlyArray(this).map(toJSON)
     }
   },
-  [DenoInspectSymbol]<A>(this: Chunk<A>) {
-    return this.toJSON()
-  },
   [NodeInspectSymbol]<A>(this: Chunk<A>) {
     return this.toJSON()
   },

package/src/Cron.ts

@@ -7,7 +7,7 @@ import * as Equal from "./Equal.js"
 import * as equivalence from "./Equivalence.js"
 import { dual, pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
-import { DenoInspectSymbol, format, type Inspectable, NodeInspectSymbol } from "./Inspectable.js"
+import { format, type Inspectable, NodeInspectSymbol } from "./Inspectable.js"
 import * as N from "./Number.js"
 import { type Pipeable, pipeArguments } from "./Pipeable.js"
 import { hasProperty } from "./Predicate.js"
@@ -67,9 +67,6 @@ const CronProto: Omit<Cron, "minutes" | "hours" | "days" | "months" | "weekdays"
       weekdays: Arr.fromIterable(this.weekdays)
     }
   },
-  [DenoInspectSymbol](this: Cron) {
-    return this.toJSON()
-  },
   [NodeInspectSymbol](this: Cron) {
     return this.toJSON()
   },

package/src/DateTime.ts

@@ -230,9 +230,6 @@ const Proto = {
   pipe() {
     return pipeArguments(this, arguments)
   },
-  [Inspectable.DenoInspectSymbol](this: DateTime) {
-    return this.toString()
-  },
   [Inspectable.NodeInspectSymbol](this: DateTime) {
     return this.toString()
   },
@@ -276,9 +273,6 @@ const ProtoZoned = {
 
 const ProtoTimeZone = {
   [TimeZoneTypeId]: TimeZoneTypeId,
-  [Inspectable.DenoInspectSymbol](this: TimeZone) {
-    return this.toString()
-  },
   [Inspectable.NodeInspectSymbol](this: TimeZone) {
     return this.toString()
   }

package/src/Duration.ts

@@ -6,7 +6,7 @@ import type * as equivalence from "./Equivalence.js"
 import { dual } from "./Function.js"
 import * as Hash from "./Hash.js"
 import type { Inspectable } from "./Inspectable.js"
-import { DenoInspectSymbol, NodeInspectSymbol } from "./Inspectable.js"
+import { NodeInspectSymbol } from "./Inspectable.js"
 import * as Option from "./Option.js"
 import * as order from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
@@ -160,9 +160,6 @@ const DurationProto: Omit<Duration, "value"> = {
         return { _id: "Duration", _tag: "Infinity" }
     }
   },
-  [DenoInspectSymbol]() {
-    return this.toJSON()
-  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },

package/src/Effect.ts

@@ -5307,7 +5307,7 @@ export const bind: {
    */
   <N extends string, A extends object, B, E2, R2>(
     name: Exclude<N, keyof A>,
-    f: (a: A) => Effect<B, E2, R2>
+    f: (a: NoInfer<A>) => Effect<B, E2, R2>
   ): <E1, R1>(self: Effect<A, E1, R1>) => Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E2 | E1, R2 | R1>
   /**
    * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
@@ -5340,7 +5340,7 @@ export const bind: {
   <A extends object, N extends string, E1, R1, B, E2, R2>(
     self: Effect<A, E1, R1>,
     name: Exclude<N, keyof A>,
-    f: (a: A) => Effect<B, E2, R2>
+    f: (a: NoInfer<A>) => Effect<B, E2, R2>
   ): Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E1 | E2, R1 | R2>
 } = effect.bind
 
@@ -5397,7 +5397,7 @@ export const bindAll: {
       readonly concurrentFinalizers?: boolean | undefined
     }
   >(
-    f: (a: A) => [Extract<keyof X, keyof A>] extends [never] ? X : `Duplicate keys`,
+    f: (a: NoInfer<A>) => [Extract<keyof X, keyof A>] extends [never] ? X : `Duplicate keys`,
     options?: undefined | O
   ): <E1, R1>(
     self: Effect<A, E1, R1>
@@ -5442,7 +5442,7 @@ export const bindAll: {
     R1
   >(
     self: Effect<A, E1, R1>,
-    f: (a: A) => [Extract<keyof X, keyof A>] extends [never] ? X : `Duplicate keys`,
+    f: (a: NoInfer<A>) => [Extract<keyof X, keyof A>] extends [never] ? X : `Duplicate keys`,
     options?: undefined | {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
@@ -5550,12 +5550,12 @@ export const bindTo: {
 const let_: {
   <N extends string, A extends object, B>(
     name: Exclude<N, keyof A>,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): <E, R>(self: Effect<A, E, R>) => Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
   <A extends object, N extends string, E, R, B>(
     self: Effect<A, E, R>,
     name: Exclude<N, keyof A>,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): Effect<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
 } = effect.let_
 

package/src/Either.ts

@@ -1383,7 +1383,7 @@ export const bind: {
    */
   <N extends string, A extends object, B, L2>(
     name: Exclude<N, keyof A>,
-    f: (a: A) => Either<B, L2>
+    f: (a: NoInfer<A>) => Either<B, L2>
   ): <L1>(self: Either<A, L1>) => Either<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, L1 | L2>
   /**
    * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
@@ -1416,7 +1416,7 @@ export const bind: {
   <A extends object, L1, N extends string, B, L2>(
     self: Either<A, L1>,
     name: Exclude<N, keyof A>,
-    f: (a: A) => Either<B, L2>
+    f: (a: NoInfer<A>) => Either<B, L2>
   ): Either<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, L1 | L2>
 } = doNotation.bind<EitherTypeLambda>(map, flatMap)
 
@@ -1512,12 +1512,12 @@ export const bindTo: {
 const let_: {
   <N extends string, R extends object, B>(
     name: Exclude<N, keyof R>,
-    f: (r: R) => B
+    f: (r: NoInfer<R>) => B
   ): <L>(self: Either<R, L>) => Either<{ [K in N | keyof R]: K extends keyof R ? R[K] : B }, L>
   <R extends object, L, N extends string, B>(
     self: Either<R, L>,
     name: Exclude<N, keyof R>,
-    f: (r: R) => B
+    f: (r: NoInfer<R>) => B
   ): Either<{ [K in N | keyof R]: K extends keyof R ? R[K] : B }, L>
 } = doNotation.let_<EitherTypeLambda>(map)
 

package/src/FiberHandle.ts

@@ -64,9 +64,6 @@ const Proto = {
       state: this.state
     }
   },
-  [Inspectable.DenoInspectSymbol](this: FiberHandle) {
-    return this.toJSON()
-  },
   [Inspectable.NodeInspectSymbol](this: FiberHandle) {
     return this.toJSON()
   },

package/src/FiberMap.ts

@@ -74,9 +74,6 @@ const Proto = {
       state: this.state
     }
   },
-  [Inspectable.DenoInspectSymbol](this: FiberMap<unknown>) {
-    return this.toJSON()
-  },
   [Inspectable.NodeInspectSymbol](this: FiberMap<unknown>) {
     return this.toJSON()
   },

package/src/FiberSet.ts

@@ -72,9 +72,6 @@ const Proto = {
       state: this.state
     }
   },
-  [Inspectable.DenoInspectSymbol](this: FiberSet<unknown, unknown>) {
-    return this.toJSON()
-  },
   [Inspectable.NodeInspectSymbol](this: FiberSet<unknown, unknown>) {
     return this.toJSON()
   },

package/src/Inspectable.ts

@@ -16,18 +16,6 @@ export const NodeInspectSymbol = Symbol.for("nodejs.util.inspect.custom")
  */
 export type NodeInspectSymbol = typeof NodeInspectSymbol
 
-/**
- * @since 3.9.0
- * @category symbols
- */
-export const DenoInspectSymbol = Symbol.for("Deno.customInspect")
-
-/**
- * @since 3.9.0
- * @category symbols
- */
-export type DenoInspectSymbol = typeof DenoInspectSymbol
-
 /**
  * @since 2.0.0
  * @category models
@@ -36,7 +24,6 @@ export interface Inspectable {
   toString(): string
   toJSON(): unknown
   [NodeInspectSymbol](): unknown
-  [DenoInspectSymbol](): unknown
 }
 
 /**
@@ -69,9 +56,6 @@ export const BaseProto: Inspectable = {
   [NodeInspectSymbol]() {
     return this.toJSON()
   },
-  [DenoInspectSymbol]() {
-    return this.toJSON()
-  },
   toString() {
     return format(this.toJSON())
   }
@@ -91,12 +75,6 @@ export abstract class Class {
   [NodeInspectSymbol]() {
     return this.toJSON()
   }
-  /**
-   * @since 3.9.0
-   */
-  [DenoInspectSymbol]() {
-    return this.toJSON()
-  }
   /**
    * @since 2.0.0
    */

package/src/List.ts

@@ -28,7 +28,7 @@ import * as Equal from "./Equal.js"
 import * as Equivalence from "./Equivalence.js"
 import { dual, identity, unsafeCoerce } from "./Function.js"
 import * as Hash from "./Hash.js"
-import { DenoInspectSymbol, format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
+import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
 import type { nonEmpty, NonEmptyIterable } from "./NonEmptyIterable.js"
 import * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
@@ -110,9 +110,6 @@ const ConsProto: Omit<Cons<unknown>, "head" | "tail" | typeof nonEmpty> = {
       values: toArray(this).map(toJSON)
     }
   },
-  [DenoInspectSymbol]() {
-    return this.toJSON()
-  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },
@@ -179,9 +176,6 @@ const NilProto: Nil<unknown> = {
       _tag: "Nil"
     }
   },
-  [DenoInspectSymbol]() {
-    return this.toJSON()
-  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },

package/src/Micro.ts

@@ -13,7 +13,7 @@ import { constTrue, constVoid, dual, identity, type LazyArg } from "./Function.j
 import { globalValue } from "./GlobalValue.js"
 import type { TypeLambda } from "./HKT.js"
 import type { Inspectable } from "./Inspectable.js"
-import { DenoInspectSymbol, NodeInspectSymbol, toStringUnknown } from "./Inspectable.js"
+import { NodeInspectSymbol, toStringUnknown } from "./Inspectable.js"
 import * as doNotation from "./internal/doNotation.js"
 import { StructuralPrototype } from "./internal/effectable.js"
 import { SingleShotGen } from "./internal/singleShotGen.js"
@@ -323,9 +323,6 @@ abstract class MicroCauseImpl<Tag extends string, E> extends globalThis.Error im
   toString() {
     return this.stack
   }
-  [DenoInspectSymbol]() {
-    return this.stack
-  }
   [NodeInspectSymbol]() {
     return this.stack
   }
@@ -4794,7 +4791,7 @@ export const bind: {
    */
   <N extends string, A extends Record<string, any>, B, E2, R2>(
     name: N,
-    f: (a: A) => Micro<B, E2, R2>
+    f: (a: NoInfer<A>) => Micro<B, E2, R2>
   ): <E, R>(self: Micro<A, E, R>) => Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
   /**
    * Bind the success value of this `Micro` effect to the provided name.
@@ -4806,19 +4803,19 @@ export const bind: {
   <A extends Record<string, any>, E, R, B, E2, R2, N extends string>(
     self: Micro<A, E, R>,
     name: N,
-    f: (a: A) => Micro<B, E2, R2>
+    f: (a: NoInfer<A>) => Micro<B, E2, R2>
   ): Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2>
 } = doNotation.bind<MicroTypeLambda>(map, flatMap)
 
 const let_: {
   <N extends string, A extends Record<string, any>, B>(
     name: N,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): <E, R>(self: Micro<A, E, R>) => Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E, R>
   <A extends Record<string, any>, E, R, B, N extends string>(
     self: Micro<A, E, R>,
     name: N,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): Micro<Simplify<Omit<A, N> & { [K in N]: B }>, E, R>
 } = doNotation.let_<MicroTypeLambda>(map)
 
@@ -5256,9 +5253,6 @@ const YieldableError: new(message?: string) => YieldableError = (function() {
     toJSON() {
       return { ...this }
     }
-    [DenoInspectSymbol](): string {
-      return this[NodeInspectSymbol]()
-    }
     [NodeInspectSymbol](): string {
       const stack = this.stack
       if (stack) {

package/src/MutableHashMap.ts

@@ -5,7 +5,7 @@ import type { NonEmptyArray } from "./Array.js"
 import * as Equal from "./Equal.js"
 import { dual } from "./Function.js"
 import * as Hash from "./Hash.js"
-import { DenoInspectSymbol, format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
+import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
 import * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
@@ -46,9 +46,6 @@ const MutableHashMapProto: Omit<MutableHashMap<unknown, unknown>, "referential"
       values: Array.from(this).map(toJSON)
     }
   },
-  [DenoInspectSymbol]() {
-    return this.toJSON()
-  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },

package/src/MutableHashSet.ts

@@ -2,7 +2,7 @@
  * @since 2.0.0
  */
 import * as Dual from "./Function.js"
-import { DenoInspectSymbol, format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
+import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
 import * as MutableHashMap from "./MutableHashMap.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
@@ -40,9 +40,6 @@ const MutableHashSetProto: Omit<MutableHashSet<unknown>, "keyMap"> = {
       values: Array.from(this).map(toJSON)
     }
   },
-  [DenoInspectSymbol]() {
-    return this.toJSON()
-  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },

package/src/MutableList.ts

@@ -2,7 +2,7 @@
  * @since 2.0.0
  */
 import * as Dual from "./Function.js"
-import { DenoInspectSymbol, format, NodeInspectSymbol, toJSON } from "./Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "./Inspectable.js"
 import type { Inspectable } from "./Inspectable.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
@@ -63,9 +63,6 @@ const MutableListProto: Omit<MutableList<unknown>, "head" | "tail"> = {
       values: Array.from(this).map(toJSON)
     }
   },
-  [DenoInspectSymbol]() {
-    return this.toJSON()
-  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },

package/src/MutableQueue.ts

@@ -3,7 +3,7 @@
  */
 import * as Chunk from "./Chunk.js"
 import * as Dual from "./Function.js"
-import { DenoInspectSymbol, format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
+import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
 import * as MutableList from "./MutableList.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
@@ -59,9 +59,6 @@ const MutableQueueProto: Omit<MutableQueue<unknown>, "queue" | "capacity"> = {
       values: Array.from(this).map(toJSON)
     }
   },
-  [DenoInspectSymbol]() {
-    return this.toJSON()
-  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },

package/src/MutableRef.ts

@@ -3,7 +3,7 @@
  */
 import * as Equal from "./Equal.js"
 import * as Dual from "./Function.js"
-import { DenoInspectSymbol, format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
+import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
 
@@ -37,9 +37,6 @@ const MutableRefProto: Omit<MutableRef<unknown>, "current"> = {
       current: toJSON(this.current)
     }
   },
-  [DenoInspectSymbol]() {
-    return this.toJSON()
-  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },

package/src/Option.ts

@@ -2199,12 +2199,12 @@ export const bindTo: {
 const let_: {
   <N extends string, A extends object, B>(
     name: Exclude<N, keyof A>,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): (self: Option<A>) => Option<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
   <A extends object, N extends string, B>(
     self: Option<A>,
     name: Exclude<N, keyof A>,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): Option<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
 } = doNotation.let_<OptionTypeLambda>(map)
 
@@ -2305,7 +2305,7 @@ export const bind: {
    */
   <N extends string, A extends object, B>(
     name: Exclude<N, keyof A>,
-    f: (a: A) => Option<B>
+    f: (a: NoInfer<A>) => Option<B>
   ): (self: Option<A>) => Option<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
   /**
    * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
@@ -2340,7 +2340,7 @@ export const bind: {
   <A extends object, N extends string, B>(
     self: Option<A>,
     name: Exclude<N, keyof A>,
-    f: (a: A) => Option<B>
+    f: (a: NoInfer<A>) => Option<B>
   ): Option<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>
 } = doNotation.bind<OptionTypeLambda>(map, flatMap)
 

package/src/STM.ts

@@ -3094,7 +3094,7 @@ export const bind: {
    */
   <N extends string, K, A, E2, R2>(
     tag: Exclude<N, keyof K>,
-    f: (_: K) => STM<A, E2, R2>
+    f: (_: NoInfer<K>) => STM<A, E2, R2>
   ): <E, R>(self: STM<K, E, R>) => STM<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
   /**
    * @category do notation
@@ -3103,19 +3103,19 @@ export const bind: {
   <K, E, R, N extends string, A, E2, R2>(
     self: STM<K, E, R>,
     tag: Exclude<N, keyof K>,
-    f: (_: K) => STM<A, E2, R2>
+    f: (_: NoInfer<K>) => STM<A, E2, R2>
   ): STM<MergeRecord<K, { [k in N]: A }>, E | E2, R | R2>
 } = stm.bind
 
 const let_: {
   <N extends string, K, A>(
     tag: Exclude<N, keyof K>,
-    f: (_: K) => A
+    f: (_: NoInfer<K>) => A
   ): <E, R>(self: STM<K, E, R>) => STM<MergeRecord<K, { [k in N]: A }>, E, R>
   <K, E, R, N extends string, A>(
     self: STM<K, E, R>,
     tag: Exclude<N, keyof K>,
-    f: (_: K) => A
+    f: (_: NoInfer<K>) => A
   ): STM<MergeRecord<K, { [k in N]: A }>, E, R>
 } = stm.let_
 

package/src/SortedMap.ts

@@ -5,7 +5,7 @@ import * as Equal from "./Equal.js"
 import * as Dual from "./Function.js"
 import { pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
-import { DenoInspectSymbol, format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
+import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
 import * as Option from "./Option.js"
 import type { Order } from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
@@ -62,9 +62,6 @@ const SortedMapProto: Omit<SortedMap<unknown, unknown>, "tree"> = {
       values: Array.from(this).map(toJSON)
     }
   },
-  [DenoInspectSymbol]() {
-    return this.toJSON()
-  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },

package/src/SortedSet.ts

@@ -7,7 +7,7 @@ import * as Dual from "./Function.js"
 import { pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
 import type { Inspectable } from "./Inspectable.js"
-import { DenoInspectSymbol, format, NodeInspectSymbol, toJSON } from "./Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "./Inspectable.js"
 import type { Order } from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
@@ -62,9 +62,6 @@ const SortedSetProto: Omit<SortedSet<unknown>, "keyTree"> = {
       values: Array.from(this).map(toJSON)
     }
   },
-  [DenoInspectSymbol]() {
-    return this.toJSON()
-  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },

package/src/Stream.ts

@@ -10819,7 +10819,7 @@ export const bind: {
    */
   <N extends string, A, B, E2, R2>(
     tag: Exclude<N, keyof A>,
-    f: (_: A) => Stream<B, E2, R2>,
+    f: (_: NoInfer<A>) => Stream<B, E2, R2>,
     options?:
       | { readonly concurrency?: number | "unbounded" | undefined; readonly bufferSize?: number | undefined }
       | undefined
@@ -10856,7 +10856,7 @@ export const bind: {
   <A, E, R, N extends string, B, E2, R2>(
     self: Stream<A, E, R>,
     tag: Exclude<N, keyof A>,
-    f: (_: A) => Stream<B, E2, R2>,
+    f: (_: NoInfer<A>) => Stream<B, E2, R2>,
     options?:
       | { readonly concurrency?: number | "unbounded" | undefined; readonly bufferSize?: number | undefined }
       | undefined
@@ -10888,11 +10888,9 @@ export const bindEffect: {
    */
   <N extends string, A, B, E2, R2>(
     tag: Exclude<N, keyof A>,
-    f: (_: A) => Effect.Effect<B, E2, R2>,
-    options?:
-      | { readonly concurrency?: number | "unbounded" | undefined; readonly bufferSize?: number | undefined }
-      | undefined
-  ): <E, R>(self: Stream<A, E, R>) => Stream<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E2 | E, R2 | R>
+    f: (_: NoInfer<A>) => Effect.Effect<B, E2, R2>,
+    options?: { readonly concurrency?: number | "unbounded" | undefined; readonly bufferSize?: number | undefined }
+  ): <E, R>(self: Stream<A, E, R>) => Stream<{ [K in keyof A | N]: K extends keyof A ? A[K] : B }, E | E2, R | R2>
   /**
    * Binds an effectful value in a `do` scope
    *
@@ -10907,11 +10905,9 @@ export const bindEffect: {
   <A, E, R, N extends string, B, E2, R2>(
     self: Stream<A, E, R>,
     tag: Exclude<N, keyof A>,
-    f: (_: A) => Effect.Effect<B, E2, R2>,
-    options?:
-      | { readonly concurrency?: number | "unbounded" | undefined; readonly unordered?: boolean | undefined }
-      | undefined
-  ): Stream<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E | E2, R | R2>
+    f: (_: NoInfer<A>) => Effect.Effect<B, E2, R2>,
+    options?: { readonly concurrency?: number | "unbounded" | undefined; readonly unordered?: boolean | undefined }
+  ): Stream<{ [K in keyof A | N]: K extends keyof A ? A[K] : B }, E | E2, R | R2>
 } = _groupBy.bindEffect
 
 /**
@@ -11009,12 +11005,12 @@ export const bindTo: {
 const let_: {
   <N extends string, A extends object, B>(
     name: Exclude<N, keyof A>,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): <E, R>(self: Stream<A, E, R>) => Stream<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
   <A extends object, E, R, N extends string, B>(
     self: Stream<A, E, R>,
     name: Exclude<N, keyof A>,
-    f: (a: A) => B
+    f: (a: NoInfer<A>) => B
   ): Stream<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }, E, R>
 } = internal.let_