@systemfsoftware/vitest 1.0.0 → 2.0.0

package/dist/failure.d.ts

@@ -1,7 +1,6 @@
 
-import { a as Values, i as PropertySubject, l as Breach, n as Gens, o as engine_d_exports, r as PropertySpec } from "./engine-CMvYG5V0.js";
+import { A as VacuousProperty, C as witnessOf, M as Breach, S as throwFailureRecord, _ as ReplayValue, a as PropertySubject, b as summaryOf, d as ProvidedCheckDefaults, g as JsonValue, h as FailureRecordInput, i as PropertySpec, j as Witness, m as FailureRecord, n as Gens, o as Values, p as AttributeValue, r as PropApi, s as engine_d_exports, v as TestIdentity, x as testIdentityOf, y as renderFailureRecord } from "./engine-D7Q6-BxD.js";
 import { i as Checks, t as Asserted } from "./checks-DiuzHhQM.js";
-import * as Cause from "effect/Cause";
 import * as Effect$1 from "effect/Effect";
 import * as Tracer from "effect/Tracer";
 import { Option, Schema } from "effect";
@@ -16,116 +15,6 @@ export declare const withRaisingFrame: {
   (frame: string | undefined): <A extends Error>(error: A) => A;
 };
 //#endregion
-//#region src/internal/failure-record.d.ts
-/** A value the renderer narrows rather than assumes. */
-type Opaque<A = unknown> = A;
-/**
- * A value a recorded span attribute or a replay path carries. Structured values stay structured on the span
- * (KTD2); the renderer decides the text.
- *
- * @internal
- */
-type AttributeValue = string | number | boolean | null | ReadonlyArray<AttributeValue> | {
-  readonly [key: string]: AttributeValue;
-};
-/**
- * The test a failure happened in, as Vitest knows it. `file` is the path the rerun command names, so a caller
- * that holds an absolute path derives the repo-relative one before handing it over.
- *
- * @internal
- */
-interface TestIdentity {
-  /**
-   * The npm package the test file belongs to, e.g. `@systemfsoftware/effect-readiness`. Empty when the run
-   * provided no name: the rerun command then drops its `pnpm --filter` prefix and runs from the package
-   * directory, which is not a breach (R6).
-   */
-  readonly package: string;
-  /** The test file, as the rerun command writes it. */
-  readonly file: string;
-  /** The scenario name the rerun command filters on with `-t`. */
-  readonly name: string;
-}
-/**
- * The value a generator chose a run by: the kernel's seed and decision path, or a property counterexample's
- * seed and path. A path without a seed is a replay value offered for a baseline run, which R6 refuses (KTD5).
- *
- * @internal
- */
-interface ReplayValue {
-  /** The generator's seed, or `undefined` when only a path was recorded. */
-  readonly seed: number | undefined;
-  /** The decisions the generator chose, in order; a decision is the index the scheduler picked (KTD5). */
-  readonly path: ReadonlyArray<number>;
-}
-/**
- * A contract rule a rendered record breaks; the runner refuses such a record (R10, KTD7).
- *
- * @internal
- */
-/**
- * What a rendered failure gives Vitest: the tag the error carries, the record text, and the rules it breaks.
- *
- * @internal
- */
-interface FailureRecord {
-  /** The headline's failure tag, e.g. `StepError`; the runner sets it as the thrown error's `name`. */
-  readonly name: string;
-  /** The text Vitest prints as the failure's message. */
-  readonly record: string;
-  /** The contract rules the record breaks: `R1` empty headline, `R2` no location, `R6` replay or rerun. */
-  readonly breaches: ReadonlyArray<Breach>;
-}
-/**
- * Everything one failure is rendered from: the failure, its run's spans, the test and the replay value.
- *
- * @internal
- */
-interface FailureRecordInput<E = never> {
-  /** The failure itself: a `Cause`, or the value a program threw or failed with. */
-  readonly failure: Cause.Cause<E> | E;
-  /** Every span the failing run recorded, in creation order. */
-  readonly spans: ReadonlyArray<Tracer.NativeSpan>;
-  /** The test the run belonged to. */
-  readonly identity: TestIdentity;
-  /** The generator that chose this run, or `undefined` on a run no generator chose. */
-  readonly replay: ReplayValue | undefined;
-  /**
-   * The seed the kernel's scheduler chose. The kernel knows its own scheduler, so it hands the note over rather
-   * than the renderer guessing it; a run no scheduler chose renders no note (KTD5).
-   */
-  readonly schedule?: {
-    readonly seed: number;
-  } | undefined;
-  /**
-   * The workspace root the rendered paths are relativized against, provided by the shared config the same way the
-   * package name is. Omitted, paths print absolute.
-   */
-  readonly root?: string | undefined;
-}
-/** @internal */
-export declare const summaryOf: (value: Opaque) => string;
-/**
- * Renders the record Vitest prints for one spec failure, and the contract rules it breaks.
- *
- * Never throws: a `Cause` renders layer by layer, a thrown `Error` renders as one layer, and any other value
- * renders as itself. The first location the record names is the raising frame — the first stack frame outside
- * `node_modules` and outside the spec libraries' own `src/` and `dist/` — and when no layer has one, the
- * innermost failed span's site stands in, or the innermost unfinished cell's decide site for a deadlock (KTD6).
- *
- * @internal
- */
-export declare const renderFailureRecord: <E>(input: FailureRecordInput<E>) => FailureRecord;
-/** @internal */
-export declare const throwFailureRecord: <E>(input: FailureRecordInput<E>) => never;
-interface TaskLike {
-  readonly name?: string | undefined;
-  readonly fullName?: string | undefined;
-  readonly fullTestName?: string | undefined;
-}
-/** @internal */
-export declare const testIdentityOf: (task?: TaskLike | null) => TestIdentity;
-//#endregion
 //#region src/internal/provided.schema.d.ts
 /**
  * The workspace root every rendered path is relativized against.
@@ -150,6 +39,10 @@ interface RecordedProperty<G extends Gens, S extends PropertySubject, N extends
   readonly name: string;
   readonly spec: PropertySpec<G, S, N>;
   readonly holds: (subject: S, values: Values<G>) => boolean;
+  /** The provided budget the run supplies in place of the configured default, e.g. a derandomizing `seed`. */
+  readonly budget?: ProvidedCheckDefaults | undefined;
+  /** The path of the test file whose seed store to read and write; absent, the run keeps no store. */
+  readonly store?: string | undefined;
 }
 /**
  * Runs one program as the runner runs a lane, with a fresh ledger and its own recorder, and resolves with the
@@ -158,6 +51,11 @@ interface RecordedProperty<G extends Gens, S extends PropertySubject, N extends
  * @internal
  */
 export declare const recordOfRun: <A, E>(program: RecordedRun<A, E>) => Promise<FailureRecord | undefined>;
