effect 4.0.5 → 4.0.7

package/src/Equal.ts

@@ -12,7 +12,7 @@
  */
 import type { Equivalence } from "./Equivalence.ts"
 import * as Hash from "./Hash.ts"
-import { byReferenceInstances, getAllObjectKeys, viewBytes } from "./internal/equal.ts"
+import { bufferBytes, byReferenceInstances, getAllObjectKeys, isArrayBufferLike, viewBytes } from "./internal/equal.ts"
 import { hasProperty } from "./Predicate.ts"
 
 /**
@@ -257,6 +257,13 @@ function compareStructure(self: object, that: object): boolean {
       return false
     }
     return compareArrays(self, that)
+  } else if (isArrayBufferLike(self)) {
+    if (!isArrayBufferLike(that) || (self instanceof ArrayBuffer) !== (that instanceof ArrayBuffer)) {
+      return false
+    }
+    const selfBytes = bufferBytes(self)
+    const thatBytes = bufferBytes(that)
+    return selfBytes !== undefined && thatBytes !== undefined && compareTypedArrays(selfBytes, thatBytes)
   } else if (ArrayBuffer.isView(self)) {
     const selfIsDataView = self instanceof DataView
     if (

package/src/Equivalence.ts

@@ -462,7 +462,8 @@ export const combine: {
  * comparison stops at the first equivalence that returns `false`. Empty
  * collections return an equivalence that always returns `true`. The result is
  * also an equivalence that satisfies reflexive, symmetric, and transitive
- * properties.
+ * properties. The collection is materialized when the equivalence is created,
+ * so it must be finite.
  *
  * **Example** (Combining multiple field equivalences)
  *
@@ -514,15 +515,17 @@ export const combine: {
  * @category combining
  * @since 2.0.0
  */
