@akterjs/cli 0.0.0-stage → 0.1.1

package/dist/Stream-bK9QIETN.mjs

@@ -0,0 +1,4012 @@
+import { $ as isFailure, F as of, b as isArray, ct as normalizeNonEmpty, j as map$2, o as empty$2, q as headUnsafe, st as normalize, tt as isSuccess, w as isReadonlyArrayNonEmpty, x as isArrayNonEmpty } from "./Array-B4kuTQeW.mjs";
+import { $t as suspend$2, A as ensuring$2, Ai as getCurrentFiber, At as provideContext$2, B as flatMap$2, Br as done, Bt as runPromise, C as catch_, Ci as fiberInterruptAll, Ct as onExitPrimitive, D as delay, Di as findRecoverableError, Dr as isFailure$1, Ei as fiberRunIn, Fn as catchDone, H as flatten$1, In as doneExitFromCause, J as forkChild, Kt as scopedWith, Ln as filterDone, M as fail$2, Mr as void_$1, N as failCause$1, Ni as makeLatch, Nr as Done, Nt as raceFirst, O as die$3, Or as isSuccess$1, Ot as promise, Pi as makeLatchUnsafe, Qn as close, Rn as isDoneCause, Rt as runFork, Si as fiberInterrupt, Sn as yieldNow, Sr as failCause$2, St as onExit$1, T as context, Ti as fiberJoin, Tr as interrupt$1, V as flatMapEager, W as fnUntraced, Wr as fromReasons, Xn as addFinalizer, Xt as succeed$2, Y as forkIn, Yr as isCause, Zn as addFinalizerExit, Zr as isDone, bt as never, ci as squash, cn as tryPromise, d as asVoid, dt as map$3, en as sync, et as gen, gn as void_, ht as mapError$2, ir as provide, j as exit, jn as toStepWithMetadata, jt as provideService$2, l as as, m as catchCause, nt as ignoreCause, o as andThen, q as forever, rn as tapError$2, rr as makeUnsafe$1, tn as tap$1, tr as forkUnsafe, vn as whileLoop, vt as matchCauseEffect, wi as fiberInterruptAs, wn as CurrentMetadata, xi as fiberAwait, xr as fail$3, xt as onError, yr as asVoidAll, zn as matchEffect, zr as die$2, zt as runForkWith } from "./Effect-CKFpqbmw.mjs";
+import { On as pipeArguments, S as none, Sn as identity, bn as dual, gn as constTrue, h as isNone, qt as hasProperty, vn as constVoid, w as some, yn as constant } from "./Option-DkxSnBhp.mjs";
+import { t as make$2 } from "./MutableRef-D4Qv592C.mjs";
+import { _ as takeAll, c as make$3, g as take$1, l as offer, o as failCause$3, p as shutdown, s as failCauseUnsafe, t as bounded, u as offerAll } from "./Queue-CO5UQ6os.mjs";
+import { n as makeUnsafe$2 } from "./Semaphore-DOVJ4ZGS.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Fiber.js
+const await_ = fiberAwait;
+/**
+* Joins a fiber, blocking until it completes. If the fiber succeeds,
+* returns its value. If it fails, the error is propagated.
+*
+* **When to use**
+*
+* Use when you need a forked fiber's failure to fail the current Effect because
+* that fiber is part of the current workflow.
+*
+* **Gotchas**
+*
+* Joining a failed fiber propagates the fiber's Cause. Use {@link await_ await} when
+* you need to inspect the `Exit` instead of failing.
+*
+* **Example** (Joining a fiber)
+*
+* ```ts import.meta.vitest
+* import { Effect, Fiber } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const fiber = yield* Effect.forkChild(Effect.succeed(42))
+*   return yield* Fiber.join(fiber)
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => 42
+* ```
+*
+* @see {@link await_ await} for inspecting the fiber outcome as an Exit
+*
+* @stability stable
+* @category combinators
+* @since 2.0.0
+*/
+const join = fiberJoin;
+/**
+* Interrupts a fiber, causing it to stop executing and clean up any
+* acquired resources.
+*
+* **When to use**
+*
+* Use when you need to cancel a forked fiber and wait for its cleanup to
+* complete.
+*
+* **Details**
+*
+* The returned Effect completes only after the interrupted fiber has completed.
+*
+* **Gotchas**
+*
+* Interruption is cooperative. A fiber can continue running while it is inside
+* uninterruptible work or finalizers.
+*
+* **Example** (Interrupting a fiber)
+*
+* ```ts import.meta.vitest
+* import { Effect, Fiber } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const fiber = yield* Effect.forkChild(
+*     Effect.delay("1 second")(Effect.succeed(42))
+*   )
+*   yield* Fiber.interrupt(fiber)
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @see {@link interruptAs} for specifying the interrupting fiber ID
+* @see {@link await_ await} for observing the interrupted fiber's Exit
+*
+* @stability stable
+* @category interruption
+* @since 2.0.0
+*/
+const interrupt = fiberInterrupt;
+/**
+* Interrupts a fiber with a specific fiber ID as the interruptor. This allows
+* tracking which fiber initiated the interruption.
+*
+* **When to use**
+*
+* Use when runtime diagnostics or tracing should attribute the interruption to
+* a specific fiber ID.
+*
+* **Details**
+*
+* The returned Effect completes only after the interrupted fiber has completed.
+*
+* **Gotchas**
+*
+* The supplied ID affects the recorded interruptor. It does not make
+* interruption synchronous or force uninterruptible regions to stop early.
+*
+* **Example** (Interrupting a fiber as another fiber)
+*
+* ```ts import.meta.vitest
+* import { Effect, Fiber } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const targetFiber = yield* Effect.forkChild(
+*     Effect.delay("5 seconds")(Effect.succeed("task completed"))
+*   )
+*
+*   // Interrupt the fiber, specifying fiber ID 123 as the interruptor
+*   yield* Fiber.interruptAs(targetFiber, 123)
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @see {@link interrupt} for using the current fiber as the interruptor
+*
+* @stability stable
+* @category interruption
+* @since 2.0.0
+*/
+const interruptAs = fiberInterruptAs;
+/**
+* Interrupts all fibers in the provided iterable, causing them to stop executing
+* and clean up any acquired resources.
+*
+* **When to use**
+*
+* Use when you need to cancel several forked fibers and wait for their cleanup
+* to complete.
+*
+* **Details**
+*
+* The current fiber is recorded as the interruptor. The returned Effect
+* completes only after all interrupted fibers have completed.
+*
+* **Gotchas**
+*
+* Interruption is cooperative for each fiber. The returned Effect can wait for
+* uninterruptible work and finalizers in any interrupted fiber.
+*
+* **Example** (Interrupting multiple fibers)
+*
+* ```ts import.meta.vitest
+* import { Effect, Fiber } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const fiber1 = yield* Effect.forkChild(Effect.never)
+*   const fiber2 = yield* Effect.forkChild(Effect.never)
+*   const fiber3 = yield* Effect.forkChild(Effect.never)
+*   yield* Fiber.interruptAll([fiber1, fiber2, fiber3])
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @see {@link interruptAllAs} for specifying the interrupting fiber ID
+*
+* @stability stable
+* @category interruption
+* @since 2.0.0
+*/
+const interruptAll = fiberInterruptAll;
+/**
+* Returns the current fiber if called from within a fiber context,
+* otherwise returns `undefined`.
+*
+* **When to use**
+*
+* Use when you need low-level runtime integrations that need access to the currently
+* executing fiber.
+*
+* **Gotchas**
+*
+* This is a synchronous accessor, not an Effect. It returns `undefined` outside
+* an active fiber runtime context.
+*
+* **Example** (Getting the current fiber)
+*
+* ```ts import.meta.vitest
+* import { Effect, Fiber } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const current = Fiber.getCurrent()
+*   return current !== undefined
+* })
+*
+* const actual = await Effect.runPromise(program)
+* actual // => true
+* ```
+*
+* @stability stable
+* @category getters
+* @since 4.0.0
+*/
+const getCurrent = getCurrentFiber;
+/**
+* Adds a fiber to a `Scope` and returns the same fiber.
+*
+* **When to use**
+*
+* Use when a manually managed fiber should be interrupted when a Scope closes.
+*
+* **Details**
+*
+* When the scope is closed, the fiber is interrupted. If the scope is already
+* closed, the fiber is interrupted immediately.
+*
+* **Gotchas**
+*
+* This does not wait for the fiber to complete. It only registers the
+* interruption finalizer and returns the same fiber.
+*
+* @see {@link interrupt} for interrupting and waiting for completion
+*
+* @stability stable
+* @category resource management
+* @since 4.0.0
+*/
+const runIn = fiberRunIn;
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Latch.js
+/**
+* Creates a `Latch` synchronously, outside of `Effect`.
+*
+* **When to use**
+*
+* Use when you need to allocate a `Latch` synchronously outside an Effect
+* workflow.
+*
+* **Details**
+*
+* The latch starts closed by default; pass `true` to create it open.
+*
+* **Example** (Creating a latch unsafely)
+*
+* ```ts import.meta.vitest
+* import { Effect, Fiber, Latch } from "effect"
+*
+* const latch = Latch.makeUnsafe(false)
+* const waiter = latch.await.pipe(Effect.as("opened"))
+*
+* const program = Effect.gen(function*() {
+*   const fiber = yield* Effect.forkChild(waiter)
+*   yield* latch.open
+*   return yield* Fiber.join(fiber)
+* })
+*
+* await Effect.runPromise(program) // => "opened"
+* ```
+*
+* @see {@link make} for creating a latch inside Effect code
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const makeUnsafe = makeLatchUnsafe;
+/**
+* Creates a `Latch` inside `Effect`.
+*
+* **When to use**
+*
+* Use to create a latch for coordinating fibers inside Effect code.
+*
+* **Details**
+*
+* The latch starts closed by default; pass `true` to create it open.
+*
+* **Example** (Creating a latch)
+*
+* ```ts import.meta.vitest
+* import { Effect, Fiber, Latch } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const latch = yield* Latch.make(false)
+*   const waiter = latch.await.pipe(Effect.as("opened"))
+*
+*   const fiber = yield* Effect.forkChild(waiter)
+*   yield* latch.open
+*   return yield* Fiber.join(fiber)
+* })
+*
+* await Effect.runPromise(program) // => "opened"
+* ```
+*
+* @see {@link makeUnsafe} for synchronous allocation outside Effect code
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const make$1 = makeLatch;
+/**
+* Opens the latch and releases fibers waiting on it.
+*
+* **When to use**
+*
+* Use to open a latch and release all fibers that are waiting on it.
+*
+* **Details**
+*
+* The returned effect succeeds with `true` when this call changed the latch
+* from closed to open, or `false` if it was already open.
+*
+* @see {@link openUnsafe} for a synchronous variant
+* @see {@link release} to release waiting fibers without opening the latch
+*
+* @stability stable
+* @category combinators
+* @since 4.0.0
+*/
+const open = (self) => self.open;
+/**
+* Checks whether the latch is currently open or closed.
+*
+* **When to use**
+*
+* Use to check the state of the latch without suspending or changing its state.
+*
+* @stability stable
+* @category predicates
+* @since 4.0.0
+*/
+const isOpen = (self) => self.isOpen();
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Channel.js
+/**
+* Provides low-level building blocks for streaming data through Effect.
+*
+* A `Channel` can read input elements, write output elements, fail with a typed
+* error, and finish with a typed result while managing resources safely.
+* Streams and sinks are built on channels, so most application code uses those
+* higher-level modules instead. This module is useful when implementing stream
+* operators or specialized streaming workflows.
+*
+* @stability stable
+* @since 2.0.0
+*/
+/**
+* Runtime identifier stored on `Channel` values and used by `isChannel` to
+* recognize them.
+*
+* @stability stable
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId$2 = "~effect/Channel";
+/**
+* Checks whether a value is a `Channel`.
+*
+* **Example** (Checking for channels)
+*
+* ```ts import.meta.vitest
+* import { Channel } from "effect"
+*
+* const channel = Channel.succeed(42)
+* Channel.isChannel(channel) // => true
+* Channel.isChannel("not a channel") // => false
+* ```
+*
+* @stability stable
+* @category guards
+* @since 3.5.4
+*/
+const isChannel = (u) => hasProperty(u, TypeId$2);
+const ChannelProto = {
+	[TypeId$2]: {
+		_Env: identity,
+		_InErr: identity,
+		_InElem: identity,
+		_OutErr: identity,
+		_OutElem: identity
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+/**
+* Creates a `Channel` from a transformation function that operates on upstream pulls.
+*
+* **Example** (Creating channels from transforms)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* const channel = Channel.fromTransform((upstream, scope) =>
+*   Effect.succeed(upstream)
+* )
+* await Effect.runPromise(Channel.runCollect(channel)) // => []
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromTransform = (transform) => {
+	const self = Object.create(ChannelProto);
+	self.transform = (upstream, scope) => catchCause(transform(upstream, scope), (cause) => succeed$2(failCause$1(cause)));
+	return self;
+};
+/**
+* Transforms a Channel by applying a function to its Pull implementation.
+*
+* **Example** (Transforming pull behavior)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* // Transform a channel by modifying its pull behavior
+* const originalChannel = Channel.fromIterable([1, 2, 3])
+*
+* const transformedChannel = Channel.transformPull(
+*   originalChannel,
+*   (pull, scope) =>
+*     Effect.succeed(
+*       Effect.map(pull, (value) => value * 2)
+*     )
+* )
+* await Effect.runPromise(Channel.runCollect(transformedChannel)) // => [2, 4, 6]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const transformPull$1 = (self, f) => fromTransform((upstream, scope) => flatMap$2(toTransform(self)(upstream, scope), (pull) => f(pull, scope)));
+/**
+* Creates a `Channel` from an `Effect` that produces a `Pull`.
+*
+* **Example** (Creating channels from pulls)
+*
+* ```ts import.meta.vitest
+* import { Cause, Channel, Effect } from "effect"
+*
+* const channel = Channel.fromPull(Effect.sync(() => {
+*   let emitted = false
+*   return Effect.suspend(() => {
+*     if (emitted) return Cause.done()
+*     emitted = true
+*     return Effect.succeed(42)
+*   })
+* }))
+* await Effect.runPromise(Channel.runCollect(channel)) // => [42]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromPull$1 = (effect) => fromTransform((_, __) => effect);
+/**
+* Creates a `Channel` from a transformation function that operates on upstream
+* pulls, but also provides a forked scope that closes when the resulting
+* Channel completes.
+*
+* **When to use**
+*
+* Use when building channels that require scoped resource lifecycle management,
+* providing both the channel scope and a forked scope that automatically closes
+* when the channel completes.
+*
+* @see {@link fromTransform} for a simpler transformation without a forked scope
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromTransformBracket = (f) => fromTransform(fnUntraced(function* (upstream, scope) {
+	const closableScope = forkUnsafe(scope);
+	const onCause = (cause) => close(closableScope, doneExitFromCause(cause));
+	const pull = yield* onError(f(upstream, scope, closableScope), onCause);
+	return onError(pull, onCause);
+}));
+/**
+* Converts a `Channel` back to its underlying transformation function.
+*
+* **Example** (Extracting channel transforms)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* const channel = Channel.succeed(42)
+* const transform = Channel.toTransform(channel)
+* typeof transform // => "function"
+* Effect.runSync(Channel.runCollect(channel)) // => [42]
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 4.0.0
+*/
+const toTransform = (channel) => channel.transform;
+/**
+* The default chunk size used by channels for batching operations.
+*
+* **Example** (Reading the default chunk size)
+*
+* ```ts import.meta.vitest
+* import { Channel } from "effect"
+*
+* Channel.DefaultChunkSize // => 4096
+* ```
+*
+* @stability stable
+* @category constants
+* @since 4.0.0
+*/
+const DefaultChunkSize = 4096;
+const asyncQueue = (scope, f, options) => make$3({
+	capacity: options?.bufferSize,
+	strategy: options?.strategy
+}).pipe(tap$1((queue) => addFinalizer(scope, shutdown(queue))), tap$1((queue) => provide(f(queue), scope).pipe(catchCause((cause) => failCause$3(queue, cause)), forkIn(scope, { startImmediately: true }))));
+/**
+* Creates a `Channel` that interacts with a callback function using a queue, emitting arrays.
+*
+* **Example** (Creating array channels from callbacks)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect, Queue } from "effect"
+*
+* const channel = Channel.callbackArray<number>(Effect.fn(function*(queue) {
+*   yield* Queue.offer(queue, 1)
+*   yield* Queue.offer(queue, 2)
+*   yield* Queue.end(queue)
+* }))
+* await Effect.runPromise(Channel.runCollect(channel)) // => [[1, 2]]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const callbackArray = (f, options) => fromTransform((_, scope) => map$3(asyncQueue(scope, f, options), takeAll));
+/**
+* Creates a `Channel` that lazily evaluates to another channel.
+*
+* **Example** (Suspending channel creation)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* const channel = Channel.suspend(() => Channel.succeed(42))
+* Effect.runSync(Channel.runCollect(channel)) // => [42]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const suspend$1 = (evaluate) => fromTransform((upstream, scope) => suspend$2(() => toTransform(evaluate())(upstream, scope)));
+/**
+* Creates a `Channel` from an iterator.
+*
+* **Example** (Creating channels from iterators)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* const numbers = [1, 2, 3, 4, 5]
+* const channel = Channel.fromIterator(() => numbers[Symbol.iterator]())
+* Effect.runSync(Channel.runCollect(channel)) // => [1, 2, 3, 4, 5]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromIterator = (iterator) => fromPull$1(sync(() => {
+	const iter = iterator();
+	return suspend$2(() => {
+		const state = iter.next();
+		return state.done ? done(state.value) : succeed$2(state.value);
+	});
+}));
+/**
+* Creates a `Channel` from an iterator that emits arrays of elements.
+*
+* **Details**
+*
+* Finite fractional `chunkSize` values are rounded down. `NaN` and non-positive
+* values are treated as `1` so every successful pull emits a non-empty array.
+*
+* **Example** (Batching iterator output)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* // Create a channel from a simple iterator
+* const numberIterator = (): Iterator<number, string> => {
+*   let count = 0
+*   return {
+*     next: () => {
+*       if (count < 3) {
+*         return { value: count++, done: false }
+*       }
+*       return { value: "finished", done: true }
+*     }
+*   }
+* }
+*
+* const channel = Channel.fromIteratorArray(() => numberIterator(), 2)
+* Effect.runSync(Channel.runCollect(channel)) // => [[0, 1], [2]]
+* ```
+*
+* **Example** (Batching generator output)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* // Create channel from a generator function
+* function* fibonacci(): Generator<number, void, unknown> {
+*   let a = 0, b = 1
+*   for (let i = 0; i < 5; i++) {
+*     yield a
+*     ;[a, b] = [b, a + b]
+*   }
+* }
+*
+* const fibChannel = Channel.fromIteratorArray(() => fibonacci(), 3)
+* Effect.runSync(Channel.runCollect(fibChannel)) // => [[0, 1, 1], [2, 3]]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromIteratorArray = (iterator, chunkSize = DefaultChunkSize) => {
+	const size = normalizeNonEmpty(chunkSize);
+	return fromPull$1(sync(() => {
+		const iter = iterator();
+		let done$8 = none();
+		return suspend$2(() => {
+			if (done$8._tag === "Some") return done(done$8.value);
+			const buffer = [];
+			while (buffer.length < size) {
+				const state = iter.next();
+				if (state.done) {
+					if (buffer.length === 0) return done(state.value);
+					done$8 = some(state.value);
+					break;
+				}
+				buffer.push(state.value);
+			}
+			return succeed$2(buffer);
+		});
+	}));
+};
+/**
+* Creates a `Channel` that emits arrays of elements from an iterable.
+*
+* **Details**
+*
+* Finite fractional `chunkSize` values are rounded down. `NaN` and non-positive
+* values are treated as `1`.
+*
+* **Example** (Batching iterable output)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* const numbers = [1, 2, 3, 4, 5]
+* const channel = Channel.fromIterableArray(numbers, 4)
+* Effect.runSync(Channel.runCollect(channel)) // => [[1, 2, 3, 4], [5]]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromIterableArray = (iterable, chunkSize = DefaultChunkSize) => fromIteratorArray(() => iterable[Symbol.iterator](), chunkSize);
+/**
+* Creates a `Channel` that emits a single value and then ends.
+*
+* **Example** (Creating channels that succeed)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* const channel = Channel.succeed(42)
+* Effect.runSync(Channel.runCollect(channel)) // => [42]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const succeed$1 = (value) => fromEffect$1(succeed$2(value));
+/**
+* Represents a `Channel` that emits no elements.
+*
+* **Example** (Creating empty channels)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* // Create an empty channel
+* const emptyChannel = Channel.empty
+*
+* // Use empty channel in composition
+* const combined = Channel.concatWith(emptyChannel, () => Channel.succeed(42))
+* // Will immediately provide the second channel's output
+*
+* // Empty channel can be used as a no-op in conditional logic
+* const conditionalChannel = (shouldEmit: boolean) =>
+*   shouldEmit ? Channel.succeed("data") : Channel.empty
+*
+* Effect.runSync(Channel.runCollect(conditionalChannel(true))) // => ["data"]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const empty$1 = /*#__PURE__*/ fromPull$1(/*#__PURE__*/ succeed$2(/*#__PURE__*/ done()));
+/**
+* Constructs a channel that fails immediately with the specified error.
+*
+* **Example** (Failing with an error)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect, Exit } from "effect"
+*
+* const failedChannel = Channel.fail("Something went wrong")
+* Effect.runSync(Effect.exit(Channel.runCollect(failedChannel))) // => Exit.fail("Something went wrong")
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fail$1 = (error) => fromPull$1(succeed$2(fail$2(error)));
+/**
+* Constructs a channel that fails immediately with the specified `Cause`.
+*
+* **When to use**
+*
+* Use when the channel failure must preserve a full `Cause`, such as defects,
+* interruptions, or combined failures.
+*
+* **Example** (Failing with causes)
+*
+* ```ts import.meta.vitest
+* import { Cause, Channel, Effect, Exit } from "effect"
+*
+* const simpleCause = Cause.fail("Simple error")
+* const failedChannel = Channel.failCause(simpleCause)
+* Effect.runSync(Effect.exit(Channel.runCollect(failedChannel))) // => Exit.failCause(simpleCause)
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const failCause = (cause) => fromPull$1(failCause$1(cause));
+/**
+* Constructs a channel that fails immediately with the specified defect.
+*
+* **Example** (Dying with defects)
+*
+* ```ts import.meta.vitest
+* import { Cause, Channel, Effect, Exit } from "effect"
+*
+* const defect = "Unrecoverable error"
+* const diedChannel = Channel.die(defect)
+* Effect.runSync(Effect.exit(Channel.runCollect(diedChannel))) // => Exit.failCause(Cause.die(defect))
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const die$1 = (defect) => failCause(die$2(defect));
+/**
+* Uses an effect to write a single value to the channel.
+*
+* **Example** (Creating channels from effects)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* const successChannel = Channel.fromEffect(
+*   Effect.succeed("Hello from effect!")
+* )
+* Effect.runSync(Channel.runCollect(successChannel)) // => ["Hello from effect!"]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fromEffect$1 = (effect) => fromPull$1(sync(() => {
+	let done$9 = false;
+	return suspend$2(() => {
+		if (done$9) return done();
+		done$9 = true;
+		return effect;
+	});
+}));
+/**
+* Uses an effect and discards its result.
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromEffectDrain = (effect) => fromPull$1(flatMap$2(effect, () => done()));
+/**
+* Creates a channel from a queue that emits arrays of elements.
+*
+* **Example** (Creating batched channels from queues)
+*
+* ```ts import.meta.vitest
+* import { Cause, Channel, Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number, Cause.Done>(4)
+*   yield* Queue.offerAll(queue, [1, 2, 3, 4])
+*   yield* Queue.end(queue)
+*   const arrayChannel = Channel.fromQueueArray(queue)
+*   return yield* Channel.runCollect(arrayChannel)
+* })
+* await Effect.runPromise(program) // => [[1, 2, 3, 4]]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromQueueArray = (queue) => fromPull$1(succeed$2(takeAll(queue)));
+/**
+* Creates a channel from a lazily supplied Web `ReadableStream`.
+*
+* **Details**
+*
+* Read failures are mapped with `onError`. Finalization cancels the reader and
+* releases its lock, or only releases the lock when `releaseLockOnEnd` is set.
+* A rejected cancel hook becomes a defect.
+*
+* **Example** (Reading from a Web stream)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* const channel = Channel.fromReadableStream({
+*   evaluate: () => new ReadableStream({
+*     start(controller) {
+*       controller.enqueue(1)
+*       controller.close()
+*     }
+*   }),
+*   onError: (cause) => new Error(String(cause))
+* })
+*
+* await Effect.runPromise(Channel.runCollect(channel)) // => [[1]]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromReadableStream$1 = (options) => fromTransform((_, scope) => readableStreamToPullUnsafe({
+	scope,
+	readable: options.evaluate(),
+	onError: options.onError,
+	releaseLockOnEnd: options.releaseLockOnEnd
+}));
+const readableStreamToPullUnsafe = (options) => {
+	const reader = options.readable.getReader();
+	const exit = options.exit ?? make$2(void 0);
+	const pull = suspend$2(() => {
+		if (exit.current) return exit.current;
+		return matchCauseEffect(tryPromise({
+			try: () => reader.read(),
+			catch: options.onError
+		}), {
+			onFailure: (cause) => exit.current ?? failCause$1(cause),
+			onSuccess: ({ done: done$11, value }) => {
+				if (exit.current) return exit.current;
+				return done$11 ? done() : succeed$2(of(value));
+			}
+		});
+	});
+	return as(addFinalizer(options.scope, options.releaseLockOnEnd ? sync(() => reader.releaseLock()) : promise(() => reader.cancel().catch((error) => reader.closed.then(() => Promise.reject(error), constVoid))).pipe(ensuring$2(sync(() => reader.releaseLock())))), pull);
+};
+/**
+* Creates a channel that pulls values from an `AsyncIterable`.
+*
+* **Details**
+*
+* Each yielded value is emitted as an output element. The iterator's return
+* value becomes the channel's done value. Thrown or rejected iterator errors
+* are converted with `onError`. If the channel scope closes early and the
+* iterator has a `return` method, that method is called. It is awaited unless
+* a `next()` call is still pending, in which case its result is ignored and an
+* async generator may not run its cleanup until that pull settles.
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromAsyncIterable$1 = (iterable, onError) => fromTransform(fnUntraced(function* (_, scope) {
+	const iter = iterable[Symbol.asyncIterator]();
+	let pulling = false;
+	if (iter.return) yield* addFinalizer(scope, suspend$2(() => pulling ? sync(() => void iter.return().catch(constVoid)) : promise(() => iter.return())));
+	return flatMap$2(tryPromise({
+		try: () => {
+			const promise = iter.next();
+			pulling = true;
+			return promise.finally(() => {
+				pulling = false;
+			});
+		},
+		catch: onError
+	}), (result) => result.done ? done(result.value) : succeed$2(result.value));
+}));
+/**
+* Creates a channel from an `AsyncIterable`, emitting each yielded value as a
+* single-element non-empty array.
+*
+* **Details**
+*
+* The iterator's return value becomes the channel's done value. Thrown or
+* rejected iterator errors are converted with `onError`. If the channel scope
+* closes early and the iterator has a `return` method, that method is called.
+* It is awaited unless a `next()` call is still pending, in which case its
+* result is ignored and an async generator may not run its cleanup until that
+* pull settles.
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromAsyncIterableArray = (iterable, onError) => map$1(fromAsyncIterable$1(iterable, onError), of);
+/**
+* Maps the output of this channel using the specified function.
+*
+* **Example** (Mapping channel output)
+*
+* ```ts import.meta.vitest
+* import { Channel, Data, Effect } from "effect"
+*
+* class TransformError extends Data.TaggedError("TransformError")<{
+*   readonly reason: string
+* }> {}
+*
+* // Basic mapping of channel values
+* const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])
+* const doubledChannel = Channel.map(numbersChannel, (n) => n * 2)
+* Effect.runSync(Channel.runCollect(doubledChannel)) // => [2, 4, 6, 8, 10]
+*
+* // Transform string data
+* const wordsChannel = Channel.fromIterable(["hello", "world", "effect"])
+* const upperCaseChannel = Channel.map(wordsChannel, (word) => word.toUpperCase())
+* Effect.runSync(Channel.runCollect(upperCaseChannel)) // => ["HELLO", "WORLD", "EFFECT"]
+*
+* // Complex object transformation
+* type User = { id: number; name: string }
+* type UserDisplay = { displayName: string; isActive: boolean }
+*
+* const usersChannel = Channel.fromIterable([
+*   { id: 1, name: "Alice" },
+*   { id: 2, name: "Bob" }
+* ])
+* const displayChannel = Channel.map(usersChannel, (user): UserDisplay => ({
+*   displayName: `User: ${user.name}`,
+*   isActive: true
+* }))
+* Effect.runSync(Channel.runCollect(displayChannel)) // => [{ displayName: "User: Alice", isActive: true }, { displayName: "User: Bob", isActive: true }]
+* ```
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const map$1 = /*#__PURE__*/ dual(2, (self, f) => transformPull$1(self, (pull) => sync(() => {
+	let i = 0;
+	return map$3(pull, (o) => f(o, i++));
+})));
+/**
+* Maps the done value of this channel using the specified function.
+*
+* @stability stable
+* @category sequencing
+* @since 4.0.0
+*/
+const mapDone = /*#__PURE__*/ dual(2, (self, f) => mapDoneEffect(self, (o) => succeed$2(f(o))));
+/**
+* Maps the done value of this channel using the specified effectful function.
+*
+* **When to use**
+*
+* Use when the terminal done value transformation needs services or can fail,
+* while emitted elements should pass through unchanged.
+*
+* @stability stable
+* @category sequencing
+* @since 4.0.0
+*/
+const mapDoneEffect = /*#__PURE__*/ dual(2, (self, f) => transformPull$1(self, (pull) => succeed$2(catchDone(pull, (done$12) => flatMap$2(f(done$12), done)))));
+const concurrencyIsSequential = (concurrency) => concurrency === void 0 || concurrency !== "unbounded" && concurrency <= 1;
+/**
+* Maps each output element with an effectful function, preserving the source
+* channel's done value.
+*
+* **When to use**
+*
+* Use when transforming each channel output needs an Effect, service
+* dependency, failure channel, or configured concurrency.
+*
+* **Details**
+*
+* The mapping function receives the output element and its zero-based index.
+* By default elements are mapped sequentially. Use `options.concurrency` to
+* map multiple elements concurrently, and `options.unordered` to allow
+* concurrently mapped outputs to be emitted as soon as they complete.
+*
+* **Example** (Mapping channel output with effects)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])
+* const processedChannel = Channel.mapEffect(
+*   numbersChannel,
+*   (n) => Effect.succeed(n * n)
+* )
+* await Effect.runPromise(Channel.runCollect(processedChannel)) // => [1, 4, 9, 16, 25]
+* ```
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const mapEffect$1 = /*#__PURE__*/ dual((args) => isChannel(args[0]), (self, f, options) => concurrencyIsSequential(options?.concurrency) ? mapEffectSequential(self, f) : mapEffectConcurrent(self, f, options));
+const mapEffectSequential = (self, f) => fromTransform((upstream, scope) => {
+	let i = 0;
+	return map$3(toTransform(self)(upstream, scope), flatMap$2((o) => f(o, i++)));
+});
+const mapEffectConcurrent = (self, f, options) => fromTransformBracket(fnUntraced(function* (upstream, scope, forkedScope) {
+	let i = 0;
+	const pull = yield* toTransform(self)(upstream, scope);
+	const concurrencyN = options.concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : Math.min(options.concurrency, Number.MAX_SAFE_INTEGER);
+	const queue = yield* bounded(0);
+	yield* addFinalizer(forkedScope, shutdown(queue));
+	const runFork = runForkWith(yield* context());
+	const trackFiber = runIn(forkedScope);
+	if (options.unordered) {
+		const semaphore = makeUnsafe$2(concurrencyN);
+		const release = constant(semaphore.release(1));
+		const handle = matchCauseEffect({
+			onFailure: (cause) => flatMap$2(failCause$3(queue, cause), release),
+			onSuccess: (value) => flatMap$2(offer(queue, value), release)
+		});
+		yield* semaphore.take(1).pipe(flatMap$2(() => pull), flatMap$2((value) => {
+			const index = i++;
+			trackFiber(runFork(handle(suspend$2(() => f(value, index)))));
+			return void_;
+		}), forever({ disableYield: true }), catchCause((cause) => semaphore.withPermits(concurrencyN - 1)(failCause$3(queue, cause))), forkIn(forkedScope));
+	} else {
+		const effects = yield* bounded(concurrencyN - 2);
+		yield* addFinalizer(forkedScope, shutdown(effects));
+		yield* take$1(effects).pipe(flatten$1, flatMap$2((value) => offer(queue, value)), forever({ disableYield: true }), catchCause((cause) => failCause$3(queue, cause)), forkIn(forkedScope));
+		let errorCause;
+		const onExit = (exit) => {
+			if (exit._tag === "Success") return;
+			errorCause = exit.cause;
+			failCauseUnsafe(queue, exit.cause);
+		};
+		yield* pull.pipe(flatMap$2((value) => {
+			if (errorCause) return failCause$1(errorCause);
+			const index = i++;
+			const fiber = runFork(suspend$2(() => f(value, index)));
+			trackFiber(fiber);
+			fiber.addObserver(onExit);
+			return offer(effects, join(fiber));
+		}), forever({ disableYield: true }), catchCause((cause) => offer(effects, failCause$2(cause)).pipe(andThen(failCause$3(effects, cause)))), forkIn(forkedScope));
+	}
+	return take$1(queue);
+}));
+/**
+* Maps each output element to a channel and flattens the child channel
+* outputs.
+*
+* **Details**
+*
+* The source channel's done value is preserved. Child channel done values are
+* used only for child-channel completion. By default child channels are run
+* sequentially. Use `options.concurrency` and `options.bufferSize` to run child
+* channels concurrently.
+*
+* **Example** (Flat mapping channel output)
+*
+* ```ts import.meta.vitest
+* import { Channel, Data, Effect } from "effect"
+*
+* class ProcessError extends Data.TaggedError("ProcessError")<{
+*   readonly cause: string
+* }> {}
+*
+* // Create a channel that outputs numbers
+* const numberChannel = Channel.fromIterable([1, 2, 3])
+*
+* // FlatMap each number to create new channels
+* const flatMappedChannel = Channel.flatMap(
+*   numberChannel,
+*   (n) =>
+*     Channel.fromIterable(Array.from({ length: n }, (_, i) => `item-${n}-${i}`))
+* )
+*
+* Effect.runSync(Channel.runCollect(flatMappedChannel)) // => ["item-1-0", "item-2-0", "item-2-1", "item-3-0", "item-3-1", "item-3-2"]
+* ```
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const flatMap$1 = /*#__PURE__*/ dual((args) => isChannel(args[0]), (self, f, options) => concurrencyIsSequential(options?.concurrency) ? flatMapSequential(self, f) : flatMapConcurrent(self, f, options));
+const flatMapSequential = (self, f) => fromTransform((upstream, scope) => map$3(toTransform(self)(upstream, scope), (pull) => {
+	let childPull;
+	let childScope;
+	const makePull = flatMap$2(pull, (value) => {
+		childScope ??= forkUnsafe(scope);
+		return flatMapEager(toTransform(f(value))(upstream, childScope), (pull) => {
+			childPull = catchHalt(pull);
+			return childPull;
+		});
+	});
+	const catchHalt = catchDone((_) => {
+		childPull = void 0;
+		if (childScope.state._tag === "Empty") return makePull;
+		const close$2 = close(childScope, void_$1);
+		childScope = void 0;
+		return flatMap$2(close$2, () => makePull);
+	});
+	return suspend$2(() => childPull ?? makePull);
+}));
+const flatMapConcurrent = (self, f, options) => self.pipe(map$1(f), mergeAll(options));
+/**
+* Flattens a channel of channels.
+*
+* **Example** (Flattening nested channels)
+*
+* ```ts import.meta.vitest
+* import { Channel, Data, Effect } from "effect"
+*
+* class FlattenError extends Data.TaggedError("FlattenError")<{
+*   readonly cause: string
+* }> {}
+*
+* // Create a channel that outputs channels
+* const nestedChannels = Channel.fromIterable([
+*   Channel.fromIterable([1, 2]),
+*   Channel.fromIterable([3, 4]),
+*   Channel.fromIterable([5, 6])
+* ])
+*
+* // Flatten the nested channels
+* const flattenedChannel = Channel.flatten(nestedChannels)
+*
+* Effect.runSync(Channel.runCollect(flattenedChannel)) // => [1, 2, 3, 4, 5, 6]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const flatten = (channels) => flatMap$1(channels, identity);
+/**
+* Flattens a channel that outputs arrays into a channel that outputs individual elements.
+*
+* **Example** (Flattening arrays of channel output)
+*
+* ```ts import.meta.vitest
+* import { Channel, Data, Effect } from "effect"
+*
+* class FlattenError extends Data.TaggedError("FlattenError")<{
+*   readonly message: string
+* }> {}
+*
+* // Create a channel that outputs arrays
+* const arrayChannel = Channel.fromIterable([
+*   [1, 2, 3],
+*   [4, 5],
+*   [6, 7, 8, 9]
+* ])
+*
+* // Flatten the arrays into individual elements
+* const flattenedChannel = Channel.flattenArray(arrayChannel)
+*
+* Effect.runSync(Channel.runCollect(flattenedChannel)) // => [1, 2, 3, 4, 5, 6, 7, 8, 9]
+* ```
+*
+* @stability stable
+* @category transforming
+* @since 4.0.0
+*/
+const flattenArray = (self) => transformPull$1(self, (pull) => {
+	let array;
+	let index = 0;
+	const pump = suspend$2(function loop() {
+		if (array === void 0) return flatMap$2(pull, (array_) => {
+			switch (array_.length) {
+				case 0: return loop();
+				case 1: return succeed$2(array_[0]);
+				default:
+					array = array_;
+					return succeed$2(array_[index++]);
+			}
+		});
+		const next = array[index++];
+		if (index >= array.length) {
+			array = void 0;
+			index = 0;
+		}
+		return succeed$2(next);
+	});
+	return succeed$2(pump);
+});
+/**
+* Creates a new channel that consumes all output from the source channel
+* but emits nothing, preserving only the completion value.
+*
+* **Example** (Draining channel output)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* // Create a channel that outputs values
+* const sourceChannel = Channel.fromIterable([1, 2, 3, 4, 5])
+*
+* // Drain all output, keeping only the completion
+* const drainedChannel = Channel.drain(sourceChannel)
+*
+* Effect.runSync(Channel.runCollect(drainedChannel)) // => []
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const drain$1 = (self) => transformPull$1(self, (pull) => succeed$2(forever(pull, { disableYield: true })));
+const repeatLoop = (self, onExit) => fromTransform((upstream, scope) => sync(() => {
+	let currentPull;
+	const makePull = () => {
+		const runScope = forkUnsafe(scope);
+		return flatMap$2(toTransform(self)(upstream, runScope), (pull) => {
+			currentPull = catchCause(pull, (cause) => {
+				const exit = doneExitFromCause(cause);
+				return close(runScope, exit).pipe(flatMap$2(() => onExit(exit, scope)), flatMap$2(makePull));
+			});
+			return currentPull;
+		});
+	};
+	return suspend$2(() => currentPull ?? makePull());
+}));
+/**
+* Filters arrays of elements emitted by a channel, applying the filter
+* to each element within the arrays and only emitting non-empty filtered arrays.
+*
+* **Example** (Filtering array output)
+*
+* ```ts import.meta.vitest
+* import { Array, Channel, Effect } from "effect"
+*
+* const nonEmptyArrayPredicate = Array.isReadonlyArrayNonEmpty
+*
+* // Create a channel that outputs arrays of mixed data
+* const arrayChannel = Channel.fromIterable([
+*   Array.make(1, 2, 3, 4, 5),
+*   Array.make(6, 7, 8, 9, 10),
+*   Array.make(11, 12, 13, 14, 15)
+* ]).pipe(Channel.filter(nonEmptyArrayPredicate))
+*
+* // Filter arrays to keep only even numbers
+* const evenArraysChannel = Channel.filterArray(arrayChannel, (n) => n % 2 === 0)
+* Effect.runSync(Channel.runCollect(evenArraysChannel)) // => [[2, 4], [6, 8, 10], [12, 14]]
+* // Note: Only non-empty filtered arrays are emitted
+*
+* // Arrays that would become empty after filtering are discarded entirely
+* const oddChannel = Channel.fromIterable([
+*   Array.make(1, 3, 5),
+*   Array.make(2, 4),
+*   Array.make(7, 9)
+* ]).pipe(Channel.filter(nonEmptyArrayPredicate))
+* const filteredOddChannel = Channel.filterArray(oddChannel, (n) => n % 2 === 0)
+* Effect.runSync(Channel.runCollect(filteredOddChannel)) // => [[2, 4]]
+* ```
+*
+* @stability stable
+* @category filtering
+* @since 4.0.0
+*/
+const filterArray = /*#__PURE__*/ dual(2, (self, predicate) => transformPull$1(self, (pull) => succeed$2(flatMap$2(pull, function loop(arr) {
+	const passes = [];
+	for (let i = 0; i < arr.length; i++) if (predicate(arr[i])) passes.push(arr[i]);
+	return isReadonlyArrayNonEmpty(passes) ? succeed$2(passes) : flatMap$2(pull, loop);
+}))));
+/**
+* Maps over a channel statefully with an accumulator, where each element can produce multiple output values.
+*
+* **Example** (Mapping with accumulated state)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* // Create a channel with numbers
+* const numbersChannel = Channel.fromIterable([1, 2, 3, 4])
+*
+* // Use mapAccum to create running sums and emit both current and sum
+* const runningSum = Channel.mapAccum(
+*   numbersChannel,
+*   () => 0, // initial accumulator state
+*   (sum, current) => {
+*     const newSum = sum + current
+*     // Return [newState, outputValues]
+*     return [newSum, [current, newSum]] as const
+*   }
+* )
+* // Using with Effect for async processing
+* const asyncMapAccum = Channel.mapAccum(
+*   numbersChannel,
+*   () => "",
+*   (acc, value) =>
+*     Effect.gen(function*() {
+*       const newAcc = acc + value.toString()
+*       return [newAcc, [`${value}-processed`, newAcc]] as const
+*     })
+* )
+* Effect.runSync(Channel.runCollect(runningSum)) // => [1, 1, 2, 3, 3, 6, 4, 10]
+* Effect.runSync(Channel.runCollect(asyncMapAccum)) // => ["1-processed", "1", "2-processed", "12", "3-processed", "123", "4-processed", "1234"]
+* ```
+*
+* @stability stable
+* @category sequencing
+* @since 4.0.0
+*/
+const mapAccum$1 = /*#__PURE__*/ dual((args) => isChannel(args[0]), (self, initial, f, options) => fromTransform((upstream, scope) => map$3(toTransform(self)(upstream, scope), (pull) => {
+	let state = initial();
+	let current;
+	let index = 0;
+	let cause;
+	const pullNext = matchCauseEffect(pull, {
+		onFailure(cause_) {
+			cause = cause_;
+			const b = options?.onHalt && options.onHalt(state);
+			return b && b.length > 0 ? succeed$2([state, b]) : failCause$1(cause_);
+		},
+		onSuccess(a) {
+			const b = f(state, a);
+			return isArray(b) ? succeed$2(b) : b;
+		}
+	});
+	return suspend$2(function loop() {
+		if (current === void 0) {
+			if (cause) return failCause$1(cause);
+			return flatMap$2(pullNext, ([newState, values]) => {
+				state = newState;
+				if (values.length === 0) return loop();
+				else if (values.length === 1) return succeed$2(values[0]);
+				current = values;
+				return loop();
+			});
+		}
+		const next = current[index++];
+		if (index >= current.length) {
+			current = void 0;
+			index = 0;
+		}
+		return succeed$2(next);
+	});
+})));
+/**
+* Runs an effect when the channel fails with a typed error, then preserves the
+* original channel failure.
+*
+* **Details**
+*
+* The effect is not run for normal channel completion. If the observer effect
+* fails, that failure can fail the returned channel.
+*
+* @stability stable
+* @category error handling
+* @since 4.0.0
+*/
+const tapError$1 = /*#__PURE__*/ dual(2, (self, f) => transformPull$1(self, (pull) => succeed$2(tapError$2(pull, (err) => isDone(err) ? void_ : asVoid(f(err))))));
+/**
+* Transforms the typed errors of a channel using the specified function.
+*
+* **Details**
+*
+* Maps every typed error in the cause, preserving defects, interrupts and
+* reason order. Unlike typed recovery, mapping does not convert errors to defects.
+*
+* @stability stable
+* @category error handling
+* @since 2.0.0
+*/
+const mapError$1 = /*#__PURE__*/ dual(2, (self, f) => transformPull$1(self, (pull) => succeed$2(mapError$2(pull, (err) => isDone(err) ? err : f(err)))));
+/**
+* Returns a new channel that retries this channel according to the specified
+* schedule whenever it fails.
+*
+* **Gotchas**
+*
+* Defects take precedence over typed errors. A failure whose cause contains a
+* defect is not retried and is propagated with every typed error converted to a
+* defect. A typed error alongside an interruption is retried.
+*
+* @stability stable
+* @category error handling
+* @since 4.0.0
+*/
+const retry$1 = /*#__PURE__*/ dual(2, (self, schedule) => suspend$1(() => {
+	let step = void 0;
+	let meta = CurrentMetadata.defaultValue();
+	const selfWithMeta = provideServiceEffect(self, CurrentMetadata, sync(() => meta));
+	const withReset = onFirst(selfWithMeta, () => {
+		step = void 0;
+		return void_;
+	});
+	const resolvedSchedule = typeof schedule === "function" ? schedule(identity) : schedule;
+	return repeatLoop(withReset, (exit, scope) => {
+		if (isSuccess$1(exit)) return done(exit.value);
+		const error = findRecoverableError(exit.cause);
+		if (isFailure(error)) return failCause$1(error.failure);
+		return gen(function* () {
+			if (!step) step = yield* toStepWithMetadata(resolvedSchedule);
+			meta = yield* step(error.success);
+		}).pipe(catchDone(() => fail$2(error.success)), provide(scope));
+	});
+}));
+/**
+* Merges multiple channels with specified concurrency and buffering options.
+*
+* **When to use**
+*
+* Use when channel outputs are themselves channels and multiple inner channels
+* should run with configured concurrency and buffering.
+*
+* **Example** (Merging nested channels)
+*
+* ```ts import.meta.vitest
+* import { Channel, Data, Effect } from "effect"
+*
+* class MergeAllError extends Data.TaggedError("MergeAllError")<{
+*   readonly reason: string
+* }> {}
+*
+* // Create channels that output other channels
+* const nestedChannels = Channel.fromIterable([
+*   Channel.fromIterable([1, 2]),
+*   Channel.fromIterable([3, 4]),
+*   Channel.fromIterable([5, 6])
+* ])
+*
+* // Merge all channels with bounded concurrency
+* const mergedChannel = Channel.mergeAll({
+*   concurrency: 1,
+*   bufferSize: 16
+* })(nestedChannels)
+*
+* await Effect.runPromise(Channel.runCollect(mergedChannel)) // => [1, 2, 3, 4, 5, 6]
+* ```
+*
+* @stability stable
+* @category combining
+* @since 2.0.0
+*/
+const mergeAll = /*#__PURE__*/ dual(2, (channels, { bufferSize = 16, concurrency, switch: switch_ = false }) => fromTransformBracket(fnUntraced(function* (upstream, scope, forkedScope) {
+	const concurrencyN = concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : Math.max(1, concurrency);
+	const semaphore = switch_ ? void 0 : makeUnsafe$2(concurrencyN);
+	const doneLatch = yield* make$1(true);
+	const fibers = /* @__PURE__ */ new Map();
+	const queue = yield* bounded(bufferSize);
+	yield* addFinalizer(forkedScope, shutdown(queue));
+	const pull = yield* toTransform(channels)(upstream, scope);
+	yield* gen(function* () {
+		while (true) {
+			let pullFiber;
+			if (semaphore) {
+				if (fibers.size < concurrencyN) yield* semaphore.take(1);
+				else {
+					pullFiber = yield* forkChild(pull);
+					yield* raceFirst(semaphore.take(1), andThen(join(pullFiber), never));
+				}
+			}
+			const channel = pullFiber === void 0 ? yield* pull : yield* join(pullFiber);
+			const childScope = forkUnsafe(forkedScope);
+			const childPull = yield* toTransform(channel)(upstream, childScope);
+			while (fibers.size >= concurrencyN) {
+				const [fiber, fiberScope] = headUnsafe(fibers);
+				fibers.delete(fiber);
+				if (fibers.size === 0) yield* doneLatch.open;
+				yield* interrupt(fiber);
+				yield* ignoreCause(close(fiberScope, interrupt$1()));
+			}
+			const fiber = yield* childPull.pipe(tap$1(() => yieldNow), flatMap$2((value) => offer(queue, value)), forever({ disableYield: true }), onError(fnUntraced(function* (cause) {
+				const exit$1 = doneExitFromCause(cause);
+				const closeExit = yield* exit(close(childScope, exit$1));
+				if (!fibers.has(fiber)) return;
+				const failure = asVoidAll([exit$1, closeExit]);
+				if (isFailure$1(failure)) yield* failCause$3(queue, failure.cause);
+				fibers.delete(fiber);
+				if (semaphore) yield* semaphore.release(1);
+				if (fibers.size === 0) yield* doneLatch.open;
+			})), forkChild);
+			doneLatch.closeUnsafe();
+			fibers.set(fiber, childScope);
+		}
+	}).pipe(catchCause((cause) => {
+		const halt = filterDone(cause);
+		if (isSuccess(halt)) return doneLatch.whenOpen(failCause$3(queue, cause));
+		return failCause$3(queue, cause);
+	}), forkIn(forkedScope));
+	return take$1(queue);
+})));
+/**
+* Returns a new channel, which is the merge of this channel and the specified
+* channel.
+*
+* **Example** (Merging channels)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* // Create two channels
+* const leftChannel = Channel.fromIterable([1, 2, 3])
+* const rightChannel = Channel.fromIterable(["a", "b", "c"])
+*
+* // The default "both" strategy waits for both channels to complete
+* const mergedChannel = Channel.merge(leftChannel, rightChannel)
+*
+* const values = await Effect.runPromise(Channel.runCollect(mergedChannel))
+* values.map(String).sort() // => ["1", "2", "3", "a", "b", "c"]
+* ```
+*
+* @stability stable
+* @category combining
+* @since 4.0.0
+*/
+const merge$1 = /*#__PURE__*/ dual((args) => isChannel(args[0]) && isChannel(args[1]), (left, right, options) => fromTransformBracket(fnUntraced(function* (upstream, _scope, forkedScope) {
+	const strategy = options?.haltStrategy ?? "both";
+	const queue = yield* bounded(0);
+	yield* addFinalizer(forkedScope, shutdown(queue));
+	let done = 0;
+	function onExit(side, cause) {
+		done++;
+		if (!isDoneCause(cause)) return failCause$3(queue, cause);
+		switch (strategy) {
+			case "both": return done === 2 ? failCause$3(queue, cause) : void_;
+			case "left":
+			case "right": return side === strategy ? failCause$3(queue, cause) : void_;
+			case "either": return failCause$3(queue, cause);
+		}
+	}
+	const runSide = (side, channel, scope) => toTransform(channel)(upstream, scope).pipe(flatMap$2((pull) => pull.pipe(flatMap$2((value) => offer(queue, value)), forever)), onError((cause) => onExitPrimitive(doneExitFromCause(cause), (exit) => close(scope, exit)).pipe(matchCauseEffect({
+		onFailure: (cause) => onExit(side, cause),
+		onSuccess: () => onExit(side, cause)
+	}))), forkIn(forkedScope));
+	yield* runSide("left", left, forkUnsafe(forkedScope));
+	yield* runSide("right", right, forkUnsafe(forkedScope));
+	return take$1(queue);
+})));
+/**
+* Runs an effect concurrently with a channel while emitting only the channel's
+* output elements.
+*
+* **When to use**
+*
+* Use when a side effect should run for the lifetime of a channel and only the
+* channel's output elements should be emitted.
+*
+* **Details**
+*
+* The effect's successful value is ignored. If the effect fails while the
+* channel is running, the returned channel fails with that error.
+*
+* @stability stable
+* @category combining
+* @since 4.0.0
+*/
+const mergeEffect$1 = /*#__PURE__*/ dual(2, (self, effect) => merge$1(self, fromEffectDrain(effect), { haltStrategy: "left" }));
+/**
+* Splits upstream string chunks into lines, recognizing `\n`, `\r\n`, and
+* standalone `\r` as line terminators. The behavior matches
+* `String.linesIterator` regardless of how the input is chunked.
+*
+* **Details**
+*
+* A line terminator at the very end of the stream does **not** produce a
+* trailing empty line (consistent with `String.linesIterator`). Conversely,
+* if the stream ends without a terminator the final partial line is still
+* emitted.
+*
+* **Example** (Splitting string chunks into lines)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const result = await Effect.runPromise(Stream.runCollect(
+*   Stream.splitLines(Stream.make("hel", "lo\r\nwor", "ld\n"))
+* ))
+* result // => ["hello", "world"]
+* ```
+*
+* @stability stable
+* @category splitting
+* @since 2.0.0
+*/
+const splitLines$1 = () => fromTransform((upstream, _scope) => sync(() => {
+	let stringBuilder = "";
+	let midCRLF = false;
+	let done$10 = none();
+	function splitLinesArray(chunk) {
+		const chunkBuilder = [];
+		function pushLine(segment) {
+			if (stringBuilder.length === 0) chunkBuilder.push(segment);
+			else {
+				chunkBuilder.push(stringBuilder + segment);
+				stringBuilder = "";
+			}
+		}
+		for (let i = 0; i < chunk.length; i++) {
+			const str = chunk[i];
+			if (str.length !== 0) {
+				let from = 0;
+				let indexOfCR = str.indexOf("\r");
+				let indexOfLF = str.indexOf("\n");
+				if (midCRLF) {
+					if (indexOfLF === 0) {
+						from = 1;
+						indexOfLF = str.indexOf("\n", from);
+					}
+					midCRLF = false;
+				}
+				while (indexOfCR !== -1 || indexOfLF !== -1) if (indexOfCR === -1 || indexOfLF !== -1 && indexOfLF < indexOfCR) {
+					pushLine(str.substring(from, indexOfLF));
+					from = indexOfLF + 1;
+					indexOfLF = str.indexOf("\n", from);
+				} else {
+					pushLine(str.substring(from, indexOfCR));
+					if (str.length === indexOfCR + 1) {
+						midCRLF = true;
+						from = str.length;
+						indexOfCR = -1;
+					} else {
+						from = indexOfCR + (indexOfLF === indexOfCR + 1 ? 2 : 1);
+						indexOfCR = str.indexOf("\r", from);
+						indexOfLF = str.indexOf("\n", from);
+					}
+				}
+				stringBuilder = stringBuilder + str.substring(from);
+			}
+		}
+		return isReadonlyArrayNonEmpty(chunkBuilder) ? chunkBuilder : null;
+	}
+	const pullOrFlush = suspend$2(() => {
+		if (done$10._tag === "Some") return done(done$10.value);
+		return matchEffect(upstream, {
+			onSuccess: loop,
+			onFailure: failCause$1,
+			onDone: (leftover) => {
+				done$10 = some(leftover);
+				if (stringBuilder.length > 0) {
+					const last = stringBuilder;
+					stringBuilder = "";
+					midCRLF = false;
+					return succeed$2([last]);
+				}
+				return done(leftover);
+			}
+		});
+	});
+	function loop(chunk) {
+		const lines = splitLinesArray(chunk);
+		return lines !== null ? succeed$2(lines) : pullOrFlush;
+	}
+	return pullOrFlush;
+}));
+/**
+* Decodes incoming `Uint8Array` chunks into strings using `TextDecoder`.
+*
+* **Details**
+*
+* Input chunks are decoded with streaming enabled so multi-byte characters may
+* span `Uint8Array` boundaries. On normal completion, incomplete trailing
+* characters become U+FFFD or, with `fatal: true`, a defect. The optional
+* `encoding` and `options` are passed to `TextDecoder`.
+*
+* @stability stable
+* @category decoding
+* @since 4.0.0
+*/
+const decodeText$1 = (encoding, options) => fromTransform((upstream, _scope) => sync(() => {
+	const decoder = new TextDecoder(encoding, options);
+	const streamOptions = { stream: true };
+	let pull = upstream.pipe(map$3(map$2((bytes) => decoder.decode(bytes, streamOptions))), catchDone((leftover) => {
+		pull = done(leftover);
+		const last = decoder.decode();
+		return last.length > 0 ? succeed$2(of(last)) : pull;
+	}));
+	return suspend$2(() => pull);
+}));
+/**
+* Returns a new channel that pipes the output of this channel into the
+* specified channel. The returned channel has the input type of this channel,
+* and the output type of the specified channel, terminating with the value of
+* the specified channel.
+*
+* **Example** (Piping one channel into another)
+*
+* ```ts import.meta.vitest
+* import { Channel, Data, Effect } from "effect"
+*
+* class PipeError extends Data.TaggedError("PipeError")<{
+*   readonly stage: string
+* }> {}
+*
+* // Create source and transform channels
+* const sourceChannel = Channel.fromIterable([1, 2, 3])
+* const transformChannel = Channel.map(sourceChannel, (n: number) => n * 2)
+*
+* // Pipe the source into the transform
+* const pipedChannel = Channel.pipeTo(sourceChannel, transformChannel)
+*
+* Effect.runSync(Channel.runCollect(pipedChannel)) // => [2, 4, 6]
+* ```
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const pipeTo = /*#__PURE__*/ dual(2, (self, that) => fromTransform((upstream, scope) => flatMap$2(toTransform(self)(upstream, scope), (upstream) => toTransform(that)(upstream, scope))));
+const isUpstreamFailure = (reason) => reason._tag === "Die" && isDone(reason.defect) && isCause(reason.defect.value);
+/** @internal */
+const hasUpstreamFailure = (cause) => cause.reasons.some(isUpstreamFailure);
+/** @internal */
+const upstreamFailureToDefect = (pull) => catchCause(pull, (cause) => isDoneCause(cause) ? failCause$1(cause) : die$3(Done(cause)));
+/** @internal */
+const unwrapUpstreamFailure = (cause) => hasUpstreamFailure(cause) ? fromReasons(cause.reasons.flatMap((reason) => isUpstreamFailure(reason) ? reason.defect.value.reasons : [reason])) : cause;
+/**
+* The type parameters are explicit because the restored error type includes
+* the upstream error, which is not part of the input effect's type.
+*
+* @internal
+*/
+const restoreUpstreamFailure = (effect) => catchCause(effect, (cause) => failCause$1(unwrapUpstreamFailure(cause)));
+/**
+* Constructs a `Channel` from a scoped effect that will result in a
+* `Channel` if successful.
+*
+* **Example** (Unwrapping channel effects)
+*
+* ```ts import.meta.vitest
+* import { Channel, Data, Effect } from "effect"
+*
+* class UnwrapError extends Data.TaggedError("UnwrapError")<{
+*   readonly reason: string
+* }> {}
+*
+* // Create an effect that produces a channel
+* const channelEffect = Effect.succeed(
+*   Channel.fromIterable([1, 2, 3])
+* )
+*
+* // Unwrap the effect to get the channel
+* const unwrappedChannel = Channel.unwrap(channelEffect)
+*
+* Effect.runSync(Channel.runCollect(unwrappedChannel)) // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const unwrap$1 = (channel) => fromTransform((upstream, scope) => {
+	let pull;
+	return succeed$2(suspend$2(() => {
+		if (pull) return pull;
+		return channel.pipe(provide(scope), flatMap$2((channel) => toTransform(channel)(upstream, scope)), flatMap$2((pull_) => pull = pull_));
+	}));
+});
+/**
+* Buffers array output elements in a queue with the configured `capacity` so a
+* faster producer can progress independently of a slower consumer.
+*
+* **When to use**
+*
+* Use when emitted arrays are batches of elements and it is acceptable for
+* buffering to flatten and rebuild those batches.
+*
+* **Details**
+*
+* Finite queues use the `strategy` option. The default `"suspend"` strategy
+* applies backpressure, while `"dropping"` and `"sliding"` can discard output
+* elements when the queue is full. `"unbounded"` capacity does not use a finite
+* capacity strategy.
+*
+* **Gotchas**
+*
+* Input arrays are offered to the queue element-by-element and outputs are
+* rebuilt from the currently available queued elements, so upstream array
+* boundaries are not preserved.
+*
+* @see {@link buffer} for buffering output elements without flattening arrays
+*
+* @stability stable
+* @category buffering
+* @since 4.0.0
+*/
+const bufferArray = /*#__PURE__*/ dual(2, (self, options) => fromTransform(fnUntraced(function* (upstream, scope) {
+	const pull = yield* toTransform(self)(upstream, scope);
+	const queue = yield* make$3({
+		capacity: options.capacity === "unbounded" ? void 0 : options.capacity,
+		strategy: options.capacity === "unbounded" ? void 0 : options.strategy
+	});
+	yield* addFinalizer(scope, shutdown(queue));
+	yield* pull.pipe(flatMap$2((value) => offerAll(queue, value)), forever({ disableYield: true }), onError((cause) => failCause$3(queue, cause)), forkIn(scope));
+	return takeAll(queue);
+})));
+/**
+* Interrupts a channel when another effect completes.
+*
+* **When to use**
+*
+* Use to race channel execution against an external effect whose success can
+* become the channel's done value.
+*
+* **Details**
+*
+* If the effect completes first, its success value becomes the returned
+* channel's done value. If the channel completes first, the original channel's
+* done value is preserved.
+*
+* @stability stable
+* @category interruption
+* @since 2.0.0
+*/
+const interruptWhen$1 = /*#__PURE__*/ dual(2, (self, effect) => merge$1(self, fromPull$1(succeed$2(flatMap$2(effect, done))), { haltStrategy: "either" }));
+/**
+* Returns a channel with an exit-aware finalizer that is guaranteed to run once
+* the channel begins execution, whether it succeeds or fails.
+*
+* **Example** (Running exit finalizers)
+*
+* ```ts import.meta.vitest
+* import { Channel, Data, Effect, Exit } from "effect"
+*
+* class ExitError extends Data.TaggedError("ExitError")<{
+*   readonly stage: string
+* }> {}
+*
+* // Create a channel
+* const dataChannel = Channel.fromIterable([1, 2, 3])
+*
+* // Attach exit handler
+* const exits: Array<Exit.Exit<void, ExitError>> = []
+* const channelWithExit = Channel.onExit(dataChannel, (exit) => {
+*   exits.push(exit)
+*   return Effect.void
+* })
+* const observed = [await Effect.runPromise(Channel.runCollect(channelWithExit)), exits] // => [[1, 2, 3], [Exit.void]]
+* ```
+*
+* @stability stable
+* @category resource management
+* @since 4.0.0
+*/
+const onExit = /*#__PURE__*/ dual(2, (self, finalizer) => fromTransformBracket((upstream, scope, forkedScope) => addFinalizerExit(forkedScope, finalizer).pipe(andThen(toTransform(self)(upstream, scope)))));
+/**
+* Runs an effect the first time the channel emits an output element.
+*
+* **When to use**
+*
+* Use when initialization depends on the first output element rather than only
+* on channel startup.
+*
+* **Details**
+*
+* The effect receives the first emitted element. The first element is still
+* emitted unchanged. The effect is not run if the channel completes without
+* emitting an element.
+*
+* @stability stable
+* @category hooks
+* @since 4.0.0
+*/
+const onFirst = /*#__PURE__*/ dual(2, (self, onFirst) => transformPull$1(self, (pull) => sync(() => {
+	let isFirst = true;
+	const pullFirst = tap$1(pull, (element) => {
+		isFirst = false;
+		return onFirst(element);
+	});
+	return suspend$2(() => isFirst ? pullFirst : pull);
+})));
+/**
+* Returns a channel with a finalizer effect that is guaranteed to run once the
+* channel begins execution, whether it succeeds or fails.
+*
+* **Example** (Ensuring cleanup runs)
+*
+* ```ts import.meta.vitest
+* import { Channel, Data, Effect } from "effect"
+*
+* class EnsureError extends Data.TaggedError("EnsureError")<{
+*   readonly operation: string
+* }> {}
+*
+* // Create a channel
+* const dataChannel = Channel.fromIterable([1, 2, 3])
+*
+* // Ensure cleanup always runs
+* const events: Array<string> = []
+* const channelWithCleanup = Channel.ensuring(
+*   dataChannel,
+*   Effect.sync(() => events.push("cleanup"))
+* )
+* const observed = [await Effect.runPromise(Channel.runCollect(channelWithCleanup)), events] // => [[1, 2, 3], ["cleanup"]]
+* ```
+*
+* @stability stable
+* @category resource management
+* @since 2.0.0
+*/
+const ensuring$1 = /*#__PURE__*/ dual(2, (self, finalizer) => onExit(self, (_) => finalizer));
+const runWith = (self, f, onHalt) => suspend$2(() => {
+	const scope = makeUnsafe$1();
+	const makePull = toTransform(self)(done(), scope);
+	return catchDone(flatMap$2(makePull, f), onHalt ? onHalt : succeed$2).pipe(onExit$1((exit) => close(scope, exit)));
+});
+/**
+* Provides a `Context` to the channel, removing the corresponding service
+* requirements from the returned channel.
+*
+* @stability stable
+* @category providing services
+* @since 2.0.0
+*/
+const provideContext$1 = /*#__PURE__*/ dual(2, (self, context) => fromTransform((upstream, scope) => map$3(provideContext$2(toTransform(self)(upstream, scope), context), provideContext$2(context))));
+/**
+* Provides a concrete service for a context key, removing that service
+* requirement from the returned channel.
+*
+* @stability stable
+* @category providing services
+* @since 2.0.0
+*/
+const provideService$1 = /*#__PURE__*/ dual(3, (self, key, service) => fromTransform((upstream, scope) => map$3(provideService$2(toTransform(self)(upstream, scope), key, service), provideService$2(key, service))));
+/**
+* Provides a service to the channel after obtaining it from an effect.
+*
+* **When to use**
+*
+* Use to supply a channel dependency when constructing the service itself is
+* effectful or can fail.
+*
+* **Details**
+*
+* If the service effect fails, the returned channel fails. The provided service
+* removes the corresponding service requirement from the returned channel.
+*
+* @stability stable
+* @category providing services
+* @since 4.0.0
+*/
+const provideServiceEffect = /*#__PURE__*/ dual(3, (self, key, service) => fromTransform((upstream, scope) => flatMap$2(service, (s) => toTransform(provideService$1(self, key, s))(upstream, scope))));
+/**
+* Runs a channel and discards all output elements, returning only the final result.
+*
+* **Example** (Draining channel output at runtime)
+*
+* ```ts import.meta.vitest
+* import { Channel, Data, Effect } from "effect"
+*
+* class DrainError extends Data.TaggedError("DrainError")<{
+*   readonly stage: string
+* }> {}
+*
+* // Create a channel that outputs elements and completes with a result
+* const resultChannel = Channel.fromIterable([1, 2, 3])
+* const completedChannel = Channel.concat(resultChannel, Channel.end("completed"))
+*
+* // Drain all elements and get only the final result
+* const drainEffect = Channel.runDrain(completedChannel)
+*
+* Effect.runSync(drainEffect) // => "completed"
+* ```
+*
+* @stability stable
+* @category running
+* @since 2.0.0
+*/
+const runDrain$1 = (self) => runWith(self, (pull) => forever(pull, { disableYield: true }));
+/**
+* Runs a channel and applies an effect to each output element.
+*
+* **Example** (Running effects for each output)
+*
+* ```ts import.meta.vitest
+* import { Channel, Data, Effect } from "effect"
+*
+* class ForEachError extends Data.TaggedError("ForEachError")<{
+*   readonly element: unknown
+* }> {}
+*
+* // Create a channel with numbers
+* const numbersChannel = Channel.fromIterable([1, 2, 3])
+*
+* // Run forEach to process each element
+* const processed: Array<number> = []
+* const forEachEffect = Channel.runForEach(
+*   numbersChannel,
+*   (n) => Effect.sync(() => processed.push(n))
+* )
+*
+* await Effect.runPromise(forEachEffect)
+* processed // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category running
+* @since 4.0.0
+*/
+const runForEach$1 = /*#__PURE__*/ dual(2, (self, f) => runWith(self, (pull) => forever(flatMap$2(pull, f), { disableYield: true })));
+/**
+* Concatenates a channel's `Uint8Array` chunks into a single `Uint8Array`.
+*
+* **Gotchas**
+*
+* This materializes the full content in memory. The source channel must not
+* reuse or mutate emitted buffers, which are retained until collection completes.
+*
+* **Example** (Joining channel byte chunks)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect } from "effect"
+*
+* const channel = Channel.fromArray([
+*   [new Uint8Array([1, 2])],
+*   [new Uint8Array([3, 4])]
+* ] as const)
+*
+* const bytes = Effect.runSync(Channel.mkUint8Array(channel))
+* Array.from(bytes) // => [1, 2, 3, 4]
+* ```
+*
+* @stability stable
+* @category running
+* @since 4.0.0
+*/
+const mkUint8Array$1 = (self) => map$3(runFold$1(self, () => ({
+	bytes: 0,
+	arrays: []
+}), (acc, chunk) => {
+	for (let i = 0; i < chunk.length; i++) {
+		acc.bytes += chunk[i].length;
+		acc.arrays.push(chunk[i]);
+	}
+	return acc;
+}), ({ arrays, bytes }) => {
+	const result = new Uint8Array(bytes);
+	let offset = 0;
+	for (let i = 0; i < arrays.length; i++) {
+		const array = arrays[i];
+		result.set(array, offset);
+		offset += array.length;
+	}
+	return result;
+});
+/**
+* Runs a channel and folds over all output elements with an accumulator.
+*
+* **Example** (Folding channel output)
+*
+* ```ts import.meta.vitest
+* import { Channel, Data, Effect } from "effect"
+*
+* class FoldError extends Data.TaggedError("FoldError")<{
+*   readonly operation: string
+* }> {}
+*
+* // Create a channel with numbers
+* const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])
+*
+* // Fold to calculate sum
+* const sumEffect = Channel.runFold(numbersChannel, () => 0, (acc, n) => acc + n)
+*
+* Effect.runSync(sumEffect) // => 15
+* ```
+*
+* @stability stable
+* @category running
+* @since 4.0.0
+*/
+const runFold$1 = /*#__PURE__*/ dual(3, (self, initial, f) => suspend$2(() => {
+	let state = initial();
+	return runWith(self, (pull) => whileLoop({
+		while: constTrue,
+		body: () => pull,
+		step: (value) => {
+			state = f(state, value);
+		}
+	}), () => succeed$2(state));
+}));
+/**
+* Runs a channel and effectfully folds all output elements with an accumulator.
+*
+* **When to use**
+*
+* Use when folding channel output needs effects, services, or an additional
+* failure channel during accumulation.
+*
+* **Details**
+*
+* The initial accumulator is evaluated lazily. Each output element is passed to
+* the effectful accumulator function. The returned effect succeeds with the
+* final accumulator value.
+*
+* @stability stable
+* @category running
+* @since 4.0.0
+*/
+const runFoldEffect$1 = /*#__PURE__*/ dual(3, (self, initial, f) => suspend$2(() => {
+	let state = initial();
+	return runWith(self, (pull) => whileLoop({
+		while: constTrue,
+		body: constant(pull.pipe(flatMap$2((o) => f(state, o)), map$3((s) => {
+			state = s;
+		}))),
+		step: constVoid
+	}), () => succeed$2(state));
+}));
+/**
+* Converts a channel to a Pull within an existing scope.
+*
+* **Example** (Converting channels to scoped pulls)
+*
+* ```ts import.meta.vitest
+* import { Channel, Data, Effect, Scope } from "effect"
+*
+* class ScopedPullError extends Data.TaggedError("ScopedPullError")<{
+*   readonly reason: string
+* }> {}
+*
+* // Create a channel
+* const numbersChannel = Channel.fromIterable([1, 2, 3])
+*
+* // Convert to Pull with explicit scope
+* const scopedPullEffect = Effect.gen(function*() {
+*   const scope = yield* Effect.scope
+*   const pull = yield* Channel.toPullScoped(numbersChannel, scope)
+*   return [yield* pull, yield* pull, yield* pull]
+* })
+* await Effect.runPromise(Effect.scoped(scopedPullEffect)) // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 4.0.0
+*/
+const toPullScoped = (self, scope) => toTransform(self)(done(), scope);
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/stream.js
+const TypeId$1 = "~effect/Stream";
+const streamVariance = {
+	_R: identity,
+	_E: identity,
+	_A: identity
+};
+const Stream = function(channel) {
+	this.channel = channel;
+};
+Stream.prototype = {
+	[TypeId$1]: streamVariance,
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+/** @internal */
+const fromChannel$1 = (channel) => new Stream(channel);
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Stream.js
+/**
+* Describes effectful sources that emit values over time.
+*
+* A `Stream<A, E, R>` can emit many `A` values, fail with `E`, and require
+* services `R` while it is being consumed. Streams are useful for data that is
+* pulled in steps, such as values from collections, queues, pubsubs, schedules,
+* callbacks, async iterables, or platform streams. The APIs here cover the full
+* stream lifecycle: create a stream, transform or combine it, control buffering
+* and timing, handle failures, and finally consume it.
+*
+* @stability stable
+* @since 2.0.0
+*/
+/**
+* Runtime identifier stored on `Stream` values and used by `isStream` to
+* recognize them.
+*
+* **Details**
+*
+* This marker is part of the runtime representation of `Stream` values. Prefer
+* `isStream` when narrowing unknown values.
+*
+* @see {@link isStream} for the public guard that checks this identifier
+*
+* @stability stable
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId = "~effect/Stream";
+/**
+* Checks whether a value is a Stream.
+*
+* **Example** (Checking whether a value is a Stream)
+*
+* ```ts import.meta.vitest
+* import { Stream } from "effect"
+*
+* Stream.isStream(Stream.make(1, 2, 3)) // => true
+* Stream.isStream({ data: [1, 2, 3] }) // => false
+* ```
+*
+* @stability stable
+* @category guards
+* @since 4.0.0
+*/
+const isStream = (u) => hasProperty(u, TypeId);
+/**
+* Creates a stream from a array-emitting `Channel`.
+*
+* **Example** (Creating a stream from an array-emitting channel)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect, Stream } from "effect"
+*
+* const channel = Channel.succeed([1, 2, 3] as const)
+* const stream = Stream.fromChannel(channel)
+* await Effect.runPromise(Stream.runCollect(stream)) // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fromChannel = fromChannel$1;
+/**
+* Creates a stream from an effect.
+*
+* **Example** (Creating a stream from an effect)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.fromEffect(Effect.succeed(42))
+* await Effect.runPromise(Stream.runCollect(stream)) // => [42]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fromEffect = (effect) => fromChannel(fromEffect$1(map$3(effect, of)));
+/**
+* Creates a stream that emits `void` immediately once, then emits another
+* `void` after each specified interval.
+*
+* **Example** (Emitting ticks on an interval)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* await Effect.runPromise(Stream.tick(0).pipe(Stream.take(3), Stream.runCollect)) // => [undefined, undefined, undefined]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const tick = (interval) => fromPull(sync(() => {
+	let first = true;
+	const effect = succeed$2(of(void 0));
+	const delayed = delay(effect, interval);
+	return suspend$2(() => {
+		if (first) {
+			first = false;
+			return effect;
+		}
+		return delayed;
+	});
+}));
+/**
+* Creates a stream from a pull effect, such as one produced by `Stream.toPull`.
+*
+* **Details**
+*
+* A pull effect yields chunks on demand and completes when the upstream stream ends.
+* See `Stream.toPull` for a matching producer.
+*
+* **Example** (Creating a stream from a pull effect)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const program = Effect.scoped(
+*   Effect.gen(function*() {
+*     const source = Stream.make(1, 2, 3)
+*     const pull = yield* Stream.toPull(source)
+*     const stream = Stream.fromPull(Effect.succeed(pull))
+*     return yield* Stream.runCollect(stream)
+*   })
+* )
+*
+* await Effect.runPromise(program) // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fromPull = (pull) => fromChannel(fromPull$1(pull));
+/**
+* Derives a stream by transforming its pull effect.
+*
+* **Example** (Transforming a pull effect)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.make(1, 2, 3)
+*
+* const transformed = Stream.transformPull(stream, (pull) => Effect.succeed(pull))
+*
+* await Effect.runPromise(Stream.runCollect(transformed)) // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const transformPull = (self, f) => fromChannel(fromTransform((_, scope) => flatMap$2(toPullScoped(self.channel, scope), (pull) => f(pull, scope))));
+/**
+* Creates a channel from a stream.
+*
+* **Example** (Converting a stream to a channel)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect, Stream } from "effect"
+*
+* const channel = Stream.toChannel(Stream.make(1, 2, 3))
+* const values = await Effect.runPromise(Channel.runCollect(channel))
+* values.flat() // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 2.0.0
+*/
+const toChannel = (stream) => stream.channel;
+/**
+* Creates a stream from a callback that can emit values into a queue.
+*
+* **When to use**
+*
+* Use when you need callback-based code to emit stream values by offering to a
+* `Queue`, or signal stream completion through the `Queue` module APIs.
+*
+* By default it uses an "unbounded" buffer size.
+* You can customize the buffer size and strategy by passing an object as the
+* second argument with the `bufferSize` and `strategy` fields.
+*
+* **Example** (Creating a stream from a callback that can emit values into a queue)
+*
+* ```ts import.meta.vitest
+* import { Effect, Queue, Stream } from "effect"
+*
+* const stream = Stream.callback<number>((queue) =>
+*   Effect.sync(() => {
+*     // Emit values to the stream
+*     Queue.offerUnsafe(queue, 1)
+*     Queue.offerUnsafe(queue, 2)
+*     Queue.offerUnsafe(queue, 3)
+*     // Signal completion
+*     Queue.endUnsafe(queue)
+*   })
+* )
+*
+* await Effect.runPromise(Stream.runCollect(stream)) // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const callback = (f, options) => fromChannel(callbackArray(f, options));
+/**
+* Creates an empty stream.
+*
+* **Example** (Creating an empty stream)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* await Effect.runPromise(Stream.runCollect(Stream.empty)) // => []
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const empty = /*#__PURE__*/ fromChannel(empty$1);
+/**
+* Creates a single-valued pure stream.
+*
+* **Example** (Creating a single-valued pure stream)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* await Effect.runPromise(Stream.runCollect(Stream.succeed(3))) // => [3]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const succeed = (value) => fromChannel(succeed$1(of(value)));
+/**
+* Creates a stream from a sequence of values.
+*
+* **Example** (Creating a stream from a sequence of values)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.make(1, 2, 3)
+*
+* await Effect.runPromise(Stream.runCollect(stream)) // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const make = (...values) => fromArray(values);
+/**
+* Creates a lazily constructed stream.
+*
+* **Details**
+*
+* The stream factory is evaluated each time the stream is run.
+*
+* **Example** (Creating a lazily constructed stream)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* await Effect.runPromise(Stream.suspend(() => Stream.make(1, 2, 3)).pipe(Stream.runCollect)) // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const suspend = (stream) => {
+	const suspended = fromChannel(suspend$1(() => stream().channel));
+	suspendedStreams.set(suspended, stream);
+	return suspended;
+};
+const suspendedStreams = /*#__PURE__*/ new WeakMap();
+/**
+* Terminates with the specified error.
+*
+* **Example** (Failing a stream)
+*
+* ```ts import.meta.vitest
+* import { Effect, Exit, Stream } from "effect"
+*
+* await Effect.runPromise(Effect.exit(Stream.runCollect(Stream.fail("Uh oh!")))) // => Exit.fail("Uh oh!")
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fail = (error) => fromChannel(fail$1(error));
+/**
+* The stream that dies with the specified defect.
+*
+* **Example** (Dying with a defect)
+*
+* ```ts import.meta.vitest
+* import { Cause, Effect, Exit, Stream } from "effect"
+*
+* const defect = new Error("Boom")
+* const stream = Stream.die(defect)
+*
+* await Effect.runPromise(Effect.exit(Stream.runCollect(stream))) // => Exit.failCause(Cause.die(defect))
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const die = (defect) => fromChannel(die$1(defect));
+/**
+* Creates a new `Stream` from an iterable collection of values.
+*
+* **Details**
+*
+* - `chunkSize`: Maximum number of values emitted per chunk. Finite fractional
+*   values are rounded down, while `NaN` and non-positive values are treated as
+*   `1`.
+*
+* **Example** (Creating a stream from an iterable)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const numbers = [1, 2, 3]
+*
+* const program = Effect.gen(function*() {
+*   const stream = Stream.fromIterable(numbers)
+*   const values = yield* Stream.runCollect(stream)
+*   values // => [1, 2, 3]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fromIterable = (iterable, options) => Array.isArray(iterable) && options?.chunkSize === void 0 ? fromArray(iterable) : fromChannel(fromIterableArray(iterable, options?.chunkSize));
+/**
+* Creates a stream from an array of values.
+*
+* **Example** (Creating a stream from an array of values)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const stream = Stream.fromArray([1, 2, 3])
+*   const values = yield* Stream.runCollect(stream)
+*   values // => [1, 2, 3]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromArray = (array) => isReadonlyArrayNonEmpty(array) ? fromChannel(succeed$1(array)) : empty;
+/**
+* Creates a stream that pulls values from a `Queue.Dequeue`.
+*
+* **Details**
+*
+* The stream emits non-empty batches of queued values and ends when the queue
+* fails with `Cause.Done`; other queue failures are propagated.
+*
+* **Example** (Creating a stream from a queue of values)
+*
+* ```ts import.meta.vitest
+* import { Cause, Effect, Queue, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.unbounded<number, Cause.Done>()
+*   yield* Queue.offer(queue, 1)
+*   yield* Queue.offer(queue, 2)
+*   yield* Queue.offer(queue, 3)
+*   yield* Queue.end(queue)
+*
+*   const stream = Stream.fromQueue(queue)
+*   const values = yield* Stream.runCollect(stream)
+*   values // => [1, 2, 3]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fromQueue = (queue) => fromChannel(fromQueueArray(queue));
+/**
+* Creates a stream from a lazily supplied Web `ReadableStream`.
+*
+* **Details**
+*
+* The stream reads from a `ReadableStreamDefaultReader` and maps read failures
+* with `onError`. Finalization cancels the reader and releases its lock, or
+* only releases the lock when `releaseLockOnEnd` is set. A rejected cancel
+* hook becomes a defect.
+*
+* **Example** (Creating a stream from a ReadableStream)
+*
+* ```ts import.meta.vitest
+* import { Data, Effect, Stream } from "effect"
+*
+* class StreamError extends Data.TaggedError("StreamError")<{ readonly cause: unknown }> {}
+*
+* const readableStream = new ReadableStream({
+*   start(controller) {
+*     controller.enqueue(1)
+*     controller.enqueue(2)
+*     controller.enqueue(3)
+*     controller.close()
+*   }
+* })
+*
+* const program = Effect.gen(function*() {
+*   const stream = Stream.fromReadableStream({
+*     evaluate: () => readableStream,
+*     onError: (cause) => new StreamError({ cause })
+*   })
+*   const values = yield* Stream.runCollect(stream)
+*   values // => [1, 2, 3]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fromReadableStream = (options) => fromChannel(fromReadableStream$1(options));
+/**
+* Creates a stream from an AsyncIterable.
+*
+* **Example** (Creating a stream from an AsyncIterable)
+*
+* ```ts import.meta.vitest
+* import { Data, Effect, Stream } from "effect"
+*
+* class StreamError extends Data.TaggedError("StreamError")<{ readonly cause: unknown }> {}
+*
+* const iterable = (async function*() {
+*   yield 1
+*   yield 2
+*   yield 3
+* })()
+*
+* await Effect.runPromise(Effect.gen(function*() {
+*   const stream = Stream.fromAsyncIterable(iterable, (cause) => new StreamError({ cause }))
+*   const values = yield* Stream.runCollect(stream)
+*   values // => [1, 2, 3]
+* }))
+*
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fromAsyncIterable = (iterable, onError) => fromChannel(fromAsyncIterableArray(iterable, onError));
+/**
+* Creates a stream by repeatedly evaluating an effectful page function.
+*
+* **When to use**
+*
+* Use to consume paginated APIs where each step returns a batch of values
+* together with an optional next state.
+*
+* **Details**
+*
+* This is similar to {@link unfold}, but each step can emit zero or more values
+* and independently decide whether another state should be requested.
+*
+* **Example** (Paginating stream state)
+*
+* ```ts import.meta.vitest
+* import { Effect, Option, Stream } from "effect"
+*
+* const stream = Stream.paginate(0, (n: number) =>
+*   Effect.succeed(
+*     [
+*       [n],
+*       n < 3 ? Option.some(n + 1) : Option.none<number>()
+*     ] as const
+*   ))
+*
+* await Effect.runPromise(Stream.runCollect(stream)) // => [0, 1, 2, 3]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const paginate = (s, f) => fromPull(sync(() => {
+	let state = s;
+	let done$1 = false;
+	return suspend$2(function loop() {
+		if (done$1) return done();
+		return flatMap$2(f(state), ([a, s]) => {
+			if (isNone(s)) done$1 = true;
+			else state = s.value;
+			if (!isReadonlyArrayNonEmpty(a)) return loop();
+			return succeed$2(a);
+		});
+	});
+}));
+/**
+* Creates a stream produced from an `Effect`.
+*
+* **Example** (Unwrapping a stream effect)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const effect = Effect.succeed(Stream.make(1, 2, 3))
+*
+* const stream = Stream.unwrap(effect)
+*
+* const program = Effect.gen(function*() {
+*   const chunk = yield* Stream.runCollect(stream)
+*   chunk // => [ 1, 2, 3 ]
+* })
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const unwrap = (effect) => fromChannel(unwrap$1(map$3(effect, toChannel)));
+/**
+* Transforms the elements of this stream using the supplied function.
+*
+* **Example** (Mapping stream values)
+*
+* ```ts import.meta.vitest
+* import { Effect, Option, Stream } from "effect"
+*
+* const stream = Stream.fromArray([1, 2, 3]).pipe(Stream.map((n, i) => n + i))
+* await Effect.runPromise(Stream.runCollect(stream)) // => [1, 3, 5]
+* ```
+*
+* @stability stable
+* @category mapping
+* @since 2.0.0
+*/
+const map = /*#__PURE__*/ dual(2, (self, f) => suspend(() => {
+	let i = 0;
+	return fromChannel(map$1(self.channel, map$2((o) => f(o, i++))));
+}));
+/**
+* Maps over elements of the stream with the specified effectful function.
+*
+* **When to use**
+*
+* Use when each stream element transformation needs an Effect, service
+* dependency, failure channel, or configured concurrency.
+*
+* **Example** (Effectfully mapping stream values)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const events: Array<string> = []
+* const stream = Stream.make(1, 2, 3)
+*
+* const mappedStream = stream.pipe(
+*   Stream.mapEffect((n) =>
+*     Effect.sync(() => {
+*       events.push(`Processing: ${n}`)
+*       return n * 2
+*     })
+*   )
+* )
+*
+* const program = Effect.gen(function*() {
+*   const result = yield* Stream.runCollect(mappedStream)
+*   result // => [2, 4, 6]
+* })
+*
+* await Effect.runPromise(program)
+* events // => ["Processing: 1", "Processing: 2", "Processing: 3"]
+* ```
+*
+* @stability stable
+* @category mapping
+* @since 2.0.0
+*/
+const mapEffect = /*#__PURE__*/ dual((args) => isStream(args[0]), (self, f, options) => self.channel.pipe(flattenArray, mapEffect$1(f, options), map$1(of), fromChannel));
+/**
+* Runs the provided effect for each element while preserving the elements.
+*
+* **Example** (Tapping stream values)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const events: Array<string> = []
+* const program = Effect.gen(function*() {
+*   const result = yield* Stream.fromArray([1, 2, 3]).pipe(
+*     Stream.tap((n) => Effect.sync(() => events.push(`before mapping: ${n}`))),
+*     Stream.map((n) => n * 2),
+*     Stream.tap((n) => Effect.sync(() => events.push(`after mapping: ${n}`))),
+*     Stream.runCollect
+*   )
+*
+*   result // => [2, 4, 6]
+* })
+*
+* await Effect.runPromise(program)
+* events // => ["before mapping: 1", "after mapping: 2", "before mapping: 2", "after mapping: 4", "before mapping: 3", "after mapping: 6"]
+* ```
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const tap = /*#__PURE__*/ dual((args) => isStream(args[0]), (self, f, options) => mapEffect(self, (a) => as(f(a), a), options));
+/**
+* Maps each element to a stream and flattens the resulting streams.
+*
+* **Details**
+*
+* With the default sequential concurrency, inner streams are concatenated in
+* input order. When `concurrency` is greater than `1` or `"unbounded"`,
+* multiple inner streams may run at the same time and their outputs are merged
+* as they arrive.
+*
+* **Example** (Flat mapping stream values)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const values = yield* Stream.make(1, 2, 3).pipe(
+*     Stream.flatMap((n) => Stream.make(n, n * 2)),
+*     Stream.runCollect
+*   )
+*   values // => [ 1, 2, 2, 4, 3, 6 ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const flatMap = /*#__PURE__*/ dual((args) => isStream(args[0]), (self, f, options) => self.channel.pipe(flattenArray, flatMap$1((a) => f(a).channel, options), fromChannel));
+/**
+* Converts this stream to one that runs its effects but emits no elements.
+*
+* **Example** (Draining stream values)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const result = yield* Stream.range(1, 6).pipe(Stream.drain, Stream.runCollect)
+*   result // => []
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const drain = (self) => fromChannel(drain$1(self.channel));
+/**
+* Runs the provided stream in the background while this stream runs, interrupting it
+* when this stream completes and failing if the background stream fails or defects.
+*
+* **Example** (Draining a stream in the background)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const events: Array<string> = []
+* const foreground = Stream.make(1, 2)
+* const background = Stream.fromEffect(Effect.sync(() => events.push("background task")))
+*
+* const program = Effect.gen(function*() {
+*   const values = yield* foreground.pipe(
+*     Stream.drainFork(background),
+*     Stream.runCollect
+*   )
+*   values // => [1, 2]
+* })
+*
+* await Effect.runPromise(program)
+* events // => ["background task"]
+* ```
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const drainFork = /*#__PURE__*/ dual(2, (self, that) => mergeEffect(self, runDrain(that)));
+/**
+* Concatenates two streams, emitting all elements from the first stream
+* followed by all elements from the second stream.
+*
+* **Example** (Concatenating streams)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.concat(Stream.make(1, 2, 3), Stream.make(4, 5, 6))
+*
+* await Effect.runPromise(Effect.gen(function*() {
+*   const values = yield* Stream.runCollect(stream)
+*   values // => [ 1, 2, 3, 4, 5, 6 ]
+* }))
+* ```
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const concat = /*#__PURE__*/ dual(2, (self, that) => {
+	const stream = fromChannel(flatten(fromIterator(() => concatChannels(self, that))));
+	concatParts.set(stream, [self, that]);
+	return stream;
+});
+const concatParts = /*#__PURE__*/ new WeakMap();
+function* concatChannels(self, that) {
+	const stack = [that, self];
+	while (stack.length > 0) {
+		const stream = stack.pop();
+		const parts = concatParts.get(stream);
+		if (parts !== void 0) {
+			stack.push(parts[1], parts[0]);
+			continue;
+		}
+		const evaluate = suspendedStreams.get(stream);
+		if (evaluate === void 0) {
+			yield stream.channel;
+			continue;
+		}
+		try {
+			stack.push(evaluate());
+		} catch (defect) {
+			stack.push(die(defect));
+		}
+		yield empty$1;
+	}
+}
+/**
+* Merges two streams, emitting elements from both as they arrive.
+*
+* **Details**
+*
+* By default, the merged stream ends when both streams end. Use
+* `haltStrategy` to change the termination behavior.
+*
+* **Example** (Merging stream values)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const fast = Stream.make(1, 2, 3)
+* const slow = Stream.fromEffect(Effect.delay(Effect.succeed(4), "50 millis"))
+*
+* const program = Effect.gen(function*() {
+*   const result = yield* Stream.runCollect(Stream.merge(fast, slow))
+*   result // => [ 1, 2, 3, 4 ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category merging
+* @since 2.0.0
+*/
+const merge = /*#__PURE__*/ dual((args) => isStream(args[0]) && isStream(args[1]), (self, that, options) => fromChannel(merge$1(toChannel(self), toChannel(that), options)));
+/**
+* Merges this stream with a background effect, keeping the stream's elements.
+*
+* **When to use**
+*
+* Use when an effect should run concurrently for the lifetime of a stream while
+* only the stream's elements remain in the output.
+*
+* **Details**
+*
+* The effect runs concurrently, fails the stream if it fails, and is interrupted
+* when the stream completes.
+*
+* **Example** (Merging with a background effect)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const events: Array<string> = []
+* const program = Effect.gen(function*() {
+*   const values = yield* Stream.make(1, 2, 3).pipe(
+*     Stream.mergeEffect(Effect.sync(() => events.push("side task"))),
+*     Stream.runCollect
+*   )
+*
+*   values // => [1, 2, 3]
+* })
+*
+* await Effect.runPromise(program)
+* events // => ["side task"]
+* ```
+*
+* @stability stable
+* @category merging
+* @since 4.0.0
+*/
+const mergeEffect = /*#__PURE__*/ dual(2, (self, effect) => self.channel.pipe(mergeEffect$1(effect), fromChannel));
+/**
+* Filters a stream to the elements that satisfy a predicate.
+*
+* **Example** (Filtering stream values)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const stream = Stream.make(1, 2, 3, 4).pipe(
+*     Stream.filter((n) => n % 2 === 0)
+*   )
+*   const values = yield* Stream.runCollect(stream)
+*   values // => [ 2, 4 ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category filtering
+* @since 2.0.0
+*/
+const filter = /*#__PURE__*/ dual(2, (self, predicate) => fromChannel(filterArray(toChannel(self), predicate)));
+/**
+* Buffers up to `capacity` elements so a faster producer can progress
+* independently of a slower consumer.
+*
+* **Details**
+*
+* Finite buffers use the configured queue strategy: `"suspend"` applies
+* backpressure, while `"dropping"` and `"sliding"` may discard elements when
+* the buffer is full. This combinator destroys chunking; use `Stream.rechunk`
+* afterward if you need fixed chunk sizes.
+*
+* **Example** (Buffering stream elements)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const values = yield* Stream.make(1, 2, 3).pipe(
+*     Stream.buffer({ capacity: 1 }),
+*     Stream.runCollect
+*   )
+*   values // => [ 1, 2, 3 ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category buffering
+* @since 2.0.0
+*/
+const buffer = /*#__PURE__*/ dual(2, (self, options) => fromChannel(bufferArray(self.channel, options)));
+/**
+* Peeks at errors effectfully without changing the stream unless the tap fails.
+*
+* **Example** (Effectfully peeking at errors)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const errors: Array<string> = []
+* const stream = Stream.make(1, 2).pipe(
+*   Stream.concat(Stream.fail("boom")),
+*   Stream.tapError((error) => Effect.sync(() => errors.push(error))),
+*   Stream.catch(() => Stream.make(999))
+* )
+*
+* const program = Effect.gen(function*() {
+*   const values = yield* Stream.runCollect(stream)
+*   values // => [1, 2, 999]
+* })
+*
+* await Effect.runPromise(program)
+* errors // => ["boom"]
+* ```
+*
+* @stability stable
+* @category error handling
+* @since 2.0.0
+*/
+const tapError = /*#__PURE__*/ dual(2, (self, f) => self.channel.pipe(tapError$1(f), fromChannel));
+/**
+* Transforms the errors emitted by this stream using `f`.
+*
+* **Details**
+*
+* Maps every typed error in the cause, preserving defects, interrupts and
+* reason order. Unlike typed recovery, mapping does not convert errors to defects.
+*
+* **Example** (Mapping stream errors)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const result = yield* Stream.fail("bad").pipe(
+*     Stream.mapError((error) => `mapped: ${error}`),
+*     Stream.catch((error) => Stream.make(`recovered from ${error}`)),
+*     Stream.runCollect
+*   )
+*   result // => [ 'recovered from mapped: bad' ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category error handling
+* @since 2.0.0
+*/
+const mapError = /*#__PURE__*/ dual(2, (self, f) => fromChannel(mapError$1(self.channel, f)));
+/**
+* Retries the stream according to the given schedule when it fails.
+*
+* **Details**
+*
+* This retries the entire stream, so will re-execute all of the stream's
+* acquire operations.
+*
+* The schedule is reset as soon as the first element passes through the
+* stream again.
+*
+* **Gotchas**
+*
+* Defects take precedence over typed errors. A failure whose cause contains a
+* defect is not retried and is propagated with every typed error converted to a
+* defect. A typed error alongside an interruption is retried.
+*
+* **Example** (Retrying stream failures)
+*
+* ```ts import.meta.vitest
+* import { Effect, Schedule, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const values = yield* Stream.make(1).pipe(
+*     Stream.concat(Stream.fail("boom")),
+*     Stream.retry(Schedule.recurs(1)),
+*     Stream.take(2),
+*     Stream.runCollect
+*   )
+*
+*   values // => [ 1, 1 ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category error handling
+* @since 2.0.0
+*/
+const retry = /*#__PURE__*/ dual(2, (self, policy) => fromChannel(retry$1(self.channel, policy)));
+/**
+* Takes the first `n` elements from this stream.
+*
+* **Details**
+*
+* Finite fractional values of `n` are rounded down. `NaN` and non-positive
+* values return `Stream.empty` without evaluating the source stream.
+*
+* **Example** (Taking values from the left)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const values = yield* Stream.make(1, 2, 3, 4, 5).pipe(
+*     Stream.take(3),
+*     Stream.runCollect
+*   )
+*   values // => [ 1, 2, 3 ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category filtering
+* @since 2.0.0
+*/
+const take = /*#__PURE__*/ dual(2, (self, n) => {
+	const count = normalize(n);
+	return count === 0 ? empty : takeUntil(self, (_, i) => i === count - 1);
+});
+/**
+* Takes elements until the predicate matches.
+*
+* **Details**
+*
+* When `excludeLast` is `true`, the matching element is dropped.
+*
+* **Example** (Taking until a predicate matches)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.range(1, 5)
+*
+* const program = Effect.gen(function*() {
+*   const inclusive = yield* stream.pipe(
+*     Stream.takeUntil((n) => n % 3 === 0),
+*     Stream.runCollect
+*   )
+*   inclusive // => [ 1, 2, 3 ]
+*
+*   const exclusive = yield* stream.pipe(
+*     Stream.takeUntil((n) => n % 3 === 0, { excludeLast: true }),
+*     Stream.runCollect
+*   )
+*   exclusive // => [ 1, 2 ]
+* })
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category filtering
+* @since 2.0.0
+*/
+const takeUntil = /*#__PURE__*/ dual((args) => isStream(args[0]), (self, predicate, options) => transformPull(self, (pull, _scope) => sync(() => {
+	let i = 0;
+	let done$6 = false;
+	return flatMap$2(suspend$2(() => done$6 ? done() : pull), (chunk) => {
+		const index = chunk.findIndex((a) => predicate(a, i++));
+		if (index >= 0) {
+			done$6 = true;
+			const arr = chunk.slice(0, options?.excludeLast ? index : index + 1);
+			return isReadonlyArrayNonEmpty(arr) ? succeed$2(arr) : done();
+		}
+		return succeed$2(chunk);
+	});
+})));
+/**
+* Drops the first `n` elements from this stream.
+*
+* **Details**
+*
+* Finite fractional values of `n` are rounded down. `NaN` and non-positive
+* values return the source stream unchanged.
+*
+* **Example** (Dropping values from the left)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.make(1, 2, 3, 4, 5)
+* const result = Stream.drop(stream, 2)
+*
+* const program = Effect.gen(function*() {
+*   const items = yield* Stream.runCollect(result)
+*   items // => [ 3, 4, 5 ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category filtering
+* @since 2.0.0
+*/
+const drop = /*#__PURE__*/ dual(2, (self, n) => {
+	const count = normalize(n);
+	if (count === 0) return self;
+	return transformPull(self, (pull, _scope) => sync(() => {
+		let dropped = 0;
+		const pump = pull.pipe(flatMap$2((chunk) => {
+			if (dropped >= count) return succeed$2(chunk);
+			dropped += chunk.length;
+			if (dropped <= count) return pump;
+			return succeed$2(chunk.slice(count - dropped));
+		}));
+		return pump;
+	}));
+});
+/**
+* Maps elements statefully, emitting zero or more outputs per input.
+*
+* **Example** (Statefully mapping stream values)
+*
+* ```ts import.meta.vitest
+* import { Console, Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const totals = yield* Stream.make(0, 1, 2, 3, 4, 5, 6).pipe(
+*     Stream.mapAccum(() => 0, (total, n) => {
+*       const next = total + n
+*       return [next, [next]] as const
+*     }),
+*     Stream.runCollect
+*   )
+*
+*   totals // => [0, 1, 3, 6, 10, 15, 21]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category mapping
+* @since 2.0.0
+*/
+const mapAccum = /*#__PURE__*/ dual((args) => isStream(args[0]), (self, initial, f, options) => fromChannel(mapAccum$1(self.channel, initial, (state, arr) => {
+	const acc = empty$2();
+	for (let index = 0; index < arr.length; index++) {
+		const [newState, values] = f(state, arr[index]);
+		state = newState;
+		for (let i = 0; i < values.length; i++) acc.push(values[i]);
+	}
+	return [state, isArrayNonEmpty(acc) ? of(acc) : emptyArr];
+}, options?.onHalt ? { onHalt(state) {
+	const arr = options.onHalt(state);
+	return isReadonlyArrayNonEmpty(arr) ? of(arr) : emptyArr;
+} } : void 0)));
+const emptyArr = /*#__PURE__*/ empty$2();
+/**
+* Applies a sink transducer to the stream and emits each sink result.
+*
+* **Example** (Transducing with a sink)
+*
+* ```ts import.meta.vitest
+* import { Effect, Sink, Stream } from "effect"
+*
+* const program = Effect.gen(function* () {
+*   const result = yield* Stream.make(1, 2, 3, 4).pipe(
+*     Stream.transduce(Sink.take(2)),
+*     Stream.runCollect
+*   )
+*
+*   result // => [ [ 1, 2 ], [ 3, 4 ], [] ]
+* })
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category aggregation
+* @since 2.0.0
+*/
+const transduce = /*#__PURE__*/ dual(2, (self, sink) => transformPull(self, (upstream, scope) => sync(() => {
+	let done$3;
+	let leftover;
+	const upstreamWithLeftover = suspend$2(() => {
+		if (leftover !== void 0) {
+			const chunk = leftover;
+			leftover = void 0;
+			return succeed$2(chunk);
+		}
+		return upstream;
+	}).pipe(catch_((error) => {
+		done$3 = fail$3(error);
+		return done();
+	}));
+	const pull = map$3(suspend$2(() => sink.transform(upstreamWithLeftover, scope)), ([value, leftover_]) => {
+		leftover = leftover_;
+		return of(value);
+	});
+	return suspend$2(() => done$3 ? done$3 : pull);
+})));
+/**
+* Pipes this stream through a channel that consumes and emits chunked elements.
+*
+* **Details**
+*
+* The channel receives `NonEmptyReadonlyArray` chunks and can transform both the
+* output elements and error type.
+*
+* **Example** (Piping through a channel)
+*
+* ```ts import.meta.vitest
+* import { Array, Channel, Effect, Stream } from "effect"
+*
+* type NumberChunk = readonly [number, ...Array<number>]
+*
+* const doubleChunks = Channel.identity<NumberChunk, never, unknown>().pipe(
+*   Channel.map((chunk) => Array.map(chunk, (n) => n * 2))
+* )
+*
+* const program = Effect.gen(function*() {
+*   const result = yield* Stream.fromArray([1, 2, 3]).pipe(
+*     Stream.rechunk(2),
+*     Stream.pipeThroughChannel(doubleChunks),
+*     Stream.runCollect
+*   )
+*   result // => [ 2, 4, 6 ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const pipeThroughChannel = /*#__PURE__*/ dual(2, (self, channel) => fromChannel(pipeTo(self.channel, channel)));
+/**
+* Decodes Uint8Array chunks into strings using TextDecoder with an optional encoding.
+*
+* **Example** (Decoding Uint8Array chunks into strings using TextDecoder with an optional encoding)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const encoder = new TextEncoder()
+* const stream = Stream.make(
+*   encoder.encode("Hello"),
+*   encoder.encode(" World")
+* )
+*
+* const program = Effect.gen(function*() {
+*   const decoded = yield* stream.pipe(
+*     Stream.decodeText,
+*     Stream.runCollect
+*   )
+*   decoded // => [ 'Hello', ' World' ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category text
+* @since 2.0.0
+*/
+const decodeText = /*#__PURE__*/ dual((args) => isStream(args[0]), (self, options) => self.channel.pipe(pipeTo(decodeText$1(options?.encoding)), fromChannel));
+/**
+* Encodes a stream of strings into UTF-8 `Uint8Array` chunks.
+*
+* **Example** (Encoding a stream of strings into UTF-8 Uint8Array chunks)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.make("Hello", " ", "World")
+* const program = Effect.gen(function*() {
+*   const encoded = Stream.encodeText(stream)
+*   const chunks = yield* Stream.runCollect(encoded)
+*   const bytes = chunks.map((chunk) => [...chunk])
+*   bytes // => [ [ 72, 101, 108, 108, 111 ], [ 32 ], [ 87, 111, 114, 108, 100 ] ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category text
+* @since 2.0.0
+*/
+const encodeText = (self) => suspend(() => {
+	const encoder = new TextEncoder();
+	return map(self, (chunk) => encoder.encode(chunk));
+});
+/**
+* Splits a stream of strings into lines, handling `\n`, `\r`, and `\r\n` delimiters across chunks.
+*
+* **Example** (Splitting streamed text into lines)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* await Effect.runPromise(Effect.gen(function* () {
+*   const lines = yield* Stream.runCollect(
+*     Stream.make("a\nb\r\n", "c\n").pipe(Stream.splitLines)
+*   )
+*   lines // => [ 'a', 'b', 'c' ]
+* }))
+* ```
+*
+* @stability stable
+* @category text
+* @since 2.0.0
+*/
+const splitLines = (self) => self.channel.pipe(pipeTo(splitLines$1()), fromChannel);
+/**
+* Interrupts the evaluation of this stream when the provided effect
+* completes. The given effect will be forked as part of this stream, and its
+* success will be discarded. This combinator will also interrupt any
+* in-progress element being pulled from upstream.
+*
+* **Details**
+*
+* If the effect completes with a failure before the stream completes, the
+* returned stream will emit that failure.
+*
+* **Example** (Interrupting when an effect completes)
+*
+* ```ts import.meta.vitest
+* import { Deferred, Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const interrupt = yield* Deferred.make<void>()
+*   const stream = Stream.make(1, 2, 3).pipe(
+*     Stream.tap((value) =>
+*       value === 2
+*         ? Deferred.succeed(interrupt, void 0)
+*         : Effect.void
+*     ),
+*     Stream.interruptWhen(Deferred.await(interrupt))
+*   )
+*
+*   const result = yield* Stream.runCollect(stream)
+*   result // => [ 1 ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category interruption
+* @since 2.0.0
+*/
+const interruptWhen = /*#__PURE__*/ dual(2, (self, effect) => fromChannel(interruptWhen$1(self.channel, effect)));
+/**
+* Executes the provided finalizer after this stream's finalizers run.
+*
+* **Example** (Ensuring finalization)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const events: Array<string> = []
+* const stream = Stream.fromArray([1, 2]).pipe(
+*   Stream.ensuring(Effect.sync(() => events.push("cleanup")))
+* )
+*
+* const program = Effect.gen(function*() {
+*   const collected = yield* Stream.runCollect(stream)
+*   collected // => [1, 2]
+* })
+*
+* await Effect.runPromise(program)
+* events // => ["cleanup"]
+* ```
+*
+* @stability stable
+* @category resource management
+* @since 2.0.0
+*/
+const ensuring = /*#__PURE__*/ dual(2, (self, finalizer) => fromChannel(ensuring$1(self.channel, finalizer)));
+/**
+* Provides multiple services to the stream using a context.
+*
+* **Example** (Providing multiple services to the stream using a context)
+*
+* ```ts import.meta.vitest
+* import { Context, Effect, Stream } from "effect"
+*
+* class Config extends Context.Service<Config, { readonly prefix: string }>()("Config") {}
+* class Greeter extends Context.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
+*
+* const context = Context.make(Config, { prefix: "Hello" }).pipe(
+*   Context.add(Greeter, { greet: (name: string) => `${name}!` })
+* )
+*
+* const stream = Stream.fromEffect(
+*   Effect.gen(function*() {
+*     const config = yield* Effect.service(Config)
+*     const greeter = yield* Effect.service(Greeter)
+*     return greeter.greet(config.prefix)
+*   })
+* )
+*
+* const program = Effect.gen(function*() {
+*   const result = yield* Stream.runCollect(Stream.provideContext(stream, context))
+*   result // => [ 'Hello!' ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category providing services
+* @since 2.0.0
+*/
+const provideContext = /*#__PURE__*/ dual(2, (self, context) => fromChannel(provideContext$1(self.channel, context)));
+/**
+* Provides the stream with a single required service, eliminating that
+* requirement from its environment.
+*
+* **Example** (Providing a stream service)
+*
+* ```ts import.meta.vitest
+* import { Context, Effect, Stream } from "effect"
+*
+* class Greeter extends Context.Service<Greeter, {
+*   greet: (name: string) => string
+* }>()("Greeter") {}
+*
+* const stream = Stream.fromEffect(
+*   Effect.service(Greeter).pipe(
+*     Effect.map((greeter) => greeter.greet("Ada"))
+*   )
+* )
+*
+* const program = Effect.gen(function*() {
+*   const collected = yield* Stream.runCollect(
+*     stream.pipe(
+*       Stream.provideService(Greeter, {
+*         greet: (name) => `Hello, ${name}`
+*       })
+*     )
+*   )
+*   collected // => [ 'Hello, Ada' ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category providing services
+* @since 2.0.0
+*/
+const provideService = /*#__PURE__*/ dual(3, (self, key, service) => fromChannel(provideService$1(self.channel, key, service)));
+/**
+* Runs a stream with a sink and returns the sink result.
+*
+* **Example** (Running a stream with a sink)
+*
+* ```ts import.meta.vitest
+* import { Effect, Sink, Stream } from "effect"
+*
+* const program = Stream.run(Stream.make(1, 2, 3), Sink.sum)
+*
+* await Effect.runPromise(program) // => 6
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 2.0.0
+*/
+const run = /*#__PURE__*/ dual(2, (self, sink) => scopedWith((scope) => toPullScoped(self.channel, scope).pipe(flatMap$2((upstream) => runSink(sink, upstream, scope)), map$3(([a]) => a))));
+/**
+* Runs `sink` against `upstream`. Upstream failures bypass the sink's error
+* handlers and are restored once the sink has exited.
+*/
+const runSink = (sink, upstream, scope) => restoreUpstreamFailure(sink.transform(upstreamFailureToDefect(upstream), scope));
+/**
+* Runs the stream and collects all elements into an array.
+*
+* **Example** (Collecting stream values)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.make(1, 2, 3, 4, 5)
+*
+* const program = Effect.gen(function*() {
+*   const collected = yield* Stream.runCollect(stream)
+*   collected // => [ 1, 2, 3, 4, 5 ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 2.0.0
+*/
+const runCollect = (self) => runFold$1(self.channel, () => [], (acc, chunk) => {
+	for (let i = 0; i < chunk.length; i++) acc.push(chunk[i]);
+	return acc;
+});
+/**
+* Runs the stream and folds elements using a pure reducer.
+*
+* **Example** (Folding stream values)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const total = yield* Stream.runFold(
+*     Stream.make(1, 2, 3),
+*     () => 0,
+*     (acc, n) => acc + n
+*   )
+*   total // => 6
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 2.0.0
+*/
+const runFold = /*#__PURE__*/ dual(3, (self, initial, f) => runFold$1(self.channel, initial, (acc, arr) => {
+	for (let i = 0; i < arr.length; i++) acc = f(acc, arr[i]);
+	return acc;
+}));
+/**
+* Runs the stream and folds elements using an effectful reducer.
+*
+* **When to use**
+*
+* Use when reducing stream elements needs Effects, services, or failures in the
+* reducer.
+*
+* **Example** (Effectfully folding stream values)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const total = yield* Stream.runFoldEffect(
+*     Stream.make(1, 2, 3),
+*     () => 0,
+*     (acc, n) => Effect.succeed(acc + n)
+*   )
+*   total // => 6
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 2.0.0
+*/
+const runFoldEffect = /*#__PURE__*/ dual(3, (self, initial, f) => runFoldEffect$1(self.channel, initial, (acc, arr) => {
+	let i = 0;
+	let s = acc;
+	return map$3(whileLoop({
+		while: () => i < arr.length,
+		body: () => f(s, arr[i]),
+		step(z) {
+			s = z;
+			i++;
+		}
+	}), () => s);
+}));
+/**
+* Runs the provided effectful callback for each element of the stream.
+*
+* **Example** (Running an effect for each value)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.make(1, 2, 3)
+* const values: Array<string> = []
+*
+* const program = Effect.gen(function*() {
+*   yield* Stream.runForEach(stream, (n) => Effect.sync(() => values.push(`Processing: ${n}`)))
+* })
+*
+* await Effect.runPromise(program)
+* values // => ["Processing: 1", "Processing: 2", "Processing: 3"]
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 2.0.0
+*/
+const runForEach = /*#__PURE__*/ dual(2, (self, f) => runForEach$1(self.channel, (arr) => {
+	let i = 0;
+	return whileLoop({
+		while: () => i < arr.length,
+		body: () => f(arr[i++]),
+		step: constVoid
+	});
+}));
+/**
+* Consumes the stream in chunks, passing each non-empty array to the callback.
+*
+* **Example** (Consuming stream chunks)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.make(1, 2, 3, 4, 5)
+* const chunks: Array<string> = []
+* const program = Effect.gen(function*() {
+*   yield* Stream.runForEachArray(
+*     stream,
+*     (chunk) => Effect.sync(() => chunks.push(chunk.join(", ")))
+*   )
+* })
+*
+* await Effect.runPromise(program)
+* chunks // => ["1, 2, 3, 4, 5"]
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 4.0.0
+*/
+const runForEachArray = /*#__PURE__*/ dual(2, (self, f) => runForEach$1(self.channel, f));
+/**
+* Runs the stream for its effects, discarding emitted elements.
+*
+* **Example** (Draining a stream run)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const values: Array<number> = []
+* const program = Effect.gen(function*() {
+*   const stream = Stream.make(1, 2, 3).pipe(
+*     Stream.mapEffect((n) => Effect.sync(() => values.push(n)))
+*   )
+*
+*   yield* Stream.runDrain(stream)
+* })
+*
+* await Effect.runPromise(program)
+* values // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 2.0.0
+*/
+const runDrain = (self) => runDrain$1(self.channel);
+/**
+* Concatenates all emitted strings into a single string.
+*
+* **Example** (Joining strings from a stream)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.make("Hello", " ", "World", "!")
+* const program = Effect.gen(function*() {
+*   const text = yield* Stream.mkString(stream)
+*   text // => "Hello World!"
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 2.0.0
+*/
+const mkString = (self) => runFold$1(self.channel, () => "", (acc, chunk) => acc + chunk.join(""));
+/**
+* Concatenates the stream's `Uint8Array` chunks into a single `ArrayBuffer`.
+*
+* **Gotchas**
+*
+* This materializes the full content in memory. The source stream must not
+* reuse or mutate emitted buffers, which are retained until collection completes.
+*
+* **Example** (Joining byte chunks into an ArrayBuffer)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const program = Stream.make(
+*   new Uint8Array([1, 2]),
+*   new Uint8Array([3, 4])
+* ).pipe(
+*   Stream.mkArrayBuffer,
+*   Effect.map((buffer) => [...new Uint8Array(buffer)])
+* )
+*
+* await Effect.runPromise(program) // => [1, 2, 3, 4]
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 4.0.0
+*/
+const mkArrayBuffer = (self) => map$3(mkUint8Array$1(self.channel), (bytes) => bytes.buffer);
+/**
+* Concatenates the stream's `Uint8Array` chunks into a single `Uint8Array`.
+*
+* **Gotchas**
+*
+* This materializes the full content in memory. The source stream must not
+* reuse or mutate emitted buffers, which are retained until collection completes.
+*
+* **Example** (Joining Uint8Array chunks)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.make(new Uint8Array([1, 2]), new Uint8Array([3, 4]))
+* const program = Effect.gen(function*() {
+*   const bytes = yield* Stream.mkUint8Array(stream)
+*   const values = Array.from(bytes) // => [1, 2, 3, 4]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 4.0.0
+*/
+const mkUint8Array = (self) => mkUint8Array$1(self.channel);
+/**
+* Converts the stream to a `ReadableStream` using the provided services.
+*
+* **When to use**
+*
+* Use when bridging to Web Streams and you already have the `Context` required
+* to run the stream outside an `Effect`.
+*
+* **Details**
+*
+* 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
+* import { Context, Stream } from "effect"
+*
+* const stream = Stream.make(1, 2, 3, 4, 5)
+* const readableStream = Stream.toReadableStreamWith(stream, Context.empty())
+* const values = await globalThis.Array.fromAsync(readableStream)
+* values // => [ 1, 2, 3, 4, 5 ]
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 4.0.0
+*/
+const toReadableStreamWith = /*#__PURE__*/ dual((args) => isStream(args[0]), (self, context, options) => {
+	let currentResolve = void 0;
+	let fiber = void 0;
+	let cancelled = false;
+	const latch = makeUnsafe(false);
+	const signal = options?.signal;
+	const onAbort = () => fiber.interruptUnsafe();
+	return new ReadableStream({
+		start(controller) {
+			fiber = runFork(provideContext$2(runForEach$1(transformPull$1(self.channel, (pull) => succeed$2(latch.whenOpen(pull))), (chunk) => sync(() => {
+				latch.closeUnsafe();
+				for (let i = 0; i < chunk.length; i++) controller.enqueue(chunk[i]);
+				currentResolve();
+				currentResolve = void 0;
+			})), context));
+			fiber.addObserver((exit) => {
+				signal?.removeEventListener("abort", onAbort);
+				if (cancelled) return;
+				if (exit._tag === "Failure" && signal?.aborted !== true) controller.error(squash(exit.cause));
+				else controller.close();
+			});
+			if (signal !== void 0 && fiber.pollUnsafe() === void 0) {
+				if (signal.aborted) onAbort();
+				else signal.addEventListener("abort", onAbort, { once: true });
+			}
+		},
+		pull() {
+			return new Promise((resolve) => {
+				currentResolve = resolve;
+				latch.openUnsafe();
+			});
+		},
+		cancel() {
+			if (!fiber) return;
+			cancelled = true;
+			return runPromise(asVoid(interrupt(fiber)));
+		}
+	}, options?.strategy);
+});
+/**
+* Creates an Effect that builds a ReadableStream from the stream.
+*
+* **When to use**
+*
+* Use when bridging to Web Streams from inside an `Effect` so the required
+* services can be captured from the current context.
+*
+* **Details**
+*
+* See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+*
+* **Example** (Creating a ReadableStream effect)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.make(1, 2, 3, 4, 5)
+*
+* const effect = Effect.gen(function*() {
+*   const readableStream = yield* Stream.toReadableStreamEffect(stream)
+*   readableStream instanceof ReadableStream // => true
+* })
+*
+* await Effect.runPromise(effect)
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 2.0.0
+*/
+const toReadableStreamEffect = /*#__PURE__*/ dual((args) => isStream(args[0]), (self, options) => map$3(context(), (context) => toReadableStreamWith(self, context, options)));
+export { toReadableStreamEffect as $, merge as A, runCollect as B, interruptWhen as C, mapAccum as D, map as E, pipeThroughChannel as F, runForEachArray as G, runFold as H, provideContext as I, suspend as J, splitLines as K, provideService as L, mkString as M, mkUint8Array as N, mapEffect as O, paginate as P, tick as Q, retry as R, fromReadableStream as S, make as T, runFoldEffect as U, runDrain as V, runForEach as W, tap as X, take as Y, tapError as Z, fromChannel as _, interruptAll as _t, die as a, mapDone as at, fromPull as b, runIn as bt, drop as c, toTransform as ct, ensuring as d, make$1 as dt, toReadableStreamWith as et, fail as f, makeUnsafe as ft, fromAsyncIterable as g, interrupt as gt, fromArray as h, getCurrent as ht, decodeText as i, fromTransform as it, mkArrayBuffer as j, mapError as k, empty as l, unwrap$1 as lt, flatMap as m, await_ as mt, callback as n, unwrap as nt, drain as o, mapError$1 as ot, filter as p, open as pt, succeed as q, concat as r, fromPull$1 as rt, drainFork as s, mkUint8Array$1 as st, buffer as t, transduce as tt, encodeText as u, isOpen as ut, fromEffect as v, interruptAs as vt, isStream as w, fromQueue as x, fromIterable as y, join as yt, run as z };