@typed/fx 1.12.6 → 1.14.0

package/src/observe.ts

@@ -1,30 +1,41 @@
+import * as Cause from '@effect/io/Cause'
+import * as Deferred from '@effect/io/Deferred'
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
 import type { Scope } from '@effect/io/Scope'
 
 import type { Fx } from './Fx.js'
 import { Sink } from './Fx.js'
-import type { Cause } from './externals.js'
-import { Deferred, Effect, Fiber } from './externals.js'
 
 export function observe<R, E, A, R2, E2>(
   fx: Fx<R, E, A>,
   f: (a: A) => Effect.Effect<R2, E2, void>,
 ): Effect.Effect<R | R2 | Scope, E | E2, void> {
-  return Effect.gen(function* ($) {
-    const deferred = yield* $(Deferred.make<E | E2, void>())
+  return Effect.flatMap(Deferred.make<E | E2, void>(), (deferred) => {
     const error = (cause: Cause.Cause<E | E2>) => Deferred.failCause(deferred, cause)
     const end = () => Deferred.succeed(deferred, undefined)
 
-    const fiber = yield* $(
+    return Effect.flatMap(
       Effect.forkScoped(
         Effect.flatMap(fx.run(Sink((a: A) => Effect.catchAllCause(f(a), error), error)), end),
       ),
+      (fiber) => Effect.flatMap(Deferred.await(deferred), () => Fiber.interruptFork(fiber)),
     )
-
-    yield* $(Deferred.await(deferred))
-    yield* $(Fiber.interruptFork(fiber))
   })
 }
 
 export function drain<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R | Scope, E, void> {
-  return observe(fx, () => Effect.unit())
+  return observe(fx, Effect.unit as any)
+}
+
+export function forkScoped<R, E, A>(
+  fx: Fx<R, E, A>,
+): Effect.Effect<R | Scope, never, Fiber.RuntimeFiber<E, void>> {
+  return Effect.forkScoped(drain(fx))
+}
+
+export function fork<R, E, A>(
+  fx: Fx<R, E, A>,
+): Effect.Effect<R | Scope, never, Fiber.RuntimeFiber<E, void>> {
+  return Effect.fork(drain(fx))
 }

package/src/onExit.ts

@@ -0,0 +1,13 @@
+import * as Effect from '@effect/io/Effect'
+import * as Exit from '@effect/io/Exit'
+
+import { Fx } from './Fx.js'
+
+export function onExit<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (exit: Exit.Exit<E, void>) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E | E2, A> {
+  return Fx((sink) =>
+    Effect.onExit(fx.run(sink), (exit) => Effect.catchAllCause(f(exit), sink.error)),
+  )
+}

package/src/onInterrupt.ts

@@ -1,8 +1,8 @@
 import type { HashSet } from '@effect/data/HashSet'
+import * as Effect from '@effect/io/Effect'
 import type { FiberId } from '@effect/io/Fiber/Id'
 
 import { Fx } from './Fx.js'
-import { Effect } from './externals.js'
 
 export function onInterrupt<R, E, A, R2, E2, B>(
   fx: Fx<R, E, A>,

package/src/orElse.ts

@@ -0,0 +1,16 @@
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+
+import { Fx } from './Fx.js'
+import { observe } from './observe.js'
+
+export function orElse<R, E, A, R2, E2, B>(
+  self: Fx<R, E, A>,
+  that: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+): Fx<R | R2, E2, A | B> {
+  return Fx((sink) =>
+    Effect.catchAllCause(Effect.scoped(observe(self, sink.event)), (cause) =>
+      that(cause).run(sink),
+    ),
+  )
+}

package/src/promise.ts

@@ -1,5 +1,6 @@
+import * as Effect from '@effect/io/Effect'
+
 import type { Fx } from './Fx.js'
-import { Effect } from './externals.js'
 import { fromEffect } from './fromEffect.js'
 import { fromFxEffect } from './fromFxEffect.js'
 
@@ -25,14 +26,14 @@ export function tryCatchPromise<A, E>(
   f: () => Promise<A>,
   g: (error: unknown) => E,
 ): Fx<never, E, A> {
-  return fromEffect(Effect.tryCatchPromise(f, g))
+  return fromEffect(Effect.tryPromise({ try: f, catch: g }))
 }
 
 export function tryCatchPromiseInterrupt<A, E>(
   f: (signal: AbortSignal) => Promise<A>,
   g: (error: unknown) => E,
 ): Fx<never, E, A> {
-  return fromEffect(Effect.tryCatchPromiseInterrupt(f, g))
+  return fromEffect(Effect.tryPromiseInterrupt({ try: f, catch: g }))
 }
 
 export function promiseFx<R, E, A>(f: () => Promise<Fx<R, E, A>>): Fx<R, E, A> {
@@ -59,12 +60,12 @@ export function tryCatchPromiseFx<R, E, A, E2>(
   f: () => Promise<Fx<R, E, A>>,
   g: (error: unknown) => E2,
 ): Fx<R, E | E2, A> {
-  return fromFxEffect(Effect.tryCatchPromise(f, g))
+  return fromFxEffect(Effect.tryPromise({ try: f, catch: g }))
 }
 
 export function tryCatchPromiseInterruptFx<R, E, A, E2>(
   f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
   g: (error: unknown) => E2,
 ): Fx<R, E | E2, A> {
-  return fromFxEffect(Effect.tryCatchPromiseInterrupt(f, g))
+  return fromFxEffect(Effect.tryPromiseInterrupt({ try: f, catch: g }))
 }

package/src/provide.ts

@@ -1,7 +1,9 @@
-import type { Sink } from './Fx.js'
+import * as Context from '@effect/data/Context'
+import * as Effect from '@effect/io/Effect'
+import * as Layer from '@effect/io/Layer'
+
 import { Fx } from './Fx.js'
-import type { Layer } from './externals.js'
-import { Context, Effect } from './externals.js'
+import type { Sink } from './Fx.js'
 import { switchMap } from './switchMap.js'
 
 export function provideContext<R, E, A>(
@@ -10,7 +12,7 @@ export function provideContext<R, E, A>(
 ): Fx<never, E, A> {
   return Fx(
     <R2>(sink: Sink<R2, E, A>): Effect.Effect<R2, never, void> =>
-      Effect.contramapContext(fx.run(sink), (ctx) => Context.merge(ctx, context)),
+      Effect.mapInputContext(fx.run(sink), (ctx) => Context.merge(ctx, context)),
   )
 }
 
@@ -20,7 +22,7 @@ export function provideSomeContext<R, E, A, R2>(
 ): Fx<Exclude<R, R2>, E, A> {
   return Fx(
     <R3>(sink: Sink<R3, E, A>): Effect.Effect<Exclude<R, R2> | R3, never, void> =>
-      Effect.contramapContext(fx.run(sink), (ctx) =>
+      Effect.mapInputContext(fx.run(sink), (ctx) =>
         Context.merge(ctx as Context.Context<R | R3>, context),
       ),
   )
@@ -55,11 +57,13 @@ export function provideServiceEffect<R, E, A, I, S, R2, E2>(
 ): Fx<Exclude<R, I> | R2, E | E2, A> {
   return Fx(
     <R3>(sink: Sink<R3, E | E2, A>): Effect.Effect<Exclude<R, I> | R2 | R3, never, void> =>
-      Effect.matchCauseEffect(service, sink.error, (s) =>
-        Effect.contramapContext(fx.run(sink), (ctx) =>
-          Context.merge(ctx as Context.Context<R | R2 | R3>, Context.make(tag, s)),
-        ),
-      ),
+      Effect.matchCauseEffect(service, {
+        onFailure: sink.error,
+        onSuccess: (s) =>
+          Effect.mapInputContext(fx.run(sink), (ctx) =>
+            Context.merge(ctx as Context.Context<R | R2 | R3>, Context.make(tag, s)),
+          ),
+      }),
   )
 }
 

package/src/reduce.ts

@@ -1,5 +1,7 @@
+import * as Effect from '@effect/io/Effect'
+import * as Scope from '@effect/io/Scope'
+
 import { Fx } from './Fx.js'
-import { Effect, Scope } from './externals.js'
 import { observe } from './observe.js'
 
 export function reduce<R, E, A, B>(

package/src/scan.ts

@@ -1,5 +1,6 @@
+import * as Effect from '@effect/io/Effect'
+
 import { Fx, Sink } from './Fx.js'
-import { Effect } from './externals.js'
 
 export function scan<R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (b: B, a: A) => B): Fx<R, E, B> {
   return Fx((sink) =>

package/src/scoped.ts

@@ -1,5 +1,7 @@
+import * as Effect from '@effect/io/Effect'
+import * as Scope from '@effect/io/Scope'
+
 import { Fx } from './Fx.js'
-import { Effect, Scope } from './externals.js'
 
 export function scoped<R, E, A>(fx: Fx<R, E, A>): Fx<Exclude<R, Scope.Scope>, E, A> {
   return Fx((sink) => Effect.scoped(fx.run(sink)))

package/src/skipRepeats.ts

@@ -1,22 +1,21 @@
-import { equals } from '@effect/data/Equal'
-import type { Equivalence } from '@effect/data/typeclass/Equivalence'
+import * as Option from '@effect/data/Option'
+import type { Equivalence } from '@effect/data/Equivalence'
+import * as Effect from '@effect/io/Effect'
+import fastDeepEqual from 'fast-deep-equal/es6'
 
 import { Fx, Sink } from './Fx.js'
-import { Effect, Option } from './externals.js'
 
 export function skipRepeatsWith<R, E, A>(fx: Fx<R, E, A>, eq: Equivalence<A>): Fx<R, E, A> {
   return Fx((sink) =>
     Effect.suspend(() => {
       let previous: Option.Option<A> = Option.none()
-      const isPrevious = Option.contains(eq)
+      const isPrevious = Option.containsWith(eq)
 
       return fx.run(
         Sink(
           (a) =>
             Effect.suspend(() =>
-              isPrevious(previous, a)
-                ? Effect.unit()
-                : sink.event(((previous = Option.some(a)), a)),
+              isPrevious(previous, a) ? Effect.unit : sink.event(((previous = Option.some(a)), a)),
             ),
           sink.error,
         ),
@@ -26,5 +25,5 @@ export function skipRepeatsWith<R, E, A>(fx: Fx<R, E, A>, eq: Equivalence<A>): F
 }
 
 export function skipRepeats<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
-  return skipRepeatsWith(fx, equals)
+  return skipRepeatsWith(fx, fastDeepEqual)
 }

package/src/skipWhile.ts

@@ -1,8 +1,8 @@
 import type { Predicate } from '@effect/data/Predicate'
 import { not } from '@effect/data/Predicate'
+import * as Effect from '@effect/io/Effect'
 
 import { Fx, Sink } from './Fx.js'
-import { Effect } from './externals.js'
 
 export function skipWhile<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
   return Fx((sink) =>
@@ -14,7 +14,7 @@ export function skipWhile<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx
           (a) =>
             Effect.suspend(() => {
               if (skipping) {
-                return predicate(a) ? Effect.unit() : sink.event(((skipping = false), a))
+                return predicate(a) ? Effect.unit : sink.event(((skipping = false), a))
               }
 
               return sink.event(a)

package/src/slice.ts

@@ -1,5 +1,6 @@
+import * as Effect from '@effect/io/Effect'
+
 import { Fx, Sink } from './Fx.js'
-import { Effect } from './externals.js'
 
 export function slice<R, E, A>(fx: Fx<R, E, A>, skip: number, take: number): Fx<R, E, A> {
   return Fx(
@@ -14,17 +15,17 @@ export function slice<R, E, A>(fx: Fx<R, E, A>, skip: number, take: number): Fx<
               Effect.suspend(() => {
                 if (toSkip > 0) {
                   toSkip -= 1
-                  return Effect.unit()
+                  return Effect.unit
                 }
 
                 if (toTake > 0) {
                   toTake -= 1
                   return Effect.tap(sink.event(a), () =>
-                    Effect.sync(() => toTake === 0 && cb(Effect.unit())),
+                    Effect.sync(() => toTake === 0 && cb(Effect.unit)),
                   )
                 }
 
-                return Effect.sync(() => cb(Effect.unit()))
+                return Effect.sync(() => cb(Effect.unit))
               }),
             sink.error,
           ),

package/src/snapshotEffect.ts

@@ -1,5 +1,9 @@
+import * as Option from '@effect/data/Option'
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import * as Ref from '@effect/io/Ref'
+
 import { Fx, Sink } from './Fx.js'
-import { Effect, Fiber, Option, Ref } from './externals.js'
 
 export function snapshotEffect<R, E, A, R2, E2, B, R3, E3, C>(
   fx: Fx<R, E, A>,

package/src/struct.ts

@@ -0,0 +1,18 @@
+import { Fx } from './Fx.js'
+import { combineAll } from './combineAll.js'
+import { map } from './map.js'
+
+export function struct<FXS extends Readonly<Record<string, Fx<any, any, any>>>>(
+  fx: FXS,
+): Fx<
+  Fx.ResourcesOf<FXS[string]>,
+  Fx.ErrorsOf<FXS[string]>,
+  {
+    readonly [K in keyof FXS]: Fx.OutputOf<FXS[K]>
+  }
+> {
+  return map(
+    combineAll(...Object.entries(fx).map(([key, value]) => map(value, (x) => [key, x] as const))),
+    Object.fromEntries,
+  )
+}

package/src/switchMap.test.ts

@@ -1,7 +1,7 @@
+import * as Duration from '@effect/data/Duration'
 import { describe } from 'vitest'
 
 import { delay } from './delay.js'
-import { Duration } from './externals.js'
 import { fromArray } from './fromArray.js'
 import { switchMap } from './switchMap.js'
 import { testCollectAll } from './test-utils.js'

package/src/switchMap.ts

@@ -1,5 +1,6 @@
+import * as Effect from '@effect/io/Effect'
+
 import { Fx, Sink } from './Fx.js'
-import { Effect } from './externals.js'
 import { fromEffect } from './fromEffect.js'
 import { withSwitch } from './helpers.js'
 

package/src/switchMapCause.test.ts

@@ -1,7 +1,7 @@
+import * as Duration from '@effect/data/Duration'
 import { describe } from 'vitest'
 
 import { delay } from './delay.js'
-import { Duration } from './externals.js'
 import { fail } from './failCause.js'
 import { fromArray } from './fromArray.js'
 import { mergeAll } from './mergeAll.js'

package/src/switchMapCause.ts

@@ -1,7 +1,10 @@
+import * as Chunk from '@effect/data/Chunk'
+import * as Either from '@effect/data/Either'
 import { pipe } from '@effect/data/Function'
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
 
 import { Fx, Sink } from './Fx.js'
-import { Cause, Effect, Either } from './externals.js'
 import { failCause } from './failCause.js'
 import { fromEffect } from './fromEffect.js'
 import { withSwitch } from './helpers.js'
@@ -27,7 +30,7 @@ export function switchMapError<R, E, A, R2, E2, B>(
   f: (e: E) => Fx<R2, E2, B>,
 ): Fx<R | R2, E2, A | B> {
   return switchMapCause(fx, (cause) =>
-    pipe(cause, Cause.failureOrCause, Either.match(f, failCause)),
+    pipe(cause, Cause.failureOrCause, Either.match({ onLeft: f, onRight: failCause })),
   )
 }
 
@@ -37,3 +40,18 @@ export function switchMapErrorEffect<R, E, A, R2, E2, B>(
 ): Fx<R | R2, E2, A | B> {
   return switchMapError(fx, (a) => fromEffect(f(a)))
 }
+
+export function switchMapDefect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (e: unknown) => Fx<R2, E2, B>,
+): Fx<R | R2, E | E2, A | B> {
+  return switchMapCause(fx, (cause): Fx<R | R2, E | E2, A | B> => {
+    const defects = Cause.defects(cause)
+
+    if (Chunk.size(defects) > 0) {
+      return f(Chunk.unsafeHead(defects))
+    }
+
+    return failCause(cause)
+  })
+}

package/src/switchMatch.test.ts

@@ -1,7 +1,7 @@
+import * as Duration from '@effect/data/Duration'
 import { describe } from 'vitest'
 
 import { delay } from './delay.js'
-import { Duration } from './externals.js'
 import { fail } from './failCause.js'
 import { fromArray } from './fromArray.js'
 import { mergeAll } from './mergeAll.js'

package/src/switchMatch.ts

@@ -1,7 +1,9 @@
+import * as Either from '@effect/data/Either'
 import { pipe } from '@effect/data/Function'
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
 
 import { Fx, Sink } from './Fx.js'
-import { Cause, Effect, Either } from './externals.js'
 import { failCause } from './failCause.js'
 import { fromEffect } from './fromEffect.js'
 import { withSwitch } from './helpers.js'
@@ -30,7 +32,7 @@ export function switchMatch<R, E, A, R2, E2, B, R3, E3, C>(
 ): Fx<R | R2 | R3, E2 | E3, B | C> {
   return switchMatchCause(
     fx,
-    (cause) => pipe(cause, Cause.failureOrCause, Either.match(f, failCause)),
+    (cause) => pipe(cause, Cause.failureOrCause, Either.match({ onLeft: f, onRight: failCause })),
     g,
   )
 }

package/src/takeWhile.ts

@@ -1,13 +1,13 @@
-import type { Predicate } from '@effect/data/Predicate'
 import { not } from '@effect/data/Predicate'
+import type { Predicate } from '@effect/data/Predicate'
+import * as Effect from '@effect/io/Effect'
 
 import { Fx, Sink } from './Fx.js'
-import { Effect } from './externals.js'
 
 export function takeWhile<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
   return Fx(<R2>(sink: Sink<R2, E, A>) =>
     Effect.asyncEffect<never, never, void, R | R2, never, void>((cb) => {
-      const exit = Effect.sync(() => cb(Effect.unit()))
+      const exit = Effect.sync(() => cb(Effect.unit))
 
       return Effect.tap(
         fx.run(

package/src/tap.ts

@@ -1,5 +1,6 @@
+import * as Effect from '@effect/io/Effect'
+
 import { Fx, Sink } from './Fx.js'
-import { Effect } from './externals.js'
 
 export function tap<R, E, A, R2, E2, B>(
   fx: Fx<R, E, A>,
@@ -7,7 +8,11 @@ export function tap<R, E, A, R2, E2, B>(
 ): Fx<R | R2, E | E2, A> {
   return Fx(<R3>(sink: Sink<R3, E | E2, A>) =>
     fx.run<R2 | R3>(
-      Sink((a: A) => Effect.matchCauseEffect(f(a), sink.error, () => sink.event(a)), sink.error),
+      Sink(
+        (a: A) =>
+          Effect.matchCauseEffect(f(a), { onFailure: sink.error, onSuccess: () => sink.event(a) }),
+        sink.error,
+      ),
     ),
   )
 }

package/src/tapCause.ts

@@ -1,7 +1,8 @@
 import { pipe } from '@effect/data/Function'
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
 
 import { Fx, Sink } from './Fx.js'
-import { Cause, Effect } from './externals.js'
 
 export function tapCause<R, E, A, R2, E2, B>(
   fx: Fx<R, E, A>,
@@ -10,11 +11,10 @@ export function tapCause<R, E, A, R2, E2, B>(
   return Fx((sink) =>
     fx.run(
       Sink(sink.event, (cause) =>
-        Effect.matchCauseEffect(
-          f(cause),
-          (cause2) => sink.error(Cause.sequential(cause, cause2)),
-          () => sink.error(cause),
-        ),
+        Effect.matchCauseEffect(f(cause), {
+          onFailure: (cause2) => sink.error(Cause.sequential(cause, cause2)),
+          onSuccess: () => sink.error(cause),
+        }),
       ),
     ),
   )
@@ -32,7 +32,10 @@ export function tapError<R, E, A, R2, E2, B>(
   f: (error: E) => Effect.Effect<R, E2, B>,
 ): Fx<R | R2, E | E2, A> {
   return tapCause(fx, (cause) =>
-    pipe(Cause.failureOrCause(cause), Effect.matchEffect(f, Effect.failCause)),
+    pipe(
+      Cause.failureOrCause(cause),
+      Effect.matchEffect({ onFailure: f, onSuccess: Effect.failCause }),
+    ),
   )
 }
 

package/src/test-utils.ts

@@ -1,9 +1,11 @@
 import { ok } from 'assert'
 
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import * as Exit from '@effect/io/Exit'
 import { it, expect } from 'vitest'
 
 import type { Fx } from './Fx.js'
-import { Cause, Effect, Exit } from './externals.js'
 import { observe } from './observe.js'
 
 export function testCollectAll<E = never, A = never>(
@@ -11,7 +13,7 @@ export function testCollectAll<E = never, A = never>(
   fx: Fx<never, E, A>,
   expected: ReadonlyArray<A>,
 ) {
-  it(name, async () => {
+  it.concurrent(name, async () => {
     const test = Effect.scoped(
       Effect.gen(function* ($) {
         const values: Array<A> = []
@@ -28,7 +30,7 @@ export function testCollectAll<E = never, A = never>(
 
 export function testCause<E, A>(name: string, fx: Fx<never, E, A>, expected: Cause.Cause<E>) {
   it(name, async () => {
-    const exit = await Effect.runPromiseExit(Effect.scoped(observe(fx, () => Effect.unit())))
+    const exit = await Effect.runPromiseExit(Effect.scoped(observe(fx, () => Effect.unit)))
 
     ok(Exit.isFailure(exit))
     expect(Cause.unannotate(exit.cause)).toEqual(expected)

package/src/throttle.test.ts

@@ -1,6 +1,6 @@
+import * as Duration from '@effect/data/Duration'
 import { describe } from 'vitest'
 
-import { Duration } from './externals.js'
 import { fromArray } from './fromArray.js'
 import { testCollectAll } from './test-utils.js'
 import { throttle } from './throttle.js'

package/src/throttle.ts

@@ -1,5 +1,7 @@
+import * as Duration from '@effect/data/Duration'
+import * as Effect from '@effect/io/Effect'
+
 import { Fx, Sink } from './Fx.js'
-import { Duration, Effect } from './externals.js'
 import { withExhaust } from './helpers.js'
 
 export function throttle<R, E, A>(fx: Fx<R, E, A>, duration: Duration.Duration): Fx<R, E, A> {

package/src/toArray.ts

@@ -1,15 +1,16 @@
+import * as Effect from '@effect/io/Effect'
 import type { Scope } from '@effect/io/Scope'
 
 import type { Fx } from './Fx.js'
-import { Effect } from './externals.js'
 import { observe } from './observe.js'
 
 export function toArray<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R | Scope, E, Array<A>> {
-  return Effect.gen(function* ($) {
+  return Effect.suspend(() => {
     const array: Array<A> = []
 
-    yield* $(observe(fx, (a) => Effect.sync(() => array.push(a))))
-
-    return array
+    return Effect.map(
+      observe(fx, (a) => Effect.sync(() => array.push(a))),
+      () => array,
+    )
   })
 }

package/src/toChunk.ts

@@ -1,7 +1,8 @@
+import * as Chunk from '@effect/data/Chunk'
+import * as Effect from '@effect/io/Effect'
 import type { Scope } from '@effect/io/Scope'
 
 import type { Fx } from './Fx.js'
-import { Chunk, Effect } from './externals.js'
 import { observe } from './observe.js'
 
 export function toChunk<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R | Scope, E, Chunk.Chunk<A>> {

package/src/toEnqueue.ts

@@ -0,0 +1,13 @@
+import * as Effect from '@effect/io/Effect'
+import * as Q from '@effect/io/Queue'
+import * as Scope from '@effect/io/Scope'
+
+import { Fx } from './Fx.js'
+import { observe } from './observe.js'
+
+export function toEnqueue<R, E, A>(
+  fx: Fx<R, E, A>,
+  enqueue: Q.Enqueue<A>,
+): Effect.Effect<R | Scope.Scope, E, void> {
+  return observe(fx, enqueue.offer)
+}

package/src/toReadonlyArray.ts

@@ -1,7 +1,7 @@
+import * as Effect from '@effect/io/Effect'
 import type { Scope } from '@effect/io/Scope'
 
 import type { Fx } from './Fx.js'
-import { Effect } from './externals.js'
 import { toArray } from './toArray.js'
 
 export function toReadonlyArray<R, E, A>(

package/tsconfig.build.json

@@ -2,6 +2,7 @@
   "extends": "./tsconfig.json",
   "exclude": [
     "src/**/*.test.ts",
+    "src/**/*.test-d.ts",
     "dist"
   ]
-}
+}