@systemfsoftware/vitest 0.1.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @systemfsoftware/vitest
 
+## 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

package/dist/engine-ZbxyPNiN.d.ts

@@ -0,0 +1,166 @@
+
+import * as Cause from "effect/Cause";
+import * as Effect$1 from "effect/Effect";
+import * as Schema$1 from "effect/Schema";
+import { Schema } from "effect";
+import * as Arbitrary from "effect/unstable/arbitrary/Arbitrary";
+//#endregion
+//#region src/internal/errors.schema.d.ts
+/**
+ * The contract rules a rendered failure record can break (R10, KTD7).
+ *
+ * @internal
+ */
+declare const Breach: Schema.Literals<readonly ["R1", "R2", "R6"]>;
+/** @internal */
+type Breach = typeof Breach.Type;
+declare const NonBooleanVerdict_base: Schema.Class<NonBooleanVerdict, Schema.TaggedStruct<"NonBooleanVerdict", {
+  readonly detail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** @internal */
+declare class NonBooleanVerdict extends NonBooleanVerdict_base {
+  get message(): string;
+}
+//#endregion
+//#region src/internal/property/impostor.d.ts
+/**
+ * @internal The constant impostor of R12: a fake of the subject under test that
+ * returns the first output it ever produced, for every later call, whatever the
+ * input it was given.
+ *
+ * A property that still holds for the impostor does not constrain the subject.
+ * Whether that is fatal is a per-file question — a subject's impostor must be
+ * refuted by some property in its file — so this module builds the fake and
+ * collects the verdicts; the engine decides them once, when the file finishes
+ * (KTD10).
+ */
+/**
+ * A value the fork hands over without inspecting: an argument to the subject, or one of its outputs.
+ *
+ * @internal
+ */
+type Opaque<A = unknown> = A;
+/**
+ * A function under test: any argument, any output.
+ *
+ * @internal
+ */
+type SubjectFunction = (...values: ReadonlyArray<never>) => Opaque;
+/**
+ * A record of functions under test; every member is replaced by a constant.
+ *
+ * @internal
+ */
+type MemberRecord = {
+  readonly [key: string]: SubjectFunction;
+};
+/**
+ * The function under test, or a record of them.
+ *
+ * @internal
+ */
+type Subject = SubjectFunction | MemberRecord;
+declare namespace kinds_d_exports {
+  export { LawApi, LawKind, LawSubject, MetamorphicRelation, deterministicHolds, idempotentHolds, invariantHolds, metamorphicHolds, modelHolds, roundTripHolds, spreadValues };
+}
+/** @internal */
+type LawKind = 'model' | 'metamorphic' | 'roundTrip' | 'invariant' | 'idempotent' | 'deterministic';
+/**
+ * A subject of a law kind: a function of the generated values.
+ *
+ * @internal
+ */
+type LawSubject<G extends Gens, A> = (...values: ReadonlyArray<ElementValues<G>>) => A;
+/**
+ * A metamorphic relation: the input transform, and how the two outputs relate (structural equality by default).
+ *
+ * @internal
+ */
+interface MetamorphicRelation<G extends Gens, A> {
+  readonly transform: (...values: ReadonlyArray<ElementValues<G>>) => Values<G>;
+  readonly relate?: (original: A, transformed: A) => boolean;
+}
+/**
+ * The R13 law surface: four gated kinds and two declared exemptions.
+ *
+ * @internal
+ */
+interface LawApi {
+  readonly model: <const G extends Gens, A, N extends number, S extends LawSubject<G, A>>(name: string, spec: PropertySpec<G, S, N>, oracle: LawSubject<G, A>) => void;
+  readonly metamorphic: <const G extends Gens, A, N extends number, S extends LawSubject<G, A>>(name: string, spec: PropertySpec<G, S, N>, relation: MetamorphicRelation<G, A>) => void;
+  readonly roundTrip: <const G extends Gens, E, N extends number, S extends LawSubject<G, E>>(name: string, spec: PropertySpec<G, S, N>, decode: (encoded: E) => Values<G>) => void;
+  readonly invariant: <const G extends Gens, A, N extends number, S extends LawSubject<G, A>>(name: string, spec: PropertySpec<G, S, N>, holds: (output: A, ...values: ReadonlyArray<ElementValues<G>>) => boolean) => void;
+  readonly idempotent: <const G extends Gens, N extends number, S extends (value: ElementValues<G>) => ElementValues<G>>(name: string, spec: PropertySpec<G, S, N>) => void;
+  readonly deterministic: <const G extends Gens, A, N extends number, S extends LawSubject<G, A>>(name: string, spec: PropertySpec<G, S, N>) => void;
+}
+/**
+ * The generated values as the argument list a law subject is called with.
+ *
+ * @internal
+ */
+declare const spreadValues: <G extends Gens>(values: Values<G>) => ReadonlyArray<ElementValues<G>>;
+/** @internal */
+declare const modelHolds: <G extends Gens, A>(oracle: LawSubject<G, A>) => (subject: LawSubject<G, A>, values: Values<G>) => boolean;
+/** @internal */
+declare const metamorphicHolds: <G extends Gens, A>(relation: MetamorphicRelation<G, A>) => (subject: LawSubject<G, A>, values: Values<G>) => boolean;
+/** @internal */
+declare const roundTripHolds: <G extends Gens, E>(decode: (encoded: E) => Values<G>) => (subject: LawSubject<G, E>, values: Values<G>) => boolean;
+/** @internal */
+declare const invariantHolds: <G extends Gens, A>(holds: (output: A, ...values: ReadonlyArray<ElementValues<G>>) => boolean) => (subject: LawSubject<G, A>, values: Values<G>) => boolean;
+/** @internal */
+declare const idempotentHolds: <G extends Gens>() => (subject: (value: ElementValues<G>) => ElementValues<G>, values: Values<G>) => boolean;
+/** @internal */
+declare const deterministicHolds: <G extends Gens, A>() => (subject: LawSubject<G, A>, values: Values<G>) => boolean;
+declare namespace engine_d_exports {
+  export { ArbitraryInput, CoveragePredicate, ElementValues, Gens, PropApi, PropertyRuntime, PropertySpec, PropertySubject, Values, makeProperty };
+}
+/** @internal */
+type ArbitraryInput = Schema$1.Top | Arbitrary.Arbitrary<Schema$1.Top['Type']>;
+/** @internal */
+type Gens = ReadonlyArray<ArbitraryInput> | {
+  readonly [key: string]: ArbitraryInput;
+};
+type Generated<I> = I extends Schema$1.Schema<infer T> ? T : I extends Arbitrary.Arbitrary<infer A> ? A : never;
+/** @internal */
+type Values<G extends Gens> = { readonly [K in keyof G]: Generated<G[K]>; };
+/** @internal */
+type ElementValues<G extends Gens> = G extends ReadonlyArray<ArbitraryInput> ? Generated<G[number]> : never;
+/** @internal */
+type PropertySubject = Subject;
+/** @internal */
+type CoveragePredicate<G extends Gens> = (...values: ReadonlyArray<ElementValues<G>>) => boolean;
+type PropertyRuns<N extends number> = number extends N ? number : `${N}` extends `-${bigint}` ? never : `${N}` extends `${bigint}` ? (N extends 0 ? never : N) : never;
+/** @internal */
+interface PropertySpec<G extends Gens, S extends PropertySubject, N extends number> {
+  readonly of: G;
+  readonly subject: S;
+  /**
+   * The property's own run count. Omitted, the configured default applies; when the run provides none,
+   * the built-in default of 100 does.
+   */
+  readonly runs?: N & PropertyRuns<N>;
+  /** Labelled input predicates, each with the minimum share of runs it must see (R14). */
+  readonly cover?: Readonly<Record<string, readonly [CoveragePredicate<G>, number]>>;
+  /** The property's own check options, merged field by field over the provided and built-in defaults. */
+  readonly arbitrary?: Arbitrary.CheckOptions;
+}
+/** @internal */
+interface PropertyRuntime<R> {
+  /** Registers the property's program; the runtime runs it inside the test it registers, under that test's binding. */
+  readonly register: (name: string, program: () => Effect$1.Effect<void, Cause.Cause<NonBooleanVerdict>, never>) => void;
+  readonly provide: <A, E>(effect: Effect$1.Effect<A, E, R>) => Effect$1.Effect<A, E, never>;
+}
+/** @internal */
+interface PropApi<R> {
+  readonly prop: <const G extends Gens, S extends PropertySubject, N extends number>(name: string, spec: PropertySpec<G, S, N>, holds: (subject: S, values: Values<G>) => boolean) => void;
+  readonly effectProp: <const G extends Gens, S extends PropertySubject, N extends number, E>(name: string, spec: PropertySpec<G, S, N>, holds: (subject: S, values: Values<G>) => Effect$1.Effect<boolean, E, R>) => void;
+  readonly law: LawApi;
+}
+/**
+ * The property surface over one runtime: `prop`, `effectProp`, and the R13 law kinds routed through the gate.
+ *
+ * @internal
+ */
+declare const makeProperty: <R>(runtime: PropertyRuntime<R>) => PropApi<R>;
+//#endregion
+export { Values as a, kinds_d_exports as c, PropertySubject as i, Breach as l, Gens as n, engine_d_exports as o, PropertySpec as r, LawApi as s, ArbitraryInput as t, __exportAll as u };