@systemfsoftware/vitest 0.2.0 → 1.0.0

package/CHANGELOG.md

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

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

@@ -1,111 +1,7 @@
 
 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: {
@@ -333,4 +229,4 @@ 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 };
+export { Expect as a, NoCheckRefusal as c, RefuseSyncBody as d, ScopedLaneRefusal as f, 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 };

package/dist/{engine-YsoQ_9we.d.ts → engine-CMvYG5V0.d.ts}

@@ -1,11 +1,19 @@
 
 import * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
+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";
+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).
+ *
+ * @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>;
@@ -139,13 +147,13 @@ interface PropertySpec<G extends Gens, S extends PropertySubject, N extends numb
 /** @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>;
+  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.Effect<boolean, E, R>) => 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;
 }
 /**
@@ -155,4 +163,4 @@ interface PropApi<R> {
  */
 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 };
+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 };