+/** @internal */
+interface RecordedFile {
+  readonly records: ReadonlyArray<FailureRecord | undefined>;
+  readonly vacuous: VacuousProperty | undefined;
+}
 /**
  * Runs one property the way the runner runs `it.prop`, with a fresh ledger and its own recorder, and resolves with
  * the record its falsification rendered — or `undefined` when it held.
@@ -165,6 +63,21 @@ export declare const recordOfRun: <A, E>(program: RecordedRun<A, E>) => Promise<
  * @internal
  */
 export declare const recordOfProperty: <const G extends Gens, S extends PropertySubject, N extends number>(input: RecordedProperty<G, S, N>) => Promise<FailureRecord | undefined>;
+interface RecordedFileOptions {
+  readonly budget?: ProvidedCheckDefaults | undefined;
+  readonly store?: string | undefined;
+}
+/**
+ * Runs every property and law a file registers, in registration order, then finalises the file's one ledger:
+ * resolves with each property's rendered failure and the file's single vacuous verdict, or `undefined` when the
+ * file holds. The name a property is recorded under is the name it was registered with.
+ *
+ * @internal
+ */
+export declare const recordOfFile: {
+  (register: (api: PropApi<never>) => void, options?: RecordedFileOptions): Promise<RecordedFile>;
+  (options?: RecordedFileOptions): (register: (api: PropApi<never>) => void) => Promise<RecordedFile>;
+};
 //#endregion
 //#region src/internal/span-recorder.d.ts
 /** @internal */
