@systemfsoftware/oxlint-plugin-test-discipline 3.5.1 → 3.6.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# @systemfsoftware/oxlint-plugin-test-discipline
+
+## 3.6.0
+
+### Minor Changes
+
+- New rule `differential-test-requires-harness` (recommended, error): a `.differential.test.ts` file must import and invoke `@systemfsoftware/differential-spec` (`Differential.compare` / `Metamorphic.on`) and must not call raw test runners. `test-suffix-outside-src` now sanctions the `.differential.test.ts` altitude alongside `.integration.test.ts`, and `property-file-purity` treats differential files as property files.
+
+- Publish standalone domain-aligned oxlint plugins and shareable configurations for Effect Schema, DMMF workflows, Effect Platform runtime entrypoints, test discipline, and Cell Architecture.
+
+  Consolidates and supersedes the 12 retired legacy packages (`@systemfsoftware/all`, `@systemfsoftware/oxlint-config`, `@systemfsoftware/oxlint-plugin`, `@systemfsoftware/oxlint-plugin-recommended`, `@systemfsoftware/oxlint-plugin-effect-dmmf`, `@systemfsoftware/oxlint-plugin-effect-native`, `@systemfsoftware/oxlint-plugin-effect-entrypoint`, `@systemfsoftware/oxlint-plugin-effect-workflow`, `@systemfsoftware/oxlint-plugin-property-testing`, `@systemfsoftware/oxlint-plugin-structure`, `@systemfsoftware/oxlint-plugin-tag-discipline`, `@systemfsoftware/oxlint-plugin-test-hygiene`, `@systemfsoftware/oxlint-plugin-test-placement`).

package/README.md

@@ -4,23 +4,25 @@ 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` — the one behaviour suffix.                                                                                                                                                                                                                                                                                                 |
-| `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.                                                                                                                                                                                                                                                                   |
-| `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           |
-| ----------------------------- | --------- | ------------------------ | ------------------ |
-| `*.workflow.property.test.ts` | Property  | none — pure core         | ONLY under `src/`  |
-| `*.integration.test.ts`       | Behaviour | permitted, at ports only | NEVER under `src/` |
+| 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` or `.differential.test.ts` — the two 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.                                                                                                                                                                      |
+
+| suffix                        | layer        | doubles                  | location           |
+| ----------------------------- | ------------ | ------------------------ | ------------------ |
+| `*.workflow.property.test.ts` | Property     | none — pure core         | ONLY under `src/`  |
+| `*.integration.test.ts`       | Behaviour    | permitted, at ports only | NEVER under `src/` |
+| `*.differential.test.ts`      | Differential | permitted, at ports only | NEVER under `src/` |
 
 ## Enrollment
 

package/dist/index.d.ts

