@systemfsoftware/vitest 2.0.0 → 4.1.2

package/CHANGELOG.md

@@ -1,63 +1,7 @@
 # @systemfsoftware/vitest
 
-## 2.0.0
+# @systemfsoftware/vitest@4.1.2
 
-### Major Changes
+The recommended config now turns on every @effect/tsgo preset (correctness, recommended, strict, style, effect-native, antipattern and maintainers) at error, on @effect/tsgo 0.69.0 with oxlint 1.93.0 and oxlint-tsgolint 7.0.2006. The rules that still have findings in this repo are listed by name, each with its finding count, and stay off until the PR that fixes its findings removes it from the list. A consumer that upgrades may see findings from rules it has never run. The rules run on the consumer's own Effect-patched tsgolint, so @effect/tsgo is now a peer dependency: a consumer must move @effect/tsgo to ^0.69.0, oxlint to ~1.93.0 and oxlint-tsgolint to 7.0.2006 in the same change, and rerun `effect-tsgo patch --oxlint`. An older patched binary refuses the config with `Rule '<name>' not found in plugin 'effecttsgo'`.
 
-- Property failures (`PropertyRefuted`, `NonBooleanVerdict`, `CoverageBelowMinimum`, `VacuousProperty`, `SelfModelLaw`, `SeedStoreUnreadable`, `ReplayUnreadable`) are exported tagged errors whose fields (property name, site, seed, runs, witness, `replay` text) reach reporters, replacing the `detail` prose. A provided budget `seed` now gives each property its own stable seed; failing seeds are recorded in `__property_seeds__/<test file>.jsonl` and replayed first; vitest-config sets `record: false` in CI and Stryker.
-
-  - To keep one literal seed, set `arbitrary: { seed }` on the property.
-  - Commit `__property_seeds__` files; a case that must always run belongs in the test source.
-  - Catch a self-model law as `SelfModelLaw`, no longer `VacuousProperty`.
-
-## 1.0.0
-
-### Major Changes
-
-- Require `effect` `^4` (stable 4.0.0). Release candidates are no longer supported: imports follow 4.0.0's module layout (`effect/http`, `effect/rpc`, `effect/http-api`, `effect/cluster`, `effect/process`, `effect/socket`, `effect/persistence`, `effect/reactivity`, `effect/encoding`, `effect/Arbitrary`), which does not exist in any 4.0.0 RC.
-
-## 0.3.0
-
-### Minor Changes
-
-- `@systemfsoftware/vitest/failure` exports `Replay`, the `ReplayFromText` codec for `CONFORMANCE_REPLAY` text (`seed=<n>;path=<steps>`), and `replayOfText`, which reads that text or throws. `ReplayValue.path` is now `ReadonlyArray<number>`, and `providedWorkspaceRoot()` returns a branded `WorkspaceRoot`.
-
-## 0.2.0
-
-### Minor Changes
-
-- Tests take `expect` from the test callback and yield each check: `it(name, function* ({ expect }) { yield* expect(actual).toEqual(expected) })`. The package stops exporting `expect`, `assert` and the `utils` helpers. With its `guard` entry listed in `setupFiles`, an `expect` imported from Vitest, or a test registered through Vitest's own `it`, is refused. Also refused, each with its rewrite as the message: a second check on one observed state, an unyielded check, a body with no check, a non-generator body, `it.effect`/`it.scoped`/`it.scopedLive`, `beforeEach`/`afterEach`, and weak matchers such as `toHaveLength`, `toBeDefined`, snapshots, `expect.anything`, `expect.soft`/`expect.poll` and argument-less `toThrow`. Libraries that judge inside a test import `step`, `captureRunBinding` and the `Check`/`Expect`/`Asserted` types from the `integration` entry.
-
-- `@systemfsoftware/differential-spec` depends on and imports `@systemfsoftware/vitest` by its own name instead of through an `@effect/vitest` alias. `@systemfsoftware/oxlint-config-recommended` enables the test-discipline rule under its new id `vitest-from-systemfsoftware-vitest`. `@systemfsoftware/vitest` documentation examples import from `@systemfsoftware/vitest`.
-
-  The lawful runner is published under its own name, `@systemfsoftware/vitest`, starting at `0.1.0`, so peers declared as `^0.1.0` accept its patch releases.
-
-- A failing test now reports one failure record instead of a raw cause: the error with its message, the first source line outside the spec libraries, the steps that ran and the cell decisions each caused, and a rerun command for that one scenario. Every cause in the chain keeps all lines of its message. A replay value is printed only for a run a seed or a property chose. Each failure prints once; other errors in the same cause are logged. A failed `expect` points at the line that called it and a property failure at the line that declared it. A new `@systemfsoftware/vitest/failure` entry exports the renderer, the recorder, the cause summary (`summaryOf`) and the author call-site capture (`callSite`, `callFrameOutside`, `withRaisingFrame`) for libraries that raise their own failures.
-
-- Kernel runs are serialized. A run started while another is live now waits behind it, in arrival order, instead of failing: two runs never interleave, so a scenario never sees another run's decisions, and a suite whose cases drive the kernel can run its tests concurrently.
-
-  `@systemfsoftware/vitest` adds `captureRunBinding`, the running test's run binding. `bind(effect)` 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 that test's assertions, report softly, and see the same `owned` regions.
-
-  `@systemfsoftware/effect-spec-runtime` runs a case that declares no live reason through that runner, and a case's annotations now reach the test's report.
-
-## 0.1.0
-
-### Minor Changes
-
-- Tests take `expect` from the test callback and yield each check: `it(name, function* ({ expect }) { yield* expect(actual).toEqual(expected) })`. The package stops exporting `expect`, `assert` and the `utils` helpers. With its `guard` entry listed in `setupFiles`, an `expect` imported from Vitest, or a test registered through Vitest's own `it`, is refused. Also refused, each with its rewrite as the message: a second check on one observed state, an unyielded check, a body with no check, a non-generator body, `it.effect`/`it.scoped`/`it.scopedLive`, `beforeEach`/`afterEach`, and weak matchers such as `toHaveLength`, `toBeDefined`, snapshots, `expect.anything`, `expect.soft`/`expect.poll` and argument-less `toThrow`. Libraries that judge inside a test import `step`, `captureRunBinding` and the `Check`/`Expect`/`Asserted` types from the `integration` entry.
-
-## 0.0.0
-
-### Minor Changes
-
-- New `captureRunBinding`: an Effect that captures the running test's binding, so a testing library can run an effect elsewhere (e.g. inside a simulation kernel) and still have its `expect` calls counted as that test's assertions.
-
-- `@systemfsoftware/differential-spec` depends on and imports `@systemfsoftware/vitest` by its own name instead of through an `@effect/vitest` alias. `@systemfsoftware/oxlint-config-recommended` enables the test-discipline rule under its new id `vitest-from-systemfsoftware-vitest`. `@systemfsoftware/vitest` documentation examples import from `@systemfsoftware/vitest`.
-
-  The lawful runner is published under its own name, `@systemfsoftware/vitest`, starting at `0.1.0`, so peers declared as `^0.1.0` accept its patch releases.
-
-- Kernel runs are serialized. A run started while another is live now waits behind it, in arrival order, instead of failing: two runs never interleave, so a scenario never sees another run's decisions, and a suite whose cases drive the kernel can run its tests concurrently.
-
-  `@systemfsoftware/vitest` adds `captureRunBinding`, the running test's run binding. `bind(effect)` 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 that test's assertions, report softly, and see the same `owned` regions.
-
-  `@systemfsoftware/effect-spec-runtime` runs a case that declares no live reason through that runner, and a case's annotations now reach the test's report.
+A vitest test body's steps are unwound through Effect.onError, which covers the same failure and interruption cases as the earlier onExit check.

