@systemfsoftware/vitest 0.1.0 → 0.3.0

package/dist/failure.d.ts

@@ -0,0 +1,204 @@
+
+import { a as Values, i as PropertySubject, l as Breach, n as Gens, o as engine_d_exports, r as PropertySpec } from "./engine-ZbxyPNiN.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";
+//#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-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.
+ *
+ * @internal
+ */
+declare const WorkspaceRoot: Schema.brand<Schema.NonEmptyString, "WorkspaceRoot">;
+/** @internal */
+type WorkspaceRoot = typeof WorkspaceRoot.Type;
+//#endregion
+//#region src/internal/provided.d.ts
+/** @internal */
+declare const providedRoot: () => WorkspaceRoot | undefined;
+//#endregion
+//#region src/internal/recorded-run.d.ts
+/** @internal */
+interface RecordedRun<A, E> {
+  (checks: Checks): Effect$1.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
+//#region src/replay.schema.d.ts
+/** The replay a generator chose: its seed and the decisions it took, in order (R6). */
+export declare const Replay: Schema.Struct<{
+  readonly seed: Schema.brand<Schema.Int, "ReplaySeed">;
+  readonly path: Schema.$Array<Schema.brand<Schema.Int, "ReplayStep">>;
+}>;
+/** @since 4.0.0 */
+export type Replay = typeof Replay.Type;
+/**
+ * The `CONFORMANCE_REPLAY` text as the replay it names. A text a seed and a path cannot be read out of is refused
+ * with the same prose the spec runtime has always thrown, so the grammar and its refusal share one home.
+ *
+ * @since 4.0.0
+ */
+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.
+ *
+ * @since 4.0.0
+ */
+export declare const ReplayFromText: Schema.decodeTo<Schema.Struct<{
+  readonly seed: Schema.brand<Schema.Int, "ReplaySeed">;
+  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 };

package/dist/failure.mjs

@@ -0,0 +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-DC_SJoxW.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 };

package/dist/index.d.ts

@@ -1,176 +1,23 @@
 /// <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-ZbxyPNiN.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";
-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;
   }
 }
 /**