effect 4.0.5 → 4.0.6

package/src/Optic.ts

@@ -1352,49 +1352,7 @@ export const get: {
    */
   <S, A>(self: NoInfer<S>, optic: Lens<S, A>): A
 } = dual<
-  // ---------------------------------------------
-  // Derived APIs
-  // ---------------------------------------------
-
-  /**
-   * Reads the focused value from a `Lens`.
-   *
-   * **When to use**
-   *
-   * Use when the optic always focuses exactly one value.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms.
-   *
-   * @see {@link getResult} for optics whose focus may be absent
-   *
-   * @stability stable
-   * @category getters
-   * @since 4.0.0
-   */
   <S, A>(optic: Lens<S, A>) => (self: NoInfer<S>) => A,
-  // ---------------------------------------------
-  // Derived APIs
-  // ---------------------------------------------
-
-  /**
-   * Reads the focused value from a `Lens`.
-   *
-   * **When to use**
-   *
-   * Use when the optic always focuses exactly one value.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms.
-   *
-   * @see {@link getResult} for optics whose focus may be absent
-   *
-   * @stability stable
-   * @category getters
-   * @since 4.0.0
-   */
   <S, A>(self: NoInfer<S>, optic: Lens<S, A>) => A
 >(2, (self, optic) => optic.get(self))
 
@@ -1453,41 +1411,7 @@ export const getResult: {
    */
   <S, A>(self: NoInfer<S>, optic: Optional<S, A>): Result.Result<A, SchemaIssue.Issue>
 } = dual<
-  /**
-   * Attempts to read the focused value from an `Optional`.
-   *
-   * **When to use**
-   *
-   * Use when the optic may not focus and you need the failure as a `Result`.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms.
-   *
-   * @see {@link get} for optics that always focus
-   *
-   * @stability stable
-   * @category getters
-   * @since 4.0.0
-   */
   <S, A>(optic: Optional<S, A>) => (self: NoInfer<S>) => Result.Result<A, SchemaIssue.Issue>,
-  /**
-   * Attempts to read the focused value from an `Optional`.
-   *
-   * **When to use**
-   *
-   * Use when the optic may not focus and you need the failure as a `Result`.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms.
-   *
-   * @see {@link get} for optics that always focus
-   *
-   * @stability stable
-   * @category getters
-   * @since 4.0.0
-   */
   <S, A>(self: NoInfer<S>, optic: Optional<S, A>) => Result.Result<A, SchemaIssue.Issue>
 >(2, (self, optic) => optic.getResult(self))
 
@@ -1546,41 +1470,7 @@ export const set: {
    */
   <S, A>(self: NoInfer<A>, optic: Prism<S, A>): S
 } = dual<
-  /**
-   * Builds a source value from a focused value using a `Prism`.
-   *
-   * **When to use**
-   *
-   * Use when the optic can construct the source without an existing source value.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms. The focused value is `self`.
-   *
-   * @see {@link replace} for updates that use an existing source
-   *
-   * @stability stable
-   * @category transforming
-   * @since 4.0.0
-   */
   <S, A>(optic: Prism<S, A>) => (self: NoInfer<A>) => S,
-  /**
-   * Builds a source value from a focused value using a `Prism`.
-   *
-   * **When to use**
-   *
-   * Use when the optic can construct the source without an existing source value.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms. The focused value is `self`.
-   *
-   * @see {@link replace} for updates that use an existing source
-   *
-   * @stability stable
-   * @category transforming
-   * @since 4.0.0
-   */
   <S, A>(self: NoInfer<A>, optic: Prism<S, A>) => S
 >(2, (self, optic) => optic.set(self))
 
@@ -1639,41 +1529,7 @@ export const replace: {
    */
   <S, A>(self: NoInfer<S>, optic: Optional<S, A>, value: NoInfer<A>): S
 } = dual<
