effect 4.0.5 → 4.0.7

package/src/ChannelSchema.ts

@@ -293,55 +293,7 @@ export const duplex: {
   InDone,
   R | In["EncodingServices"] | Out["DecodingServices"]
 > =>
-  encode(options.inputSchema)</**
-   * Wraps a channel so callers work with typed input and output chunks while the
-   * wrapped channel uses encoded chunks.
-   *
-   * **When to use**
-   *
-   * Use to expose typed input and output at a bidirectional channel boundary
-   * while the wrapped channel continues to operate on schema-encoded chunks.
-   *
-   * **Details**
-   *
-   * Values sent into the resulting channel are encoded with `inputSchema` before
-   * reaching the wrapped channel. Values emitted by the wrapped channel are
-   * decoded with `outputSchema` before they are emitted downstream. Schema
-   * failures are surfaced as `SchemaError`.
-   *
-   * @see {@link duplexUnknown} for the variant whose encoded side is intentionally untyped
-   * @see {@link encode} for encoding typed chunks at one-way channel boundaries
-   * @see {@link decode} for decoding encoded chunks at one-way channel boundaries
-   *
-   * @stability unstable
-   * @category combinators
-   * @since 4.0.0
-   */
-  InErr, /**
-   * Wraps a channel so callers work with typed input and output chunks while the
-   * wrapped channel uses encoded chunks.
-   *
-   * **When to use**
-   *
-   * Use to expose typed input and output at a bidirectional channel boundary
-   * while the wrapped channel continues to operate on schema-encoded chunks.
-   *
-   * **Details**
-   *
-   * Values sent into the resulting channel are encoded with `inputSchema` before
-   * reaching the wrapped channel. Values emitted by the wrapped channel are
-   * decoded with `outputSchema` before they are emitted downstream. Schema
-   * failures are surfaced as `SchemaError`.
-   *
-   * @see {@link duplexUnknown} for the variant whose encoded side is intentionally untyped
-   * @see {@link encode} for encoding typed chunks at one-way channel boundaries
-   * @see {@link decode} for decoding encoded chunks at one-way channel boundaries
-   *
-   * @stability unstable
-   * @category combinators
-   * @since 4.0.0
-   */
-  InDone>().pipe(
+  encode(options.inputSchema)<InErr, InDone>().pipe(
     Channel.pipeTo(self),
     Channel.pipeTo(decode(options.outputSchema)())
   ))

package/src/Chunk.ts

@@ -561,6 +561,11 @@ export const reverse: <S extends Chunk<any>>(self: S) => Chunk.With<S, Chunk.Inf
  * Gets the value at an index in a `Chunk` safely, returning `None` when the index is
  * out of bounds.
  *
+ * **Details**
+ *
+ * The index is floored to an integer. `NaN` and infinite indexes are out of
+ * bounds. This never throws.
+ *
  * **Example** (Accessing elements safely)
  *
  * ```ts import.meta.vitest
@@ -585,6 +590,11 @@ export const get: {
    * Gets the value at an index in a `Chunk` safely, returning `None` when the index is
    * out of bounds.
    *
+   * **Details**
+   *
+   * The index is floored to an integer. `NaN` and infinite indexes are out of
+   * bounds. This never throws.
+   *
    * **Example** (Accessing elements safely)
    *
    * ```ts import.meta.vitest
@@ -609,6 +619,11 @@ export const get: {
    * Gets the value at an index in a `Chunk` safely, returning `None` when the index is
    * out of bounds.
    *
+   * **Details**
+   *
+   * The index is floored to an integer. `NaN` and infinite indexes are out of
+   * bounds. This never throws.
+   *
    * **Example** (Accessing elements safely)
    *
    * ```ts import.meta.vitest
@@ -631,8 +646,10 @@ export const get: {
   <A>(self: Chunk<A>, index: number): Option<A>
 } = dual(
   2,
-  <A>(self: Chunk<A>, index: number): Option<A> =>
-    index < 0 || index >= self.length ? O.none() : O.some(getUnsafe(self, index))
+  <A>(self: Chunk<A>, index: number): Option<A> => {
+    const i = Math.floor(index)
+    return i >= 0 && i < self.length ? O.some(getUnchecked(self, i)) : O.none()
+  }
 )
 
 /**
@@ -710,7 +727,8 @@ export const fromNonEmptyArrayUnsafe = <A>(self: NonEmptyReadonlyArray<A>): NonE
  *
  * **Gotchas**
  *
- * Throws if the index is out of bounds.
+ * Throws if the floored index is out of bounds, including for `NaN` and
+ * infinite indexes.
  *
  * **Example** (Accessing elements unsafely)
  *
@@ -741,7 +759,8 @@ export const getUnsafe: {
    *
    * **Gotchas**
    *
-   * Throws if the index is out of bounds.
+   * Throws if the floored index is out of bounds, including for `NaN` and
+   * infinite indexes.
    *
    * **Example** (Accessing elements unsafely)
    *
@@ -772,7 +791,8 @@ export const getUnsafe: {
    *
    * **Gotchas**
    *
-   * Throws if the index is out of bounds.
+   * Throws if the floored index is out of bounds, including for `NaN` and
+   * infinite indexes.
    *
    * **Example** (Accessing elements unsafely)
    *
@@ -795,32 +815,33 @@ export const getUnsafe: {
   <A>(self: Chunk<A>, index: number): A
 } = dual(2, <A>(self: Chunk<A>, index: number): A => {
   const i = Math.floor(index)
+  if (!(i >= 0 && i < self.length)) {
+    throw new Error(`Index out of bounds: ${i}`)
+  }
+  return getUnchecked(self, i)
+})
+
+const getUnchecked = <A>(self: Chunk<A>, i: number): A => {
   switch (self.backing._tag) {
     case "IEmpty": {
       throw new Error(`Index out of bounds: ${i}`)
     }
     case "ISingleton": {
-      if (index !== 0) {
-        throw new Error(`Index out of bounds: ${i}`)
-      }
       return self.backing.a
     }
     case "IArray": {
-      if (i >= self.length || i < 0) {
-        throw new Error(`Index out of bounds: ${i}`)
-      }
       return self.backing.array[i]!
     }
     case "IConcat": {
       return i < self.left.length
-        ? getUnsafe(self.left, i)
-        : getUnsafe(self.right, i - self.left.length)
+        ? getUnchecked(self.left, i)
+        : getUnchecked(self.right, i - self.left.length)
     }
     case "ISlice": {
-      return getUnsafe(self.backing.chunk, i + self.backing.offset)
+      return getUnchecked(self.backing.chunk, i + self.backing.offset)
     }
   }
-})
+}
 
 /**
  * Appends the specified element to the end of the `Chunk`.
@@ -1532,34 +1553,7 @@ export const appendAll: {
   }
   const diff = that.depth - self.depth
   if (Math.abs(diff) <= 1) {
-    return makeChunk</**
-     * Concatenates two chunks, combining their elements.
-     * If either chunk is non-empty, the result is also a non-empty chunk.
-     *
-     * **When to use**
-     *
-     * Use to concatenate two chunks when the second chunk's elements should come
-     * after the first.
-     *
-     * **Example** (Appending all elements)
-     *
-     * ```ts import.meta.vitest
-     * import { Chunk } from "effect"
-     *
-     * Chunk.make(1, 2).pipe(
-     *   Chunk.appendAll(Chunk.make("a", "b")),
-     *   Chunk.toArray
-     * ) // => [1, 2, "a", "b"]
-     * ```
-     *
-     * @see {@link prependAll} for concatenating chunks in the opposite order
-     * @see {@link append} for adding a single element to the end
-     *
-     * @stability stable
-     * @category combining
-     * @since 2.0.0
-     */
-    A | B>({ _tag: "IConcat", left: self, right: that });
+    return makeChunk<A | B>({ _tag: "IConcat", left: self, right: that })
   } else if (diff < -1) {
     if (self.left.depth >= self.right.depth) {
       const nr = appendAll(self.right, that)
@@ -3929,7 +3923,12 @@ export const takeWhile: {
 })
 
 /**
- * Creates a Chunks of unique values, in order, from all given Chunks.
+ * Computes the union of two chunks using Effect equality.
+ *
+ * **Gotchas**
+ *
+ * Each input must already be deduplicated. Use {@link dedupe} to remove
+ * duplicates from an input first.
  *
  * **Example** (Unioning chunks)
  *
@@ -3939,11 +3938,6 @@ export const takeWhile: {
  * const chunk1 = Chunk.make(1, 2, 3)
  * const chunk2 = Chunk.make(3, 4, 5)
  * Chunk.toArray(Chunk.union(chunk1, chunk2)) // => [1, 2, 3, 4, 5]
- *
- * // Handles duplicates within the same chunk
- * const withDupes1 = Chunk.make(1, 1, 2)
- * const withDupes2 = Chunk.make(2, 3, 3)
- * Chunk.toArray(Chunk.union(withDupes1, withDupes2)) // => [1, 2, 3]
  * ```
  *
  * @stability stable
@@ -3952,7 +3946,12 @@ export const takeWhile: {
  */
 export const union: {
   /**
-   * Creates a Chunks of unique values, in order, from all given Chunks.
+   * Computes the union of two chunks using Effect equality.
+   *
+   * **Gotchas**
+   *
+   * Each input must already be deduplicated. Use {@link dedupe} to remove
+   * duplicates from an input first.
    *
    * **Example** (Unioning chunks)
    *
@@ -3962,11 +3961,6 @@ export const union: {
    * const chunk1 = Chunk.make(1, 2, 3)
    * const chunk2 = Chunk.make(3, 4, 5)
    * Chunk.toArray(Chunk.union(chunk1, chunk2)) // => [1, 2, 3, 4, 5]
-   *
-   * // Handles duplicates within the same chunk
-   * const withDupes1 = Chunk.make(1, 1, 2)
-   * const withDupes2 = Chunk.make(2, 3, 3)
-   * Chunk.toArray(Chunk.union(withDupes1, withDupes2)) // => [1, 2, 3]
    * ```
    *
    * @stability stable
@@ -3975,7 +3969,12 @@ export const union: {
    */
   <A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A | B>
   /**
-   * Creates a Chunks of unique values, in order, from all given Chunks.
+   * Computes the union of two chunks using Effect equality.
+   *
+   * **Gotchas**
+   *
+   * Each input must already be deduplicated. Use {@link dedupe} to remove
+   * duplicates from an input first.
    *
    * **Example** (Unioning chunks)
    *
@@ -3985,11 +3984,6 @@ export const union: {
    * const chunk1 = Chunk.make(1, 2, 3)
    * const chunk2 = Chunk.make(3, 4, 5)
    * Chunk.toArray(Chunk.union(chunk1, chunk2)) // => [1, 2, 3, 4, 5]
-   *
-   * // Handles duplicates within the same chunk
-   * const withDupes1 = Chunk.make(1, 1, 2)
-   * const withDupes2 = Chunk.make(2, 3, 3)
-   * Chunk.toArray(Chunk.union(withDupes1, withDupes2)) // => [1, 2, 3]
    * ```
    *
    * @stability stable

package/src/Config.ts

@@ -671,50 +671,7 @@ export const orElse: {
    */
   <A, A2>(self: Config<A>, that: (error: ConfigError) => Config<A2>): Config<A | A2>
 } = dual(2, <A, A2>(self: Config<A>, that: (error: ConfigError) => Config<A2>): Config<A | A2> => {
-  return make</**
-   * Provides a fallback config when parsing fails with a `ConfigError`.
-   *
-   * **When to use**
-   *
-   * Use when you need to try an alternative config source after the primary one
-   * fails.
-   *
-   * **Details**
-   *
-   * Unlike {@link withDefault}, this handles both semantic absence and **all**
-   * `ConfigError`s. The fallback function receives the error and returns a new
-   * `Config`.
-   *
-   * **Gotchas**
-   *
-   * The fallback's result replaces the original failure. If the fallback is
-   * absent, an outer {@link withDefault} or {@link option} can recover it. If the
-   * fallback fails, only its error propagates. Defects and interruptions never
-   * reach the fallback; they propagate unchanged.
-   *
-   * **Example** (Trying another port before using a default)
-   *
-   * ```ts import.meta.vitest
-   * import { Config, ConfigProvider, Effect } from "effect"
-   *
-   * const port = Config.Int("PORT").pipe(
-   *   Config.orElse(() => Config.Int("BACKUP_PORT")),
-   *   Config.withDefault(3000)
-   * )
-   * const provider = ConfigProvider.fromUnknown({ PORT: "invalid", BACKUP_PORT: "8080" })
-   * await Effect.runPromise(port.parse(provider)) // => 8080
-   *
-   * const missingBackup = ConfigProvider.fromUnknown({ PORT: "invalid" })
-   * await Effect.runPromise(port.parse(missingBackup)) // => 3000
-   * ```
-   *
-   * @see {@link withDefault} – fallback only on semantic absence
-   *
-   * @stability stable
-   * @category combinators
-   * @since 2.0.0
-   */
-  A | A2>((provider, pathPrefix) =>
+  return make<A | A2>((provider, pathPrefix) =>
     Effect.matchCauseEffect(evaluateAt(self, provider, pathPrefix), {
       // Only plain failures reach the fallback; defects and interruptions propagate unchanged.
       onFailure: (cause) => {
@@ -728,7 +685,7 @@ export const orElse: {
           ? evaluateAt(that(resolution.failure), provider, pathPrefix)
           : Effect.succeed(resolution)
     })
-  );
+  )
 })
 
 /**
@@ -916,48 +873,12 @@ export const withDefault: {
    */
   <A, const A2>(self: Config<A>, defaultValue: A2): Config<A | A2>
 } = dual(2, <A, const A2>(self: Config<A>, defaultValue: A2): Config<A | A2> => {
-  return make</**
-   * Provides a fallback value when the config is absent.
-   *
-   * **When to use**
-   *
-   * Use when you need to make a config key optional with a sensible default.
-   *
-   * **Gotchas**
-   *
-   * Validation and source errors still propagate. For an {@link all} group, any
-   * absent child causes the default to replace the entire group unless another
-   * child fails. Apply defaults to individual children to preserve other values.
-   *
-   * A schema that successfully decodes absent input keeps its decoded value
-   * instead of using the default. Schema configs first represent a missing or
-   * incompatible provider shape as `undefined`; the default is used only when
-   * the schema rejects that value and no relevant input was found.
-   *
-   * **Example** (Defaulting a missing port)
-   *
-   * ```ts import.meta.vitest
-   * import { Config, ConfigProvider, Effect } from "effect"
-   *
-   * const port = Config.Number("port").pipe(Config.withDefault(3000))
-   *
-   * const provider = ConfigProvider.fromUnknown({})
-   * Effect.runSync(port.parse(provider)) // => 3000
-   * ```
-   *
-   * @see {@link option} – returns `Option` instead of a default value
-   * @see {@link orElse} – catches all errors, not just absent input
-   *
-   * @stability stable
-   * @category combinators
-   * @since 2.0.0
-   */
-  A | A2>((provider, pathPrefix) =>
+  return make<A | A2>((provider, pathPrefix) =>
     Effect.mapEager(
       evaluateAt(self, provider, pathPrefix),
       (resolution) => Result.isFailure(resolution) ? Result.succeed(defaultValue) : resolution
     )
-  );
+  )
 })
 
 /**
@@ -1171,7 +1092,6 @@ const toConfigCursorAST = memoize((root: SchemaAST.AST): SchemaAST.AST => {
     seen.add(ast)
     switch (ast._tag) {
       case "Objects": {
-        const matchesIndex = ast.indexSignatures.map((is) => SchemaParser._is(is.parameter))
         const materialize = Effect.fnUntraced(function*(cursor: ConfigCursor) {
           if (cursor.node?._tag !== "Record") {
             return undefined
@@ -1181,9 +1101,15 @@ const toConfigCursorAST = memoize((root: SchemaAST.AST): SchemaAST.AST => {
           for (const property of ast.propertySignatures) {
             if (typeof property.name === "string") keys.add(property.name)
           }
-          if (matchesIndex.length > 0) {
+          if (ast.indexSignatures.length > 0) {
+            const input: Record<string, undefined> = {}
             for (const key of node.keys) {
-              if (matchesIndex.some((matches) => matches(key))) keys.add(key)
+              InternalRecord.assignProperty(input, key, undefined)
+            }
+            for (const is of ast.indexSignatures) {
+              for (const key of SchemaAST.getIndexSignatureKeys(input, is.parameter)) {
+                if (typeof key === "string") keys.add(key)
+              }
             }
           }
           const out: Record<string, ConfigCursor> = {}

package/src/ConfigProvider.ts

@@ -1391,11 +1391,12 @@ function interpolate(
   parsed: Record<string, string>,
   seen: ReadonlySet<string>
 ): string {
-  const reference = /(?<!\\)\${?(\w+)/g
+  const reference = /\${?(\w+)/g
   let result = ""
   let cursor = 0
   let match: RegExpExecArray | null
   while ((match = reference.exec(envValue)) != null) {
+    if (match.index > 0 && envValue[match.index - 1] === "\\") continue
     const [, name] = match
     let end = reference.lastIndex
     let defaultValue = ""

package/src/Cron.ts

@@ -815,8 +815,8 @@ export const next = (cron: Cron, now?: DateTime.DateTime.Input): Date => {
  *
  * **Gotchas**
  *
- * The search is strict: if the supplied date/time already matches the schedule,
- * the result is the earlier occurrence.
+ * The search is strict: if the supplied date/time is exactly an occurrence of
+ * the schedule, the result is the earlier occurrence.
  *
  * @see {@link next} for finding the next scheduled occurrence
  *
@@ -866,7 +866,10 @@ const stepCron = (cron: Cron, now: DateTime.DateTime.Input | undefined, directio
     }).epochMilliseconds <= zoned.epochMilliseconds
 
   const result = dateTime.mutate(zoned, (current) => {
-    current.setUTCSeconds(current.getUTCSeconds() + tick, 0)
+    // Start from the nearest whole second strictly past the input in the search
+    // direction. Going backward, a fractional input already has one.
+    const offset = reverse && current.getUTCMilliseconds() > 0 ? 0 : tick
+    current.setUTCSeconds(current.getUTCSeconds() + offset, 0)
 
     for (let i = 0; i < 10_000; i++) {
       if (cron.seconds.size !== 0) {