effect 3.5.8 → 3.6.0

package/src/Stream.ts

@@ -373,6 +373,46 @@ export const asyncEffect: <A, E = never, R = never>(
   } | undefined
 ) => Stream<A, E, R> = internal.asyncEffect
 
+/**
+ * Creates a stream from an external push-based resource.
+ *
+ * You can use the `emit` helper to emit values to the stream. The `emit` helper
+ * returns a boolean indicating whether the value was emitted or not.
+ *
+ * You can also use the `emit` helper to signal the end of the stream by
+ * using apis such as `emit.end` or `emit.fail`.
+ *
+ * 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
+ * import { Effect, Stream } from "effect"
+ *
+ * Stream.asyncPush<string>((emit) =>
+ *   Effect.acquireRelease(
+ *     Effect.gen(function*() {
+ *       yield* Effect.log("subscribing")
+ *       return setInterval(() => emit.single("tick"), 1000)
+ *     }),
+ *     (handle) =>
+ *       Effect.gen(function*() {
+ *         yield* Effect.log("unsubscribing")
+ *         clearInterval(handle)
+ *       })
+ *   ), { bufferSize: 16, strategy: "dropping" })
+ *
+ * @since 3.6.0
+ * @category constructors
+ */
+export const asyncPush: <A, E = never, R = never>(
+  register: (emit: Emit.EmitOpsPush<E, A>) => Effect.Effect<unknown, never, R | Scope.Scope>,
+  options?: { readonly bufferSize: "unbounded" } | {
+    readonly bufferSize?: number | undefined
+    readonly strategy?: "dropping" | "sliding" | undefined
+  } | undefined
+) => Stream<A, E, Exclude<R, Scope.Scope>> = internal.asyncPush
+
 /**
  * Creates a stream from an asynchronous callback that can be called multiple
  * times. The registration of the callback itself returns an a scoped
@@ -2887,6 +2927,38 @@ export const mkString: <E, R>(self: Stream<string, E, R>) => Effect.Effect<strin
  */
 export const never: Stream<never> = internal.never
 
