@systemfsoftware/vitest 0.1.0 → 0.2.0

package/dist/failure.d.ts

@@ -0,0 +1,80 @@
+
+import { a as Values, i as PropertySubject, n as Gens, o as engine_d_exports, r as PropertySpec } from "./engine-YsoQ_9we.js";
+import { S as summaryOf, _ as FailureRecord, b as TestIdentity, g as Breach, h as AttributeValue, i as Checks, t as Asserted, v as FailureRecordInput, x as renderFailureRecord, y as ReplayValue } from "./checks-Cq9of-Lx.js";
+import * as Effect from "effect/Effect";
+import * as Tracer from "effect/Tracer";
+//#region src/internal/call-site.d.ts
+/** @internal */
+export declare const callFrameOutside: (library: RegExp) => string | undefined;
+/** @internal */
+export declare const callSite: () => string | undefined;
+/** @internal */
+export declare const withRaisingFrame: {
+  <A extends Error>(error: A, frame: string | undefined): A;
+  (frame: string | undefined): <A extends Error>(error: A) => A;
+};
+//#endregion
+//#region src/internal/failure-error.d.ts
+/**
+ * Renders the record and throws what Vitest prints for it: the record itself when it holds its contract, a
+ * `FailureRecordRefused` when it breaks one, and a refusal passed in unchanged, so refusing cannot recurse (R10).
+ *
+ * @internal
+ */
+export declare const throwFailureRecord: <E>(input: FailureRecordInput<E>) => never;
+//#endregion
+//#region src/internal/failure-identity.d.ts
+/** The fields this reads off a Vitest task: every one optional, so a partial context yields an incomplete identity. */
+interface TaskLike {
+  readonly name?: string | undefined;
+  readonly fullName?: string | undefined;
+  readonly fullTestName?: string | undefined;
+}
+/**
+ * The identity of the test being run, or of the task handed in. A run outside a test, or one whose task carries
+ * no file, yields an incomplete identity, which the renderer reports as the R6 breach it is.
+ *
+ * @internal
+ */
+export declare const testIdentityOf: (task?: TaskLike | null) => TestIdentity;
+//#endregion
+//#region src/internal/provided.d.ts
+/** @internal */
+declare const providedRoot: () => string | undefined;
+//#endregion
+//#region src/internal/recorded-run.d.ts
+/** @internal */
+interface RecordedRun<A, E> {
+  (checks: Checks): Effect.Effect<A, E, Asserted>;
+}
+/** @internal */
+interface RecordedProperty<G extends Gens, S extends PropertySubject, N extends number> {
+  readonly name: string;
+  readonly spec: PropertySpec<G, S, N>;
+  readonly holds: (subject: S, values: Values<G>) => boolean;
+}
+/**
+ * Runs one program as the runner runs a lane, with a fresh ledger and its own recorder, and resolves with the
+ * record its failure rendered — or `undefined` when it passed.
+ *
+ * @internal
+ */
+export declare const recordOfRun: <A, E>(program: RecordedRun<A, E>) => Promise<FailureRecord | 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.
+ *
+ * @internal
+ */
+export declare const recordOfProperty: <const G extends Gens, S extends PropertySubject, N extends number>(input: RecordedProperty<G, S, N>) => Promise<FailureRecord | undefined>;
+//#endregion
+//#region src/internal/span-recorder.d.ts
+/** @internal */
+interface SpanRecorder {
+  readonly tracer: Tracer.Tracer;
+  readonly spans: ReadonlyArray<Tracer.NativeSpan>;
+}
+/** @internal */
+export declare const createSpanRecorder: () => SpanRecorder;
+//#endregion
+export { type AttributeValue, type Breach, type FailureRecord, type FailureRecordInput, type RecordedProperty, type RecordedRun, type ReplayValue, type SpanRecorder, type TestIdentity, providedRoot as providedWorkspaceRoot, renderFailureRecord, summaryOf };

package/dist/failure.mjs

@@ -0,0 +1,4 @@
+
+import { d as summaryOf, l as throwFailureRecord, n as recordOfRun, o as testIdentityOf, r as createSpanRecorder, s as providedRoot, t as recordOfProperty, u as renderFailureRecord } from "./failure-BquJJPFZ.mjs";
+import { c as callFrameOutside, l as callSite, p as withRaisingFrame } from "./test-context-ChvjVyCo.mjs";
+export { callFrameOutside, callSite, createSpanRecorder, providedRoot as providedWorkspaceRoot, recordOfProperty, recordOfRun, renderFailureRecord, summaryOf, testIdentityOf, throwFailureRecord, withRaisingFrame };

package/dist/{guard-BocOhXt2.mjs → guard-p_8ARgPm.mjs}

