@systemfsoftware/vitest 0.0.0 → 0.2.0

package/dist/index.d.ts

@@ -1,288 +1,23 @@
 /// <reference types="./compat.d.ts" />
-import { n as NarrowVacuousName, r as PresenceRefusal, t as NarrowNegatedName } from "./refusals-_6e3GzVK.js";
+import { a as Values$1, c as kinds_d_exports, i as PropertySubject$1, l as __exportAll, n as Gens$1, o as engine_d_exports, r as PropertySpec$1, s as LawApi, t as ArbitraryInput } from "./engine-YsoQ_9we.js";
+import { a as Expect, c as NoCheckRefusal, d as RefuseSyncBody, f as ScopedLaneRefusal, i as Checks, l as RefuseAsyncBody, m as UnprovidedRefusal, o as EffectLaneRefusal, p as ScopedLiveLaneRefusal, r as Check, s as HookRefusal, t as Asserted, u as RefuseEffectBody } from "./checks-Cq9of-Lx.js";
 import * as V from "vitest";
-import * as Context from "effect/Context";
-import { Schema } from "effect";
-import * as Effect from "effect/Effect";
-import * as Cause from "effect/Cause";
+import { afterAll, assertType, beforeAll, expectTypeOf, inject, onTestFailed, onTestFinished, recordArtifact, vi, vitest } from "vitest";
 import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Scheduler from "effect/Scheduler";
-import * as Schema$1 from "effect/Schema";
 import * as Scope from "effect/Scope";
-import * as TestClock from "effect/testing/TestClock";
 import * as TestConsole from "effect/testing/TestConsole";
+import * as Context from "effect/Context";
 import * as Arbitrary from "effect/unstable/arbitrary/Arbitrary";
 import * as Clock from "effect/Clock";
-export * from "vitest";
-declare namespace expect_d_exports {
-  export { Lawful, LawfulCheck, LawfulExpectStatic, LawfulNot, afterAll$1 as afterAll, afterEach$1 as afterEach, beforeAll$1 as beforeAll, beforeEach$1 as beforeEach, check, expect$1 as expect };
-}
-type Assertion<A> = V.Assertion<void, A>;
-/**
- * Vitest's matchers for a value of type `A`, with the narrowed ones answering the refusal instead. `toBe` on
- * an object, `toBeTypeOf` and `toBeInstanceOf` stay legal (R9).
- *
- * @internal
- */
-type Lawful<A> = Omit<Assertion<A>, 'not' | NarrowVacuousName> & { readonly [Name in NarrowVacuousName]: PresenceRefusal<Name>; } & {
-  readonly not: LawfulNot<A>;
-};
-/**
- * @internal
- */
-type LawfulNot<A> = Omit<Assertion<A>, 'not' | NarrowNegatedName> & { readonly [Name in NarrowNegatedName]: PresenceRefusal<Name>; };
-/**
- * @internal
- */
-interface LawfulCheck {
-  <A>(actual: A, message?: string): Lawful<A>;
-  <A>(message?: string): (actual: A) => Lawful<A>;
-}
-/**
- * Vitest's `expect` statics with the narrowed call signature and the fork's soft `soft`.
- *
- * @internal
- */
-type LawfulExpectStatic = LawfulCheck & {
-  readonly soft: LawfulCheck;
-} & { readonly [K in Exclude<keyof V.ExpectStatic, 'soft'>]: V.ExpectStatic[K]; };
-/**
- * The pipeable form of a check: `check(actual, message)` and `check(message)(actual)`.
- *
- * @internal
- */
-declare const check: {
-  <A>(actual: A, message?: string): Lawful<A>;
-  <A>(message?: string): (actual: A) => Lawful<A>;
-};
-/**
- * The fork's `expect`: soft within one Effect step, refusing the slop forms.
- *
- * @internal
- */
-declare const expect$1: LawfulExpectStatic;
-type EachFirst = Parameters<typeof V.beforeEach>[0];
-type AfterEachFirst = Parameters<typeof V.afterEach>[0];
-type BeforeAllFirst = Parameters<typeof V.beforeAll>[0];
-type AfterAllFirst = Parameters<typeof V.afterAll>[0];
-/**
- * @internal
- */
-declare const beforeEach$1: {
-  (fn: EachFirst, timeout?: number): void;
-  (timeout?: number): (fn: EachFirst) => void;
-};
-/**
- * @internal
- */
-declare const afterEach$1: {
-  (fn: AfterEachFirst, timeout?: number): void;
-  (timeout?: number): (fn: AfterEachFirst) => void;
-};
-/**
- * @internal
- */
-declare const beforeAll$1: {
-  (fn: BeforeAllFirst, timeout?: number): void;
-  (timeout?: number): (fn: BeforeAllFirst) => void;
-};
-/**
- * @internal
- */
-declare const afterAll$1: {
-  (fn: AfterAllFirst, timeout?: number): void;
-  (timeout?: number): (fn: AfterAllFirst) => void;
-};
-declare namespace owned_d_exports {
-  export { OwnedAssertions, RunBinding, captureRunBinding$1 as captureRunBinding, isOwned, owned$1 as owned, recordAssertion$1 as recordAssertion };
-}
-/** @internal */
-declare const OwnedAssertions: Context.Reference<boolean>;
-/** @internal */
-declare const isOwned: () => boolean;
-/** @internal */
-declare const owned$1: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-/**
- * Counts an Effect-native check as an assertion of the run it happens in, so the run's own gate sees it.
- *
- * @internal
- */
-declare const recordAssertion$1: () => void;
-/**
- * The test's run binding. `bind` hands it to an effect a library runs on a
- * runtime of its own — its own scheduler, a worker, a simulation kernel — so
- * the checks inside it count as this test's assertions, report softly, and see
- * the same `owned` regions as the test itself.
- *
- * @internal
- */
-interface RunBinding {
-  readonly bind: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-}
-/**
- * The run binding of the test the caller is executing in.
- *
- * @internal
- */
-declare const captureRunBinding$1: Effect.Effect<RunBinding>;
-//#endregion
+import * as Scheduler from "effect/Scheduler";
 //#region src/internal/property/defaults.d.ts
 /** @internal The `test.provide` key the shared config fills with this run's tier's check options. */
 declare const checkDefaultsKey = "@systemfsoftware/vitest:property-check";
 /** @internal The check options a run supplies as its property default, minus `replay`. */
 type ProvidedCheckDefaults = Omit<Arbitrary.CheckOptions, 'replay'>;
 //#endregion