package/README.md

@@ -97,6 +97,18 @@ A passing test outside a declared-shared block runs a second time on a fresh bui
 
 That is how a module-level counter, a shared cache, or a process-global histogram gets reported instead of staying green. `it.live` is re-run too, so a real-resource suite gets the same check. A declared-shared block is the one exception.
 
+A registration can name what the second run runs with `rerun`, a generator body of the same shape. The second run still happens only after a clean first run, on a fresh build, and a failure there is still `LeakedState`. A harness whose first run already repeats the body many times uses it to run the body once more instead of repeating all of that work:
+
+```ts
+it('reads the stored row', function*({ expect }) {
+  // the first run
+}, {
+  rerun: function*({ expect }) {
+    // the second run, on a fresh build of the services
+  },
+})
+```
+
 ## Concurrency and shuffle
 
 Tests inside a block run concurrently and in shuffled order, and each concurrent test keeps its own failure list and check counts. Concurrency is what makes a cross-test leak reproducible: two tests that interleave are two tests whose state must not be shared. Nothing else pins their order.
@@ -199,11 +211,13 @@ CONFORMANCE_REPLAY="property=<hash>;seed=<n>;runs=<n>|..." pnpm test
 Other property failures are exported from the package root as tagged errors — each carries its own fields:
 
 - **`PropertyRefuted`**: `property` (name, site, seed, runs), `counterexample` (rendered, value), `shrinks`, `replay`
