@typed/fx 0.0.35 → 1.0.2

package/src/filterLoop.ts

@@ -1,151 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { Scope } from '@effect/core/io/Scope'
-import { pipe } from '@tsplus/stdlib/data/Function'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-
-import { Emitter, Fx } from './Fx.js'
-import { startWith } from './continueWith.js'
-import { FilterMap, Map } from './filterMap.js'
-
-export function loop<A, B, C>(seed: A, f: (a: A, b: B) => readonly [A, C]) {
-  return <R, E>(fx: Fx<R, E, B>): Fx<R, E, C> => Loop.make(fx, seed, f)
-}
-
-export function scan<A, B>(seed: A, f: (a: A, b: B) => A) {
-  return <R, E>(fx: Fx<R, E, B>): Fx<R, E, A> =>
-    pipe(
-      fx,
-      loop(seed, (a, b) => {
-        const c = f(a, b)
-        return [c, c]
-      }),
-      startWith(seed),
-    )
-}
-
-export function filterLoop<A, B, C>(seed: A, f: (a: A, b: B) => Maybe.Maybe<readonly [A, C]>) {
-  return <R, E>(fx: Fx<R, E, B>): Fx<R, E, C> => FilterLoop.make(fx, seed, f)
-}
-
-export function filterScan<A, B>(seed: A, f: (a: A, b: B) => Maybe.Maybe<A>) {
-  return <R, E>(fx: Fx<R, E, B>): Fx<R, E, A> =>
-    pipe(
-      fx,
-      filterLoop(seed, (a, b) =>
-        pipe(
-          f(a, b),
-          Maybe.map((c) => [c, c]),
-        ),
-      ),
-      startWith(seed),
-    )
-}
-
-export class Loop<R, E, A, B, C> implements Fx<R, E, C> {
-  readonly _R!: () => R
-  readonly _E!: () => E
-  readonly _A!: () => C
-
-  constructor(
-    readonly fx: Fx<R, E, B>,
-    readonly seed: A,
-    readonly f: (a: A, b: B) => readonly [A, C],
-  ) {}
-
-  run<R2>(emitter: Emitter<R2, E, C>): Effect.Effect<R | R2 | Scope, never, unknown> {
-    return Effect.suspendSucceed(() => {
-      let acc = this.seed
-
-      return this.fx.run(
-        Emitter(
-          (b: B) => {
-            const [a, c] = this.f(acc, b)
-
-            acc = a
-
-            return emitter.emit(c)
-          },
-          emitter.failCause,
-          emitter.end,
-        ),
-      )
-    })
-  }
-
-  static make<R, E, A, B, C>(
-    fx: Fx<R, E, B>,
-    seed: A,
-    f: (a: A, b: B) => readonly [A, C],
-  ): Fx<R, E, C> {
-    if (fx instanceof FilterMap) {
-      return FilterLoop.make(fx.fx, seed, (a, x) =>
-        pipe(
-          x,
-          fx.f,
-          Maybe.map((b) => f(a, b)),
-        ),
-      )
-    }
-
-    if (fx instanceof Map) {
-      return Loop.make(fx.fx, seed, (a, x) => f(a, fx.f(x)))
-    }
-
-    return new Loop(fx, seed, f)
-  }
-}
-
-export class FilterLoop<R, E, A, B, C> implements Fx<R, E, C> {
-  readonly _R!: () => R
-  readonly _E!: () => E
-  readonly _A!: () => C
-
-  constructor(
-    readonly fx: Fx<R, E, B>,
-    readonly seed: A,
-    readonly f: (a: A, b: B) => Maybe.Maybe<readonly [A, C]>,
-  ) {}
-
-  run<R2>(emitter: Emitter<R2, E, C>): Effect.Effect<R | R2 | Scope, never, unknown> {
-    return Effect.suspendSucceed(() => {
-      let acc = this.seed
-
-      return this.fx.run(
-        Emitter(
-          (b: B) =>
-            pipe(
-              this.f(acc, b),
-              Maybe.fold(
-                () => Effect.unit,
-                ([a, c]) => ((acc = a), emitter.emit(c)),
-              ),
-            ),
-          emitter.failCause,
-          emitter.end,
-        ),
-      )
-    })
-  }
-
-  static make<R, E, A, B, C>(
-    fx: Fx<R, E, B>,
-    seed: A,
-    f: (a: A, b: B) => Maybe.Maybe<readonly [A, C]>,
-  ): Fx<R, E, C> {
-    if (fx instanceof FilterMap) {
-      return FilterLoop.make(fx.fx, seed, (a, x) =>
-        pipe(
-          x,
-          fx.f,
-          Maybe.flatMap((b) => f(a, b)),
-        ),
-      )
-    }
-
-    if (fx instanceof Map) {
-      return FilterLoop.make(fx.fx, seed, (a, x) => f(a, fx.f(x)))
-    }
-
-    return new FilterLoop(fx, seed, f)
-  }
-}

