@systemfsoftware/oxlint-plugin-test-discipline 3.9.0 → 4.0.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @systemfsoftware/oxlint-plugin-test-discipline
 
+## 4.0.1
+
+### Patch Changes
+
+- `in-source-test-targets-private`'s message now names an exported operation in the `it.prop` `subject` slot as a legal target for an in-source block, beside a private helper.
+
+## 4.0.0
+
+### Minor Changes
+
+- Contract suites are now a recognised kind of behaviour test. A test file with the `contract` suffix may live beside integration suites, and the rules hold it to the same obligations: exactly one Gherkin feature, no bare test runner, and an import of the package it proves.
+
 ## 3.9.0
 
 ### Minor Changes

package/README.md

@@ -4,21 +4,22 @@ Oxlint rules enforcing property-based test laws, test placement, and test naming
 
 ## Rules
 
-| Rule                                 | What it enforces                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| ------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `no-test-file-in-src`                | Under `src/`, the only sanctioned test file is a single-segment `<stem>.workflow.property.test.ts` inside a sanctioned test directory, plus the generated `schema-laws.test.ts` entry point. Every other test file is banned: a kernel, policy, or schema suite becomes an in-source `import.meta.vitest` block, and a public-surface test moves outside `src/` as an integration test.                                                      |
-| `src-property-test-cell`             | A property test under `src/` must be a single-segment `<stem>.workflow.property.test.ts` beside the `<stem>.workflow.ts` it covers. A source file whose suffix names a cell listed in `cellsRequiringTest` must also carry an in-source vitest block; that list is empty by default.                                                                                                                                                         |
-| `test-file-outside-tests-dir`        | A test file outside `src/` must live under `tests/`.                                                                                                                                                                                                                                                                                                                                                                                         |
-| `test-suffix-outside-src`            | Outside `src/`, a test file must end `.integration.test.ts`, `.differential.test.ts`, or `.trace.test.ts` — the three behaviour suffixes.                                                                                                                                                                                                                                                                                                    |
-| `tests-dir-helpers-in-fixtures`      | Under `tests/`, the only non-test modules are helpers and fixtures, and they live inside `tests/__fixtures__/`.                                                                                                                                                                                                                                                                                                                              |
-| `no-io-module-in-source-test`        | An in-source `import.meta.vitest` test block is forbidden in a module that performs I/O — decided from the module's own syntax (a non-type import from a filesystem, process or network module, called at least once), never from its filename. Only the in-source-test idiom is judged: a module whose tests live in separate files is a no-op for this rule.                                                                               |
-| `behaviour-test-requires-gherkin`    | A `.integration.test.ts` must import `makeFeature` from `@systemfsoftware/effect-gherkin-spec` and must not import test runners directly from `vitest` or `@effect/vitest`.                                                                                                                                                                                                                                                                  |
-| `behaviour-exercises-use-case`       | A `.integration.test.ts` must reach at least one shell entry — an executor/handler/adapter/store, the package `main`/`mod`/`index`, or a non-foundation package — so it drives a use case.                                                                                                                                                                                                                                                   |
-| `behaviour-one-feature-per-file`     | A `.integration.test.ts` must contain exactly one `Feature(...)` call; zero or two-or-more is the junk-drawer signal.                                                                                                                                                                                                                                                                                                                        |
-| `differential-test-requires-harness` | A `.differential.test.ts` must import `@systemfsoftware/differential-spec` and invoke its harness; direct `vitest`/`@effect/vitest` imports and raw runner calls (`it`, `test`, `describe`, `it.effect`, and aliases) are forbidden, and importing the harness without invoking it is equally non-compliant.                                                                                                                                 |
-| `tests-import-public-api`            | Every file under the package-root `tests/` or `__tests__/` trees, regardless of basename, may not relative-import `src` or climb into an `internal` folder. Import the published package name or a sibling helper.                                                                                                                                                                                                                           |
-| `expect-boolean-predicate`           | An `expect(...)` asserted with `toBe(true)`, `toBe(false)`, `toEqual(true)` or `toEqual(false)` must wrap a boolean the code under test returned. A predicate call, comparison, negation or `&&` / `\|\|` evaluated in the test is refused, with the `toSatisfy` or `toEqual` rewrite as the fix.                                                                                                                                            |
-| `vitest-from-effect-vitest`          | Every value a test uses from Vitest is imported from `@effect/vitest`, which re-exports all of Vitest. Any value import from `vitest` — named, namespace, default, side-effect or dynamic — is refused; a type-only import stays legal. Exempt: the packages that drive Vitest's own runner instead of the fork (`vitest` itself, `vitest-conformance`, and `effect-spec-runtime`, whose `Register` calls Vitest's option-taking collector). |
+| Rule                                 | What it enforces                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `no-test-file-in-src`                | Under `src/`, the only sanctioned test file is a single-segment `<stem>.workflow.property.test.ts` inside a sanctioned test directory, plus the generated `schema-laws.test.ts` entry point. Every other test file is banned: a kernel, policy, or schema suite becomes an in-source `import.meta.vitest` block, and a public-surface test moves outside `src/` as an integration test.                                                                                                                                                                                                  |
+| `src-property-test-cell`             | A property test under `src/` must be a single-segment `<stem>.workflow.property.test.ts` beside the `<stem>.workflow.ts` it covers. A source file whose suffix names a cell listed in `cellsRequiringTest` must also carry an in-source vitest block; that list is empty by default.                                                                                                                                                                                                                                                                                                     |
+| `test-file-outside-tests-dir`        | A test file outside `src/` must live under `tests/`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `test-suffix-outside-src`            | Outside `src/`, a test file must end `.integration.test.ts`, `.differential.test.ts`, `.trace.test.ts`, or `.conformance.test.ts` — the four sanctioned lane suffixes. A runner-driving package (`vitest`, `vitest-conformance`, `effect-spec-runtime`) is exempt: its plain `*.test.ts` runners and nested-run probes are not consumer lanes.                                                                                                                                                                                                                                           |
+| `tests-dir-helpers-in-fixtures`      | Under `tests/`, the only non-test modules are helpers and fixtures, and they live inside `tests/__fixtures__/`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `no-io-module-in-source-test`        | An in-source `import.meta.vitest` test block is forbidden in a module that performs I/O — decided from the module's own syntax (a non-type import from a filesystem, process or network module, called at least once), never from its filename. Only the in-source-test idiom is judged: a module whose tests live in separate files is a no-op for this rule.                                                                                                                                                                                                                           |
+| `behaviour-test-requires-gherkin`    | A `.integration.test.ts` must import `makeFeature` from `@systemfsoftware/effect-gherkin-spec` and must not import test runners directly from `vitest`, `@effect/vitest` or `@systemfsoftware/vitest`.                                                                                                                                                                                                                                                                                                                                                                                   |
+| `behaviour-exercises-use-case`       | A `.integration.test.ts` must reach at least one shell entry — an executor/handler/adapter/store, the package `main`/`mod`/`index`, or a non-foundation package — so it drives a use case.                                                                                                                                                                                                                                                                                                                                                                                               |
+| `behaviour-one-feature-per-file`     | A `.integration.test.ts` must contain exactly one `Feature(...)` call; zero or two-or-more is the junk-drawer signal.                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `differential-test-requires-harness` | A `.differential.test.ts` must import `@systemfsoftware/differential-spec` and invoke its harness; direct `vitest`/`@effect/vitest`/`@systemfsoftware/vitest` imports and raw runner calls (`it`, `test`, `describe`, `it.effect`, and aliases) are forbidden, and importing the harness without invoking it is equally non-compliant. The harness is expressed as `Differential.compare({ name, reference, candidate })` or `Metamorphic.on({ name, system })`.                                                                                                                         |
+| `conformance-test-requires-harness`  | A `.conformance.test.ts` must import `Conformance` from `@systemfsoftware/conformance-spec` and invoke one of its checks — `Conformance.linearizable`, `Conformance.sequential`, or `Conformance.released`; direct `vitest`/`@effect/vitest`/`@systemfsoftware/vitest` imports, raw runner calls (`it`, `test`, `describe`, `it.effect`, and aliases), and the retired `Linearizable.check` / `SequentialModel.check` / `Released.check` shapes are forbidden, and importing the barrel without invoking a check is equally non-compliant.                                               |
+| `model-fixture-imports-subject`      | A `*.model.ts` fixture may not import the package whose tests it serves. The package is read from the fixture's path — the directory its tests tree lives in — and an import, re-export, dynamic import, or require of that name, or of any subpath of it, is the implementation reaching its own oracle. A relative specifier is judged the same way lexically: resolved against the fixture's directory it must stay inside the tests tree, so `../../src/Lock.js` is reported and `./Locks.js` is a sibling fixture. `effect`, node builtins, and other packages' names stay allowed. |
+| `vitest-from-systemfsoftware-vitest` | Every value a test uses from Vitest is imported from `@systemfsoftware/vitest`, which re-exports all of Vitest. Any value import from `vitest` or the upstream `@effect/vitest` — named, namespace, default, side-effect or dynamic — is refused; a type-only import stays legal. Exempt: the packages that drive Vitest's own runner instead of the fork (`vitest` itself, `vitest-conformance`, and `effect-spec-runtime`, whose `Register` calls Vitest's option-taking collector).                                                                                                   |
+| `tests-import-public-api`            | Every file under the package-root `tests/` or `__tests__/` trees, regardless of basename, may not relative-import `src` or climb into an `internal` folder. Import the published package name or a sibling helper.                                                                                                                                                                                                                                                                                                                                                                       |
 
 | suffix                        | layer        | doubles                  | location           |
 | ----------------------------- | ------------ | ------------------------ | ------------------ |