+/**
+ * Adds an effect to be executed at the end of the stream.
+ *
+ * @example
+ * import { Console, Effect, Stream } from "effect"
+ *
+ * const stream = Stream.make(1, 2, 3).pipe(
+ *   Stream.map((n) => n * 2),
+ *   Stream.tap((n) => Console.log(`after mapping: ${n}`)),
+ *   Stream.onEnd(Console.log("Stream ended"))
+ * )
+ *
+ * Effect.runPromise(Stream.runCollect(stream)).then(console.log)
+ * // after mapping: 2
+ * // after mapping: 4
+ * // after mapping: 6
+ * // Stream ended
+ * // { _id: 'Chunk', values: [ 2, 4, 6 ] }
+ *
+ * @since 3.6.0
+ * @category sequencing
+ */
+export const onEnd: {
+  <_, E2, R2>(
+    effect: Effect.Effect<_, E2, R2>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <A, E, R, _, E2, R2>(
+    self: Stream<A, E, R>,
+    effect: Effect.Effect<_, E2, R2>
+  ): Stream<A, E | E2, R | R2>
+} = internal.onEnd
+
 /**
  * Runs the specified effect if this stream fails, providing the error to the
  * effect if it exists.
@@ -2918,6 +2990,38 @@ export const onDone: {
   <A, E, R, X, R2>(self: Stream<A, E, R>, cleanup: () => Effect.Effect<X, never, R2>): Stream<A, E, R | R2>
 } = internal.onDone
 
+/**
+ * Adds an effect to be executed at the start of the stream.
+ *
+ * @example
+ * import { Console, Effect, Stream } from "effect"
+ *
+ * const stream = Stream.make(1, 2, 3).pipe(
+ *   Stream.onStart(Console.log("Stream started")),
+ *   Stream.map((n) => n * 2),
+ *   Stream.tap((n) => Console.log(`after mapping: ${n}`))
+ * )
+ *
+ * // Effect.runPromise(Stream.runCollect(stream)).then(console.log)
+ * // Stream started
+ * // after mapping: 2
+ * // after mapping: 4
+ * // after mapping: 6
+ * // { _id: 'Chunk', values: [ 2, 4, 6 ] }
+ *
+ * @since 3.6.0
+ * @category sequencing
+ */
+export const onStart: {
+  <_, E2, R2>(
+    effect: Effect.Effect<_, E2, R2>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <A, E, R, _, E2, R2>(
+    self: Stream<A, E, R>,
+    effect: Effect.Effect<_, E2, R2>
+  ): Stream<A, E | E2, R | R2>
+} = internal.onStart
+
 /**
  * Translates any failure into a stream termination, making the stream
  * infallible and all failures unchecked.
@@ -5676,11 +5780,11 @@ export const zipWithPreviousAndNext: <A, E, R>(
 export const zipWithIndex: <A, E, R>(self: Stream<A, E, R>) => Stream<[A, number], E, R> = internal.zipWithIndex
 
 // -------------------------------------------------------------------------------------
-// Do notation
+// do notation
 // -------------------------------------------------------------------------------------
 
 /**
- * The "do simulation" in allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+ * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
  *
  * Here's how the do simulation works:
  *
@@ -5711,7 +5815,7 @@ export const zipWithIndex: <A, E, R>(self: Stream<A, E, R>) => Stream<[A, number
 export const Do: Stream<{}> = internal.Do
 
 /**
- * The "do simulation" in allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+ * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
  *
  * Here's how the do simulation works:
  *
@@ -5787,7 +5891,7 @@ export const bindEffect: {
 } = _groupBy.bindEffect
 
 /**
- * The "do simulation" in allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+ * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
  *
  * Here's how the do simulation works:
  *
@@ -5834,7 +5938,7 @@ const let_: {
 
 export {
   /**
-   * The "do simulation" in allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
+   * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`.
    *
    * Here's how the do simulation works:
    *
@@ -5923,5 +6027,6 @@ export const fromEventListener: <A = unknown>(
     readonly capture?: boolean
     readonly passive?: boolean
     readonly once?: boolean
+    readonly bufferSize?: number | "unbounded" | undefined
   } | undefined
 ) => Stream<A> = internal.fromEventListener

package/src/StreamEmit.ts

@@ -81,3 +81,56 @@ export interface EmitOps<in R, in E, in A, out B> {
    */
   single(value: A): Promise<B>
 }
+
+/**
+ * @since 3.6.0
+ * @category models
+ */
+export interface EmitOpsPush<in E, in A> {
+  /**
+   * Emits a chunk containing the specified values.
+   */
+  chunk(chunk: Chunk.Chunk<A>): boolean
+
+  /**
+   * Emits a chunk containing the specified values.
+   */
+  array(chunk: ReadonlyArray<A>): boolean
+
+  /**
+   * Terminates with a cause that dies with the specified defect.
+   */
+  die<Err>(defect: Err): void
+
+  /**
+   * Terminates with a cause that dies with a `Throwable` with the specified
+   * message.
+   */
+  dieMessage(message: string): void
+
+  /**
+   * Either emits the specified value if this `Exit` is a `Success` or else
+   * terminates with the specified cause if this `Exit` is a `Failure`.
+   */
+  done(exit: Exit.Exit<A, E>): void
+
+  /**
+   * Terminates with an end of stream signal.
+   */
+  end(): void
+
+  /**
+   * Terminates with the specified error.
+   */
+  fail(error: E): void
+
+  /**
+   * Terminates the stream with the specified cause.
+   */
+  halt(cause: Cause.Cause<E>): void
+
+  /**
+   * Emits a chunk containing the specified value.
+   */
+  single(value: A): boolean
+}

package/src/Struct.ts

@@ -179,3 +179,25 @@ export const evolve: {
 export const get =
   <K extends PropertyKey>(key: K) => <S extends { [P in K]?: any }>(s: S): MatchRecord<S, S[K] | undefined, S[K]> =>
     s[key]
+
+/**
+ * Retrieves the object keys that are strings in a typed manner
+ *
+ * @example
+ * import { Struct } from "effect"
+ *
+ * const symbol: unique symbol = Symbol()
+ *
+ * const value = {
+ *   a: 1,
+ *   b: 2,
+ *   [symbol]: 3
+ * }
+ *
+ * const keys: Array<"a" | "b"> = Struct.keys(value)
+ *
+ * assert.deepStrictEqual(keys, ["a", "b"])
+ *
+ * @since 3.6.0
+ */
+export const keys = <T extends {}>(o: T): Array<(keyof T) & string> => Object.keys(o) as Array<(keyof T) & string>

package/src/index.ts

@@ -187,6 +187,11 @@ export * as Cron from "./Cron.js"
  */
 export * as Data from "./Data.js"
 
+/**
+ * @since 3.6.0
+ */
+export * as DateTime from "./DateTime.js"
+
 /**
  * @since 2.0.0
  */

package/src/internal/configProvider.ts

@@ -68,7 +68,7 @@ export const makeFlat = (
       path: ReadonlyArray<string>,
       config: Config.Config.Primitive<A>,
       split: boolean
-    ) => Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+    ) => Effect.Effect<Array<A>, ConfigError.ConfigError>
     readonly enumerateChildren: (
       path: ReadonlyArray<string>
     ) => Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError>
@@ -114,7 +114,7 @@ export const fromEnv = (
     path: ReadonlyArray<string>,
     primitive: Config.Config.Primitive<A>,
     split = true
-  ): Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError> => {
+  ): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
     const pathString = makePathString(path)
     const current = getEnv()
     const valueOpt = pathString in current ? Option.some(current[pathString]!) : Option.none()
@@ -165,7 +165,7 @@ export const fromMap = (
     path: ReadonlyArray<string>,
     primitive: Config.Config.Primitive<A>,
     split = true
-  ): Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError> => {
+  ): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
     const pathString = makePathString(path)
     const valueOpt = mapWithIndexSplit.has(pathString) ?
       Option.some(mapWithIndexSplit.get(pathString)!) :
@@ -240,20 +240,20 @@ const fromFlatLoop = <A>(
   prefix: ReadonlyArray<string>,
   config: Config.Config<A>,
   split: boolean
-): Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError> => {
+): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
   const op = config as _config.ConfigPrimitive
   switch (op._tag) {
     case OpCodes.OP_CONSTANT: {
-      return core.succeed(Arr.of(op.value)) as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      return core.succeed(Arr.of(op.value)) as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_DESCRIBED: {
       return core.suspend(
         () => fromFlatLoop(flat, prefix, op.config, split)
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_FAIL: {
       return core.fail(configError.MissingData(prefix, op.message)) as Effect.Effect<
-        ReadonlyArray<A>,
+        Array<A>,
         ConfigError.ConfigError
       >
     }
@@ -269,11 +269,11 @@ const fromFlatLoop = <A>(
           }
           return core.fail(error1)
         })
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_LAZY: {
       return core.suspend(() => fromFlatLoop(flat, prefix, op.config(), split)) as Effect.Effect<
-        ReadonlyArray<A>,
+        Array<A>,
         ConfigError.ConfigError
       >
     }
@@ -290,7 +290,7 @@ const fromFlatLoop = <A>(
             )
           )
         )
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_NESTED: {
       return core.suspend(() =>
@@ -300,7 +300,7 @@ const fromFlatLoop = <A>(
           op.config,
           split
         )
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_PRIMITIVE: {
       return pipe(
@@ -317,7 +317,7 @@ const fromFlatLoop = <A>(
             })
           )
         )
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_SEQUENCE: {
       return pipe(
@@ -330,7 +330,7 @@ const fromFlatLoop = <A>(
               if (indices.length === 0) {
                 return core.suspend(() =>
                   core.map(fromFlatLoop(flat, patchedPrefix, op.config, true), Arr.of)
-                ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+                ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
               }
               return pipe(
                 core.forEachSequential(
@@ -344,7 +344,7 @@ const fromFlatLoop = <A>(
                   }
                   return Arr.of(flattened)
                 })
-              ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+              ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
             })
           )
         )
@@ -382,7 +382,7 @@ const fromFlatLoop = <A>(
             )
           )
         )
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_ZIP_WITH: {
       return core.suspend(() =>
@@ -430,7 +430,7 @@ const fromFlatLoop = <A>(
             )
           )
         )