package/src/filterMap.test.ts

@@ -1,33 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@tsplus/stdlib/data/Function'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.map.name, () => {
-    it('transform the values of a Fx', async () => {
-      const test = pipe(
-        Fx.fromIterable([1, 2, 3]),
-        Fx.map((x) => x ** x),
-        Fx.runCollect,
-      )
-
-      deepStrictEqual(await Effect.unsafeRunPromise(test), [1, 4, 27])
-    })
-  })
-
-  describe(Fx.filterMap.name, () => {
-    it('transform the values and filters using Maybe of a Fx', async () => {
-      const test = pipe(
-        Fx.fromIterable([1, 2, 3]),
-        Fx.filterMap((x) => (x % 2 === 0 ? Maybe.none : Maybe.some(x ** x))),
-        Fx.runCollect,
-      )
-
-      deepStrictEqual(await Effect.unsafeRunPromise(test), [1, 27])
-    })
-  })
-})

package/src/filterMap.ts

@@ -1,79 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { Scope } from '@effect/core/io/Scope'
-import { flow } from '@fp-ts/data/Function'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-import { Predicate } from '@tsplus/stdlib/data/Predicate'
-
-import { Emitter, Fx } from './Fx.js'
-
-export const map =
-  <A, B>(f: (a: A) => B) =>
-  <R, E>(fx: Fx<R, E, A>): Fx<R, E, B> =>
-    Map.make(fx, f)
-
-export const as = <B>(value: B): (<R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, B>) => map(() => value)
-
-export class Map<R, E, A, B> implements Fx<R, E, B> {
-  readonly _R!: () => R
-  readonly _E!: () => E
-  readonly _A!: () => B
-
-  constructor(readonly fx: Fx<R, E, A>, readonly f: (a: A) => B) {}
-
-  run<R2>(emitter: Emitter<R2, E, B>): Effect.Effect<R | R2 | Scope, never, unknown> {
-    return this.fx.run(Emitter(flow(this.f, emitter.emit), emitter.failCause, emitter.end))
-  }
-
-  static make = <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B> => {
-    if (fx instanceof Map) {
-      return Map.make(fx.fx, flow(fx.f, f))
-    }
-
-    if (fx instanceof FilterMap) {
-      return FilterMap.make(fx.fx, flow(fx.f, Maybe.map(f)))
-    }
-
-    return new Map(fx, f)
-  }
-}
-
-export function filterMap<A, B>(f: (a: A) => Maybe.Maybe<B>) {
-  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, B> => FilterMap.make(fx, f)
-}
-
-export function filter<A>(predicate: Predicate<A>) {
-  return filterMap((a: A) => Maybe.fromPredicate(a, predicate))
-}
-
-export class FilterMap<R, E, A, B> implements Fx<R, E, B> {
-  readonly _R!: () => R
-  readonly _E!: () => E
-  readonly _A!: () => B
-
-  constructor(readonly fx: Fx<R, E, A>, readonly f: (a: A) => Maybe.Maybe<B>) {}
-
-  run<R2>(emitter: Emitter<R2, E, B>): Effect.Effect<R | R2 | Scope, never, unknown> {
-    return this.fx.run(
-      Emitter(
-        flow(
-          this.f,
-          Maybe.fold(() => Effect.unit, emitter.emit),
-        ),
-        emitter.failCause,
-        emitter.end,
-      ),
-    )
-  }
-
-  static make<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Maybe.Maybe<B>): Fx<R, E, B> {
-    if (fx instanceof Map) {
-      return FilterMap.make(fx.fx, flow(fx.f, f))
-    }
-
-    if (fx instanceof FilterMap) {
-      return FilterMap.make(fx.fx, flow(fx.f, Maybe.flatMap(f)))
-    }
-
-    return new FilterMap(fx, f)
-  }
-}

package/src/flatMap.test.ts