@@ -26,10 +27,11 @@ Oxlint rules enforcing property-based test laws, test placement, and test naming
 | `*.integration.test.ts`       | Behaviour    | permitted, at ports only | NEVER under `src/` |
 | `*.differential.test.ts`      | Differential | permitted, at ports only | NEVER under `src/` |
 | `*.trace.test.ts`             | Trace spec   | none — observes graphs   | NEVER under `src/` |
+| `*.conformance.test.ts`       | Conformance  | permitted, at ports only | NEVER under `src/` |
 
 ## Enrollment
 
-`@systemfsoftware/oxlint-config-recommended` loads this plugin in `jsPlugins` and turns on `expect-boolean-predicate` and `vitest-from-effect-vitest` at `error` in its default config. The rest of `configs.recommended` is exported from that preset as `rules`, but the default config does not enable it, so those rules fire only in a package that spreads it into its own `rules`.
+`@systemfsoftware/oxlint-config-recommended` loads this plugin in `jsPlugins` and spreads `configs.recommended` into its default `rules` at `error`, so every rule above fires in every package that extends the preset.
 
 ## Testing
 

package/dist/index.d.ts

@@ -25,11 +25,12 @@ declare const _default: {
     'behaviour-one-feature-per-file': import("@oxlint/plugins").Rule;
     'no-pseudo-gherkin-unit-tests': import("@oxlint/plugins").Rule;
     'tests-dir-helpers-in-fixtures': import("@oxlint/plugins").Rule;
-    'expect-boolean-predicate': import("@oxlint/plugins").Rule;
-    'vitest-from-effect-vitest': import("@oxlint/plugins").Rule;
+    'vitest-from-systemfsoftware-vitest': import("@oxlint/plugins").Rule;
     'no-io-module-in-source-test': import("@oxlint/plugins").Rule;
     'tests-import-public-api': import("@oxlint/plugins").Rule;
     'differential-test-requires-harness': import("@oxlint/plugins").Rule;
+    'conformance-test-requires-harness': import("@oxlint/plugins").Rule;
+    'model-fixture-imports-subject': import("@oxlint/plugins").Rule;
     'ban-raw-span-name-emit': import("@oxlint/plugins").Rule;
     'trace-test-requires-taxonomy': import("@oxlint/plugins").Rule;
   };

package/dist/index.mjs

@@ -8,7 +8,7 @@ const EMIT_CALLEES = [
 ];
 const EXPECTED$3 = "a span declared once with Span.declare({ id, name, attrs }) and started through the start(attrs) it returns";
 const FIX$3 = "declare the span with Span.declare({ id, name, attrs }) and emit it with SomeSpan.start(attrs)";
