effect 4.0.2 → 4.0.4

package/src/SchemaGetter.ts

@@ -2264,6 +2264,8 @@ function bracketPathToTokens(bracketPath: string): Array<string | number> {
     .map((part) => (Arr.isCanonicalArrayIndex(part) ? globalThis.Number(part) : part))
 }
 
+const MAX_ARRAY_HOLES = 20
+
 /**
  * Builds a nested tree object from a list of bracket-path entries.
  *
@@ -2287,6 +2289,10 @@ function bracketPathToTokens(bracketPath: string): Array<string | number> {
  *   - `""` → real empty key
  * - Numeric bracket segments become array indices only when they are valid
  *   JavaScript array-index strings; otherwise they remain object keys.
+ * - An indexed container becomes an array only when it has at most 20 holes
+ *   (missing indices below its highest index). Otherwise it is returned as an
+ *   object keyed by the index strings, so untrusted input such as
+ *   `a[4294967294]` cannot produce huge sparse arrays.
  * - Duplicate keys for the same path are merged into arrays.
  * - If a structural path conflicts with a previous leaf or a different container
  *   type, the later structural path replaces the conflicting value.
@@ -2319,43 +2325,31 @@ export function makeTreeRecord<A>(
   const out: any = {}
   const containers = new WeakSet<object>()
   const duplicates = new WeakSet<object>()
-
-  function getOrCreateContainer(self: any, key: PropertyKey, shouldBeArray: boolean): any {
-    const current = Object.hasOwn(self, key) ? self[key] : undefined
-    if (containers.has(current) && Array.isArray(current) === shouldBeArray) {
-      return current
-    }
-    const container = shouldBeArray ? [] : {}
-    containers.add(container)
-    InternalRecord.assignProperty(self, key, container)
-    return container
-  }
+  // Indexed containers are built as plain objects so that large indices never
+  // allocate sparse arrays, and are materialized once all entries are applied
+  const indexed = new Map<object, { readonly parent: any; readonly key: PropertyKey; length: number }>()
 
   bracketPathEntries.forEach(([key, value]) => {
     const tokens = bracketPathToTokens(key)
     let cur: any = out
-    tokens.forEach((token, i) => {
-      const isLast = i === tokens.length - 1
-
-      // We are inside an array and see "[]" (empty token) => append
-      if (Array.isArray(cur) && token === "") {
-        if (isLast) {
-          cur.push(value)
-        } else {
-          // bracket path: "foo[][bar]" => push a new element and descend into it
-          const next = tokens[i + 1]
-          const shouldBeArray = typeof next === "number" || next === ""
-          const index = cur.length
-          cur = getOrCreateContainer(cur, index, shouldBeArray)
-        }
-      } else if (isLast) {
-        // If we're setting a value at a path that already exists
-        // convert it to an array to support multiple values for the same key
-        const hasOwn = Object.hasOwn(cur, token)
-        if (hasOwn && Array.isArray(cur[token]) && (containers.has(cur[token]) || duplicates.has(cur[token]))) {
-          cur[token].push(value)
+    for (let i = 0; i < tokens.length; i++) {
+      const state = indexed.get(cur)
+      // Resolve "[]" to the next index before handling leaves or containers
+      const token = tokens[i] === "" && state !== undefined ? state.length : tokens[i]
+      if (state !== undefined && typeof token === "number") {
+        state.length = Math.max(state.length, token + 1)
+      }
+      const hasOwn = Object.hasOwn(cur, token)
+      const current = hasOwn ? cur[token] : undefined
+
+      if (i === tokens.length - 1) {
+        const currentState = indexed.get(current)
+        if (currentState !== undefined) {
+          InternalRecord.assignProperty(current, currentState.length++, value)
+        } else if (duplicates.has(current)) {
+          current.push(value)
         } else if (hasOwn) {
-          const values = [cur[token], value]
+          const values = [current, value]
           duplicates.add(values)
           InternalRecord.assignProperty(cur, token, values)
         } else {
@@ -2363,12 +2357,30 @@ export function makeTreeRecord<A>(
         }
       } else {
         const next = tokens[i + 1]
-        // if next is a number OR "" (from []), we are building an array
         const shouldBeArray = typeof next === "number" || next === ""
-        cur = getOrCreateContainer(cur, token, shouldBeArray)
+        if (containers.has(current) && indexed.has(current) === shouldBeArray) {
+          cur = current
+        } else {
+          const container = {}
+          containers.add(container)
+          if (shouldBeArray) {
+            indexed.set(container, { parent: cur, key: token, length: 0 })
+          }
+          InternalRecord.assignProperty(cur, token, container)
+          cur = container
+        }
       }
-    })
+    }
   })
+
+  // Children are created after their parents, so materializing in reverse
+  // creation order replaces every nested container before its parent is copied
+  for (const [builder, { key, length, parent }] of Array.from(indexed).reverse()) {
+    // A later conflicting path may have replaced the container in its parent
+    if (parent[key] === builder && length - Object.keys(builder).length <= MAX_ARRAY_HOLES) {
+      InternalRecord.assignProperty(parent, key, Object.assign(new Array(length), builder))
+    }
+  }
   return out
 }
 

package/src/Sink.ts

@@ -2177,13 +2177,24 @@ export const takeWhileFilterEffect = <In, Out, X, E, R>(
  * @since 4.0.0
  */
 export const takeUntil = <In>(predicate: Predicate<In>): Sink<Array<In>, In, In> =>