-export const combineAll = <A>(collection: Iterable<Equivalence<A>>): Equivalence<A> =>
-  make((x, y) => {
-    for (const equivalence of collection) {
+export const combineAll = <A>(collection: Iterable<Equivalence<A>>): Equivalence<A> => {
+  const equivalences = Array.from(collection)
+  return make((x, y) => {
+    for (const equivalence of equivalences) {
       if (!equivalence(x, y)) {
         return false
       }
     }
     return true
   })
+}
 
 /**
  * Transforms an equivalence relation by mapping the input values before comparison.

package/src/Exit.ts

@@ -463,7 +463,7 @@ export const isFailure: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effe
  * @category guards
  * @since 4.0.0
  */
-export const hasFails: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effect.exitHasFails
+export const hasFails: <A, E>(self: Exit<A, E>) => boolean = effect.exitHasFails
 
 /**
  * Checks whether a failed Exit contains defects (Die reasons).
@@ -494,7 +494,7 @@ export const hasFails: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effec
  * @category guards
  * @since 4.0.0
  */
-export const hasDies: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effect.exitHasDies
+export const hasDies: <A, E>(self: Exit<A, E>) => boolean = effect.exitHasDies
 
 /**
  * Checks whether a failed Exit contains interruptions (Interrupt reasons).
@@ -525,7 +525,7 @@ export const hasDies: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effect
  * @category guards
  * @since 4.0.0
  */
-export const hasInterrupts: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effect.exitHasInterrupts
+export const hasInterrupts: <A, E>(self: Exit<A, E>) => boolean = effect.exitHasInterrupts
 
 /**
  * Extracts the Success variant from an Exit as a Result.
@@ -953,8 +953,10 @@ export const map: {
  *
  * **Gotchas**
  *
- * Only transforms typed errors (Fail reasons). If the Cause contains only
- * defects or interruptions, the failure passes through unchanged.
+ * Maps every typed error in the cause, preserving defects, interrupts and
+ * reason order. Unlike typed recovery, mapping does not convert errors to defects.
+ *
+ * If the Cause contains only defects or interruptions, no mapper is called.
  *
  * **Example** (Mapping over an error)
  *
@@ -987,8 +989,10 @@ export const mapError: {
    *
    * **Gotchas**
    *
-   * Only transforms typed errors (Fail reasons). If the Cause contains only
-   * defects or interruptions, the failure passes through unchanged.
+   * Maps every typed error in the cause, preserving defects, interrupts and
+   * reason order. Unlike typed recovery, mapping does not convert errors to defects.
+   *
+   * If the Cause contains only defects or interruptions, no mapper is called.
    *
    * **Example** (Mapping over an error)
    *
@@ -1021,8 +1025,10 @@ export const mapError: {
    *
    * **Gotchas**
    *
-   * Only transforms typed errors (Fail reasons). If the Cause contains only
-   * defects or interruptions, the failure passes through unchanged.
+   * Maps every typed error in the cause, preserving defects, interrupts and
+   * reason order. Unlike typed recovery, mapping does not convert errors to defects.
+   *
+   * If the Cause contains only defects or interruptions, no mapper is called.
    *
    * **Example** (Mapping over an error)
    *
@@ -1052,11 +1058,14 @@ export const mapError: {
  * **Details**
  *
  * `onSuccess` transforms the value if the Exit is a Success. `onFailure`
- * transforms the typed error if the Exit is a Failure with a Fail reason.
+ * transforms each typed error if the Exit is a Failure with Fail reasons.
  * Allocates a new Exit.
  *
  * **Gotchas**
  *
+ * Maps every typed error in the cause, preserving defects, interrupts and
+ * reason order. Unlike typed recovery, mapping does not convert errors to defects.
+ *
  * If the Cause contains only defects or interruptions, the failure passes
  * through unchanged.
  *
@@ -1089,11 +1098,14 @@ export const mapBoth: {
    * **Details**
    *
    * `onSuccess` transforms the value if the Exit is a Success. `onFailure`
-   * transforms the typed error if the Exit is a Failure with a Fail reason.
+   * transforms each typed error if the Exit is a Failure with Fail reasons.
    * Allocates a new Exit.
    *
    * **Gotchas**
    *
+   * Maps every typed error in the cause, preserving defects, interrupts and
+   * reason order. Unlike typed recovery, mapping does not convert errors to defects.
+   *
    * If the Cause contains only defects or interruptions, the failure passes
    * through unchanged.
    *
@@ -1128,11 +1140,14 @@ export const mapBoth: {
    * **Details**
    *
    * `onSuccess` transforms the value if the Exit is a Success. `onFailure`
-   * transforms the typed error if the Exit is a Failure with a Fail reason.
+   * transforms each typed error if the Exit is a Failure with Fail reasons.
    * Allocates a new Exit.
    *
    * **Gotchas**
    *
+   * Maps every typed error in the cause, preserving defects, interrupts and
+   * reason order. Unlike typed recovery, mapping does not convert errors to defects.
+   *
    * If the Cause contains only defects or interruptions, the failure passes
    * through unchanged.
    *

package/src/FiberHandle.ts

@@ -62,6 +62,8 @@ export interface FiberHandle<out A = unknown, out E = unknown> extends Pipeable,
   state: {
     readonly _tag: "Open"
     fiber: Fiber.Fiber<A, E> | undefined
+    /** Every fiber the handle still owns: the current one plus replaced fibers that are still interrupting. */
+    readonly fibers: Set<Fiber.Fiber<A, E>>
   } | {
     readonly _tag: "Closed"
   }
@@ -105,7 +107,7 @@ const Proto = {
 
 const makeUnsafe = <A = unknown, E = unknown>(): FiberHandle<A, E> => {
   const self = Object.create(Proto)
-  self.state = { _tag: "Open", fiber: undefined }
+  self.state = { _tag: "Open", fiber: undefined, fibers: new Set() }
   self.deferred = Deferred.makeUnsafe()
   return self
 }
@@ -154,12 +156,7 @@ export const make = <A = unknown, E = unknown>(): Effect.Effect<FiberHandle<A, E
       const state = handle.state
       if (state._tag === "Closed") return Effect.void
       handle.state = { _tag: "Closed" }
-      return state.fiber ?
-        Deferred.into(
-          Effect.asVoid(Fiber.interruptAs(state.fiber, internalFiberId)),
-          handle.deferred
-        ) :
-        Deferred.done(handle.deferred, Exit.void)
+      return Deferred.into(Fiber.interruptAllAs(state.fibers, internalFiberId), handle.deferred)
     }
   )
 
@@ -418,10 +415,14 @@ export const setUnsafe: {
 
   // Install the replacement before interruption can re-enter the handle through a finalizer.
   self.state.fiber = fiber
+  self.state.fibers.add(fiber)
   previous?.interruptUnsafe(internalFiberId)
   fiber.addObserver((exit) => {
-    if (self.state._tag === "Open" && fiber === self.state.fiber) {
-      self.state.fiber = undefined
+    if (self.state._tag === "Open") {
+      self.state.fibers.delete(fiber)
+      if (fiber === self.state.fiber) {
+        self.state.fiber = undefined
+      }
     }
     if (
       Exit.isFailure(exit) &&

package/src/FiberMap.ts

@@ -67,6 +67,8 @@ export interface FiberMap<in out K, out A = unknown, out E = unknown>
   state: {
     readonly _tag: "Open"
     readonly backing: MutableHashMap.MutableHashMap<K, Fiber.Fiber<A, E>>
+    /** Every fiber the map still owns: the keyed ones plus replaced fibers that are still interrupting. */
+    readonly fibers: Set<Fiber.Fiber<A, E>>
   } | {
     readonly _tag: "Closed"
   }
@@ -122,7 +124,7 @@ const makeUnsafe = <K, A = unknown, E = unknown>(
   deferred: Deferred.Deferred<void, E>
 ): FiberMap<K, A, E> => {
   const self = Object.create(Proto)
-  self.state = { _tag: "Open", backing }
+  self.state = { _tag: "Open", backing, fibers: new Set() }
   self.deferred = deferred
   return self
 }
@@ -176,7 +178,7 @@ export const make = <K, A = unknown, E = unknown>(): Effect.Effect<FiberMap<K, A
         const state = map.state
         if (state._tag === "Closed") return Effect.void
         map.state = { _tag: "Closed" }
-        return Fiber.interruptAll(MutableHashMap.values(state.backing)).pipe(
+        return Fiber.interruptAll(state.fibers).pipe(
           Deferred.into(map.deferred)
         )
       })
@@ -471,6 +473,7 @@ export const setUnsafe: {
 
   // Install the replacement before interruption can re-enter the map through a finalizer.
   MutableHashMap.set(self.state.backing, key, fiber)
+  self.state.fibers.add(fiber)
   if (previous._tag === "Some") {
     previous.value.interruptUnsafe(internalFiberId)
   }
@@ -478,6 +481,7 @@ export const setUnsafe: {
     if (self.state._tag === "Closed") {
       return
     }
+    self.state.fibers.delete(fiber)
     const current = MutableHashMap.get(self.state.backing, key)
     if (Option.isSome(current) && fiber === current.value) {
       MutableHashMap.remove(self.state.backing, key)
@@ -1145,70 +1149,13 @@ export const remove: {
    */
   <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<void>
 } = dual<
-  /**
-   * Removes a fiber from the FiberMap, interrupting it if it exists.
-   *
-   * **Example** (Removing a fiber)
-   *
-   * ```ts import.meta.vitest
-   * import { Effect, FiberMap } from "effect"
-   *
-   * const program = Effect.gen(function*() {
-   *   const map = yield* FiberMap.make<string>()
-   *
-   *   // Add some fibers to the map
-   *   yield* FiberMap.run(map, "task1", Effect.never)
-   *   yield* FiberMap.run(map, "task2", Effect.never)
-   *
-   *   const sizeBefore = yield* FiberMap.size(map)
-   *
-   *   // Remove a specific fiber (this will interrupt it)
-   *   yield* FiberMap.remove(map, "task1")
-   *
-   *   return [sizeBefore, yield* FiberMap.size(map)]
-   * })
-   *
-   * const actual = await Effect.runPromise(Effect.scoped(program))
-   * actual // => [2, 1]
-   * ```
-   *
-   * @stability stable
-   * @category combinators
-   * @since 2.0.0
-   */
-  <K>(key: K) => <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<void>,
-  /**
-   * Removes a fiber from the FiberMap, interrupting it if it exists.
-   *
-   * **Example** (Removing a fiber)
-   *
-   * ```ts import.meta.vitest
-   * import { Effect, FiberMap } from "effect"
-   *
-   * const program = Effect.gen(function*() {
-   *   const map = yield* FiberMap.make<string>()
-   *
-   *   // Add some fibers to the map
-   *   yield* FiberMap.run(map, "task1", Effect.never)
-   *   yield* FiberMap.run(map, "task2", Effect.never)
-   *
-   *   const sizeBefore = yield* FiberMap.size(map)
-   *
-   *   // Remove a specific fiber (this will interrupt it)
-   *   yield* FiberMap.remove(map, "task1")
-   *
-   *   return [sizeBefore, yield* FiberMap.size(map)]
-   * })
-   *
-   * const actual = await Effect.runPromise(Effect.scoped(program))
-   * actual // => [2, 1]
-   * ```
-   *
-   * @stability stable
-   * @category combinators
-   * @since 2.0.0
-   */
-  <K, A, E>(self: FiberMap<K, A, E>, key: K) => Effect.Effect<void>
+  <K>(
+    key: K
+  ) => <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<void>,
+  <K, A, E>(
+    self: FiberMap<K, A, E>,
+    key: K
+  ) => Effect.Effect<void>
 >(2, (self, key) =>
   Effect.suspend(() => {
     if (self.state._tag === "Closed") {

package/src/FileSystem.ts

@@ -152,6 +152,13 @@ export interface FileSystem {
     fromPath: string,
     toPath: string
   ) => Effect.Effect<void, PlatformError>
+  /**
+   * Get information about a file at `path` without following symbolic links.
+   * See `File.Info` for metadata limits.
+   */
+  readonly lstat: (
+    path: string
+  ) => Effect.Effect<File.Info, PlatformError>
   /**
    * Create a directory at `path`. You can optionally specify the mode and
    * whether to recursively create nested directories.
@@ -671,6 +678,9 @@ export const makeNoop = (fileSystem: Partial<FileSystem>): FileSystem =>
     link(path) {
       return Effect.fail(notFound("link", path))
     },
+    lstat(path) {
+      return Effect.fail(notFound("lstat", path))
+    },
     makeDirectory() {
       return Effect.die("not implemented")
     },

package/src/Formatter.ts

@@ -309,10 +309,11 @@ export function formatJson(input: unknown, options?: {
   readonly space?: number | string | undefined
 }): string {
   const ancestors: Array<object> = []
+  const sources = new WeakMap<object, object>()
   return JSON.stringify(
     input,
     function(this: object, key: string, value: unknown) {
-      const original = Object.getOwnPropertyDescriptor(this, key)?.value
+      const original = Object.getOwnPropertyDescriptor(sources.get(this) ?? this, key)?.value
       const redacted = Predicate.hasProperty(original, symbolRedactable)
         ? redact(original)
         : redact(value)
@@ -339,18 +340,10 @@ export function formatJson(input: unknown, options?: {
       if (!hasGetter(current) || isJsonPrimitiveWrapper(current)) {
         return current
       }
-      // JSON.stringify reads a getter once, then calls toJSON on the result
-      // before the replacer sees it. Intercept that read to redact the value
-      // first, instead of re-reading the getter in the replacer, which could
-      // repeat side effects or return a different value.
-      const serialized = new Proxy(current, {
-        get(target, key) {
-          const value = Reflect.get(target, key, target)
-          return Object.getOwnPropertyDescriptor(target, key)?.get !== undefined ? redact(value) : value
-        }
-      })
-      ancestors.push(serialized)
-      return serialized
+      const view = redactingView(current)
+      sources.set(view, current)
+      ancestors.push(view)
+      return view
     },
     options?.space
   ) ?? "null"
@@ -365,6 +358,28 @@ function hasGetter(object: object): boolean {
   return false
 }
 
+// JSON.stringify reads a getter once, then calls toJSON on the result before
+// the replacer sees it, so getter results are redacted at the read. A Proxy
+// would do, but not every engine has one, so each key becomes a getter that
+// reads the source lazily, with the source as receiver.
+function redactingView(object: object): object {
+  const view = Array.isArray(object) ? [] : {}
+  // JSON.stringify reads every array index, regardless of enumerability
+  const keys = Array.isArray(object)
+    ? Array.from({ length: object.length }, (_, i) => String(i))
+    : Object.keys(object)
+  for (const key of keys) {
+    Object.defineProperty(view, key, {
+      enumerable: true,
+      get: () => {
+        const value = Reflect.get(object, key)
+        return Object.getOwnPropertyDescriptor(object, key)?.get !== undefined ? redact(value) : value
+      }
+    })
+  }
+  return view
+}
+
 function isJsonPrimitiveWrapper(object: object): boolean {
   // Built-in valueOf checks internal slots across realms without calling user code.
   for (const valueOf of [Number.prototype.valueOf, Boolean.prototype.valueOf, String.prototype.valueOf]) {