effect 4.0.3 → 4.0.5

package/src/Match.ts

@@ -712,6 +712,26 @@ export const withReturnType: <Ret>() => <I, F, R, A, Pr, _, Args extends Array<a
 ) => [Ret] extends [[A] extends [never] ? any : A] ? Matcher<I, F, R, A, Pr, Ret, Args>
   : "withReturnType constraint does not extend Result type" = internal.withReturnType
 
+// `P` is a const type parameter, so object literals skip excess-property checks.
+// Reject pattern keys that no object variant of the input has. Functions,
+// refinements, and array patterns are not checked.
+type PatternKey<K> = K extends number ? `${K}` : K
+
+type PatternKeys<A> = object extends A ? PropertyKey
+  : A extends object ? PatternKey<keyof A>
+  : never
+
+type ObjectPatternGuard<A, P> = [P] extends [Function | ReadonlyArray<any> | SafeRefinement<never, any>] ? unknown
+  : [P] extends [object] ? { readonly [K in Exclude<PatternKey<keyof P>, PatternKeys<A>>]: never }
+  : unknown
+
+type ExactPattern<R, P> = (Types.PatternPrimitive<R> | Types.PatternBase<R>) & ObjectPatternGuard<R, P>
+
+type ExactPatterns<R, P> = {
+  readonly [I in keyof P]: I extends number | `${number}` ? P[I] & ExactPattern<R, P[I]>
+    : P[I]
+}
+
 /**
  * Defines a condition for matching values.
  *
@@ -763,7 +783,7 @@ export const withReturnType: <Ret>() => <I, F, R, A, Pr, _, Args extends Array<a
  */
 export const when: <
   R,
-  const P extends Types.PatternPrimitive<R> | Types.PatternBase<R>,
+  const P extends ExactPattern<R, P>,
   Ret,
   Args extends Array<any>,
   Fn extends (_: Types.WhenMatch<R, P>, ...args: Args) => Ret
@@ -831,7 +851,7 @@ export const whenOr: <
   Args extends Array<any>,
   Fn extends (_: Types.WhenMatch<R, P[number]>, ...args: Args) => Ret
 >(
-  ...args: [...patterns: P, f: Fn]
+  ...args: [...patterns: ExactPatterns<R, P>, f: Fn]
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret, Args>
 ) => Matcher<
@@ -842,7 +862,13 @@ export const whenOr: <
   Pr,
   Ret,
   Args
-> = internal.whenOr
+> = <
+  R,
+  const P extends ReadonlyArray<Types.PatternPrimitive<R> | Types.PatternBase<R>>,
+  Ret,
+  Args extends Array<any>,
+  Fn extends (_: Types.WhenMatch<R, P[number]>, ...args: Args) => Ret
+>(...args: [...patterns: ExactPatterns<R, P>, f: Fn]) => internal.whenOr<R, P, Ret, Args, Fn>(...args)
 
 /**
  * Matches a value that satisfies all provided patterns.
@@ -890,7 +916,7 @@ export const whenAnd: <
   Args extends Array<any>,
   Fn extends (_: Types.WhenMatch<R, T.UnionToIntersection<P[number]>>, ...args: Args) => Ret
 >(
-  ...args: [...patterns: P, f: Fn]
+  ...args: [...patterns: ExactPatterns<R, P>, f: Fn]
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret, Args>
 ) => Matcher<
@@ -901,7 +927,13 @@ export const whenAnd: <
   Pr,
   Ret,
   Args
-> = internal.whenAnd
+> = <
+  R,
+  const P extends ReadonlyArray<Types.PatternPrimitive<R> | Types.PatternBase<R>>,
+  Ret,
+  Args extends Array<any>,
+  Fn extends (_: Types.WhenMatch<R, T.UnionToIntersection<P[number]>>, ...args: Args) => Ret
+>(...args: [...patterns: ExactPatterns<R, P>, f: Fn]) => internal.whenAnd<R, P, Ret, Args, Fn>(...args)
 
 /**
  * Matches values based on a specified discriminant field.
@@ -1398,7 +1430,7 @@ export const tagsExhaustive: <
  */
 export const not: <
   R,
-  const P extends Types.PatternPrimitive<R> | Types.PatternBase<R>,
+  const P extends ExactPattern<R, P>,
   Ret,
   Args extends Array<any>,
   Fn extends (_: Types.NotMatch<R, P>, ...args: Args) => Ret