-const meta$27 = {
+const meta$28 = {
 	type: "problem",
 	docs: { description: "Ban a raw span name passed to an emit API (startSpan, spanBuilder, startActiveSpan). Span names enter through Span.declare, never as a literal at the emit site." },
 	schema: [],
@@ -18,14 +18,14 @@ const meta$27 = {
 //#region src/rules/ban-raw-span-name-emit.ts
 const INTERPOLATION = "${}";
 const isEmitCallee$1 = (name) => EMIT_CALLEES.some((emit) => emit === name);
-const memberPropertyName = (callee) => {
+const memberPropertyName$1 = (callee) => {
 	if (callee.computed) return null;
 	if (callee.property.type !== "Identifier") return null;
 	return callee.property.name;
 };
-const calleeName$1 = (callee) => {
+const calleeName$2 = (callee) => {
 	if (callee.type === "Identifier") return callee.name;
-	if (callee.type === "MemberExpression") return memberPropertyName(callee);
+	if (callee.type === "MemberExpression") return memberPropertyName$1(callee);
 	return null;
 };
 const templateName = (node) => node.quasis.map((quasi) => quasi.value.raw).join(INTERPOLATION);
@@ -39,7 +39,7 @@ const argName = (arg) => {
 	return inlineName(arg);
 };
 const inspect = (node) => {
-	const callee = calleeName$1(node.callee);
+	const callee = calleeName$2(node.callee);
 	if (callee === null || !isEmitCallee$1(callee)) return null;
 	const name = argName(node.arguments[0]);
 	if (name === null) return null;
@@ -49,7 +49,7 @@ const inspect = (node) => {
 	};
 };
 const banRawSpanNameEmit = defineRule({
-	meta: meta$27,
+	meta: meta$28,
 	create(context) {
 		return { CallExpression(node) {
 			const emitCall = inspect(node);
@@ -71,6 +71,7 @@ const banRawSpanNameEmit = defineRule({
 //#endregion
 //#region src/rules/path.config.ts
 const TEST_BASENAME = /\.(?:test|spec)\.[cm]?tsx?$/;
+const TYPE_TEST_BASENAME = /\.tst\.[cm]?tsx?$/;
 const SANCTIONED_TEST_DIRS = /* @__PURE__ */ new Set(["tests"]);
 /**
 * The only test location sanctioned under `src/`. A workflow property test
@@ -80,7 +81,6 @@ const SANCTIONED_TEST_DIRS = /* @__PURE__ */ new Set(["tests"]);
 const NESTED_TEST_DIR = "__tests__";
 const TEST_TREE_DIRS = /* @__PURE__ */ new Set([...SANCTIONED_TEST_DIRS, NESTED_TEST_DIR]);
 const PROPERTY_SUFFIX = ".property.test.ts";
-const INTEGRATION_SUFFIX = ".integration.test.ts";
 const DIFFERENTIAL_SUFFIX = ".differential.test.ts";
 /**
 * Forbidden outright. A schema's laws are generated, so a hand-written
@@ -97,8 +97,19 @@ const SCHEMA_SUFFIX = ".schema.test.ts";
 const WORKFLOW_TEST_BASENAME = /^[^.]+\.workflow\.property\.test\.ts$/;
 const GHERKIN_PACKAGE = "@systemfsoftware/effect-gherkin-spec";
 const DIFFERENTIAL_PACKAGE = "@systemfsoftware/differential-spec";
+const CONFORMANCE_PACKAGE = "@systemfsoftware/conformance-spec";
 const TRACE_SPEC_PACKAGE = "@systemfsoftware/trace-spec";
-const FOREIGN_RUNNERS = /* @__PURE__ */ new Set(["vitest", "@effect/vitest"]);
+const LAWFUL_RUNNER = "@systemfsoftware/vitest";
+const FOREIGN_VITEST_SOURCES = {
+	"vitest": true,
+	"@effect/vitest": true
+};
+/** Runners a harness-owned test (Gherkin, conformance, differential) must not import directly. */
+const FOREIGN_RUNNERS = {
+	...FOREIGN_VITEST_SOURCES,
+	[LAWFUL_RUNNER]: true
+};
+/** Packages whose own tests drive Vitest directly: the runner and its conformance harness. */
 const RAW_VITEST_PACKAGES = {
 	"effect-spec-runtime": true,
 	"vitest": true,
@@ -109,19 +120,19 @@ const RUNNER_NAMES = /* @__PURE__ */ new Set([
 	"test",
 	"describe"
 ]);
-const MESSAGE$9 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const MESSAGE$8 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
 const ABSENCE_MESSAGE = "{{name}} is untested. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
 //#endregion
 //#region src/rules/behaviour-exercises-use-case.config.ts
 const NO_SUBJECT_IMPORT_NAME = "a *.integration.test.ts that reaches no package code";
 const NO_SUBJECT_IMPORT_EXPECTED = "an import of the package code under test";
-const NO_SUBJECT_IMPORT_ACTUAL = "a behaviour file whose every runtime import is vitest, @effect/vitest, the gherkin spec package, effect, a Node builtin, or the file itself";
+const NO_SUBJECT_IMPORT_ACTUAL = "a behaviour file whose every runtime import is vitest, @effect/vitest, @systemfsoftware/vitest, the gherkin spec package, effect, a Node builtin, or the file itself";
 const NO_SUBJECT_IMPORT_FIX = "a behaviour test exercises a use case, so it has to reach the package. A file that imports nothing but its runner and effect is asserting over values it built in the same file. Ask whether the assertion tests anything at all: if it restates a literal, delete the scenario; if it states an invariant that holds over generated inputs, move it to a *.property.test.ts beside the cell that decides it. Type-only imports never count - they are erased before anything runs - while a side-effect import (import \"../src/x.js\", import {} from \"../src/x.js\") does count, because it executes that module.";
-const meta$26 = {
+const meta$27 = {
 	type: "problem",
 	docs: { description: "A *.integration.test.ts must import the package under test, not only its runner and effect, so the scenario exercises code that ships rather than values the test built itself." },
 	schema: [],
-	messages: { noSubjectImport: MESSAGE$9 }
+	messages: { noSubjectImport: MESSAGE$8 }
 };
 //#endregion
 //#region src/rules/path.ts
@@ -141,13 +152,14 @@ const isInTestsImportScope = (filename) => {
 };
 const isInConfiguredTestDir = (filename, dirs) => directoriesOf(filename).some((segment) => dirs.includes(segment));
 const isTestFile = (basename) => TEST_BASENAME.test(basename);
+const isBehaviourBasename = (basename) => basename.endsWith(".integration.test.ts") || basename.endsWith(".contract.test.ts");
 const CELL_SUFFIX = /\.([^.]+)\.[cm]?tsx?$/;
 const cellOf = (basename) => CELL_SUFFIX.exec(basename)?.[1];
 //#endregion
 //#region src/rules/behaviour-exercises-use-case.ts
 const EFFECT_PACKAGE = "effect";
 const FOUNDATION_PACKAGES = /* @__PURE__ */ new Set([
-	...FOREIGN_RUNNERS,
+	...Object.keys(FOREIGN_RUNNERS),
 	GHERKIN_PACKAGE,
 	EFFECT_PACKAGE
 ]);
@@ -170,7 +182,6 @@ const isFoundationImport = (source, filename) => {
 	if (source === "@systemfsoftware/effect-gherkin-spec" && isGherkinPackageTree(filename)) return false;
 	return FOUNDATION_PACKAGES.has(source) || source.startsWith(`${EFFECT_PACKAGE}/`) || source.startsWith("node:");
 };
-const isBehaviourTest$3 = (basename) => basename.endsWith(INTEGRATION_SUFFIX);
 /** The stem of a path with its final extension stripped, for identity comparisons. */
 const stemOf = (file) => file.replace(/\.[^/]+$/, "");
 /**
@@ -222,16 +233,17 @@ const DIST_SEGMENT = /(?:^|\/)dist\//;
 * name documents it for the reader without pretending to be evidence.
 *
 * What counts as reaching: a runtime import from anything that is not the
-* scaffolding - vitest, @effect/vitest, the gherkin spec package, effect or a
-* subpath of it, or a Node builtin - and not the test file itself, or a dynamic
-* `import(...)` of such a source. Type-only specifiers are erased and never
-* count; a side-effect import (`import "./x.js"`, `import {} from "./x.js"`)
-* executes its module and counts for whatever that module is. Whether a named
-* module actually exists is not observable from one file, so an import whose
-* path names nothing satisfies the rule the same way a real one does.
+* scaffolding - vitest, @effect/vitest, @systemfsoftware/vitest, the gherkin
+* spec package, effect or a subpath of it, or a Node builtin - and not the test
+* file itself, or a dynamic `import(...)` of such a source. Type-only
+* specifiers are erased and never count; a side-effect import (`import
+* "./x.js"`, `import {} from "./x.js"`) executes its module and counts for
+* whatever that module is. Whether a named module actually exists is not
+* observable from one file, so an import whose path names nothing satisfies the
+* rule the same way a real one does.
 */
 const behaviourExercisesUseCase = defineRule({
-	meta: meta$26,
+	meta: meta$27,
 	create(context) {
 		let reached = false;
 		return {
@@ -246,7 +258,7 @@ const behaviourExercisesUseCase = defineRule({
 				if (typeof node.value === "string" && DIST_SEGMENT.test(node.value)) reached = true;
 			},
 			"Program:exit"(node) {
-				if (!isBehaviourTest$3(basenameOf(context.filename))) return;
+				if (!isBehaviourBasename(basenameOf(context.filename))) return;
 				if (reached) return;
 				for (const statement of node.body) {
 					if (statement.type !== "ImportDeclaration") continue;
@@ -281,13 +293,13 @@ const TOO_MANY_FEATURES_NAME = "a *.integration.test.ts accumulating multiple Fe
 const TOO_MANY_FEATURES_EXPECTED = "exactly one Feature(...) — every additional one signals a junk drawer";
 const TOO_MANY_FEATURES_ACTUAL = "a behaviour file with two or more Feature(...) calls";
 const TOO_MANY_FEATURES_FIX = "splitting a junk drawer into several smaller junk drawers is not an improvement. When separating scenarios surfaces assertions that restate a pure function return value — change detectors against a lookup table or constant — those get deleted, not rehoused. Each surviving capability keeps its own file with exactly one Feature.";
-const meta$25 = {
+const meta$26 = {
 	type: "problem",
 	docs: { description: "A *.integration.test.ts must contain exactly one Feature(...) call. Zero or two-or-more is the junk-drawer signal that produced 41 scenarios of pure-function assertions in a single file." },
 	schema: [],
 	messages: {
-		tooFewFeatures: MESSAGE$9,
-		tooManyFeatures: MESSAGE$9
+		tooFewFeatures: MESSAGE$8,
+		tooManyFeatures: MESSAGE$8
 	}
 };
 //#endregion
@@ -306,7 +318,6 @@ const isFeatureCallStatement = (statement) => {
 	if (statement.expression.type !== "CallExpression") return false;
 	return rootCalleeName(statement.expression.callee) === "Feature";
 };
-const isBehaviourTest$2 = (basename) => basename.endsWith(INTEGRATION_SUFFIX);
 const findSecondFeatureCall = (program) => {
 	let seen = 0;
 	for (const statement of program.body) {
@@ -326,10 +337,10 @@ const hasAnyFeatureCall = (program) => {
 	return false;
 };
 const behaviourOneFeaturePerFile = defineRule({
-	meta: meta$25,
+	meta: meta$26,
 	create(context) {
 		return { "Program:exit"(node) {
-			if (!isBehaviourTest$2(basenameOf(context.filename))) return;
+			if (!isBehaviourBasename(basenameOf(context.filename))) return;
 			const excess = findSecondFeatureCall(node);
 			if (excess !== null) {
 				const total = countFeatureCalls(node);
@@ -361,19 +372,19 @@ const behaviourOneFeaturePerFile = defineRule({
 //#endregion
 //#region src/rules/behaviour-test-requires-gherkin.config.ts
 const FOREIGN_RUNNER_EXPECTED = "it and layer imported from @systemfsoftware/effect-gherkin-spec";
-const FOREIGN_RUNNER_ACTUAL = "a test runner imported directly from vitest or @effect/vitest in a behaviour file";
-const FOREIGN_RUNNER_FIX = "import { it, layer } from @systemfsoftware/effect-gherkin-spec and build the suite with makeFeature({ it, layer })";
+const FOREIGN_RUNNER_ACTUAL = "a test runner imported directly from vitest, @effect/vitest or @systemfsoftware/vitest in a behaviour file";
+const FOREIGN_RUNNER_FIX = "import { it } from @systemfsoftware/effect-gherkin-spec and build the suite with makeFeature({ it })";
 const MISSING_MAKE_FEATURE_NAME = "a *.integration.test.ts without makeFeature";
 const MISSING_MAKE_FEATURE_EXPECTED = "makeFeature imported from @systemfsoftware/effect-gherkin-spec";
 const MISSING_MAKE_FEATURE_ACTUAL = "a behaviour file that never constructs a Gherkin feature";
 const MISSING_MAKE_FEATURE_FIX = "import { makeFeature } from @systemfsoftware/effect-gherkin-spec and declare `const Feature = makeFeature({ it, layer })`";
-const meta$24 = {
+const meta$25 = {
 	type: "problem",
-	docs: { description: "A *.integration.test.ts must drive its suite through makeFeature from @systemfsoftware/effect-gherkin-spec and must not import test runners from vitest or @effect/vitest." },
+	docs: { description: "A *.integration.test.ts must drive its suite through makeFeature from @systemfsoftware/effect-gherkin-spec and must not import test runners from vitest, @effect/vitest or @systemfsoftware/vitest." },
 	schema: [],
 	messages: {
-		foreignRunner: MESSAGE$9,
-		missingMakeFeature: MESSAGE$9
+		foreignRunner: MESSAGE$8,
+		missingMakeFeature: MESSAGE$8
 	}
 };
 //#endregion
@@ -393,13 +404,12 @@ const foreignRunnerNameOf = (specifier) => {
 	const { name } = Schema.decodeSync(ImportedIdentifier)(specifier.imported);
 	return RUNNER_NAMES.has(name) ? name : null;
 };
-const isBehaviourTest$1 = (basename) => basename.endsWith(INTEGRATION_SUFFIX);
 const behaviourTestRequiresGherkin = defineRule({
-	meta: meta$24,
+	meta: meta$25,
 	create(context) {
 		const basename = basenameOf(context.filename);
 		return { Program(node) {
-			if (!isBehaviourTest$1(basename)) return;
+			if (!isBehaviourBasename(basename)) return;
 			let hasMakeFeature = false;
 			for (const statement of node.body) {
 				if (statement.type !== "ImportDeclaration") continue;
@@ -408,7 +418,7 @@ const behaviourTestRequiresGherkin = defineRule({
 					if (specifier.type !== "ImportSpecifier") continue;
 					if (isMakeFeatureSpecifier(specifier)) hasMakeFeature = true;
 				}
-				if (!FOREIGN_RUNNERS.has(sourceValue)) continue;
+				if (FOREIGN_RUNNERS[sourceValue] !== true) continue;
 				for (const specifier of statement.specifiers) {
 					if (specifier.type !== "ImportSpecifier") continue;
 					const runnerName = foreignRunnerNameOf(specifier);
@@ -438,6 +448,145 @@ const behaviourTestRequiresGherkin = defineRule({
 		} };
 	}
 });
+const HARNESS_MEMBERS = {
+	linearizable: true,
+	sequential: true,
+	released: true
+};
+const LEGACY_CHECK_MEMBER = "check";
+const HARNESS_PRESCRIPTION$2 = "import { Conformance } from @systemfsoftware/conformance-spec and express the test as Conformance.linearizable(implementation, { commands, model, run, fibers, operations }) in the scenario body";
+const meta$24 = {
+	type: "problem",
+	docs: { description: "Conformance tests must use the @systemfsoftware/conformance-spec Conformance barrel: Conformance.linearizable, Conformance.sequential, or Conformance.released. Raw runner calls (it, test, describe, and member forms like it.effect) and direct runner imports are forbidden in *.conformance.test.ts files; the retired Linearizable.check / SequentialModel.check / Released.check shapes are rejected, and importing Conformance without invoking a check is equally non-compliant." },
+	schema: [],
+	messages: {
+		rawRunnerCall: MESSAGE$8,
+		runnerImport: MESSAGE$8,
+		missingHarnessImport: MESSAGE$8,
+		legacyHarnessCall: MESSAGE$8,
+		missingHarnessUsage: MESSAGE$8
+	}
+};
+//#endregion
+//#region src/rules/conformance-test-requires-harness.ts
+const memberObjectName$1 = (callee) => callee.type === "MemberExpression" && callee.object.type === "Identifier" ? callee.object.name : void 0;
+const memberPropertyName = (callee) => callee.type === "MemberExpression" && callee.property.type === "Identifier" ? callee.property.name : void 0;
+const memberName = (callee) => callee.type === "Identifier" ? callee.name : memberPropertyName(callee);
+const calleeName$1 = (callee) => callee.type === "Identifier" ? callee.name : memberObjectName$1(callee);
+const isRawRunnerCall = (callee) => {
+	const name = calleeName$1(callee);
+	return name !== void 0 && RUNNER_NAMES.has(name);
+};
+const isForeignRunnerImport$1 = (node) => typeof node.source.value === "string" && FOREIGN_RUNNERS[node.source.value] === true;
+const namesConformanceExport = (specifier) => specifier.imported.type === "Identifier" && specifier.imported.name === "Conformance";
+const recordBindings = (node, packageBindings, conformanceBindings) => {
+	if (node.source.value !== "@systemfsoftware/conformance-spec") return;
+	for (const specifier of node.specifiers) {
+		packageBindings.add(specifier.local.name);
+		if (specifier.type === "ImportSpecifier" && namesConformanceExport(specifier)) conformanceBindings.add(specifier.local.name);
+	}
+};
+const isHarnessInvocation = (callee, conformanceBindings) => {
+	const member = memberName(callee);
+	const root = calleeName$1(callee);
+	return member !== void 0 && HARNESS_MEMBERS[member] === true && root !== void 0 && conformanceBindings.has(root);
+};
+const isLegacyCheck = (callee, packageBindings) => {
+	const root = calleeName$1(callee);
+	return memberName(callee) === "check" && root !== void 0 && packageBindings.has(root);
+};
+const legacyCallText = (callee) => callee.type === "Identifier" ? callee.name : `${calleeName$1(callee)}.${LEGACY_CHECK_MEMBER}`;
+const legacyCheckError = (callee) => ({
+	messageId: "legacyHarnessCall",
+	data: {
+		name: `a .${LEGACY_CHECK_MEMBER}(...) call in a conformance test file`,
+		expected: HARNESS_PRESCRIPTION$2,
+		actual: `${legacyCallText(callee)} is not a check the barrel exposes`,
+		fix: HARNESS_PRESCRIPTION$2
+	}
+});
+const conformanceTestRequiresHarness = defineRule({
+	meta: meta$24,
+	create(context) {
+		if (!context.filename.endsWith(".conformance.test.ts")) return {};
+		const packageBindings = /* @__PURE__ */ new Set();
+		const conformanceBindings = /* @__PURE__ */ new Set();
+		let violations = 0;
+		let hasHarnessInvocation = false;
+		return {
+			ImportDeclaration(node) {
+				if (isForeignRunnerImport$1(node)) {
+					context.report({
+						node,
+						messageId: "runnerImport",
+						data: {
+							name: `runner import from ${String(node.source.value)} in a conformance test file`,
+							expected: HARNESS_PRESCRIPTION$2,
+							actual: "a direct vitest / @effect/vitest / @systemfsoftware/vitest runner import bypasses the conformance check",
+							fix: `delete the runner import; ${HARNESS_PRESCRIPTION$2}`
+						}
+					});
+					violations += 1;
+					return;
+				}
+				recordBindings(node, packageBindings, conformanceBindings);
+			},
+			CallExpression(node) {
+				if (isRawRunnerCall(node.callee)) {
+					const name = calleeName$1(node.callee) ?? "";
+					context.report({
+						node,
+						messageId: "rawRunnerCall",
+						data: {
+							name: `raw runner call (${name}) in a conformance test file`,
+							expected: HARNESS_PRESCRIPTION$2,
+							actual: `${name}(...) bypasses the conformance check`,
+							fix: `rewrite using ${HARNESS_PRESCRIPTION$2}`
+						}
+					});
+					violations += 1;
+					return;
+				}
+				if (isHarnessInvocation(node.callee, conformanceBindings)) {
+					hasHarnessInvocation = true;
+					return;
+				}
+				if (isLegacyCheck(node.callee, packageBindings)) {
+					context.report({
+						node,
+						...legacyCheckError(node.callee)
+					});
+					violations += 1;
+				}
+			},
+			"Program:exit"(node) {
+				if (packageBindings.size === 0) {
+					context.report({
+						node,
+						messageId: "missingHarnessImport",
+						data: {
+							name: `conformance test file without the ${CONFORMANCE_PACKAGE} import`,
+							expected: HARNESS_PRESCRIPTION$2,
+							actual: "no conformance check import found",
+							fix: HARNESS_PRESCRIPTION$2
+						}
+					});
+					return;
+				}
+				if (!hasHarnessInvocation && violations === 0) context.report({
+					node,
+					messageId: "missingHarnessUsage",
+					data: {
+						name: `conformance test file imports ${CONFORMANCE_PACKAGE} but never invokes it`,
+						expected: HARNESS_PRESCRIPTION$2,
+						actual: "no Conformance.linearizable, Conformance.sequential, or Conformance.released call runs",
+						fix: HARNESS_PRESCRIPTION$2
+					}
+				});
+			}
+		};
+	}
+});
 //#endregion
 //#region src/rules/damp-test-naming.config.ts
 const PASCAL_CASE$1 = /^[A-Z][a-z][a-zA-Z0-9]*$/;
@@ -540,6 +689,7 @@ const isTestFunctionCall = (node) => {
 const dampTestNaming = defineRule({
 	meta: meta$23,
 	create(context) {
+		if (TYPE_TEST_BASENAME.test(basenameOf(context.filename))) return {};
 		return { CallExpression(node) {
 			if (!isTestFunctionCall(node)) return;
 			const firstArg = node.arguments[0];
@@ -574,14 +724,14 @@ const meta$22 = {
 };
 //#endregion
 //#region src/rules/differential-test-requires-harness.ts
-const HARNESS_PRESCRIPTION$1 = "import { Differential, Metamorphic } from @systemfsoftware/differential-spec and express the test as Differential.compare({ reference, candidate }).on(arb).assert(oracle) or Metamorphic.on(system).relation({ transformInput, assertOutput }).on(arb)";
+const HARNESS_PRESCRIPTION$1 = "import { Differential, Metamorphic } from @systemfsoftware/differential-spec and express the test as Differential.compare({ name, reference, candidate }).on(arb).assert(oracle) or Metamorphic.on({ name, system }).relation({ transformInput, assertOutput }).on(arb)";
 const memberObjectName = (callee) => callee.type === "MemberExpression" && callee.object.type === "Identifier" ? callee.object.name : void 0;
 const calleeName = (callee) => callee.type === "Identifier" ? callee.name : memberObjectName(callee);
 const recordHarnessBindings = (node, bindings) => {
 	if (node.source.value !== "@systemfsoftware/differential-spec") return;
 	for (const specifier of node.specifiers) bindings.add(specifier.local.name);
 };
-const isForeignRunnerImport = (node) => typeof node.source.value === "string" && FOREIGN_RUNNERS.has(node.source.value);
+const isForeignRunnerImport = (node) => typeof node.source.value === "string" && FOREIGN_RUNNERS[node.source.value] === true;
 const differentialTestRequiresHarness = defineRule({
 	meta: meta$22,
 	create(context) {
@@ -598,7 +748,7 @@ const differentialTestRequiresHarness = defineRule({
 						data: {
 							name: `runner import from ${String(node.source.value)} in a differential test file`,
 							expected: HARNESS_PRESCRIPTION$1,
-							actual: "a direct vitest / @effect/vitest runner import bypasses the differential oracle",
+							actual: "a direct vitest / @effect/vitest / @systemfsoftware/vitest runner import bypasses the differential oracle",
 							fix: `delete the runner import; ${HARNESS_PRESCRIPTION$1}`
 						}
 					});
@@ -654,97 +804,16 @@ const differentialTestRequiresHarness = defineRule({
 	}
 });
 //#endregion
-//#region src/rules/expect-boolean-predicate.config.ts
-const MESSAGE$8 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
-const BOOLEAN_MATCHERS = {
-	toBe: true,
-	toEqual: true
-};
-const COMPARISON_OPERATORS = {
-	"===": true,
-	"!==": true,
-	"==": true,
-	"!=": true,
-	"<": true,
-	"<=": true,
-	">": true,
-	">=": true,
-	instanceof: true,
-	in: true
-};
-const VIOLATION_NAME$4 = "a predicate evaluated in the test asserted against true or false";
-const VIOLATION_EXPECTED$1 = "expect(...) around a boolean the code under test returned";
-const VIOLATION_ACTUAL$1 = "expect(...) wraps a call, a comparison, a `!` or an `&&` / `||` evaluated in the test, so a failure reports `expected false to be true` instead of the values that disagreed";
-const VIOLATION_FIX$1 = "rewrite a predicate call as expect(x).toSatisfy(P) — e.g. expect(s.reading).toSatisfy(Result.isFailure) — and a comparison as expect(a).toEqual(b)";
-const meta$21 = {
-	type: "problem",
-	docs: { description: "An expect(...) asserted with toBe(true|false) or toEqual(true|false) must wrap a boolean the code under test returned. A predicate call, comparison, negation or && / || evaluated in the test is refused, with the toSatisfy or toEqual rewrite as the fix." },
-	schema: [],
-	messages: { booleanPredicate: MESSAGE$8 }
-};
-//#endregion
-//#region src/rules/expect-call.ts
-const EXPECT = "expect";
-const isExpectCallee = (callee) => callee.type === "Identifier" && callee.name === EXPECT;
-const expectCallOf = (node, acceptsMember) => {
-	if (node.callee.type !== "MemberExpression") return void 0;
-	let target = node.callee.object;
-	while (target.type === "MemberExpression") {
-		if (acceptsMember !== void 0 && acceptsMember(target) === false) return void 0;
-		target = target.object;
-	}
-	if (target.type !== "CallExpression" || isExpectCallee(target.callee) === false) return void 0;
-	return target;
-};
-//#endregion
-//#region src/rules/expect-boolean-predicate.ts
-const isNotMember = (member) => member.property.type === "Identifier" && member.property.name === "not";
-const isBooleanLiteral = (node) => node !== void 0 && node.type === "Literal" && typeof node.value === "boolean";
-/** The ARG positions `expect` exposes that no subject can fill by accident. */
-const isEvaluatedInTest = (arg) => {
-	switch (arg.type) {
-		case "CallExpression": return true;
-		case "UnaryExpression": return arg.operator === "!";
-		case "LogicalExpression": return arg.operator === "&&" || arg.operator === "||";
-		case "BinaryExpression": return COMPARISON_OPERATORS[arg.operator] === true;
-		default: return false;
-	}
-};
-const expectBooleanPredicate = defineRule({
-	meta: meta$21,
-	create(context) {
-		return { CallExpression(node) {
-			if (node.callee.type !== "MemberExpression" || node.callee.property.type !== "Identifier") return;
-			if (BOOLEAN_MATCHERS[node.callee.property.name] !== true) return;
-			if (!isBooleanLiteral(node.arguments[0])) return;
-			const receiver = expectCallOf(node, isNotMember);
-			if (receiver === void 0) return;
-			const arg = receiver.arguments[0];
-			if (arg === void 0 || !isEvaluatedInTest(arg)) return;
-			context.report({
-				node,
-				messageId: "booleanPredicate",
-				data: {
-					name: VIOLATION_NAME$4,
-					expected: VIOLATION_EXPECTED$1,
-					actual: VIOLATION_ACTUAL$1,
-					fix: VIOLATION_FIX$1
-				}
-			});
-		} };
-	}
-});
-//#endregion
 //#region src/rules/in-source-test-prop-only.config.ts
 const NON_PROP_CALL_NAME = "a non-property test call inside an `import.meta.vitest` block";
 const NON_PROP_CALL_EXPECTED = "only `it.prop` or `it.effect.prop` member-chain calls (standard modifiers included) with boolean predicates";
 const NON_PROP_CALL_ACTUAL = "a bare or member-chain test call other than `it.prop`/`it.effect.prop`";
 const NON_PROP_CALL_FIX = "delete the block — non-property in-source tests belong nowhere in `src/`; re-home a meaningful example through the cell public export as `*.integration.test.ts`, or rewrite a real invariant as `it.prop` over a schema-derived arbitrary";
-const meta$20 = {
+const meta$21 = {
 	type: "problem",
 	docs: { description: "In-source `if (import.meta.vitest)` blocks under src/ must contain only `it.prop` or `it.effect.prop` calls; every other test call fails — delete the block or rewrite the invariant as a property." },
 	schema: [],
-	messages: { nonPropCall: MESSAGE$9 }
+	messages: { nonPropCall: MESSAGE$8 }
 };
 //#endregion
 //#region src/rules/vitest-guard.ts
@@ -804,7 +873,7 @@ const rootNameOf = (node) => {
 	if (node.type === "CallExpression") return rootNameOf(node.callee);
 };
 const inSourceTestPropOnly = defineRule({
-	meta: meta$20,
+	meta: meta$21,
 	create(context) {
 		const filename = context.filename;
 		const basename = basenameOf(filename);
@@ -845,17 +914,17 @@ const NOT_MODULE_LEVEL_NAME = "a nested `import.meta.vitest` block";
 const NOT_MODULE_LEVEL_EXPECTED = "the in-source test block as a direct statement of the module body";
 const NOT_MODULE_LEVEL_ACTUAL = "an `import.meta.vitest` block nested inside another statement";
 const NOT_MODULE_LEVEL_FIX = "move the block to module level — a nested block does not run under vitest includeSource";
-const NO_PRIVATE_TARGET_NAME = "an `import.meta.vitest` block touching no private binding";
-const NO_PRIVATE_TARGET_EXPECTED = "an in-source test exercising a non-exported module-level binding";
-const NO_PRIVATE_TARGET_ACTUAL = "an in-source block referencing only exported or imported names";
-const NO_PRIVATE_TARGET_FIX = "test the public surface from tests/ as *.integration.test.ts; in-source blocks exist for private helpers only — if the public behaviour you meant to cover is a pure function, delete the assertion: the type system already proves it";
-const meta$19 = {
+const NO_PRIVATE_TARGET_NAME = "an `import.meta.vitest` block touching no module-level binding";
+const NO_PRIVATE_TARGET_EXPECTED = "an in-source test exercising this module's own code — a private helper, or an exported operation named in the `it.prop` `subject` slot";
+const NO_PRIVATE_TARGET_ACTUAL = "an in-source block referencing only exported-call or imported names";
+const NO_PRIVATE_TARGET_FIX = "touch this module. A private helper is referenced directly; an exported operation is named in the `it.prop` `subject` slot beside its declaration — that is the one home for its laws and the file whose mutants they run. What the block cannot hold is a behaviour binding no module-level name: test the public surface from tests/ as *.integration.test.ts instead";
+const meta$20 = {
 	type: "problem",
-	docs: { description: "In-source `if (import.meta.vitest)` blocks under src/ must be at module level and exercise at least one non-exported binding; other tests belong in tests/." },
+	docs: { description: "In-source `if (import.meta.vitest)` blocks under src/ must be at module level and exercise this module's own code — a private helper, or an exported operation named in the `it.prop` `subject` slot; a public-surface test belongs in tests/ as an integration test." },
 	schema: [],
 	messages: {
-		notModuleLevel: MESSAGE$9,
-		noPrivateTarget: MESSAGE$9
+		notModuleLevel: MESSAGE$8,
+		noPrivateTarget: MESSAGE$8
 	}
 };
 //#endregion
@@ -882,8 +951,25 @@ const collectPrivateNames = (body, out) => {
 		if (isCollectable(node)) collectDeclaration(node, out);
 	}
 };
+const collectModuleNames = (body, out) => {
+	for (const node of body) {
+		if (node.type === "ExportNamedDeclaration") {
+			if (node.source === null && node.declaration !== null && isCollectable(node.declaration)) collectDeclaration(node.declaration, out);
+			continue;
+		}
+		if (node.type === "ExportDefaultDeclaration" && isCollectable(node.declaration)) {
+			collectDeclaration(node.declaration, out);
+			continue;
+		}
+		if (isCollectable(node)) collectDeclaration(node, out);
+	}
+};
+const isSubjectValue = (node) => {
+	const parent = node.parent;
+	return parent.type === "Property" && parent.computed !== true && parent.key.type === "Identifier" && parent.key.name === "subject" && parent.value === node;
+};
 const inSourceTestTargetsPrivate = defineRule({
-	meta: meta$19,
+	meta: meta$20,
 	create(context) {
 		const filename = context.filename;
 		const basename = basenameOf(filename);
@@ -891,10 +977,12 @@ const inSourceTestTargetsPrivate = defineRule({
 		const inTestFile = isTestFile(basename);
 		if (!underSrc || inTestFile) return {};
 		const privateNames = /* @__PURE__ */ new Set();
+		const moduleNames = /* @__PURE__ */ new Set();
 		const guards = [];
 		return {
 			Program(node) {
 				collectPrivateNames(node.body, privateNames);
+				collectModuleNames(node.body, moduleNames);
 			},
 			IfStatement(node) {
 				if (!isVitestGuard(node.test)) return;
@@ -917,7 +1005,7 @@ const inSourceTestTargetsPrivate = defineRule({
 				});
 			},
 			Identifier(node) {
-				if (!privateNames.has(node.name)) return;
+				if (!(privateNames.has(node.name) || moduleNames.has(node.name) && isSubjectValue(node))) return;
 				const guard = guards.find((g) => isInsideConsequent(node, g.node.consequent));
 				if (guard !== void 0) guard.hit = true;
 			},
@@ -940,6 +1028,122 @@ const inSourceTestTargetsPrivate = defineRule({
 	}
 });
 //#endregion
+//#region src/rules/model-fixture-imports-subject.config.ts
+const SUBJECT_IMPORT_NAME = "a *.model.ts fixture that imports the package under test";
+const SUBJECT_IMPORT_EXPECTED = "a pure model that imports only effect, node builtins, and harness types";
+const SUBJECT_IMPORT_FIX = "delete the import; the model derives its state from the declared Schema it is given, so it needs no symbol from the package it stands in for";
+const RELATIVE_ESCAPE_NAME = "a *.model.ts fixture that climbs out of the tests tree";
+const RELATIVE_ESCAPE_EXPECTED = "a relative import that stays inside the tests tree — a sibling fixture under tests/__fixtures__/";
+const RELATIVE_ESCAPE_FIX = "import the sibling fixture with ./<name>.js, or move the model; a model that reaches src/ is the implementation checking itself";
+const meta$19 = {
+	type: "problem",
+	docs: { description: "A *.model.ts fixture is the pure model a conformance check stands the implementation against, so it may not import the package whose tests it serves. The package is derived from the path: the directory the tests tree lives in. An import, re-export, dynamic import, or require of that package name — or of any subpath of it — is the implementation reaching its own oracle. A relative specifier is judged the same way lexically: resolved against the fixture directory, it must stay inside the tests tree, so ../../src/Lock.js is the implementation again while ./Locks.js is a sibling fixture." },
+	schema: [],
+	messages: {
+		subjectImport: MESSAGE$8,
+		relativeEscape: MESSAGE$8
+	}
+};
+//#endregion
+//#region src/rules/model-fixture-imports-subject.ts
+/**
+* The basename of the directory whose tests tree the fixture lives in. A
+* `*.model.ts` serves that package's tests, so the directory name is the
+* unscoped name of the package under test. Read lexically, the way every rule
+* here reads a path: one file cannot know what else is on disk (OX-TS2), and
+* with no tests tree in the path the subject is unknown — an unknown subject is
+* never reported.
+*/
+const packageDirOf = (filename) => {
+	const dirs = directoriesOf(filename);
+	const index = dirs.findIndex((segment) => TEST_TREE_DIRS.has(segment));
+	return index <= 0 ? void 0 : dirs[index - 1];
+};
+/**
+* The unscoped, subpath-stripped head of a package specifier:
+* `@systemfsoftware/effect-lock/testing` -> `effect-lock`. A subpath is still
+* the same dependency, and admitting it would let a fixture reach the
+* implementation through a nested entry.
+*/
+const packageHeadOf = (source) => {
+	const unscoped = source.startsWith("@") ? source.slice(source.indexOf("/") + 1) : source;
+	return unscoped.includes("/") ? unscoped.slice(0, unscoped.indexOf("/")) : unscoped;
+};
+const importsSubject = (source, subjectDir) => subjectDir !== void 0 && packageHeadOf(source) === subjectDir;
+const specifierOf$1 = (node) => node !== void 0 && node.type === "Literal" && typeof node.value === "string" ? node.value : void 0;
+const isRelativeSpecifier = (source) => source.startsWith("./") || source.startsWith("../");
+/**
+* The directory stack a relative specifier resolves to against the linted
+* file's own directory, `..` segments collapsed. Existence is never checked:
+* one file cannot know what else is on disk (OX-TS2), so only the lexical
+* identity is decided.
+*/
+const resolveRelative = (source, filename) => {
+	const stack = [...directoriesOf(filename)];
+	for (const segment of source.split("/")) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") {
+			stack.pop();
+			continue;
+		}
+		stack.push(segment);
+	}
+	return stack;
+};
+const inTestsTree = (segments) => segments.some((segment) => TEST_TREE_DIRS.has(segment));
+const modelFixtureImportsSubject = defineRule({
+	meta: meta$19,
+	create(context) {
+		if (!basenameOf(context.filename).endsWith(".model.ts")) return {};
+		const subjectDir = packageDirOf(context.filename);
+		const fixtureInTestsTree = inTestsTree(directoriesOf(context.filename));
+		const checkSource = (node, source) => {
+			const specifier = specifierOf$1(source);
+			if (specifier === void 0) return;
+			if (importsSubject(specifier, subjectDir)) {
+				context.report({
+					node,
+					messageId: "subjectImport",
+					data: {
+						name: SUBJECT_IMPORT_NAME,
+						expected: SUBJECT_IMPORT_EXPECTED,
+						actual: `a dependency on ${specifier} in a *.model.ts fixture`,
+						fix: SUBJECT_IMPORT_FIX
+					}
+				});
+				return;
+			}
+			if (fixtureInTestsTree && isRelativeSpecifier(specifier) && !inTestsTree(resolveRelative(specifier, context.filename))) context.report({
+				node,
+				messageId: "relativeEscape",
+				data: {
+					name: RELATIVE_ESCAPE_NAME,
+					expected: RELATIVE_ESCAPE_EXPECTED,
+					actual: `a relative import of ${specifier}, resolving outside the tests tree`,
+					fix: RELATIVE_ESCAPE_FIX
+				}
+			});
+		};
+		return {
+			ImportDeclaration(node) {
+				checkSource(node, node.source);
+			},
+			ExportNamedDeclaration(node) {
+				if (node.source !== null) checkSource(node, node.source);
+			},
+			ExportAllDeclaration(node) {
+				checkSource(node, node.source);
+			},
+			ImportExpression(node) {
+				checkSource(node, node.source);
+			},
+			TSImportEqualsDeclaration(node) {
+				if (node.moduleReference.type === "TSExternalModuleReference") checkSource(node, node.moduleReference.expression);
+			}
+		};
+	}
+});
+//#endregion
 //#region src/rules/no-assert-in-property.config.ts
 const MESSAGE$7 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
 const meta$18 = {
@@ -1019,6 +1223,20 @@ const noAssertInProperty = defineRule({
 	}
 });
 //#endregion
+//#region src/rules/expect-call.ts
+const EXPECT = "expect";
+const isExpectCallee = (callee) => callee.type === "Identifier" && callee.name === EXPECT;
+const expectCallOf = (node, acceptsMember) => {
+	if (node.callee.type !== "MemberExpression") return void 0;
+	let target = node.callee.object;
+	while (target.type === "MemberExpression") {
+		if (acceptsMember !== void 0 && acceptsMember(target) === false) return void 0;
+		target = target.object;
+	}
+	if (target.type !== "CallExpression" || isExpectCallee(target.callee) === false) return void 0;
+	return target;
+};
+//#endregion
 //#region src/rules/no-behaviourless-assertion.config.ts
 const TEST_FILE = /\.(test|spec)\.[cm]?tsx?$/;
 const BEHAVIOUR_NODES = {
@@ -1430,7 +1648,7 @@ const meta$14 = {
 	type: "problem",
 	docs: { description: "A *.integration.test.ts Feature builder must configure at least one environment Layer (.withLayer or .withScenarioLayer) to enforce real integration boundaries under WGI-CLS1." },
 	schema: [],
-	messages: { noLayerInFeature: MESSAGE$9 }
+	messages: { noLayerInFeature: MESSAGE$8 }
 };
 //#endregion
 //#region src/rules/no-pseudo-gherkin-unit-tests.ts
@@ -1438,7 +1656,6 @@ const LAYER_METHODS = {
 	withLayer: true,
 	withScenarioLayer: true
 };
-const isBehaviourTest = (basename) => basename.endsWith(INTEGRATION_SUFFIX);
 const hasLayerInChain = (callNode) => {
 	let current = callNode;
 	while (current.type === "CallExpression") {
@@ -1463,7 +1680,7 @@ const findRootFeatureCall = (callNode) => {
 const noPseudoGherkinUnitTests = defineRule({
 	meta: meta$14,
 	create(context) {
-		if (!isBehaviourTest(basenameOf(context.filename))) return {};
+		if (!isBehaviourBasename(basenameOf(context.filename))) return {};
 		return { CallExpression(node) {
 			if (node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier") {
 				if (node.callee.property.name === "body") {
@@ -1488,7 +1705,7 @@ const noPseudoGherkinUnitTests = defineRule({
 const MESSAGE$5 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
 const meta$13 = {
 	type: "problem",
-	docs: { description: "Property predicates (it.prop / it.effect.prop from @effect/vitest) must return a boolean verdict on every code path. fast-check counts undefined as success, so a bare return, a non-boolean return, or falling off the end of the body is a silent pass. Opaque values (identifiers, member expressions, calls) are trusted to be boolean; literals and operators are checked." },
+	docs: { description: "Property predicates (it.prop / it.effect.prop from @systemfsoftware/vitest) must return a boolean verdict on every code path. fast-check counts undefined as success, so a bare return, a non-boolean return, or falling off the end of the body is a silent pass. Opaque values (identifiers, member expressions, calls) are trusted to be boolean; literals and operators are checked." },
 	schema: [],
 	messages: {
 		bareReturn: MESSAGE$5,
@@ -1668,9 +1885,9 @@ const meta$12 = {
 	docs: { description: "Under src/, the only sanctioned test file is a single-segment <stem>.workflow.property.test.ts inside a sanctioned test directory, plus the generated schema-laws.test.ts entry point. Every other test file is banned: a kernel, policy, or schema suite becomes an in-source import.meta.vitest block, and a public-surface test moves outside src/ as an integration test. The sanctioned directory list is the sanctionedDirs option, defaulting to the one directory this repo runs." },
 	schema: [Schema.toJsonSchemaDocument(Options$1).schema],
 	messages: {
-		testFileInSrc: MESSAGE$9,
-		schemaTestInSrc: MESSAGE$9,
-		propertyTestOutsideTestsDir: MESSAGE$9
+		testFileInSrc: MESSAGE$8,
+		schemaTestInSrc: MESSAGE$8,
+		propertyTestOutsideTestsDir: MESSAGE$8
 	}
 };
 //#endregion
@@ -1725,7 +1942,8 @@ const PREDICATE_SYMBOLS = /* @__PURE__ */ new Set([
 	"∘",
 	"∩",
 	"∪",
-	"⊥"
+	"⊥",
+	"⊨"
 ]);
 const NULLARY_PREDICATE_SYMBOLS = /* @__PURE__ */ new Set(["⊥"]);
 const PASCAL_CASE = /^[A-Z][a-z][a-zA-Z0-9]*$/;
@@ -1740,7 +1958,7 @@ const meta$11 = {
 		incompleteScope: "Expected: a bound variable after the quantifier \"{{symbol}}\" in scope segment \"{{scope}}\" (e.g., ∀x, ∀order, ∃e, →Shipped). A property quantifies over a named input drawn from a generator; name it. A lone quantifier binds nothing and specifies no domain.",
 		emptyDomain: "Expected: a non-empty PascalCase domain between the two underscores in \"{{actual}}\". If this isn't a universal invariant, delete the test. Otherwise name the thing under test, e.g., ∀x_DecodeEncode_=x.",
 		domainLeaksDAMP: "Expected: an invariant domain, not scenario language. Actual: domain \"{{domain}}\" contains \"{{word}}\" — that describes one case, not a universal law. Delete this test. It is not a property. Find the actual invariant and write that instead.",
-		invalidPredicateSymbol: "Expected: a relation symbol (≡ ≠ = ≤ ≥ ∈ ⊆ ⊇ → ¬ ∘ ∩ ∪ ⊥) starting the last segment of \"{{actual}}\". Actual: it ends with \"{{firstChar}}\". If this isn't a universal invariant, delete the test. Otherwise relate the output: = / ≡ (roundtrip or oracle), ⊆ / ∈ (invariant), ≠ (distinctness), ⊥ (impossibility).",
+		invalidPredicateSymbol: "Expected: a relation symbol (≡ ≠ = ≤ ≥ ∈ ⊆ ⊇ → ¬ ∘ ∩ ∪ ⊥ ⊨) starting the last segment of \"{{actual}}\". Actual: it ends with \"{{firstChar}}\". If this isn't a universal invariant, delete the test. Otherwise relate the output: = / ≡ (roundtrip or oracle), ⊆ / ∈ (invariant), ≠ (distinctness), ⊨ (satisfies a declared model), ⊥ (impossibility).",
 		incompletePredicate: "Expected: an operand after the relation symbol \"{{symbol}}\" in predicate \"{{predicate}}\", naming what the output is related to: =x / ≡Oracle (roundtrip or reference), ⊆Input / ∈Ignored (invariant), ≠Zero (distinctness), ⊥Cancellable (impossibility — name the outcome that cannot occur). A bare symbol relates the output to nothing and so asserts no property."
 	}
 };
@@ -2540,6 +2758,16 @@ const NEUTRAL_METHODS = {
 	match: true,
 	gen: true
 };
+/**
+* The fork's lawful `it.prop(name, { of, subject }, holds)` hands the function
+* under test to `holds` as its first parameter. Calling that parameter is
+* calling the subject, so it reaches this module's code by construction — even
+* when the parameter name would otherwise read as a codec accessor.
+*/
+const subjectParameterOf = (predicate) => {
+	const first = predicate.params[0];
+	return first !== void 0 && first.type === "Identifier" ? first.name : void 0;
+};
 const isNode = (value) => value !== null && typeof value === "object" && "type" in value;
 const mentionsImportMetaVitest = (value) => {
 	if (Array.isArray(value)) return value.some((item) => mentionsImportMetaVitest(item));
@@ -2551,9 +2779,9 @@ const mentionsImportMetaVitest = (value) => {
 	}
 	return false;
 };
-const collectPredicateShape = (provenance, node, shape) => {
+const collectPredicateShape = (provenance, node, shape, subjectParameter) => {
 	if (Array.isArray(node)) {
-		for (const item of node) collectPredicateShape(provenance, item, shape);
+		for (const item of node) collectPredicateShape(provenance, item, shape, subjectParameter);
 		return;
 	}
 	if (!isNode(node)) return;
@@ -2571,12 +2799,12 @@ const collectPredicateShape = (provenance, node, shape) => {
 				if (provenance.classifyCall(name, node) === "domain" || receiverIsLocal) shape.callsDomainFunction = true;
 			}
 		} else if (callee.type === "Identifier") {
-			if (CODEC_ACCESSORS[callee.name] !== true && NEUTRAL_METHODS[callee.name] !== true && provenance.classifyCall(callee.name, node) === "domain") shape.callsDomainFunction = true;
+			if (subjectParameter !== void 0 && callee.name === subjectParameter || CODEC_ACCESSORS[callee.name] !== true && NEUTRAL_METHODS[callee.name] !== true && provenance.classifyCall(callee.name, node) === "domain") shape.callsDomainFunction = true;
 		}
 	}
 	for (const [key, child] of Object.entries(node)) {
 		if (key === "parent") continue;
-		collectPredicateShape(provenance, child, shape);
+		collectPredicateShape(provenance, child, shape, subjectParameter);
 	}
 };
 const checkPropCall = (provenance, context, call) => {
@@ -2586,7 +2814,7 @@ const checkPropCall = (provenance, context, call) => {
 		usesCompilerProbe: false,
 		callsDomainFunction: false
 	};
-	collectPredicateShape(provenance, predicate.body, shape);
+	collectPredicateShape(provenance, predicate.body, shape, subjectParameterOf(predicate));
 	if (shape.usesCompilerProbe) {
 		context.report({
 			node: call,
@@ -2681,7 +2909,7 @@ const PROPERTY_FILE_KIND = {
 	suffix: PROPERTY_TEST_SUFFIX,
 	plainExpected: "it.prop(...) or it.effect.prop(...) — property files never mix with scenario tests",
 	plainFix: "move the scenario test to a plain *.test.ts file, or rewrite it as a property with arbitraries and a boolean-returning predicate",
-	rawFcExpected: "it.prop(...) or it.effect.prop(...) from @effect/vitest",
+	rawFcExpected: "it.prop(...) or it.effect.prop(...) from @systemfsoftware/vitest",
 	rawFcActualSuffix: "bypasses the vitest/Effect integration",
 	rawFcFix: "rewrite as it.prop(name, { of, subject, runs }, holds) returning a boolean; fc.* stays for building arbitraries (fc.pre, fc.stringMatching, ...)"
 };
@@ -2794,7 +3022,7 @@ const meta$6 = {
 	docs: { description: "A property test under src/ must be a single-segment <stem>.workflow.property.test.ts beside the <stem>.workflow.ts it covers; every other property-test basename is unsanctioned. A source file whose suffix names a cell listed in the cellsRequiringTest option must additionally carry an in-source vitest block; that list is empty by default, so the presence arm is opt-in per consumer." },
 	schema: [Schema.toJsonSchemaDocument(Options).schema],
 	messages: {
-		unsanctionedCell: MESSAGE$9,
+		unsanctionedCell: MESSAGE$8,
 		missingCellTest: ABSENCE_MESSAGE
 	}
 };
@@ -2855,7 +3083,7 @@ const testFileOutsideTestsDir = defineRule({
 		type: "problem",
 		docs: { description: "Test files outside src/ must live under a tests/ directory; free-standing test files have no sanctioned home." },
 		schema: [],
-		messages: { strayTestFile: MESSAGE$9 }
+		messages: { strayTestFile: MESSAGE$8 }
 	},
 	create(context) {
 		if (isUnderSrc(context.filename)) return {};
@@ -2877,24 +3105,25 @@ const testFileOutsideTestsDir = defineRule({
 });
 //#endregion
 //#region src/rules/test-suffix-outside-src.config.ts
-const UNSANCTIONED_SUFFIX_EXPECTED = "*.integration.test.ts, *.differential.test.ts, or *.trace.test.ts";
+const UNSANCTIONED_SUFFIX_EXPECTED = "*.integration.test.ts, *.contract.test.ts, *.differential.test.ts, *.trace.test.ts, or *.conformance.test.ts";
 const UNSANCTIONED_SUFFIX_ACTUAL = "another test suffix outside src/";
-const UNSANCTIONED_SUFFIX_FIX = "public surface -> *.integration.test.ts; parity -> *.differential.test.ts; span graph -> *.trace.test.ts; pure-cell property -> in-source; restated literal -> delete";
+const UNSANCTIONED_SUFFIX_FIX = "public surface -> *.integration.test.ts; real-oracle medium -> *.contract.test.ts (contract lane); parity -> *.differential.test.ts; span graph -> *.trace.test.ts; concurrent or stateful behaviour -> *.conformance.test.ts; pure-cell property -> in-source; restated literal -> delete";
 //#endregion
 //#region src/rules/test-suffix-outside-src.ts
 const testSuffixOutsideSrc = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Outside src/, a test file ends .integration.test.ts, .differential.test.ts, or .trace.test.ts." },
+		docs: { description: "Outside src/, a test file ends .integration.test.ts, .differential.test.ts, .trace.test.ts, or .conformance.test.ts. A runner-driving package (Vitest itself, the fork, effect-spec-runtime) keeps plain *.test.ts runners and nested-run probes, so the lane taxonomy does not apply there." },
 		schema: [],
-		messages: { unsanctionedSuffix: MESSAGE$9 }
+		messages: { unsanctionedSuffix: MESSAGE$8 }
 	},
 	create(context) {
 		const filename = context.filename;
 		if (isUnderSrc(filename)) return {};
+		if (isRawVitestPackage(filename)) return {};
 		const basename = basenameOf(filename);
 		if (!isTestFile(basename)) return {};
-		if (basename.endsWith(".integration.test.ts") || basename.endsWith(".differential.test.ts") || basename.endsWith(".trace.test.ts")) return {};
+		if (isBehaviourBasename(basename) || basename.endsWith(".differential.test.ts") || basename.endsWith(".trace.test.ts") || basename.endsWith(".conformance.test.ts")) return {};
 		return { Program(node) {
 			context.report({
 				node,
@@ -2921,7 +3150,7 @@ const testsDirHelpersInFixtures = defineRule({
 		type: "problem",
 		docs: { description: "Under tests/, the only non-test modules are helpers and fixtures, and they live inside tests/__fixtures__/." },
 		schema: [],
-		messages: { helperOutsideFixtures: MESSAGE$9 }
+		messages: { helperOutsideFixtures: MESSAGE$8 }
 	},
 	create(context) {
 		const filename = context.filename;
@@ -2954,7 +3183,7 @@ const meta$2 = {
 	type: "problem",
 	docs: { description: "Forbid package-level tests from relative-importing src or climbing into an internal folder" },
 	schema: [],
-	messages: { sourceReachIn: MESSAGE$9 }
+	messages: { sourceReachIn: MESSAGE$8 }
 };
 //#endregion
 //#region src/rules/tests-import-public-api.ts
@@ -3035,9 +3264,9 @@ const meta$1 = {
 	docs: { description: "A *.trace.test.ts must import its harness from @systemfsoftware/trace-spec and terminate cases on relation holds over the declared span graph. Raw emit calls (startSpan, spanBuilder, startActiveSpan) and HTTP status, statusText, or body assertions (expect(res.status).toBe(200), expect(res).toHaveProperty(\"status\", 200), expect(res).resolves.toMatchObject({ status: 200 }), expect(res).toEqual(expect.objectContaining({ status: 200 }))) are forbidden — replacing that altitude is what a trace spec exists for." },
 	schema: [],
 	messages: {
-		missingHarnessImport: MESSAGE$9,
-		httpTermination: MESSAGE$9,
-		rawEmitCall: MESSAGE$9
+		missingHarnessImport: MESSAGE$8,
+		httpTermination: MESSAGE$8,
+		rawEmitCall: MESSAGE$8
 	}
 };
 //#endregion
@@ -3233,27 +3462,27 @@ const traceTestRequiresTaxonomy = defineRule({
 	}
 });
 //#endregion
-//#region src/rules/vitest-from-effect-vitest.config.ts
+//#region src/rules/vitest-from-systemfsoftware-vitest.config.ts
 const MESSAGE = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
-const VIOLATION_NAME = "a value import from vitest";
-const VIOLATION_EXPECTED = "every test value imported from @effect/vitest, which re-exports all of Vitest";
-const VIOLATION_ACTUAL = "a named, namespace, default, side-effect or dynamic value import from vitest";
-const VIOLATION_FIX = "import it from @effect/vitest instead of vitest";
+const VIOLATION_NAME = "a value import from a foreign vitest runner";
+const VIOLATION_EXPECTED = "every test value imported from @systemfsoftware/vitest, which re-exports all of Vitest";
+const VIOLATION_ACTUAL = "a named, namespace, default, side-effect or dynamic value import from vitest or @effect/vitest";
+const VIOLATION_FIX = "import it from @systemfsoftware/vitest instead of vitest or @effect/vitest";
 const meta = {
 	type: "problem",
-	docs: { description: "Every value a test uses from Vitest is imported from @effect/vitest, which re-exports all of Vitest. Any value import from vitest — named, namespace, default, side-effect or dynamic — is refused; a type-only import stays legal." },
+	docs: { description: "Every value a test uses from Vitest is imported from @systemfsoftware/vitest, which re-exports all of Vitest. Any value import from vitest or the upstream @effect/vitest — named, namespace, default, side-effect or dynamic — is refused; a type-only import stays legal." },
 	schema: [],
 	messages: { vitestImport: MESSAGE }
 };
 //#endregion
-//#region src/rules/vitest-from-effect-vitest.ts
+//#region src/rules/vitest-from-systemfsoftware-vitest.ts
 const isTypeOnly = (node) => {
 	if (node.importKind === "type") return true;
 	if (node.specifiers.length === 0) return false;
 	return node.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type");
 };
-const isVitestLiteral = (node) => node.type === "Literal" && typeof node.value === "string" && node.value === "vitest";
-const vitestFromEffectVitest = defineRule({
+const isForeignVitestLiteral = (node) => node.type === "Literal" && typeof node.value === "string" && FOREIGN_VITEST_SOURCES[node.value] === true;
+const vitestFromSystemfsoftwareVitest = defineRule({
 	meta,
 	create(context) {
 		if (isRawVitestPackage(context.filename)) return {};
@@ -3271,12 +3500,22 @@ const vitestFromEffectVitest = defineRule({
 		};
 		return {
 			ImportDeclaration(node) {
-				if (node.source.value !== "vitest") return;
+				if (FOREIGN_VITEST_SOURCES[node.source.value] !== true) return;
 				if (isTypeOnly(node)) return;
 				report(node);
 			},
 			ImportExpression(node) {
-				if (!isVitestLiteral(node.source)) return;
+				if (!isForeignVitestLiteral(node.source)) return;
+				report(node);
+			},
+			ExportAllDeclaration(node) {
+				if (node.exportKind === "type") return;
+				if (FOREIGN_VITEST_SOURCES[node.source.value] !== true) return;
+				report(node);
+			},
+			ExportNamedDeclaration(node) {
+				if (node.source === null || node.exportKind === "type") return;
+				if (FOREIGN_VITEST_SOURCES[node.source.value] !== true) return;
 				report(node);
 			}
 		};
@@ -3307,11 +3546,12 @@ const recommendedRules = {
 	[rule("behaviour-exercises-use-case")]: "error",
 	[rule("behaviour-one-feature-per-file")]: "error",
 	[rule("tests-dir-helpers-in-fixtures")]: "error",
-	[rule("expect-boolean-predicate")]: "error",
-	[rule("vitest-from-effect-vitest")]: "error",
+	[rule("vitest-from-systemfsoftware-vitest")]: "error",
 	[rule("no-io-module-in-source-test")]: "error",
 	[rule("tests-import-public-api")]: "error",
 	[rule("differential-test-requires-harness")]: "error",
+	[rule("conformance-test-requires-harness")]: "error",
+	[rule("model-fixture-imports-subject")]: "error",
 	[rule("no-pseudo-gherkin-unit-tests")]: "error",
 	[rule("ban-raw-span-name-emit")]: "error",
 	[rule("trace-test-requires-taxonomy")]: "error"
@@ -3340,11 +3580,12 @@ var src_default = {
 		"behaviour-one-feature-per-file": behaviourOneFeaturePerFile,
 		"no-pseudo-gherkin-unit-tests": noPseudoGherkinUnitTests,
 		"tests-dir-helpers-in-fixtures": testsDirHelpersInFixtures,
-		"expect-boolean-predicate": expectBooleanPredicate,
-		"vitest-from-effect-vitest": vitestFromEffectVitest,
+		"vitest-from-systemfsoftware-vitest": vitestFromSystemfsoftwareVitest,
 		"no-io-module-in-source-test": noIoModuleInSourceTest,
 		"tests-import-public-api": testsImportPublicApi,
 		"differential-test-requires-harness": differentialTestRequiresHarness,
+		"conformance-test-requires-harness": conformanceTestRequiresHarness,
+		"model-fixture-imports-subject": modelFixtureImportsSubject,
 		"ban-raw-span-name-emit": banRawSpanNameEmit,
 		"trace-test-requires-taxonomy": traceTestRequiresTaxonomy
 	},

package/dist/oxlint-plugin-test-discipline-untrimmed.d.ts

@@ -26,11 +26,12 @@ declare const _default: {
         'behaviour-one-feature-per-file': Rule;
         'no-pseudo-gherkin-unit-tests': Rule;
         'tests-dir-helpers-in-fixtures': Rule;
-        'expect-boolean-predicate': Rule;
-        'vitest-from-effect-vitest': Rule;
+        'vitest-from-systemfsoftware-vitest': Rule;
         'no-io-module-in-source-test': Rule;
         'tests-import-public-api': Rule;
         'differential-test-requires-harness': Rule;
+        'conformance-test-requires-harness': Rule;
+        'model-fixture-imports-subject': Rule;
         'ban-raw-span-name-emit': Rule;
         'trace-test-requires-taxonomy': Rule;
     };

package/dist/oxlint-plugin-test-discipline.d.ts

@@ -26,11 +26,12 @@ declare const _default: {
         'behaviour-one-feature-per-file': Rule;
         'no-pseudo-gherkin-unit-tests': Rule;
         'tests-dir-helpers-in-fixtures': Rule;
-        'expect-boolean-predicate': Rule;
-        'vitest-from-effect-vitest': Rule;
+        'vitest-from-systemfsoftware-vitest': Rule;
         'no-io-module-in-source-test': Rule;
         'tests-import-public-api': Rule;
         'differential-test-requires-harness': Rule;
+        'conformance-test-requires-harness': Rule;
+        'model-fixture-imports-subject': Rule;
         'ban-raw-span-name-emit': Rule;
         'trace-test-requires-taxonomy': Rule;
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/oxlint-plugin-test-discipline",
   "license": "Apache-2.0",
-  "version": "3.9.0",
+  "version": "4.0.1",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -45,12 +45,12 @@
     "@microsoft/api-extractor": "^7.59.1",
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
     "@systemfsoftware/stryker-config": "^0.1.0",
-    "@systemfsoftware/stryker-ignorer-effect-schema-declarations": "^0.1.1",
-    "@systemfsoftware/stryker-ignorer-in-source-vitest-block": "^0.1.1",
-    "@systemfsoftware/stryker-js": "^10.1.1",
-    "@systemfsoftware/stryker-js-typescript-checker": "^7.0.5",
-    "@systemfsoftware/stryker-js-vitest-runner": "^7.1.1",
-    "@systemfsoftware/stryker-test-contribution": "^3.0.3",
+    "@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",
@@ -69,6 +69,7 @@
     "typescript": ">=5.0.0"
   },
   "publishConfig": {
+    "access": "public",
     "provenance": true
   },
   "scripts": {