@shivaedev/test 0.0.0-stage → 0.9.0

package/CHANGELOG.md

@@ -0,0 +1,140 @@
+# Changelog
+
+## 0.9.0 - 2026-10-25
+
+### Added
+
+- `@shivaedev/effect-test` readiness retries accept `timeout` and `wait` options. A timeout preserves the final typed failure; a custom wait lets adapters settle observable work through the same retry engine.
+
+### Breaking
+
+- `@shivaedev/effect-react/client/testing.ts` now returns an Effect from `eventually(assert)`. Replace `yield* Effect.promise(() => eventually(assert))` with `yield* eventually(assert)` in stories and Effect tests, or replace `await eventually(assert)` with `await Effect.runPromise(eventually(assert))` in async tests. Assertions wait inside React `act` in live time, including under TestClock. Timeout errors include elapsed milliseconds and the last assertion message, with the assertion error as their `cause`.
+
+## 0.8.1 - 2026-10-25
+
+### Fixed
+
+- Close shared test service Layers before their test file completes so database cleanup finishes before Vitest starts terminating the fork.
+
+## 0.8.0 - 2026-10-25
+
+### Breaking
+
+- Move `@shivaedev/effect-test/vitest.ts` to `@shivaedev/effect-test/makeEffectIt.ts`. Change imports to `@shivaedev/effect-test/makeEffectIt.ts`; the exported `makeEffectIt` function is unchanged.
+
+## 0.7.2 - 2026-10-24
+
+### Changed
+
+- Require Effect and its companion packages at exactly 4.0.5. Generated applications use the same versions.
+
+## 0.7.1 - 2026-10-18
+
+### Fixed
+
+- Wait for an interrupted test's Scope to close after its Vitest timeout, so application workers and database pools finish teardown before the next test starts. Keep the timeout as the test failure without leaking the interrupted program's rejection as an uncaught error.
+
+## 0.7.0 - 2026-10-18
+
+### Added
+
+- Pass a UTC `DateTime` to the existing `clock` option to pin a story or Effect fixture before its per-test setup runs. The exported `EffectClock` type now accepts `DateTime.Utc` alongside `"test"` and `"live"`. Hosts, workers and screens acquired with the story's Effect Context share native `Clock` / `TestClock`, including explicit `TestClock.adjust` advances; application code using `Clock` or `DateTime.now` needs no changes.
+
+## 0.6.0 - 2026-10-18
+
+### Breaking
+
+- Modules are named in camelCase: `any-test-layer.ts` becomes `anyTestLayer.ts`.
+
+## 0.5.0 - 2026-10-16
+
+### Added
+
+- `withLive(effect)` from `@shivaedev/effect-test/withLive.ts` runs sleeps and readiness polls in live time under either TestClock or the live clock, without advancing the surrounding TestClock.
+
+## 0.4.0 - 2026-10-13
+
+### Breaking
+
+- Requires stable Effect 4.0.4 in place of 4.0.0-rc.112. Effect 4.0.4 moves the former `effect/unstable/*` modules to `effect/*` and renames constructors such as `Config.string` to `Config.String`. Install `@effect/vitest` 4.0.4 alongside it, which requires Vitest 5.
+
+## 0.3.2 - 2026-10-12
+
+### Added
+
+- `makeEffectIt` fixture testers accept Effect-returning bodies as well as generators, including table cases and tester variants. Both forms retain harness, service, clock and per-test Scope behavior.
+- Export `EffectTestBody<THarness, TProvided, A>` from `types.ts` to describe both fixture body forms.
+- `makeEffectIt` harnesses, wrappers, generator bodies and table bodies can use the per-test `Scope` already supplied by the runner. The worker Context and inferred Layer services stay unchanged; unrelated services still require a matching Layer.
+
+### Changed
+
+- Name descriptive generic type parameters with a `T` prefix, preserving test runner types and behavior.
+- Verify conditional skipping in an isolated Vitest fixture, with passing suite assertions for registration and body non-execution instead of a skipped suite test.
+- Explain the runner's purpose, service and test lifetimes, clock choices and typed readiness polling in the README, agent north star and package docs; publish `docs/` with the README.
+- Build package JavaScript, declarations and source maps with TypeScript 7.
+
+## 0.3.1 - 2026-10-06
+
+### Fixed
+
+- `makeEffectIt` takes a Layer that provides nothing, such as `Layer.empty`, so a suite whose tests need no services passes no placeholder service. A test body that yields a service such a Layer does not provide still does not type-check.
+- `@shivaedev/effect-test/any-test-layer.ts` exports `buildTestLayer(layer, scope)`, which builds any test Layer, `Layer.empty` included, into the services it provides.
+
+## 0.3.0 - 2026-10-05
+
+### Added
+
+- `@shivaedev/effect-test/it.ts` exports `it`: the `it` of `@effect/vitest`, whose `effect` and `live` testers also take a generator function and run it with `Effect.gen`, so a test reads `it.effect("loads the item", function* () { … })`. They take a function that returns an Effect as well, as `@effect/vitest`'s testers do, so a file switches its import without rewriting other tests. Each tester supports `each`, `fails`, `only`, `runIf`, `skip` and `skipIf`, runs the body in a Scope, and types the yielded values, failures and requirements: a body that needs a service the test does not provide does not type-check. `effect` installs the test services, such as TestClock; `live` uses the live ones. The types are `EffectIt`, `EffectItTest` and `EffectItTester` in `@shivaedev/effect-test/types.ts`.
+
+## 0.2.0 - 2026-10-04
+
+### Changed
+
+- Breaking: no root entry and no module that re-exports another. `exports` maps one `"./*.ts"` pattern to every module (`src` under the `source` condition, `dist` otherwise), so you import the module that defines a name, and a bundler sees only the modules you use. Where each name now lives:
+  - `@shivaedev/effect-test`: `@shivaedev/effect-test/eventually.ts` (`EventuallyOptions`, `eventually`), `@shivaedev/effect-test/types.ts` (`EffectClock`, `EffectTest`, `EffectTester`, `EffectTestOptions`, `MakeEffectItOptions`, `MakeEffectItResult`), `@shivaedev/effect-test/vitest.ts` (`makeEffectIt`)
+
+## 0.1.3 - 2026-10-04
+
+### Changed
+
+- Imports that leave their folder go through `#` aliases declared in the `imports` field of `package.json`: `#*.ts` resolves to `src` under the `source` condition and to `dist` otherwise, and `#test/*` names a test file. The published modules and declarations name the package's own files through these aliases.
+
+- Consolidate duplicate test cases around observable package behavior.
+
+- Validate packed consumers and executable bins through the shared workspace gate.
+
+- Build with the `@shivaedev/quality` tsconfig presets, which target ESNext and allow only erasable TypeScript syntax.
+
+- Type-check with TypeScript 7 only. TypeScript 6 still builds the package.
+
+- Lint and format with the `@shivaedev/quality` Biome preset through `quality lint` at the repository root, which replaces the package's `check` script.
+
+- Run tests through the `@shivaedev/quality` Vitest projects, which take a test's environment from its file name. Type tests are named `*.typecheck.test.ts`.
+
+- Keep `package.json` in sort-package-json key order, checked by `quality lint`.
+
+## 0.1.2 - 2026-09-26
+
+### Fixed
+
+- Make `eventually` retry only typed failures under TestClock, matching the live
+  clock. Defects and interruption propagate without retrying.
+
+### Changed
+
+- Document the live worker-Layer clock and the scope of per-test clock overrides.
+
+## 0.1.1 - 2026-09-04
+
+### Changed
+
+- Require Effect 4.0.0-rc.112, so applications tracking the current release
+  candidate install without unmet peer warnings.
+
+## 0.1.0 - 2026-08-30
+
+### Added
+
+- Add `makeEffectIt` for generator Effect tests on a worker-scoped Layer, with
+  TestClock by default, an optional `around` hook, and a Clock-aware
+  `eventually` helper.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ShivaeDev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,243 @@
-# Temporary Holding Version
+# @shivaedev/test
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Effect tests should spend their lines on the behavior they check. This package gives ordinary tests and reusable fixtures one Vitest runner, so a generator can use the application's services and a controlled clock without repeating the runner around every test.
+
+## Why you want this
+
+Wrapping every body in `Effect.gen` hides the test's work, and copying a runner into each fixture makes service and clock setup drift. Pass the generator itself and read the test from top to bottom:
+
+```ts
+import { expect } from "@effect/vitest";
+import { Clock } from "effect";
+import * as TestClock from "effect/testing/TestClock";
+import { it } from "@shivaedev/test/it.ts";
+
+it.effect("advances the test's time", function* () {
+  expect(yield* Clock.currentTimeMillis).toBe(0);
+  yield* TestClock.adjust("1 second");
+  expect(yield* Clock.currentTimeMillis).toBe(1000);
+});
+```
+
+That is a whole test. The body starts at time zero and advances its clock by one second. For a suite that needs services, the same package makes a tester from a Layer and a harness, so the suite defines its plumbing once and each spec keeps its own work.
+
+## Using it
+
+### How to think about it
+
+There are two ways to enter the runner. `it.effect` and `it.live` are the ordinary testers: their body receives Vitest's test context and uses services it provides inside its own Effect. `makeEffectIt` defines a tester for a reusable fixture: its body receives a harness first, then the test context, and can yield the services its Layer provides.
+
+A **Layer** describes how to acquire the fixture's services. `makeEffectIt` builds it in a Vitest file fixture and retains the resulting Effect **Context**, the map from service keys to service values. A **harness** is the value made for one test using those services. It can hold a service, a fixture identifier or the domain entry points the test needs. The **test context** is Vitest's context, with the test's name, assertion helpers and hooks; it is a different thing from Effect's Context.
+
+Keep the two lifetimes separate. The file owns the acquired Layer and its scope; its finalizers finish before Vitest reports the file complete. Each test makes its harness and runs its body in a separate scope. Harnesses, wrappers, generator bodies and `each` bodies may acquire resources through that Scope; their finalizers run on success, failure and interruption. Scope is available per test and is not added to the file Context. A shared service can retain mutable state across tests; a fresh harness alone does not reset it. Put application-state isolation in the fixture that owns that state, such as a database transaction wrapper.
+
+The work usually splits into two parts:
+
+1. Once per fixture, define its Layer, `makeHarness` and, when needed, an `around` wrapper in test support.
+2. In every test, write the generator and the assertions. For a test with no reusable fixture, use `it.effect` directly.
+
+### 1. Once per fixture: services and the harness
+
+```ts
+import { expect } from "@effect/vitest";
+import { Clock, Context, Effect, Layer } from "effect";
+import { makeEffectIt } from "@shivaedev/test/makeEffectIt.ts";
+
+class Token extends Context.Service<Token, string>()("test/Token") {}
+
+const { effectApp } = makeEffectIt({
+  layer: Layer.succeed(Token, "from-layer"),
+  makeHarness: (context) => Effect.gen(function* () {
+    return {
+      name: context.task.name,
+      token: yield* Token,
+    };
+  }),
+});
+
+effectApp("reads the fixture's services", function* (harness, context) {
+  expect(harness.token).toBe("from-layer");
+  expect(harness.name).toBe(context.task.name);
+  expect(yield* Token).toBe("from-layer");
+});
+```
+
+The Layer supplies `Token`. `makeHarness` runs for the test and reads that same service; the generator receives its result and can also yield `Token` directly. Harness fields and provided services keep their types. A body that requires a service the Layer does not provide does not type-check.
+
+A fixture that needs no services uses `Layer.empty`. This separate module replaces the token fixture above:
+
+```ts
+import { expect } from "@effect/vitest";
+import { Effect, Layer } from "effect";
+import { makeEffectIt } from "@shivaedev/test/makeEffectIt.ts";
+
+const { effectApp } = makeEffectIt({
+  layer: Layer.empty,
+  makeHarness: () => Effect.succeed({ shelf: 0 }),
+});
+
+effectApp("uses a harness without services", function* (harness) {
+  expect(harness.shelf).toBe(0);
+});
+```
+
+There is no placeholder service. The harness is still inferred, and a body that tries to yield `Token` from this fixture does not compile. The Layer itself must have no unmet service requirements: compose its dependencies before passing it to the factory.
+
+#### Wrapping the harness and body
+
+This alternative token fixture adds a tracing wrapper:
+
+```ts
+import { expect } from "@effect/vitest";
+import { Context, Effect, Layer } from "effect";
+import { makeEffectIt } from "@shivaedev/test/makeEffectIt.ts";
+
+class Token extends Context.Service<Token, string>()("test/Token") {}
+
+const { effectApp } = makeEffectIt({
+  around: (effect) => Effect.withSpan(effect, "test.token"),
+  layer: Layer.succeed(Token, "from-layer"),
+  makeHarness: () => Effect.service(Token),
+});
+
+effectApp("reads the harness", function* (token) {
+  expect(token).toBe("from-layer");
+});
+```
+
+`around` receives the Effect that makes the harness and then runs the body. The wrapper also has the Layer's services. This is where a fixture composes its tracing or transaction boundary. The database package owns whether that transaction rolls back; this runner does not add a database policy. The later examples use the first token fixture, whose harness contains `token` and `name`.
+
+`@shivaedev/test-story` builds domain stories above it and owns traits, verbs, engine stepping and failure narration. Use those helpers when the test needs their vocabulary; use this runner when defining the fixture underneath. An application-owned story kit can lease PostgreSQL through its file Layer, use `around` for real-commit resets or local rollback, and acquire servers, native RPC clients and React roots through per-test Scope. The [order feature kit](https://github.com/ShivaeDev/platform/tree/main/packages/react/src/test-support/order-example) demonstrates that composition; [test-story’s kit guide](https://github.com/ShivaeDev/platform/tree/main/packages/test-story#whole-stack-application-kits) explains the application’s isolation, seed and screen responsibilities.
+
+### 2. In every test: the generator
+
+```ts
+import { expect } from "@effect/vitest";
+import { Effect } from "effect";
+import { it } from "@shivaedev/test/it.ts";
+
+it.effect("reads an Effect result", function* ({ task }) {
+  expect(task.name).toBe("reads an Effect result");
+  expect(yield* Effect.succeed(3)).toBe(3);
+});
+
+it.effect("accepts an Effect-returning body", () =>
+  Effect.sync(() => expect(3).toBe(3)),
+);
+
+it.effect.each([1, 2])("passes the case %s", function* (count) {
+  expect(yield* Effect.succeed(count)).toBe(count);
+});
+```
+
+The ordinary body receives Vitest's context. An `each` body receives the table case instead. Both generator and Effect-returning bodies are accepted. `it` itself remains the plain Vitest tester.
+
+For a fixture's `effectApp.each`, the arguments are the case, harness and context:
+
+```ts
+effectApp.each(["alpha", "beta"])("checks %s", function* (item, harness, context) {
+  expect(context.task.name).toContain(item);
+  expect(harness.token).toBe("from-layer");
+});
+```
+
+This uses the token fixture from the first example. Case and harness types are inferred. A synchronous DOM fixture test can return `Effect.sync(() => expect(harness.token).toBe("from-layer"))`; the harness, services and per-test Scope are the same for both body forms.
+
+### Choosing which clock runs the test
+
+`it.effect` uses TestClock; `it.live` uses live time. A fixture defaults to `clock: "test"`. Its factory may choose `clock: "live"`, and a single test may override the factory in either direction:
+
+```ts
+effectApp("reads live time", function* () {
+  expect(yield* Clock.currentTimeMillis).toBeGreaterThan(1_000_000);
+}, { clock: "live" });
+```
+
+The override changes the per-test environment used by the wrapper, harness and body. A UTC `DateTime` also works as `clock`: it selects native TestClock and sets its initial instant before the wrapper or harness runs. `TestClock.adjust` advances that clock explicitly. For example, `{ clock: DateTime.makeUnsafe("2026-10-17T12:34:56.000Z") }` pins time to that UTC instant; import `DateTime` from `effect`. The same option is available on a fixture's factory.
+
+Worker acquisition is separate: a Layer that reads the default Clock while it is being built sees live time, even when its tests use TestClock.
+
+A `Clock.Clock` supplied by the fixture's Layer takes precedence over the runner's default Clock in the wrapper, harness and body. Reads and sleeps use that fixture Clock, including explicit advancement when it is a native TestClock.
+
+Both test and live clock fixtures install a fresh native TestConsole for each test. `Console.log` from `effect` is captured by `TestConsole.logLines` from `effect/testing/TestConsole`; one test's output does not carry into the next.
+
+### Waiting for a typed readiness condition
+
+`eventually(effect, options)` retries the Effect's typed failures until it succeeds or uses its retry budget. It uses the active Clock: under TestClock it advances time with `TestClock.adjust`; under live time it waits with `Effect.sleep`.
+
+```ts
+import { eventually } from "@shivaedev/test/eventually.ts";
+
+effectApp("reaches the selected time", function* () {
+  const readyAt = yield* eventually(
+    Effect.gen(function* () {
+      const now = yield* Clock.currentTimeMillis;
+      return now >= 50 ? now : yield* Effect.fail("too-early");
+    }),
+    { interval: "7 millis", times: 8 },
+  );
+
+  expect(readyAt).toBe(56);
+});
+```
+
+The attempts see 0, 7, 14 and subsequent multiples of 7 through 56 milliseconds. `times` counts retries after the initial attempt, so `times: 0` tries once. When the budget runs out, the final typed failure remains the failure. `timeout` sets an elapsed-time budget on the active clock, checked after a failed attempt. `wait` replaces the interval delay with a settlement Effect, so adapters such as React testing can own how pending work settles.
+
+A thrown assertion is a defect, so it escapes on the first attempt. Interruption also escapes immediately. Capture an assertion with `Effect.try` only when its failure means the state is not ready yet:
+
+```ts
+effectApp("retries a readiness assertion", function* () {
+  let attempts = 0;
+
+  yield* eventually(
+    Effect.try(() => {
+      attempts += 1;
+      expect(attempts).toBe(3);
+    }),
+    { interval: "1 millis", times: 3 },
+  );
+
+  expect(attempts).toBe(3);
+});
+```
+
+This distinction applies under both clocks. The helper preserves the Effect's success, error and service types.
+
+### Waiting in live time without advancing TestClock
+
+Use `withLive(effect)` from `@shivaedev/test/withLive.ts` for a real-time sleep or readiness poll in a harness, hook or story step. Under TestClock it delegates to native `TestClock.withLive`; under a live clock it runs the Effect directly. The surrounding clock is restored afterward, so waiting for external work does not move virtual token expiry.
+
+```ts
+import { withLive } from "@shivaedev/test/withLive.ts";
+
+yield* withLive(Effect.sleep("10 millis"));
+yield* withLive(eventually(queueIsEmpty, { interval: "10 millis", times: 100 }));
+```
+
+The entire wrapped Effect, including readiness checks and retry delays, uses live time. The same call works when a kit defaults to a live clock and one story opts into TestClock. Success, typed failure and service requirements are preserved.
+
+### API
+
+Import the module that defines the name; the package has no root entry.
+
+| Module | Exports |
+| --- | --- |
+| `@shivaedev/test/it.ts` | `it`, with generator-aware `effect` and `live` testers. |
+| `@shivaedev/test/makeEffectIt.ts` | `makeEffectIt({ layer, makeHarness, around?, clock? })`, returning `{ effectApp }`. |
+| `@shivaedev/test/eventually.ts` | `eventually(effect, options?)` and `EventuallyOptions`. |
+| `@shivaedev/test/withLive.ts` | `withLive(effect)`, a live-time region under either clock. |
+| `@shivaedev/test/anyTestLayer.ts` | `AnyTestLayer` and `buildTestLayer(layer, scope)`, an Effect that builds the Layer's service Context in the supplied scope. |
+| `@shivaedev/test/types.ts` | `EffectClock`, `EffectTestOptions`, `EffectTestBody`, `EffectTest`, `EffectTester`, `MakeEffectItOptions`, `MakeEffectItResult`, `EffectItTest`, `EffectItTester` and `EffectIt`. |
+
+`eventually` waits `"10 millis"` between attempts by default; omitting `times` leaves retries unbounded.
+
+### Install, setup and limits
+
+```sh
+pnpm add --save-dev @shivaedev/test @effect/vitest@4.0.5 effect@4.0.5 vitest@5.0.3
+```
+
+The package declares `effect` as a peer and `@effect/vitest` as an optional peer. The Vitest runner modules require `@effect/vitest`; install it when using them. The package requires Node.js 24 or later. Use peer versions compatible with the package's `package.json`.
+
+- Define a fixture tester in test support and import it from Vitest tests. Calling `makeEffectIt` declares a Vitest fixture; it is not an application runtime factory.
+- An unbounded readiness poll can run until Vitest ends the test. Set a retry budget when the condition may never become true.

package/dist/anyTestLayer.d.ts

@@ -0,0 +1,4 @@
+import { type Context, type Effect, Layer, type Scope } from "effect";
+export type AnyTestLayer = Layer.Layer<any, any, never> | Layer.Layer<never, any, never>;
+export declare function buildTestLayer<TLayer extends AnyTestLayer>(layer: TLayer, scope: Scope.Scope): Effect.Effect<Context.Context<Layer.Success<TLayer>>, unknown>;
+//# sourceMappingURL=anyTestLayer.d.ts.map

package/dist/anyTestLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anyTestLayer.d.ts","sourceRoot":"","sources":["../src/anyTestLayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAC;AAEtE,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAGzF,wBAAgB,cAAc,CAAC,MAAM,SAAS,YAAY,EACzD,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,KAAK,CAAC,KAAK,GAChB,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC"}

package/dist/anyTestLayer.js

@@ -0,0 +1,5 @@
+import { Layer } from "effect";
+export function buildTestLayer(layer, scope) {
+    return Layer.buildWithScope(layer, scope);
+}
+//# sourceMappingURL=anyTestLayer.js.map

package/dist/anyTestLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anyTestLayer.js","sourceRoot":"","sources":["../src/anyTestLayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,EAAc,MAAM,QAAQ,CAAC;AAStE,MAAM,UAAU,cAAc,CAAC,KAAyC,EAAE,KAAkB;IAC3F,OAAO,KAAK,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAC3C,CAAC"}

package/dist/eventually.d.ts

@@ -0,0 +1,9 @@
+import { Duration, Effect } from "effect";
+export interface EventuallyOptions {
+    readonly interval?: Duration.Input;
+    readonly timeout?: Duration.Input;
+    readonly times?: number;
+    readonly wait?: Effect.Effect<void>;
+}
+export declare const eventually: <A, E, R>(effect: Effect.Effect<A, E, R>, options?: EventuallyOptions | undefined) => Effect.Effect<A, E, R>;
+//# sourceMappingURL=eventually.d.ts.map

package/dist/eventually.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventually.d.ts","sourceRoot":"","sources":["../src/eventually.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,QAAQ,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AAGzD,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;IAClC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CACpC;AAED,eAAO,MAAM,UAAU,GAAgC,CAAC,EAAE,CAAC,EAAE,CAAC,oGAwB5D,CAAC"}

package/dist/eventually.js

@@ -0,0 +1,25 @@
+import { Clock, Duration, Effect, Result } from "effect";
+import * as TestClock from "effect/testing/TestClock";
+export const eventually = Effect.fnUntraced(function* (effect, options) {
+    const clock = yield* Clock.Clock;
+    const started = yield* Clock.currentTimeMillis;
+    const timeout = options?.timeout === undefined ? undefined : Duration.toMillis(Duration.fromInputUnsafe(options.timeout));
+    const interval = options?.interval ?? "10 millis";
+    const wait = options?.wait ?? ("adjust" in clock ? TestClock.adjust(interval) : Effect.sleep(interval));
+    let retriesLeft = options?.times;
+    for (;;) {
+        const result = yield* Effect.result(effect);
+        if (Result.isSuccess(result)) {
+            return result.success;
+        }
+        const elapsed = (yield* Clock.currentTimeMillis) - started;
+        if (retriesLeft === 0 || (timeout !== undefined && elapsed >= timeout)) {
+            return yield* Effect.fail(result.failure);
+        }
+        if (retriesLeft !== undefined) {
+            retriesLeft -= 1;
+        }
+        yield* wait;
+    }
+});
+//# sourceMappingURL=eventually.js.map

package/dist/eventually.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventually.js","sourceRoot":"","sources":["../src/eventually.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACzD,OAAO,KAAK,SAAS,MAAM,0BAA0B,CAAC;AAStD,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EACpD,MAA8B,EAC9B,OAA2B;IAE3B,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC;IACjC,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC;IAC/C,MAAM,OAAO,GAAG,OAAO,EAAE,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,eAAe,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1H,MAAM,QAAQ,GAAG,OAAO,EAAE,QAAQ,IAAI,WAAW,CAAC;IAClD,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;IACxG,IAAI,WAAW,GAAG,OAAO,EAAE,KAAK,CAAC;IACjC,SAAS,CAAC;QACT,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5C,IAAI,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;YAC9B,OAAO,MAAM,CAAC,OAAO,CAAC;QACvB,CAAC;QACD,MAAM,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,OAAO,CAAC;QAC3D,IAAI,WAAW,KAAK,CAAC,IAAI,CAAC,OAAO,KAAK,SAAS,IAAI,OAAO,IAAI,OAAO,CAAC,EAAE,CAAC;YACxE,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC3C,CAAC;QACD,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC/B,WAAW,IAAI,CAAC,CAAC;QAClB,CAAC;QACD,KAAK,CAAC,CAAC,IAAI,CAAC;IACb,CAAC;AACF,CAAC,CAAC,CAAC"}

package/dist/internal/environmentFor.d.ts

@@ -0,0 +1,5 @@
+import { Layer } from "effect";
+import * as TestConsole from "effect/testing/TestConsole";
+import type { EffectClock } from "#types.ts";
+export declare function environmentFor(clock: EffectClock): Layer.Layer<TestConsole.TestConsole, never, never>;
+//# sourceMappingURL=environmentFor.d.ts.map

package/dist/internal/environmentFor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environmentFor.d.ts","sourceRoot":"","sources":["../../src/internal/environmentFor.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,EAAE,MAAM,QAAQ,CAAC;AAExD,OAAO,KAAK,WAAW,MAAM,4BAA4B,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAK7C,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,sDAehD"}

package/dist/internal/environmentFor.js

@@ -0,0 +1,16 @@
+import { Clock, DateTime, Effect, Layer } from "effect";
+import * as TestClock from "effect/testing/TestClock";
+import * as TestConsole from "effect/testing/TestConsole";
+const TestClockEnvironment = Layer.mergeAll(TestConsole.layer, TestClock.layer());
+const LiveClockEnvironment = TestConsole.layer;
+export function environmentFor(clock) {
+    if (typeof clock === "string") {
+        return clock === "live" ? LiveClockEnvironment : TestClockEnvironment;
+    }
+    return Layer.mergeAll(TestConsole.layer, Layer.effect(Clock.Clock, Effect.gen(function* () {
+        const testClock = yield* TestClock.make();
+        yield* testClock.setTime(DateTime.toEpochMillis(clock));
+        return testClock;
+    })));
+}
+//# sourceMappingURL=environmentFor.js.map

package/dist/internal/environmentFor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"environmentFor.js","sourceRoot":"","sources":["../../src/internal/environmentFor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACxD,OAAO,KAAK,SAAS,MAAM,0BAA0B,CAAC;AACtD,OAAO,KAAK,WAAW,MAAM,4BAA4B,CAAC;AAG1D,MAAM,oBAAoB,GAAG,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC;AAClF,MAAM,oBAAoB,GAAG,WAAW,CAAC,KAAK,CAAC;AAE/C,MAAM,UAAU,cAAc,CAAC,KAAkB;IAChD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,oBAAoB,CAAC;IACvE,CAAC;IACD,OAAO,KAAK,CAAC,QAAQ,CACpB,WAAW,CAAC,KAAK,EACjB,KAAK,CAAC,MAAM,CACX,KAAK,CAAC,KAAK,EACX,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACnB,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QAC1C,KAAK,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;QACxD,OAAO,SAAS,CAAC;IAClB,CAAC,CAAC,CACF,CACD,CAAC;AACH,CAAC"}

package/dist/internal/runEffectTest.d.ts

@@ -0,0 +1,5 @@
+import type { TestContext } from "@effect/vitest";
+import { Effect, type Scope } from "effect";
+import type { EffectClock } from "#types.ts";
+export declare function runEffectTest<A, E>(effect: Effect.Effect<A, E, Scope.Scope>, context: TestContext, clock: EffectClock): Promise<A>;
+//# sourceMappingURL=runEffectTest.d.ts.map

package/dist/internal/runEffectTest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runEffectTest.d.ts","sourceRoot":"","sources":["../../src/internal/runEffectTest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAS,MAAM,EAAQ,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG7C,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAoBlI"}

package/dist/internal/runEffectTest.js

@@ -0,0 +1,18 @@
+import { Cause, Effect, Exit } from "effect";
+import { environmentFor } from "./environmentFor.js";
+export function runEffectTest(effect, context, clock) {
+    const result = Effect.runPromise(Effect.gen(function* () {
+        const exit = yield* Effect.exit(effect);
+        if (Exit.isFailure(exit)) {
+            for (const error of Cause.prettyErrors(exit.cause)) {
+                yield* Effect.logError(error);
+            }
+        }
+        return yield* exit;
+    }).pipe(Effect.scoped, Effect.provide(environmentFor(clock))), { signal: context.signal });
+    // Vitest's timeout stops awaiting the body while Effect is still closing its Scope.
+    const settled = result.then(() => undefined, () => undefined);
+    context.onTestFinished(() => settled, 0);
+    return result;
+}
+//# sourceMappingURL=runEffectTest.js.map

package/dist/internal/runEffectTest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runEffectTest.js","sourceRoot":"","sources":["../../src/internal/runEffectTest.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAc,MAAM,QAAQ,CAAC;AAEzD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,MAAM,UAAU,aAAa,CAAO,MAAwC,EAAE,OAAoB,EAAE,KAAkB;IACrH,MAAM,MAAM,GAAG,MAAM,CAAC,UAAU,CAC/B,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACnB,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACxC,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;YAC1B,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBACpD,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC;QACF,CAAC;QACD,OAAO,KAAK,CAAC,CAAC,IAAI,CAAC;IACpB,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,EAC7D,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAC1B,CAAC;IACF,oFAAoF;IACpF,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAC1B,GAAG,EAAE,CAAC,SAAS,EACf,GAAG,EAAE,CAAC,SAAS,CACf,CAAC;IACF,OAAO,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACzC,OAAO,MAAM,CAAC;AACf,CAAC"}

package/dist/it.d.ts

@@ -0,0 +1,3 @@
+import type { EffectIt } from "./types.ts";
+export declare const it: EffectIt;
+//# sourceMappingURL=it.d.ts.map

package/dist/it.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"it.d.ts","sourceRoot":"","sources":["../src/it.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAgC,MAAM,YAAY,CAAC;AAsCzE,eAAO,MAAM,EAAE,EAAE,QAGf,CAAC"}

package/dist/it.js

@@ -0,0 +1,31 @@
+import { it as effectIt } from "@effect/vitest";
+import { Effect } from "effect";
+function effectOf(body) {
+    return (...args) => {
+        const result = body(...args);
+        return Effect.isEffect(result) ? result : Effect.gen(() => result);
+    };
+}
+function bodyTest(register) {
+    return (name, body, options) => register(name, effectOf(body), options);
+}
+function bodyTester(register) {
+    return Object.assign(bodyTest(register), {
+        each: (cases) => (name, body, options) => register.each(cases)(name, effectOf(body), options),
+        fails: bodyTest(register.fails),
+        only: bodyTest(register.only),
+        runIf: (condition) => bodyTest(register.runIf(condition)),
+        skip: bodyTest(register.skip),
+        skipIf: (condition) => bodyTest(register.skipIf(condition)),
+    });
+}
+const testers = {};
+const vitestTests = new Proxy(effectIt, {
+    get: (target, key, receiver) => (Object.hasOwn(testers, key) ? testers[key] : Reflect.get(target, key, receiver)),
+    set: (_target, key, value) => Reflect.set(testers, key, value),
+});
+export const it = Object.assign(vitestTests, {
+    effect: bodyTester(effectIt.effect),
+    live: bodyTester(effectIt.live),
+});
+//# sourceMappingURL=it.js.map

package/dist/it.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"it.js","sourceRoot":"","sources":["../src/it.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,IAAI,QAAQ,EAAmD,MAAM,gBAAgB,CAAC;AACjG,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAQhC,SAAS,QAAQ,CAAsC,IAAoB;IAC1E,OAAO,CAAC,GAAG,IAAW,EAAsC,EAAE;QAC7D,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QAC7B,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC;IACpE,CAAC,CAAC;AACH,CAAC;AAED,SAAS,QAAQ,CAAI,QAAwB;IAC5C,OAAO,CAAC,IAAY,EAAE,IAAqC,EAAE,OAA8B,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;AACzI,CAAC;AAED,SAAS,UAAU,CAAI,QAA0B;IAChD,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;QACxC,IAAI,EACH,CAAQ,KAAuB,EAAkC,EAAE,CACnE,CAAC,IAAY,EAAE,IAA4B,EAAE,OAA8B,EAAE,EAAE,CAC9E,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;QACrD,KAAK,EAAE,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;QAC/B,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC;QAC7B,KAAK,EAAE,CAAC,SAAkB,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAClE,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC;QAC7B,MAAM,EAAE,CAAC,SAAkB,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;KACpE,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,OAAO,GAAiC,EAAE,CAAC;AAEjD,MAAM,WAAW,GAAG,IAAI,KAAK,CAAU,QAAQ,EAAE;IAChD,GAAG,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;IACjH,GAAG,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC;CAC9D,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,EAAE,GAAa,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE;IACtD,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC;IACnC,IAAI,EAAE,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;CAC/B,CAAC,CAAC"}

package/dist/makeEffectIt.d.ts

@@ -0,0 +1,5 @@
+import { type Layer } from "effect";
+import { type AnyTestLayer } from "./anyTestLayer.ts";
+import type { MakeEffectItOptions, MakeEffectItResult } from "./types.ts";
+export declare function makeEffectIt<THarness, TTestLayer extends AnyTestLayer>(options: MakeEffectItOptions<THarness, TTestLayer>): MakeEffectItResult<THarness, Layer.Success<TTestLayer>>;
+//# sourceMappingURL=makeEffectIt.d.ts.map

package/dist/makeEffectIt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeEffectIt.d.ts","sourceRoot":"","sources":["../src/makeEffectIt.ts"],"names":[],"mappings":"AACA,OAAO,EAA8B,KAAK,KAAK,EAAS,MAAM,QAAQ,CAAC;AAEvE,OAAO,EAAE,KAAK,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAA4E,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAgDpJ,wBAAgB,YAAY,CAAC,QAAQ,EAAE,UAAU,SAAS,YAAY,EACrE,OAAO,EAAE,mBAAmB,CAAC,QAAQ,EAAE,UAAU,CAAC,GAChD,kBAAkB,CAAC,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAuEzD"}

package/dist/makeEffectIt.js

@@ -0,0 +1,92 @@
+import { it as effectIt } from "@effect/vitest";
+import { Effect, Exit, Scope } from "effect";
+import { runEffectTest } from "#internal/runEffectTest.ts";
+import { buildTestLayer } from "./anyTestLayer.js";
+const FIXTURE_NAME = "__effectTestContext";
+function restoreContext(fixture, context) {
+    return {
+        ...context,
+        [FIXTURE_NAME]: fixture,
+    };
+}
+function splitOptions(options) {
+    if (typeof options === "number") {
+        return { clock: undefined, vitest: { timeout: options } };
+    }
+    if (options === undefined) {
+        return { clock: undefined, vitest: {} };
+    }
+    const { clock, ...vitest } = options;
+    return { clock, vitest };
+}
+function makeFixtureIt(layer) {
+    return effectIt.extend(FIXTURE_NAME, { scope: "file" }, async ({}, { onCleanup }) => {
+        const scope = Effect.runSync(Scope.make());
+        onCleanup(() => Effect.runPromise(Scope.close(scope, Exit.void)));
+        try {
+            return await Effect.runPromise(buildTestLayer(layer, scope));
+        }
+        catch (error) {
+            await Effect.runPromise(Scope.close(scope, Exit.void));
+            throw error;
+        }
+    });
+}
+export function makeEffectIt(options) {
+    const fixtureIt = makeFixtureIt(options.layer);
+    const defaultClock = options.clock ?? "test";
+    function run(body, context) {
+        const ready = Effect.gen(function* () {
+            const harness = yield* options.makeHarness(context);
+            const result = body(harness, context);
+            return yield* Effect.isEffect(result) ? result : Effect.gen(() => result);
+        });
+        const wrapped = options.around?.(ready) ?? ready;
+        return wrapped.pipe(Effect.provide(context[FIXTURE_NAME]));
+    }
+    function register(current) {
+        return (name, body, testOptions) => {
+            const split = splitOptions(testOptions);
+            const clock = split.clock ?? defaultClock;
+            current(name, split.vitest, ({ __effectTestContext, task, signal, onTestFailed, onTestFinished, skip, annotate, expect, bench }) => {
+                const context = restoreContext(__effectTestContext, {
+                    annotate,
+                    bench,
+                    expect,
+                    onTestFailed,
+                    onTestFinished,
+                    signal,
+                    skip,
+                    task,
+                });
+                return runEffectTest(run(body, context), context, clock);
+            });
+        };
+    }
+    const effectApp = Object.assign(register(fixtureIt), {
+        each: (cases) => (name, body, testOptions) => {
+            const split = splitOptions(testOptions);
+            const clock = split.clock ?? defaultClock;
+            fixtureIt.for(cases)(name, split.vitest, (item, { __effectTestContext, task, signal, onTestFailed, onTestFinished, skip, annotate, expect, bench }) => {
+                const context = restoreContext(__effectTestContext, {
+                    annotate,
+                    bench,
+                    expect,
+                    onTestFailed,
+                    onTestFinished,
+                    signal,
+                    skip,
+                    task,
+                });
+                return runEffectTest(Effect.asVoid(run((harness, testContext) => body(item, harness, testContext), context)), context, clock);
+            });
+        },
+        fails: register(fixtureIt.fails),
+        only: register(fixtureIt.only),
+        runIf: (condition) => register(fixtureIt.runIf(condition)),
+        skip: register(fixtureIt.skip),
+        skipIf: (condition) => register(fixtureIt.skipIf(condition)),
+    });
+    return { effectApp };
+}
+//# sourceMappingURL=makeEffectIt.js.map

package/dist/makeEffectIt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeEffectIt.js","sourceRoot":"","sources":["../src/makeEffectIt.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,44 @@
+import type { TestContext, TestOptions } from "@effect/vitest";
+import type { DateTime, Effect, Layer, Scope } from "effect";
+import type { TestAPI } from "vitest";
+import type { AnyTestLayer } from "./anyTestLayer.ts";
+export type EffectClock = "test" | "live" | DateTime.Utc;
+export type EffectTestOptions = TestOptions & {
+    readonly clock?: EffectClock;
+};
+export type EffectTestBody<THarness, TProvided, A = unknown> = (harness: THarness, context: TestContext) => Generator<Effect.Effect<unknown, unknown, TProvided | Scope.Scope>, A, never> | Effect.Effect<A, unknown, TProvided | Scope.Scope>;
+export type EffectTest<THarness, TProvided> = <A, TEff extends Effect.Effect<unknown, unknown, TProvided | Scope.Scope>>(name: string, body: (harness: THarness, context: TestContext) => Generator<TEff, A, never> | Effect.Effect<A, unknown, TProvided | Scope.Scope>, options?: number | EffectTestOptions) => void;
+export interface EffectTester<THarness, TProvided> extends EffectTest<THarness, TProvided> {
+    readonly each: <TItem>(cases: readonly TItem[]) => <A, TEff extends Effect.Effect<unknown, unknown, TProvided | Scope.Scope>>(name: string, body: (item: TItem, harness: THarness, context: TestContext) => Generator<TEff, A, never> | Effect.Effect<A, unknown, TProvided | Scope.Scope>, options?: number | EffectTestOptions) => void;
+    readonly fails: EffectTest<THarness, TProvided>;
+    readonly only: EffectTest<THarness, TProvided>;
+    readonly runIf: (condition: unknown) => EffectTest<THarness, TProvided>;
+    readonly skip: EffectTest<THarness, TProvided>;
+    readonly skipIf: (condition: unknown) => EffectTest<THarness, TProvided>;
+}
+export interface MakeEffectItOptions<THarness, TTestLayer extends AnyTestLayer> {
+    readonly around?: (<A, E>(effect: Effect.Effect<A, E, Layer.Success<TTestLayer> | Scope.Scope>) => Effect.Effect<A, unknown, Layer.Success<TTestLayer> | Scope.Scope>) | undefined;
+    readonly clock?: EffectClock | undefined;
+    readonly layer: TTestLayer;
+    readonly makeHarness: (context: TestContext) => Effect.Effect<THarness, unknown, Layer.Success<TTestLayer> | Scope.Scope>;
+}
+export interface MakeEffectItResult<THarness, TProvided> {
+    readonly effectApp: EffectTester<THarness, TProvided>;
+}
+export interface EffectItTest<R, TArgs extends readonly unknown[] = [context: TestContext]> {
+    <TEffect extends Effect.Effect<unknown, unknown, R>, A>(name: string, body: (...args: TArgs) => Generator<TEffect, A, never>, options?: number | TestOptions): void;
+    <A, E>(name: string, body: (...args: TArgs) => Effect.Effect<A, E, R>, options?: number | TestOptions): void;
+}
+export interface EffectItTester<R> extends EffectItTest<R> {
+    readonly each: <TItem>(cases: readonly TItem[]) => EffectItTest<R, [item: TItem]>;
+    readonly fails: EffectItTest<R>;
+    readonly only: EffectItTest<R>;
+    readonly runIf: (condition: unknown) => EffectItTest<R>;
+    readonly skip: EffectItTest<R>;
+    readonly skipIf: (condition: unknown) => EffectItTest<R>;
+}
+export type EffectIt = TestAPI & {
+    readonly effect: EffectItTester<Scope.Scope>;
+    readonly live: EffectItTester<Scope.Scope>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/dist/withLive.d.ts

@@ -0,0 +1,3 @@
+import { type Effect } from "effect";
+export declare function withLive<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+//# sourceMappingURL=withLive.d.ts.map

package/dist/withLive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withLive.d.ts","sourceRoot":"","sources":["../src/withLive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAG5C,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAExF"}

package/dist/withLive.js

@@ -0,0 +1,6 @@
+import { Clock } from "effect";
+import * as TestClock from "effect/testing/TestClock";
+export function withLive(effect) {
+    return Clock.clockWith((clock) => ("withLive" in clock ? TestClock.withLive(effect) : effect));
+}
+//# sourceMappingURL=withLive.js.map

package/dist/withLive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withLive.js","sourceRoot":"","sources":["../src/withLive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAe,MAAM,QAAQ,CAAC;AAC5C,OAAO,KAAK,SAAS,MAAM,0BAA0B,CAAC;AAEtD,MAAM,UAAU,QAAQ,CAAU,MAA8B;IAC/D,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,UAAU,IAAI,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAChG,CAAC"}

package/package.json

@@ -1,6 +1,76 @@
 {
   "name": "@shivaedev/test",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.9.0",
+  "description": "Generic Effect Vitest runner with file-scoped Layers and TestClock",
+  "keywords": [
+    "effect"
+  ],
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/test#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShivaeDev/platform.git",
+    "directory": "packages/test"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "imports": {
+    "#test/*": "./src/test-support/*",
+    "#*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "exports": {
+    "./*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./internal/*": null,
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/test-support",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@effect/vitest": "4.0.5",
+    "@shivaedev/quality": "0.41.1",
+    "@types/node": "24.19.2",
+    "effect": "4.0.5",
+    "typescript": "7.0.2",
+    "vitest": "5.0.5"
+  },
+  "peerDependencies": {
+    "@effect/vitest": "4.0.5",
+    "effect": "4.0.5"
+  },
+  "peerDependenciesMeta": {
+    "@effect/vitest": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc --project tsconfig.build.json",
+    "ready": "pnpm typecheck && pnpm test && pnpm build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
 }

package/src/anyTestLayer.ts

@@ -0,0 +1,12 @@
+import { type Context, type Effect, Layer, type Scope } from "effect";
+
+export type AnyTestLayer = Layer.Layer<any, any, never> | Layer.Layer<never, any, never>;
+
+// Only a Layer that provides never takes every test Layer, Layer.empty included, so the overload restores what the given Layer provides.
+export function buildTestLayer<TLayer extends AnyTestLayer>(
+	layer: TLayer,
+	scope: Scope.Scope,
+): Effect.Effect<Context.Context<Layer.Success<TLayer>>, unknown>;
+export function buildTestLayer(layer: Layer.Layer<never, unknown, never>, scope: Scope.Scope): Effect.Effect<Context.Context<never>, unknown> {
+	return Layer.buildWithScope(layer, scope);
+}

package/src/eventually.ts

@@ -0,0 +1,35 @@
+import { Clock, Duration, Effect, Result } from "effect";
+import * as TestClock from "effect/testing/TestClock";
+
+export interface EventuallyOptions {
+	readonly interval?: Duration.Input;
+	readonly timeout?: Duration.Input;
+	readonly times?: number;
+	readonly wait?: Effect.Effect<void>;
+}
+
+export const eventually = Effect.fnUntraced(function* <A, E, R>(
+	effect: Effect.Effect<A, E, R>,
+	options?: EventuallyOptions,
+): Effect.fn.Return<A, E, R> {
+	const clock = yield* Clock.Clock;
+	const started = yield* Clock.currentTimeMillis;
+	const timeout = options?.timeout === undefined ? undefined : Duration.toMillis(Duration.fromInputUnsafe(options.timeout));
+	const interval = options?.interval ?? "10 millis";
+	const wait = options?.wait ?? ("adjust" in clock ? TestClock.adjust(interval) : Effect.sleep(interval));
+	let retriesLeft = options?.times;
+	for (;;) {
+		const result = yield* Effect.result(effect);
+		if (Result.isSuccess(result)) {
+			return result.success;
+		}
+		const elapsed = (yield* Clock.currentTimeMillis) - started;
+		if (retriesLeft === 0 || (timeout !== undefined && elapsed >= timeout)) {
+			return yield* Effect.fail(result.failure);
+		}
+		if (retriesLeft !== undefined) {
+			retriesLeft -= 1;
+		}
+		yield* wait;
+	}
+});

package/src/internal/environmentFor.ts

@@ -0,0 +1,24 @@
+import { Clock, DateTime, Effect, Layer } from "effect";
+import * as TestClock from "effect/testing/TestClock";
+import * as TestConsole from "effect/testing/TestConsole";
+import type { EffectClock } from "#types.ts";
+
+const TestClockEnvironment = Layer.mergeAll(TestConsole.layer, TestClock.layer());
+const LiveClockEnvironment = TestConsole.layer;
+
+export function environmentFor(clock: EffectClock) {
+	if (typeof clock === "string") {
+		return clock === "live" ? LiveClockEnvironment : TestClockEnvironment;
+	}
+	return Layer.mergeAll(
+		TestConsole.layer,
+		Layer.effect(
+			Clock.Clock,
+			Effect.gen(function* () {
+				const testClock = yield* TestClock.make();
+				yield* testClock.setTime(DateTime.toEpochMillis(clock));
+				return testClock;
+			}),
+		),
+	);
+}

package/src/internal/runEffectTest.ts

@@ -0,0 +1,26 @@
+import type { TestContext } from "@effect/vitest";
+import { Cause, Effect, Exit, type Scope } from "effect";
+import type { EffectClock } from "#types.ts";
+import { environmentFor } from "./environmentFor.ts";
+
+export function runEffectTest<A, E>(effect: Effect.Effect<A, E, Scope.Scope>, context: TestContext, clock: EffectClock): Promise<A> {
+	const result = Effect.runPromise(
+		Effect.gen(function* () {
+			const exit = yield* Effect.exit(effect);
+			if (Exit.isFailure(exit)) {
+				for (const error of Cause.prettyErrors(exit.cause)) {
+					yield* Effect.logError(error);
+				}
+			}
+			return yield* exit;
+		}).pipe(Effect.scoped, Effect.provide(environmentFor(clock))),
+		{ signal: context.signal },
+	);
+	// Vitest's timeout stops awaiting the body while Effect is still closing its Scope.
+	const settled = result.then(
+		() => undefined,
+		() => undefined,
+	);
+	context.onTestFinished(() => settled, 0);
+	return result;
+}

package/src/it.ts

@@ -0,0 +1,45 @@
+import { it as effectIt, type TestContext, type TestOptions, type Vitest } from "@effect/vitest";
+import { Effect } from "effect";
+import type { TestAPI } from "vitest";
+import type { EffectIt, EffectItTest, EffectItTester } from "./types.ts";
+
+type Body<TArgs extends readonly unknown[], R> = (
+	...args: TArgs
+) => Effect.Effect<unknown, unknown, R> | Generator<Effect.Effect<unknown, unknown, R>, unknown, never>;
+
+function effectOf<TArgs extends readonly unknown[], R>(body: Body<TArgs, R>) {
+	return (...args: TArgs): Effect.Effect<unknown, unknown, R> => {
+		const result = body(...args);
+		return Effect.isEffect(result) ? result : Effect.gen(() => result);
+	};
+}
+
+function bodyTest<R>(register: Vitest.Test<R>): EffectItTest<R> {
+	return (name: string, body: Body<[context: TestContext], R>, options?: number | TestOptions) => register(name, effectOf(body), options);
+}
+
+function bodyTester<R>(register: Vitest.Tester<R>): EffectItTester<R> {
+	return Object.assign(bodyTest(register), {
+		each:
+			<TItem>(cases: readonly TItem[]): EffectItTest<R, [item: TItem]> =>
+			(name: string, body: Body<[item: TItem], R>, options?: number | TestOptions) =>
+				register.each(cases)(name, effectOf(body), options),
+		fails: bodyTest(register.fails),
+		only: bodyTest(register.only),
+		runIf: (condition: unknown) => bodyTest(register.runIf(condition)),
+		skip: bodyTest(register.skip),
+		skipIf: (condition: unknown) => bodyTest(register.skipIf(condition)),
+	});
+}
+
+const testers: Record<PropertyKey, unknown> = {};
+
+const vitestTests = new Proxy<TestAPI>(effectIt, {
+	get: (target, key, receiver) => (Object.hasOwn(testers, key) ? testers[key] : Reflect.get(target, key, receiver)),
+	set: (_target, key, value) => Reflect.set(testers, key, value),
+});
+
+export const it: EffectIt = Object.assign(vitestTests, {
+	effect: bodyTester(effectIt.effect),
+	live: bodyTester(effectIt.live),
+});

package/src/makeEffectIt.ts

@@ -0,0 +1,126 @@
+import { it as effectIt, type TestContext, type TestOptions } from "@effect/vitest";
+import { type Context, Effect, Exit, type Layer, Scope } from "effect";
+import { runEffectTest } from "#internal/runEffectTest.ts";
+import { type AnyTestLayer, buildTestLayer } from "./anyTestLayer.ts";
+import type { EffectClock, EffectTest, EffectTestBody, EffectTester, EffectTestOptions, MakeEffectItOptions, MakeEffectItResult } from "./types.ts";
+
+const FIXTURE_NAME = "__effectTestContext";
+
+type EffectFixture<TProvided> = TestContext & {
+	readonly [FIXTURE_NAME]: Context.Context<TProvided>;
+};
+
+type FixtureTest<TProvided> = (name: string, options: TestOptions, body: (context: EffectFixture<TProvided>) => Promise<unknown>) => void;
+
+function restoreContext<TProvided>(
+	fixture: Context.Context<TProvided>,
+	context: Omit<EffectFixture<TProvided>, typeof FIXTURE_NAME>,
+): EffectFixture<TProvided> {
+	return {
+		...context,
+		[FIXTURE_NAME]: fixture,
+	};
+}
+
+function splitOptions(options: number | EffectTestOptions | undefined): {
+	readonly vitest: TestOptions;
+	readonly clock: EffectClock | undefined;
+} {
+	if (typeof options === "number") {
+		return { clock: undefined, vitest: { timeout: options } };
+	}
+	if (options === undefined) {
+		return { clock: undefined, vitest: {} };
+	}
+	const { clock, ...vitest } = options;
+	return { clock, vitest };
+}
+
+function makeFixtureIt<TLayer extends AnyTestLayer>(layer: TLayer) {
+	return effectIt.extend(FIXTURE_NAME, { scope: "file" }, async ({}, { onCleanup }) => {
+		const scope = Effect.runSync(Scope.make());
+		onCleanup(() => Effect.runPromise(Scope.close(scope, Exit.void)));
+
+		try {
+			return await Effect.runPromise(buildTestLayer(layer, scope));
+		} catch (error) {
+			await Effect.runPromise(Scope.close(scope, Exit.void));
+			throw error;
+		}
+	});
+}
+
+export function makeEffectIt<THarness, TTestLayer extends AnyTestLayer>(
+	options: MakeEffectItOptions<THarness, TTestLayer>,
+): MakeEffectItResult<THarness, Layer.Success<TTestLayer>> {
+	type Provided = Layer.Success<TTestLayer>;
+	const fixtureIt = makeFixtureIt(options.layer);
+	const defaultClock = options.clock ?? "test";
+
+	function run<A>(body: EffectTestBody<THarness, Provided, A>, context: EffectFixture<Provided>): Effect.Effect<A, unknown, Scope.Scope> {
+		const ready: Effect.Effect<A, unknown, Provided | Scope.Scope> = Effect.gen(function* () {
+			const harness = yield* options.makeHarness(context);
+			const result = body(harness, context);
+			return yield* Effect.isEffect(result) ? result : Effect.gen(() => result);
+		});
+		const wrapped = options.around?.(ready) ?? ready;
+		return wrapped.pipe(Effect.provide(context[FIXTURE_NAME]));
+	}
+
+	function register(current: FixtureTest<Provided>): EffectTest<THarness, Provided> {
+		return (name, body, testOptions) => {
+			const split = splitOptions(testOptions);
+			const clock = split.clock ?? defaultClock;
+			current(name, split.vitest, ({ __effectTestContext, task, signal, onTestFailed, onTestFinished, skip, annotate, expect, bench }) => {
+				const context = restoreContext(__effectTestContext, {
+					annotate,
+					bench,
+					expect,
+					onTestFailed,
+					onTestFinished,
+					signal,
+					skip,
+					task,
+				});
+				return runEffectTest(run(body, context), context, clock);
+			});
+		};
+	}
+
+	const effectApp: EffectTester<THarness, Provided> = Object.assign(register(fixtureIt), {
+		each:
+			<TItem>(cases: readonly TItem[]) =>
+			<A, TEff extends Effect.Effect<unknown, unknown, Provided | Scope.Scope>>(
+				name: string,
+				body: (item: TItem, harness: THarness, context: TestContext) => Generator<TEff, A, never> | Effect.Effect<A, unknown, Provided | Scope.Scope>,
+				testOptions?: number | EffectTestOptions,
+			) => {
+				const split = splitOptions(testOptions);
+				const clock = split.clock ?? defaultClock;
+				fixtureIt.for(cases)(
+					name,
+					split.vitest,
+					(item, { __effectTestContext, task, signal, onTestFailed, onTestFinished, skip, annotate, expect, bench }) => {
+						const context = restoreContext(__effectTestContext, {
+							annotate,
+							bench,
+							expect,
+							onTestFailed,
+							onTestFinished,
+							signal,
+							skip,
+							task,
+						});
+						return runEffectTest(Effect.asVoid(run((harness, testContext) => body(item, harness, testContext), context)), context, clock);
+					},
+				);
+			},
+		fails: register(fixtureIt.fails),
+		only: register(fixtureIt.only),
+		runIf: (condition: unknown) => register(fixtureIt.runIf(condition)),
+		skip: register(fixtureIt.skip),
+		skipIf: (condition: unknown) => register(fixtureIt.skipIf(condition)),
+	});
+
+	return { effectApp };
+}

package/src/types.ts

@@ -0,0 +1,74 @@
+import type { TestContext, TestOptions } from "@effect/vitest";
+import type { DateTime, Effect, Layer, Scope } from "effect";
+import type { TestAPI } from "vitest";
+import type { AnyTestLayer } from "./anyTestLayer.ts";
+
+export type EffectClock = "test" | "live" | DateTime.Utc;
+
+export type EffectTestOptions = TestOptions & {
+	readonly clock?: EffectClock;
+};
+
+export type EffectTestBody<THarness, TProvided, A = unknown> = (
+	harness: THarness,
+	context: TestContext,
+) => Generator<Effect.Effect<unknown, unknown, TProvided | Scope.Scope>, A, never> | Effect.Effect<A, unknown, TProvided | Scope.Scope>;
+
+export type EffectTest<THarness, TProvided> = <A, TEff extends Effect.Effect<unknown, unknown, TProvided | Scope.Scope>>(
+	name: string,
+	body: (harness: THarness, context: TestContext) => Generator<TEff, A, never> | Effect.Effect<A, unknown, TProvided | Scope.Scope>,
+	options?: number | EffectTestOptions,
+) => void;
+
+export interface EffectTester<THarness, TProvided> extends EffectTest<THarness, TProvided> {
+	readonly each: <TItem>(
+		cases: readonly TItem[],
+	) => <A, TEff extends Effect.Effect<unknown, unknown, TProvided | Scope.Scope>>(
+		name: string,
+		body: (item: TItem, harness: THarness, context: TestContext) => Generator<TEff, A, never> | Effect.Effect<A, unknown, TProvided | Scope.Scope>,
+		options?: number | EffectTestOptions,
+	) => void;
+	readonly fails: EffectTest<THarness, TProvided>;
+	readonly only: EffectTest<THarness, TProvided>;
+	readonly runIf: (condition: unknown) => EffectTest<THarness, TProvided>;
+	readonly skip: EffectTest<THarness, TProvided>;
+	readonly skipIf: (condition: unknown) => EffectTest<THarness, TProvided>;
+}
+
+export interface MakeEffectItOptions<THarness, TTestLayer extends AnyTestLayer> {
+	readonly around?:
+		| (<A, E>(
+				effect: Effect.Effect<A, E, Layer.Success<TTestLayer> | Scope.Scope>,
+		  ) => Effect.Effect<A, unknown, Layer.Success<TTestLayer> | Scope.Scope>)
+		| undefined;
+	readonly clock?: EffectClock | undefined;
+	readonly layer: TTestLayer;
+	readonly makeHarness: (context: TestContext) => Effect.Effect<THarness, unknown, Layer.Success<TTestLayer> | Scope.Scope>;
+}
+
+export interface MakeEffectItResult<THarness, TProvided> {
+	readonly effectApp: EffectTester<THarness, TProvided>;
+}
+
+export interface EffectItTest<R, TArgs extends readonly unknown[] = [context: TestContext]> {
+	<TEffect extends Effect.Effect<unknown, unknown, R>, A>(
+		name: string,
+		body: (...args: TArgs) => Generator<TEffect, A, never>,
+		options?: number | TestOptions,
+	): void;
+	<A, E>(name: string, body: (...args: TArgs) => Effect.Effect<A, E, R>, options?: number | TestOptions): void;
+}
+
+export interface EffectItTester<R> extends EffectItTest<R> {
+	readonly each: <TItem>(cases: readonly TItem[]) => EffectItTest<R, [item: TItem]>;
+	readonly fails: EffectItTest<R>;
+	readonly only: EffectItTest<R>;
+	readonly runIf: (condition: unknown) => EffectItTest<R>;
+	readonly skip: EffectItTest<R>;
+	readonly skipIf: (condition: unknown) => EffectItTest<R>;
+}
+
+export type EffectIt = TestAPI & {
+	readonly effect: EffectItTester<Scope.Scope>;
+	readonly live: EffectItTester<Scope.Scope>;
+};

package/src/withLive.ts

@@ -0,0 +1,6 @@
+import { Clock, type Effect } from "effect";
+import * as TestClock from "effect/testing/TestClock";
+
+export function withLive<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> {
+	return Clock.clockWith((clock) => ("withLive" in clock ? TestClock.withLive(effect) : effect));
+}