@@ -191,8 +104,8 @@ export type Replay = typeof Replay.Type;
  */
 export declare const replayOfText: (text: string) => Replay;
 /**
- * The replay codec: `Schema.String` in, a replay out. A text that names no seed and path fails the decode, and
- * every replay encodes back to the text it was read from.
+ * The kernel's replay codec: `Schema.String` in, a replay out. A text that names no seed and path fails the decode,
+ * and every replay encodes back to the text it was read from.
  *
  * @since 4.0.0
  */
@@ -201,4 +114,4 @@ export declare const ReplayFromText: Schema.decodeTo<Schema.Struct<{
   readonly path: Schema.$Array<Schema.brand<Schema.Int, "ReplayStep">>;
 }>, Schema.String, never, never>;
 //#endregion
-export { type AttributeValue, type Breach, type FailureRecord, type FailureRecordInput, type RecordedProperty, type RecordedRun, type ReplayValue, type SpanRecorder, type TestIdentity, providedRoot as providedWorkspaceRoot };
+export { type AttributeValue, type Breach, type FailureRecord, type FailureRecordInput, type JsonValue, type RecordedFile, type RecordedProperty, type RecordedRun, type ReplayValue, type SpanRecorder, type TestIdentity, type Witness, providedRoot as providedWorkspaceRoot, renderFailureRecord, summaryOf, testIdentityOf, throwFailureRecord, witnessOf };

package/dist/failure.mjs

@@ -1,4 +1,4 @@
 
-import { _ as ReplayFromText, c as summaryOf, d as providedRoot, g as Replay, l as testIdentityOf, n as recordOfRun, r as createSpanRecorder, s as renderFailureRecord, t as recordOfProperty, u as throwFailureRecord, v as replayOfText } from "./failure-D8mPXwf4.mjs";
+import { E as replayOfText, T as ReplayFromText, _ as testIdentityOf, b as providedRoot, g as summaryOf, h as renderFailureRecord, i as createSpanRecorder, n as recordOfProperty, r as recordOfRun, t as recordOfFile, v as throwFailureRecord, w as Replay, y as witnessOf } from "./failure-nvq5TwWX.mjs";
 import { c as callFrameOutside, l as callSite, p as withRaisingFrame } from "./test-context-D_-acRSc.mjs";
-export { Replay, ReplayFromText, callFrameOutside, callSite, createSpanRecorder, providedRoot as providedWorkspaceRoot, recordOfProperty, recordOfRun, renderFailureRecord, replayOfText, summaryOf, testIdentityOf, throwFailureRecord, withRaisingFrame };
+export { Replay, ReplayFromText, callFrameOutside, callSite, createSpanRecorder, providedRoot as providedWorkspaceRoot, recordOfFile, recordOfProperty, recordOfRun, renderFailureRecord, replayOfText, summaryOf, testIdentityOf, throwFailureRecord, withRaisingFrame, witnessOf };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="./compat.d.ts" />
-import { a as Values$1, c as kinds_d_exports, i as PropertySubject$1, n as Gens$1, o as engine_d_exports, r as PropertySpec$1, s as LawApi, t as ArbitraryInput, u as __exportAll } from "./engine-CMvYG5V0.js";
+import { A as VacuousProperty, D as ReplayUnreadable, E as PropertyRefuted, N as __exportAll, O as SeedStoreUnreadable, T as NonBooleanVerdict, a as PropertySubject$1, c as LawApi, d as ProvidedCheckDefaults, f as checkDefaultsKey, i as PropertySpec$1, k as SelfModelLaw, l as kinds_d_exports, n as Gens$1, o as Values$1, s as engine_d_exports, t as ArbitraryInput, u as PropertyBudget, w as CoverageBelowMinimum } from "./engine-D7Q6-BxD.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-DiuzHhQM.js";
 import * as V from "vitest";
 import { afterAll, assertType, beforeAll, expectTypeOf, inject, onTestFailed, onTestFinished, recordArtifact, vi, vitest } from "vitest";