-      ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      ) as unknown as Effect.Effect<Array<A>, ConfigError.ConfigError>
     }
   }
 }
@@ -592,7 +592,7 @@ export const within = dual<
   return orElse(nest, () => self)
 })
 
-const splitPathString = (text: string, delim: string): ReadonlyArray<string> => {
+const splitPathString = (text: string, delim: string): Array<string> => {
   const split = text.split(new RegExp(`\\s*${regexp.escape(delim)}\\s*`))
   return split
 }
@@ -603,7 +603,7 @@ const parsePrimitive = <A>(
   primitive: Config.Config.Primitive<A>,
   delimiter: string,
   split: boolean
-): Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError> => {
+): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
   if (!split) {
     return pipe(
       primitive.parse(text),
@@ -620,11 +620,11 @@ const parsePrimitive = <A>(
   )
 }
 
-const transpose = <A>(array: ReadonlyArray<ReadonlyArray<A>>): ReadonlyArray<ReadonlyArray<A>> => {
+const transpose = <A>(array: ReadonlyArray<ReadonlyArray<A>>): Array<Array<A>> => {
   return Object.keys(array[0]).map((column) => array.map((row) => row[column as any]))
 }
 
-const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<ReadonlyArray<number>> =>
+const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<Array<number>> =>
   pipe(
     core.forEachSequential(quotedIndices, parseQuotedIndex),
     core.mapBoth({

package/src/internal/core.ts

@@ -1250,6 +1250,12 @@ export const tap = dual<
     ) => [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
       : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
+    <A, X, E1, R1>(
+      f: (a: NoInfer<A>) => Effect.Effect<X, E1, R1>,
+      options: { onlyEffect: true }
+    ): <E, R>(
+      self: Effect.Effect<A, E, R>
+    ) => Effect.Effect<A, E | E1, R | R1>
     <X>(
       f: NotFunction<X>
     ): <A, E, R>(
@@ -1257,6 +1263,12 @@ export const tap = dual<
     ) => [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
       : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
+    <X, E1, R1>(
+      f: Effect.Effect<X, E1, R1>,
+      options: { onlyEffect: true }
+    ): <A, E, R>(
+      self: Effect.Effect<A, E, R>
+    ) => Effect.Effect<A, E | E1, R | R1>
   },
   {
     <A, E, R, X>(
@@ -1265,25 +1277,38 @@ export const tap = dual<
     ): [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
       : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
+    <A, E, R, X, E1, R1>(
+      self: Effect.Effect<A, E, R>,
+      f: (a: NoInfer<A>) => Effect.Effect<X, E1, R1>,
+      options: { onlyEffect: true }
+    ): Effect.Effect<A, E | E1, R | R1>
     <A, E, R, X>(
       self: Effect.Effect<A, E, R>,
       f: NotFunction<X>
     ): [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
       : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
+    <A, E, R, X, E1, R1>(
+      self: Effect.Effect<A, E, R>,
+      f: Effect.Effect<X, E1, R1>,
+      options: { onlyEffect: true }
+    ): Effect.Effect<A, E | E1, R | R1>
   }
->(2, (self, f) =>
-  flatMap(self, (a) => {
-    const b = typeof f === "function" ? (f as any)(a) : f
-    if (isEffect(b)) {
-      return as(b, a)
-    } else if (isPromiseLike(b)) {
-      return async<any, Cause.UnknownException>((resume) => {
-        b.then((_) => resume(succeed(a)), (e) => resume(fail(new UnknownException(e))))
-      })
-    }
-    return succeed(a)
-  }))
+>(
+  (args) => args.length === 3 || args.length === 2 && !(isObject(args[1]) && "onlyEffect" in args[1]),
+  <A, E, R, X>(self: Effect.Effect<A, E, R>, f: X) =>
+    flatMap(self, (a) => {
+      const b = typeof f === "function" ? (f as any)(a) : f
+      if (isEffect(b)) {
+        return as(b, a)
+      } else if (isPromiseLike(b)) {
+        return async<any, Cause.UnknownException>((resume) => {
+          b.then((_) => resume(succeed(a)), (e) => resume(fail(new UnknownException(e))))
+        })
+      }
+      return succeed(a)
+    })
+)
 
 /* @internal */
 export const transplant = <A, E, R>(

package/src/internal/defaultServices.ts

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js"
 import type * as Chunk from "../Chunk.js"
 import type * as Clock from "../Clock.js"
 import type * as Config from "../Config.js"
@@ -133,6 +134,19 @@ export const nextIntBetween = (min: number, max: number): Effect.Effect<number>
 export const shuffle = <A>(elements: Iterable<A>): Effect.Effect<Chunk.Chunk<A>> =>
   randomWith((random) => random.shuffle(elements))
 
+/** @internal */
+export const choice = <Self extends Iterable<unknown>>(
+  elements: Self
+) => {
+  const array = Array.fromIterable(elements)
+  return core.map(
+    array.length === 0
+      ? core.fail(new core.NoSuchElementException("Cannot select a random element from an empty array"))
+      : randomWith((random) => random.nextIntBetween(0, array.length)),
+    (i) => array[i]
+  ) as any
+}
+
 // circular with Tracer
 
 /** @internal */

package/src/internal/metric/registry.ts

@@ -27,7 +27,7 @@ class MetricRegistryImpl implements MetricRegistry.MetricRegistry {
     MetricHook.MetricHook.Root
   >()
 
-  snapshot(): ReadonlyArray<MetricPair.MetricPair.Untyped> {
+  snapshot(): Array<MetricPair.MetricPair.Untyped> {
     const result: Array<MetricPair.MetricPair.Untyped> = []
     for (const [key, hook] of this.map) {
       result.push(metricPair.unsafeMake(key, hook.get()))

package/src/internal/metric.ts

@@ -525,9 +525,9 @@ export const zip = dual<
 )
 
 /** @internal */
-export const unsafeSnapshot = (): ReadonlyArray<MetricPair.MetricPair.Untyped> => globalMetricRegistry.snapshot()
+export const unsafeSnapshot = (): Array<MetricPair.MetricPair.Untyped> => globalMetricRegistry.snapshot()
 
 /** @internal */
-export const snapshot: Effect.Effect<ReadonlyArray<MetricPair.MetricPair.Untyped>> = core.sync(
+export const snapshot: Effect.Effect<Array<MetricPair.MetricPair.Untyped>> = core.sync(
   unsafeSnapshot
 )

package/src/internal/stream/emit.ts

@@ -4,6 +4,8 @@ import * as Effect from "../../Effect.js"
 import * as Exit from "../../Exit.js"
 import { pipe } from "../../Function.js"
 import * as Option from "../../Option.js"
+import type * as Queue from "../../Queue.js"
+import type * as Scheduler from "../../Scheduler.js"
 import type * as Emit from "../../StreamEmit.js"
 
 /** @internal */
@@ -44,3 +46,78 @@ export const make = <R, E, A, B>(
   }
   return Object.assign(emit, ops)
 }
+
+/** @internal */
+export const makePush = <E, A>(
+  queue: Queue.Queue<Array<A> | Exit.Exit<void, E>>,
+  scheduler: Scheduler.Scheduler
+): Emit.EmitOpsPush<E, A> => {
+  let finished = false
+  let buffer: Array<A> = []
+  let running = false
+  function array(items: ReadonlyArray<A>) {
+    if (finished) return false
+    if (items.length <= 50_000) {
+      buffer.push.apply(buffer, items as Array<A>)
+    } else {
+      for (let i = 0; i < items.length; i++) {
+        buffer.push(items[0])
+      }
+    }
+    if (!running) {
+      running = true
+      scheduler.scheduleTask(flush, 0)
+    }
+    return true
+  }
+  function flush() {
+    running = false
+    if (buffer.length > 0) {
+      queue.unsafeOffer(buffer)
+      buffer = []
+    }
+  }
+  function done(exit: Exit.Exit<A, E>) {
+    if (finished) return
+    finished = true
+    if (exit._tag === "Success") {
+      buffer.push(exit.value)
+    }
+    flush()
+    queue.unsafeOffer(exit._tag === "Success" ? Exit.void : exit)
+  }
+  return {
+    single(value: A) {
+      if (finished) return false
+      buffer.push(value)
+      if (!running) {
+        running = true
+        scheduler.scheduleTask(flush, 0)
+      }
+      return true
+    },
+    array,
+    chunk(chunk) {
+      return array(Chunk.toReadonlyArray(chunk))
+    },
+    done,
+    end() {
+      if (finished) return
+      finished = true
+      flush()
+      queue.unsafeOffer(Exit.void)
+    },
+    halt(cause: Cause.Cause<E>) {
+      return done(Exit.failCause(cause))
+    },
+    fail(error: E) {
+      return done(Exit.fail(error))
+    },
+    die<Err>(defect: Err): void {
+      return done(Exit.die(defect))
+    },
+    dieMessage(message: string): void {
+      return done(Exit.die(new Error(message)))
+    }
+  }
+}