-  suspend(() => {
-    let done = false
-    return takeWhile((i) => {
-      if (done) return false
-      done = predicate(i)
-      return true
-    })
+  fromTransform((upstream) => {
+    const out = Arr.empty<In>()
+    return upstream.pipe(
+      Effect.flatMap((arr) => {
+        for (let i = 0; i < arr.length; i++) {
+          out.push(arr[i])
+          if (predicate(arr[i])) {
+            const leftover: NonEmptyReadonlyArray<In> | undefined = (i + 1) < arr.length
+              ? arr.slice(i + 1) as Arr.NonEmptyArray<In>
+              : undefined
+            return Cause.done([out, leftover] as const)
+          }
+        }
+        return Effect.void
+      }),
+      Effect.forever({ disableYield: true }),
+      Pull.catchDone((end) => Effect.succeed<End<Array<In>, In>>(end ?? [out]))
+    )
   })
 
 /**
@@ -2201,17 +2212,33 @@ export const takeUntil = <In>(predicate: Predicate<In>): Sink<Array<In>, In, In>
 export const takeUntilEffect = <In, E, R>(
   predicate: (input: In) => Effect.Effect<boolean, E, R>
 ): Sink<Array<In>, In, In, E, R> =>
-  suspend(() => {
-    let done = false
-    return takeWhileEffect((input) => {
-      if (done) {
-        return Effect.succeed(false)
-      }
-      return Effect.map(predicate(input), (b) => {
-        done = b
-        return true
-      })
-    })
+  fromTransform((upstream) => {
+    const out = Arr.empty<In>()
+    let leftover: NonEmptyReadonlyArray<In> | undefined = undefined
+    return upstream.pipe(
+      Effect.flatMap((arr) => {
+        let i = 0
+        return Effect.whileLoop({
+          while: () => i < arr.length,
+          body: () => {
+            const input = arr[i++]
+            return Effect.flatMap(predicate(input), (matched) => {
+              out.push(input)
+              if (!matched) {
+                return Effect.void
+              }
+              if (i < arr.length) {
+                leftover = arr.slice(i) as Arr.NonEmptyArray<In>
+              }
+              return Cause.done()
+            })
+          },
+          step: constVoid
+        })
+      }),
+      Effect.forever({ disableYield: true }),
+      Pull.catchDone(() => Effect.succeed([out, leftover] as const))
+    )
   })
 
 /**

package/src/Stdio.ts

@@ -79,6 +79,12 @@ export interface Stdio {
    * @since 4.0.0
    */
   readonly stdoutIsTerminal: Effect.Effect<boolean>
+  /**
+   * Whether standard error is attached to a terminal.
+   *
+   * @since 4.0.0
+   */
+  readonly stderrIsTerminal: Effect.Effect<boolean>
   stdout(options?: {
     readonly endOnDone?: boolean | undefined
   }): Sink.Sink<void, string | Uint8Array, never, PlatformError>
@@ -127,12 +133,13 @@ export const Stdio: Context.Service<Stdio, Stdio> = Context.Service<Stdio>(TypeI
  */
 export const make = (
   options:
-    & Omit<Stdio, TypeId | "stdinIsTerminal" | "stdoutIsTerminal">
-    & Partial<Pick<Stdio, "stdinIsTerminal" | "stdoutIsTerminal">>
+    & Omit<Stdio, TypeId | "stdinIsTerminal" | "stdoutIsTerminal" | "stderrIsTerminal">
+    & Partial<Pick<Stdio, "stdinIsTerminal" | "stdoutIsTerminal" | "stderrIsTerminal">>
 ): Stdio => ({
   [TypeId]: TypeId,
   stdinIsTerminal: Effect.succeed(false),
   stdoutIsTerminal: Effect.succeed(false),
+  stderrIsTerminal: Effect.succeed(false),
   ...options
 })
 

package/src/Stream.ts

@@ -20767,6 +20767,9 @@ export const mkUint8Array = <E, R>(self: Stream<Uint8Array, E, R>): Effect.Effec
  *
  * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
  *
+ * When `signal` aborts, the stream is interrupted even if the reader has
+ * stopped pulling, and the `ReadableStream` closes.
+ *
  * **Example** (Converting to a ReadableStream with services)
  *
  * ```ts import.meta.vitest
@@ -20774,7 +20777,7 @@ export const mkUint8Array = <E, R>(self: Stream<Uint8Array, E, R>): Effect.Effec
  *
  * const stream = Stream.make(1, 2, 3, 4, 5)
  * const readableStream = Stream.toReadableStreamWith(stream, Context.empty())
- * const values = await Array.fromAsync(readableStream)
+ * const values = await globalThis.Array.fromAsync(readableStream)
  * values // => [ 1, 2, 3, 4, 5 ]
  * ```
  *
@@ -20795,6 +20798,9 @@ export const toReadableStreamWith: {
    *
    * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
    *
+   * When `signal` aborts, the stream is interrupted even if the reader has
+   * stopped pulling, and the `ReadableStream` closes.
+   *
    * **Example** (Converting to a ReadableStream with services)
    *
    * ```ts import.meta.vitest
@@ -20802,7 +20808,7 @@ export const toReadableStreamWith: {
    *
    * const stream = Stream.make(1, 2, 3, 4, 5)
    * const readableStream = Stream.toReadableStreamWith(stream, Context.empty())
-   * const values = await Array.fromAsync(readableStream)
+   * const values = await globalThis.Array.fromAsync(readableStream)
    * values // => [ 1, 2, 3, 4, 5 ]
    * ```
    *
@@ -20812,7 +20818,10 @@ export const toReadableStreamWith: {
    */
   <A, XR>(
     context: Context.Context<XR>,
-    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+    options?: {
+      readonly strategy?: QueuingStrategy<A> | undefined
+      readonly signal?: AbortSignal | undefined
+    }
   ): <E, R extends XR>(self: Stream<A, E, R>) => ReadableStream<A>
   /**
    * Converts the stream to a `ReadableStream` using the provided services.
@@ -20826,6 +20835,9 @@ export const toReadableStreamWith: {
    *
    * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
    *
+   * When `signal` aborts, the stream is interrupted even if the reader has
+   * stopped pulling, and the `ReadableStream` closes.
+   *
    * **Example** (Converting to a ReadableStream with services)
    *
    * ```ts import.meta.vitest
@@ -20833,7 +20845,7 @@ export const toReadableStreamWith: {
    *
    * const stream = Stream.make(1, 2, 3, 4, 5)
    * const readableStream = Stream.toReadableStreamWith(stream, Context.empty())
-   * const values = await Array.fromAsync(readableStream)
+   * const values = await globalThis.Array.fromAsync(readableStream)
    * values // => [ 1, 2, 3, 4, 5 ]
    * ```
    *
@@ -20844,18 +20856,28 @@ export const toReadableStreamWith: {
   <A, E, XR, R extends XR>(
     self: Stream<A, E, R>,
     context: Context.Context<XR>,
-    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+    options?: {
+      readonly strategy?: QueuingStrategy<A> | undefined
+      readonly signal?: AbortSignal | undefined
+    }
   ): ReadableStream<A>
 } = dual(
   (args) => isStream(args[0]),
   <A, E, XR, R extends XR>(
     self: Stream<A, E, R>,
     context: Context.Context<XR>,
-    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+    options?: {
+      readonly strategy?: QueuingStrategy<A> | undefined
+      readonly signal?: AbortSignal | undefined
+    }
   ): ReadableStream<A> => {
     let currentResolve: (() => void) | undefined = undefined
     let fiber: Fiber.Fiber<void, E> | undefined = undefined
+    let cancelled = false
     const latch = Latch.makeUnsafe(false)
+    const signal = options?.signal
+    // Interrupting the fiber directly also stops a consumer waiting for a pull.
+    const onAbort = () => fiber!.interruptUnsafe()
 
     return new ReadableStream<A>({
       start(controller) {
@@ -20872,12 +20894,18 @@ export const toReadableStreamWith: {
           context
         ))
         fiber.addObserver((exit) => {
-          if (exit._tag === "Failure") {
+          signal?.removeEventListener("abort", onAbort)
+          if (cancelled) return
+          if (exit._tag === "Failure" && signal?.aborted !== true) {
             controller.error(Cause.squash(exit.cause))
           } else {
             controller.close()
           }
         })
+        if (signal !== undefined && fiber.pollUnsafe() === undefined) {
+          if (signal.aborted) onAbort()
+          else signal.addEventListener("abort", onAbort, { once: true })
+        }
       },
       pull() {
         return new Promise<void>((resolve) => {
@@ -20887,6 +20915,7 @@ export const toReadableStreamWith: {
       },
       cancel() {
         if (!fiber) return
+        cancelled = true
         return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)))
       }
     }, options?.strategy)
@@ -20906,7 +20935,7 @@ export const toReadableStreamWith: {
  * import { Stream } from "effect"
  *
  * const readableStream = Stream.toReadableStream(Stream.make(1, 2, 3))
- * const values = await Array.fromAsync(readableStream)
+ * const values = await globalThis.Array.fromAsync(readableStream)
  * values // => [ 1, 2, 3 ]
  * ```
  *
@@ -20928,7 +20957,7 @@ export const toReadableStream: {
    * import { Stream } from "effect"
    *
    * const readableStream = Stream.toReadableStream(Stream.make(1, 2, 3))
-   * const values = await Array.fromAsync(readableStream)
+   * const values = await globalThis.Array.fromAsync(readableStream)
    * values // => [ 1, 2, 3 ]
    * ```
    *
@@ -20952,7 +20981,7 @@ export const toReadableStream: {
    * import { Stream } from "effect"
    *
    * const readableStream = Stream.toReadableStream(Stream.make(1, 2, 3))
-   * const values = await Array.fromAsync(readableStream)
+   * const values = await globalThis.Array.fromAsync(readableStream)
    * values // => [ 1, 2, 3 ]
    * ```
    *
@@ -21132,7 +21161,7 @@ export const toReadableStreamEffect: {
  * const stream = Stream.make(1, 2, 3)
  * const iterable = Stream.toAsyncIterableWith(stream, Context.empty())
  *
- * await Array.fromAsync(iterable) // => [1, 2, 3]
+ * await globalThis.Array.fromAsync(iterable) // => [1, 2, 3]
  * ```
  *
  * @stability stable
@@ -21156,7 +21185,7 @@ export const toAsyncIterableWith: {
    * const stream = Stream.make(1, 2, 3)
    * const iterable = Stream.toAsyncIterableWith(stream, Context.empty())
    *
-   * await Array.fromAsync(iterable) // => [1, 2, 3]
+   * await globalThis.Array.fromAsync(iterable) // => [1, 2, 3]
    * ```
    *
    * @stability stable
@@ -21180,7 +21209,7 @@ export const toAsyncIterableWith: {
    * const stream = Stream.make(1, 2, 3)
    * const iterable = Stream.toAsyncIterableWith(stream, Context.empty())
    *
-   * await Array.fromAsync(iterable) // => [1, 2, 3]
+   * await globalThis.Array.fromAsync(iterable) // => [1, 2, 3]
    * ```
    *
    * @stability stable
@@ -21282,7 +21311,7 @@ export const toAsyncIterableWith: {
  *
  * const program = Effect.gen(function*() {
  *   const iterable = yield* Stream.toAsyncIterableEffect(stream)
- *   return yield* Effect.promise(() => Array.fromAsync(iterable))
+ *   return yield* Effect.promise(() => globalThis.Array.fromAsync(iterable))
  * })
  *
  * await Effect.runPromise(program) // => [1, 2, 3]
@@ -21308,7 +21337,7 @@ export const toAsyncIterableEffect = <A, E, R>(self: Stream<A, E, R>): Effect.Ef
  *
  * const stream = Stream.make(1, 2, 3)
  *
- * await Array.fromAsync(Stream.toAsyncIterable(stream)) // => [1, 2, 3]
+ * await globalThis.Array.fromAsync(Stream.toAsyncIterable(stream)) // => [1, 2, 3]
  * ```
  *
  * @stability stable

package/src/Utils.ts

@@ -12,7 +12,7 @@
  * @since 2.0.0
  */
 import type { Kind, TypeLambda } from "./HKT.ts"
-import { getStackTraceLimit } from "./internal/stackTraceLimit.ts"
+import { getStackTraceLimit, setStackTraceLimit } from "./internal/stackTraceLimit.ts"
 import type * as Types from "./Types.ts"
 
 /**
@@ -209,10 +209,13 @@ const pickInternalCall = (): <A>(body: () => A) => A => {
     }
   }
 
-  const isNotOptimizedAway = getStackTraceLimit() !== 0 &&
-    standard[InternalTypeId](() => new Error().stack)?.includes(InternalTypeId) === true
-
-  return isNotOptimizedAway ? standard[InternalTypeId] : forced[InternalTypeId]
+  const limit = getStackTraceLimit()
+  if (limit === 0) return forced[InternalTypeId]
+  // Only the callback and internal call frames are needed for detection.
+  setStackTraceLimit(2)
+  const error = standard[InternalTypeId](() => new Error())
+  setStackTraceLimit(limit)
+  return error.stack?.includes(InternalTypeId) === true ? standard[InternalTypeId] : forced[InternalTypeId]
 }
 
 /** @internal */

package/src/ai/AnthropicStructuredOutput.ts

@@ -14,8 +14,8 @@ import type * as JsonSchema from "../JsonSchema.ts"
 import * as Rec from "../Record.ts"
 import * as Schema from "../Schema.ts"
 import * as InternalStructuredOutput from "./internal/structured-output.ts"
-import * as LanguageModel from "./LanguageModel.ts"
-import * as OpenAiStructuredOutput from "./OpenAiStructuredOutput.ts"
+import type * as LanguageModel from "./LanguageModel.ts"
+import type * as OpenAiStructuredOutput from "./OpenAiStructuredOutput.ts"
 
 /**
  * Converts a `Schema.Codec` to Anthropic structured-output JSON Schema and a

package/src/ai/Chat.ts

@@ -228,7 +228,7 @@ export interface Chat {
     <Options extends NoExcessProperties<LanguageModel.GenerateTextOptions<{}>, Options>>(
       options: Options & { readonly toolkit?: undefined } & LanguageModel.GenerateTextOptions<{}>
     ): Effect.Effect<
-      LanguageModel.GenerateTextResponse<{}>,
+      LanguageModel.GenerateTextResponse<{}, LanguageModel.ExtractToolParametersModeWithoutToolkit<Options>>,
       LanguageModel.ExtractError<Options>,
       LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
     >
@@ -310,7 +310,7 @@ export interface Chat {
     <Options extends NoExcessProperties<LanguageModel.GenerateTextOptions<{}>, Options>>(
       options: Options & { readonly toolkit?: undefined } & LanguageModel.GenerateTextOptions<{}>
     ): Stream.Stream<
-      Response.StreamPart<{}>,
+      Response.StreamPart<{}, LanguageModel.ExtractToolParametersModeWithoutToolkit<Options>>,
       LanguageModel.ExtractError<Options>,
       LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
     >