+- **`PropertyExhausted`**: `property`, `discards`, `budget` (`{ runs, maxDiscards }`, `maxDiscards` null when uncapped), `replay` — the generator discarded too many draws, so the property was never evaluated; it is not a refutation and records nothing to the seed store
 - **`NonBooleanVerdict`**: `property`, `drawn` (rendered, value), `returned` (array of kinds), `replay`
 - **`CoverageBelowMinimum`**: `property`, `classes` (array of {label, hits, runs, minimum}), `replay`
-- **`SelfModelLaw`**: `name`, `site` — the law compared the subject to itself
+- **`SelfModelLaw`**: `law`, `site` — the law compared the subject to itself
 - **`SeedStoreUnreadable`**: `file`, `line`, `detail` — a seed store file's line could not be decoded
 - **`ReplayUnreadable`**: `text` — `CONFORMANCE_REPLAY` names neither the kernel's `seed=…;path=…` nor a property entry
+- **`ReplayNoLongerReproduces`**: `property`, `replay` — a `CONFORMANCE_REPLAY` replay no longer reproduces its recorded failure
 
 A reporter receives every field on the raw error, so a script or agent narrows by `_tag` and reads the fields directly without parsing messages:
 
@@ -239,6 +253,8 @@ export default defineConfig({
 
 Recorded seeds replay before novel draws on every run, whatever the budget. Only a refuted or non-boolean failure writes, and only in a run that is not derandomized and does not set `record: false`; the shared config sets `record: false` in CI and in Stryker workers. Commit seed store updates like snapshot files.
 
+**Stale seeds**: a recorded seed-store refutation whose draw now passes no longer fails the property; the property's novel draws decide it, and the stale line can be deleted. A recorded draw that still fails but whose recorded shrink steps no longer replay (the generator's shrinking or the failure's kind changed) refutes the property with that draw, unshrunk, as its counterexample. An explicit `CONFORMANCE_REPLAY` replay that no longer reproduces its failure fails with `ReplayNoLongerReproduces` — the stored seed-store path is the one that passes.
+
 **Generator changes**: if a property's generator changes, its recorded seeds may no longer produce their old counterexamples, so the failure stops reproducing. Cases that must always run belong in the test source itself, not in the seed store.
 
 **The `record` option**: `{ runs: 30, record: false }` opts out of writing seeds for a run; the engine still reads and replays existing seeds.

package/dist/{checks-DiuzHhQM.d.ts → checks-BHOX6fGC.d.ts}

@@ -128,7 +128,7 @@ type Assertion<A> = V.Assertion<void, A>;
 /** @internal */
 type MakeAssertion = <A>(actual: A, message?: string) => Assertion<A>;
 /** @internal */
-type Judgement = (make: MakeAssertion) => void;
+type Judgement = (make: MakeAssertion) => Opaque;
 /**
  * The service a check needs. `judge` counts the check and throws {@link refusePiecewise} when a check already ran
  * since the last {@link AssertedShape.step}; `step` opens a new observed state.
@@ -136,7 +136,7 @@ type Judgement = (make: MakeAssertion) => void;
  * @internal
  */
 interface AssertedShape {
-  readonly judge: (judgement: Judgement) => void;
+  readonly judge: (judgement: Judgement) => Opaque;
   readonly step: () => void;
 }
 declare const Asserted_base: Context.ServiceClass<Asserted, "@systemfsoftware/vitest/Asserted", AssertedShape>;

package/dist/{engine-D7Q6-BxD.d.ts → engine-CYGdHvr8.d.ts}

@@ -5,7 +5,6 @@ import * as Schema$1 from "effect/Schema";
 import * as Tracer from "effect/Tracer";
 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).
@@ -28,19 +27,6 @@ declare const Witness: Schema.Struct<{
 }>;
 /** @internal */
 type Witness = typeof Witness.Type;
-/**
- * One property involved in a failure: its full name, its declaration site, its seed and its run count (R2).
- *
- * @internal
- */
-declare const PropertyRun: Schema.Struct<{
-  readonly name: Schema.String;
-  readonly site: Schema.NullOr<Schema.String>;
-  readonly seed: Schema.brand<Schema.Int, "PropertySeed">;
-  readonly runs: Schema.brand<Schema.Int, "PropertyRunCount">;
-}>;
-/** @internal */
-type PropertyRun = typeof PropertyRun.Type;
 declare const PropertyRefuted_base: Schema.Class<PropertyRefuted, Schema.TaggedStruct<"PropertyRefuted", {
   readonly property: Schema.Struct<{
     readonly name: Schema.String;
@@ -54,7 +40,9 @@ declare const PropertyRefuted_base: Schema.Class<PropertyRefuted, Schema.TaggedS
   }>;
   readonly shrinks: Schema.brand<Schema.Int, "PropertyShrinkCount">;
   readonly replay: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 /**
  * A falsified property: the property that ran, the shrunk counterexample the generator settled on, and how many
  * shrink steps it took to reach it (R2-R4).
@@ -64,6 +52,26 @@ declare const PropertyRefuted_base: Schema.Class<PropertyRefuted, Schema.TaggedS
 declare class PropertyRefuted extends PropertyRefuted_base {
   get message(): string;
 }
+declare const PropertyExhausted_base: Schema.Class<PropertyExhausted, Schema.TaggedStruct<"PropertyExhausted", {
+  readonly property: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly site: Schema.NullOr<Schema.String>;
+    readonly seed: Schema.brand<Schema.Int, "PropertySeed">;
+    readonly runs: Schema.brand<Schema.Int, "PropertyRunCount">;
+  }>;
+  readonly discards: Schema.brand<Schema.Int, "PropertyRunCount">;
+  readonly budget: Schema.Struct<{
+    readonly runs: Schema.brand<Schema.Int, "PropertyRunCount">;
+    readonly maxDiscards: Schema.NullOr<Schema.brand<Schema.Int, "PropertyRunCount">>;
+  }>;
+  readonly replay: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** @internal */
+declare class PropertyExhausted extends PropertyExhausted_base {
+  get message(): string;
+}
 declare const NonBooleanVerdict_base: Schema.Class<NonBooleanVerdict, Schema.TaggedStruct<"NonBooleanVerdict", {
   readonly property: Schema.Struct<{
     readonly name: Schema.String;
@@ -77,7 +85,9 @@ declare const NonBooleanVerdict_base: Schema.Class<NonBooleanVerdict, Schema.Tag
   }>;
   readonly returned: Schema.$Array<Schema.Literals<readonly ["undefined", "object", "boolean", "number", "bigint", "string", "symbol", "function", "effect"]>>;
   readonly replay: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 /**
  * A verdict that was not a literal boolean: the property that ran, the first drawn values whose verdict was not a
  * boolean, and every kind of value the property returned (R4).
@@ -101,7 +111,9 @@ declare const CoverageBelowMinimum_base: Schema.Class<CoverageBelowMinimum, Sche
     readonly minimum: Schema.Finite;
   }>>;
   readonly replay: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 /**
  * A property whose declared coverage classes stayed under their minima: the property and the failed classes, in
  * declaration order (R7).
@@ -112,9 +124,11 @@ declare class CoverageBelowMinimum extends CoverageBelowMinimum_base {
   get message(): string;
 }
 declare const SelfModelLaw_base: Schema.Class<SelfModelLaw, Schema.TaggedStruct<"SelfModelLaw", {
-  readonly name: Schema.String;
+  readonly law: Schema.String;
   readonly site: Schema.NullOr<Schema.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 /**
  * A model law given the subject itself as its oracle, so it compares nothing (R13).
  *
@@ -127,7 +141,9 @@ declare const SeedStoreUnreadable_base: Schema.Class<SeedStoreUnreadable, Schema
   readonly file: Schema.String;
   readonly line: Schema.Int;
   readonly detail: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 /**
  * A seed-store line that could not be decoded (R16, KTD6).
  *
@@ -162,7 +178,9 @@ declare const VacuousProperty_base: Schema.Class<VacuousProperty, Schema.TaggedS
     readonly kind: Schema.String;
   }>>;
   readonly replay: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 /**
  * Thrown at file end when no property in the file refuted a subject's constant impostor (R12, R5, R6).
  *
@@ -173,11 +191,34 @@ declare class VacuousProperty extends VacuousProperty_base {
 }
 declare const ReplayUnreadable_base: Schema.Class<ReplayUnreadable, Schema.TaggedStruct<"ReplayUnreadable", {
   readonly text: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 /** @internal */
 declare class ReplayUnreadable extends ReplayUnreadable_base {
   get message(): string;
 }
+declare const ReplayNoLongerReproduces_base: Schema.Class<ReplayNoLongerReproduces, Schema.TaggedStruct<"ReplayNoLongerReproduces", {
+  readonly property: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly site: Schema.NullOr<Schema.String>;
+    readonly seed: Schema.brand<Schema.Int, "PropertySeed">;
+    readonly runs: Schema.brand<Schema.Int, "PropertyRunCount">;
+  }>;
+  readonly replay: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * An explicit `CONFORMANCE_REPLAY` replay whose recorded failure no longer reproduces: after the root re-check,
+ * the replay still mismatched, so no draw reproduces the failure the text names. The recorded seed-store path is
+ * not this — there the entry is one candidate among the novel draws, and only a draw that still fails refutes.
+ *
+ * @internal
+ */
+declare class ReplayNoLongerReproduces extends ReplayNoLongerReproduces_base {
+  get message(): string;
+}
 //#endregion
 //#region src/internal/failure-record.d.ts
 /** A value the renderer narrows rather than assumes. */
@@ -351,46 +392,8 @@ type MemberRecord = {
  * @internal
  */
 type Subject = SubjectFunction | MemberRecord;
-/**
- * One key the impostor froze and the raw output it answered with: the subject itself, or a record member.
- *
- * @internal
- */
-interface FrozenOutput {
-  readonly member: string;
-  readonly output: Opaque;
-}
-/**
- * One property's verdict against a subject's impostor: whether the property refuted the fake, the property it
- * ran, and the raw outputs the fake froze for it.
- *
- * @internal
- */
-interface Refutation {
-  /** `true` when the property falsified for the impostor, so the property does pin the subject down. */
-  readonly refuted: boolean;
-  readonly property: PropertyRun;
-  /** The property's identity hash, so a vacuous verdict's replay text can name it (R9, R11). */
-  readonly identity: number;
-  readonly frozen: ReadonlyArray<FrozenOutput>;
-}
-/**
- * The R12 repair verdict for one subject no property in the file refuted.
- *
- * @internal
- */
-interface FileLedger {
-  readonly record: (subject: Subject, verdict: Refutation) => void;
-  /** Records a law kind exempt from the gate, so a refusal can list it (R6). */
-  readonly recordExempt: (name: string, kind: string) => void;
-  /** The single refusal when at least one subject is vacuous, or `undefined` when the file holds. */
-  readonly finalise: () => VacuousProperty | undefined;
-}
-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';
+//#endregion
+//#region src/internal/property/kinds.d.ts
 /**
  * A subject of a law kind: a function of the generated values.
  *
@@ -419,27 +422,8 @@ interface LawApi {
   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, PropertyTask, Values, makeProperty };
-}
+//#endregion
+//#region src/internal/property/engine.d.ts
 /** @internal */
 type ArbitraryInput = Schema$1.Top | Arbitrary.Arbitrary<Schema$1.Top['Type']>;
 /** @internal */
@@ -471,33 +455,10 @@ interface PropertySpec<G extends Gens, S extends PropertySubject, N extends numb
   readonly arbitrary?: Arbitrary.CheckOptions;
 }
 /** @internal */
-interface PropertyTask {
-  /** The property's run-time identity (KTD3): its package, project-relative file and full name. */
-  readonly identity: TestIdentity;
-  /** The absolute path of the test file whose seed store is read and written beside it (KTD6); `null` keeps no store. */
-  readonly filepath: string | null;
-  /** The provided property budget, or `undefined` when the run provided none. */
-  readonly budget: ProvidedCheckDefaults | undefined;
-}
-/** @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: (task: PropertyTask) => 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>;
-  /** The file ledger every property of this runtime records its impostor verdict into (R20, KTD10). */
-  readonly ledger: FileLedger;
-}
-/** @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 { VacuousProperty as A, witnessOf as C, ReplayUnreadable as D, PropertyRefuted as E, Breach as M, __exportAll as N, SeedStoreUnreadable as O, throwFailureRecord as S, NonBooleanVerdict as T, ReplayValue as _, PropertySubject as a, summaryOf as b, LawApi as c, ProvidedCheckDefaults as d, checkDefaultsKey as f, JsonValue as g, FailureRecordInput as h, PropertySpec as i, Witness as j, SelfModelLaw as k, kinds_d_exports as l, FailureRecord as m, Gens as n, Values as o, AttributeValue as p, PropApi as r, engine_d_exports as s, ArbitraryInput as t, PropertyBudget as u, TestIdentity as v, CoverageBelowMinimum as w, testIdentityOf as x, renderFailureRecord as y };
+export { VacuousProperty as A, NonBooleanVerdict as C, ReplayUnreadable as D, ReplayNoLongerReproduces as E, Breach as M, SeedStoreUnreadable as O, CoverageBelowMinimum as S, PropertyRefuted as T, renderFailureRecord as _, PropertySubject as a, throwFailureRecord as b, PropertyBudget as c, AttributeValue as d, FailureRecord as f, TestIdentity as g, ReplayValue as h, PropertySpec as i, Witness as j, SelfModelLaw as k, ProvidedCheckDefaults as l, JsonValue as m, Gens as n, Values as o, FailureRecordInput as p, PropApi as r, LawApi as s, ArbitraryInput as t, checkDefaultsKey as u, summaryOf as v, PropertyExhausted as w, witnessOf as x, testIdentityOf as y };