@@ -27,6 +27,7 @@ declare const _default: {
     'tests-dir-helpers-in-fixtures': 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;
   };
   configs: {
     recommended: {

package/dist/index.mjs

@@ -12,6 +12,7 @@ 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
 * `*.schema.test.ts` only ever restates coverage that already exists.
@@ -26,6 +27,7 @@ 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 FOREIGN_RUNNERS = /* @__PURE__ */ new Set(["vitest", "@effect/vitest"]);
 const RUNNER_NAMES = /* @__PURE__ */ new Set([
 	"it",
@@ -40,7 +42,7 @@ const NO_SUBJECT_IMPORT_NAME = "a *.integration.test.ts that reaches no package
 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_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$22 = {
+const meta$23 = {
 	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: [],
@@ -153,7 +155,7 @@ const DIST_SEGMENT = /(?:^|\/)dist\//;
 * path names nothing satisfies the rule the same way a real one does.
 */
 const behaviourExercisesUseCase = defineRule({
-	meta: meta$22,
+	meta: meta$23,
 	create(context) {
 		let reached = false;
 		return {
@@ -203,7 +205,7 @@ 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$21 = {
+const meta$22 = {
 	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: [],
@@ -248,7 +250,7 @@ const hasAnyFeatureCall = (program) => {
 	return false;
 };
 const behaviourOneFeaturePerFile = defineRule({
-	meta: meta$21,
+	meta: meta$22,
 	create(context) {
 		return { "Program:exit"(node) {
 			if (!isBehaviourTest$2(basenameOf(context.filename))) return;
@@ -289,7 +291,7 @@ 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$20 = {
+const meta$21 = {
 	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." },
 	schema: [],
@@ -317,7 +319,7 @@ const foreignRunnerNameOf = (specifier) => {
 };
 const isBehaviourTest$1 = (basename) => basename.endsWith(INTEGRATION_SUFFIX);
 const behaviourTestRequiresGherkin = defineRule({
-	meta: meta$20,
+	meta: meta$21,
 	create(context) {
 		const basename = basenameOf(context.filename);
 		return { Program(node) {
@@ -380,7 +382,7 @@ const INVALID_BEHAVIOR_CASE_FIX = "Convert behavior to PascalCase (e.g., throwEr
 const INVALID_CONDITION_CASE_FIX = "Convert condition to PascalCase (e.g., passwordInvalid → PasswordInvalid)";
 const EMPTY_BEHAVIOR_ACTUAL = "Empty string between Should_ and _When_";
 const EMPTY_CONDITION_ACTUAL = "Empty string after _When_";
-const meta$19 = {
+const meta$20 = {
 	type: "suggestion",
 	docs: { description: "Enforce DAMP (Descriptive and Meaningful Phrases) test naming format: Should_[ExpectedBehavior]_When_[Condition]" },
 	schema: [],
@@ -460,7 +462,7 @@ const isTestFunctionCall = (node) => {
 	return false;
 };
 const dampTestNaming = defineRule({
-	meta: meta$19,
+	meta: meta$20,
 	create(context) {
 		return { CallExpression(node) {
 			if (!isTestFunctionCall(node)) return;
@@ -482,6 +484,100 @@ const dampTestNaming = defineRule({
 	}
 });
 //#endregion
+//#region src/rules/differential-test-requires-harness.config.ts
+const meta$19 = {
+	type: "problem",
+	docs: { description: "Differential tests must use @systemfsoftware/differential-spec harness. Raw runner calls (it, test, describe, and member forms like it.effect) and direct runner imports are forbidden in *.differential.test.ts files; importing the harness without invoking it is equally non-compliant." },
+	schema: [],
+	messages: {
+		rawRunnerCall: "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.",
+		runnerImport: "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.",
+		missingHarnessImport: "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.",
+		missingHarnessUsage: "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}."
+	}
+};
+//#endregion
+//#region src/rules/differential-test-requires-harness.ts
+const HARNESS_PRESCRIPTION = "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 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 differentialTestRequiresHarness = defineRule({
+	meta: meta$19,
+	create(context) {
+		if (!context.filename.endsWith(".differential.test.ts")) return {};
+		const harnessBindings = /* @__PURE__ */ new Set();
+		let violations = 0;
+		let hasHarnessInvocation = false;
+		return {
+			ImportDeclaration(node) {
+				if (isForeignRunnerImport(node)) {
+					context.report({
+						node,
+						messageId: "runnerImport",
+						data: {
+							name: `runner import from ${String(node.source.value)} in a differential test file`,
+							expected: HARNESS_PRESCRIPTION,
+							actual: "a direct vitest / @effect/vitest runner import bypasses the differential oracle",
+							fix: `delete the runner import; ${HARNESS_PRESCRIPTION}`
+						}
+					});
+					violations += 1;
+					return;
+				}
+				recordHarnessBindings(node, harnessBindings);
+			},
+			CallExpression(node) {
+				const name = calleeName(node.callee);
+				if (name !== void 0 && RUNNER_NAMES.has(name)) {
+					context.report({
+						node,
+						messageId: "rawRunnerCall",
+						data: {
+							name: `raw runner call (${name}) in a differential test file`,
+							expected: HARNESS_PRESCRIPTION,
+							actual: `${name}(...) bypasses the differential oracle`,
+							fix: `rewrite using ${HARNESS_PRESCRIPTION}`
+						}
+					});
+					violations += 1;
+					return;
+				}
+				if (name !== void 0 && harnessBindings.has(name)) hasHarnessInvocation = true;
+			},
+			"Program:exit"(node) {
+				if (harnessBindings.size === 0) {
+					context.report({
+						node,
+						messageId: "missingHarnessImport",
+						data: {
+							name: `differential test file without ${DIFFERENTIAL_PACKAGE} import`,
+							expected: HARNESS_PRESCRIPTION,
+							actual: "no differential harness import found",
+							fix: HARNESS_PRESCRIPTION
+						}
+					});
+					return;
+				}
+				if (!hasHarnessInvocation && violations === 0) context.report({
+					node,
+					messageId: "missingHarnessUsage",
+					data: {
+						name: `differential test file imports ${DIFFERENTIAL_PACKAGE} but never invokes it`,
+						expected: HARNESS_PRESCRIPTION,
+						actual: "the harness is imported but no Differential.compare or Metamorphic.on chain runs",
+						fix: HARNESS_PRESCRIPTION
+					}
+				});
+			}
+		};
+	}
+});
+//#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";
@@ -2327,7 +2423,8 @@ const checkPropCall = (provenance, context, call) => {
 		});
 		return;
 	}
-	if (!shape.callsDomainFunction) context.report({
+	if (shape.callsDomainFunction) return;
+	context.report({
 		node: call,
 		messageId: "noDomainFunction",
 		data: {
@@ -2403,45 +2500,64 @@ const RAW_FC_METHODS = /* @__PURE__ */ new Set([
 	"property",
 	"asyncProperty"
 ]);
-const reportPlain = (context, node, messageId, actual) => {
+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",
+	rawFcActualSuffix: "bypasses the vitest/Effect integration",
+	rawFcFix: "rewrite as it.prop(name, [arbitraries], predicate) returning a boolean; fc.* stays for building arbitraries (fc.pre, fc.stringMatching, ...)"
+};
+const DIFFERENTIAL_FILE_KIND = {
+	suffix: DIFFERENTIAL_SUFFIX,
+	plainExpected: "the differential harness — Differential.compare(...).on(arb).assert(oracle) or Metamorphic.on(system).relation(...).on(arb)",
+	plainFix: "rewrite via @systemfsoftware/differential-spec; scenario tests do not belong in a differential file",
+	rawFcExpected: "the harness owns fast-check — pass an fc.Arbitrary to the harness, never call fc.assert/fc.check directly",
+	rawFcActualSuffix: "bypasses the differential harness oracle",
+	rawFcFix: "build the arbitrary in tests/__fixtures__ and hand it to Differential.compare(...).on(arb) or Metamorphic.on(...).relation(...).on(arb)"
+};
+const reportPlain = (context, node, messageId, actual, kind) => {
 	context.report({
 		node,
 		messageId,
 		data: {
-			name: `scenario test (${actual}) in a ${PROPERTY_TEST_SUFFIX} file`,
-			expected: "it.prop(...) or it.effect.prop(...) — property files never mix with scenario tests",
+			name: `scenario test (${actual}) in a ${kind.suffix} file`,
+			expected: kind.plainExpected,
 			actual: `${actual} runs a single example, not a property`,
-			fix: "move the scenario test to a plain *.test.ts file, or rewrite it as a property with arbitraries and a boolean-returning predicate"
+			fix: kind.plainFix
+		}
+	});
+};
+const reportRawFc = (context, node, method, kind) => {
+	context.report({
+		node,
+		messageId: "rawFastCheck",
+		data: {
+			name: `raw fc.${method}(...) in a ${kind.suffix} file`,
+			expected: kind.rawFcExpected,
+			actual: `fc.${method}(...) ${kind.rawFcActualSuffix}`,
+			fix: kind.rawFcFix
 		}
 	});
 };
-const createPropertyFileVisitors = (context) => ({ CallExpression(node) {
+const createPropertyFileVisitors = (context, kind) => ({ CallExpression(node) {
 	const callee = node.callee;
 	if (callee.type === "Identifier") {
-		if (callee.name === "it" || callee.name === "test") reportPlain(context, node, "plainIt", `${callee.name}(...)`);
+		if (callee.name === "it" || callee.name === "test") reportPlain(context, node, "plainIt", `${callee.name}(...)`, kind);
 		return;
 	}
 	if (callee.type !== "MemberExpression" || callee.property.type !== "Identifier") return;
 	const object = callee.object;
 	if (object.type === "Identifier" && object.name === "fc" && RAW_FC_METHODS.has(callee.property.name)) {
-		context.report({
-			node,
-			messageId: "rawFastCheck",
-			data: {
-				name: `raw fc.${callee.property.name}(...) in a ${PROPERTY_TEST_SUFFIX} file`,
-				expected: "it.prop(...) or it.effect.prop(...) from @effect/vitest",
-				actual: `fc.${callee.property.name}(...) bypasses the vitest/Effect integration`,
-				fix: "rewrite as it.prop(name, [arbitraries], predicate) returning a boolean; fc.* stays for building arbitraries (fc.pre, fc.stringMatching, ...)"
-			}
-		});
+		reportRawFc(context, node, callee.property.name, kind);
 		return;
 	}
 	if (object.type === "Identifier" && object.name === "it") {
-		if (callee.property.name === "effect") reportPlain(context, node, "plainEffectIt", "it.effect(...)");
-		else if (PROP_MODIFIERS.has(callee.property.name)) reportPlain(context, node, "plainIt", `it.${callee.property.name}(...)`);
+		if (callee.property.name === "effect") reportPlain(context, node, "plainEffectIt", "it.effect(...)", kind);
+		else if (PROP_MODIFIERS.has(callee.property.name)) reportPlain(context, node, "plainIt", `it.${callee.property.name}(...)`, kind);
 		return;
 	}
-	if (PROP_MODIFIERS.has(callee.property.name) && object.type === "MemberExpression" && object.object.type === "Identifier" && object.object.name === "it" && object.property.type === "Identifier" && object.property.name === "effect") reportPlain(context, node, "plainEffectIt", `it.effect.${callee.property.name}(...)`);
+	if (PROP_MODIFIERS.has(callee.property.name) && object.type === "MemberExpression" && object.object.type === "Identifier" && object.object.name === "it" && object.property.type === "Identifier" && object.property.name === "effect") reportPlain(context, node, "plainEffectIt", `it.effect.${callee.property.name}(...)`, kind);
 } });
 const FAST_CHECK_IMPORT_DATA = {
 	name: "FastCheck import in a scenario test file",
@@ -2478,11 +2594,12 @@ const createScenarioFileVisitors = (context) => ({
 		});
 	}
 });
+const kindOf = (filename) => filename.endsWith(".differential.test.ts") ? DIFFERENTIAL_FILE_KIND : PROPERTY_FILE_KIND;
 const propertyFilePurity = defineRule({
 	meta: meta$5,
 	create(context) {
-		if (!Array$1.last(context.filename.split("/")).pipe(Option.exists((base) => base.includes(".test.") || base.includes(".spec.")))) return {};
-		if (context.filename.endsWith(".property.test.ts")) return createPropertyFileVisitors(context);
+		if (!isTestFile(basenameOf(context.filename))) return {};
+		if (context.filename.endsWith(".property.test.ts") || context.filename.endsWith(".differential.test.ts")) return createPropertyFileVisitors(context, kindOf(context.filename));
 		return createScenarioFileVisitors(context);
 	}
 });
@@ -2583,26 +2700,25 @@ const testFileOutsideTestsDir = defineRule({
 });
 //#endregion
 //#region src/rules/test-suffix-outside-src.config.ts
-const UNSANCTIONED_SUFFIX_EXPECTED = "exactly *.integration.test.ts outside src/";
+const UNSANCTIONED_SUFFIX_EXPECTED = "exactly *.integration.test.ts or *.differential.test.ts outside src/";
 const UNSANCTIONED_SUFFIX_ACTUAL = "an unsanctioned test suffix outside src/";
-const UNSANCTIONED_SUFFIX_FIX = "name what this file exercises. Every scenario restates a literal from a pure cell (a lookup-table entry, a constant, a mapping) -> it is a change detector, not a test: delete it. It drives the package through its public surface -> rename it *.integration.test.ts, the one behaviour suffix, whether or not a layer doubles at a port. It is a property over a pure cell -> it does not belong outside src/: convert it to an in-source if (import.meta.vitest) block in the module it covers";
+const UNSANCTIONED_SUFFIX_FIX = "name what this file exercises. Every scenario restates a literal from a pure cell (a lookup-table entry, a constant, a mapping) -> it is a change detector, not a test: delete it. It drives the package through its public surface -> rename it *.integration.test.ts, the one behaviour suffix, whether or not a layer doubles at a port. It proves parity or a metamorphic relation between implementations -> rename it *.differential.test.ts and express it through @systemfsoftware/differential-spec. It is a property over a pure cell -> it does not belong outside src/: convert it to an in-source if (import.meta.vitest) block in the module it covers";
 //#endregion
 //#region src/rules/test-suffix-outside-src.ts
 const testSuffixOutsideSrc = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Outside src/, a test file must end .integration.test.ts — the one behaviour suffix. Whether the layer doubles at a port is a judgement the suffix no longer encodes." },
+		docs: { description: "Outside src/, a test file must end .integration.test.ts or .differential.test.ts. Integration is the behaviour suffix; differential is the parity/metamorphic suffix driven by @systemfsoftware/differential-spec. Whether the layer doubles at a port is a judgement the suffix no longer encodes." },
 		schema: [],
 		messages: { unsanctionedSuffix: MESSAGE$7 }
 	},
 	create(context) {
 		const filename = context.filename;
+		if (isUnderSrc(filename)) return {};
 		const basename = basenameOf(filename);
-		const suffixIsAllowed = basename.endsWith(INTEGRATION_SUFFIX);
+		if (!isTestFile(basename)) return {};
+		if (basename.endsWith(".integration.test.ts") || basename.endsWith(".differential.test.ts")) return {};
 		return { Program(node) {
-			if (isUnderSrc(filename)) return;
-			if (!isTestFile(basename)) return;
-			if (suffixIsAllowed) return;
 			context.report({
 				node,
 				messageId: "unsanctionedSuffix",
@@ -2741,7 +2857,8 @@ const recommendedRules = {
 	[rule("behaviour-one-feature-per-file")]: "error",
 	[rule("tests-dir-helpers-in-fixtures")]: "error",
 	[rule("no-io-module-in-source-test")]: "error",
-	[rule("tests-import-public-api")]: "error"
+	[rule("tests-import-public-api")]: "error",
+	[rule("differential-test-requires-harness")]: "error"
 };
 var src_default = {
 	meta: { name: PLUGIN_NAME },
@@ -2768,7 +2885,8 @@ var src_default = {
 		"no-pseudo-gherkin-unit-tests": noPseudoGherkinUnitTests,
 		"tests-dir-helpers-in-fixtures": testsDirHelpersInFixtures,
 		"no-io-module-in-source-test": noIoModuleInSourceTest,
-		"tests-import-public-api": testsImportPublicApi
+		"tests-import-public-api": testsImportPublicApi,
+		"differential-test-requires-harness": differentialTestRequiresHarness
 	},
 	configs: { recommended: { rules: recommendedRules } }
 };

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

@@ -28,6 +28,7 @@ declare const _default: {
         'tests-dir-helpers-in-fixtures': Rule;
         'no-io-module-in-source-test': Rule;
         'tests-import-public-api': Rule;
+        'differential-test-requires-harness': Rule;
     };
     configs: {
         recommended: {

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

@@ -28,6 +28,7 @@ declare const _default: {
         'tests-dir-helpers-in-fixtures': Rule;
         'no-io-module-in-source-test': Rule;
         'tests-import-public-api': Rule;
+        'differential-test-requires-harness': Rule;
     };
     configs: {
         recommended: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/oxlint-plugin-test-discipline",
   "license": "Apache-2.0",
-  "version": "3.5.1",
+  "version": "3.6.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -59,10 +59,10 @@
     "tsdown": "^0.23.0",
     "typescript": "^7",
     "vitest": "^5",
-    "@systemfsoftware/stryker-config": "^0.1.0",
+    "@systemfsoftware/tsconfig": "^1.3.6",
     "@systemfsoftware/tsdown-config": "^0.1.0",
     "@systemfsoftware/vitest-config": "^0.1.0",
-    "@systemfsoftware/tsconfig": "^1.3.6"
+    "@systemfsoftware/stryker-config": "^0.1.0"
   },
   "peerDependencies": {
     "effect": "4.0.0-rc.116",

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

@@ -1,32 +0,0 @@
-import { Rule } from '@oxlint/plugins';
-
-declare const _default: {
-    meta: {
-        name: string;
-    };
-    rules: {
-        'in-source-test-prop-only': Rule;
-        'in-source-test-targets-private': Rule;
-        'no-test-file-in-src': Rule;
-        'src-property-test-cell': Rule;
-        'test-file-outside-tests-dir': Rule;
-        'test-suffix-outside-src': Rule;
-        'behaviour-test-requires-gherkin': Rule;
-        'behaviour-exercises-use-case': Rule;
-        'behaviour-one-feature-per-file': Rule;
-        'no-pseudo-gherkin-unit-tests': Rule;
-        'tests-dir-helpers-in-fixtures': Rule;
-        'no-io-module-in-source-test': Rule;
-        'tests-import-public-api': Rule;
-    };
-    configs: {
-        recommended: {
-            rules: {
-                readonly [x: string]: "error";
-            };
-        };
-    };
-};
-export default _default;
-
-export { }

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

@@ -1,32 +0,0 @@
-import { Rule } from '@oxlint/plugins';
-
-declare const _default: {
-    meta: {
-        name: string;
-    };
-    rules: {
-        'in-source-test-prop-only': Rule;
-        'in-source-test-targets-private': Rule;
-        'no-test-file-in-src': Rule;
-        'src-property-test-cell': Rule;
-        'test-file-outside-tests-dir': Rule;
-        'test-suffix-outside-src': Rule;
-        'behaviour-test-requires-gherkin': Rule;
-        'behaviour-exercises-use-case': Rule;
-        'behaviour-one-feature-per-file': Rule;
-        'no-pseudo-gherkin-unit-tests': Rule;
-        'tests-dir-helpers-in-fixtures': Rule;
-        'no-io-module-in-source-test': Rule;
-        'tests-import-public-api': Rule;
-    };
-    configs: {
-        recommended: {
-            rules: {
-                readonly [x: string]: "error";
-            };
-        };
-    };
-};
-export default _default;
-
-export { }