@clayroach/effect 3.19.14-source-capture.7 → 3.19.14-source-capture.8

package/src/TestClock.ts

@@ -1,556 +0,0 @@
-/**
- * @since 2.0.0
- */
-import * as Chunk from "./Chunk.js"
-import type * as Clock from "./Clock.js"
-import * as Context from "./Context.js"
-import * as DateTime from "./DateTime.js"
-import type * as Deferred from "./Deferred.js"
-import * as Duration from "./Duration.js"
-import type * as Effect from "./Effect.js"
-import * as Equal from "./Equal.js"
-import type * as Fiber from "./Fiber.js"
-import type * as FiberId from "./FiberId.js"
-import * as FiberStatus from "./FiberStatus.js"
-import { constVoid, dual, identity, pipe } from "./Function.js"
-import * as HashMap from "./HashMap.js"
-import * as clock from "./internal/clock.js"
-import * as effect from "./internal/core-effect.js"
-import * as core from "./internal/core.js"
-import * as defaultServices from "./internal/defaultServices.js"
-import * as circular from "./internal/effect/circular.js"
-import * as fiberRuntime from "./internal/fiberRuntime.js"
-import * as layer from "./internal/layer.js"
-import * as ref from "./internal/ref.js"
-import * as synchronized from "./internal/synchronizedRef.js"
-import * as SuspendedWarningData from "./internal/testing/suspendedWarningData.js"
-import * as WarningData from "./internal/testing/warningData.js"
-import type * as Layer from "./Layer.js"
-import * as number from "./Number.js"
-import * as Option from "./Option.js"
-import * as Order from "./Order.js"
-import type * as Ref from "./Ref.js"
-import type * as SortedSet from "./SortedSet.js"
-import type * as Synchronized from "./SynchronizedRef.js"
-import * as Annotations from "./TestAnnotations.js"
-import * as Live from "./TestLive.js"
-
-/**
- * A `TestClock` makes it easy to deterministically and efficiently test effects
- * involving the passage of time.
- *
- * Instead of waiting for actual time to pass, `sleep` and methods implemented
- * in terms of it schedule effects to take place at a given clock time. Users
- * can adjust the clock time using the `adjust` and `setTime` methods, and all
- * effects scheduled to take place on or before that time will automatically be
- * run in order.
- *
- * For example, here is how we can test `Effect.timeout` using `TestClock`:
- *
- * ```ts
- * import * as assert from "node:assert"
- * import { Duration, Effect, Fiber, TestClock, Option, pipe } from "effect"
- *
- * Effect.gen(function*() {
- *   const fiber = yield* pipe(
- *     Effect.sleep(Duration.minutes(5)),
- *     Effect.timeout(Duration.minutes(1)),
- *     Effect.fork
- *   )
- *   yield* TestClock.adjust(Duration.minutes(1))
- *   const result = yield* Fiber.join(fiber)
- *   assert.deepStrictEqual(result, Option.none())
- * })
- * ```
- *
- * Note how we forked the fiber that `sleep` was invoked on. Calls to `sleep`
- * and methods derived from it will semantically block until the time is set to
- * on or after the time they are scheduled to run. If we didn't fork the fiber
- * on which we called sleep we would never get to set the time on the line
- * below. Thus, a useful pattern when using `TestClock` is to fork the effect
- * being tested, then adjust the clock time, and finally verify that the
- * expected effects have been performed.
- *
- * @since 2.0.0
- */
-export interface TestClock extends Clock.Clock {
-  adjust(duration: Duration.DurationInput): Effect.Effect<void>
-  adjustWith(duration: Duration.DurationInput): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  readonly save: Effect.Effect<Effect.Effect<void>>
-  setTime(time: number): Effect.Effect<void>
-  readonly sleeps: Effect.Effect<Chunk.Chunk<number>>
-}
-
-/**
- * `Data` represents the state of the `TestClock`, including the clock time.
- *
- * @since 2.0.1
- */
-export interface Data {
-  readonly instant: number
-  readonly sleeps: Chunk.Chunk<readonly [number, Deferred.Deferred<void>]>
-}
-
-/**
- * @since 2.0.0
- */
-export const makeData = (
-  instant: number,
-  sleeps: Chunk.Chunk<readonly [number, Deferred.Deferred<void>]>
-): Data => ({
-  instant,
-  sleeps
-})
-
-/**
- * @since 2.0.0
- */
-export const TestClock: Context.Tag<TestClock, TestClock> = Context.GenericTag<TestClock>("effect/TestClock")
-
-/**
- * The warning message that will be displayed if a test is using time but is
- * not advancing the `TestClock`.
- *
- * @internal
- */
-const warning = "Warning: A test is using time, but is not advancing " +
-  "the test clock, which may result in the test hanging. Use TestClock.adjust to " +
-  "manually advance the time."
-
-/**
- * The warning message that will be displayed if a test is advancing the clock
- * but a fiber is still running.
- *
- * @internal
- */
-const suspendedWarning = "Warning: A test is advancing the test clock, " +
-  "but a fiber is not suspending, which may result in the test hanging. Use " +
-  "TestAspect.diagnose to identity the fiber that is not suspending."
-
-/** @internal */
-export class TestClockImpl implements TestClock {
-  [clock.ClockTypeId]: Clock.ClockTypeId = clock.ClockTypeId
-  constructor(
-    readonly clockState: Ref.Ref<Data>,
-    readonly live: Live.TestLive,
-    readonly annotations: Annotations.TestAnnotations,
-    readonly warningState: Synchronized.SynchronizedRef<WarningData.WarningData>,
-    readonly suspendedWarningState: Synchronized.SynchronizedRef<SuspendedWarningData.SuspendedWarningData>
-  ) {
-    this.currentTimeMillis = core.map(
-      ref.get(this.clockState),
-      (data) => data.instant
-    )
-    this.currentTimeNanos = core.map(
-      ref.get(this.clockState),
-      (data) => BigInt(data.instant * 1000000)
-    )
-  }
-
-  /**
-   * Unsafely returns the current time in milliseconds.
-   */
-  unsafeCurrentTimeMillis(): number {
-    return ref.unsafeGet(this.clockState).instant
-  }
-
-  /**
-   * Unsafely returns the current time in nanoseconds.
-   */
-  unsafeCurrentTimeNanos(): bigint {
-    return BigInt(ref.unsafeGet(this.clockState).instant * 1000000)
-  }
-
-  /**
-   * Returns the current clock time in milliseconds.
-   */
-  currentTimeMillis: Effect.Effect<number>
-
-  /**
-   * Returns the current clock time in nanoseconds.
-   */
-  currentTimeNanos: Effect.Effect<bigint>
-
-  /**
-   * Saves the `TestClock`'s current state in an effect which, when run, will
-   * restore the `TestClock` state to the saved state.
-   */
-  get save(): Effect.Effect<Effect.Effect<void>> {
-    return core.map(ref.get(this.clockState), (data) => ref.set(this.clockState, data))
-  }
-  /**
-   * Sets the current clock time to the specified instant. Any effects that
-   * were scheduled to occur on or before the new time will be run in order.
-   */
-  setTime(instant: number): Effect.Effect<void> {
-    return core.zipRight(this.warningDone(), this.run(() => instant))
-  }
-  /**
-   * Semantically blocks the current fiber until the clock time is equal to or
-   * greater than the specified duration. Once the clock time is adjusted to
-   * on or after the duration, the fiber will automatically be resumed.
-   */
-  sleep(durationInput: Duration.DurationInput): Effect.Effect<void> {
-    const duration = Duration.decode(durationInput)
-    return core.flatMap(core.deferredMake<void>(), (deferred) =>
-      pipe(
-        ref.modify(this.clockState, (data) => {
-          const end = data.instant + Duration.toMillis(duration)
-          if (end > data.instant) {
-            return [
-              true,
-              makeData(data.instant, pipe(data.sleeps, Chunk.prepend([end, deferred] as const)))
-            ] as const
-          }
-          return [false, data] as const
-        }),
-        core.flatMap((shouldAwait) =>
-          shouldAwait ?
-            pipe(this.warningStart(), core.zipRight(core.deferredAwait(deferred))) :
-            pipe(core.deferredSucceed(deferred, void 0), core.asVoid)
-        )
-      ))
-  }
-  /**
-   * Returns a list of the times at which all queued effects are scheduled to
-   * resume.
-   */
-  get sleeps(): Effect.Effect<Chunk.Chunk<number>> {
-    return core.map(
-      ref.get(this.clockState),
-      (data) => Chunk.map(data.sleeps, (_) => _[0])
-    )
-  }
-  /**
-   * Increments the current clock time by the specified duration. Any effects
-   * that were scheduled to occur on or before the new time will be run in
-   * order.
-   */
-  adjust(durationInput: Duration.DurationInput): Effect.Effect<void> {
-    const duration = Duration.decode(durationInput)
-    return core.zipRight(this.warningDone(), this.run((n) => n + Duration.toMillis(duration)))
-  }
-  /**
-   * Increments the current clock time by the specified duration. Any effects
-   * that were scheduled to occur on or before the new time will be run in
-   * order.
-   */
-  adjustWith(durationInput: Duration.DurationInput) {
-    const duration = Duration.decode(durationInput)
-    return <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-      fiberRuntime.zipLeftOptions(effect, this.adjust(duration), { concurrent: true })
-  }
-  /**
-   * Returns a set of all fibers in this test.
-   */
-  supervisedFibers(): Effect.Effect<SortedSet.SortedSet<Fiber.RuntimeFiber<unknown, unknown>>> {
-    return this.annotations.supervisedFibers
-  }
-  /**
-   * Captures a "snapshot" of the identifier and status of all fibers in this
-   * test other than the current fiber. Fails with the `void` value if any of
-   * these fibers are not done or suspended. Note that because we cannot
-   * synchronize on the status of multiple fibers at the same time this
-   * snapshot may not be fully consistent.
-   */
-  freeze(): Effect.Effect<HashMap.HashMap<FiberId.FiberId, FiberStatus.FiberStatus>, void> {
-    return core.flatMap(this.supervisedFibers(), (fibers) =>
-      pipe(
-        fibers,
-        effect.reduce(HashMap.empty<FiberId.FiberId, FiberStatus.FiberStatus>(), (map, fiber) =>
-          pipe(
-            fiber.status,
-            core.flatMap((status) => {
-              if (FiberStatus.isDone(status)) {
-                return core.succeed(HashMap.set(map, fiber.id() as FiberId.FiberId, status as FiberStatus.FiberStatus))
-              }
-              if (FiberStatus.isSuspended(status)) {
-                return core.succeed(HashMap.set(map, fiber.id() as FiberId.FiberId, status as FiberStatus.FiberStatus))
-              }
-              return core.fail(void 0)
-            })
-          ))
-      ))
-  }
-  /**
-   * Forks a fiber that will display a warning message if a test is using time
-   * but is not advancing the `TestClock`.
-   */
-  warningStart(): Effect.Effect<void> {
-    return synchronized.updateSomeEffect(this.warningState, (data) =>
-      WarningData.isStart(data) ?
-        Option.some(
-          pipe(
-            this.live.provide(
-              pipe(effect.logWarning(warning), effect.delay(Duration.seconds(5)))
-            ),
-            core.interruptible,
-            fiberRuntime.fork,
-            core.map((fiber) => WarningData.pending(fiber))
-          )
-        ) :
-        Option.none())
-  }
-  /**
-   * Cancels the warning message that is displayed if a test is using time but
-   * is not advancing the `TestClock`.
-   */
-  warningDone(): Effect.Effect<void> {
-    return synchronized.updateSomeEffect(this.warningState, (warningData) => {
-      if (WarningData.isStart(warningData)) {
-        return Option.some(core.succeed(WarningData.done))
-      }
-      if (WarningData.isPending(warningData)) {
-        return Option.some(pipe(core.interruptFiber(warningData.fiber), core.as(WarningData.done)))
-      }
-      return Option.none()
-    })
-  }
-
-  private yieldTimer = core.async<void>((resume) => {
-    const timer = setTimeout(() => {
-      resume(core.void)
-    }, 0)
-    return core.sync(() => clearTimeout(timer))
-  })
-
-  /**
-   * Returns whether all descendants of this fiber are done or suspended.
-   */
-  suspended(): Effect.Effect<HashMap.HashMap<FiberId.FiberId, FiberStatus.FiberStatus>, void> {
-    return pipe(
-      this.freeze(),
-      core.zip(pipe(this.yieldTimer, core.zipRight(this.freeze()))),
-      core.flatMap(([first, last]) =>
-        Equal.equals(first, last) ?
-          core.succeed(first) :
-          core.fail(void 0)
-      )
-    )
-  }
-  /**
-   * Polls until all descendants of this fiber are done or suspended.
-   */
-  awaitSuspended(): Effect.Effect<void> {
-    return pipe(
-      this.suspendedWarningStart(),
-      core.zipRight(
-        pipe(
-          this.suspended(),
-          core.zipWith(
-            pipe(this.yieldTimer, core.zipRight(this.suspended())),
-            Equal.equals
-          ),
-          effect.filterOrFail(identity, constVoid),
-          effect.eventually
-        )
-      ),
-      core.zipRight(this.suspendedWarningDone())
-    )
-  }
-  /**
-   * Forks a fiber that will display a warning message if a test is advancing
-   * the `TestClock` but a fiber is not suspending.
-   */
-  suspendedWarningStart(): Effect.Effect<void> {
-    return synchronized.updateSomeEffect(this.suspendedWarningState, (suspendedWarningData) => {
-      if (SuspendedWarningData.isStart(suspendedWarningData)) {
-        return Option.some(
-          pipe(
-            this.live.provide(
-              pipe(
-                effect.logWarning(suspendedWarning),
-                core.zipRight(ref.set(this.suspendedWarningState, SuspendedWarningData.done)),
-                effect.delay(Duration.seconds(5))
-              )
-            ),
-            core.interruptible,
-            fiberRuntime.fork,
-            core.map((fiber) => SuspendedWarningData.pending(fiber))
-          )
-        )
-      }
-      return Option.none()
-    })
-  }
-  /**
-   * Cancels the warning message that is displayed if a test is advancing the
-   * `TestClock` but a fiber is not suspending.
-   */
-  suspendedWarningDone(): Effect.Effect<void> {
-    return synchronized.updateSomeEffect(this.suspendedWarningState, (suspendedWarningData) => {
-      if (SuspendedWarningData.isPending(suspendedWarningData)) {
-        return Option.some(pipe(core.interruptFiber(suspendedWarningData.fiber), core.as(SuspendedWarningData.start)))
-      }
-      return Option.none()
-    })
-  }
-  /**
-   * Runs all effects scheduled to occur on or before the specified instant,
-   * which may depend on the current time, in order.
-   */
-  run(f: (instant: number) => number): Effect.Effect<void> {
-    return pipe(
-      this.awaitSuspended(),
-      core.zipRight(pipe(
-        ref.modify(this.clockState, (data) => {
-          const end = f(data.instant)
-          const sorted = pipe(
-            data.sleeps,
-            Chunk.sort<readonly [number, Deferred.Deferred<void>]>(
-              pipe(number.Order, Order.mapInput((_) => _[0]))
-            )
-          )
-          if (Chunk.isNonEmpty(sorted)) {
-            const [instant, deferred] = Chunk.headNonEmpty(sorted)
-            if (instant <= end) {
-              return [
-                Option.some([end, deferred] as const),
-                makeData(instant, Chunk.tailNonEmpty(sorted))
-              ] as const
-            }
-          }
-          return [Option.none(), makeData(end, data.sleeps)] as const
-        }),
-        core.flatMap((option) => {
-          switch (option._tag) {
-            case "None": {
-              return core.void
-            }
-            case "Some": {
-              const [end, deferred] = option.value
-              return pipe(
-                core.deferredSucceed(deferred, void 0),
-                core.zipRight(core.yieldNow()),
-                core.zipRight(this.run(() => end))
-              )
-            }
-          }
-        })
-      ))
-    )
-  }
-}
-
-/**
- * @since 2.0.0
- */
-export const live = (data: Data): Layer.Layer<TestClock, never, Annotations.TestAnnotations | Live.TestLive> =>
-  layer.scoped(
-    TestClock,
-    core.gen(function*() {
-      const live = yield* Live.TestLive
-      const annotations = yield* Annotations.TestAnnotations
-      const clockState = yield* core.sync(() => ref.unsafeMake(data))
-      const warningState = yield* circular.makeSynchronized(WarningData.start)
-      const suspendedWarningState = yield* circular.makeSynchronized(SuspendedWarningData.start)
-      const testClock = new TestClockImpl(clockState, live, annotations, warningState, suspendedWarningState)
-      yield* fiberRuntime.withClockScoped(testClock)
-      yield* fiberRuntime.addFinalizer(
-        () => core.zipRight(testClock.warningDone(), testClock.suspendedWarningDone())
-      )
-      return testClock
-    })
-  )
-
-/**
- * @since 2.0.0
- */
-export const defaultTestClock: Layer.Layer<TestClock, never, Annotations.TestAnnotations | Live.TestLive> = live(
-  makeData(new Date(0).getTime(), Chunk.empty())
-)
-
-/**
- * Accesses a `TestClock` instance in the context and increments the time
- * by the specified duration, running any actions scheduled for on or before
- * the new time in order.
- *
- * @since 2.0.0
- */
-export const adjust = (durationInput: Duration.DurationInput): Effect.Effect<void> => {
-  const duration = Duration.decode(durationInput)
-  return testClockWith((testClock) => testClock.adjust(duration))
-}
-
-/**
- * @since 2.0.0
- */
-export const adjustWith = dual<
-  (duration: Duration.DurationInput) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R>(effect: Effect.Effect<A, E, R>, duration: Duration.DurationInput) => Effect.Effect<A, E, R>
->(2, (effect, durationInput) => {
-  const duration = Duration.decode(durationInput)
-  return testClockWith((testClock) => testClock.adjustWith(duration)(effect))
-})
-
-/**
- * Accesses a `TestClock` instance in the context and saves the clock
- * state in an effect which, when run, will restore the `TestClock` to the
- * saved state.
- *
- * @since 2.0.0
- */
-export const save = (): Effect.Effect<Effect.Effect<void>> => testClockWith((testClock) => testClock.save)
-
-/**
- * Accesses a `TestClock` instance in the context and sets the clock time
- * to the specified `Instant` or `Date`, running any actions scheduled for on or before
- * the new time in order.
- *
- * @since 2.0.0
- */
-export const setTime = (input: DateTime.DateTime.Input): Effect.Effect<void> =>
-  testClockWith((testClock) =>
-    testClock.setTime(
-      typeof input === "number"
-        ? input
-        : DateTime.unsafeMake(input).epochMillis
-    )
-  )
-
-/**
- * Semantically blocks the current fiber until the clock time is equal to or
- * greater than the specified duration. Once the clock time is adjusted to
- * on or after the duration, the fiber will automatically be resumed.
- *
- * @since 2.0.0
- */
-export const sleep = (durationInput: Duration.DurationInput): Effect.Effect<void> => {
-  const duration = Duration.decode(durationInput)
-  return testClockWith((testClock) => testClock.sleep(duration))
-}
-
-/**
- * Accesses a `TestClock` instance in the context and returns a list of
- * times that effects are scheduled to run.
- *
- * @since 2.0.0
- */
-export const sleeps = (): Effect.Effect<Chunk.Chunk<number>> => testClockWith((testClock) => testClock.sleeps)
-
-/**
- * Retrieves the `TestClock` service for this test.
- *
- * @since 2.0.0
- */
-export const testClock = (): Effect.Effect<TestClock> => testClockWith(core.succeed)
-
-/**
- * Retrieves the `TestClock` service for this test and uses it to run the
- * specified workflow.
- *
- * @since 2.0.0
- */
-export const testClockWith = <A, E, R>(f: (testClock: TestClock) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-  core.fiberRefGetWith(
-    defaultServices.currentServices,
-    (services) => f(pipe(services, Context.get(clock.clockTag)) as TestClock)
-  )
-
-/**
- * Accesses the current time of a `TestClock` instance in the context in
- * milliseconds.
- *
- * @since 2.0.0
- */
-export const currentTimeMillis: Effect.Effect<number> = testClockWith((testClock) => testClock.currentTimeMillis)

package/src/TestConfig.ts

@@ -1,47 +0,0 @@
-/**
- * @since 2.0.0
- */
-import * as Context from "./Context.js"
-
-/**
- * The `TestConfig` service provides access to default configuration settings
- * used by tests, including the number of times to repeat tests to ensure
- * they are stable, the number of times to retry flaky tests, the sufficient
- * number of samples to check from a random variable, and the maximum number of
- * shrinkings to minimize large failures.
- *
- * @since 2.0.0
- */
-export interface TestConfig {
-  /**
-   * The number of times to repeat tests to ensure they are stable.
-   */
-  readonly repeats: number
-  /**
-   * The number of times to retry flaky tests.
-   */
-  readonly retries: number
-  /**
-   * The number of sufficient samples to check for a random variable.
-   */
-  readonly samples: number
-  /**
-   * The maximum number of shrinkings to minimize large failures
-   */
-  readonly shrinks: number
-}
-
-/**
- * @since 2.0.0
- */
-export const TestConfig: Context.Tag<TestConfig, TestConfig> = Context.GenericTag<TestConfig>("effect/TestConfig")
-
-/**
- * @since 2.0.0
- */
-export const make = (params: {
-  readonly repeats: number
-  readonly retries: number
-  readonly samples: number
-  readonly shrinks: number
-}): TestConfig => params

package/src/TestContext.ts

@@ -1,36 +0,0 @@
-/**
- * @since 2.0.0
- */
-import type * as DefaultServices from "./DefaultServices.js"
-import { pipe } from "./Function.js"
-import * as defaultServices from "./internal/defaultServices.js"
-import * as layer from "./internal/layer.js"
-import type * as Layer from "./Layer.js"
-import * as TestClock from "./TestClock.js"
-import * as TestServices from "./TestServices.js"
-
-/** @internal */
-export const live: Layer.Layer<TestServices.TestServices, never, DefaultServices.DefaultServices> = pipe(
-  TestServices.annotationsLayer(),
-  layer.merge(TestServices.liveLayer()),
-  layer.merge(TestServices.sizedLayer(100)),
-  layer.merge(pipe(
-    TestClock.defaultTestClock,
-    layer.provideMerge(
-      layer.merge(TestServices.liveLayer(), TestServices.annotationsLayer())
-    )
-  )),
-  layer.merge(TestServices.testConfigLayer({ repeats: 100, retries: 100, samples: 200, shrinks: 1000 }))
-)
-
-/**
- * @since 2.0.0
- */
-export const LiveContext: Layer.Layer<DefaultServices.DefaultServices> = layer.syncContext(() =>
-  defaultServices.liveServices
-)
-
-/**
- * @since 2.0.0
- */
-export const TestContext: Layer.Layer<TestServices.TestServices> = layer.provideMerge(live, LiveContext)

package/src/TestLive.ts

@@ -1,53 +0,0 @@
-/**
- * @since 2.0.0
- */
-import * as Context from "./Context.js"
-import type * as DefaultServices from "./DefaultServices.js"
-import type * as Effect from "./Effect.js"
-import * as core from "./internal/core.js"
-import * as defaultServices from "./internal/defaultServices.js"
-
-/**
- * @since 2.0.0
- */
-export const TestLiveTypeId: unique symbol = Symbol.for("effect/TestLive")
-
-/**
- * @since 2.0.0
- */
-export type TestLiveTypeId = typeof TestLiveTypeId
-
-/**
- * The `Live` trait provides access to the "live" default Effect services from
- * within tests for workflows such as printing test results to the console or
- * timing out tests where it is necessary to access the real implementations of
- * these services.
- *
- * @since 2.0.0
- */
-export interface TestLive {
-  readonly [TestLiveTypeId]: TestLiveTypeId
-  provide<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
-}
-
-/**
- * @since 2.0.0
- */
-export const TestLive: Context.Tag<TestLive, TestLive> = Context.GenericTag<TestLive>("effect/TestLive")
-
-/** @internal */
-class LiveImpl implements TestLive {
-  readonly [TestLiveTypeId]: TestLiveTypeId = TestLiveTypeId
-  constructor(readonly services: Context.Context<DefaultServices.DefaultServices>) {}
-  provide<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> {
-    return core.fiberRefLocallyWith(
-      defaultServices.currentServices,
-      Context.merge(this.services)
-    )(effect)
-  }
-}
-
-/**
- * @since 2.0.0
- */
-export const make = (services: Context.Context<DefaultServices.DefaultServices>): TestLive => new LiveImpl(services)