@@ -2835,6 +2867,32 @@ export declare namespace Types {
 
   type Simplify<A> = { [K in keyof A]: A[K] } & {}
 
+  // Tuple patterns match a prefix at runtime. For inputs with a variadic part,
+  // narrow each position the pattern requires and keep the rest of the input.
+  type NarrowArrayPattern<I extends ReadonlyArray<any>, P extends ReadonlyArray<any>> = number extends I["length"]
+    ? number extends P["length"] ? MapArrayPattern<I, P>
+    : P["length"] extends Required<P>["length"] ? NarrowArrayPrefix<I, P>
+    : MapArrayPattern<I, P>
+    : MapArrayPattern<I, P>
+
+  type MapArrayPattern<I, P> = {
+    readonly [K in keyof I]: K extends keyof P ? ExtractAndNarrow<I[K], P[K]> : I[K]
+  } extends infer R ? Fail extends R[keyof R] ? never
+    : R
+    : never
+
+  type NarrowArrayPrefix<
+    I extends ReadonlyArray<any>,
+    P extends ReadonlyArray<any>,
+    Out extends ReadonlyArray<any> = readonly []
+  > = P extends readonly [infer PH, ...infer PT] ?
+    I extends readonly [infer IH, ...infer IT] ?
+      [ExtractAndNarrow<IH, PH>] extends [infer N] ? [N] extends [never] ? never
+        : NarrowArrayPrefix<IT, PT, readonly [...Out, N]>
+      : never
+    : NarrowArrayPrefix<readonly [I[number], ...Array<I[number]>], P, Out>
+    : readonly [...Out, ...I]
+
   type ExtractAndNarrow<Input, P> = P extends Predicate.Refinement<infer _In, infer _Out> ?
     _Out extends Input ? Extract<_Out, Input>
     : Extract<Input, _Out> :
@@ -2843,12 +2901,7 @@ export declare namespace Types {
       : Extract<Input, _In>
     : P extends Predicate.Predicate<infer _In> ? Extract<Input, _In>
     : Input extends infer I ? Exclude<
-        I extends ReadonlyArray<any> ? P extends ReadonlyArray<any> ? {
-              readonly [K in keyof I]: K extends keyof P ? ExtractAndNarrow<I[K], P[K]>
-                : I[K]
-            } extends infer R ? Fail extends R[keyof R] ? never
-              : R
-            : never
+        I extends ReadonlyArray<any> ? P extends ReadonlyArray<any> ? NarrowArrayPattern<I, P>
           : never
           : IsPlainObject<I> extends true ? string extends keyof I ? I extends P ? I
               : never

package/src/Path.ts

@@ -14,6 +14,7 @@ import * as Context from "./Context.ts"
 import * as Effect from "./Effect.ts"
 import { identity } from "./Function.ts"
 import * as Layer from "./Layer.ts"
+import * as Option from "./Option.ts"
 import { BadArgument } from "./PlatformError.ts"
 
 /**
@@ -47,10 +48,17 @@ export const TypeId = "~effect/Path"
  * formatting, and converting file system paths. URL conversion methods return
  * `Effect`s because invalid file URLs or paths can fail with `BadArgument`.
  *
+ * `resolveWithin(root, input)` resolves a relative `input` beneath `root` and
+ * returns `Option.none()` when the result would leave the root or when `input`
+ * has its own root (an absolute path, or a Windows drive or UNC prefix). The
+ * root itself is allowed. The check is lexical: it does not follow symlinks,
+ * so it is not a sandbox on its own. A relative `root` is resolved against the
+ * current working directory, as with `resolve`.
+ *
  * **Example** (Using path operations)
  *
  * ```ts import.meta.vitest
- * import { Effect, Path } from "effect"
+ * import { Effect, Option, Path } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const path = yield* Path.Path
@@ -64,7 +72,8 @@ export const TypeId = "~effect/Path"
  *     isAbsolute: path.isAbsolute("/absolute/path"),
  *     name: path.parse("/path/to/file.txt").name,
  *     relative: path.relative("/from/path", "/to/path"),
- *     resolved: path.resolve("/base", "relative", "path")
+ *     resolved: path.resolve("/base", "relative", "path"),
+ *     within: path.resolveWithin("/base", "../outside")
  *   }
  * })
  *
@@ -78,6 +87,7 @@ export const TypeId = "~effect/Path"
  * result.name // => "file"
  * result.relative // => "../../to/path"
  * result.resolved // => "/base/relative/path"
+ * result.within // => Option.none()
  * ```
  *
  * @stability unstable
@@ -98,6 +108,7 @@ export interface Path {
   readonly parse: (path: string) => Path.Parsed
   readonly relative: (from: string, to: string) => string
   readonly resolve: (...pathSegments: ReadonlyArray<string>) => string
+  readonly resolveWithin: (root: string, input: string) => Option.Option<string>
   readonly toFileUrl: (path: string) => Effect.Effect<URL, BadArgument>
   readonly toNamespacedPath: (path: string) => string
 }
@@ -204,8 +215,7 @@ export declare namespace Path {
  * import { Effect, Layer, Path } from "effect"
  *
  * // Create a custom path implementation
- * const customPath: Path.Path = {
- *   [Path.TypeId]: Path.TypeId,
+ * const customPath = Path.make({
  *   sep: "/",
  *   basename: (path: string, suffix?: string) => {
  *     const base = path.split("/").pop() || ""
@@ -239,7 +249,7 @@ export declare namespace Path {
  *   resolve: (...pathSegments: ReadonlyArray<string>) => pathSegments.join("/"),
  *   toFileUrl: (path: string) => Effect.succeed(new URL(`file://${path}`)),
  *   toNamespacedPath: (path: string) => path
- * }
+ * })
  *
  * // Provide the path service
  * const customPathLayer = Layer.succeed(Path.Path)(customPath)
@@ -259,6 +269,42 @@ export declare namespace Path {
  */
 export const Path: Context.Service<Path, Path> = Context.Service("effect/Path")
 
+/**
+ * Creates a `Path` service from platform path operations.
+ *
+ * **When to use**
+ *
+ * Use to build a `Path` implementation, such as a platform layer or a test
+ * double, without implementing the operations that can be derived from the
+ * others.
+ *
+ * **Details**
+ *
+ * Adds the `Path` type marker and derives `resolveWithin` from the provided
+ * `parse`, `resolve`, `relative`, `isAbsolute`, and `sep`, so containment
+ * follows the same platform rules as those operations.
+ *
+ * @see {@link layer} for the built-in POSIX `Path` service layer
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 4.0.0
+ */
+export const make = (impl: Omit<Path, typeof TypeId | "resolveWithin">): Path =>
+  Path.of({
+    ...impl,
+    [TypeId]: TypeId,
+    resolveWithin(root, input) {
+      if (impl.parse(input).root !== "") return Option.none()
+      const base = impl.resolve(root)
+      const candidate = impl.resolve(base, input)
+      const relative = impl.relative(base, candidate)
+      return relative === ".." || relative.startsWith(`..${impl.sep}`) || impl.isAbsolute(relative)
+        ? Option.none()
+        : Option.some(candidate)
+    }
+  })
+
 /**
  * The following functions are adapted from the Node.js source code:
  * https://github.com/nodejs/node/blob/main/lib/internal/url.js
@@ -479,8 +525,7 @@ function encodePathChars(filepath: string) {
   return filepath
 }
 
-const posixImpl = Path.of({
-  [TypeId]: TypeId,
+const posixImpl = make({
   resolve,
   normalize(path) {
     if (path.length === 0) return "."

package/src/RequestResolver.ts

@@ -311,16 +311,10 @@ export const makeGrouped = <A extends Request.Any, K>(options: {
   })
 
 const hashGroupKey = <A, K>(get: (entry: Request.Entry<A>) => K) => {
-  const groupKeys = MutableHashMap.empty<K, K>()
-  return (entry: Request.Entry<A>): unknown => {
-    const key = get(entry)
-    const okey = MutableHashMap.get(groupKeys, key)
-    if (okey._tag === "Some") {
-      return okey.value
-    }
-    MutableHashMap.set(groupKeys, key, key)
-    return key
-  }
+  // Pending batches match equal keys, so they share one batch.
+  const batchKey = (entry: Request.Entry<A>): unknown => get(entry)
+  internal.equalBatchKeys.add(batchKey)
+  return batchKey
 }
 
 /**

package/src/Scheduler.ts

@@ -160,6 +160,15 @@ class PriorityBuckets {
  * operation counts to decide when fibers should yield, and is the default
  * scheduler implementation.
  *
+ * **Gotchas**
+ *
+ * On Cloudflare Workers, request-owned scheduler timers can be discarded,
+ * leaving shared fibers suspended. Use `new MixedScheduler("sync")` for the
+ * whole application; see `HttpRouter.toWebHandler` for a recipe.
+ * Sync mode does not yield to the event loop: CPU-heavy work delays other
+ * requests, and I/O-polling loops can exhaust the CPU limit. It does not fix
+ * request-owned timers (such as `Effect.sleep`) or request-bound async contexts.
+ *
  * @stability stable
  * @category models
  * @since 2.0.0

package/src/Schema.ts

@@ -36,6 +36,7 @@ import * as HashMap_ from "./HashMap.ts"
 import * as HashSet_ from "./HashSet.ts"
 import * as Cookies_ from "./http/Cookies.ts"
 import * as Headers_ from "./http/Headers.ts"
+import * as UrlParams_internal from "./http/internal/urlParams.ts"
 import * as UrlParams_ from "./http/UrlParams.ts"
 import { NodeInspectSymbol } from "./Inspectable.ts"
 import * as core from "./internal/core.ts"
@@ -4029,6 +4030,7 @@ export declare namespace StructWithRest {
    */
   type Objects = Constraint & {
     readonly ast: SchemaAST.Objects
+    readonly Encoded: object
   }
   /**
    * Readonly list of record schemas that provide the additional index signatures
@@ -4198,6 +4200,13 @@ export interface StructWithRest<
  *
  * **Gotchas**
  *
+ * The base schema must have an object-shaped encoded type. Whole-object
+ * transformations are not supported, even with an empty rest array. Apply
+ * transformations such as `Schema.fromJsonString` to the completed
+ * `StructWithRest` schema instead. Object-shaped encoded types alone do not
+ * guarantee compatibility: unsupported encodings are still rejected at runtime.
+ * Transformations on individual fields remain supported.
+ *
  * TypeScript index signatures also apply to fixed keys. `StructWithRest` does
  * not reject incompatible fixed fields at the call site; use
  * `StructWithRest.ValidateRecords` when you want an explicit type-level
@@ -5958,6 +5967,9 @@ export type DecodingDefaultOptions = {
 function toIssueEffect<A, R>(
   self: Effect.Effect<A, SchemaError, R>
 ): Effect.Effect<A, SchemaIssue.Issue, R> {
+  if (effectIsExit(self) && self._tag === "Success") {
+    return self as unknown as Exit_.Exit<A, SchemaIssue.Issue>
+  }
   return Effect.catchCause(self, (cause) => Effect.failCauseSync(() => Cause_.map(cause, (error) => error.issue)))
 }
 /**
@@ -6304,6 +6316,12 @@ type Flatten<Schemas> = Schemas extends readonly [infer Head, ...infer Tail]
   ? Head extends Union<infer Inner> ? [...Flatten<Inner>, ...Flatten<Tail>]
   : [Head, ...Flatten<Tail>]
   : []
+type DiscriminantKey<T extends PropertyKey> = T extends number ? `${T}` : T
+type EnsureUniqueDiscriminants<Tags extends ReadonlyArray<PropertyKey>, Seen = never> = Tags extends
+  readonly [infer Head extends PropertyKey, ...infer Tail extends ReadonlyArray<PropertyKey>]
+  ? [DiscriminantKey<Head> & Seen] extends [never] ? EnsureUniqueDiscriminants<Tail, Seen | DiscriminantKey<Head>>
+  : never
+  : unknown
 type MatchCasesResult<Cases> = {
   [K in keyof Cases]-?: NonNullable<Cases[K]> extends (...args: Array<any>) => infer R ? R : never
 }[keyof Cases]
@@ -6388,7 +6406,10 @@ export type toTaggedUnion<
  *
  * **Gotchas**
  *
- * Throws if multiple members use the same discriminant property key.
+ * Rejects overlapping discriminant types in known member tuples at compile
+ * time, including nested unions. Numeric and string values such as `1` and
+ * `"1"` count as duplicates. Also throws at runtime if multiple members use the
+ * same discriminant property key.
  *
  * **Example** (Adding tagged-union utilities to an existing union)
  *
@@ -6415,7 +6436,7 @@ export type toTaggedUnion<
  */
 export function toTaggedUnion<const Tag extends PropertyKey>(tag: Tag) {
   return <const Members extends ReadonlyArray<Constraint & { readonly Type: { readonly [K in Tag]: PropertyKey } }>>(
-    self: Union<Members>
+    self: Union<Members> & NoInfer<EnsureUniqueDiscriminants<TaggedUnionUtils<Tag, Members>["discriminants"]>>
   ): toTaggedUnion<Tag, Members> => {
     const cases: Record<PropertyKey, unknown> = {}
     const discriminants: Array<PropertyKey> = []
@@ -15213,9 +15234,9 @@ export const UrlParams: UrlParams = declare(
     toCodec: () =>
       link<UrlParams_.UrlParams>()(
         ArraySchema(Tuple([String, String])),
-        SchemaTransformation.transform({
+        SchemaTransformation.transform<UrlParams_.UrlParams, ReadonlyArray<readonly [string, string]>>({
           decode: UrlParams_.make,
-          encode: (self) => self.params
+          encode: (self) => self.params.map(([key, value]) => [key, UrlParams_internal.unwrap(value)])
         })
       )
   }

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))
+    )
   })
 
 /**