@typed/fx 1.12.5 → 1.13.0

package/src/debounce.test.ts

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

package/src/debounce.ts

@@ -1,6 +1,7 @@
+import * as Duration from '@effect/data/Duration'
+import * as Effect from '@effect/io/Effect'
+
 import type { Fx } from './Fx.js'
-import type { Duration } from './externals.js'
-import { Effect } from './externals.js'
 import { switchMapEffect } from './switchMap.js'
 
 export function debounce<R, E, A>(fx: Fx<R, E, A>, duration: Duration.Duration): Fx<R, E, A> {

package/src/delay.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 { testCollectAll } from './test-utils.js'
 

package/src/delay.ts

@@ -1,7 +1,7 @@
 import type { Duration } from '@effect/data/Duration'
+import * as Effect from '@effect/io/Effect'
 
 import { Fx, Sink } from './Fx.js'
-import { Effect } from './externals.js'
 
 export function delay<R, E, A>(fx: Fx<R, E, A>, delay: Duration): Fx<R, E, A> {
   return Fx((sink) => fx.run(Sink((a) => Effect.delay(sink.event(a), delay), sink.error)))

package/src/exhaustMap.test.ts

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

package/src/exhaustMap.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 { withExhaust } from './helpers.js'
 

package/src/exhaustMapCause.test.ts

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

package/src/exhaustMapCause.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 { withExhaust } from './helpers.js'

package/src/exhaustMapLatest.test.ts

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

package/src/exhaustMapLatest.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 { withExhaustLatest } from './helpers.js'
 

package/src/exhaustMapLatestCause.test.ts

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

package/src/exhaustMapLatestCause.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 { withExhaustLatest } from './helpers.js'

package/src/failCause.test.ts

@@ -1,6 +1,7 @@
+import * as Cause from '@effect/io/Cause'
+import * as FiberId from '@effect/io/Fiber/Id'
 import { describe } from 'vitest'
 
-import { Cause, FiberId } from './externals.js'
 import { failCause } from './failCause.js'
 import { testCause } from './test-utils.js'
 

package/src/filter.ts

@@ -1,8 +1,8 @@
 import type { Predicate, Refinement } 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 filter<R, E, A, B extends A>(
   fx: Fx<R, E, A>,

package/src/filterMap.ts

@@ -1,5 +1,7 @@
+import * as Option from '@effect/data/Option'
+import * as Effect from '@effect/io/Effect'
+
 import { Fx, Sink } from './Fx.js'
-import { Effect, Option } from './externals.js'
 
 export function filterMap<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Option.Option<B>): Fx<R, E, B> {
   return Fx((sink) => fx.run(Sink((a) => Option.match(f(a), Effect.unit, sink.event), sink.error)))

package/src/flatMap.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 { flatMap } from './flatMap.js'
 import { fromArray } from './fromArray.js'
 import { testCollectAll } from './test-utils.js'

package/src/flatMap.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 { withUnboundedConcurrency } from './helpers.js'
 

package/src/fromArray.ts

@@ -1,5 +1,6 @@
+import * as Effect from '@effect/io/Effect'
+
 import { Fx } from './Fx.js'
-import { Effect } from './externals.js'
 
 export function fromArray<A>(array: ReadonlyArray<A>): Fx<never, never, A> {
   return Fx((sink) =>

package/src/fromEffect.test.ts

@@ -1,6 +1,7 @@
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
 import { describe } from 'vitest'
 
-import { Cause, Effect } from './externals.js'
 import { fromEffect } from './fromEffect.js'
 import { testCause, testCollectAll } from './test-utils.js'
 

package/src/fromEffect.ts

@@ -1,5 +1,6 @@
+import * as Effect from '@effect/io/Effect'
+
 import { Fx } from './Fx.js'
-import { Effect } from './externals.js'
 
 export function fromEffect<R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A> {
   return Fx((sink) => Effect.matchCauseEffect(effect, sink.error, sink.event))

package/src/fromEmitter.test.ts

@@ -1,6 +1,7 @@
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
 import { describe } from 'vitest'
 
-import { Cause, Effect } from './externals.js'
 import { fromEmitter } from './fromEmitter.js'
 import { testCause, testCollectAll } from './test-utils.js'
 

package/src/fromEmitter.ts

@@ -1,10 +1,12 @@
 import { methodWithTrace } from '@effect/data/Debug'
+import * as Cause from '@effect/io/Cause'
+import * as Deferred from '@effect/io/Deferred'
+import * as Effect from '@effect/io/Effect'
+import * as Runtime from '@effect/io/Runtime'
 import type { Scope } from '@effect/io/Scope'
 
 import type { Sink } from './Fx.js'
 import { Fx } from './Fx.js'
-import type { Cause } from './externals.js'
-import { Deferred, Effect, Runtime } from './externals.js'
 
 export function fromEmitter<E, A, R, E2>(
   f: (emitter: Emitter<E, A>) => Effect.Effect<R | Scope, E2, void>,

package/src/fromFxEffect.test.ts

@@ -1,6 +1,7 @@
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
 import { describe } from 'vitest'
 
-import { Cause, Effect } from './externals.js'
 import { fromFxEffect } from './fromFxEffect.js'
 import { succeed } from './succeed.js'
 import { testCause, testCollectAll } from './test-utils.js'

package/src/fromFxEffect.ts

@@ -1,5 +1,6 @@
+import * as Effect from '@effect/io/Effect'
+
 import { Fx } from './Fx.js'
-import { Effect } from './externals.js'
 
 export function fromFxEffect<R, E, R2, E2, B>(
   effect: Effect.Effect<R, E, Fx<R2, E2, B>>,

package/src/fromIterable.ts

@@ -1,5 +1,6 @@
+import * as Effect from '@effect/io/Effect'
+
 import { Fx } from './Fx.js'
-import { Effect } from './externals.js'
 
 export function fromIterable<A>(iterable: Iterable<A>): Fx<never, never, A> {
   return Fx((sink) =>

package/src/gen.test.ts

@@ -1,6 +1,7 @@
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
 import { describe } from 'vitest'
 
-import { Cause, Effect } from './externals.js'
 import { gen } from './gen.js'
 import { succeed } from './succeed.js'
 import { testCause, testCollectAll } from './test-utils.js'

package/src/gen.ts

@@ -1,5 +1,6 @@
+import * as Effect from '@effect/io/Effect'
+
 import type { Fx } from './Fx.js'
-import { Effect } from './externals.js'
 import { fromFxEffect } from './fromFxEffect.js'
 
 export type EffectGenResources<T> = [T] extends [never]

package/src/helpers.ts

@@ -1,6 +1,10 @@
 import { pipe } from '@effect/data/Function'
-
-import { Effect, Fiber, Option, Ref, RefS, Scope } from './externals.js'
+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 * as RefS from '@effect/io/Ref/Synchronized'
+import * as Scope from '@effect/io/Scope'
 
 export type ScopedFork = <R2, E2, B>(
   effect: Effect.Effect<R2, E2, B>,

package/src/hold.test.ts

@@ -1,3 +1,4 @@
+import * as Chunk from '@effect/data/Chunk'
 import { millis } from '@effect/data/Duration'
 import { range } from '@effect/data/ReadonlyArray'
 import * as Effect from '@effect/io/Effect'
@@ -5,7 +6,6 @@ import * as Fiber from '@effect/io/Fiber'
 import { describe, it, expect } from 'vitest'
 
 import { at } from './at.js'
-import { Chunk } from './externals.js'
 import { hold } from './hold.js'
 import { mergeAll } from './mergeAll.js'
 import { toChunk } from './toChunk.js'

package/src/hold.ts

@@ -1,8 +1,10 @@
 import type { Trace } from '@effect/data/Debug'
+import * as MutableRef from '@effect/data/MutableRef'
+import * as Option from '@effect/data/Option'
+import * as Effect from '@effect/io/Effect'
 
 import type { Fx, Sink } from './Fx.js'
 import { Traced } from './Fx.js'
-import { Effect, MutableRef, Option } from './externals.js'
 import { MulticastFx } from './multicast.js'
 
 export function hold<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {

package/src/index.ts

@@ -1,14 +1,19 @@
+import * as Chunk from '@effect/data/Chunk'
+import * as Context from '@effect/data/Context'
 import { dualWithTrace, methodWithTrace } from '@effect/data/Debug'
 import type { Duration } from '@effect/data/Duration'
 import type { HashSet } from '@effect/data/HashSet'
+import * as Option from '@effect/data/Option'
 import type { Predicate, Refinement } from '@effect/data/Predicate'
 import type { Equivalence } from '@effect/data/typeclass/Equivalence'
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
 import type { FiberId } from '@effect/io/Fiber/Id'
+import * as Layer from '@effect/io/Layer'
+import * as Scope from '@effect/io/Scope'
 
 import type { Fx } from './Fx.js'
 import * as internal from './data-first.js'
-import type { Cause, Chunk, Context, Effect, Layer, Option, Scope } from './externals.js'
-
 export * from './Fx.js'
 
 export const at: {

package/src/keyed.ts

@@ -1,15 +1,13 @@
 import * as MutableHashMap from '@effect/data/MutableHashMap'
 import * as Option from '@effect/data/Option'
 import * as ReadonlyArray from '@effect/data/ReadonlyArray'
-import * as Equivalence from '@effect/data/typeclass/Equivalence'
+import * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 import * as Fiber from '@effect/io/Fiber'
-import fastDeepEqual from 'fast-deep-equal'
 
 import { Fx, Sink } from './Fx.js'
 import { RefSubject } from './RefSubject.js'
 import { Subject, makeHoldSubject } from './Subject.js'
-import { Cause } from './externals.js'
 import { ScopedFork, withScopedFork } from './helpers.js'
 
 export function keyed<R, E, A, R2, E2, B, C>(
@@ -21,13 +19,10 @@ export function keyed<R, E, A, R2, E2, B, C>(
     withScopedFork((fork) =>
       Effect.gen(function* ($) {
         const state = createKeyedState<A, B, C>()
-        const eq = Equivalence.make((x: A, y: A) => fastDeepEqual(getKey(x), getKey(y)))
-        const difference = ReadonlyArray.difference(eq)
-        const intersection = ReadonlyArray.intersection(eq)
         const emit = emitWhenReady(state, getKey)
 
-        // Let output emit to the sink
-        const fiber = yield* $(fork(state.output.run(sink)))
+        // Let output emit to the sink, it is closes by the surrounding scope
+        yield* $(fork(state.output.run(sink)))
 
         // Listen to the input and update the state
         yield* $(
@@ -40,8 +35,6 @@ export function keyed<R, E, A, R2, E2, B, C>(
                   getKey,
                   f,
                   fork,
-                  difference,
-                  intersection,
                   emit,
                   error: sink.error,
                 }),
@@ -54,9 +47,6 @@ export function keyed<R, E, A, R2, E2, B, C>(
 
         // When the source stream ends we wait for the remaining fibers to end
         yield* $(Fiber.joinAll(Array.from(state.fibers).map((x) => x[1])))
-
-        // Terminate the output fiber
-        yield* $(Fiber.interrupt(fiber))
       }),
     ),
   )
@@ -64,7 +54,7 @@ export function keyed<R, E, A, R2, E2, B, C>(
 
 type KeyedState<A, B, C> = {
   previous: readonly A[]
-  ended: boolean
+  previousKeys: ReadonlySet<C>
 
   readonly subjects: MutableHashMap.MutableHashMap<C, RefSubject<never, A>>
   readonly fibers: MutableHashMap.MutableHashMap<C, Fiber.RuntimeFiber<never, void>>
@@ -75,7 +65,7 @@ type KeyedState<A, B, C> = {
 function createKeyedState<A, B, C>(): KeyedState<A, B, C> {
   return {
     previous: [],
-    ended: false,
+    previousKeys: new Set(),
     subjects: MutableHashMap.empty(),
     fibers: MutableHashMap.empty(),
     values: MutableHashMap.empty(),
@@ -88,8 +78,6 @@ function updateState<A, B, C, R2, E2, R3>({
   updated,
   f,
   fork,
-  difference,
-  intersection,
   emit,
   error,
   getKey,
@@ -98,21 +86,18 @@ function updateState<A, B, C, R2, E2, R3>({
   updated: readonly A[]
   f: (fx: RefSubject<never, A>) => Fx<R2, E2, B>
   fork: ScopedFork
-  difference: (self: Iterable<A>, that: Iterable<A>) => A[]
-  intersection: (self: Iterable<A>, that: Iterable<A>) => A[]
   emit: Effect.Effect<never, never, void>
   error: (e: Cause.Cause<E2>) => Effect.Effect<R3, never, void>
   getKey: (a: A) => C
 }) {
   return Effect.gen(function* ($) {
-    const added = difference(updated, state.previous)
-    const removed = difference(state.previous, updated)
-    const unchanged = intersection(updated, state.previous)
-
-    state.previous = updated
+    const { added, removed, unchanged } = diffValues(state, updated, getKey)
 
     // Remove values that are no longer in the stream
-    yield* $(Effect.forEachParDiscard(removed, (value) => removeValue(state, value, getKey)))
+    yield* $(Effect.forEachDiscard(removed, (key) => removeValue(state, key)))
+
+    // Update values that are still in the stream
+    yield* $(Effect.forEachParDiscard(unchanged, (value) => updateValue(state, value, getKey)))
 
     // Add values that are new to the stream
     yield* $(
@@ -121,9 +106,6 @@ function updateState<A, B, C, R2, E2, R3>({
       ),
     )
 
-    // Update values that are still in the stream
-    yield* $(Effect.forEachParDiscard(unchanged, (value) => updateValue(state, value, getKey)))
-
     // If nothing was added, emit the current values
     if (added.length === 0) {
       yield* $(emit)
@@ -131,9 +113,46 @@ function updateState<A, B, C, R2, E2, R3>({
   })
 }
 
-function removeValue<A, B, C>(state: KeyedState<A, B, C>, value: A, getKey: (a: A) => C) {
-  return Effect.gen(function* ($) {
+function diffValues<A, B, C>(
+  state: KeyedState<A, B, C>,
+  updated: ReadonlyArray<A>,
+  getKey: (a: A) => C,
+) {
+  const added: A[] = []
+  const unchanged: A[] = []
+  const removed: C[] = []
+  const previousKeys = state.previousKeys
+  const keys = new Set<C>(updated.map(getKey))
+
+  for (let i = 0; i < updated.length; ++i) {
+    const value = updated[i]
     const key = getKey(value)
+
+    if (previousKeys.has(key)) {
+      unchanged.push(value)
+    } else {
+      added.push(value)
+    }
+  }
+
+  previousKeys.forEach((k) => {
+    if (!keys.has(k)) {
+      removed.push(k)
+    }
+  })
+
+  state.previous = updated
+  state.previousKeys = keys
+
+  return {
+    added,
+    unchanged,
+    removed,
+  } as const
+}
+
+function removeValue<A, B, C>(state: KeyedState<A, B, C>, key: C) {
+  return Effect.gen(function* ($) {
     const subject = MutableHashMap.get(state.subjects, key)
 
     if (Option.isSome(subject)) yield* $(Effect.fork(subject.value.end()))
@@ -202,6 +221,11 @@ function updateValue<A, B, C>(state: KeyedState<A, B, C>, value: A, getKey: (a:
 
 function emitWhenReady<A, B, C>(state: KeyedState<A, B, C>, getKey: (a: A) => C) {
   return Effect.suspend(() => {
+    // Fast path: if we don't have enough values, don't emit
+    if (MutableHashMap.size(state.values) !== state.previous.length) {
+      return Effect.unit()
+    }
+
     const values = ReadonlyArray.filterMap(state.previous, (value) =>
       MutableHashMap.get(state.values, getKey(value)),
     )
@@ -216,7 +240,5 @@ function emitWhenReady<A, B, C>(state: KeyedState<A, B, C>, getKey: (a: A) => C)
 }
 
 function endAll<A, B, C>(state: KeyedState<A, B, C>) {
-  return Effect.gen(function* ($) {
-    yield* $(Effect.forEachParDiscard(state.subjects, ([, subject]) => subject.end()))
-  })
+  return Effect.forEachParDiscard(state.subjects, ([, subject]) => subject.end())
 }

package/src/map.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 map<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B> {
   return Fx((sink) => fx.run(Sink((a) => Effect.suspend(() => sink.event(f(a))), sink.error)))

package/src/mergeAll.ts

@@ -1,5 +1,8 @@
+import * as Option from '@effect/data/Option'
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+
 import { Fx, Sink } from './Fx.js'
-import { Cause, Effect, Option } from './externals.js'
 import { compact } from './filterMap.js'
 import { map } from './map.js'
 

package/src/multicast.test.ts

@@ -1,10 +1,11 @@
+import * as Chunk from '@effect/data/Chunk'
+import * as Duration from '@effect/data/Duration'
 import { pipe } from '@effect/data/Function'
 import * as Effect from '@effect/io/Effect'
 import * as Fiber from '@effect/io/Fiber'
 import { describe, it, expect } from 'vitest'
 
 import { delay } from './delay.js'
-import { Chunk, Duration } from './externals.js'
 import { flatMap } from './flatMap.js'
 import { fromArray } from './fromArray.js'
 import { merge } from './mergeAll.js'

package/src/multicast.ts

@@ -1,10 +1,12 @@
+import type * as Context from '@effect/data/Context'
 import type { Trace } from '@effect/data/Debug'
 import { identity } from '@effect/data/Function'
+import type * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
 
-import type { Fx, Sink } from './Fx.js'
 import { FxTypeId, Traced } from './Fx.js'
-import type { Cause, Context } from './externals.js'
-import { Effect, Fiber } from './externals.js'
+import type { Fx, Sink } from './Fx.js'
 
 export function multicast<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
   return new MulticastFx(fx)

package/src/never.ts

@@ -1,5 +1,6 @@
+import * as Effect from '@effect/io/Effect'
+
 import { Fx } from './Fx.js'
-import { Effect } from './externals.js'
 
 export function never<E = never, A = never>(): Fx<never, E, A> {
   return Fx<never, E, A>(() => Effect.never())

package/src/observe.ts

@@ -1,9 +1,11 @@
+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>,

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/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'
 

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>(

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>(