@@ -2,16 +2,6 @@
 import { chai } from "vitest";
 //#region src/internal/refusals.ts
 /**
-* Every refusal the fork prints, as the one text it uses on both channels: the `this` type (or parameter union)
-* the compiler prints at the call site, and the message thrown at run time.
-*
-* Surface: `it(name, function* ({ expect }) { ... })`. Ported verbatim from the prototype's `checks.ts`; the
-* prototype's `test(` surfaces are rewritten to `it(`, and `refusedText` gained the `expect` statics
-* (`.resolves`, `.rejects`, `expect.anything`, `expect.poll`, `expect.soft`).
-*
-* @since 4.0.0
-*/
-/**
 * The brand every run-time refusal carries. A test is run a second time on a fresh build to catch leaked state,
 * so when that second run fails with a refusal the fork itself made, the runner re-throws the refusal rather than
 * relabelling it as a leak (see `throwSecondRun` in `runner.ts`). The brand is a `Symbol.for` value because a
@@ -91,6 +81,20 @@ const refuseHook = "✗ hooks share state between tests. Build what a test needs
 const refuseRawExpect = "✗ an expect imported from vitest ran; take it from the test callback: it(name, function* ({ expect }) { ... })";
 /** @internal */
 const refuseRawIt = "✗ this test was registered with vitest's it; import it from @systemfsoftware/vitest";
+/**
+* The fixed prose each breach of the record contract is refused with (R10, KTD7). A refusal carries this text and
+* nothing from the record itself, and nothing ever reads it back, so a refusal cannot recurse. The breach letter is
+* not printed: a reader acts on what is missing, not on which requirement numbered it.
+*/
+/** @internal */
+const refusedRecordText = {
+	R1: "the headline is empty",
+	R2: "the record names no source location",
+	R6: "a replay value names a run no generator chose, or the rerun line is missing"
+};
+/** The one detail a record refusal carries: every breach the renderer found, in the prose above (R10). */
+/** @internal */
+const refusedRecordDetail = (breaches) => `✗ refused a failure record: ${breaches.map((breach) => refusedRecordText[breach]).join(", and ")}`;
 //#endregion
 //#region src/internal/guard.ts
 /**
@@ -243,4 +247,4 @@ const installGuard = () => {
 	patchExtend();
 };
 //#endregion
-export { refuseScopedLiveLane as _, booleanRefusal as a, refusedText as b, negatedText as c, refuseAsyncBody as d, refuseEffectLane as f, refuseScopedLane as g, refuseRawIt as h, markTask as i, noCheckRefusal as l, refusePiecewise as m, installGuard as n, isRefusal as o, refuseHook as p, isMarked as r, neededText as s, authorize as t, refusalOf as u, refuseSyncBody as v, unprovidedText as x, refuseUnyielded as y };
+export { unprovidedText as S, refuseScopedLiveLane as _, booleanRefusal as a, refusedRecordDetail as b, negatedText as c, refuseAsyncBody as d, refuseEffectLane as f, refuseScopedLane as g, refuseRawIt as h, markTask as i, noCheckRefusal as l, refusePiecewise as m, installGuard as n, isRefusal as o, refuseHook as p, isMarked as r, neededText as s, authorize as t, refusalOf as u, refuseSyncBody as v, refusedText as x, refuseUnyielded as y };

package/dist/guard.mjs

@@ -1,5 +1,5 @@
 
-import { h as refuseRawIt, n as installGuard, r as isMarked, u as refusalOf } from "./guard-BocOhXt2.mjs";
+import { h as refuseRawIt, n as installGuard, r as isMarked, u as refusalOf } from "./guard-p_8ARgPm.mjs";
 import { beforeEach } from "vitest";
 //#region src/guard.ts
 /**

package/dist/index.d.ts

@@ -1,176 +1,23 @@
 /// <reference types="./compat.d.ts" />
-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 { a as Values$1, c as kinds_d_exports, i as PropertySubject$1, l as __exportAll, n as Gens$1, o as engine_d_exports, r as PropertySpec$1, s as LawApi, t as ArbitraryInput } from "./engine-YsoQ_9we.js";
+import { a as Expect, c as NoCheckRefusal, d as RefuseSyncBody, f as ScopedLaneRefusal, i as Checks, l as RefuseAsyncBody, m as UnprovidedRefusal, o as EffectLaneRefusal, p as ScopedLiveLaneRefusal, r as Check, s as HookRefusal, t as Asserted, u as RefuseEffectBody } from "./checks-Cq9of-Lx.js";
 import * as V from "vitest";
 import { afterAll, assertType, beforeAll, expectTypeOf, inject, onTestFailed, onTestFinished, recordArtifact, vi, vitest } from "vitest";
-import * as Cause from "effect/Cause";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Schema$1 from "effect/Schema";
 import * as Scope from "effect/Scope";
 import * as TestConsole from "effect/testing/TestConsole";
 import * as Context from "effect/Context";
-import { Schema } from "effect";
 import * as Arbitrary from "effect/unstable/arbitrary/Arbitrary";
 import * as Clock from "effect/Clock";
 import * as Scheduler from "effect/Scheduler";
-//#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 {
@@ -290,6 +137,8 @@ declare namespace mod_d_exports {
 declare module 'vitest' {
   interface ProvidedContext {
     [checkDefaultsKey]?: ProvidedCheckDefaults;
+    '@systemfsoftware/vitest:package'?: string;
+    '@systemfsoftware/vitest:workspace-root'?: string;
   }
 }
 /**