@@ -1,50 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import * as Duration from '@tsplus/stdlib/data/Duration'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.flatMap.name, () => {
-    it('allows chaining multiple synchronous streams', async () => {
-      const result = await pipe(
-        Fx.fromIterable([1, 2, 3]),
-        Fx.flatMap((n) => Fx.fromIterable([n, n, n])),
-        Fx.runCollect,
-        Effect.unsafeRunPromise,
-      )
-
-      deepStrictEqual(result, [1, 1, 1, 2, 2, 2, 3, 3, 3])
-    })
-
-    it('allows chaining multiple asynchronous streams', async () => {
-      const result = await pipe(
-        Fx.fromIterable([1, 2, 3]),
-        Fx.flatMap((n) => Fx.delay(Duration.millis(10))(Fx.fromIterable([n, n, n]))),
-        Fx.runCollect,
-        Effect.unsafeRunPromise,
-      )
-
-      deepStrictEqual(result, [1, 2, 3, 1, 2, 3, 1, 2, 3])
-    })
-
-    it('interrupts inner fibers when they emit their end signal', async () => {
-      const result = await pipe(
-        Fx.fromIterable([1, 2, 3]),
-        Fx.flatMap((n) =>
-          n === 1
-            ? Fx.take(4)(
-                Fx.fromIterable([n, n + 10, n + 20, n + 30, n + 40, n + 50, n + 60, n + 70]),
-              )
-            : Fx.fromIterable([n, n, n]),
-        ),
-        Fx.runCollect,
-        Effect.unsafeRunPromise,
-      )
-
-      deepStrictEqual(result, [1, 11, 21, 31, 2, 2, 2, 3, 3, 3])
-    })
-  })
-})

package/src/flatMap.ts

@@ -1,43 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { flow, pipe } from '@fp-ts/data/Function'
-
-import { Emitter, Fx } from './Fx.js'
-import { withDynamicCountdownLatch } from './_internal.js'
-import { Map } from './filterMap.js'
-
-export function flatMap<A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>) {
-  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> =>
-    fx instanceof Map ? flatMap_(fx.fx, flow(fx.f, f)) : flatMap_(fx, f)
-}
-
-export function join<R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>): Fx<R | R2, E | E2, A> {
-  return flatMap_(fx, (fx) => fx)
-}
-
-function flatMap_<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Fx<R2, E2, B>,
-): Fx<R | R2, E | E2, B> {
-  return Fx((emitter) =>
-    withDynamicCountdownLatch(
-      1,
-      ({ increment, latch }) =>
-        fx.run(
-          Emitter(
-            (a) =>
-              pipe(
-                increment,
-                Effect.flatMap(() =>
-                  Effect.forkScoped(
-                    f(a).run(Emitter(emitter.emit, emitter.failCause, latch.countDown)),
-                  ),
-                ),
-              ),
-            emitter.failCause,
-            latch.countDown,
-          ),
-        ),
-      emitter.end,
-    ),
-  )
-}

package/src/flatMapConcurrently.test.ts

@@ -1,23 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import * as Duration from '@tsplus/stdlib/data/Duration'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe('flatMapConcurrently', () => {
-    it('should run effects with specified concurrency', async () => {
-      const test = pipe(
-        Fx.mergeAll([Fx.succeed(1), Fx.succeed(2), Fx.succeed(3)]),
-        Fx.concatMap((a) => Fx.mergeAll([Fx.succeed(a), Fx.at(Duration.millis(50))(a * a)])),
-        Fx.runCollect,
-      )
-
-      const events = await Effect.unsafeRunPromise(test)
-
-      deepStrictEqual(events, [1, 1, 2, 4, 3, 9])
-    })
-  })
-})

package/src/flatMapConcurrently.ts

@@ -1,16 +0,0 @@
-import * as TSemaphore from '@effect/core/stm/TSemaphore'
-import { flow, pipe } from '@fp-ts/data/Function'
-
-import { Fx } from './Fx.js'
-import { flatMap } from './flatMap.js'
-import { suspendSucceed } from './suspendSucceed.js'
-import { withPermit } from './transform.js'
-
-export function flatMapConcurrently<A, R2, E2, B>(concurrency: number, f: (a: A) => Fx<R2, E2, B>) {
-  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> =>
-    suspendSucceed(() => pipe(fx, flatMap(flow(f, withPermit(TSemaphore.unsafeMake(concurrency))))))
-}
-
-export function concatMap<A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>) {
-  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> => pipe(fx, flatMapConcurrently(1, f))
-}

package/src/fromDequeue.ts

@@ -1,17 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Q from '@effect/core/io/Queue'
-
-import { Fx } from './Fx.js'
-
-export function fromDequeue<A>(dequeue: Q.Dequeue<A>): Fx<never, never, A> {
-  return Fx((emitter) =>
-    Effect.gen(function* ($) {
-      while (!(yield* $(dequeue.isShutdown))) {
-        const a = yield* $(dequeue.take)
-        yield* $(emitter.emit(a))
-      }
-
-      yield* $(emitter.end)
-    }),
-  )
-}

