@systemfsoftware/vitest 1.0.0 → 4.1.1

package/dist/{test-context-D_-acRSc.mjs → test-context-DelFkLBL.mjs}

@@ -1,11 +1,12 @@
 
-import { a as booleanRefusal, b as refusedText, c as negatedText, m as refusePiecewise, s as neededText, t as authorize, u as refusalOf } from "./guard-BocOhXt2.mjs";
+import { a as booleanRefusal, b as refusedText, c as negatedText, m as refusePiecewise, s as neededText, t as authorize, u as refusalOf } from "./guard-Ci0TyBYv.mjs";
 import * as V from "vitest";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Schema from "effect/Schema";
 import * as Option from "effect/Option";
 import * as Context from "effect/Context";
+import * as Predicate from "effect/Predicate";
 //#region src/internal/call-site.ts
 /**
 * The one rule that reads a frame out of a stack: which frame a failure is raised from, and which frame an author
@@ -126,10 +127,12 @@ const branded = /* @__PURE__ */ new WeakSet();
 const isObject = (value) => typeof value === "object" && value !== null;
 /** @internal */
 const isCheck = (value) => isObject(value) && branded.has(value);
+const settled = (outcome) => Predicate.isPromiseLike(outcome) ? Effect.asVoid(Effect.promise(() => outcome)) : Effect.void;
 const makeCheck = (judgement, written) => {
 	written(judgement);
 	const check = Effect.gen(function* () {
-		(yield* Asserted).judge(judgement);
+		const asserted = yield* Asserted;
+		yield* settled(asserted.judge(judgement));
 	});
 	branded.add(check);
 	return check;
@@ -176,21 +179,22 @@ const memberAt = (target, property) => Reflect.get(target, property, target);
 const isCallable = (value) => typeof value === "function";
 const invokeMember = (target, property, args) => {
 	const member = memberAt(target, property);
-	if (isCallable(member)) Reflect.apply(member, target, args);
+	return isCallable(member) ? Reflect.apply(member, target, args) : void 0;
 };
 const judgedBy = (view, property, args, make) => {
 	const assertion = make(view.actual, view.message);
 	const target = view.negated ? assertion.not : assertion;
-	invokeMember(target, property, args);
+	return invokeMember(target, property, args);
 };
 const raisedFailure = (thrown, site) => thrown instanceof Error ? withRaisingFrame(thrown, site) : thrown;
+const framedOutcome = (outcome, site) => Predicate.isPromiseLike(outcome) ? outcome.then(void 0, (thrown) => Promise.reject(raisedFailure(thrown, site))) : outcome;
 /**
 * A failed judgement is a failure the fork raised: by now the stack holds only the fork's frames, so the site the
 * body called `expect` from is prepended to the error's stack (R2, KTD6).
 */
 const judgementOf = (view, property, args) => (make) => {
 	try {
-		judgedBy(view, property, args, make);
+		return framedOutcome(judgedBy(view, property, args, make), view.site);
 	} catch (thrown) {
 		throw raisedFailure(thrown, view.site);
 	}
@@ -294,7 +298,7 @@ const makeLedger = (ctx) => {
 				counter.judged += 1;
 				counter.since += 1;
 				if (counter.since > 1) throw refusalOf(refusePiecewise);
-				authorize(() => judgement(hard));
+				return authorize(() => judgement(hard));
 			},
 			step: () => {
 				counter.since = 0;

package/dist/tiers-W0BWq1uh.mjs

@@ -0,0 +1,36 @@
+
+//#region src/internal/property/tiers.ts
+const RUNS = {
+	mutation: 30,
+	ci: 1e3,
+	local: 100
+};
+const CI_OFF_VALUES = [
+	void 0,
+	"",
+	"false",
+	"0"
+];
+const isCi = (env) => env["AGENT"] === void 0 && !CI_OFF_VALUES.includes(env["CI"]);
+const isMutationWorker = (env) => env["STRYKER_MUTATOR_WORKER"] !== void 0;
+const ciOrLocal = (env) => isCi(env) ? "ci" : "local";
+/** @internal A Stryker worker wants fast mutant runs; CI wants the thorough tier; everything else is local. */
+const tierOf = (env) => isMutationWorker(env) ? "mutation" : ciOrLocal(env);
+/**
+* @internal The check options direct `Arbitrary` checks use by default: `{ check: { runs } }` for the tier. A property
+* test that passes its own `runs` still wins over this default.
+*/
+const propertyTestDefaults = (env) => ({ check: { runs: RUNS[tierOf(env)] } });
+/**
+* @internal The property budget a run uses when it provides none: the tier's runs, and no seed-store writes in CI or a
+* Stryker worker, where a checkout is discarded or a mutant run fails on purpose.
+*/
+const providedBudgetOf = (env) => {
+	const tier = tierOf(env);
+	return tier === "local" ? { runs: RUNS.local } : {
+		runs: RUNS[tier],
+		record: false
+	};
+};
+//#endregion
+export { providedBudgetOf as n, propertyTestDefaults as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/vitest",
   "license": "MIT",
-  "version": "1.0.0",
+  "version": "4.1.1",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -37,6 +37,10 @@
       "types": "./dist/integration.d.ts",
       "default": "./dist/integration.mjs"
     },
+    "./property-defaults": {
+      "types": "./dist/property-defaults.d.ts",
+      "default": "./dist/property-defaults.mjs"
+    },
     "./TestClock": {
       "types": "./dist/TestClock.d.ts",
       "default": "./dist/TestClock.mjs"
@@ -46,30 +50,26 @@
   "files": [
     "dist"
   ],
+  "dependencies": {
+    "@effect/platform-node": "^4.1.2"
+  },
   "devDependencies": {
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
-    "@systemfsoftware/oxlint-config-recommended": "^4.0.0",
-    "@systemfsoftware/stryker-config": "^0.1.0",
-    "@systemfsoftware/stryker-ignorer-effect-schema-declarations": "latest",
-    "@systemfsoftware/stryker-ignorer-in-source-vitest-block": "latest",
-    "@systemfsoftware/stryker-js": "latest",
-    "@systemfsoftware/stryker-js-typescript-checker": "latest",
-    "@systemfsoftware/stryker-js-vitest-runner": "latest",
-    "@systemfsoftware/stryker-test-contribution": "latest",
-    "@systemfsoftware/tsconfig": "^2.0.1",
-    "@systemfsoftware/tsdown-config": "^0.1.0",
-    "@systemfsoftware/vitest-config": "^0.1.0",
-    "@types/node": "^26",
-    "effect": "^4",
-    "oxlint": "~1.82.0",
+    "@systemfsoftware/oxlint-config-recommended": "^6.0.1",
+    "@systemfsoftware/tsconfig": "^2.1.0",
+    "@systemfsoftware/tsdown-config": "^0.1.2",
+    "@systemfsoftware/vitest-config": "^0.1.3",
+    "@types/node": "^26.6.5",
+    "effect": "^4.1.2",
+    "oxlint": "~1.89.0",
     "rimraf": "^6.1.3",
     "tsdown": "^0.23.0",
     "tstyche": "^7.2.5",
-    "vitest": "^5"
+    "vitest": "^5.1.0"
   },
   "peerDependencies": {
-    "effect": "^4",
-    "vitest": "^5"
+    "effect": "^4.1.2",
+    "vitest": "^5.1.0"
   },
   "publishConfig": {
     "access": "public",
@@ -80,7 +80,6 @@
     "build": "tsdown -l warn",
     "typecheck": "tsc -b",
     "test": "vitest run",
-    "mutation": "stryker run",
     "test:types": "TSTYCHE_TYPESCRIPT_MODULE=tstyche-typescript tstyche",
     "lint": "f=${OXLINT_FORMAT:-${AGENT:+agent}}; oxlint . --format=${f:-default}",
     "attw": "attw --pack ."

package/dist/engine-CMvYG5V0.d.ts

@@ -1,166 +0,0 @@
-
-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/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 };