effect-bun-testing 4.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Justin Menga
+
+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

@@ -0,0 +1,462 @@
+# effect-bun-testing
+
+Effect test helpers for Bun's built-in test runner.
+
+This library ports the [`@effect/vitest`](https://github.com/Effect-TS/effect/tree/main/packages/vitest) API to [`bun:test`](https://bun.sh/docs/cli/test), providing first-class support for running Effect programs in Bun's test runner — including test services (`TestClock`, `TestConsole`), scoping, property-based testing, and all standard test modifiers.
+
+> For Effect v3, install `effect-bun-testing@v3`.
+
+## Requirements
+
+- [Bun](https://bun.sh) >= 1.0
+- [Effect](https://effect.website) v4 (`^4.0.0-beta.10`)
+
+## Installation
+
+```bash
+bun add effect-bun-testing
+```
+
+## Overview
+
+| API | Description |
+|---|---|
+| `it.effect` | Run an Effect test with test services (auto-scoped) |
+| `it.live` | Run an Effect test without test services (auto-scoped) |
+| `it.effect.skip` | Skip an Effect test |
+| `it.effect.only` | Run only this Effect test |
+| `it.effect.skipIf(cond)` | Skip when condition is truthy |
+| `it.effect.if(cond)` | Run when condition is truthy |
+| `it.effect.each(cases)` | Parameterized Effect tests |
+| `it.effect.failing` | Test that is expected to fail |
+| `it.effect.prop` | Property-based Effect test |
+| `it.prop` | Property-based test (non-Effect) |
+| `it.flakyTest` | Retry an Effect up to 10 times within a timeout |
+| `layer(L)` | Share a Layer across tests with `beforeAll`/`afterAll` lifecycle |
+
+## Writing Tests
+
+### Basic Effect tests
+
+Import `it` from `effect-bun-testing` as a drop-in replacement for `bun:test`'s `it`. All standard `bun:test` functionality is preserved, with Effect methods added.
+
+```ts
+import { describe, expect } from "bun:test"
+import { it } from "effect-bun-testing"
+import { Effect } from "effect"
+
+describe("my tests", () => {
+  it.effect("runs a basic Effect test", () =>
+    Effect.gen(function*() {
+      const result = yield* Effect.succeed(42)
+      expect(result).toBe(42)
+    })
+  )
+})
+```
+
+### Defining services
+
+```ts
+import { Effect, Layer, ServiceMap } from "effect"
+
+interface Greeter {
+  readonly greet: (name: string) => Effect.Effect<string>
+}
+const Greeter = ServiceMap.Service<Greeter>("app/Greeter")
+```
+
+### Providing layers per-test
+
+The standard pattern is to pipe layers directly to individual tests using `Effect.provide`. Each test gets a fresh layer instance.
+
+```ts
+const GreeterLive = Layer.succeed(Greeter)({
+  greet: (name) => Effect.succeed(`Hello, ${name}!`)
+})
+
+describe("greeter", () => {
+  it.effect("greets by name", () =>
+    Effect.gen(function*() {
+      const greeter = yield* Greeter
+      const msg = yield* greeter.greet("World")
+      expect(msg).toBe("Hello, World!")
+    }).pipe(Effect.provide(GreeterLive))
+  )
+})
+```
+
+You can compose multiple layers for a single test:
+
+```ts
+it.effect("uses multiple services", () =>
+  Effect.gen(function*() {
+    const counter = yield* Counter
+    const logger = yield* Logger
+    yield* counter.increment
+    const count = yield* counter.get
+    yield* logger.log(`count is ${count}`)
+    const msgs = yield* logger.messages
+    expect(msgs).toHaveLength(1)
+  }).pipe(Effect.provide(Layer.mergeAll(CounterLive, LoggerLive)))
+)
+```
+
+### TestClock
+
+`it.effect` provides `TestClock` automatically. Use `TestClock.adjust` to advance time without waiting.
+
+```ts
+import { TestClock } from "effect/testing"
+
+it.effect("advances time via TestClock", () =>
+  Effect.gen(function*() {
+    const before = yield* Effect.clockWith((clock) => clock.currentTimeMillis)
+    yield* TestClock.adjust("1 second")
+    const after = yield* Effect.clockWith((clock) => clock.currentTimeMillis)
+    expect(after - before).toBe(1000)
+  })
+)
+```
+
+### Scoped tests
+
+`it.effect` and `it.live` auto-scope in Effect v4, so no special handling is needed for `Effect.addFinalizer` or other scoped resources:
+
+```ts
+it.effect("auto-scopes resources", () =>
+  Effect.gen(function*() {
+    const ref = yield* Ref.make(0)
+    yield* Effect.addFinalizer(() => Ref.set(ref, 99))
+    const before = yield* Ref.get(ref)
+    expect(before).toBe(0)
+    // finalizer runs automatically after this test
+  })
+)
+```
+
+### Handling failures
+
+```ts
+it.effect("handles failures", () =>
+  Effect.gen(function*() {
+    const result = yield* Effect.fail("boom").pipe(
+      Effect.catch(() => Effect.succeed("recovered"))
+    )
+    expect(result).toBe("recovered")
+  })
+)
+```
+
+### Live tests
+
+`it.live` runs effects without test services (`TestClock`, `TestConsole`), using the real runtime:
+
+```ts
+it.live("uses real clock", () =>
+  Effect.gen(function*() {
+    const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis)
+    expect(now).toBeGreaterThan(0)
+  })
+)
+```
+
+### Modifiers
+
+All standard `bun:test` modifiers are available on `it.effect`:
+
+```ts
+// Skip a test
+it.effect.skip("not ready yet", () => ...)
+
+// Run only this test
+it.effect.only("focus on this", () => ...)
+
+// Conditional skip
+it.effect.skipIf(process.env.CI)("skip in CI", () => ...)
+
+// Conditional run
+it.effect.if(process.env.CI)("only in CI", () => ...)
+
+// Alias for .if (vitest compat)
+it.effect.runIf(someCondition)("conditional", () => ...)
+
+// Expected failure
+it.effect.failing("known bug", () =>
+  Effect.gen(function*() {
+    yield* Effect.fail("not implemented")
+  })
+)
+
+// Alias for .failing (vitest compat)
+it.effect.fails("also known bug", () => ...)
+```
+
+### Parameterized tests
+
+Use `it.effect.each` to run the same test with different inputs:
+
+```ts
+it.effect.each([1, 2, 3])("doubles %d", (n) =>
+  Effect.gen(function*() {
+    const result = yield* Effect.succeed(n * 2)
+    expect(result).toBe(n * 2)
+  })
+)
+```
+
+### Flaky tests
+
+`flakyTest` retries an Effect up to 10 times within a timeout (default 30 seconds):
+
+```ts
+import { it } from "effect-bun-testing"
+import { Effect, Duration } from "effect"
+
+it.effect("retries flaky operations", () =>
+  it.flakyTest(
+    Effect.gen(function*() {
+      const n = Math.random()
+      if (n < 0.8) yield* Effect.fail("unlucky")
+      expect(n).toBeGreaterThanOrEqual(0.8)
+    }),
+    Duration.seconds(5)
+  )
+)
+```
+
+## Property-Based Testing
+
+Property-based testing is supported via [fast-check](https://github.com/dubzzz/fast-check).
+
+### Non-Effect properties
+
+```ts
+import * as fc from "fast-check"
+
+it.prop(
+  "arrays always have non-negative length",
+  [fc.array(fc.string())],
+  (arr) => {
+    expect(arr.length).toBeGreaterThanOrEqual(0)
+  }
+)
+
+it.prop(
+  "multiple arbitraries",
+  [fc.string(), fc.integer({ min: 0, max: 100 })],
+  (str, num) => {
+    expect(typeof str).toBe("string")
+    expect(num).toBeGreaterThanOrEqual(0)
+  }
+)
+```
+
+### Effect properties
+
+```ts
+it.effect.prop(
+  "positive numbers remain positive after increment",
+  [fc.integer({ min: 1, max: 1000 })],
+  (n) =>
+    Effect.gen(function*() {
+      const result = yield* Effect.succeed(n + 1)
+      expect(result).toBeGreaterThan(n)
+    })
+)
+```
+
+## Shared Layer Lifecycle
+
+For expensive resources (database connections, server instances) or tests that intentionally share state, use `layer()` to build a layer once in `beforeAll` and tear it down in `afterAll`:
+
+```ts
+import { describe, expect } from "bun:test"
+import { it, layer } from "effect-bun-testing"
+import { Effect, Layer, ServiceMap } from "effect"
+
+interface Counter {
+  readonly get: Effect.Effect<number>
+  readonly increment: Effect.Effect<void>
+}
+const Counter = ServiceMap.Service<Counter>("app/Counter")
+
+const CounterLive = Layer.effect(
+  Counter,
+  Effect.gen(function*() {
+    let count = 0
+    return {
+      get: Effect.sync(() => count),
+      increment: Effect.sync(() => { count++ })
+    }
+  })
+)
+
+describe("shared counter", () => {
+  layer(CounterLive)("shared lifecycle", (it) => {
+    it.effect("starts at zero", () =>
+      Effect.gen(function*() {
+        const counter = yield* Counter
+        const count = yield* counter.get
+        expect(count).toBe(0)
+      })
+    )
+
+    it.effect("state persists across tests (shared instance)", () =>
+      Effect.gen(function*() {
+        const counter = yield* Counter
+        yield* counter.increment
+        const count = yield* counter.get
+        expect(count).toBeGreaterThanOrEqual(1)
+      })
+    )
+  })
+})
+```
+
+> **Note:** For most tests, prefer the per-test `Effect.provide(layer)` pattern. It gives each test a fresh layer instance, which avoids shared-state coupling. Use `layer()` only when you need the layer to be built once and shared.
+
+## Mocking Effect Services
+
+Effect services are interfaces resolved from the environment, which makes them straightforward to mock using Bun's built-in `mock()`. The pattern uses three steps:
+
+1. Create dynamically typed mocks with `mock()`
+2. Wire them into test layers with `Layer.mock` (partial implementation — only mock what you need)
+3. Set default implementations in `beforeEach`
+
+### Full example
+
+```ts
+import { beforeEach, describe, expect, mock } from "bun:test"
+import { it } from "effect-bun-testing"
+import { Effect, Layer, ServiceMap } from "effect"
+
+interface UserRepository {
+  readonly findById: (id: string) => Effect.Effect<{ id: string; name: string } | null>
+}
+const UserRepository = ServiceMap.Service<UserRepository>("app/UserRepository")
+
+interface NotificationService {
+  readonly send: (userId: string, message: string) => Effect.Effect<void>
+  readonly test: () => Effect.Effect<void>
+}
+const NotificationService = ServiceMap.Service<NotificationService>("app/NotificationService")
+
+// Business logic under test
+const notifyUser = (userId: string, message: string) =>
+  Effect.gen(function*() {
+    const repo = yield* UserRepository
+    const notifications = yield* NotificationService
+    const user = yield* repo.findById(userId)
+    if (!user) {
+      return yield* Effect.fail(new Error(`User ${userId} not found`))
+    }
+    yield* notifications.send(userId, `${user.name}: ${message}`)
+    return { sent: true, to: user.name }
+  })
+
+// 1. Create dynamically typed mocks
+const mockFindById = mock()
+const mockSend = mock()
+
+// 2. Wire mocks into test layers using Layer.mock
+// Layer.mock accepts a partial implementation — only mock the methods you need.
+const TestUserRepository = Layer.mock(UserRepository)({
+  findById: mockFindById
+})
+
+// NotificationService has both `send` and `test`, but we only need `send`
+const TestNotificationService = Layer.mock(NotificationService)({
+  send: mockSend
+})
+
+const TestLayer = Layer.mergeAll(TestUserRepository, TestNotificationService)
+
+// 3. Set defaults in beforeEach, provide layer per-test
+describe("notifyUser", () => {
+  beforeEach(() => {
+    mockFindById.mockClear()
+    mockSend.mockClear()
+
+    mockFindById.mockImplementation((id: string) =>
+      Effect.succeed(id === "user-1" ? { id: "user-1", name: "Alice" } : null)
+    )
+    mockSend.mockReturnValue(Effect.void)
+  })
+
+  it.effect("sends notification to existing user", () =>
+    Effect.gen(function*() {
+      const result = yield* notifyUser("user-1", "hello!")
+      expect(result).toEqual({ sent: true, to: "Alice" })
+      expect(mockSend).toHaveBeenCalledTimes(1)
+      expect(mockSend).toHaveBeenCalledWith("user-1", "Alice: hello!")
+    }).pipe(Effect.provide(TestLayer))
+  )
+
+  it.effect("can override mock per-test", () =>
+    Effect.gen(function*() {
+      mockFindById.mockReturnValue(
+        Effect.succeed({ id: "user-42", name: "Bob" })
+      )
+      const result = yield* notifyUser("user-42", "hey!")
+      expect(result).toEqual({ sent: true, to: "Bob" })
+      expect(mockSend).toHaveBeenCalledWith("user-42", "Bob: hey!")
+    }).pipe(Effect.provide(TestLayer))
+  )
+})
+```
+
+### Key points
+
+- **Use `Layer.mock` (not `Layer.succeed`)** — `Layer.mock` accepts a partial implementation, so you only mock the methods your test actually exercises. `Layer.succeed` requires the full service interface.
+- **Use `mock()` (not `mock<T>()`)** — dynamically typed mocks avoid wrestling with generics and work naturally with `Layer.mock`.
+- **`mockImplementation`** for methods that take arguments and return an `Effect` with a value based on those arguments.
+- **`mockReturnValue(Effect.void)`** for side-effect methods that always return the same thing.
+- **`mockReturnValue(Effect.succeed(value))`** for methods that return a fixed value (useful for per-test overrides).
+- **`mockClear()` in `beforeEach`** resets call counts and implementations, so each test starts clean.
+- **Per-test overrides** simply call `mockReturnValue` or `mockImplementation` again before running the effect — `beforeEach` resets it for the next test automatically.
+
+## Assertion Utilities
+
+A set of assertion helpers is available at `effect-bun-testing/utils`, ported from `@effect/vitest/utils`:
+
+```ts
+import {
+  assertEquals,       // Compare via Effect's Equal.equals
+  assertTrue,         // Truthy assertion
+  assertFalse,        // Falsy assertion
+  assertNone,         // Option is None
+  assertSome,         // Option is Some with expected value
+  assertSuccess_,     // Result is Success with expected value
+  assertFailure_,     // Result is Failure with expected value
+  assertRight,        // Alias for assertSuccess_ (vitest compat)
+  assertExitSuccess,  // Exit is Success with expected value
+  assertExitFailure,  // Exit is Failure with expected Cause
+  deepStrictEqual,    // Structural equality (toStrictEqual)
+  strictEqual,        // Reference equality (toBe)
+  assertInstanceOf,   // instanceof check
+  assertInclude,      // String contains substring
+  assertMatch,        // String matches regex
+  throws,             // Function throws
+  throwsAsync,        // Async function throws
+  fail                // Always throws (unconditional failure)
+} from "effect-bun-testing/utils"
+```
+
+## API Mapping from @effect/vitest
+
+| @effect/vitest | effect-bun-testing | Notes |
+|---|---|---|
+| `it.effect(name, (ctx) => ...)` | `it.effect(name, () => ...)` | No TestContext param (Bun has none) |
+| `it.live(name, (ctx) => ...)` | `it.live(name, () => ...)` | Same |
+| `it.effect.fails` | `it.effect.failing` | Bun's name; `fails` alias also available |
+| `it.effect.runIf(cond)` | `it.effect.if(cond)` | Bun's name; `runIf` alias also available |
+| `it.effect.skip/only/skipIf/each` | `it.effect.skip/only/skipIf/each` | Direct mapping |
+| `it.effect.prop` | `it.effect.prop` | Same API |
+| `it.prop` | `it.prop` | Same API |
+| `layer(L)(name, fn)` | `layer(L)(name, fn)` | Same API |
+| `flakyTest(effect, timeout)` | `flakyTest(effect, timeout)` | Same API |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Effect test helpers for Bun's built-in test runner.
+ *
+ * Ports the `@effect/vitest` API to `bun:test`, including `it.effect`,
+ * `it.live`, `layer()`, `flakyTest`, property-based testing, and assertion
+ * utilities.
+ *
+ * @example
+ * ```ts
+ * import { it } from "effect-bun-test"
+ * import { Effect } from "effect"
+ *
+ * it.effect("adds numbers", () =>
+ *   Effect.gen(function*() {
+ *     const result = 1 + 1
+ *     expect(result).toBe(2)
+ *   })
+ * )
+ * ```
+ *
+ * @module
+ */
+export { describe, expect, beforeAll, afterAll, beforeEach, afterEach, test, mock, spyOn, jest, vi, setSystemTime } from "bun:test";
+export { effect, live, makeTester, flakyTest, prop, layer, makeMethods, addEqualityTesters } from "./internal/internal.js";
+export type { TestFunction, Test, Tester, PropEffect, Prop, TestServices, Methods, MethodsNonLive, LayerOptions, LayerFn } from "./internal/internal.js";
+import { test as bunTest } from "bun:test";
+import type { Methods } from "./internal/internal.js";
+/**
+ * Drop-in replacement for bun:test's `it` / `test`, augmented with Effect
+ * methods.
+ *
+ * @example
+ * ```ts
+ * import { it } from "effect-bun-test"
+ *
+ * it.effect("runs an Effect test", () =>
+ *   Effect.succeed(42).pipe(Effect.map((n) => expect(n).toBe(42)))
+ * )
+ *
+ * it.live("runs without test services", () =>
+ *   Effect.sync(() => expect(Date.now()).toBeGreaterThan(0))
+ * )
+ * ```
+ */
+export declare const it: typeof bunTest & Methods;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,EACL,QAAQ,EACR,MAAM,EACN,SAAS,EACT,QAAQ,EACR,UAAU,EACV,SAAS,EACT,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,EAAE,EACF,aAAa,EACd,MAAM,UAAU,CAAA;AAKjB,OAAO,EACL,MAAM,EACN,IAAI,EACJ,UAAU,EACV,SAAS,EACT,IAAI,EACJ,KAAK,EACL,WAAW,EACX,kBAAkB,EACnB,MAAM,wBAAwB,CAAA;AAK/B,YAAY,EACV,YAAY,EACZ,IAAI,EACJ,MAAM,EACN,UAAU,EACV,IAAI,EACJ,YAAY,EACZ,OAAO,EACP,cAAc,EACd,YAAY,EACZ,OAAO,EACR,MAAM,wBAAwB,CAAA;AAK/B,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,UAAU,CAAA;AAQ1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAErD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,EAAE,EAAE,OAAO,OAAO,GAAG,OAMd,CAAA"}

package/dist/index.js

@@ -0,0 +1,58 @@
+/**
+ * Effect test helpers for Bun's built-in test runner.
+ *
+ * Ports the `@effect/vitest` API to `bun:test`, including `it.effect`,
+ * `it.live`, `layer()`, `flakyTest`, property-based testing, and assertion
+ * utilities.
+ *
+ * @example
+ * ```ts
+ * import { it } from "effect-bun-test"
+ * import { Effect } from "effect"
+ *
+ * it.effect("adds numbers", () =>
+ *   Effect.gen(function*() {
+ *     const result = 1 + 1
+ *     expect(result).toBe(2)
+ *   })
+ * )
+ * ```
+ *
+ * @module
+ */
+// Re-export bun:test for convenience (parallel to @effect/vitest re-exporting vitest)
+export { describe, expect, beforeAll, afterAll, beforeEach, afterEach, test, mock, spyOn, jest, vi, setSystemTime } from "bun:test";
+// ---------------------------------------------------------------------------
+// Core exports from internal
+// ---------------------------------------------------------------------------
+export { effect, live, makeTester, flakyTest, prop, layer, makeMethods, addEqualityTesters } from "./internal/internal.js";
+// ---------------------------------------------------------------------------
+// Composed `it` — the primary import for most users
+// ---------------------------------------------------------------------------
+import { test as bunTest } from "bun:test";
+import { effect, live, flakyTest, layer, prop } from "./internal/internal.js";
+/**
+ * Drop-in replacement for bun:test's `it` / `test`, augmented with Effect
+ * methods.
+ *
+ * @example
+ * ```ts
+ * import { it } from "effect-bun-test"
+ *
+ * it.effect("runs an Effect test", () =>
+ *   Effect.succeed(42).pipe(Effect.map((n) => expect(n).toBe(42)))
+ * )
+ *
+ * it.live("runs without test services", () =>
+ *   Effect.sync(() => expect(Date.now()).toBeGreaterThan(0))
+ * )
+ * ```
+ */
+export const it = Object.assign(bunTest, {
+    effect,
+    live,
+    flakyTest,
+    layer,
+    prop
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,sFAAsF;AACtF,OAAO,EACL,QAAQ,EACR,MAAM,EACN,SAAS,EACT,QAAQ,EACR,UAAU,EACV,SAAS,EACT,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,EAAE,EACF,aAAa,EACd,MAAM,UAAU,CAAA;AAEjB,8EAA8E;AAC9E,6BAA6B;AAC7B,8EAA8E;AAC9E,OAAO,EACL,MAAM,EACN,IAAI,EACJ,UAAU,EACV,SAAS,EACT,IAAI,EACJ,KAAK,EACL,WAAW,EACX,kBAAkB,EACnB,MAAM,wBAAwB,CAAA;AAkB/B,8EAA8E;AAC9E,oDAAoD;AACpD,8EAA8E;AAC9E,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,EACL,MAAM,EACN,IAAI,EACJ,SAAS,EACT,KAAK,EACL,IAAI,EACL,MAAM,wBAAwB,CAAA;AAG/B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,EAAE,GAA6B,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE;IACjE,MAAM;IACN,IAAI;IACJ,SAAS;IACT,KAAK;IACL,IAAI;CACa,CAAC,CAAA"}

package/dist/internal/internal.d.ts

@@ -0,0 +1,82 @@
+import { Duration, Effect, Layer, Scope } from "effect";
+import { TestClock, TestConsole } from "effect/testing";
+import { test as bunTest } from "bun:test";
+import * as fc from "fast-check";
+/** A test body that returns an Effect. */
+export interface TestFunction<A, E, R> {
+    (): Effect.Effect<A, E, R>;
+}
+/** Registers a named test whose body returns an Effect. */
+export interface Test<R> {
+    <A, E>(name: string, self: TestFunction<A, E, R>, timeout?: number): void;
+}
+/** Full tester with modifiers (skip, only, each, etc.). */
+export interface Tester<R> extends Test<R> {
+    readonly skip: Test<R>;
+    readonly only: Test<R>;
+    readonly skipIf: (condition: unknown) => Test<R>;
+    readonly if: (condition: unknown) => Test<R>;
+    /** Alias for `if` (vitest compat). */
+    readonly runIf: (condition: unknown) => Test<R>;
+    readonly each: <T>(cases: ReadonlyArray<T>) => <A, E>(name: string, self: (args: T) => Effect.Effect<A, E, R>, timeout?: number) => void;
+    readonly failing: Test<R>;
+    /** Alias for `failing` (vitest compat). */
+    readonly fails: Test<R>;
+    readonly prop: PropEffect<R>;
+}
+/** Property-based test that returns an Effect. */
+export interface PropEffect<R> {
+    <const Arbs extends ReadonlyArray<fc.Arbitrary<any>>>(name: string, arbitraries: Arbs, self: (...args: {
+        [K in keyof Arbs]: Arbs[K] extends fc.Arbitrary<infer T> ? T : never;
+    }) => Effect.Effect<any, any, R>, timeout?: number | {
+        readonly fastCheck?: fc.Parameters<any>;
+    }): void;
+}
+/** Property-based test that returns void / Promise<void>. */
+export interface Prop {
+    <const Arbs extends ReadonlyArray<fc.Arbitrary<any>>>(name: string, arbitraries: Arbs, self: (...args: {
+        [K in keyof Arbs]: Arbs[K] extends fc.Arbitrary<infer T> ? T : never;
+    }) => void | Promise<void>, timeout?: number | {
+        readonly fastCheck?: fc.Parameters<any>;
+    }): void;
+}
+export type TestServices = TestClock.TestClock | TestConsole.TestConsole;
+/** Full method set exposed on `it` and returned from `makeMethods`. */
+export interface Methods {
+    readonly effect: Tester<TestServices | Scope.Scope>;
+    readonly live: Tester<Scope.Scope>;
+    readonly flakyTest: typeof flakyTest;
+    readonly layer: typeof layer;
+    readonly prop: Prop;
+}
+/** Method set available inside a `layer()` callback. */
+export interface MethodsNonLive<R, ExcludeTestServices extends boolean = false> {
+    readonly effect: Tester<ExcludeTestServices extends true ? R | Scope.Scope : R | TestServices | Scope.Scope>;
+    readonly flakyTest: typeof flakyTest;
+    readonly layer: <R2, E2>(layer_: Layer.Layer<R2, E2>, options?: LayerOptions) => LayerFn<R2, ExcludeTestServices>;
+    readonly prop: Prop;
+}
+export interface LayerOptions {
+    readonly memoMap?: Layer.MemoMap;
+    readonly timeout?: Duration.Input;
+    readonly excludeTestServices?: boolean;
+}
+export type LayerFn<R, ExcludeTestServices extends boolean = false> = {
+    (f: (it: MethodsNonLive<R, ExcludeTestServices>) => void): void;
+    (name: string, f: (it: MethodsNonLive<R, ExcludeTestServices>) => void): void;
+};
+export declare const makeTester: <R>(mapEffect: (self: Effect.Effect<any, any, R>) => Effect.Effect<any, any, never>, testFn?: typeof bunTest) => Tester<R>;
+/** Run effects with TestClock + TestConsole, auto-scoped. */
+export declare const effect: Tester<TestServices | Scope.Scope>;
+/** Run effects live (no test services), auto-scoped. */
+export declare const live: Tester<Scope.Scope>;
+export declare const flakyTest: <A, E, R>(self: Effect.Effect<A, E, R>, timeout?: Duration.Input) => Effect.Effect<A, never, R>;
+export declare const prop: Prop;
+export declare const layer: <R, E, const ExcludeTestServices extends boolean = false>(layer_: Layer.Layer<R, E>, options?: {
+    readonly memoMap?: Layer.MemoMap;
+    readonly timeout?: Duration.Input;
+    readonly excludeTestServices?: ExcludeTestServices;
+}) => LayerFn<R, ExcludeTestServices>;
+export declare const makeMethods: () => Methods;
+export declare const addEqualityTesters: () => void;
+//# sourceMappingURL=internal.d.ts.map

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

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