-//#region src/internal/errors.schema.d.ts
-declare const NonBooleanVerdict_base: Schema.Class<NonBooleanVerdict, Schema.TaggedStruct<"NonBooleanVerdict", {
-  readonly detail: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-/** @internal */
-declare class NonBooleanVerdict extends NonBooleanVerdict_base {
-  get message(): string;
-}
-//#endregion
-//#region src/internal/property/impostor.d.ts
-/**
- * @internal The constant impostor of R12: a fake of the subject under test that
- * returns the first output it ever produced, for every later call, whatever the
- * input it was given.
- *
- * A property that still holds for the impostor does not constrain the subject.
- * Whether that is fatal is a per-file question — a subject's impostor must be
- * refuted by some property in its file — so this module builds the fake and
- * collects the verdicts; the engine decides them once, when the file finishes
- * (KTD10).
- */
-/**
- * A value the fork hands over without inspecting: an argument to the subject, or one of its outputs.
- *
- * @internal
- */
-type Opaque<A = unknown> = A;
-/**
- * A function under test: any argument, any output.
- *
- * @internal
- */
-type SubjectFunction = (...values: ReadonlyArray<never>) => Opaque;
-/**
- * A record of functions under test; every member is replaced by a constant.
- *
- * @internal
- */
-type MemberRecord = {
-  readonly [key: string]: SubjectFunction;
-};
-/**
- * The function under test, or a record of them.
- *
- * @internal
- */
-type Subject = SubjectFunction | MemberRecord;
-declare namespace kinds_d_exports {
-  export { LawApi, LawKind, LawSubject, MetamorphicRelation, deterministicHolds, idempotentHolds, invariantHolds, metamorphicHolds, modelHolds, roundTripHolds, spreadValues };
-}
-/** @internal */
-type LawKind = 'model' | 'metamorphic' | 'roundTrip' | 'invariant' | 'idempotent' | 'deterministic';
-/**
- * A subject of a law kind: a function of the generated values.
- *
- * @internal
- */
-type LawSubject<G extends Gens$1, A> = (...values: ReadonlyArray<ElementValues<G>>) => A;
-/**
- * A metamorphic relation: the input transform, and how the two outputs relate (structural equality by default).
- *
- * @internal
- */
-interface MetamorphicRelation<G extends Gens$1, A> {
-  readonly transform: (...values: ReadonlyArray<ElementValues<G>>) => Values$1<G>;
-  readonly relate?: (original: A, transformed: A) => boolean;
-}
-/**
- * The R13 law surface: four gated kinds and two declared exemptions.
- *
- * @internal
- */
-interface LawApi {
-  readonly model: <const G extends Gens$1, A, N extends number, S extends LawSubject<G, A>>(name: string, spec: PropertySpec$1<G, S, N>, oracle: LawSubject<G, A>) => void;
-  readonly metamorphic: <const G extends Gens$1, A, N extends number, S extends LawSubject<G, A>>(name: string, spec: PropertySpec$1<G, S, N>, relation: MetamorphicRelation<G, A>) => void;
-  readonly roundTrip: <const G extends Gens$1, E, N extends number, S extends LawSubject<G, E>>(name: string, spec: PropertySpec$1<G, S, N>, decode: (encoded: E) => Values$1<G>) => void;
-  readonly invariant: <const G extends Gens$1, A, N extends number, S extends LawSubject<G, A>>(name: string, spec: PropertySpec$1<G, S, N>, holds: (output: A, ...values: ReadonlyArray<ElementValues<G>>) => boolean) => void;
-  readonly idempotent: <const G extends Gens$1, N extends number, S extends (value: ElementValues<G>) => ElementValues<G>>(name: string, spec: PropertySpec$1<G, S, N>) => void;
-  readonly deterministic: <const G extends Gens$1, A, N extends number, S extends LawSubject<G, A>>(name: string, spec: PropertySpec$1<G, S, N>) => void;
-}
-/**
- * The generated values as the argument list a law subject is called with.
- *
- * @internal
- */
-declare const spreadValues: <G extends Gens$1>(values: Values$1<G>) => ReadonlyArray<ElementValues<G>>;
-/** @internal */
-declare const modelHolds: <G extends Gens$1, A>(oracle: LawSubject<G, A>) => (subject: LawSubject<G, A>, values: Values$1<G>) => boolean;
-/** @internal */
-declare const metamorphicHolds: <G extends Gens$1, A>(relation: MetamorphicRelation<G, A>) => (subject: LawSubject<G, A>, values: Values$1<G>) => boolean;
-/** @internal */
-declare const roundTripHolds: <G extends Gens$1, E>(decode: (encoded: E) => Values$1<G>) => (subject: LawSubject<G, E>, values: Values$1<G>) => boolean;
-/** @internal */
-declare const invariantHolds: <G extends Gens$1, A>(holds: (output: A, ...values: ReadonlyArray<ElementValues<G>>) => boolean) => (subject: LawSubject<G, A>, values: Values$1<G>) => boolean;
-/** @internal */
-declare const idempotentHolds: <G extends Gens$1>() => (subject: (value: ElementValues<G>) => ElementValues<G>, values: Values$1<G>) => boolean;
-/** @internal */
-declare const deterministicHolds: <G extends Gens$1, A>() => (subject: LawSubject<G, A>, values: Values$1<G>) => boolean;
-declare namespace engine_d_exports {
-  export { ArbitraryInput, CoveragePredicate, ElementValues, Gens$1 as Gens, PropApi, PropertyRuntime, PropertySpec$1 as PropertySpec, PropertySubject$1 as PropertySubject, Values$1 as Values, makeProperty };
-}
-/** @internal */
-type ArbitraryInput = Schema$1.Top | Arbitrary.Arbitrary<Schema$1.Top['Type']>;
-/** @internal */
-type Gens$1 = ReadonlyArray<ArbitraryInput> | {
-  readonly [key: string]: ArbitraryInput;
-};
-type Generated<I> = I extends Schema$1.Schema<infer T> ? T : I extends Arbitrary.Arbitrary<infer A> ? A : never;
-/** @internal */
-type Values$1<G extends Gens$1> = { readonly [K in keyof G]: Generated<G[K]>; };
-/** @internal */
-type ElementValues<G extends Gens$1> = G extends ReadonlyArray<ArbitraryInput> ? Generated<G[number]> : never;
-/** @internal */
-type PropertySubject$1 = Subject;
-/** @internal */
-type CoveragePredicate<G extends Gens$1> = (...values: ReadonlyArray<ElementValues<G>>) => boolean;
-type PropertyRuns<N extends number> = number extends N ? number : `${N}` extends `-${bigint}` ? never : `${N}` extends `${bigint}` ? (N extends 0 ? never : N) : never;
-/** @internal */
-interface PropertySpec$1<G extends Gens$1, S extends PropertySubject$1, N extends number> {
-  readonly of: G;
-  readonly subject: S;
-  /**
-   * The property's own run count. Omitted, the configured default applies; when the run provides none,
-   * the built-in default of 100 does.
-   */
-  readonly runs?: N & PropertyRuns<N>;
-  /** Labelled input predicates, each with the minimum share of runs it must see (R14). */
-  readonly cover?: Readonly<Record<string, readonly [CoveragePredicate<G>, number]>>;
-  /** The property's own check options, merged field by field over the provided and built-in defaults. */
-  readonly arbitrary?: Arbitrary.CheckOptions;
-}
-/** @internal */
-interface PropertyRuntime<R> {
-  /** Registers the property's program; the runtime runs it inside the test it registers, under that test's binding. */
-  readonly register: (name: string, program: () => Effect.Effect<void, Cause.Cause<NonBooleanVerdict>, never>) => void;
-  readonly provide: <A, E>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, never>;
-}
-/** @internal */
-interface PropApi<R> {
-  readonly prop: <const G extends Gens$1, S extends PropertySubject$1, N extends number>(name: string, spec: PropertySpec$1<G, S, N>, holds: (subject: S, values: Values$1<G>) => boolean) => void;
-  readonly effectProp: <const G extends Gens$1, S extends PropertySubject$1, N extends number, E>(name: string, spec: PropertySpec$1<G, S, N>, holds: (subject: S, values: Values$1<G>) => Effect.Effect<boolean, E, R>) => void;
-  readonly law: LawApi;
-}
-/**
- * The property surface over one runtime: `prop`, `effectProp`, and the R13 law kinds routed through the gate.
- *
- * @internal
- */
-declare const makeProperty: <R>(runtime: PropertyRuntime<R>) => PropApi<R>;
-//#endregion
 //#region src/internal/virtual-time.d.ts
 /** @internal */
 interface VirtualRuntime {
@@ -294,36 +29,37 @@ interface VirtualRuntime {
   readonly end: Effect.Effect<void, never, never>;
 }
 declare namespace runner_d_exports {
-  export { BlockRegistrar, LayerOptions$1 as LayerOptions, NestedLayer, RunEnv, TestContext, addEqualityTesters$1 as addEqualityTesters, describeWrapped$1 as describeWrapped, flakyTest$1 as flakyTest, hookTimeout, layer$1 as layer, makeMethods$1 as makeMethods, perRun, prop$1 as prop, realTime, testEnv, testOptions };
+  export { BlockRegistrar, LayerOptions$1 as LayerOptions, NestedLayer, RunEnv, addEqualityTesters$1 as addEqualityTesters, afterEach$1 as afterEach, beforeEach$2 as beforeEach, describeWrapped$1 as describeWrapped, flakyTest$1 as flakyTest, hookTimeout, law$1 as law, layer$1 as layer, makeMethods$1 as makeMethods, perRun, prop$1 as prop, realTime, testEnv, testOptions };
 }
 /** @internal */
-type TestContext = TestConsole.TestConsole | TestClock.TestClock;
-/** @internal */
 declare const addEqualityTesters$1: () => void;
 /** @internal */
 declare const testOptions: (timeout?: number | V.TestOptions) => V.TestOptions;
 /** @internal */
 declare const hookTimeout: (timeout?: Duration.Input) => number | undefined;
-/**
- * How a run arms the step boundary: a test's `stopCheckOf` interrupts it once one of its checks failed (R6),
- * and `neverStop` leaves a property's verdict returned, so a `false` one still shrinks (R6, U4).
- */
-type StopPolicy = (ctx: V.TestContext | undefined) => (() => boolean) | undefined;
 /** @internal */
 interface RunEnv {
   readonly runtime: VirtualRuntime | undefined;
   readonly owned: boolean;
-  /** How the runs of this env arm the step boundary. */
-  readonly stop: StopPolicy;
 }
 /** @internal */
 declare const realTime: RunEnv;
-/** @internal */
+/**
+ * A run with its own virtual clock: the clock only ever advances when the run's fibers are idle.
+ *
+ * @internal
+ */
 declare const perRun: () => RunEnv;
 /** @internal */
 declare const testEnv: (env: RunEnv) => Layer.Layer<TestConsole.TestConsole, never, never>;
 /** @internal */
-declare const prop$1: Vitest.Methods['prop'];
+declare const prop$1: Vitest.SyncProperty;
+/**
+ * The law kinds over the sync property family: the top-level `it.law`.
+ *
+ * @internal
+ */
+declare const law$1: LawApi;
 /**
  * Options for the top-level `layer` and for `it.layer` inside a `Methods` block.
  *
@@ -335,8 +71,8 @@ type LayerOptions$1 = {
   readonly timeout?: Duration.Input;
   readonly excludeTestServices?: boolean;
   /**
-   * Share one build of these layers across every test of the block, instead of giving each test its own
-   * fresh build. The only way to share; nested blocks inherit it.
+   * Share one build of these layers across every test of the block, instead of giving each test its own fresh
+   * build. The only way to share; nested blocks inherit it.
    */
   readonly shared?: boolean;
 };
@@ -367,88 +103,161 @@ declare const flakyTest$1: {
   <A, E, R>(self: Effect.Effect<A, E, R | Scope.Scope>, timeout?: Duration.Input): Effect.Effect<A, never, R>;
   (timeout?: Duration.Input): <A, E, R>(self: Effect.Effect<A, E, R | Scope.Scope>) => Effect.Effect<A, never, R>;
 };
+type EachFirst = Parameters<typeof V.beforeEach>[0];
+type AfterEachFirst = Parameters<typeof V.afterEach>[0];
+/**
+ * @internal
+ */
+declare const beforeEach$2: {
+  (this: HookRefusal, fn: EachFirst, timeout?: number): never;
+  (this: HookRefusal, timeout?: number): (fn: EachFirst) => never;
+};
 /**
- * The fork's `it`: Vitest's test API with the fork's Effect lanes and lawful property lanes attached,
- * callable data-first (`it(name, body)`) or data-last (`it(body, options?)(name)`).
+ * @internal
+ */
+declare const afterEach$1: {
+  (this: HookRefusal, fn: AfterEachFirst, timeout?: number): never;
+  (this: HookRefusal, timeout?: number): (fn: AfterEachFirst) => never;
+};
+/**
+ * The fork's `it`: the generator lanes on virtual time, the real-clock lane, the lawful property lanes and the
+ * layer blocks, callable data-first (`it(name, body)`) or data-last (`it(body, timeout?)(name)`).
  *
  * @internal
  */
 declare const makeMethods$1: (it: V.TestAPI) => Vitest.Methods;
 /** @internal */
-/** @internal */
-/** @internal */
-/** @internal */
 declare const describeWrapped$1: {
   (name: string, f: (it: Vitest.Methods) => void): V.SuiteCollector;
   (f: (it: Vitest.Methods) => void): (name: string) => V.SuiteCollector;
 };
 declare namespace mod_d_exports {
-  export { API, Methods, MethodsNonLive, Vitest, VitestTestContext, addEqualityTesters, afterAll, afterEach, beforeAll, beforeEach, captureRunBinding, describe, describeWrapped, effect, expect, flakyTest, it, layer, live, makeMethods, owned, prop, recordAssertion, vitestTestContextKey };
+  export { Asserted, Check, Checks, Expect, Gate, Vitest, VitestTestContext, addEqualityTesters, afterAll, afterEach, assertType, beforeAll, beforeEach, describe, describeWrapped, expectTypeOf, flakyTest, inject, it, law, layer, makeMethods, onTestFailed, onTestFinished, prop, recordArtifact, test, vi, vitest, vitestTestContextKey };
 }
-import * as import_vitest from "vitest";
 declare module 'vitest' {
   interface ProvidedContext {
     [checkDefaultsKey]?: ProvidedCheckDefaults;
+    '@systemfsoftware/vitest:package'?: string;
+    '@systemfsoftware/vitest:workspace-root'?: string;
   }
 }
 /**
- * Vitest's test API, with its call signatures paired: each data-first form has its data-last twin, so
- * `it(name, body)`, `it(body)(name)`, `it(name, options, body)` and `it(options, body)(name)` all work.
+ * The fork's test API and the types a body, a check and a property are written with.
  *
  * @since 4.0.0
  */
-export type API = Omit<V.TestAPI<{}>, never> & {
+export declare namespace Vitest {
   /**
-   * Data-last: `it(body, timeout?)(name)`. Declared before the data-first forms so that a bare
-   * `it(body)` resolves here, which is where the runtime routes a first argument that is not a name.
+   * Any argument a refusal accepts. A refusal sits on the `this` type, so the call's own arguments must still
+   * type-check; this is the widest argument type this repo's lint allows.
    *
    * @since 4.0.0
    */
-  <ExtraContext extends {}>(fn?: V.TestFunction<ExtraContext>, options?: number): (name: string | Function) => void;
+  type Argument = object | string | number | boolean | bigint | symbol | null | undefined;
   /**
+   * What a body yields and returns: the checks it was handed, then the Effects it yields.
+   *
    * @since 4.0.0
    */
-  <ExtraContext extends {}>(name: string | Function, fn: V.TestFunction<ExtraContext> | undefined, options?: number): void;
+  type Body<Eff, AEff> = (checks: Checks) => Generator<Eff, AEff, never>;
   /**
-   * Data-last: `it(options, body)(name)`.
+   * A row body: the row first, then the checks — the order Vitest's `it.for` passes them (R9).
    *
    * @since 4.0.0
    */
-  <ExtraContext extends {}>(options: V.TestOptions, fn?: V.TestFunction<ExtraContext>): (name: string | Function) => void;
+  type RowBody<Row, Eff, AEff> = (row: Row, checks: Checks) => Generator<Eff, AEff, never>;
   /**
+   * Whether `Eff` still stands at the placeholder the checker uses while it is inferring a body's yields.
+   * `unknown` is the only sound placeholder; `Sentinel` names it as a generic default, so no bare `unknown`
+   * appears at a use site.
+   *
    * @since 4.0.0
    */
-  <ExtraContext extends {}>(name: string | Function, options: V.TestOptions, fn?: V.TestFunction<ExtraContext>): void;
-};
-/**
- * @since 4.0.0
- */
-export declare namespace Vitest {
+  type Unresolved<Eff, Sentinel = unknown> = [Eff] extends [never] ? false : [Sentinel] extends [Eff] ? true : false;
+  /**
+   * The requirement a body's yields impose on the run.
+   *
+   * **Details**
+   *
+   * `Eff` is inferred from what the body yields. While a body is still being inferred — and always, for a body
+   * whose `{ expect }` is destructured without an annotation — `Eff` stands at the checker's placeholder, and
+   * this reads that placeholder as the checks' own requirement. The body's real yields decide once inference
+   * settles, which is what refuses a body that yields no check at the test name (R4).
+   *
+   * @since 4.0.0
+   */
+  type RequirementOf<Eff> = [Eff] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : Unresolved<Eff> extends true ? Asserted : never;
   /**
+   * What a lane provides besides its block's layer: the scope the body runs in, and the checks it yields.
+   *
    * @since 4.0.0
    */
-  interface TestFunction<A, E, R, TestArgs extends TestContextWithValues> {
-    (...args: TestArgs): Effect.Effect<A, E, R>;
-  }
+  type Lane<R> = R | Scope.Scope | Asserted;
   /**
+   * The no-check gate, on the test name (KTD4). It reads the tuple form so a distributive `Exclude` cannot widen
+   * `R`, and it sits on the name rather than the body because a body with a destructured `{ expect }` is
+   * context-sensitive: a gate on the body is judged before `{ expect }` is inferred, so it cannot see the checks.
+   *
    * @since 4.0.0
    */
-  type TestContextOnly = [V.TestContext];
+  type Gate<R, Provided = never> = [R] extends [Asserted | Provided] ? [Asserted] extends [R] ? string : NoCheckRefusal : UnprovidedRefusal;
   /**
+   * A body that is not the generator itself, as a parameter union: the error prints the rewrite (KTD3). A sync
+   * body, an `async` body and an Effect-returning body each reach one of these texts, at compile time and at run
+   * time (R2).
+   *
    * @since 4.0.0
    */
-  type TestContextWithValues = [V.TestContext] | [V.TestContext | object] | [V.TestContext | object, V.TestContext] | [V.TestContext | object, V.TestContext & object];
+  type BodyRefusal = RefuseSyncBody | RefuseAsyncBody | RefuseEffectBody;
   /**
+   * A test lane: `it(name, function* ({ expect }) { ... })`. `R` is what the lane's own environment provides
+   * besides the checks — its scope, and the services of the `layer` block it is written in.
+   *
    * @since 4.0.0
    */
   interface Test<R> {
-    <A, E>(name: string, self: TestFunction<A, E, R, [V.TestContext]>, timeout?: number | V.TestOptions): void;
-    /**
-     * Data-last: `it.effect(self, timeout?)(name)`.
-     *
-     * @since 4.0.0
-     */
-    <A, E>(self: TestFunction<A, E, R, [V.TestContext]>, timeout?: number | V.TestOptions): (name: string) => void;
+    <Eff, AEff>(name: NoInfer<Gate<RequirementOf<Eff>, Lane<R>>>, body: Body<Eff, AEff> | BodyRefusal, timeout?: number | V.TestOptions): void;
+    <Eff, AEff>(body: Body<Eff, AEff> | BodyRefusal, timeout?: number | V.TestOptions): (name: NoInfer<Gate<RequirementOf<Eff>, Lane<R>>>) => void;
+  }
+  /**
+   * A row lane: `it.each(rows)(name, function* (row, { expect }) { ... })`.
+   *
+   * @since 4.0.0
+   */
+  interface RowTest<Row, R> {
+    <Eff, AEff>(name: NoInfer<Gate<RequirementOf<Eff>, Lane<R>>>, body: RowBody<Row, Eff, AEff> | BodyRefusal, timeout?: number | V.TestOptions): void;
+  }
+  /**
+   * The `it` modifiers every lane has, each registering the same generator body.
+   *
+   * @since 4.0.0
+   */
+  interface Modifiers<R> {
+    readonly skip: Test<R>;
+    readonly skipIf: (condition: boolean) => Test<R>;
+    readonly runIf: (condition: boolean) => Test<R>;
+    readonly only: Test<R>;
+    readonly fails: Test<R>;
+    readonly each: <Row>(cases: ReadonlyArray<Row>) => RowTest<Row, R>;
+  }
+  /**
+   * A lane with the Effect-lane property attached: `it.live.prop(...)` and `it.effect.prop(...)`.
+   *
+   * @since 4.0.0
+   */
+  interface Tester<R> extends Test<R>, Modifiers<R> {
+    readonly prop: EffectProperty<R>;
+  }
+  /**
+   * A removed habit lane: calling it is a `this`-type error naming the lane and its rewrite, and a run-time
+   * throw with the same text (R9, KTD3). `Refusal` is that lane's own text, so `it.scoped` blames `it.scoped`
+   * and `it.effect` blames `it.effect`. It keeps `prop`, so `it.effect.prop` still runs properties.
+   *
+   * @since 4.0.0
+   */
+  interface EffectLane<R, Refusal extends string = EffectLaneRefusal> {
+    (this: Refusal, ...args: ReadonlyArray<Argument>): never;
+    readonly prop: EffectProperty<R | Scope.Scope>;
   }
   /**
    * A generated input: a Schema, or an Arbitrary of an already-generated type.
@@ -482,6 +291,21 @@ export declare namespace Vitest {
    * @since 4.0.0
    */
   type PropertySpec<G extends Gens, S extends PropertySubject, N extends number> = PropertySpec$1<G, S, N>;
+  /**
+   * A property's `holds` on the Effect lane: the verdict is an `Effect` of the literal boolean.
+   *
+   * @since 4.0.0
+   */
+  type EffectProperty<R> = <const G extends Gens, S extends PropertySubject, N extends number, E>(name: string, spec: PropertySpec<G, S, N>, holds: (subject: S, values: Values<G>) => Effect.Effect<boolean, E, R>) => void;
+  /**
+   * A property's `holds` on the sync lane: the verdict is a literal boolean.
+   *
+   * @since 4.0.0
+   */
+  type SyncProperty = {
+    <const G extends Gens, S extends PropertySubject, N extends number>(name: string, spec: PropertySpec<G, S, N>, holds: (subject: S, values: Values<G>) => boolean): void;
+    <const G extends Gens, S extends PropertySubject, N extends number>(spec: PropertySpec<G, S, N>, holds: (subject: S, values: Values<G>) => boolean): (name: string) => void;
+  };
   /**
    * The block a layer opens: `layer(L)(body)` or `layer(L)("name", body)`.
    *
@@ -516,39 +340,16 @@ export declare namespace Vitest {
    */
   type FlakyTest = typeof flakyTest$1;
   /**
+   * The lanes a `layer` block hands its body: the generator lanes, the fences a property lives in, and the
+   * removal of the Effect lane as a callable. `R` is what the block's layer provides; the lanes carry the
+   * block's own scope beside it, which is why the base callable is `Test<R | Scope.Scope>`.
+   *
    * @since 4.0.0
    */
-  interface Tester<R> extends Vitest.Test<R> {
-    skip: Vitest.Test<R>;
-    skipIf: (condition: boolean) => Vitest.Test<R>;
-    runIf: (condition: boolean) => Vitest.Test<R>;
-    only: Vitest.Test<R>;
-    each: <T extends object>(cases: ReadonlyArray<T>) => <A, E>(name: string, self: TestFunction<A, E, R, TestContextWithValues & [V.TestContext | T]>, timeout?: number | V.TestOptions) => void;
-    fails: Vitest.Test<R>;
-    /**
-     * Runs a property that names its subject and carries a budget, on the Effect lane.
-     *
-     * **Details**
-     *
-     * `spec.subject` is handed to `holds` instead of being imported into the property. `holds` returns an
-     * `Effect` of its verdict: `true` holds, `false` falsifies and triggers shrinking, and any typed failure
-     * falsifies the property with its cause. A verdict that is not a literal boolean fails as
-     * `NonBooleanVerdict`; a `runs` that is not a positive integer fails as `InvalidBudget`. `runs` is optional:
-     * the property's own fields win over the configured default (`test.provide`) over `runs: 100`. After the
-     * property holds, it is run again against a constant impostor of its subject; the file fails as
-     * `VacuousProperty` unless some property in it refutes that impostor.
-     *
-     * The old positional form `it.effect.prop(name, [arbitraries], predicate)` is refused.
-     *
-     * @since 4.0.0
-     */
-    prop: <const G extends Gens, S extends PropertySubject, N extends number, E>(name: string, spec: PropertySpec<G, S, N>, holds: (subject: S, values: Values<G>) => Effect.Effect<boolean, E, R>) => void;
-  }
-  /**
-   * @since 4.0.0
-   */
-  interface MethodsNonLive<R = never> extends API {
-    readonly effect: Vitest.Tester<R | Scope.Scope>;
+  interface MethodsNonLive<R = never> extends Test<R | Scope.Scope>, Modifiers<R | Scope.Scope> {
+    readonly effect: EffectLane<R, EffectLaneRefusal>;
+    readonly scoped: EffectLane<R, ScopedLaneRefusal>;
+    readonly scopedLive: EffectLane<R, ScopedLiveLaneRefusal>;
     readonly flakyTest: FlakyTest;
     readonly layer: LayerOf<R, NestedLayerOptions>;
     /**
@@ -567,10 +368,7 @@ export declare namespace Vitest {
      *
      * @since 4.0.0
      */
-    readonly prop: {
-      <const G extends Gens, S extends PropertySubject, N extends number>(name: string, spec: PropertySpec<G, S, N>, holds: (subject: S, values: Values<G>) => boolean): void;
-      <const G extends Gens, S extends PropertySubject, N extends number>(spec: PropertySpec<G, S, N>, holds: (subject: S, values: Values<G>) => boolean): (name: string) => void;
-    };
+    readonly prop: SyncProperty;
     /**
      * The R13 law kinds: `model`, `metamorphic`, `roundTrip` and `invariant` are gated like `prop`;
      * `idempotent` and `deterministic` skip the impostor gate and are reported as exempt.
@@ -580,76 +378,66 @@ export declare namespace Vitest {
     readonly law: LawApi;
   }
   /**
+   * The top-level methods: `MethodsNonLive` plus the real-clock lane and the top-level `layer`.
+   *
    * @since 4.0.0
    */
   interface Methods<R = never> extends MethodsNonLive<R> {
-    readonly live: Vitest.Tester<Scope.Scope | R>;
+    readonly live: Tester<R | Scope.Scope>;
     readonly layer: LayerOf<R, LayerOptions>;
   }
 }
 /**
+ * The fork's test API, with the generator lanes of R2 and R9.
+ *
  * @since 4.0.0
  */
-export type MethodsNonLive<R = never> = Vitest.MethodsNonLive<R>;
-/**
- * @since 4.0.0
- */
-export type Methods<R = never> = Vitest.Methods<R>;
+export declare const it: Vitest.Methods;
 /**
+ * The same lanes under the other name upstream publishes.
+ *
  * @since 4.0.0
  */
-export declare const addEqualityTesters: () => void;
+export declare const test: Vitest.Methods;
 /**
+ * The fork's lawful collector: it forces the fork's concurrency and shuffle defaults and hands its body the
+ * fork's methods.
+ *
  * @since 4.0.0
  */
-export declare const effect: Vitest.Tester<Scope.Scope>;
+export declare const describeWrapped: {
+  (name: string, f: (it: Vitest.Methods) => void): V.SuiteCollector;
+  (f: (it: Vitest.Methods) => void): (name: string) => V.SuiteCollector;
+};
 /**
  * @since 4.0.0
  */
-export declare const live: Vitest.Tester<Scope.Scope>;
+export declare const describe: {
+  (name: string, f: (it: Vitest.Methods) => void): V.SuiteCollector;
+  (f: (it: Vitest.Methods) => void): (name: string) => V.SuiteCollector;
+};
 /**
- * Share a `Layer` between multiple tests, optionally wrapping
- * the tests in a `describe` block if a name is provided.
- *
- * Named layers accept `concurrent` to override inherited suite concurrency.
- * Anonymous layers always inherit the enclosing suite's concurrency.
- * Use `ctx.expect` in concurrent tests for test-local snapshots and assertion counts.
- *
- * @since 4.0.0
+ * Share a `Layer` between multiple tests, optionally wrapping the tests in a `describe` block if a name is
+ * provided. Every test in the block gets its own fresh build of the layer, unless the block declares
+ * `shared: true`.
  *
  * ```ts
- * import { assert, layer } from "@systemfsoftware/vitest"
- * import { Effect, Layer, Context } from "effect"
+ * import { it, layer } from "@systemfsoftware/vitest"
+ * import { Context, Effect, Layer } from "effect"
  *
  * class Foo extends Context.Service<Foo, "foo">()("Foo") {
  *   static layer = Layer.succeed(Foo, "foo")
  * }
  *
- * class Bar extends Context.Service<Bar, "bar">()("Bar") {
- *   static layer = Layer.effect(
- *     Bar,
- *     Effect.map(Foo, () => "bar" as const)
- *   )
- * }
- *
  * layer(Foo.layer)("layer", (it) => {
- *   it.effect("adds context", () =>
- *     Effect.gen(function*() {
- *       const foo = yield* Foo
- *       assert.strictEqual(foo, "foo")
- *     }))
- *
- *   it.layer(Bar.layer)("nested", (it) => {
- *     it.effect("adds context", () =>
- *       Effect.gen(function*() {
- *         const foo = yield* Foo
- *         const bar = yield* Bar
- *         assert.strictEqual(foo, "foo")
- *         assert.strictEqual(bar, "bar")
- *       }))
+ *   it("reads the service", function* ({ expect }) {
+ *     const foo = yield* Foo
+ *     yield* expect(foo).toEqual("foo")
  *   })
  * })
  * ```
+ *
+ * @since 4.0.0
  */
 export declare const layer: Vitest.LayerOf<never, Vitest.LayerOptions>;
 /**
@@ -659,77 +447,52 @@ export declare const flakyTest: Vitest.FlakyTest;
 /**
  * @since 4.0.0
  */
-export declare const prop: Vitest.Methods['prop'];
+export declare const prop: Vitest.SyncProperty;
 /**
  * @since 4.0.0
  */
-export declare const owned: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+export declare const law: LawApi;
 /**
- * @since 4.0.0
- */
-export declare const recordAssertion: () => void;
-/**
- * The run binding of the test the effect is executing in. `bind` re-provides it
- * to an effect a library runs on a runtime of its own — its own scheduler, a
- * worker, a simulation kernel — so the checks inside it count as this test's
- * assertions, report softly, and see the same `owned` regions as the test.
+ * The fork's test API over another Vitest `it`, so a library can register tests in its own suite.
  *
  * @since 4.0.0
  */
-export declare const captureRunBinding: Effect.Effect<RunBinding>;
+export declare const makeMethods: (it: V.TestAPI) => Vitest.Methods;
 /**
- * The key the running test's context is published under. A library that carries its own view of the task
- * context builds that view on this key, so the context a case lane sees and a property lane sees agree.
+ * Refused: hooks share state between tests, and services come fresh per test from `layer`.
  *
  * @since 4.0.0
  */
-export declare const vitestTestContextKey: string;
+export declare const beforeEach: typeof beforeEach$2;
 /**
- * The running Vitest `TestContext`, provided on every test the fork runs — the Effect lanes, both property
- * lanes, and each `it.each` row. It is `null` outside a run.
+ * Refused: hooks share state between tests, and services come fresh per test from `layer`.
  *
  * @since 4.0.0
  */
-export declare const VitestTestContext: Context.Reference<V.TestContext | null>;
-/**
- * @since 4.0.0
- */
-export declare const it: Vitest.Methods;
-/**
- * @since 4.0.0
- */
-export declare const makeMethods: (it: V.TestAPI) => Vitest.Methods;
+export declare const afterEach: typeof afterEach$1;
 /**
  * @since 4.0.0
  */
-export declare const describeWrapped: {
-  (name: string, f: (it: Vitest.Methods) => void): V.SuiteCollector;
-  (f: (it: Vitest.Methods) => void): (name: string) => V.SuiteCollector;
-};
-export declare const describe: {
-  (name: string, f: (it: Vitest.Methods) => void): V.SuiteCollector;
-  (f: (it: Vitest.Methods) => void): (name: string) => V.SuiteCollector;
-};
+export declare const addEqualityTesters: () => void;
 /**
- * The fork's `expect`: soft within one Effect step, refusing the slop forms.
+ * The key the running test's context is published under. A library that carries its own view of the task
+ * context builds that view on this key, so the context a case lane sees and a property lane sees agree.
  *
  * @since 4.0.0
  */
-export declare const expect: typeof expect$1;
-/**
- * @since 4.0.0
- */
-export declare const beforeEach: typeof beforeEach$1;
-/**
- * @since 4.0.0
- */
-export declare const afterEach: typeof afterEach$1;
+export declare const vitestTestContextKey: string;
 /**
+ * The running Vitest `TestContext`, provided on every test the fork runs — every generator lane, both property
+ * lanes, and each `it.each` row. It is `null` outside a run.
+ *
  * @since 4.0.0
  */
-export declare const beforeAll: typeof beforeAll$1;
+export declare const VitestTestContext: Context.Reference<V.TestContext | null>;
 /**
+ * The no-check gate, on the test name (KTD4).
+ *
  * @since 4.0.0
  */
-export declare const afterAll: typeof afterAll$1;
-//#endregion
+export type Gate<R, Provided = never> = Vitest.Gate<R, Provided>;
+//#endregion
+export { type Asserted, type Check, type Checks, type Expect, afterAll, assertType, beforeAll, expectTypeOf, inject, onTestFailed, onTestFinished, recordArtifact, vi, vitest };