package/src/fromEffect.ts

@@ -1,112 +0,0 @@
-import * as Cause from '@effect/core/io/Cause'
-import { Clock } from '@effect/core/io/Clock'
-import * as Effect from '@effect/core/io/Effect'
-import { Exit } from '@effect/core/io/Exit'
-import { Fiber } from '@effect/core/io/Fiber'
-import { FiberId } from '@effect/core/io/FiberId'
-import { LazyArg, flow, pipe } from '@fp-ts/data/Function'
-import { Either } from '@tsplus/stdlib/data/Either'
-import { Maybe } from '@tsplus/stdlib/data/Maybe'
-import { Env } from '@tsplus/stdlib/service/Env'
-import { Tag } from '@tsplus/stdlib/service/Tag'
-
-import { Fx } from './Fx.js'
-
-export function fromEffect<R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A> {
-  return Fx((emitter) =>
-    pipe(
-      effect,
-      Effect.foldCauseEffect(emitter.failCause, flow(emitter.emit, Effect.zipRight(emitter.end))),
-    ),
-  )
-}
-
-export const succeed = flow(Effect.succeed, fromEffect)
-
-export const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never> = flow(
-  Effect.failCause,
-  fromEffect,
-)
-
-export const fail: <E>(e: E) => Fx<never, E, never> = flow(Effect.fail, fromEffect)
-
-export const unit: Fx<never, never, void> = fromEffect(Effect.unit)
-
-export const never: Fx<never, never, never> = fromEffect(Effect.never)
-
-export const interrupt = fromEffect(Effect.interrupt)
-export const interruptAs: (fiberId: FiberId) => Fx<never, never, never> = flow(
-  Effect.interruptAs,
-  fromEffect,
-)
-
-export const die = flow(Effect.die, fromEffect)
-export const dieMessage = flow(Effect.dieMessage, fromEffect)
-export const dieSync: <A>(f: LazyArg<A>) => Fx<never, never, never> = flow(
-  Effect.dieSync,
-  fromEffect,
-)
-
-export const done: <E, A>(exit: Exit<E, A>) => Fx<never, E, A> = flow(Effect.done, fromEffect)
-
-export const fromEither: <E, A>(either: Either<E, A>) => Fx<never, E, A> = flow(
-  Effect.fromEither,
-  fromEffect,
-)
-
-export const succeedLeft: <A>(value: A) => Fx<never, never, Either<A, never>> = flow(
-  Effect.succeedLeft,
-  fromEffect,
-)
-
-export const succeedRight: <A>(value: A) => Fx<never, never, Either<never, A>> = flow(
-  Effect.succeedRight,
-  fromEffect,
-)
-
-export const yieldNow = fromEffect(Effect.yieldNow)
-
-export const tryPromise: <A>(promise: LazyArg<Promise<A>>) => Fx<never, unknown, A> = flow(
-  Effect.tryPromise,
-  fromEffect,
-)
-
-export const tryCatchPromise = <A, E>(
-  promise: LazyArg<Promise<A>>,
-  onThrow: (u: unknown) => E,
-): Fx<never, E, A> => fromEffect(Effect.tryCatchPromise(promise, onThrow))
-
-export const tryCatch: <A, E>(f: LazyArg<A>, onThrow: (u: unknown) => E) => Fx<never, E, A> = flow(
-  Effect.tryCatch,
-  fromEffect,
-)
-
-export const sync: <A>(f: LazyArg<A>) => Fx<never, never, A> = flow(Effect.sync, fromEffect)
-
-export const async = flow(Effect.async, fromEffect)
-
-export const asyncEffect = flow(Effect.asyncEffect, fromEffect)
-
-export const asyncInterrupt = flow(Effect.asyncInterrupt, fromEffect)
-
-export const asyncMaybe: <R, E, A>(
-  register: (callback: (_: Effect.Effect<R, E, A>) => void) => Maybe<Effect.Effect<R, E, A>>,
-) => Fx<R, E, A> = flow(Effect.asyncMaybe, fromEffect)
-
-export const clock: Fx<never, never, Clock> = fromEffect(Effect.clock)
-
-export const environment = <R>(): Fx<R, never, Env<R>> => fromEffect(Effect.environment<R>())
-
-export const service = <R>(tag: Tag<R>): Fx<R, never, R> => fromEffect(Effect.service<R>(tag))
-
-export const environmentWith = flow(Effect.environmentWith, fromEffect)
-export const environmentWithEffect = flow(Effect.environmentWithEffect, fromEffect)
-
-export const descriptor: Fx<never, never, Fiber.Descriptor> = fromEffect(Effect.descriptor)
-
-export const descriptorWith = flow(Effect.descriptorWith, fromEffect)
-
-export const fromFiber = flow(Effect.fromFiber, fromEffect)
-export const fromFiberEffect = flow(Effect.fromFiberEffect, fromEffect)
-
-export const fromMaybe = flow(Effect.fromMaybe, fromEffect)