@@ -9,15 +9,8 @@ import * as Layer from "effect/Layer";
 import * as Scope from "effect/Scope";
 import * as TestConsole from "effect/testing/TestConsole";
 import * as Context from "effect/Context";
-import * as Arbitrary from "effect/Arbitrary";
 import * as Clock from "effect/Clock";
 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/virtual-time.d.ts
 /** @internal */
 interface VirtualRuntime {
@@ -132,7 +125,7 @@ declare const describeWrapped$1: {
   (f: (it: Vitest.Methods) => void): (name: string) => V.SuiteCollector;
 };
 declare namespace mod_d_exports {
-  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 };
+  export { Asserted, Check, Checks, CoverageBelowMinimum, Expect, Gate, NonBooleanVerdict, PropertyBudget, PropertyRefuted, ReplayUnreadable, SeedStoreUnreadable, SelfModelLaw, VacuousProperty, 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 };
 }
 declare module 'vitest' {
   interface ProvidedContext {
@@ -495,4 +488,4 @@ export declare const VitestTestContext: Context.Reference<V.TestContext | null>;
  */
 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 };
+export { type Asserted, type Check, type Checks, CoverageBelowMinimum, type Expect, NonBooleanVerdict, type PropertyBudget, PropertyRefuted, ReplayUnreadable, SeedStoreUnreadable, SelfModelLaw, VacuousProperty, afterAll, assertType, beforeAll, expectTypeOf, inject, onTestFailed, onTestFinished, recordArtifact, vi, vitest };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 
-import { a as replayOfFailure, d as providedRoot, f as InvalidBudget, h as Slop, i as makeProperty, l as testIdentityOf, m as NonBooleanVerdict, o as isFailureRecordError, p as LeakedState, r as createSpanRecorder, u as throwFailureRecord } from "./failure-D8mPXwf4.mjs";
+import { C as Slop, D as providedCheckDefaults, S as LeakedState, _ as testIdentityOf, a as makeProperty, b as providedRoot, c as NonBooleanVerdict, d as SeedStoreUnreadable, f as SelfModelLaw, i as createSpanRecorder, l as PropertyRefuted, m as isFailureRecordError, o as makeFileLedger, p as VacuousProperty, s as CoverageBelowMinimum, u as ReplayUnreadable, v as throwFailureRecord, x as InvalidBudget } from "./failure-nvq5TwWX.mjs";
 import { a as isCheck, i as checksFor, n as vitestTestContextKey$1, o as makeLedger, r as Asserted, t as VitestTestContext$1 } from "./test-context-D_-acRSc.mjs";
 import { _ as refuseScopedLiveLane, d as refuseAsyncBody, f as refuseEffectLane, g as refuseScopedLane, i as markTask, l as noCheckRefusal, o as isRefusal$1, p as refuseHook, u as refusalOf$1, v as refuseSyncBody, x as unprovidedText, y as refuseUnyielded } from "./guard-BocOhXt2.mjs";
 import * as V from "vitest";
@@ -374,7 +374,7 @@ const throwRecorded = (cause, recorder, ctx) => {
 		failure,
 		spans: recorder.spans,
 		identity: testIdentityOf(ctx.task),
-		replay: replayOfFailure(failure),
+		replay: void 0,
 		root: providedRoot()
 	});
 };
@@ -462,14 +462,26 @@ const NO_ERRORS = [];
 const presentErrors = (errors) => errors === void 0 ? NO_ERRORS : errors;
 /** Whether a run left no failure behind: only a clean first run is worth running a second time. */
 const isClean = (ctx) => presentErrors(ctx.task.result?.errors).length === 0;