-  /**
-   * Replaces the focused value in a source.
-   *
-   * **When to use**
-   *
-   * Use when a failed focus should leave the source unchanged.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms.
-   *
-   * @see {@link replaceResult} for an explicit replacement failure
-   *
-   * @stability stable
-   * @category transforming
-   * @since 4.0.0
-   */
   <S, A>(optic: Optional<S, A>, value: NoInfer<A>) => (self: NoInfer<S>) => S,
-  /**
-   * Replaces the focused value in a source.
-   *
-   * **When to use**
-   *
-   * Use when a failed focus should leave the source unchanged.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms.
-   *
-   * @see {@link replaceResult} for an explicit replacement failure
-   *
-   * @stability stable
-   * @category transforming
-   * @since 4.0.0
-   */
   <S, A>(self: NoInfer<S>, optic: Optional<S, A>, value: NoInfer<A>) => S
 >(3, (self, optic, value) => optic.replace(value, self))
 
@@ -1732,42 +1588,15 @@ export const replaceResult: {
    */
   <S, A>(self: NoInfer<S>, optic: Optional<S, A>, value: NoInfer<A>): Result.Result<S, SchemaIssue.Issue>
 } = dual<
-  /**
-   * Attempts to replace the focused value in a source.
-   *
-   * **When to use**
-   *
-   * Use when you need an explicit `Result` for a replacement failure.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms.
-   *
-   * @see {@link replace} for returning the original source on failure
-   *
-   * @stability stable
-   * @category transforming
-   * @since 4.0.0
-   */
-  <S, A>(optic: Optional<S, A>, value: NoInfer<A>) => (self: NoInfer<S>) => Result.Result<S, SchemaIssue.Issue>,
-  /**
-   * Attempts to replace the focused value in a source.
-   *
-   * **When to use**
-   *
-   * Use when you need an explicit `Result` for a replacement failure.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms.
-   *
-   * @see {@link replace} for returning the original source on failure
-   *
-   * @stability stable
-   * @category transforming
-   * @since 4.0.0
-   */
-  <S, A>(self: NoInfer<S>, optic: Optional<S, A>, value: NoInfer<A>) => Result.Result<S, SchemaIssue.Issue>
+  <S, A>(
+    optic: Optional<S, A>,
+    value: NoInfer<A>
+  ) => (self: NoInfer<S>) => Result.Result<S, SchemaIssue.Issue>,
+  <S, A>(
+    self: NoInfer<S>,
+    optic: Optional<S, A>,
+    value: NoInfer<A>
+  ) => Result.Result<S, SchemaIssue.Issue>
 >(3, (self, optic, value) => optic.replaceResult(value, self))
 
 /**
@@ -1832,43 +1661,10 @@ export const modify: {
     f: (value: NoInfer<A>) => NoInfer<A>
   ): S
 } = dual<
-  /**
-   * Transforms the focused value in a source.
-   *
-   * **When to use**
-   *
-   * Use when you want to update a focus with a function.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms. A failed focus leaves the
-   * source unchanged.
-   *
-   * @see {@link modifyAll} for transforming every value in a traversal
-   *
-   * @stability stable
-   * @category transforming
-   * @since 4.0.0
-   */
-  <S, A>(optic: Optional<S, A>, f: (value: NoInfer<A>) => NoInfer<A>) => (self: NoInfer<S>) => S,
-  /**
-   * Transforms the focused value in a source.
-   *
-   * **When to use**
-   *
-   * Use when you want to update a focus with a function.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms. A failed focus leaves the
-   * source unchanged.
-   *
-   * @see {@link modifyAll} for transforming every value in a traversal
-   *
-   * @stability stable
-   * @category transforming
-   * @since 4.0.0
-   */
+  <S, A>(
+    optic: Optional<S, A>,
+    f: (value: NoInfer<A>) => NoInfer<A>
+  ) => (self: NoInfer<S>) => S,
   <S, A>(
     self: NoInfer<S>,
     optic: Optional<S, A>,
@@ -1994,83 +1790,7 @@ export const getAll: {
    */
   <S, A>(self: NoInfer<S>, traversal: Traversal<S, A>): Array<A>
 } = dual<
-  /**
-   * Extracts all values focused by a `Traversal` as a plain mutable array.
-   *
-   * **When to use**
-   *
-   * Use when you need the focused values as a simple `Array<A>` for further
-   *   processing.
-   *
-   * **Details**
-   *
-   * - Returns an empty array when the traversal cannot focus.
-   * - Always returns a fresh array (safe to mutate).
-   * - Supports both data-first and data-last forms.
-   *
-   * **Example** (Collecting positive numbers)
-   *
-   * ```ts import.meta.vitest
-   * import { Optic, Schema } from "effect"
-   *
-   * type S = { readonly values: ReadonlyArray<number> }
-   *
-   * const _pos = Optic.id<S>()
-   *   .key("values")
-   *   .forEach((n) => n.check(Schema.isGreaterThan(0)))
-   *
-   * const getPositive = Optic.getAll(_pos)
-   *
-   * getPositive({ values: [3, -1, 5] }) // => [3, 5]
-   *
-   * getPositive({ values: [-1, -2] }) // => []
-   * ```
-   *
-   * @see {@link Traversal} — the optic type this operates on
-   *
-   * @stability stable
-   * @category getters
-   * @since 4.0.0
-   */
   <S, A>(traversal: Traversal<S, A>) => (self: NoInfer<S>) => Array<A>,
-  /**
-   * Extracts all values focused by a `Traversal` as a plain mutable array.
-   *
-   * **When to use**
-   *
-   * Use when you need the focused values as a simple `Array<A>` for further
-   *   processing.
-   *
-   * **Details**
-   *
-   * - Returns an empty array when the traversal cannot focus.
-   * - Always returns a fresh array (safe to mutate).
-   * - Supports both data-first and data-last forms.
-   *
-   * **Example** (Collecting positive numbers)
-   *
-   * ```ts import.meta.vitest
-   * import { Optic, Schema } from "effect"
-   *
-   * type S = { readonly values: ReadonlyArray<number> }
-   *
-   * const _pos = Optic.id<S>()
-   *   .key("values")
-   *   .forEach((n) => n.check(Schema.isGreaterThan(0)))
-   *
-   * const getPositive = Optic.getAll(_pos)
-   *
-   * getPositive({ values: [3, -1, 5] }) // => [3, 5]
-   *
-   * getPositive({ values: [-1, -2] }) // => []
-   * ```
-   *
-   * @see {@link Traversal} — the optic type this operates on
-   *
-   * @stability stable
-   * @category getters
-   * @since 4.0.0
-   */
   <S, A>(self: NoInfer<S>, traversal: Traversal<S, A>) => Array<A>
 >(2, (self, traversal) =>
   Result.match(traversal.getResult(self), {
@@ -2143,45 +1863,10 @@ export const modifyAll: {
     f: (value: NoInfer<A>) => NoInfer<A>
   ): S
 } = dual<
-  /**
-   * Transforms every value focused by a `Traversal`.
-   *
-   * **When to use**
-   *
-   * Use when you want to update each value selected by a traversal.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms. A failed traversal leaves the
-   * source unchanged.
-   *
-   * @see {@link modify} for transforming the focus as a whole
-   * @see {@link getAll} for reading every focused value
-   *
-   * @stability stable
-   * @category transforming
-   * @since 4.0.0
-   */
-  <S, A>(traversal: Traversal<S, A>, f: (value: NoInfer<A>) => NoInfer<A>) => (self: NoInfer<S>) => S,
-  /**
-   * Transforms every value focused by a `Traversal`.
-   *
-   * **When to use**
-   *
-   * Use when you want to update each value selected by a traversal.
-   *
-   * **Details**
-   *
-   * Supports both data-first and data-last forms. A failed traversal leaves the
-   * source unchanged.
-   *
-   * @see {@link modify} for transforming the focus as a whole
-   * @see {@link getAll} for reading every focused value
-   *
-   * @stability stable
-   * @category transforming
-   * @since 4.0.0
-   */
+  <S, A>(
+    traversal: Traversal<S, A>,
+    f: (value: NoInfer<A>) => NoInfer<A>
+  ) => (self: NoInfer<S>) => S,
   <S, A>(
     self: NoInfer<S>,
     traversal: Traversal<S, A>,

package/src/Path.ts

@@ -430,7 +430,15 @@ function fromFileUrl(url: URL): Effect.Effect<string, BadArgument> {
       }
     }
   }
-  return Effect.succeed(decodeURIComponent(pathname))
+  return Effect.try({
+    try: () => decodeURIComponent(pathname),
+    catch: (cause) =>
+      new BadArgument({
+        module: "Path",
+        method: "fromFileUrl",
+        cause
+      })
+  })
 }
 
 const resolve: Path["resolve"] = function resolve() {

package/src/PubSub.ts

@@ -1915,16 +1915,16 @@ export const takeUpTo: {
 } = dual(2, <A>(self: Subscription<A>, max: number): Effect.Effect<Array<A>> =>
   Effect.suspend(() => {
     if (self.shutdownFlag.current) return Effect.interrupt
-    max = Count.normalize(max)
+    let limit = Count.normalize(max)
     let replay: Array<A> | undefined = undefined
-    if (self.replayWindow.remaining >= max) {
-      return Effect.succeed(self.replayWindow.takeN(max))
+    if (self.replayWindow.remaining >= limit) {
+      return Effect.succeed(self.replayWindow.takeN(limit))
     } else if (self.replayWindow.remaining > 0) {
       replay = self.replayWindow.takeAll()
-      max = max - replay.length
+      limit = limit - replay.length
     }
     const as = self.pollers.length === 0
-      ? self.subscription.pollUpTo(max)
+      ? self.subscription.pollUpTo(limit)
       : []
     self.strategy.onPubSubEmptySpaceUnsafe(self.pubsub, self.subscribers)
     return replay ? Effect.succeed(replay.concat(as)) : Effect.succeed(as)
@@ -2051,7 +2051,9 @@ const takeRemainderLoop = <A>(
     return Effect.succeed(acc)
   }
   return Effect.flatMap(takeUpTo(self, max), (bs) => {
-    acc.push(...bs)
+    for (let i = 0; i < bs.length; i++) {
+      acc.push(bs[i])
+    }
     const remaining = min - bs.length
     if (remaining === 1) {
       return Effect.map(take(self), (b) => {
@@ -3449,7 +3451,10 @@ class ReplayBuffer<A> {
     }
     this.tail = this.tail.next
     if (this.size === this.capacity) {
-      this.head = this.head.next!
+      const dropped = this.head
+      this.head = dropped.next!
+      dropped.next = null
+      dropped.value = AbsentValue
     } else {
       this.size += 1
     }

package/src/Queue.ts

@@ -761,7 +761,10 @@ export const offer: {
 )
 
 /**
- * Adds a message to the queue synchronously. Returns `false` if the queue is done.
+ * Adds a message to the queue synchronously. Returns `false` without adding the
+ * message if the queue is closing or done, or if it is full with a non-sliding
+ * strategy (`"suspend"` or `"dropping"`). A queue with non-positive capacity can
+ * still accept a message when a taker is waiting.
  *
  * **When to use**
  *
@@ -929,42 +932,7 @@ export const offerAll: {
 } = dual(2, <A, E>(self: Enqueue<A, E>, messages: Iterable<A>): Effect<Array<A>> =>
   // Admitting what fits and registering the rest are one step, so no take can
   // free capacity between them
-  internalEffect.callback</**
-   * Adds multiple messages to the queue. Returns the remaining messages that
-   * were not added.
-   *
-   * **When to use**
-   *
-   * Use when producers can submit a batch at once and need to know which messages
-   * did not fit under the queue's capacity strategy.
-   *
-   * **Details**
-   *
-   * For bounded queues, this operation may suspend if the queue doesn't have
-   * enough capacity. The operation returns an array of messages that couldn't
-   * be added (empty array means all messages were successfully added).
-   *
-   * **Example** (Offering multiple values)
-   *
-   * ```ts import.meta.vitest
-   * import { Effect, Queue } from "effect"
-   *
-   * const program = Effect.gen(function*() {
-   *   const queue = yield* Queue.dropping<number>(3)
-   *
-   *   // Try to add more messages than capacity without suspending
-   *   const remaining1 = yield* Queue.offerAll(queue, [1, 2, 3, 4, 5])
-   *   return remaining1
-   * })
-   *
-   * await Effect.runPromise(program) // => [4, 5]
-   * ```
-   *
-   * @stability stable
-   * @category offering
-   * @since 2.0.0
-   */
-  Array<A>>((resume) => {
+  internalEffect.callback<Array<A>>((resume) => {
     const remaining = offerAllUnsafe(self, messages)
     if (remaining.length === 0 || self.strategy === "dropping") {
       return resume(core.exitSucceed(remaining))

package/src/Random.ts

@@ -392,7 +392,7 @@ export const withSeed: {
 } = dual(2, <A, E, R>(
   self: Effect.Effect<A, E, R>,
   seed: string | number
-) => Effect.provideService(self, Random, ISAAC_CSPRNG(seed)))
+) => Effect.suspend(() => Effect.provideService(self, Random, ISAAC_CSPRNG(seed))))
 
 /*///////////////////////////////////////////////////////////////////////////////////////////////////
 This is a derivative work copyright (c) 2025 Effectful Technologies Inc, under MIT license.

package/src/RcMap.ts

@@ -4,10 +4,12 @@
  * An `RcMap` runs a lookup effect the first time a key is requested, shares the
  * in-progress or acquired resource with other callers for the same key, and
  * tracks each caller through its current `Scope`. When the last scope for a key
- * closes, the resource can be released, kept alive for an idle time, or removed
- * by capacity limits or explicit invalidation. It is meant for resource
- * lifecycles such as clients, sessions, and connections, not as a general
- * mutable cache.
+ * closes, the resource is released immediately or kept alive until its idle
+ * time-to-live expires. Entries can also be explicitly invalidated. Capacity
+ * limits do not evict entries: idle entries count toward capacity, and a new
+ * key fails with `ExceededCapacityError` when the map is full. It is meant for
+ * resource lifecycles such as clients, sessions, and connections, not as a
+ * general mutable cache.
  *
  * @stability stable
  * @since 3.5.0
@@ -204,7 +206,8 @@ const makeUnsafe = <K, A, E>(options: {
  *
  * Complex keys can extend `Equal` and `Hash` to allow lookups by value.
  *
- * - `capacity`: The maximum number of resources that can be held in the map.
+ * - `capacity`: The maximum number of entries, including idle entries. A new key
+ *   fails with `ExceededCapacityError` when full; existing entries are not evicted.
  * - `idleTimeToLive`: When the reference count reaches zero, the resource will be released after this duration.
  *
  * **Example** (Creating a reference-counted map)
@@ -257,7 +260,8 @@ export const make: {
    *
    * Complex keys can extend `Equal` and `Hash` to allow lookups by value.
    *
-   * - `capacity`: The maximum number of resources that can be held in the map.
+   * - `capacity`: The maximum number of entries, including idle entries. A new key
+   *   fails with `ExceededCapacityError` when full; existing entries are not evicted.
    * - `idleTimeToLive`: When the reference count reaches zero, the resource will be released after this duration.
    *
    * **Example** (Creating a reference-counted map)
@@ -316,7 +320,8 @@ export const make: {
    *
    * Complex keys can extend `Equal` and `Hash` to allow lookups by value.
    *
-   * - `capacity`: The maximum number of resources that can be held in the map.
+   * - `capacity`: The maximum number of entries, including idle entries. A new key
+   *   fails with `ExceededCapacityError` when full; existing entries are not evicted.
    * - `idleTimeToLive`: When the reference count reaches zero, the resource will be released after this duration.
    *
    * **Example** (Creating a reference-counted map)
@@ -393,7 +398,8 @@ export const make: {
             Effect.sync(() => {
               MutableHashMap.clear(map)
             })
-          )
+          ),
+          Effect.flatMap(Exit.asVoidAll)
         )
       }),
       self

package/src/Record.ts

@@ -1784,6 +1784,11 @@ export const isSubrecord: {
 /**
  * Reduces a record to a single value by combining its entries with a specified function.
  *
+ * **Details**
+ *
+ * The reducer function receives the accumulator, the current value, and the
+ * key of the current entry.
+ *
  * **Example** (Reducing record values)
  *
  * ```ts import.meta.vitest
@@ -1792,6 +1797,18 @@ export const isSubrecord: {
  * Record.reduce({ a: 1, b: 2, c: 3 }, 0, (acc, value) => acc + value) // => 6
  * ```
  *
+ * **Example** (Using the key in the reducer)
+ *
+ * ```ts import.meta.vitest
+ * import { Record } from "effect"
+ *
+ * Record.reduce(
+ *   { a: 1, b: 2, c: 3 },
+ *   "",
+ *   (acc, value, key) => (acc === "" ? `${key}${value}` : `${acc}-${key}${value}`)
+ * ) // => "a1-b2-c3"
+ * ```
+ *
  * @stability stable
  * @category folding
  * @since 2.0.0
@@ -1800,6 +1817,11 @@ export const reduce: {
   /**
    * Reduces a record to a single value by combining its entries with a specified function.
    *
+   * **Details**
+   *
+   * The reducer function receives the accumulator, the current value, and the
+   * key of the current entry.
+   *
    * **Example** (Reducing record values)
    *
    * ```ts import.meta.vitest
@@ -1808,6 +1830,18 @@ export const reduce: {
    * Record.reduce({ a: 1, b: 2, c: 3 }, 0, (acc, value) => acc + value) // => 6
    * ```
    *
+   * **Example** (Using the key in the reducer)
+   *
+   * ```ts import.meta.vitest
+   * import { Record } from "effect"
+   *
+   * Record.reduce(
+   *   { a: 1, b: 2, c: 3 },
+   *   "",
+   *   (acc, value, key) => (acc === "" ? `${key}${value}` : `${acc}-${key}${value}`)
+   * ) // => "a1-b2-c3"
+   * ```
+   *
    * @stability stable
    * @category folding
    * @since 2.0.0
@@ -1816,6 +1850,11 @@ export const reduce: {
   /**
    * Reduces a record to a single value by combining its entries with a specified function.
    *
+   * **Details**
+   *
+   * The reducer function receives the accumulator, the current value, and the
+   * key of the current entry.
+   *
    * **Example** (Reducing record values)
    *
    * ```ts import.meta.vitest
@@ -1824,6 +1863,18 @@ export const reduce: {
    * Record.reduce({ a: 1, b: 2, c: 3 }, 0, (acc, value) => acc + value) // => 6
    * ```
    *
+   * **Example** (Using the key in the reducer)
+   *
+   * ```ts import.meta.vitest
+   * import { Record } from "effect"
+   *
+   * Record.reduce(
+   *   { a: 1, b: 2, c: 3 },
+   *   "",
+   *   (acc, value, key) => (acc === "" ? `${key}${value}` : `${acc}-${key}${value}`)
+   * ) // => "a1-b2-c3"
+   * ```
+   *
    * @stability stable
    * @category folding
    * @since 2.0.0