@systemfsoftware/vitest 0.0.0 → 0.2.0

package/dist/checks-Cq9of-Lx.d.ts

@@ -0,0 +1,336 @@
+
+import * as V from "vitest";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Tracer from "effect/Tracer";
+import * as Context from "effect/Context";
+//#region src/internal/failure-record.d.ts
+/** A value the renderer narrows rather than assumes. */
+type Opaque$1<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 or inputs the generator chose, in order. */
+  readonly path: ReadonlyArray<AttributeValue>;
+}
+/**
+ * A contract rule a rendered record breaks; the runner refuses such a record (R10, KTD7).
+ *
+ * @internal
+ */
+type Breach = 'R1' | 'R2' | 'R6';
+/**
+ * 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 */
+declare const summaryOf: (value: Opaque$1) => 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
+ */
+declare const renderFailureRecord: <E>(input: FailureRecordInput<E>) => FailureRecord;
+//#endregion
+//#region src/internal/refusals.d.ts
+/** @internal */
+declare const refusedText: {
+  readonly toBeDefined: '✗ toBeDefined passes for almost any value the code returns. Assert the value: yield* expect(actual).toEqual(expected).';
+  readonly toBeTruthy: '✗ toBeTruthy passes for almost any value the code returns. Assert the value: yield* expect(actual).toEqual(expected).';
+  readonly toBeFalsy: '✗ toBeFalsy passes for almost any value the code returns. Assert the value: yield* expect(actual).toEqual(expected).';
+  readonly toHaveLength: '✗ toHaveLength checks how many, not which. Assert the contents: toEqual([...]); only some of them: toEqual(expect.arrayContaining([...])).';
+  readonly toHaveProperty: '✗ toHaveProperty checks one key at a time. Assert the shape once: toMatchObject({ key: value, ... }).';
+  readonly toBeInstanceOf: '✗ toBeInstanceOf checks the kind of value, not the value. Assert the value: toEqual(expected); only its shape: toEqual(expect.schemaMatching(Schema)).';
+  readonly toBeTypeOf: '✗ toBeTypeOf checks the kind of value, not the value. Assert the value: toEqual(expected); only its shape: toEqual(expect.schemaMatching(Schema)).';
+  readonly toHaveBeenCalled: '✗ toHaveBeenCalled passes for any call with any arguments. Assert what the call carried: toHaveBeenCalledExactlyOnceWith(...args).';
+  readonly toHaveBeenCalledTimes: '✗ toHaveBeenCalledTimes counts calls, not what they carried. Assert the calls: toHaveBeenNthCalledWith(n, ...args), or all of them: expect(spy.mock.calls).toEqual([[...], [...]]).';
+  readonly toMatchSnapshot: '✗ a snapshot records what the code does now, not what it should do, and cannot fail on the run that writes it. State the expected value: toEqual(expected).';
+  readonly toMatchInlineSnapshot: '✗ a snapshot records what the code does now, not what it should do, and cannot fail on the run that writes it. State the expected value: toEqual(expected).';
+  readonly toMatchFileSnapshot: '✗ a snapshot records what the code does now, not what it should do, and cannot fail on the run that writes it. State the expected value: toEqual(expected).';
+  readonly toThrowErrorMatchingSnapshot: '✗ a snapshot records what the code does now, not what it should do, and cannot fail on the run that writes it. Name the error: toThrow(MyError).';
+  readonly toThrowErrorMatchingInlineSnapshot: '✗ a snapshot records what the code does now, not what it should do, and cannot fail on the run that writes it. Name the error: toThrow(MyError).';
+  readonly resolves: '✗ .resolves/.rejects assert on a Promise outside the test runtime. Yield the Effect: const value = yield* program; its failure: const error = yield* Effect.flip(program); then yield* expect(error).toEqual(new MyError(...)).';
+  readonly rejects: '✗ .resolves/.rejects assert on a Promise outside the test runtime. Yield the Effect: const value = yield* program; its failure: const error = yield* Effect.flip(program); then yield* expect(error).toEqual(new MyError(...)).';
+  readonly anything: '✗ expect.anything() matches every value. Say what the value must be: expect.any(Money), expect.objectContaining({ ... }), expect.schemaMatching(Schema).';
+  readonly poll: '✗ expect.poll waits on the real clock, outside the runner\'s virtual time. Let time pass inside the test: yield* TestClock.adjust("3 seconds"); then yield* expect(value).toEqual(expected).';
+  readonly soft: '✗ expect.soft reports several failures on one state; the fork reports the state once. Assert the state once: yield* expect(actual).toEqual(expected).';
+};
+/** @internal */
+type refusedText = typeof refusedText;
+/** @internal */
+declare const negatedText: {
+  readonly toBeDefined: '✗ toBeDefined passes for almost any value the code returns. Assert the value: yield* expect(actual).toEqual(expected).';
+  readonly toBeTruthy: '✗ toBeTruthy passes for almost any value the code returns. Assert the value: yield* expect(actual).toEqual(expected).';
+  readonly toBeFalsy: '✗ toBeFalsy passes for almost any value the code returns. Assert the value: yield* expect(actual).toEqual(expected).';
+  readonly toHaveLength: '✗ toHaveLength checks how many, not which. Assert the contents: toEqual([...]); only some of them: toEqual(expect.arrayContaining([...])).';
+  readonly toHaveProperty: '✗ toHaveProperty checks one key at a time. Assert the shape once: toMatchObject({ key: value, ... }).';
+  readonly toBeInstanceOf: '✗ toBeInstanceOf checks the kind of value, not the value. Assert the value: toEqual(expected); only its shape: toEqual(expect.schemaMatching(Schema)).';
+  readonly toBeTypeOf: '✗ toBeTypeOf checks the kind of value, not the value. Assert the value: toEqual(expected); only its shape: toEqual(expect.schemaMatching(Schema)).';
+  readonly toHaveBeenCalled: '✗ toHaveBeenCalled passes for any call with any arguments. Assert what the call carried: toHaveBeenCalledExactlyOnceWith(...args).';
+  readonly toHaveBeenCalledTimes: '✗ toHaveBeenCalledTimes counts calls, not what they carried. Assert the calls: toHaveBeenNthCalledWith(n, ...args), or all of them: expect(spy.mock.calls).toEqual([[...], [...]]).';
+  readonly toMatchSnapshot: '✗ a snapshot records what the code does now, not what it should do, and cannot fail on the run that writes it. State the expected value: toEqual(expected).';
+  readonly toMatchInlineSnapshot: '✗ a snapshot records what the code does now, not what it should do, and cannot fail on the run that writes it. State the expected value: toEqual(expected).';
+  readonly toMatchFileSnapshot: '✗ a snapshot records what the code does now, not what it should do, and cannot fail on the run that writes it. State the expected value: toEqual(expected).';
+  readonly toThrowErrorMatchingSnapshot: '✗ a snapshot records what the code does now, not what it should do, and cannot fail on the run that writes it. Name the error: toThrow(MyError).';
+  readonly toThrowErrorMatchingInlineSnapshot: '✗ a snapshot records what the code does now, not what it should do, and cannot fail on the run that writes it. Name the error: toThrow(MyError).';
+  readonly resolves: '✗ .resolves/.rejects assert on a Promise outside the test runtime. Yield the Effect: const value = yield* program; its failure: const error = yield* Effect.flip(program); then yield* expect(error).toEqual(new MyError(...)).';
+  readonly rejects: '✗ .resolves/.rejects assert on a Promise outside the test runtime. Yield the Effect: const value = yield* program; its failure: const error = yield* Effect.flip(program); then yield* expect(error).toEqual(new MyError(...)).';
+  readonly anything: '✗ expect.anything() matches every value. Say what the value must be: expect.any(Money), expect.objectContaining({ ... }), expect.schemaMatching(Schema).';
+  readonly poll: '✗ expect.poll waits on the real clock, outside the runner\'s virtual time. Let time pass inside the test: yield* TestClock.adjust("3 seconds"); then yield* expect(value).toEqual(expected).';
+  readonly soft: '✗ expect.soft reports several failures on one state; the fork reports the state once. Assert the state once: yield* expect(actual).toEqual(expected).';
+  readonly toBeNull: '✗ not.toBeNull passes for almost any value the code returns. Assert the value: yield* expect(actual).toEqual(expected).';
+  readonly toBeUndefined: '✗ not.toBeUndefined passes for almost any value the code returns. Assert the value: yield* expect(actual).toEqual(expected).';
+};
+/** @internal */
+type negatedText = typeof negatedText;
+/** @internal */
+declare const neededText: {
+  readonly toThrow: '✗ toThrow() passes for any error. Name the one expected: toThrow(MyError) or toThrow("message"). An Effect failure is a value: const error = yield* Effect.flip(program); yield* expect(error).toEqual(new MyError(...)).';
+  readonly toThrowError: '✗ toThrowError() passes for any error. Name the one expected: toThrow(MyError) or toThrow("message"). An Effect failure is a value: const error = yield* Effect.flip(program); yield* expect(error).toEqual(new MyError(...)).';
+  readonly toSatisfy: '✗ toSatisfy(predicate) fails with \'expected x to satisfy [Function]\'. Say what must hold: toSatisfy(predicate, "every line has a positive quantity").';
+  readonly toMatchObject: '✗ toMatchObject({}) matches every object. Name the fields that must hold: toMatchObject({ status: "Pending" }).';
+};
+/** @internal */
+type neededText = typeof neededText;
+/** @internal */
+declare const booleanRefusal = "✗ expect(<boolean>) can only report 'expected false to be true'. Pass the two values instead: yield* expect(a).toEqual(b), which uses Effect Equal. A predicate: yield* expect(value).toSatisfy(predicate, \"what must hold\").";
+/** @internal */
+type booleanRefusal = typeof booleanRefusal;
+/** @internal */
+declare const noCheckRefusal = "✗ this test yields no check, so it cannot fail. Yield one from the test's own expect: it(name, function* ({ expect }) { yield* expect(actual).toEqual(expected) }). An expect imported from vitest does not count.";
+/** @internal */
+type noCheckRefusal = typeof noCheckRefusal;
+/** @internal */
+type NoCheckRefusal = typeof noCheckRefusal;
+/** @internal */
+declare const unprovidedText = "✗ the test needs a service that nothing provides. Write the test inside layer(Service.layer)((it) => { it(name, ...) }); every test gets its own fresh build.";
+/** @internal */
+type unprovidedText = typeof unprovidedText;
+/** @internal */
+type UnprovidedRefusal = typeof unprovidedText;
+/** @internal */
+declare const refuseEffectBody = "✗ the body returned an Effect, so the runner cannot see its steps. Pass the generator itself: it(name, function* ({ expect }) { ... }).";
+/** @internal */
+type refuseEffectBody = typeof refuseEffectBody;
+/** @internal */
+type RefuseEffectBody = typeof refuseEffectBody;
+/** @internal */
+declare const refuseAsyncBody = "✗ an async body runs outside the test runtime. Pass a generator: it(name, function* ({ expect }) { yield* expect(actual).toEqual(expected) }).";
+/** @internal */
+type refuseAsyncBody = typeof refuseAsyncBody;
+/** @internal */
+type RefuseAsyncBody = typeof refuseAsyncBody;
+/** @internal */
+declare const refuseSyncBody = "✗ the body must be a generator that yields its checks: it(name, function* ({ expect }) { const x = yield* program; yield* expect(x).toEqual(expected) }).";
+/** @internal */
+type refuseSyncBody = typeof refuseSyncBody;
+/** @internal */
+type RefuseSyncBody = typeof refuseSyncBody;
+/** @internal */
+declare const refuseEffectLane = "✗ it.effect is removed: the body is the generator itself, so the runner sees every step. it(name, function* ({ expect }) { const x = yield* program; yield* expect(x).toEqual(expected) }).";
+/** @internal */
+type refuseEffectLane = typeof refuseEffectLane;
+/** @internal */
+type EffectLaneRefusal = typeof refuseEffectLane;
+/** @internal */
+declare const refuseScopedLane = "✗ it.scoped is removed: the body is the generator itself, so the runner sees every step. it(name, function* ({ expect }) { const x = yield* program; yield* expect(x).toEqual(expected) }).";
+/** @internal */
+type refuseScopedLane = typeof refuseScopedLane;
+/** @internal */
+type ScopedLaneRefusal = typeof refuseScopedLane;
+/** @internal */
+declare const refuseScopedLiveLane = "✗ it.scopedLive is removed: the body is the generator itself, so the runner sees every step. it(name, function* ({ expect }) { const x = yield* program; yield* expect(x).toEqual(expected) }).";
+/** @internal */
+type refuseScopedLiveLane = typeof refuseScopedLiveLane;
+/** @internal */
+type ScopedLiveLaneRefusal = typeof refuseScopedLiveLane;
+/** @internal */
+declare const refuseHook = "✗ hooks share state between tests. Build what a test needs inside it; services come fresh per test from layer(Service.layer)((it) => { ... }).";
+/** @internal */
+type refuseHook = typeof refuseHook;
+/** @internal */
+type HookRefusal = typeof refuseHook;
+//#endregion
+//#region src/internal/checks.d.ts
+/** An opaque runtime value: the fork does not read it, only hands it back. */
+type Opaque<A = unknown> = A;
+type Assertion<A> = V.Assertion<void, A>;
+/** @internal */
+type MakeAssertion = <A>(actual: A, message?: string) => Assertion<A>;
+/** @internal */
+type Judgement = (make: MakeAssertion) => void;
+/**
+ * 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.
+ *
+ * @internal
+ */
+interface AssertedShape {
+  readonly judge: (judgement: Judgement) => void;
+  readonly step: () => void;
+}
+declare const Asserted_base: Context.ServiceClass<Asserted, "@systemfsoftware/vitest/Asserted", AssertedShape>;
+/** @internal */
+declare class Asserted extends Asserted_base {}
+/**
+ * An Effect that performs one check. Only the runner can provide what it needs.
+ *
+ * @internal
+ */
+type Check = Effect.Effect<void, never, Asserted>;
+type Refusal<T extends string> = (this: T, ...args: ReadonlyArray<Opaque>) => Check;
+type StaticRefusal<T extends string> = (this: T, ...args: ReadonlyArray<Opaque>) => never;
+/** Callable only with the arguments that make it specific; the empty call's `this` type is the rewrite. */
+interface Needs<Args extends ReadonlyArray<Opaque>, T extends string> {
+  (...args: Args): Check;
+  (this: T, ...args: ReadonlyArray<Opaque>): Check;
+}
+type MatcherName = Extract<keyof Assertion<Opaque>, `to${string}`>;
+type ArgsOf<A, K extends MatcherName> = Assertion<A>[K] extends ((...args: infer P) => infer _) ? P : never;
+type Refused = Extract<keyof typeof refusedText, MatcherName>;
+type Needed = keyof typeof neededText;
+type NegatedRefused = Extract<keyof typeof negatedText, MatcherName>;
+/** The values `toThrow(X)` names the error with: a message, a pattern, an error class, or an error instance. */
+type ThrowExpected = string | RegExp | (abstract new (...args: ReadonlyArray<never>) => Opaque) | Error;
+/** @internal */
+type Positive<A> = { readonly [K in Exclude<MatcherName, Refused | Needed>]: (...args: ArgsOf<A, K>) => Check; } & { readonly [K in Refused]: Refusal<(typeof refusedText)[K]>; } & {
+  readonly toThrow: Needs<[expected: ThrowExpected], (typeof neededText)['toThrow']>;
+  readonly toThrowError: Needs<[expected: ThrowExpected], (typeof neededText)['toThrowError']>;
+  readonly toSatisfy: Needs<[predicate: (value: A) => boolean, holds: string], (typeof neededText)['toSatisfy']>;
+  readonly toMatchObject: Needs<ArgsOf<A, 'toMatchObject'>, (typeof neededText)['toMatchObject']>;
+  readonly resolves: (typeof refusedText)['resolves'];
+  readonly rejects: (typeof refusedText)['rejects'];
+};
+/** @internal */
+type Negative<A> = { readonly [K in Exclude<MatcherName, NegatedRefused>]: (...args: ArgsOf<A, K>) => Check; } & { readonly [K in NegatedRefused]: Refusal<(typeof negatedText)[K]>; };
+/** @internal */
+type Checked<A> = Positive<A> & {
+  readonly not: Negative<A>;
+};
+/** An asymmetric matcher: an opaque value vitest reads when the check runs. */
+type Matcher = object;
+/**
+ * The asymmetric matchers vitest builds: each names what a value must be, and only vitest reads the result.
+ *
+ * @internal
+ */
+interface Matchers {
+  readonly objectContaining: <T = Opaque>(expected: V.DeeplyAllowMatchers<T>) => Matcher;
+  readonly arrayContaining: <T = Opaque>(expected: Array<V.DeeplyAllowMatchers<T>>) => Matcher;
+  readonly stringContaining: (expected: string) => Matcher;
+  readonly stringMatching: (expected: string | RegExp) => Matcher;
+  readonly closeTo: (expected: number, precision?: number) => Matcher;
+  /** Accepts an Effect Schema directly, or any Standard Schema. */
+  readonly schemaMatching: (schema: Opaque) => Matcher;
+}
+/**
+ * `expect.not.<matcher>`: the four asymmetric matchers whose negation states an absence honestly.
+ *
+ * @internal
+ */
+type NegatedMatchers = Pick<Matchers, 'objectContaining' | 'arrayContaining' | 'stringContaining' | 'stringMatching'>;
+/**
+ * The asymmetric matchers that name what a value must be, the same matchers negated, and the statics the fork
+ * refuses by name.
+ *
+ * @internal
+ */
+interface Shapes extends Matchers {
+  readonly any: (constructor: Opaque) => Matcher;
+  /**
+   * `expect.not.<matcher>`, forwarded to vitest's own negated statics (`@vitest/expect/dist/index.d.ts:172`
+   * declares `not: AsymmetricMatchersContaining`); only the four honest absences are exposed.
+   */
+  readonly not: NegatedMatchers;
+  readonly anything: StaticRefusal<(typeof refusedText)['anything']>;
+  readonly poll: StaticRefusal<(typeof refusedText)['poll']>;
+  readonly soft: StaticRefusal<(typeof refusedText)['soft']>;
+}
+/** @internal */
+interface Expect extends Shapes {
+  <A>(actual: [A] extends [boolean] ? (typeof booleanRefusal) : A, message?: string): Checked<A>;
+}
+/**
+ * What a test body receives.
+ *
+ * @internal
+ */
+interface Checks {
+  readonly expect: Expect;
+}
+//#endregion
+export { summaryOf as S, FailureRecord as _, Expect as a, TestIdentity as b, NoCheckRefusal as c, RefuseSyncBody as d, ScopedLaneRefusal as f, Breach as g, AttributeValue as h, Checks as i, RefuseAsyncBody as l, UnprovidedRefusal as m, AssertedShape as n, EffectLaneRefusal as o, ScopedLiveLaneRefusal as p, Check as r, HookRefusal as s, Asserted as t, RefuseEffectBody as u, FailureRecordInput as v, renderFailureRecord as x, ReplayValue as y };

package/dist/engine-YsoQ_9we.d.ts

@@ -0,0 +1,158 @@
+
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Schema$1 from "effect/Schema";
+import { Schema } from "effect";
+import * as Arbitrary from "effect/unstable/arbitrary/Arbitrary";
+//#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, 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.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, 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.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, __exportAll as l, Gens as n, engine_d_exports as o, PropertySpec as r, LawApi as s, ArbitraryInput as t };