+const propertyTaskOf = (ctx) => ({
+	identity: testIdentityOf(ctx.task),
+	filepath: ctx.task.file.filepath,
+	budget: providedCheckDefaults()
+});
 /**
 * Runs a property's program as the test that registered it, under the same context the generator lanes use. The
 * env is the bare `propertyEnv`: a `false` verdict is the property's own shrink path, so nothing interrupts it.
 */
-const runProperty = (ctx, program) => runRecorded(bindRun(Effect.suspend(program), ctx), ctx, propertyEnv);
+const runProperty = (ctx, program) => runRecorded(bindRun(Effect.suspend(() => program(propertyTaskOf(ctx))), ctx), ctx, propertyEnv);
+/** The sync and effect property lanes of one test file share this ledger; it is judged once, at file end (R20). */
+const propertyLedger = makeFileLedger();
+V.afterAll(() => {
+	const refused = propertyLedger.finalise();
+	if (refused !== void 0) throw new VacuousProperty(refused);
+});
 const property = makeProperty({
 	register: (name, program) => marked(() => V.it(name, (ctx) => runProperty(ctx, program))),
-	provide: (effect) => effect
+	provide: (effect) => effect,
+	ledger: propertyLedger
 });
 const propImpl = (name, spec, holds) => {
 	refusePositional(spec);
@@ -676,7 +688,8 @@ const makeTesterWith = (mapEffect, it, envFor, rerunnable) => {
 	};
 	const effectProperty = makeProperty({
 		register: (name, program) => marked(() => it(name, (ctx) => runProperty(ctx, program))),
-		provide: (effect) => mapEffect(effect, envFor())
+		provide: (effect) => mapEffect(effect, envFor()),
+		ledger: propertyLedger
 	});
 	const prop = (name, spec, holds) => {
 		refusePositional(spec);
@@ -838,4 +851,4 @@ const vitestTestContextKey = vitestTestContextKey$1;
 */
 const VitestTestContext = VitestTestContext$1;
 //#endregion
-export { VitestTestContext, addEqualityTesters, afterAll, afterEach, assertType, beforeAll, beforeEach, describe, describeWrapped, expectTypeOf, flakyTest, inject, it, law, layer, makeMethods, onTestFailed, onTestFinished, prop, recordArtifact, test, vi, vitest, vitestTestContextKey };
+export { CoverageBelowMinimum, NonBooleanVerdict, PropertyRefuted, ReplayUnreadable, SeedStoreUnreadable, SelfModelLaw, VacuousProperty, VitestTestContext, addEqualityTesters, afterAll, afterEach, assertType, beforeAll, beforeEach, describe, describeWrapped, expectTypeOf, flakyTest, inject, it, law, layer, makeMethods, onTestFailed, onTestFinished, prop, recordArtifact, test, vi, vitest, vitestTestContextKey };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/vitest",
   "license": "MIT",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -46,6 +46,9 @@
   "files": [
     "dist"
   ],
+  "dependencies": {
+    "@effect/platform-node": "^4"
+  },
   "devDependencies": {
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
     "@systemfsoftware/oxlint-config-recommended": "^4.0.0",

package/dist/engine-CMvYG5V0.d.ts

@@ -1,166 +0,0 @@
-
-import * as Cause from "effect/Cause";
-import * as Effect$1 from "effect/Effect";
-import * as Schema$1 from "effect/Schema";
-import { Schema } from "effect";
-import * as Arbitrary from "effect/Arbitrary";
-//#endregion
-//#region src/internal/errors.schema.d.ts
-/**
- * The contract rules a rendered failure record can break (R10, KTD7).
- *
- * @internal
- */
-declare const Breach: Schema.Literals<readonly ["R1", "R2", "R6"]>;
-/** @internal */
-type Breach = typeof Breach.Type;
-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, 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, A> {
-  readonly transform: (...values: ReadonlyArray<ElementValues<G>>) => Values<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, A, N extends number, S extends LawSubject<G, A>>(name: string, spec: PropertySpec<G, S, N>, oracle: LawSubject<G, A>) => void;
-  readonly metamorphic: <const G extends Gens, A, N extends number, S extends LawSubject<G, A>>(name: string, spec: PropertySpec<G, S, N>, relation: MetamorphicRelation<G, A>) => void;
-  readonly roundTrip: <const G extends Gens, E, N extends number, S extends LawSubject<G, E>>(name: string, spec: PropertySpec<G, S, N>, decode: (encoded: E) => Values<G>) => void;
-  readonly invariant: <const G extends Gens, A, N extends number, S extends LawSubject<G, A>>(name: string, spec: PropertySpec<G, S, N>, holds: (output: A, ...values: ReadonlyArray<ElementValues<G>>) => boolean) => void;
-  readonly idempotent: <const G extends Gens, N extends number, S extends (value: ElementValues<G>) => ElementValues<G>>(name: string, spec: PropertySpec<G, S, N>) => void;
-  readonly deterministic: <const G extends Gens, A, N extends number, S extends LawSubject<G, A>>(name: string, spec: PropertySpec<G, S, N>) => void;
-}
-/**
- * The generated values as the argument list a law subject is called with.
- *
- * @internal
- */
-declare const spreadValues: <G extends Gens>(values: Values<G>) => ReadonlyArray<ElementValues<G>>;
-/** @internal */
-declare const modelHolds: <G extends Gens, A>(oracle: LawSubject<G, A>) => (subject: LawSubject<G, A>, values: Values<G>) => boolean;
-/** @internal */
-declare const metamorphicHolds: <G extends Gens, A>(relation: MetamorphicRelation<G, A>) => (subject: LawSubject<G, A>, values: Values<G>) => boolean;
-/** @internal */
-declare const roundTripHolds: <G extends Gens, E>(decode: (encoded: E) => Values<G>) => (subject: LawSubject<G, E>, values: Values<G>) => boolean;
-/** @internal */
-declare const invariantHolds: <G extends Gens, A>(holds: (output: A, ...values: ReadonlyArray<ElementValues<G>>) => boolean) => (subject: LawSubject<G, A>, values: Values<G>) => boolean;
-/** @internal */
-declare const idempotentHolds: <G extends Gens>() => (subject: (value: ElementValues<G>) => ElementValues<G>, values: Values<G>) => boolean;
-/** @internal */
-declare const deterministicHolds: <G extends Gens, A>() => (subject: LawSubject<G, A>, values: Values<G>) => boolean;
-declare namespace engine_d_exports {
-  export { ArbitraryInput, CoveragePredicate, ElementValues, Gens, PropApi, PropertyRuntime, PropertySpec, PropertySubject, Values, makeProperty };
-}
-/** @internal */
-type ArbitraryInput = Schema$1.Top | Arbitrary.Arbitrary<Schema$1.Top['Type']>;
-/** @internal */
-type Gens = 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<G extends Gens> = { readonly [K in keyof G]: Generated<G[K]>; };
-/** @internal */
-type ElementValues<G extends Gens> = G extends ReadonlyArray<ArbitraryInput> ? Generated<G[number]> : never;
-/** @internal */
-type PropertySubject = Subject;
-/** @internal */
-type CoveragePredicate<G extends Gens> = (...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<G extends Gens, S extends PropertySubject, 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$1.Effect<void, Cause.Cause<NonBooleanVerdict>, never>) => void;
-  readonly provide: <A, E>(effect: Effect$1.Effect<A, E, R>) => Effect$1.Effect<A, E, never>;
-}
-/** @internal */
-interface PropApi<R> {
-  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;
-  readonly effectProp: <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$1.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
-export { Values as a, kinds_d_exports as c, PropertySubject as i, Breach as l, Gens as n, engine_d_exports as o, PropertySpec as r, LawApi as s, ArbitraryInput as t, __exportAll as u };