effect 4.0.0-beta.73 → 4.0.0-beta.75

package/dist/Order.js

@@ -85,15 +85,15 @@ import * as Reducer from "./Reducer.js";
  *
  * **When to use**
  *
- * Use when when creating a custom order for a type that doesn't have a built-in order
- * - When you need fine-grained control over comparison logic
- * - When implementing orders for complex types
+ * Use when you need a sorting rule not covered by the built-in orders or input
+ * mapping helpers, and you can provide a total comparison.
  *
  * **Details**
  *
- * - Uses reference equality (`===`) as a shortcut: if `self === that`, returns `0` without calling the comparison function
- * - The comparison function should return `-1`, `0`, or `1` based on the comparison result
- * - The returned order satisfies total ordering laws if the comparison function does
+ * Uses reference equality (`===`) as a shortcut: if `self === that`, it returns
+ * `0` without calling the comparison function. The comparison function should
+ * return `-1`, `0`, or `1`, and the returned order satisfies total ordering
+ * laws when the comparison function does.
  *
  * **Example** (Creating an Order)
  *
@@ -123,15 +123,12 @@ export function make(compare) {
  *
  * **When to use**
  *
- * Use when when comparing strings alphabetically
- * - When sorting string collections
- * - As a base for creating orders on types containing strings
+ * Use when you need lexicographic string ordering.
  *
  * **Details**
  *
- * - Uses lexicographic (dictionary) ordering
- * - Empty string is less than any non-empty string
- * - Comparison is case-sensitive
+ * Uses lexicographic dictionary ordering. The empty string is less than any
+ * non-empty string, and comparisons are case-sensitive.
  *
  * **Example** (String Ordering)
  *
@@ -154,16 +151,13 @@ export const String = /*#__PURE__*/make((self, that) => self < that ? -1 : 1);
  *
  * **When to use**
  *
- * Use when when comparing numbers for sorting or searching
- * - As a base for creating orders on types containing numbers
- * - When implementing numeric comparisons in data structures
+ * Use when you need numeric ordering for numbers.
  *
  * **Details**
  *
- * - `0` is considered equal to `-0`
- * - All `NaN` values are considered equal to each other
- * - Any `NaN` is considered less than any non-NaN number
- * - Uses standard numeric comparison for all other values
+ * `0` is considered equal to `-0`. All `NaN` values are considered equal to
+ * each other, and any `NaN` is considered less than any non-`NaN` number. All
+ * other values use standard numeric comparison.
  *
  * **Example** (Number Ordering)
  *
@@ -194,14 +188,11 @@ export const Number = /*#__PURE__*/make((self, that) => {
  *
  * **When to use**
  *
- * Use when when comparing booleans for sorting or searching
- * - As a base for creating orders on types containing booleans
- * - When implementing boolean-based comparisons
+ * Use when you need boolean ordering where `false` comes before `true`.
  *
  * **Details**
  *
- * - `false` is less than `true`
- * - Equal values return `0`
+ * `false` is less than `true`, and equal values return `0`.
  *
  * **Example** (Boolean Ordering)
  *
@@ -223,14 +214,12 @@ export const Boolean = /*#__PURE__*/make((self, that) => self < that ? -1 : 1);
  *
  * **When to use**
  *
- * Use when when comparing bigint values for sorting or searching
- * - As a base for creating orders on types containing bigints
- * - When working with large integers that exceed number precision
+ * Use when you need numeric ordering for `bigint` values.
  *
  * **Details**
  *
- * - Uses standard numeric comparison for bigint values
- * - Handles arbitrarily large integers
+ * Uses standard numeric comparison for bigint values and handles arbitrarily
+ * large integers.
  *
  * **Example** (BigInt Ordering)
  *
@@ -253,15 +242,13 @@ export const BigInt = /*#__PURE__*/make((self, that) => self < that ? -1 : 1);
  *
  * **When to use**
  *
- * Use when when you need descending order instead of ascending
- * - When reversing an existing order without modifying the original
- * - When creating orders that compare in the opposite direction
+ * Use when you need the reverse of an existing order.
  *
  * **Details**
  *
- * - Returns a new order that swaps the arguments before comparison
- * - If the original order returns `-1`, the flipped order returns `1`, and vice versa
- * - Equal comparisons remain `0`
+ * Returns a new order that swaps the arguments before comparison. If the
+ * original order returns `-1`, the flipped order returns `1`, and vice versa.
+ * Equal comparisons remain `0`.
  *
  * **Example** (Reversing Order)
  *
@@ -288,15 +275,13 @@ export function flip(O) {
  *
  * **When to use**
  *
- * Use when when you need multi-criteria comparison (e.g., sort by age, then by name)
- * - When creating composite orders from simpler orders
- * - When implementing lexicographic ordering
+ * Use when you need tie-breaking with exactly two orders.
  *
  * **Details**
  *
- * - First applies the first order; if the result is non-zero, returns that result
- * - If the first order returns `0` (equal), applies the second order
- * - Returns the first non-zero result, or `0` if both orders return `0`
+ * First applies the first order. If the result is non-zero, that result is
+ * returned; otherwise, the second order is applied. The result is the first
+ * non-zero comparison result, or `0` if both orders return `0`.
  *
  * **Example** (Combining Orders)
  *
@@ -338,14 +323,12 @@ export const combine = /*#__PURE__*/dual(2, (self, that) => make((a1, a2) => {
  *
  * **When to use**
  *
- * Use when when you need an order that doesn't distinguish between values
- * - As a default or fallback order when no meaningful comparison exists
- * - When implementing optional ordering where equality is sufficient
+ * Use when you need an order that treats all values as equal.
  *
  * **Details**
  *
- * - Always returns `0` regardless of input values
- * - Useful as a neutral element in order composition
+ * Always returns `0` regardless of input values, making it useful as a neutral
+ * element in order composition.
  *
  * **Example** (Always Equal Order)
  *
@@ -372,16 +355,12 @@ export function alwaysEqual() {
  *
  * **When to use**
  *
- * Use when when you have a variable number of orders to combine
- * - When combining orders from a collection or array
- * - When implementing dynamic multi-criteria sorting
+ * Use when you need tie-breaking across a variable number of orders.
  *
  * **Details**
  *
- * - Applies orders in iteration order
- * - Returns the first non-zero result from any order
- * - Returns `0` only if all orders return `0`
- * - Short-circuits on the first non-zero result
+ * Applies orders in iteration order and short-circuits on the first non-zero
+ * result. It returns `0` only if all orders return `0`.
  *
  * **Example** (Combining Multiple Orders)
  *
@@ -428,15 +407,14 @@ export function combineAll(collection) {
  *
  * **When to use**
  *
- * Use when when you have an order for a property type and want to compare objects by that property
- * - When extracting a comparable value from a complex type
- * - When creating orders for types that contain comparable values
+ * Use when you need to adapt an `Order` to compare a larger value by one
+ * derived property.
  *
  * **Details**
  *
- * - Applies the mapping function to both values before comparison
- * - The mapping function should be pure and not have side effects
- * - Preserves the ordering properties of the original order
+ * Applies the mapping function to both values before comparison. The mapping
+ * function should be pure and not have side effects so the ordering properties
+ * of the original order are preserved.
  *
  * **Example** (Mapping Input)
  *
@@ -461,15 +439,13 @@ export const mapInput = /*#__PURE__*/dual(2, (self, f) => make((b1, b2) => self(
  *
  * **When to use**
  *
- * Use when when comparing dates for sorting or searching
- * - As a base for creating orders on types containing dates
- * - When implementing time-based comparisons
+ * Use when you need chronological ordering for JavaScript date values.
  *
  * **Details**
  *
- * - Compares dates by their underlying timestamp (milliseconds since epoch)
- * - Earlier dates are less than later dates
- * - Invalid dates are compared as if they were valid (uses `getTime()` result)
+ * Compares dates by their underlying timestamp in milliseconds since the epoch.
+ * Earlier dates are less than later dates. Invalid dates are compared through
+ * their `getTime()` result.
  *
  * **Example** (Date Ordering)
  *
@@ -494,16 +470,13 @@ export const Date = /*#__PURE__*/mapInput(Number, date => date.getTime());
  *
  * **When to use**
  *
- * Use when when comparing tuples with different types for each position
- * - When you need type-safe tuple ordering
- * - When working with fixed-length heterogeneous collections
+ * Use when you need fixed-length tuple ordering with per-position orders.
  *
  * **Details**
  *
- * - Compares tuples element-by-element using the corresponding order
- * - Stops at the first non-zero comparison result
- * - Requires tuples to have the same length as the order collection
- * - Returns `0` if all elements are equal
+ * Compares tuples element-by-element using the corresponding order and stops at
+ * the first non-zero comparison result. Tuples must have the same length as the
+ * order collection, and the result is `0` only if all elements are equal.
  *
  * **Example** (Tuple Ordering)
  *
@@ -556,16 +529,14 @@ export {
  *
  * **When to use**
  *
- * Use when when comparing arrays of the same element type
- * - When you want shorter arrays to be considered less than longer arrays
- * - When sorting collections of arrays
+ * Use when you need lexicographic ordering for arrays of one element type.
  *
  * **Details**
  *
- * - Compares arrays element-by-element using the provided order
- * - Stops at the first non-zero comparison result
- * - If all elements are equal, shorter arrays are less than longer arrays
- * - Returns `0` only if arrays have the same length and all elements are equal
+ * Compares arrays element-by-element using the provided order and stops at the
+ * first non-zero comparison result. If all elements are equal, shorter arrays
+ * are less than longer arrays. The result is `0` only if arrays have the same
+ * length and all elements are equal.
  *
  * **Example** (Array Element Ordering)
  *
@@ -590,16 +561,13 @@ Array_ as Array };
  *
  * **When to use**
  *
- * Use when when comparing objects with multiple properties
- * - When you need multi-field comparison for structs
- * - When creating orders for complex data types
+ * Use when you need multi-field ordering for objects with known properties.
  *
  * **Details**
  *
- * - Compares structs field-by-field in the order of keys in the fields object
- * - Stops at the first non-zero comparison result
- * - Returns `0` only if all fields are equal
- * - Field order matters: earlier fields take precedence
+ * Compares structs field-by-field in the key order of the fields object and
+ * stops at the first non-zero comparison result. Field order matters: earlier
+ * fields take precedence. The result is `0` only if all fields are equal.
  *
  * **Example** (Struct Ordering)
  *
@@ -642,15 +610,12 @@ export function Struct(fields) {
  *
  * **When to use**
  *
- * Use when when you need a boolean predicate instead of an ordering result
- * - When checking if a value is less than another in conditional logic
- * - When implementing range checks or comparisons
+ * Use when you need a boolean less-than predicate using an `Order`.
  *
  * **Details**
  *
- * - Returns `true` if the order returns `-1` (first value is less than second)
- * - Returns `false` for equal or greater values
- * - Supports curried and uncurried call styles
+ * Returns `true` if the order returns `-1`, meaning the first value is less
+ * than the second. Equal or greater values return `false`.
  *
  * **Example** (Less Than)
  *
@@ -675,15 +640,12 @@ export const isLessThan = O => dual(2, (self, that) => O(self, that) === -1);
  *
  * **When to use**
  *
- * Use when when you need a boolean predicate instead of an ordering result
- * - When checking if a value is greater than another in conditional logic
- * - When implementing range checks or comparisons
+ * Use when you need a boolean greater-than predicate using an `Order`.
  *
  * **Details**
  *
- * - Returns `true` if the order returns `1` (first value is greater than second)
- * - Returns `false` for equal or lesser values
- * - Supports curried and uncurried call styles
+ * Returns `true` if the order returns `1`, meaning the first value is greater
+ * than the second. Equal or lesser values return `false`.
  *
  * **Example** (Greater Than)
  *
@@ -708,15 +670,12 @@ export const isGreaterThan = O => dual(2, (self, that) => O(self, that) === 1);
  *
  * **When to use**
  *
- * Use when when you need a boolean predicate for non-strict comparison
- * - When checking if a value is within a range (inclusive lower bound)
- * - When implementing inclusive comparisons
+ * Use when you need a boolean less-than-or-equal predicate using an `Order`.
  *
  * **Details**
  *
- * - Returns `true` if the order returns `-1` or `0` (less than or equal)
- * - Returns `false` only if the order returns `1` (greater than)
- * - Supports curried and uncurried call styles
+ * Returns `true` if the order returns `-1` or `0`, and returns `false` only if
+ * the order returns `1`.
  *
  * **Example** (Less Than Or Equal)
  *
@@ -741,15 +700,13 @@ export const isLessThanOrEqualTo = O => dual(2, (self, that) => O(self, that) !=
  *
  * **When to use**
  *
- * Use when when you need a boolean predicate for non-strict comparison
- * - When checking if a value is within a range (inclusive upper bound)
- * - When implementing inclusive comparisons
+ * Use when you need a boolean greater-than-or-equal predicate using an
+ * `Order`.
  *
  * **Details**
  *
- * - Returns `true` if the order returns `1` or `0` (greater than or equal)
- * - Returns `false` only if the order returns `-1` (less than)
- * - Supports curried and uncurried call styles
+ * Returns `true` if the order returns `1` or `0`, and returns `false` only if
+ * the order returns `-1`.
  *
  * **Example** (Greater Than Or Equal)
  *
@@ -774,15 +731,13 @@ export const isGreaterThanOrEqualTo = O => dual(2, (self, that) => O(self, that)
  *
  * **When to use**
  *
- * Use when when you need to find the smaller of two values
- * - When implementing min/max operations
- * - When selecting values based on ordering
+ * Use when you need to select the smaller of two values according to an
+ * `Order`.
  *
  * **Details**
  *
- * - Returns the value that compares as less than or equal to the other
- * - If values are equal, returns the first argument
- * - Supports curried and uncurried call styles
+ * Returns the value that compares as less than or equal to the other value. If
+ * values are equal, the first argument is returned.
  *
  * **Example** (Minimum Value)
  *
@@ -807,15 +762,13 @@ export const min = O => dual(2, (self, that) => self === that || O(self, that) <
  *
  * **When to use**
  *
- * Use when when you need to find the larger of two values
- * - When implementing min/max operations
- * - When selecting values based on ordering
+ * Use when you need to select the larger of two values according to an
+ * `Order`.
  *
  * **Details**
  *
- * - Returns the value that compares as greater than or equal to the other
- * - If values are equal, returns the first argument
- * - Supports curried and uncurried call styles
+ * Returns the value that compares as greater than or equal to the other value.
+ * If values are equal, the first argument is returned.
  *
  * **Example** (Maximum Value)
  *
@@ -840,17 +793,15 @@ export const max = O => dual(2, (self, that) => self === that || O(self, that) >
  *
  * **When to use**
  *
- * Use when when you need to restrict a value to a specific range
- * - When implementing bounds checking and normalization
- * - When ensuring values stay within valid ranges
+ * Use when you need to clamp a value to an inclusive range according to an
+ * `Order`.
  *
  * **Details**
  *
- * - Returns the value if it's between minimum and maximum (inclusive)
- * - Returns minimum if the value is less than minimum
- * - Returns maximum if the value is greater than maximum
- * - Supports curried and uncurried call styles
- * - Requires that minimum <= maximum according to the order
+ * Returns the value itself when it is between minimum and maximum, inclusive.
+ * Values below the range return minimum, and values above the range return
+ * maximum. The minimum must be less than or equal to the maximum according to
+ * the order.
  *
  * **Example** (Clamping Values)
  *
@@ -876,16 +827,15 @@ export const clamp = O => dual(2, (self, options) => min(O)(options.maximum, max
  *
  * **When to use**
  *
- * Use when when validating that a value is within a valid range
- * - When implementing range checks for bounds validation
- * - When filtering or selecting values within a range
+ * Use when you need range checks that respect domain-specific ordering, such as
+ * dates, versions, or custom priorities, instead of JavaScript numeric
+ * comparison.
  *
  * **Details**
  *
- * - Returns `true` if the value is greater than or equal to minimum and less than or equal to maximum
- * - Returns `false` if the value is outside the range
- * - Supports curried and uncurried call styles
- * - Both bounds are inclusive
+ * Returns `true` when the value is greater than or equal to minimum and less
+ * than or equal to maximum. Values outside the range return `false`. Both
+ * bounds are inclusive.
  *
  * **Example** (Checking Range)
  *
@@ -913,16 +863,14 @@ export const isBetween = O => dual(2, (self, options) => !isLessThan(O)(self, op
  *
  * **When to use**
  *
- * Use when when you need to combine multiple orders from a collection using reducer patterns
- * - When implementing fold operations over collections of orders
- * - When working with reducers that operate on orders
+ * Use when you need a reducer that combines orders.
  *
  * **Details**
  *
- * - Returns a reducer that combines orders using {@link combine}
- * - Uses {@link alwaysEqual} as the identity element (returns `0` for empty collections)
- * - Uses {@link combineAll} for combining collections of orders
- * - The reducer can be used with fold operations on collections
+ * Returns a reducer that combines orders using `combine`, uses `alwaysEqual` as
+ * the identity element for empty collections, and uses `combineAll` for
+ * combining collections of orders. The reducer can be used with fold operations
+ * on collections.
  *
  * **Example** (Creating a Reducer)
  *
@@ -939,7 +887,7 @@ export const isBetween = O => dual(2, (self, options) => !isLessThan(O)(self, op
  * @see {@link combine} to combine two orders
  * @see {@link combineAll} to combine multiple orders
  * @see {@link Reducer} for reducing orders as a collection operation
- * @category utils
+ * @category constructors
  * @since 4.0.0
  */
 export function makeReducer() {

package/dist/Order.js.map

@@ -1 +1 @@
-{"version":3,"file":"Order.js","names":["dual","Reducer","make","compare","self","that","String","Number","globalThis","isNaN","Boolean","BigInt","flip","O","combine","a1","a2","out","alwaysEqual","combineAll","collection","mapInput","f","b1","b2","Date","date","getTime","Tuple","elements","len","length","i","o","Array_","aLen","bLen","Math","min","Array","Struct","fields","keys","Object","key","isLessThan","isGreaterThan","isLessThanOrEqualTo","isGreaterThanOrEqualTo","max","clamp","options","maximum","minimum","isBetween","makeReducer"],"sources":["../src/Order.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"Order.js","names":["dual","Reducer","make","compare","self","that","String","Number","globalThis","isNaN","Boolean","BigInt","flip","O","combine","a1","a2","out","alwaysEqual","combineAll","collection","mapInput","f","b1","b2","Date","date","getTime","Tuple","elements","len","length","i","o","Array_","aLen","bLen","Math","min","Array","Struct","fields","keys","Object","key","isLessThan","isGreaterThan","isLessThanOrEqualTo","isGreaterThanOrEqualTo","max","clamp","options","maximum","minimum","isBetween","makeReducer"],"sources":["../src/Order.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/PartitionedSemaphore.d.ts

@@ -115,8 +115,8 @@ export interface Partitioned<in K> extends PartitionedSemaphore<K> {
  *
  * **When to use**
  *
- * Use when a partitioned semaphore must be constructed synchronously outside an
- * `Effect` workflow.
+ * Use when you need to construct a partitioned semaphore synchronously outside
+ * an `Effect` workflow.
  *
  * **Details**
  *
@@ -207,8 +207,8 @@ export declare const capacity: <K>(self: PartitionedSemaphore<K>) => number;
  *
  * **When to use**
  *
- * Use to manually acquire permits for a partition when acquisition and release
- * must be controlled as separate effects.
+ * Use when you need manual permit acquisition for a partition and want to
+ * control acquisition and release as separate effects.
  *
  * **Details**
  *
@@ -235,8 +235,8 @@ export declare const take: {
      *
      * **When to use**
      *
-     * Use to manually acquire permits for a partition when acquisition and release
-     * must be controlled as separate effects.
+     * Use when you need manual permit acquisition for a partition and want to
+     * control acquisition and release as separate effects.
      *
      * **Details**
      *
@@ -263,8 +263,8 @@ export declare const take: {
      *
      * **When to use**
      *
-     * Use to manually acquire permits for a partition when acquisition and release
-     * must be controlled as separate effects.
+     * Use when you need manual permit acquisition for a partition and want to
+     * control acquisition and release as separate effects.
      *
      * **Details**
      *
@@ -292,8 +292,8 @@ export declare const take: {
  *
  * **When to use**
  *
- * Use to manually return permits acquired with `take` when a lower-level
- * partitioned permit protocol needs explicit release control.
+ * Use when you need to return permits acquired with `take` in a lower-level
+ * partitioned permit protocol with explicit release control.
  *
  * **Details**
  *
@@ -315,8 +315,8 @@ export declare const release: {
      *
      * **When to use**
      *
-     * Use to manually return permits acquired with `take` when a lower-level
-     * partitioned permit protocol needs explicit release control.
+     * Use when you need to return permits acquired with `take` in a lower-level
+     * partitioned permit protocol with explicit release control.
      *
      * **Details**
      *
@@ -338,8 +338,8 @@ export declare const release: {
      *
      * **When to use**
      *
-     * Use to manually return permits acquired with `take` when a lower-level
-     * partitioned permit protocol needs explicit release control.
+     * Use when you need to return permits acquired with `take` in a lower-level
+     * partitioned permit protocol with explicit release control.
      *
      * **Details**
      *

package/dist/PartitionedSemaphore.js

@@ -57,8 +57,8 @@ export const PartitionedTypeId = "~effect/PartitionedSemaphore";
  *
  * **When to use**
  *
- * Use when a partitioned semaphore must be constructed synchronously outside an
- * `Effect` workflow.
+ * Use when you need to construct a partitioned semaphore synchronously outside
+ * an `Effect` workflow.
  *
  * **Details**
  *
@@ -279,8 +279,8 @@ export const capacity = self => self.capacity;
  *
  * **When to use**
  *
- * Use to manually acquire permits for a partition when acquisition and release
- * must be controlled as separate effects.
+ * Use when you need manual permit acquisition for a partition and want to
+ * control acquisition and release as separate effects.
  *
  * **Details**
  *
@@ -307,8 +307,8 @@ export const take = /*#__PURE__*/dual(3, (self, key, permits) => self.take(key,
  *
  * **When to use**
  *
- * Use to manually return permits acquired with `take` when a lower-level
- * partitioned permit protocol needs explicit release control.
+ * Use when you need to return permits acquired with `take` in a lower-level
+ * partitioned permit protocol with explicit release control.
  *
  * **Details**
  *

package/dist/Path.d.ts

@@ -211,7 +211,7 @@ export declare namespace Path {
  *
  * **When to use**
  *
- * Use when an effect needs path operations supplied by its environment.
+ * Use when you need path operations supplied by an effect's environment.
  *
  * **Example** (Providing a custom Path service)
  *
@@ -269,7 +269,7 @@ export declare namespace Path {
  * const result = Effect.provide(program, customPathLayer)
  * ```
  *
- * @category tag
+ * @category services
  * @since 4.0.0
  */
 export declare const Path: Context.Service<Path, Path>;
@@ -278,7 +278,7 @@ export declare const Path: Context.Service<Path, Path>;
  *
  * **When to use**
  *
- * Use when an effect requires the `Path` service and should run with the
+ * Use when you need an effect that requires the `Path` service to run with the
  * built-in POSIX path implementation.
  *
  * **Details**