package/src/fromFxEffect.ts

@@ -1,31 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@fp-ts/data/Function'
-
-import { Fx } from './Fx.js'
-
-export function fromFxEffect<R, E, R2, E2, A>(
-  effectFx: Effect.Effect<R, E, Fx<R2, E2, A>>,
-): Fx<R | R2, E | E2, A> {
-  return Fx((emitter) =>
-    pipe(
-      effectFx,
-      Effect.foldCauseEffect(emitter.failCause, (fx) => fx.run(emitter)),
-    ),
-  )
-}
-
-export function fromFxGen<Eff extends Effect.GenEffect<any, any, any>, R2, E2, A>(
-  f: (i: Effect.Adapter) => Generator<Eff, Fx<R2, E2, A>, any>,
-): Fx<
-  ([Eff] extends [{ [Effect._GenR]: () => infer R }] ? R : never) | R2,
-  ([Eff] extends [{ [Effect._GenE]: () => infer E }] ? E : never) | E2,
-  A
-> {
-  return fromFxEffect<
-    [Eff] extends [{ [Effect._GenR]: () => infer R }] ? R : never,
-    [Eff] extends [{ [Effect._GenE]: () => infer E }] ? E : never,
-    R2,
-    E2,
-    A
-  >(Effect.gen(f))
-}

package/src/fromHub.ts

@@ -1,12 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Hub from '@effect/core/io/Hub'
-import { pipe } from '@fp-ts/data/Function'
-
-import { Fx } from './Fx.js'
-import { fromDequeue } from './fromDequeue.js'
-import { fromFxEffect } from './fromFxEffect.js'
-import { scoped } from './transform.js'
-
-export function fromHub<A>(hub: Hub.Hub<A>): Fx<never, never, A> {
-  return pipe(hub.subscribe, Effect.map(fromDequeue), fromFxEffect, scoped)
-}

package/src/fromIterable.ts

@@ -1,19 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-
-import { Emitter, Fx } from './Fx.js'
-
-export function fromIterable<A>(iterable: Iterable<A>): Fx<never, never, A> {
-  return new FromIterable(iterable)
-}
-
-export class FromIterable<A> implements Fx<never, never, A> {
-  readonly _R!: () => never
-  readonly _E!: () => never
-  readonly _A!: () => A
-
-  constructor(readonly iterable: Iterable<A>) {}
-
-  run<R2>(emitter: Emitter<R2, never, A>) {
-    return Effect.zipRight(emitter.end)(Effect.forEachDiscard(this.iterable, emitter.emit))
-  }
-}

package/src/hold.test.ts

@@ -1,49 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import * as Fiber from '@effect/core/io/Fiber'
-import * as Duration from '@tsplus/stdlib/data/Duration'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe('hold', () => {
-    it('emits values to late observers', async () => {
-      const value = Math.random()
-
-      let started = 0
-      const fx = pipe(
-        Fx.fromEffect(Effect.sync(() => started++)),
-        Fx.flatMap(() =>
-          Fx.mergeAll([
-            Fx.at(Duration.millis(0))(value),
-            Fx.at(Duration.millis(100))(value + 1),
-            Fx.at(Duration.millis(200))(value + 2),
-          ]),
-        ),
-        Fx.hold,
-      )
-
-      const test = Effect.gen(function* ($) {
-        const a = yield* $(Effect.fork(Fx.runCollect(fx)))
-
-        yield* $(Effect.sleep(Duration.millis(50)))
-
-        const b = yield* $(Effect.fork(Fx.runCollect(fx)))
-
-        yield* $(Effect.sleep(Duration.millis(100)))
-
-        const c = yield* $(Effect.fork(Fx.runCollect(fx)))
-
-        deepStrictEqual(yield* $(Fiber.join(a)), [value, value + 1, value + 2])
-        deepStrictEqual(yield* $(Fiber.join(b)), [value, value + 1, value + 2])
-        deepStrictEqual(yield* $(Fiber.join(c)), [value + 1, value + 2])
-
-        deepStrictEqual(started, 1)
-      })
-
-      await Effect.unsafeRunPromise(test)
-    })
-  })
-})