@systemfsoftware/vitest 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,735 @@
+/// <reference types="./compat.d.ts" />
+import { n as NarrowVacuousName, r as PresenceRefusal, t as NarrowNegatedName } from "./refusals-_6e3GzVK.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 * as Duration from "effect/Duration";
+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 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
+//#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 {
+  readonly clock: Clock.Clock;
+  readonly scheduler: Scheduler.Scheduler;
+  /** @internal */
+  readonly observe: Effect.Effect<void, never, never>;
+  /** @internal */
+  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 };
+}
+/** @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 */
+declare const perRun: () => RunEnv;
+/** @internal */
+declare const testEnv: (env: RunEnv) => Layer.Layer<TestConsole.TestConsole, never, never>;
+/** @internal */
+declare const prop$1: Vitest.Methods['prop'];
+/**
+ * Options for the top-level `layer` and for `it.layer` inside a `Methods` block.
+ *
+ * @internal
+ */
+type LayerOptions$1 = {
+  readonly concurrent?: boolean;
+  readonly memoMap?: Layer.MemoMap;
+  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.
+   */
+  readonly shared?: boolean;
+};
+type BlockBody<R> = (it: Vitest.MethodsNonLive<R>) => void;
+/** @internal */
+type BlockRegistrar<R> = {
+  (f: BlockBody<R>): void;
+  (name: string, f: BlockBody<R>): void;
+};
+/**
+ * The nested layer a block's own `it.layer` opens, and the options it accepts.
+ *
+ * @internal
+ */
+type NestedLayer = {
+  readonly concurrent?: boolean;
+  readonly timeout?: Duration.Input;
+  /** Share one build across this nested block's tests; inherited from a shared parent block. */
+  readonly shared?: boolean;
+};
+/** @internal */
+declare const layer$1: {
+  <R, E>(layer_: Layer.Layer<R, E>, options?: LayerOptions$1): BlockRegistrar<R>;
+  <R, E>(options?: LayerOptions$1): (layer_: Layer.Layer<R, E>) => BlockRegistrar<R>;
+};
+/** @internal */
+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>;
+};
+/**
+ * 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 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 };
+}
+import * as import_vitest from "vitest";
+declare module 'vitest' {
+  interface ProvidedContext {
+    [checkDefaultsKey]?: ProvidedCheckDefaults;
+  }
+}
+/**
+ * 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.
+ *
+ * @since 4.0.0
+ */
+export type API = Omit<V.TestAPI<{}>, never> & {
+  /**
+   * 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.
+   *
+   * @since 4.0.0
+   */
+  <ExtraContext extends {}>(fn?: V.TestFunction<ExtraContext>, options?: number): (name: string | Function) => void;
+  /**
+   * @since 4.0.0
+   */
+  <ExtraContext extends {}>(name: string | Function, fn: V.TestFunction<ExtraContext> | undefined, options?: number): void;
+  /**
+   * Data-last: `it(options, body)(name)`.
+   *
+   * @since 4.0.0
+   */
+  <ExtraContext extends {}>(options: V.TestOptions, fn?: V.TestFunction<ExtraContext>): (name: string | Function) => void;
+  /**
+   * @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 {
+  /**
+   * @since 4.0.0
+   */
+  interface TestFunction<A, E, R, TestArgs extends TestContextWithValues> {
+    (...args: TestArgs): Effect.Effect<A, E, R>;
+  }
+  /**
+   * @since 4.0.0
+   */
+  type TestContextOnly = [V.TestContext];
+  /**
+   * @since 4.0.0
+   */
+  type TestContextWithValues = [V.TestContext] | [V.TestContext | object] | [V.TestContext | object, V.TestContext] | [V.TestContext | object, V.TestContext & object];
+  /**
+   * @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;
+  }
+  /**
+   * A generated input: a Schema, or an Arbitrary of an already-generated type.
+   *
+   * @since 4.0.0
+   */
+  type ArbitraryInput = ArbitraryInput;
+  /**
+   * The inputs a property generates: a tuple or record of Schemas or Arbitraries.
+   *
+   * @since 4.0.0
+   */
+  type Gens = Gens$1;
+  /**
+   * The types a `Gens` generates: a tuple when `of` is a tuple, a record when it is a record.
+   *
+   * @since 4.0.0
+   */
+  type Values<G extends Gens> = Values$1<G>;
+  /**
+   * The function under test, handed to the property rather than imported into it.
+   *
+   * @since 4.0.0
+   */
+  type PropertySubject = PropertySubject$1;
+  /**
+   * A property's subject, its optional budget and its coverage classes. `runs`, when given, must be a
+   * positive integer; omitted, the effective check options merge the property's fields over the configured
+   * default (`test.provide`) over the built-in `runs: 100`. `cover` declares the coverage classes of R14.
+   *
+   * @since 4.0.0
+   */
+  type PropertySpec<G extends Gens, S extends PropertySubject, N extends number> = PropertySpec$1<G, S, N>;
+  /**
+   * The block a layer opens: `layer(L)(body)` or `layer(L)("name", body)`.
+   *
+   * @since 4.0.0
+   */
+  type LayerBlock<R> = BlockRegistrar<R>;
+  /**
+   * The nested layer a block's own `it.layer` opens.
+   *
+   * @since 4.0.0
+   */
+  type NestedLayerOptions = NestedLayer;
+  /**
+   * Options for the top-level `layer` and for `it.layer` inside a `Methods` block.
+   *
+   * @since 4.0.0
+   */
+  type LayerOptions = LayerOptions$1;
+  /**
+   * A layer's block, data-first or data-last.
+   *
+   * @since 4.0.0
+   */
+  interface LayerOf<R, Options> {
+    <R2, E>(layer: Layer.Layer<R2, E, R>, options?: Options): LayerBlock<R | R2>;
+    (options?: Options): <R2, E>(layer: Layer.Layer<R2, E, R>) => LayerBlock<R | R2>;
+  }
+  /**
+   * A flaky Effect, data-first or data-last.
+   *
+   * @since 4.0.0
+   */
+  type FlakyTest = typeof flakyTest$1;
+  /**
+   * @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>;
+    readonly flakyTest: FlakyTest;
+    readonly layer: LayerOf<R, NestedLayerOptions>;
+    /**
+     * Runs a property that names its subject and carries a budget, on the sync lane.
+     *
+     * **Details**
+     *
+     * `spec.subject` is handed to `holds` instead of being imported into the property. `holds` returns a literal
+     * `true`/`false` verdict: `false` falsifies and triggers shrinking. A verdict that is not a boolean — an
+     * `Effect`, an `expect()`, an object — fails as `NonBooleanVerdict`, and 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.prop(name, [arbitraries], predicate)` is refused.
+     *
+     * @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;
+    };
+    /**
+     * 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.
+     *
+     * @since 4.0.0
+     */
+    readonly law: LawApi;
+  }
+  /**
+   * @since 4.0.0
+   */
+  interface Methods<R = never> extends MethodsNonLive<R> {
+    readonly live: Vitest.Tester<Scope.Scope | R>;
+    readonly layer: LayerOf<R, LayerOptions>;
+  }
+}
+/**
+ * @since 4.0.0
+ */
+export type MethodsNonLive<R = never> = Vitest.MethodsNonLive<R>;
+/**
+ * @since 4.0.0
+ */
+export type Methods<R = never> = Vitest.Methods<R>;
+/**
+ * @since 4.0.0
+ */
+export declare const addEqualityTesters: () => void;
+/**
+ * @since 4.0.0
+ */
+export declare const effect: Vitest.Tester<Scope.Scope>;
+/**
+ * @since 4.0.0
+ */
+export declare const live: Vitest.Tester<Scope.Scope>;
+/**
+ * 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
+ *
+ * ```ts
+ * import { assert, layer } from "@systemfsoftware/vitest"
+ * import { Effect, Layer, Context } 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")
+ *       }))
+ *   })
+ * })
+ * ```
+ */
+export declare const layer: Vitest.LayerOf<never, Vitest.LayerOptions>;
+/**
+ * @since 4.0.0
+ */
+export declare const flakyTest: Vitest.FlakyTest;
+/**
+ * @since 4.0.0
+ */
+export declare const prop: Vitest.Methods['prop'];
+/**
+ * @since 4.0.0
+ */
+export declare const owned: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * @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.
+ *
+ * @since 4.0.0
+ */
+export declare const captureRunBinding: Effect.Effect<RunBinding>;
+/**
+ * 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 vitestTestContextKey: string;
+/**
+ * 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.
+ *
+ * @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;
+/**
+ * @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;
+};
+/**
+ * The fork's `expect`: soft within one Effect step, refusing the slop forms.
+ *
+ * @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;
+/**
+ * @since 4.0.0
+ */
+export declare const beforeAll: typeof beforeAll$1;
+/**
+ * @since 4.0.0
+ */
+export declare const afterAll: typeof afterAll$1;
+//#endregion