@systemfsoftware/oxlint-plugin-test-discipline 3.5.1

package/dist/index.mjs

@@ -0,0 +1,2776 @@
+import { defineRule } from "@oxlint/plugins";
+import { Array as Array$1, Effect, Option, Schema } from "effect";
+//#region src/rules/path.config.ts
+const TEST_BASENAME = /\.(?:test|spec)\.[cm]?tsx?$/;
+const SANCTIONED_TEST_DIRS = /* @__PURE__ */ new Set(["tests"]);
+/**
+* The only test location sanctioned under `src/`. A workflow property test
+* earns colocation with the workflow it covers, but not adjacency: it lives in
+* a `__tests__` directory beside that workflow, never as a sibling file.
+*/
+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";
+/**
+* Forbidden outright. A schema's laws are generated, so a hand-written
+* `*.schema.test.ts` only ever restates coverage that already exists.
+*/
+const SCHEMA_SUFFIX = ".schema.test.ts";
+/**
+* The one property-test basename sanctioned under `src/`: a single-segment
+* stem, then `.workflow.property.test.ts`, beside the `<stem>.workflow.ts` it
+* covers. Every other test file under `src/` is banned; a kernel, policy, or
+* schema suite has no file home and becomes an in-source `import.meta.vitest`
+* block in the module it covers.
+*/
+const WORKFLOW_TEST_BASENAME = /^[^.]+\.workflow\.property\.test\.ts$/;
+const GHERKIN_PACKAGE = "@systemfsoftware/effect-gherkin-spec";
+const FOREIGN_RUNNERS = /* @__PURE__ */ new Set(["vitest", "@effect/vitest"]);
+const RUNNER_NAMES = /* @__PURE__ */ new Set([
+	"it",
+	"test",
+	"describe"
+]);
+const MESSAGE$7 = "{{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_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 = {
+	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$7 }
+};
+//#endregion
+//#region src/rules/path.ts
+const PathSegments = Schema.NonEmptyArray(Schema.String);
+const segmentsOf = (filename) => Schema.decodeUnknownSync(PathSegments)(filename.split("/"));
+const basenameOf = (filename) => Array$1.lastNonEmpty(segmentsOf(filename));
+/** Directory segments only — the basename never counts as a directory. */
+const directoriesOf = (filename) => Array$1.initNonEmpty(segmentsOf(filename));
+const isUnderSrc = (filename) => directoriesOf(filename).includes("src");
+const isInSanctionedTestDir = (filename) => directoriesOf(filename).some((segment) => SANCTIONED_TEST_DIRS.has(segment));
+const isInTestsImportScope = (filename) => {
+	const segments = segmentsOf(filename);
+	const directories = Array$1.initNonEmpty(segments);
+	if (directories.some((segment) => segment === "src")) return false;
+	return isTestFile(Array$1.lastNonEmpty(segments)) || directories.some((segment) => TEST_TREE_DIRS.has(segment));
+};
+const isInConfiguredTestDir = (filename, dirs) => directoriesOf(filename).some((segment) => dirs.includes(segment));
+const isTestFile = (basename) => TEST_BASENAME.test(basename);
+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,
+	GHERKIN_PACKAGE,
+	EFFECT_PACKAGE
+]);
+/**
+* The runner, the spec DSL and effect itself - the scaffolding every behaviour
+* file imports. `effect/testing` and every other subpath counts too: a subpath
+* is still the same dependency, and admitting it would let a file satisfy the
+* rule by importing an arbitrary. A `node:` builtin is scaffolding as well: it
+* is part of the environment, not of the package, and a file whose only
+* non-runner import is `node:assert` still never touches the package under
+* test. Whether `node:child_process` legitimately reaches a CLI's behaviour is
+* a decision for the file's other imports - the builtin itself never does.
+*
+* The gherkin spec package is scaffolding for every other package's tests. A
+* behaviour file that lives inside that package and imports the package name
+* is exercising the package under test, not importing a runner.
+*/
+const isGherkinPackageTree = (filename) => filename.includes("/gherkin/effect/") || filename.includes("/effect-gherkin-spec/");
+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(/\.[^/]+$/, "");
+/**
+* A relative module specifier resolved against the linted file's directory,
+* with `..` 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 sourceResolvesToItself = (source, filename) => {
+	if (!source.startsWith(".")) return false;
+	if (source.startsWith("/")) return false;
+	const stack = filename.slice(0, Math.max(0, filename.lastIndexOf("/"))).split("/");
+	for (const segment of source.split("/")) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") {
+			if (stack.length > 0) stack.pop();
+		} else stack.push(segment);
+	}
+	return stemOf(stack.join("/")) === stemOf(filename);
+};
+/**
+* `import type` is erased before anything executes; `import { type X, Y }` still
+* binds the value `Y`. Zero specifiers is a side-effect import - it executes the
+* module it names, so it reaches whatever that module is.
+*/
+const hasRuntimeSpecifier = (statement) => {
+	if (statement.specifiers.length === 0) return true;
+	return statement.specifiers.some((spec) => !(spec.type === "ImportSpecifier" && spec.importKind === "type"));
+};
+/**
+* A path segment naming the package's build output. Keyed on the emitted directory
+* rather than a filename, so a renamed entry is followed automatically.
+*/
+const DIST_SEGMENT = /(?:^|\/)dist\//;
+/**
+* Reports a behaviour file that reaches no package code at all.
+*
+* This deliberately stops short of the convention it serves. The convention is
+* that a behaviour test drives a real use case through the I/O sandwich, and the
+* earlier form of this rule claimed to enforce it by requiring an import whose
+* basename ended in `Executor`, `Handler`, `Adapter`, `Store` or `Middleware`.
+* A probe settled that: a pure kernel named `ZzPureAdapter.ts`, imported by a
+* behaviour test that touched nothing else, was admitted in silence. The gate
+* read a filename its own author chose, so renaming a kernel bought a pass and
+* nothing recomputed whether the module did any I/O. Which side of the sandwich
+* an imported module sits on is not decidable from the importing file's syntax -
+* one file holds no cross-file or type information - so the rule states the part
+* that is: whether the file reaches the package under test. That the reached
+* module is a shell is a review matter, and the role word in a shell module's
+* 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.
+*/
+const behaviourExercisesUseCase = defineRule({
+	meta: meta$22,
+	create(context) {
+		let reached = false;
+		return {
+			ImportExpression(node) {
+				if (node.source.type !== "Literal" || typeof node.source.value !== "string") {
+					reached = true;
+					return;
+				}
+				if (!isFoundationImport(node.source.value, context.filename)) reached = true;
+			},
+			Literal(node) {
+				if (typeof node.value === "string" && DIST_SEGMENT.test(node.value)) reached = true;
+			},
+			"Program:exit"(node) {
+				if (!isBehaviourTest$3(basenameOf(context.filename))) return;
+				if (reached) return;
+				for (const statement of node.body) {
+					if (statement.type !== "ImportDeclaration") continue;
+					if (statement.importKind === "type") continue;
+					const source = statement.source.value;
+					if (isFoundationImport(source, context.filename)) continue;
+					if (sourceResolvesToItself(source, context.filename)) continue;
+					if (!hasRuntimeSpecifier(statement)) continue;
+					return;
+				}
+				context.report({
+					node: node.body[0] ?? node,
+					messageId: "noSubjectImport",
+					data: {
+						name: NO_SUBJECT_IMPORT_NAME,
+						expected: NO_SUBJECT_IMPORT_EXPECTED,
+						actual: NO_SUBJECT_IMPORT_ACTUAL,
+						fix: NO_SUBJECT_IMPORT_FIX
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/behaviour-one-feature-per-file.config.ts
+const TOO_FEW_FEATURES_NAME = "a *.integration.test.ts that constructs no Feature";
+const TOO_FEW_FEATURES_EXPECTED = "exactly one Feature(...) — the capability the file proves";
+const TOO_FEW_FEATURES_ACTUAL = "a behaviour file with zero Feature(...) calls";
+const TOO_FEW_FEATURES_FIX = "one file, one capability. A Feature is what the file is for; if there is none, the file is not a behaviour test — delete it or add the missing Feature call.";
+const TOO_MANY_FEATURES_NAME = "a *.integration.test.ts accumulating multiple Feature(...) calls";
+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 = {
+	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$7,
+		tooManyFeatures: MESSAGE$7
+	}
+};
+//#endregion
+//#region src/rules/behaviour-one-feature-per-file.ts
+const rootCalleeName = (callee) => {
+	const descend = (current) => {
+		if (current.type === "CallExpression") return descend(current.callee);
+		if (current.type === "MemberExpression") return descend(current.object);
+		return current;
+	};
+	const root = descend(callee);
+	return root.type === "Identifier" ? root.name : null;
+};
+const isFeatureCallStatement = (statement) => {
+	if (statement.type !== "ExpressionStatement") return false;
+	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) {
+		if (!isFeatureCallStatement(statement)) continue;
+		seen += 1;
+		if (seen === 2) return statement;
+	}
+	return null;
+};
+const countFeatureCalls = (program) => {
+	let count = 0;
+	for (const statement of program.body) if (isFeatureCallStatement(statement)) count += 1;
+	return count;
+};
+const hasAnyFeatureCall = (program) => {
+	for (const statement of program.body) if (isFeatureCallStatement(statement)) return true;
+	return false;
+};
+const behaviourOneFeaturePerFile = defineRule({
+	meta: meta$21,
+	create(context) {
+		return { "Program:exit"(node) {
+			if (!isBehaviourTest$2(basenameOf(context.filename))) return;
+			const excess = findSecondFeatureCall(node);
+			if (excess !== null) {
+				const total = countFeatureCalls(node);
+				context.report({
+					node: excess,
+					messageId: "tooManyFeatures",
+					data: {
+						name: TOO_MANY_FEATURES_NAME,
+						expected: TOO_MANY_FEATURES_EXPECTED,
+						actual: `${TOO_MANY_FEATURES_ACTUAL} (${total} found)`,
+						fix: TOO_MANY_FEATURES_FIX
+					}
+				});
+				return;
+			}
+			if (!hasAnyFeatureCall(node)) context.report({
+				node: node.body[0] ?? node,
+				messageId: "tooFewFeatures",
+				data: {
+					name: TOO_FEW_FEATURES_NAME,
+					expected: TOO_FEW_FEATURES_EXPECTED,
+					actual: TOO_FEW_FEATURES_ACTUAL,
+					fix: TOO_FEW_FEATURES_FIX
+				}
+			});
+		} };
+	}
+});
+//#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 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 = {
+	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: [],
+	messages: {
+		foreignRunner: MESSAGE$7,
+		missingMakeFeature: MESSAGE$7
+	}
+};
+//#endregion
+//#region src/rules/behaviour-test-requires-gherkin.ts
+const ImportedIdentifier = Schema.Struct({ name: Schema.String });
+const isMakeFeatureSpecifier = (specifier) => {
+	const imported = specifier.imported;
+	return imported.type === "Identifier" && imported.name === "makeFeature";
+};
+/**
+* `null` for any specifier that cannot name a runner. The decode is unreachable
+* for a string-literal import name because the narrowing above rejects it first;
+* it exists so removing that narrowing fails loudly instead of silently.
+*/
+const foreignRunnerNameOf = (specifier) => {
+	if (specifier.imported.type !== "Identifier") return null;
+	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$20,
+	create(context) {
+		const basename = basenameOf(context.filename);
+		return { Program(node) {
+			if (!isBehaviourTest$1(basename)) return;
+			let hasMakeFeature = false;
+			for (const statement of node.body) {
+				if (statement.type !== "ImportDeclaration") continue;
+				const sourceValue = statement.source.value;
+				if (sourceValue === "@systemfsoftware/effect-gherkin-spec") for (const specifier of statement.specifiers) {
+					if (specifier.type !== "ImportSpecifier") continue;
+					if (isMakeFeatureSpecifier(specifier)) hasMakeFeature = true;
+				}
+				if (!FOREIGN_RUNNERS.has(sourceValue)) continue;
+				for (const specifier of statement.specifiers) {
+					if (specifier.type !== "ImportSpecifier") continue;
+					const runnerName = foreignRunnerNameOf(specifier);
+					if (runnerName === null) continue;
+					context.report({
+						node: specifier,
+						messageId: "foreignRunner",
+						data: {
+							name: runnerName,
+							expected: FOREIGN_RUNNER_EXPECTED,
+							actual: FOREIGN_RUNNER_ACTUAL,
+							fix: FOREIGN_RUNNER_FIX
+						}
+					});
+				}
+			}
+			if (!hasMakeFeature) context.report({
+				node,
+				messageId: "missingMakeFeature",
+				data: {
+					name: MISSING_MAKE_FEATURE_NAME,
+					expected: MISSING_MAKE_FEATURE_EXPECTED,
+					actual: MISSING_MAKE_FEATURE_ACTUAL,
+					fix: MISSING_MAKE_FEATURE_FIX
+				}
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/damp-test-naming.config.ts
+const PASCAL_CASE$1 = /^[A-Z][a-z][a-zA-Z0-9]*$/;
+const RECOGNIZED_TEST_METHODS = /* @__PURE__ */ new Set(["only", "effect"]);
+const TEST_PREFIX_FORBIDDEN_EXPECTED = "DAMP format starting with Should_";
+const MISSING_SHOULD_PREFIX_EXPECTED = "Test name starting with Should_";
+const MISSING_WHEN_SEPARATOR_EXPECTED = "Should_[Behavior]_When_[Condition] format";
+const EMPTY_BEHAVIOR_EXPECTED = "Non-empty behavior in PascalCase (e.g., ThrowError)";
+const EMPTY_CONDITION_EXPECTED = "Non-empty condition in PascalCase (e.g., PasswordInvalid)";
+const INVALID_BEHAVIOR_CASE_EXPECTED = "PascalCase (e.g., ThrowError)";
+const INVALID_CONDITION_CASE_EXPECTED = "PascalCase (e.g., PasswordInvalid)";
+const TEST_PREFIX_FORBIDDEN_FIX = "Remove \"test\" prefix and use DAMP format: Should_[Behavior]_When_[Condition]";
+const MISSING_SHOULD_PREFIX_FIX = "Add \"Should_\" prefix to test name";
+const MISSING_WHEN_SEPARATOR_FIX = "Insert \"_When_\" separator between behavior and condition";
+const EMPTY_BEHAVIOR_FIX = "Add descriptive behavior between Should_ and _When_ (e.g., Should_ThrowError_When_Called)";
+const EMPTY_CONDITION_FIX = "Add descriptive condition after _When_ (e.g., Should_ThrowError_When_PasswordInvalid)";
+const INVALID_BEHAVIOR_CASE_FIX = "Convert behavior to PascalCase (e.g., throwError → ThrowError)";
+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 = {
+	type: "suggestion",
+	docs: { description: "Enforce DAMP (Descriptive and Meaningful Phrases) test naming format: Should_[ExpectedBehavior]_When_[Condition]" },
+	schema: [],
+	messages: {
+		testPrefixForbidden: "{{expected}}. Actual: {{actual}}. Fix: {{fix}}.",
+		missingShouldPrefix: "{{expected}}. Actual: {{actual}}. Fix: {{fix}}.",
+		missingWhenSeparator: "{{expected}}. Actual: {{actual}}. Fix: {{fix}}.",
+		emptyBehavior: "{{expected}}. Actual: {{actual}}. Fix: {{fix}}.",
+		emptyCondition: "{{expected}}. Actual: {{actual}}. Fix: {{fix}}.",
+		invalidBehaviorCase: "{{expected}}. Actual: {{actual}}. Fix: {{fix}}.",
+		invalidConditionCase: "{{expected}}. Actual: {{actual}}. Fix: {{fix}}."
+	}
+};
+//#endregion
+//#region src/rules/damp-test-naming.ts
+const getExpected = (errorCode) => {
+	switch (errorCode) {
+		case "testPrefixForbidden": return TEST_PREFIX_FORBIDDEN_EXPECTED;
+		case "missingShouldPrefix": return MISSING_SHOULD_PREFIX_EXPECTED;
+		case "missingWhenSeparator": return MISSING_WHEN_SEPARATOR_EXPECTED;
+		case "emptyBehavior": return EMPTY_BEHAVIOR_EXPECTED;
+		case "emptyCondition": return EMPTY_CONDITION_EXPECTED;
+		case "invalidBehaviorCase": return INVALID_BEHAVIOR_CASE_EXPECTED;
+		case "invalidConditionCase": return INVALID_CONDITION_CASE_EXPECTED;
+	}
+};
+const getActual = (testName, errorCode) => {
+	switch (errorCode) {
+		case "testPrefixForbidden": return `Test starts with "${testName.startsWith("Test") ? "Test" : "test"}" prefix`;
+		case "missingShouldPrefix": return `Test name "${testName}" missing Should_ prefix`;
+		case "missingWhenSeparator": return `Test name "${testName}" missing _When_ separator`;
+		case "emptyBehavior": return EMPTY_BEHAVIOR_ACTUAL;
+		case "emptyCondition": return EMPTY_CONDITION_ACTUAL;
+		case "invalidBehaviorCase": return `Behavior "${testName.slice(7, testName.indexOf("_When_"))}" is not PascalCase`;
+		case "invalidConditionCase": return `Condition "${testName.slice(testName.indexOf("_When_") + 6)}" is not PascalCase`;
+	}
+};
+const getFix = (errorCode) => {
+	switch (errorCode) {
+		case "testPrefixForbidden": return TEST_PREFIX_FORBIDDEN_FIX;
+		case "missingShouldPrefix": return MISSING_SHOULD_PREFIX_FIX;
+		case "missingWhenSeparator": return MISSING_WHEN_SEPARATOR_FIX;
+		case "emptyBehavior": return EMPTY_BEHAVIOR_FIX;
+		case "emptyCondition": return EMPTY_CONDITION_FIX;
+		case "invalidBehaviorCase": return INVALID_BEHAVIOR_CASE_FIX;
+		case "invalidConditionCase": return INVALID_CONDITION_CASE_FIX;
+	}
+};
+const validateDampFormat = (name) => {
+	if (name.toLowerCase().startsWith("test")) return "testPrefixForbidden";
+	if (!name.startsWith("Should_")) return "missingShouldPrefix";
+	const whenIndex = name.indexOf("_When_");
+	if (whenIndex === -1) return "missingWhenSeparator";
+	const behavior = name.slice(7, whenIndex);
+	const condition = name.slice(whenIndex + 6);
+	if (behavior.length === 0) return "emptyBehavior";
+	if (condition.length === 0) return "emptyCondition";
+	if (!PASCAL_CASE$1.test(behavior)) return "invalidBehaviorCase";
+	if (!PASCAL_CASE$1.test(condition)) return "invalidConditionCase";
+	return null;
+};
+const extractTestName$1 = (node) => {
+	const firstArg = node.arguments[0];
+	if (!firstArg) return;
+	if (firstArg.type === "Literal") return String(firstArg.value);
+	if (firstArg.type === "TemplateLiteral" && firstArg.quasis.length === 1) return firstArg.quasis[0]?.value.cooked ?? void 0;
+};
+const isTestFunctionCall = (node) => {
+	if (node.callee.type === "Identifier") return node.callee.name === "it" || node.callee.name === "test";
+	if (node.callee.type === "MemberExpression") {
+		if (node.callee.property.type !== "Identifier") return false;
+		if (!RECOGNIZED_TEST_METHODS.has(node.callee.property.name)) return false;
+		let current = node.callee.object;
+		for (; current.type === "MemberExpression"; current = current.object);
+		return current.type === "Identifier" && (current.name === "it" || current.name === "test");
+	}
+	return false;
+};
+const dampTestNaming = defineRule({
+	meta: meta$19,
+	create(context) {
+		return { CallExpression(node) {
+			if (!isTestFunctionCall(node)) return;
+			const firstArg = node.arguments[0];
+			if (!firstArg) return;
+			const testName = extractTestName$1(node);
+			if (!testName) return;
+			const errorCode = validateDampFormat(testName);
+			if (errorCode) context.report({
+				node: firstArg,
+				messageId: errorCode,
+				data: {
+					expected: getExpected(errorCode),
+					actual: getActual(testName, errorCode),
+					fix: getFix(errorCode)
+				}
+			});
+		} };
+	}
+});
+//#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$18 = {
+	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$7 }
+};
+//#endregion
+//#region src/rules/vitest-guard.ts
+/** True when `node` is the `import.meta.vitest` member expression itself. */
+const isMetaVitest = (node) => node.type === "MemberExpression" && node.property.type === "Identifier" && node.property.name === "vitest" && node.object.type === "MetaProperty";
+/**
+* True when `test` is the condition of an in-source test block — `import.meta.vitest` bare,
+* or compared against a sentinel on either side.
+*
+* Shared by the rules that must recognise an in-source block without judging its contents.
+*/
+const isVitestGuard = (test) => {
+	if (isMetaVitest(test)) return true;
+	if (test.type !== "BinaryExpression") return false;
+	return isMetaVitest(test.left) || isMetaVitest(test.right);
+};
+const isInsideConsequent = (node, consequent) => {
+	const walk = (current) => {
+		if (current === null) return false;
+		if (current === consequent) return true;
+		return walk(current.parent);
+	};
+	return walk(node.parent);
+};
+//#endregion
+//#region src/rules/in-source-test-prop-only.ts
+const PROP_MODIFIERS$1 = /* @__PURE__ */ new Set([
+	"only",
+	"skip",
+	"todo"
+]);
+const isPropCallee$1 = (callee) => {
+	if (callee.type !== "MemberExpression" || callee.property.type !== "Identifier") return false;
+	if (callee.property.name === "prop") {
+		const object = callee.object;
+		if (object.type === "Identifier") return object.name === "it";
+		return object.type === "MemberExpression" && object.property.type === "Identifier" && object.property.name === "effect" && object.object.type === "Identifier" && object.object.name === "it";
+	}
+	return PROP_MODIFIERS$1.has(callee.property.name) && isPropCallee$1(callee.object);
+};
+const BANNED_TEST_ROOTS = /* @__PURE__ */ new Set([
+	"it",
+	"test",
+	"describe",
+	"suite",
+	"expect",
+	"assert",
+	"vi",
+	"beforeEach",
+	"afterEach",
+	"beforeAll",
+	"afterAll"
+]);
+const rootNameOf = (node) => {
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "MemberExpression") return rootNameOf(node.object);
+	if (node.type === "CallExpression") return rootNameOf(node.callee);
+};
+const inSourceTestPropOnly = defineRule({
+	meta: meta$18,
+	create(context) {
+		const filename = context.filename;
+		const basename = basenameOf(filename);
+		if (!isUnderSrc(filename) || isTestFile(basename)) return {};
+		const guards = [];
+		const offending = [];
+		return {
+			IfStatement(node) {
+				if (!isVitestGuard(node.test)) return;
+				guards.push(node);
+			},
+			CallExpression(node) {
+				if (guards.length === 0) return;
+				if (isPropCallee$1(node.callee)) return;
+				const root = rootNameOf(node.callee);
+				if (root === void 0 || !BANNED_TEST_ROOTS.has(root)) return;
+				if (guards.find((g) => isInsideConsequent(node, g.consequent)) === void 0) return;
+				offending.push(node);
+			},
+			"Program:exit"() {
+				for (const node of offending) context.report({
+					node,
+					messageId: "nonPropCall",
+					data: {
+						name: NON_PROP_CALL_NAME,
+						expected: NON_PROP_CALL_EXPECTED,
+						actual: NON_PROP_CALL_ACTUAL,
+						fix: NON_PROP_CALL_FIX
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/in-source-test-targets-private.config.ts
+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$17 = {
+	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/." },
+	schema: [],
+	messages: {
+		notModuleLevel: MESSAGE$7,
+		noPrivateTarget: MESSAGE$7
+	}
+};
+//#endregion
+//#region src/rules/in-source-test-targets-private.ts
+const isCollectable = (node) => node.type === "VariableDeclaration" || node.type === "FunctionDeclaration" || node.type === "ClassDeclaration" || node.type === "TSEnumDeclaration";
+const addPrivateName = (id, out) => {
+	if (id.type === "Identifier") out.add(id.name);
+};
+const LocalBinding = Schema.Struct({ name: Schema.String });
+const collectDeclaration = (node, out) => {
+	if (node.type === "VariableDeclaration") {
+		for (const declarator of node.declarations) addPrivateName(declarator.id, out);
+		return;
+	}
+	if (node.id !== null) addPrivateName(node.id, out);
+};
+const collectPrivateNames = (body, out) => {
+	for (const node of body) {
+		if (node.type === "ExportNamedDeclaration") {
+			if (node.source !== null) continue;
+			for (const specifier of node.specifiers) out.delete(Schema.decodeUnknownSync(LocalBinding)(specifier.local).name);
+			continue;
+		}
+		if (isCollectable(node)) collectDeclaration(node, out);
+	}
+};
+const inSourceTestTargetsPrivate = defineRule({
+	meta: meta$17,
+	create(context) {
+		const filename = context.filename;
+		const basename = basenameOf(filename);
+		const underSrc = isUnderSrc(filename);
+		const inTestFile = isTestFile(basename);
+		if (!underSrc || inTestFile) return {};
+		const privateNames = /* @__PURE__ */ new Set();
+		const guards = [];
+		return {
+			Program(node) {
+				collectPrivateNames(node.body, privateNames);
+			},
+			IfStatement(node) {
+				if (!isVitestGuard(node.test)) return;
+				if (node.parent.type !== "Program") {
+					context.report({
+						node: node.test,
+						messageId: "notModuleLevel",
+						data: {
+							name: NOT_MODULE_LEVEL_NAME,
+							expected: NOT_MODULE_LEVEL_EXPECTED,
+							actual: NOT_MODULE_LEVEL_ACTUAL,
+							fix: NOT_MODULE_LEVEL_FIX
+						}
+					});
+					return;
+				}
+				guards.push({
+					node,
+					hit: false
+				});
+			},
+			Identifier(node) {
+				if (!privateNames.has(node.name)) return;
+				const guard = guards.find((g) => isInsideConsequent(node, g.node.consequent));
+				if (guard !== void 0) guard.hit = true;
+			},
+			"Program:exit"() {
+				for (const guard of guards) {
+					if (guard.hit) continue;
+					context.report({
+						node: guard.node.test,
+						messageId: "noPrivateTarget",
+						data: {
+							name: NO_PRIVATE_TARGET_NAME,
+							expected: NO_PRIVATE_TARGET_EXPECTED,
+							actual: NO_PRIVATE_TARGET_ACTUAL,
+							fix: NO_PRIVATE_TARGET_FIX
+						}
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-assert-in-property.config.ts
+const MESSAGE$6 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const meta$16 = {
+	type: "problem",
+	docs: { description: "Property predicates (it.prop / it.effect.prop) must never call expect(...), assert*(...), or raw fc.assert/fc.check. The boolean return IS the verdict — assertions fork the failure channel. assert* remains correct in normal (non-property) tests." },
+	schema: [],
+	messages: {
+		expectCall: MESSAGE$6,
+		assertCall: MESSAGE$6,
+		rawFcRun: MESSAGE$6
+	}
+};
+//#endregion
+//#region src/rules/prop-call.ts
+const PROP_MODIFIERS = /* @__PURE__ */ new Set([
+	"only",
+	"skip",
+	"todo"
+]);
+const isPropCallee = (callee) => {
+	if (callee.type !== "MemberExpression" || callee.property.type !== "Identifier") return false;
+	if (callee.property.name === "prop") {
+		const object = callee.object;
+		if (object.type === "Identifier") return object.name === "it";
+		return object.type === "MemberExpression" && object.property.type === "Identifier" && object.property.name === "effect" && object.object.type === "Identifier" && object.object.name === "it";
+	}
+	return PROP_MODIFIERS.has(callee.property.name) && isPropCallee(callee.object);
+};
+const getPredicate = (node) => Array$1.findLast(node.arguments, (arg) => arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression");
+//#endregion
+//#region src/rules/no-assert-in-property.ts
+const ASSERT_IDENTIFIER = /^assert/;
+const FC_RUN_METHODS = /* @__PURE__ */ new Set(["assert", "check"]);
+const isInsidePropPredicate = (node) => {
+	const parent = node.parent;
+	if (parent === null) return false;
+	if ((parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") && Option.fromNullishOr(parent.parent).pipe(Option.exists((grandparent) => grandparent.type === "CallExpression" && isPropCallee(grandparent.callee)))) return true;
+	return isInsidePropPredicate(parent);
+};
+const noAssertInProperty = defineRule({
+	meta: meta$16,
+	create(context) {
+		return { CallExpression(node) {
+			const callee = node.callee;
+			let finding = null;
+			if (callee.type === "Identifier") {
+				if (callee.name === "expect") finding = {
+					messageId: "expectCall",
+					name: "expect(...)"
+				};
+				else if (ASSERT_IDENTIFIER.test(callee.name)) finding = {
+					messageId: "assertCall",
+					name: `${callee.name}(...)`
+				};
+			} else if (callee.type === "MemberExpression" && callee.property.type === "Identifier") {
+				if (callee.object.type === "Identifier" && callee.object.name === "assert") finding = {
+					messageId: "assertCall",
+					name: `assert.${callee.property.name}(...)`
+				};
+				else if (callee.object.type === "Identifier" && callee.object.name === "fc" && FC_RUN_METHODS.has(callee.property.name)) finding = {
+					messageId: "rawFcRun",
+					name: `fc.${callee.property.name}(...)`
+				};
+			}
+			if (finding === null || !isInsidePropPredicate(node)) return;
+			context.report({
+				node,
+				messageId: finding.messageId,
+				data: {
+					name: `${finding.name} inside a property predicate`,
+					expected: "return <boolean> — the boolean return IS the verdict in it.prop / it.effect.prop",
+					actual: `${finding.name} forks the failure channel (throw vs false)`,
+					fix: "compute the value, then return a single boolean expression; assert* stays correct in normal (non-property) tests"
+				}
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-behaviourless-assertion.config.ts
+const TEST_FILE = /\.(test|spec)\.[cm]?tsx?$/;
+const BEHAVIOUR_NODES = {
+	AwaitExpression: true,
+	CallExpression: true,
+	NewExpression: true,
+	TaggedTemplateExpression: true
+};
+const SKIP_WALK_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"loc",
+	"range",
+	"parent"
+]);
+const meta$15 = {
+	type: "problem",
+	docs: { description: "Flag an assertion whose subject and expectation are both built only from imported declarations and literals. Such an assertion invokes nothing, so no change to the behaviour under test can make it fail." },
+	schema: [],
+	messages: {
+		behaviourlessAssertion: "Expected: an assertion over a value the code under test produced. Actual: both sides are built only from imported declarations and literals, so this calls nothing and cannot fail on any behaviour change. Fix: assert the output of the function under test, or delete this — mutation score is computed over mutants, not tests, so a worthless test leaves it untouched and nothing else will catch this.",
+		gherkinEmptyCallback: "Expected: a Then/And/But step callback that asserts on the scope or invokes behaviour. Actual: the step callback is empty or contains no assertions/effects, performing no verification."
+	}
+};
+//#endregion
+//#region src/rules/no-behaviourless-assertion.ts
+const GHERKIN_TAP_KEYWORDS = {
+	Then: true,
+	And: true,
+	But: true
+};
+const isGherkinTapCall = (node) => {
+	if (node.callee.type !== "CallExpression") return false;
+	const outerCallee = node.callee.callee;
+	return outerCallee.type === "Identifier" && GHERKIN_TAP_KEYWORDS[outerCallee.name] === true;
+};
+const isEmptyCallback = (node) => {
+	if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
+		if (node.body !== null && node.body.type === "BlockStatement") return node.body.body.length === 0;
+	}
+	return false;
+};
+const isNode$4 = (value) => typeof value === "object" && value !== null && "type" in value;
+/**
+* An identifier that is not an import binding is treated as behaviour, because it was bound
+* locally and most often holds a call result (`const verdict = interpret(cmd)`). That
+* direction is deliberate; only import bindings are known to be declarations and only
+* literals are known to be inert, so anything else is given the benefit of the doubt and the
+* rule stays silent. It under-reports rather than accusing a real assertion.
+*/
+const dependsOnBehaviour = (node, imported) => {
+	if (Array.isArray(node)) {
+		for (const child of node) if (dependsOnBehaviour(child, imported)) return true;
+		return false;
+	}
+	if (!isNode$4(node)) return false;
+	if (BEHAVIOUR_NODES[node.type] === true) return true;
+	if (node.type === "Identifier") return !imported.has(node.name);
+	for (const [key, value] of Object.entries(node)) {
+		if (SKIP_WALK_KEYS.has(key)) continue;
+		if (node.type === "MemberExpression" && key === "property" && node.computed !== true) continue;
+		if (dependsOnBehaviour(value, imported)) return true;
+	}
+	return false;
+};
+const expectCallOf = (node) => {
+	if (node.callee.type !== "MemberExpression") return void 0;
+	let target = node.callee.object;
+	while (target.type === "MemberExpression") target = target.object;
+	if (target.type !== "CallExpression") return void 0;
+	const callee = target.callee;
+	if (!("name" in callee && callee.name === "expect")) return void 0;
+	return target;
+};
+const importedNames = (program) => {
+	const names = /* @__PURE__ */ new Set();
+	for (const statement of program.body) {
+		if (statement.type !== "ImportDeclaration") continue;
+		for (const specifier of statement.specifiers) names.add(specifier.local.name);
+	}
+	return names;
+};
+const noBehaviourlessAssertion = defineRule({
+	meta: meta$15,
+	create(context) {
+		if (!TEST_FILE.test(context.filename)) return {};
+		const imported = importedNames(context.sourceCode.ast);
+		return { CallExpression(node) {
+			if (isGherkinTapCall(node)) {
+				const firstArg = node.arguments[0];
+				if (firstArg !== void 0 && isEmptyCallback(firstArg)) {
+					context.report({
+						node,
+						messageId: "gherkinEmptyCallback"
+					});
+					return;
+				}
+			}
+			const expectCall = expectCallOf(node);
+			if (expectCall === void 0) return;
+			const subject = expectCall.arguments[0];
+			if (subject === void 0) return;
+			if (dependsOnBehaviour(subject, imported)) return;
+			if (dependsOnBehaviour(node.arguments, imported)) return;
+			context.report({
+				node,
+				messageId: "behaviourlessAssertion"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-io-module-in-source-test.config.ts
+/**
+* The specifiers whose modules perform filesystem, process-spawning or network
+* work. The predicate keys on a *call* against a non-type import from one of
+* these — the import alone never decides anything, because a type-only import
+* is erased at runtime and performs nothing.
+*
+* `path` is deliberately absent: it is pure string math and performs no I/O.
+*
+* The effect-group entries carry both spellings an adopter can be on, because
+* platform moved: v4 merges it into the main package (`effect/FileSystem`,
+* verified in-tree across `effect-memfs`, `arethetypeswrong/cli` and
+* `omp-claude-compat`, including a generated api report), while v3 ships it as
+* `@effect/platform/...`. Both are live for someone installing this rule.
+*/
+const IO_SPECIFIERS = {
+	fs: true,
+	"node:fs": true,
+	"node:fs/promises": true,
+	child_process: true,
+	"node:child_process": true,
+	net: true,
+	http: true,
+	https: true,
+	dns: true,
+	"node:net": true,
+	"node:http": true,
+	"node:https": true,
+	"node:dns": true,
+	"effect/FileSystem": true,
+	"effect/unstable/process/ChildProcessSpawner": true,
+	"@effect/platform/FileSystem": true,
+	"@effect/platform/CommandExecutor": true,
+	"@effect/platform-node": true,
+	"@effect/platform-node/NodeFileSystem": true,
+	"@effect/platform-node-shared/NodeFileSystem": true
+};
+const IO_SOURCE_TEST_NAME = "An in-source `import.meta.vitest` test block";
+const IO_SOURCE_TEST_EXPECTED = "the tests of a module whose own source calls an I/O binding to live outside it — a separate test file, or a composition test with a double at the port";
+const IO_SOURCE_TEST_ACTUAL = "this module calls a binding imported from a filesystem, process or network module and guards tests in-source with `import.meta.vitest`";
+const IO_SOURCE_TEST_FIX = "test the module from outside its own source — a separate test file or a composition test doubling the boundary — or, when an assertion merely restates a literal the module already computes, it is a change detector: delete it. The verdict here is the file's own imports and calls, never its name";
+const meta$14 = {
+	type: "problem",
+	docs: { description: "Reports an in-source `import.meta.vitest` test block in a module whose own syntax shows a called, non-type import from a filesystem, process or network module. Judges only the in-source-test idiom — a module whose tests live in separate files is a no-op for this rule, whatever it imports." },
+	schema: [],
+	messages: { ioSourceTest: "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}." }
+};
+//#endregion
+//#region src/rules/no-io-module-in-source-test.ts
+const isIoSpecifier = (source) => IO_SPECIFIERS[source] === true;
+/**
+* The binding a call is made against: the callee identifier itself, or the
+* base identifier of a member chain (`fs`, `fs.promises`) when the call is
+* `fs.readFileSync(...)` / `fs.promises.readFile(...)`. Anything else — a
+* computed call, a `super` edge, an erased type construct — performs nothing a
+* type-only import could not.
+*/
+const bindingBase = (callee) => {
+	if (callee.type === "MemberExpression") return bindingBase(callee.object);
+	if (callee.type === "Identifier") return callee.name;
+};
+const noIoModuleInSourceTest = defineRule({
+	meta: meta$14,
+	create(context) {
+		/** Local binding name -> specifier it was (non-type) imported from. */
+		const ioBindings = {};
+		let ioCallSeen = false;
+		return {
+			ImportDeclaration(node) {
+				if (node.importKind === "type") return;
+				const specifier = node.source.value;
+				if (!isIoSpecifier(specifier)) return;
+				for (const spec of node.specifiers) {
+					if (spec.type === "ImportSpecifier" && spec.importKind === "type") continue;
+					ioBindings[spec.local.name] = specifier;
+				}
+			},
+			CallExpression(node) {
+				if (ioCallSeen) return;
+				const binding = bindingBase(node.callee);
+				if (binding === void 0) return;
+				if (ioBindings[binding] !== void 0) ioCallSeen = true;
+			},
+			"Program:exit"(node) {
+				if (!ioCallSeen) return;
+				for (const statement of node.body) {
+					if (statement.type !== "IfStatement") continue;
+					if (isVitestGuard(statement.test)) context.report({
+						node: statement.test,
+						messageId: "ioSourceTest",
+						data: {
+							name: IO_SOURCE_TEST_NAME,
+							expected: IO_SOURCE_TEST_EXPECTED,
+							actual: IO_SOURCE_TEST_ACTUAL,
+							fix: IO_SOURCE_TEST_FIX
+						}
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-nested-quantification.config.ts
+const MESSAGE$5 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const Options$2 = Schema.Struct({ exempt: Schema.Array(Schema.String).pipe(Schema.annotate({ description: "File basenames this rule stays silent on. An owner who has measured the cost and accepted it names the file here; the property still runs." }), Schema.withDecodingDefaultType(Effect.succeed([]))) });
+const ITERATOR_METHODS = /* @__PURE__ */ new Set([
+	"every",
+	"some",
+	"map",
+	"flatMap",
+	"filter",
+	"forEach",
+	"reduce",
+	"reduceRight",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"sort"
+]);
+const CONSTANT_POOL_ARBITRARIES = /* @__PURE__ */ new Set(["constant", "constantFrom"]);
+const FASTCHECK_NAMESPACES = /* @__PURE__ */ new Set(["fc"]);
+const VIOLATION_NAME$2 = "quantification nested inside a property predicate";
+const EXPECTED$2 = "per-case cost bounded by the draw, not by the draw times a second traversal — inspect a generated value with a fold whose body calls nothing, or move the inner quantifier into the generator so the shrinker can see it";
+const ACTUAL$2 = "the predicate iterates a value derived from a generated parameter and calls a free function inside that loop, so cost scales with the drawn size times whatever that call costs";
+const FIX$2 = "hoist the inner call out of the loop when its result does not vary per element; otherwise assert one drawn element per case and let numRuns supply the quantifier, or generate the pair and compare directly. If the cost is understood and accepted, add this file's basename to the rule's exempt option";
+const meta$13 = {
+	type: "problem",
+	docs: { description: "A property predicate must not quantify over its own generated value and call out again inside that loop. Per-case cost then scales with the drawn size rather than with the draw count, which is the shape Hypothesis reports as nested_given: the suite slows superlinearly as the generator widens, and a CI budget tuned on small draws times out on large ones. Iteration over a bound the generator does not control, and a fold whose body calls nothing, are both fine." },
+	schema: [Schema.toJsonSchemaDocument(Options$2).schema],
+	messages: { nestedQuantification: MESSAGE$5 }
+};
+//#endregion
+//#region src/rules/no-nested-quantification.ts
+const isNode$3 = (value) => value !== null && typeof value === "object" && "type" in value;
+const elementsOf = (value) => Array.isArray(value) ? value : null;
+const entriesOf = (node) => Object.entries(node);
+const visit = (value, onNode) => {
+	const elements = elementsOf(value);
+	if (elements !== null) {
+		for (const item of elements) visit(item, onNode);
+		return;
+	}
+	if (!isNode$3(value)) return;
+	onNode(value);
+	for (const [key, child] of entriesOf(value)) {
+		if (key === "parent") continue;
+		visit(child, onNode);
+	}
+};
+const identifiersIn = (value) => {
+	const names = /* @__PURE__ */ new Set();
+	visit(value, (node) => {
+		if (node.type === "Identifier") names.add(node.name);
+	});
+	return names;
+};
+const touches = (value, names) => {
+	for (const name of identifiersIn(value)) if (names.has(name)) return true;
+	return false;
+};
+const declaredNamesIn = (predicate) => {
+	const names = /* @__PURE__ */ new Set();
+	const addPattern = (pattern) => {
+		for (const name of identifiersIn(pattern)) names.add(name);
+	};
+	visit(predicate, (node) => {
+		if (node.type === "VariableDeclarator") addPattern(node.id);
+		if (node.type === "FunctionDeclaration" && node.id !== null) names.add(node.id.name);
+		if ("params" in node) addPattern(node.params);
+	});
+	return names;
+};
+const isConstantPool = (element) => {
+	if (!isNode$3(element)) return false;
+	if (element.type !== "CallExpression") return false;
+	const callee = element.callee;
+	if (callee.type !== "MemberExpression") return false;
+	if (callee.object.type !== "Identifier") return false;
+	if (!FASTCHECK_NAMESPACES.has(callee.object.name)) return false;
+	if (callee.property.type !== "Identifier") return false;
+	return CONSTANT_POOL_ARBITRARIES.has(callee.property.name);
+};
+const boundedPoolIndices = (call) => {
+	const bounded = /* @__PURE__ */ new Set();
+	const generators = call.arguments.find((argument) => argument.type === "ArrayExpression");
+	if (generators === void 0) return bounded;
+	generators.elements.forEach((element, index) => {
+		if (isConstantPool(element)) bounded.add(index);
+	});
+	return bounded;
+};
+const drawnNamesIn = (predicate, bounded) => {
+	const drawn = /* @__PURE__ */ new Set();
+	const addFrom = (value) => {
+		for (const name of identifiersIn(value)) drawn.add(name);
+	};
+	const [first, ...rest] = predicate.params;
+	if (isNode$3(first) && first.type === "ArrayPattern") first.elements.forEach((element, index) => {
+		if (bounded.has(index)) return;
+		addFrom(element);
+	});
+	else addFrom(first);
+	addFrom(rest);
+	visit(predicate.body, (node) => {
+		if (node.type !== "VariableDeclarator") return;
+		if (!touches(node.init, drawn)) return;
+		addFrom(node.id);
+	});
+	return drawn;
+};
+const iterationOf = (node) => {
+	switch (node.type) {
+		case "ForOfStatement":
+		case "ForInStatement": return {
+			node,
+			iterable: node.right,
+			body: node.body
+		};
+		case "ForStatement":
+		case "WhileStatement":
+		case "DoWhileStatement": return {
+			node,
+			iterable: node.test,
+			body: node.body
+		};
+		case "CallExpression": {
+			const callee = node.callee;
+			if (callee.type !== "MemberExpression") return null;
+			if (callee.property.type !== "Identifier") return null;
+			if (!ITERATOR_METHODS.has(callee.property.name)) return null;
+			return {
+				node,
+				iterable: callee.object,
+				body: node.arguments[0]
+			};
+		}
+		default: return null;
+	}
+};
+const hasFreeCall = (body, declared) => {
+	let free = false;
+	visit(body, (node) => {
+		if (node.type !== "CallExpression" && node.type !== "NewExpression") return;
+		if (node.callee.type !== "Identifier") return;
+		if (declared.has(node.callee.name)) return;
+		free = true;
+	});
+	return free;
+};
+const check = (context, call, predicate) => {
+	const declared = declaredNamesIn(predicate);
+	const drawn = drawnNamesIn(predicate, boundedPoolIndices(call));
+	visit(predicate.body, (node) => {
+		const iteration = iterationOf(node);
+		if (iteration === null) return;
+		if (!touches(iteration.iterable, drawn)) return;
+		if (!hasFreeCall(iteration.body, declared)) return;
+		context.report({
+			node: iteration.node,
+			messageId: "nestedQuantification",
+			data: {
+				name: VIOLATION_NAME$2,
+				expected: EXPECTED$2,
+				actual: ACTUAL$2,
+				fix: FIX$2
+			}
+		});
+	});
+};
+/**
+* Admission gate (measured 2026-08-06): across the whole repo (packages/ +
+* omp/, all .ts) this rule reports 0 times — 0% false positives, under the 5%
+* band that licenses `error` severity. A draw from a constant pool is bounded
+* and excluded; DISCHARGED_BY in the suite pins the unbounded recipe shape.
+*/
+const noNestedQuantification = defineRule({
+	meta: meta$13,
+	create(context) {
+		const options = Schema.decodeUnknownSync(Options$2)(context.options[0] ?? {});
+		const exempt = new Set(options.exempt);
+		const basename = context.filename.slice(context.filename.lastIndexOf("/") + 1);
+		return { CallExpression(node) {
+			if (exempt.has(basename)) return;
+			if (!isPropCallee(node.callee)) return;
+			Option.match(getPredicate(node), {
+				onNone: () => {},
+				onSome: (predicate) => check(context, node, predicate)
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-pseudo-gherkin-unit-tests.config.ts
+const NO_LAYER_IN_FEATURE_NAME = "a *.integration.test.ts feature with no environment double";
+const NO_LAYER_IN_FEATURE_EXPECTED = "a feature builder chained with .withLayer(...) or .withScenarioLayer(...)";
+const NO_LAYER_IN_FEATURE_ACTUAL = "a Feature(...) call with no .withLayer or .withScenarioLayer builder method";
+const NO_LAYER_IN_FEATURE_FIX = "an integration test under WGI-CLS1 exercises real collaborator seams using Layer doubles (withLayer or withScenarioLayer). A test with no Layers is a pure in-memory calculation: move its laws into deterministic-universal scenarios, or provide the external boundary Layer it exercises.";
+const meta$12 = {
+	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$7 }
+};
+//#endregion
+//#region src/rules/no-pseudo-gherkin-unit-tests.ts
+const LAYER_METHODS = {
+	withLayer: true,
+	withScenarioLayer: true
+};
+const isBehaviourTest = (basename) => basename.endsWith(INTEGRATION_SUFFIX);
+const hasLayerInChain = (callNode) => {
+	let current = callNode;
+	while (current.type === "CallExpression") {
+		const calleeNode = current.callee;
+		if (calleeNode.type === "MemberExpression") {
+			if (calleeNode.property.type === "Identifier" && LAYER_METHODS[calleeNode.property.name] === true) return true;
+			current = calleeNode.object;
+		} else break;
+	}
+	return false;
+};
+const findRootFeatureCall = (callNode) => {
+	let current = callNode;
+	while (current.type === "CallExpression") {
+		const calleeNode = current.callee;
+		if (calleeNode.type === "Identifier" && calleeNode.name === "Feature") return current;
+		if (calleeNode.type === "MemberExpression") current = calleeNode.object;
+		else break;
+	}
+	return null;
+};
+const noPseudoGherkinUnitTests = defineRule({
+	meta: meta$12,
+	create(context) {
+		if (!isBehaviourTest(basenameOf(context.filename))) return {};
+		return { CallExpression(node) {
+			if (node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier") {
+				if (node.callee.property.name === "body") {
+					const rootFeature = findRootFeatureCall(node);
+					if (rootFeature !== null && !hasLayerInChain(node)) context.report({
+						node: rootFeature,
+						messageId: "noLayerInFeature",
+						data: {
+							name: NO_LAYER_IN_FEATURE_NAME,
+							expected: NO_LAYER_IN_FEATURE_EXPECTED,
+							actual: NO_LAYER_IN_FEATURE_ACTUAL,
+							fix: NO_LAYER_IN_FEATURE_FIX
+						}
+					});
+				}
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-silent-return.config.ts
+const MESSAGE$4 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const meta$11 = {
+	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." },
+	schema: [],
+	messages: {
+		bareReturn: MESSAGE$4,
+		nonBooleanReturn: MESSAGE$4,
+		missingReturn: MESSAGE$4,
+		nonBooleanBody: MESSAGE$4
+	}
+};
+//#endregion
+//#region src/rules/no-silent-return.ts
+const BOOLEAN_PRODUCING_OPERATORS = /* @__PURE__ */ new Set([
+	"===",
+	"!==",
+	"==",
+	"!=",
+	"<",
+	"<=",
+	">",
+	">=",
+	"instanceof",
+	"in",
+	"!"
+]);
+const LOOP_LIKE = /* @__PURE__ */ new Set([
+	"ForStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"WhileStatement",
+	"DoWhileStatement",
+	"LabeledStatement"
+]);
+const isLoopLike = (stmt) => LOOP_LIKE.has(stmt.type);
+/**
+* Syntactically boolean-producing expressions. Identifiers, member
+* expressions, and calls are opaque — trusted to be boolean (documented in
+* the rule meta); everything else must PROVE it is boolean.
+*/
+const isBooleanShaped = (expr) => {
+	if (expr.type === "ChainExpression") return isBooleanShaped(expr.expression);
+	if (expr.type === "AwaitExpression") return isBooleanShaped(expr.argument);
+	if (expr.type === "TSAsExpression" || expr.type === "TSSatisfiesExpression" || expr.type === "TSNonNullExpression" || expr.type === "TSTypeAssertion") return isBooleanShaped(expr.expression);
+	switch (expr.type) {
+		case "Literal": return typeof expr.value === "boolean";
+		case "UnaryExpression":
+		case "BinaryExpression": return BOOLEAN_PRODUCING_OPERATORS.has(expr.operator);
+		case "LogicalExpression": return expr.operator !== "??" && isBooleanShaped(expr.left) && isBooleanShaped(expr.right);
+		case "ConditionalExpression": return isBooleanShaped(expr.consequent) && isBooleanShaped(expr.alternate);
+		case "CallExpression":
+		case "Identifier":
+		case "MemberExpression": return true;
+		default: return false;
+	}
+};
+const report = (context, node, messageId, actual) => {
+	context.report({
+		node,
+		messageId,
+		data: {
+			name: "A silent exit from a property predicate",
+			expected: "return <boolean> on every code path — fast-check counts undefined as success",
+			actual,
+			fix: "return a boolean verdict; to skip an input dynamically, call fc.pre(condition) instead"
+		}
+	});
+};
+const checkReturn = (context, stmt) => {
+	if (stmt.argument === null) {
+		report(context, stmt, "bareReturn", "bare `return;` — the predicate exits with undefined, a silent pass");
+		return;
+	}
+	if (!isBooleanShaped(stmt.argument)) report(context, stmt, "nonBooleanReturn", `return of a non-boolean ${stmt.argument.type}`);
+};
+const checkStatements = (context, statements) => {
+	for (const stmt of statements) if (stmt.type === "ReturnStatement") checkReturn(context, stmt);
+	else if (stmt.type === "IfStatement") {
+		checkStatements(context, [stmt.consequent]);
+		if (stmt.alternate !== null) checkStatements(context, [stmt.alternate]);
+	} else if (stmt.type === "BlockStatement") checkStatements(context, stmt.body);
+	else if (stmt.type === "SwitchStatement") for (const switchCase of stmt.cases) checkStatements(context, switchCase.consequent);
+	else if (stmt.type === "TryStatement") {
+		checkStatements(context, [stmt.block]);
+		if (stmt.handler !== null) checkStatements(context, [stmt.handler.body]);
+		if (stmt.finalizer !== null) checkStatements(context, [stmt.finalizer]);
+	} else if (isLoopLike(stmt)) checkStatements(context, [stmt.body]);
+	else if (stmt.type === "FunctionDeclaration") {
+		if (stmt.generator) checkFn(context, stmt);
+	}
+};
+/**
+* Does every path through this statement EXIT the function (return or
+* throw)? Returns already reported by checkReturn count as exits — the tail
+* analysis only owns paths with no exit at all.
+*/
+const pathExits = (stmt) => {
+	switch (stmt.type) {
+		case "ReturnStatement":
+		case "ThrowStatement": return true;
+		case "BlockStatement": return Array$1.last(stmt.body).pipe(Option.exists(pathExits));
+		case "IfStatement": return stmt.alternate !== null && pathExits(stmt.consequent) && pathExits(stmt.alternate);
+		case "SwitchStatement": return Array$1.some(stmt.cases, (switchCase) => switchCase.test === null) && Array$1.every(stmt.cases, (switchCase) => Array$1.last(switchCase.consequent).pipe(Option.exists(pathExits)));
+		case "TryStatement": return pathExits(stmt.block) && (stmt.handler === null || pathExits(stmt.handler.body));
+		default: return false;
+	}
+};
+/** Narrow an arbitrary ESTree-adjacent value to a walkable object record. */
+const isRecord = (value) => typeof value === "object" && value !== null;
+/** Narrow an object whose `type`/`generator` fields mark it as a generator function expression. */
+const isGeneratorFunction = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("type" in value) || value["type"] !== "FunctionExpression") return false;
+	return "generator" in value && Boolean(value["generator"]);
+};
+/** Collect generator functions (Effect.gen bodies are verdict carriers). */
+const collectGenerators = (value) => {
+	const out = [];
+	const walk = (inner) => {
+		const items = Array.isArray(inner) ? inner : [inner];
+		for (const item of items) {
+			if (!isRecord(item)) continue;
+			if (item["type"] === "FunctionExpression") {
+				if (isGeneratorFunction(item)) out.push(item);
+				continue;
+			}
+			if (item["type"] === "ArrowFunctionExpression") continue;
+			for (const key of Object.keys(item)) {
+				if (key === "parent") continue;
+				walk(item[key]);
+			}
+		}
+	};
+	walk(value);
+	return out;
+};
+const checkFn = (context, fn) => {
+	const body = Option.getOrThrow(Option.fromNullishOr(fn.body));
+	if (body.type !== "BlockStatement") {
+		if (!isBooleanShaped(body)) report(context, body, "nonBooleanBody", `predicate body is a non-boolean ${body.type}`);
+		for (const gen of collectGenerators(body)) checkFn(context, gen);
+		return;
+	}
+	checkStatements(context, body.body);
+	for (const gen of collectGenerators(body)) checkFn(context, gen);
+	if (!Array$1.last(body.body).pipe(Option.exists(pathExits))) report(context, fn, "missingReturn", "the predicate can fall off the end without returning — undefined is a silent pass");
+};
+const noSilentReturn = defineRule({
+	meta: meta$11,
+	create(context) {
+		return { CallExpression(node) {
+			if (!isPropCallee(node.callee)) return;
+			Option.match(getPredicate(node), {
+				onNone: () => {},
+				onSome: (predicate) => checkFn(context, predicate)
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-test-file-in-src.config.ts
+const Options$1 = Schema.Struct({ sanctionedDirs: Schema.NonEmptyArray(Schema.String).pipe(Schema.withDecodingDefaultType(Effect.succeed([NESTED_TEST_DIR]))) });
+const testFileInSrcDetail = (dir) => ({
+	expected: `src/**/${dir}/<stem>.workflow.property.test.ts beside the <stem>.workflow.ts it covers, or an in-source import.meta.vitest block`,
+	actual: `a test file under src/ that is neither the schema-laws entry point nor a <stem>.workflow.property.test.ts inside a ${dir} directory`,
+	fix: `pick the arm matching what this file exercises. A workflow law -> rename to <stem>.workflow.property.test.ts inside src/<path>/${dir}/. A kernel/policy/schema property or characterization suite -> convert it to an in-source \`if (import.meta.vitest)\` block in the module it covers. The package public surface -> move outside src/ to tests/<name>.integration.test.ts. No arm matches -> delete this file`
+});
+const propertyTestLocationDetail = (dir) => ({
+	expected: `src/**/${dir}/<stem>.workflow.property.test.ts — a property test one directory down from the workflow it covers, never beside it`,
+	actual: `a property test under src/ that is not a single-segment <stem>.workflow.property.test.ts inside a ${dir} directory`,
+	fix: `a workflow law -> rename to <stem>.workflow.property.test.ts inside src/<path>/${dir}/. A kernel/policy/schema property suite -> convert it to an in-source \`if (import.meta.vitest)\` block in the module it covers. Relative imports shift one level when moving into ${dir}: ./<cell>.js -> ../<cell>.js`
+});
+const SCHEMA_TEST_DETAIL = {
+	expected: "no authored test under this name — the generated schema-laws.test.ts carries the ruleOfSchemas pair for every exported schema",
+	actual: "an authored *.schema.test.ts restating generated coverage",
+	fix: "delete it. The generated laws already state round-trip identity and encode stability. What they cannot state is rejection — every input they draw comes from the arbitrary the schema itself supplies — so a refusal belongs in an in-source if (import.meta.vitest) block in the schema file, never here"
+};
+const meta$10 = {
+	type: "problem",
+	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$7,
+		schemaTestInSrc: MESSAGE$7,
+		propertyTestOutsideTestsDir: MESSAGE$7
+	}
+};
+//#endregion
+//#region src/rules/no-test-file-in-src.ts
+const violationOf = (basename, isPropertyTest, dir) => basename.endsWith(".schema.test.ts") ? ["schemaTestInSrc", SCHEMA_TEST_DETAIL] : isPropertyTest ? ["propertyTestOutsideTestsDir", propertyTestLocationDetail(dir)] : ["testFileInSrc", testFileInSrcDetail(dir)];
+const noTestFileInSrc = defineRule({
+	meta: meta$10,
+	create(context) {
+		const { sanctionedDirs } = Schema.decodeUnknownSync(Options$1)(context.options[0] ?? {});
+		const basename = basenameOf(context.filename);
+		if (!isUnderSrc(context.filename)) return {};
+		if (!isTestFile(basename)) return {};
+		if (basename === "schema-laws.test.ts") return {};
+		const isPropertyTest = basename.endsWith(PROPERTY_SUFFIX);
+		const isSchemaTest = basename.endsWith(SCHEMA_SUFFIX);
+		const colocated = isInConfiguredTestDir(context.filename, sanctionedDirs);
+		if (!isSchemaTest && WORKFLOW_TEST_BASENAME.test(basename) && colocated) return {};
+		const [messageId, detail] = violationOf(basename, isPropertyTest, sanctionedDirs[0]);
+		return { Program(node) {
+			context.report({
+				node,
+				messageId,
+				data: {
+					name: basename,
+					...detail
+				}
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/pbt-naming.config.ts
+const SCOPE_SYMBOLS = /* @__PURE__ */ new Set([
+	"∀",
+	"∃",
+	"→",
+	"¬",
+	"≤",
+	"≥"
+]);
+const PREDICATE_SYMBOLS = /* @__PURE__ */ new Set([
+	"≡",
+	"≠",
+	"=",
+	"≤",
+	"≥",
+	"∈",
+	"⊆",
+	"⊇",
+	"→",
+	"¬",
+	"∘",
+	"∩",
+	"∪",
+	"⊥"
+]);
+const NULLARY_PREDICATE_SYMBOLS = /* @__PURE__ */ new Set(["⊥"]);
+const PASCAL_CASE = /^[A-Z][a-z][a-zA-Z0-9]*$/;
+const DAMP_WORDS = /When|Should|Given|Then|Otherwise|After|Before/;
+const meta$9 = {
+	type: "suggestion",
+	docs: { description: "Enforce a complete formal-specification name for property-based tests (it.prop / it.effect.prop). Format: [ScopeSymbol][binder]_[Domain]_[PredicateSymbol][operand] (e.g., ∀x_DecodeEncode_=x, ∀l_Filter_⊆Input, →Shipped_Cancel_⊥Allowed). Both the quantifier and the predicate must carry an operand — a bare symbol specifies nothing." },
+	schema: [],
+	messages: {
+		invalidSegments: "Expected: exactly 2 underscores in PBT name ([Scope]_[Domain]_[Predicate]). Actual: name \"{{actual}}\" has {{count}} separator(s). If this isn't a universal invariant, delete the test. Otherwise use format [ScopeSymbol][binder]_[Domain]_[PredicateSymbol][operand] (e.g., ∀x_DecodeEncode_=x).",
+		invalidScopeSymbol: "Expected: a quantifier symbol (∀ ∃ → ¬ ≤ ≥) at the start of \"{{actual}}\". Actual: it starts with \"{{firstChar}}\". If this isn't a universal invariant, delete the test. Otherwise quantify the input: ∀ (for all), ∃ (there exists), → (implies), ¬, ≤, ≥.",
+		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).",
+		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."
+	}
+};
+//#endregion
+//#region src/rules/pbt-naming.ts
+const isPropCall = (node) => {
+	let foundProp = false;
+	let current = node.callee;
+	for (; current.type === "MemberExpression"; current = current.object) if (current.property.type === "Identifier" && current.property.name === "prop") foundProp = true;
+	return foundProp && current.type === "Identifier" && (current.name === "it" || current.name === "test");
+};
+const extractTestName = (node) => {
+	const firstArg = node.arguments[0];
+	if (!firstArg) return;
+	if (firstArg.type === "Literal") return String(firstArg.value);
+	if (firstArg.type !== "TemplateLiteral") return;
+	if (firstArg.quasis.length !== 1) return;
+	return firstArg.quasis[0]?.value.cooked ?? void 0;
+};
+const parseSegments = (name) => {
+	const parts = name.split("_");
+	if (parts.length !== 3) return null;
+	const scopeSegment = parts[0];
+	const domainSegment = parts[1];
+	const predicateSegment = parts[2];
+	if (scopeSegment === void 0 || domainSegment === void 0 || predicateSegment === void 0) return null;
+	return {
+		scopeSegment,
+		domainSegment,
+		predicateSegment
+	};
+};
+const pbtNaming = defineRule({
+	meta: meta$9,
+	create(context) {
+		return { CallExpression(node) {
+			if (!isPropCall(node)) return;
+			const firstArg = node.arguments[0];
+			if (!firstArg) return;
+			const testName = extractTestName(node);
+			if (!testName) return;
+			const segments = parseSegments(testName);
+			if (!segments) {
+				context.report({
+					node: firstArg,
+					messageId: "invalidSegments",
+					data: {
+						actual: testName,
+						count: testName.split("_").length - 1
+					}
+				});
+				return;
+			}
+			const { scopeSegment, domainSegment, predicateSegment } = segments;
+			const scopeSymbol = scopeSegment.charAt(0);
+			if (!SCOPE_SYMBOLS.has(scopeSymbol)) {
+				context.report({
+					node: firstArg,
+					messageId: "invalidScopeSymbol",
+					data: {
+						actual: testName,
+						firstChar: scopeSymbol
+					}
+				});
+				return;
+			}
+			if (scopeSegment.slice(1).length === 0) {
+				context.report({
+					node: firstArg,
+					messageId: "incompleteScope",
+					data: {
+						symbol: scopeSymbol,
+						scope: scopeSegment
+					}
+				});
+				return;
+			}
+			if (!PASCAL_CASE.test(domainSegment)) {
+				context.report({
+					node: firstArg,
+					messageId: "emptyDomain",
+					data: { actual: testName }
+				});
+				return;
+			}
+			const dampMatch = DAMP_WORDS.exec(domainSegment);
+			if (dampMatch) {
+				context.report({
+					node: firstArg,
+					messageId: "domainLeaksDAMP",
+					data: {
+						domain: domainSegment,
+						word: dampMatch[0]
+					}
+				});
+				return;
+			}
+			const predicateSymbol = predicateSegment.charAt(0);
+			if (!PREDICATE_SYMBOLS.has(predicateSymbol)) {
+				context.report({
+					node: firstArg,
+					messageId: "invalidPredicateSymbol",
+					data: {
+						actual: testName,
+						firstChar: predicateSymbol
+					}
+				});
+				return;
+			}
+			if (!NULLARY_PREDICATE_SYMBOLS.has(predicateSymbol) && predicateSegment.slice(1).length === 0) {
+				context.report({
+					node: firstArg,
+					messageId: "incompletePredicate",
+					data: {
+						symbol: predicateSymbol,
+						predicate: predicateSegment
+					}
+				});
+				return;
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/rules/prop-arbitrary-schema-origin.config.ts
+const MESSAGE$3 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const VIOLATION_NAME$1 = "a hand-built fast-check arbitrary with no schema underneath";
+const EXPECTED$1 = "every in-source it.prop arbitrary derives from an Effect Schema — a schema reference, a schema-attached arbitrary annotation, or a pipe/map/oneof chain rooted in one; an input with no schema grows one first";
+const ACTUAL$1 = "the arbitrary is assembled from fast-check constructors alone, so the generator can emit shapes the schema never declared and the suite stays green while exercising almost nothing";
+const FIX$1 = "delete the block, or grow the schema the input needs and derive the arbitrary from it — Arbitrary.schema(schema) is the sanctioned derivation; nothing rewrites a hand-built generator into a property";
+const STOCK_NAME = "a stock-schema derivation wearing a domain costume";
+const STOCK_EXPECTED = "the arbitrary derives from a schema this module (or a sibling) declares for its own contract — a domain schema — never from a stock Schema member or stock composition at the prop site";
+const STOCK_ACTUAL = "the Arbitrary.schema root is Schema.String, Schema.Int, or another stock member — the filter and map chains on it are the hand-built generator, relocated behind a schema-looking call";
+const STOCK_FIX = "declare the domain schema that states the shape — its filter carries the format, its arbitrary annotation carries the generator — and derive through Arbitrary.schema(ThatSchema)";
+const SCHEMA_SOURCE_PATTERN = /schema/i;
+const SCHEMA_NAMESPACE_NAMES = {
+	Schema: true,
+	Arbitrary: true
+};
+const FASTCHECK_NAMESPACE_NAMES = { FastCheck: true };
+const COMBINATOR_CALLEES = { pipe: true };
+const meta$8 = {
+	type: "problem",
+	docs: { description: "Inside an import.meta.vitest in-source block, every it.prop / it.effect.prop arbitrary must derive from an Effect Schema — a schema reference, a schema-attached arbitrary annotation, or a chain rooted in one. A hand-built fast-check construction with no schema underneath reports; statically opaque arbitraries (unresolved or foreign bindings) fail open into the runtime domain audit." },
+	schema: [],
+	messages: {
+		handBuiltArbitrary: MESSAGE$3,
+		stockDerivedArbitrary: MESSAGE$3
+	}
+};
+//#endregion
+//#region src/rules/prop-arbitrary-schema-origin.ts
+const MAX_WALK_DEPTH$1 = 32;
+const isNode$2 = (value) => value !== null && typeof value === "object" && "type" in value;
+const isImportMetaVitest$1 = (node) => node.type === "MemberExpression" && node.property.type === "Identifier" && node.property.name === "vitest" && node.object.type === "MetaProperty" && node.object.meta.name === "import" && node.object.property.name === "meta";
+/**
+* Broader than test-placement's condition-only `isVitestGuard`: this walks the whole
+* test-expression subtree, so a guard like `if (runTests && import.meta.vitest)` is
+* recognised here. Deliberate — plugins do not share code (KTD8).
+*/
+const mentionsImportMetaVitest$2 = (value) => {
+	if (Array.isArray(value)) return value.some(mentionsImportMetaVitest$2);
+	if (!isNode$2(value)) return false;
+	if (isImportMetaVitest$1(value)) return true;
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "parent") continue;
+		if (mentionsImportMetaVitest$2(child)) return true;
+	}
+	return false;
+};
+const isScopeLike$1 = (value) => typeof value === "object" && value !== null && "set" in value && "upper" in value;
+const resolveLocal$1 = (name, node, getScope) => {
+	const scope = getScope(node);
+	if (!isScopeLike$1(scope)) return { kind: "none" };
+	for (let current = scope; current !== null; current = current.upper) {
+		const variable = current.set.get(name);
+		if (variable === void 0) continue;
+		for (const def of variable.defs) {
+			if (def.type === "ImportBinding") return { kind: "import" };
+			if (def.node.type === "FunctionDeclaration") return { kind: "function" };
+			if (def.node.type !== "VariableDeclarator") continue;
+			const init = Option.fromNullishOr(def.node.init);
+			if (Option.isSome(init)) return {
+				kind: "init",
+				init: init.value,
+				declarator: def.node
+			};
+		}
+		return { kind: "none" };
+	}
+	return { kind: "none" };
+};
+const importSourceOf = (argument) => {
+	if (argument === void 0 || argument === null) return void 0;
+	if (argument.type !== "ImportExpression") return void 0;
+	const { source } = argument;
+	return source.type === "Literal" && typeof source.value === "string" ? source.value : void 0;
+};
+/**
+* A guard-local `const { FastCheck: fc } = await import('effect/testing')` is a
+* hand-built generator binding. Resolve it to the same import edge a static import
+* would produce, so the dynamic idiom cannot hide a hand-built arbitrary behind
+* an opaque verdict.
+*/
+const dynamicEdgeOf = (declarator, init, name) => {
+	if (init.type !== "AwaitExpression") return void 0;
+	const source = importSourceOf(init.argument);
+	if (source === void 0) return void 0;
+	const { id } = declarator;
+	if (id.type === "ObjectPattern") {
+		for (const property of id.properties) {
+			if (property.type !== "Property") continue;
+			if (property.key.type !== "Identifier" || property.value.type !== "Identifier") continue;
+			if (property.value.name !== name) continue;
+			return {
+				source,
+				imported: property.key.name
+			};
+		}
+		return;
+	}
+	if (id.type === "Identifier" && id.name === name) return {
+		source,
+		imported: null
+	};
+};
+const vocabularyOf = (edge) => {
+	if (SCHEMA_SOURCE_PATTERN.test(edge.source)) return "schema";
+	if (edge.source.startsWith("effect/unstable/arbitrary")) return "schema";
+	if (edge.source === "effect" && edge.imported !== null) {
+		if (SCHEMA_NAMESPACE_NAMES[edge.imported] === true) return "schema";
+		if (FASTCHECK_NAMESPACE_NAMES[edge.imported] === true) return "handBuilt";
+	}
+	if (edge.source === "effect/testing" && edge.imported !== null) {
+		if (FASTCHECK_NAMESPACE_NAMES[edge.imported] === true) return "handBuilt";
+		if (SCHEMA_NAMESPACE_NAMES[edge.imported] === true) return "schema";
+	}
+	if (edge.source === "fast-check" || edge.source.startsWith(`fast-check/`)) return "handBuilt";
+	return "opaque";
+};
+var Provenance = class {
+	getScope;
+	imports = /* @__PURE__ */ new Map();
+	constructor(getScope) {
+		this.getScope = getScope;
+	}
+	isLocalFunction(name, node) {
+		const resolved = resolveLocal$1(name, node, this.getScope);
+		if (resolved.kind === "function") return true;
+		return resolved.kind === "init" && (resolved.init.type === "ArrowFunctionExpression" || resolved.init.type === "FunctionExpression");
+	}
+	isSchemaNamespaceBinding(name, node) {
+		if (resolveLocal$1(name, node, this.getScope).kind !== "import") return false;
+		const edge = this.imports.get(name);
+		return edge !== void 0 && edge.source === "effect" && edge.imported === "Schema";
+	}
+	isArbitraryNamespaceBinding(name, node) {
+		if (resolveLocal$1(name, node, this.getScope).kind !== "import") return false;
+		const edge = this.imports.get(name);
+		if (edge === void 0) return false;
+		if (edge.source.startsWith("effect/unstable/arbitrary")) return true;
+		return edge.source === "effect" && edge.imported === "Arbitrary";
+	}
+	classifyCall(name, node) {
+		if (this.isLocalFunction(name, node)) return "domain";
+		const resolved = resolveLocal$1(name, node, this.getScope);
+		if (resolved.kind === "import") {
+			const edge = this.imports.get(name);
+			if (edge === void 0) return "unknown";
+			const verdict = vocabularyOf(edge);
+			return verdict === "schema" || verdict === "handBuilt" ? "codec" : "domain";
+		}
+		if (resolved.kind === "init") {
+			const verdict = this.verdictOf(resolved.init, 0);
+			if (verdict === "schema" || verdict === "handBuilt") return "codec";
+			return "unknown";
+		}
+		return "unknown";
+	}
+	isLocalBinding(name, node) {
+		const resolved = resolveLocal$1(name, node, this.getScope);
+		return resolved.kind === "init" || resolved.kind === "function";
+	}
+	verdictOf(expr, depth) {
+		if (depth > MAX_WALK_DEPTH$1 || !isNode$2(expr)) return "opaque";
+		switch (expr.type) {
+			case "ChainExpression": return this.verdictOf(expr.expression, depth + 1);
+			case "TSAsExpression":
+			case "TSSatisfiesExpression":
+			case "TSNonNullExpression":
+			case "TSTypeAssertion": return this.verdictOf(expr.expression, depth + 1);
+			case "Identifier": {
+				const resolved = resolveLocal$1(expr.name, expr, this.getScope);
+				if (resolved.kind === "import") {
+					const edge = this.imports.get(expr.name);
+					return edge === void 0 ? "opaque" : vocabularyOf(edge);
+				}
+				if (resolved.kind === "init") {
+					const edge = dynamicEdgeOf(resolved.declarator, resolved.init, expr.name);
+					return edge === void 0 ? this.verdictOf(resolved.init, depth + 1) : vocabularyOf(edge);
+				}
+				return "opaque";
+			}
+			case "MemberExpression": return this.verdictOf(expr.object, depth + 1);
+			case "Literal": return "handBuilt";
+			case "ObjectExpression": return this.objectVerdictOf(expr, depth);
+			case "ArrayExpression": return this.reduceArgs(expr.elements, depth);
+			case "CallExpression": return this.callVerdictOf(expr, depth);
+			case "AwaitExpression": return this.verdictOf(expr.argument, depth + 1);
+			default: return "opaque";
+		}
+	}
+	callVerdictOf(call, depth) {
+		const callee = call.callee;
+		if (callee.type === "MemberExpression") {
+			const receiver = this.verdictOf(callee.object, depth + 1);
+			if (receiver === "schema") return "schema";
+			if (receiver === "opaque") return "opaque";
+			return this.reduceArgs(call.arguments, depth);
+		}
+		if (callee.type === "Identifier" && COMBINATOR_CALLEES[callee.name] === true) return this.reduceArgs(call.arguments, depth);
+		const calleeVerdict = this.verdictOf(callee, depth + 1);
+		if (calleeVerdict === "schema") return "schema";
+		if (calleeVerdict === "opaque") return "opaque";
+		return this.reduceArgs(call.arguments, depth);
+	}
+	objectVerdictOf(object, depth) {
+		let sawSchema = false;
+		let sawOpaque = false;
+		for (const property of object.properties) {
+			if (property.type !== "Property" || property.computed) {
+				sawOpaque = true;
+				continue;
+			}
+			const verdict = this.verdictOf(property.value, depth + 1);
+			if (verdict === "handBuilt") return "handBuilt";
+			if (verdict === "schema") sawSchema = true;
+			if (verdict === "opaque") sawOpaque = true;
+		}
+		return sawOpaque ? "opaque" : sawSchema ? "schema" : "handBuilt";
+	}
+	reduceArgs(args, depth) {
+		let sawSchema = false;
+		let sawOpaque = false;
+		for (const arg of args) {
+			if (arg === null) {
+				sawOpaque = true;
+				continue;
+			}
+			if (arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression") continue;
+			const verdict = this.verdictOf(arg, depth + 1);
+			if (verdict === "handBuilt") return "handBuilt";
+			if (verdict === "schema") sawSchema = true;
+			if (verdict === "opaque") sawOpaque = true;
+		}
+		return sawOpaque ? "opaque" : sawSchema ? "schema" : "handBuilt";
+	}
+};
+const mentionsLocalBinding = (provenance, value) => {
+	if (Array.isArray(value)) return value.some((item) => mentionsLocalBinding(provenance, item));
+	if (!isNode$2(value)) return false;
+	if (value.type === "Identifier") {
+		if (provenance.isSchemaNamespaceBinding(value.name, value)) return false;
+		if (provenance.isLocalFunction(value.name, value)) return true;
+		return provenance.verdictOf(value, 0) !== "opaque";
+	}
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "parent") continue;
+		if (mentionsLocalBinding(provenance, child)) return true;
+	}
+	return false;
+};
+const stockArgVerdict = (provenance, arg) => {
+	if (arg === void 0 || arg === null || !isNode$2(arg)) return false;
+	if (arg.type === "MemberExpression") {
+		if (arg.object.type !== "Identifier" || !provenance.isSchemaNamespaceBinding(arg.object.name, arg)) return false;
+		return true;
+	}
+	if (arg.type === "CallExpression") {
+		const callee = arg.callee;
+		if (callee.type !== "MemberExpression" || callee.object.type !== "Identifier") return false;
+		if (!provenance.isSchemaNamespaceBinding(callee.object.name, arg)) return false;
+		return !mentionsLocalBinding(provenance, arg.arguments);
+	}
+	return false;
+};
+const checkArbitraryFactory = (provenance, context, call) => {
+	const callee = call.callee;
+	if (callee.type !== "MemberExpression" || callee.property.type !== "Identifier") return;
+	const isToArbitrary = callee.property.name === "toArbitrary";
+	const isArbitrarySchema = callee.property.name === "schema" && callee.object.type === "Identifier" && provenance.isArbitraryNamespaceBinding(callee.object.name, call);
+	if (!isToArbitrary && !isArbitrarySchema) return;
+	const arg = call.arguments[0];
+	if (arg === void 0) return;
+	if (stockArgVerdict(provenance, arg)) context.report({
+		node: call,
+		messageId: "stockDerivedArbitrary",
+		data: {
+			name: STOCK_NAME,
+			expected: STOCK_EXPECTED,
+			actual: STOCK_ACTUAL,
+			fix: STOCK_FIX
+		}
+	});
+};
+const checkPropCall$1 = (provenance, context, call) => {
+	const arbitraries = call.arguments.find((argument) => argument.type === "ArrayExpression");
+	if (arbitraries === void 0) return;
+	for (const element of arbitraries.elements) {
+		if (element === null) continue;
+		if (provenance.verdictOf(element, 0) !== "handBuilt") continue;
+		context.report({
+			node: element,
+			messageId: "handBuiltArbitrary",
+			data: {
+				name: VIOLATION_NAME$1,
+				expected: EXPECTED$1,
+				actual: ACTUAL$1,
+				fix: FIX$1
+			}
+		});
+	}
+};
+const propArbitrarySchemaOrigin = defineRule({
+	meta: meta$8,
+	create(context) {
+		const provenance = new Provenance(context.sourceCode.getScope);
+		const collect = (value, out) => {
+			if (Array.isArray(value)) {
+				for (const item of value) collect(item, out);
+				return;
+			}
+			if (!isNode$2(value)) return;
+			if (value.type === "IfStatement" && mentionsImportMetaVitest$2(value.test)) return;
+			if (value.type === "CallExpression" && isPropCallee(value.callee)) out.push(value);
+			for (const [key, child] of Object.entries(value)) {
+				if (key === "parent") continue;
+				collect(child, out);
+			}
+		};
+		return {
+			Program(node) {
+				for (const statement of node.body) {
+					if (statement.type !== "ImportDeclaration") continue;
+					const source = statement.source.value;
+					for (const specifier of statement.specifiers) if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier") provenance.imports.set(specifier.local.name, {
+						source,
+						imported: specifier.imported.name
+					});
+					else provenance.imports.set(specifier.local.name, {
+						source,
+						imported: null
+					});
+				}
+			},
+			IfStatement(node) {
+				if (!mentionsImportMetaVitest$2(node.test)) return;
+				const calls = [];
+				collect(node.consequent, calls);
+				collect(node.alternate, calls);
+				const factories = [];
+				const collectFactories = (value) => {
+					if (Array.isArray(value)) {
+						for (const item of value) collectFactories(item);
+						return;
+					}
+					if (!isNode$2(value)) return;
+					if (value.type === "CallExpression" && value.callee.type === "MemberExpression" && value.callee.property.type === "Identifier" && (value.callee.property.name === "toArbitrary" || value.callee.property.name === "schema")) factories.push(value);
+					for (const [key, child] of Object.entries(value)) {
+						if (key === "parent") continue;
+						collectFactories(child);
+					}
+				};
+				collectFactories(node.consequent);
+				collectFactories(node.alternate);
+				for (const call of calls) checkPropCall$1(provenance, context, call);
+				for (const factory of factories) checkArbitraryFactory(provenance, context, factory);
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/prop-fixture-schema-origin.config.ts
+const MESSAGE$2 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const VIOLATION_NAME = "a hand-rolled recursive schema fixture inside a test block";
+const EXPECTED = "a recursive fixture schema enters the block through a named local builder call, or its recursion point declares its generation with a visible toCodecArbitrary derivation or a recursionBudget ceiling";
+const ACTUAL = "the union and its recursion cycle are assembled inline, so the suite exercises a surrogate universe the shipped schema contract never declared and no budget gate grades";
+const FIX = "hoist the members into a named builder the annotated and counterfactual fixtures share, or declare the recursion point's generation in its annotation";
+const meta$7 = {
+	type: "problem",
+	docs: { description: "Inside an import.meta.vitest in-source block or a *.test.ts file, a recursive schema union must enter through a named local builder or an imported helper, or its recursion point must declare its generation with a visible toCodecArbitrary derivation or recursionBudget ceiling. An inline hand-rolled recursive union reports; outside test scope the rule is silent, because production schemas are the derivation-cost rule domain." },
+	schema: [],
+	messages: { handRolledRecursiveFixture: MESSAGE$2 }
+};
+//#endregion
+//#region src/rules/prop-fixture-schema-origin.ts
+const MAX_WALK_DEPTH = 32;
+const isNode$1 = (value) => value !== null && typeof value === "object" && "type" in value;
+const isImportMetaVitest = (node) => node.type === "MemberExpression" && node.property.type === "Identifier" && node.property.name === "vitest" && node.object.type === "MetaProperty" && node.object.meta.name === "import" && node.object.property.name === "meta";
+/**
+* Broader than test-placement's condition-only guard: this walks the whole test-expression
+* subtree, so `if (runTests && import.meta.vitest)` is recognised here. Deliberate — plugins
+* do not share code (KTD8), and a test-scope walk that misses a guard silently disarms the rule.
+*/
+const mentionsImportMetaVitest$1 = (value) => {
+	if (Array.isArray(value)) return value.some(mentionsImportMetaVitest$1);
+	if (!isNode$1(value)) return false;
+	if (isImportMetaVitest(value)) return true;
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "parent") continue;
+		if (mentionsImportMetaVitest$1(child)) return true;
+	}
+	return false;
+};
+const isTestScope = (node, filename) => {
+	if (filename.endsWith(".test.ts")) return true;
+	for (let current = node; current !== null; current = current.parent) if (current.type === "IfStatement" && mentionsImportMetaVitest$1(current.test)) return true;
+	return false;
+};
+const isScopeLike = (value) => typeof value === "object" && value !== null && "set" in value && "upper" in value;
+const resolveLocal = (name, node, getScope) => {
+	const scope = getScope(node);
+	if (!isScopeLike(scope)) return { kind: "none" };
+	for (let current = scope; current !== null; current = current.upper) {
+		const variable = current.set.get(name);
+		if (variable === void 0) continue;
+		for (const def of variable.defs) {
+			if (def.type === "ImportBinding") return { kind: "import" };
+			if (def.node.type === "FunctionDeclaration") return { kind: "function" };
+			if (def.node.type !== "VariableDeclarator") continue;
+			if (def.node.init === null) continue;
+			return {
+				kind: "init",
+				init: def.node.init
+			};
+		}
+		return { kind: "none" };
+	}
+	return { kind: "none" };
+};
+const isNamedBuilder = (name, node, getScope) => {
+	const resolved = resolveLocal(name, node, getScope);
+	if (resolved.kind === "function" || resolved.kind === "import") return true;
+	return resolved.kind === "init" && (resolved.init.type === "ArrowFunctionExpression" || resolved.init.type === "FunctionExpression");
+};
+/** The identifier thunk of a `Schema.suspend(...)` / `S.suspend(...)` binding, when the name resolves to one. */
+const suspendThunkOf = (name, node, getScope) => {
+	const resolved = resolveLocal(name, node, getScope);
+	if (resolved.kind !== "init") return void 0;
+	const { init } = resolved;
+	if (init.type !== "CallExpression") return void 0;
+	const { callee } = init;
+	if (callee.type !== "MemberExpression" || callee.computed) return void 0;
+	if (callee.property.type !== "Identifier" || callee.property.name !== "suspend") return void 0;
+	return init.arguments[0];
+};
+const mentionsIdentifier = (value, name, depth) => {
+	if (depth > MAX_WALK_DEPTH) return false;
+	if (Array.isArray(value)) return value.some((item) => mentionsIdentifier(item, name, depth + 1));
+	if (!isNode$1(value)) return false;
+	if (value.type === "Identifier") return value.name === name;
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "parent") continue;
+		if (mentionsIdentifier(child, name, depth + 1)) return true;
+	}
+	return false;
+};
+const collectIdentifierNames = (value, out, depth) => {
+	if (depth > MAX_WALK_DEPTH) return;
+	if (Array.isArray(value)) {
+		for (const item of value) collectIdentifierNames(item, out, depth + 1);
+		return;
+	}
+	if (!isNode$1(value)) return;
+	if (value.type === "Identifier") {
+		out.push(value.name);
+		return;
+	}
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "parent") continue;
+		collectIdentifierNames(child, out, depth + 1);
+	}
+};
+/** The variable the union call is assigned to, when it has a plain-identifier binding. */
+const bindingNameOf = (union) => {
+	for (let current = union; current !== null; current = current.parent) if (current.type === "VariableDeclarator") return current.id.type === "Identifier" ? current.id.name : void 0;
+};
+const unionMembersOf = (union) => {
+	const first = union.arguments[0];
+	if (first !== void 0 && first.type === "ArrayExpression") return first.elements.filter((element) => element !== null);
+	return union.arguments;
+};
+const memberNamesOf = (union) => {
+	const names = [];
+	for (const member of unionMembersOf(union)) {
+		if (member.type === "Identifier") {
+			names.push(member.name);
+			continue;
+		}
+		if (member.type === "SpreadElement" && member.argument.type === "Identifier") names.push(member.argument.name);
+	}
+	return names;
+};
+const isRecursiveUnion = (union, getScope) => {
+	const binding = bindingNameOf(union);
+	const reachesBinding = (name, seen) => {
+		if (seen.has(name)) return false;
+		seen.add(name);
+		const thunk = suspendThunkOf(name, union, getScope);
+		if (thunk === void 0) return false;
+		if (binding !== void 0 && mentionsIdentifier(thunk, binding, 0)) return true;
+		const nestedNames = [];
+		collectIdentifierNames(thunk, nestedNames, 0);
+		return nestedNames.some((nested) => suspendThunkOf(nested, union, getScope) !== void 0 && reachesBinding(nested, seen));
+	};
+	return memberNamesOf(union).some((name) => reachesBinding(name, /* @__PURE__ */ new Set()));
+};
+const annotateCallOf = (union) => {
+	const member = union.parent;
+	if (member === null || member.type !== "MemberExpression") return void 0;
+	if (member.object !== union) return void 0;
+	if (member.property.type !== "Identifier" || member.property.name !== "annotate") return void 0;
+	const call = member.parent;
+	return call !== null && call.type === "CallExpression" && call.callee === member ? call : void 0;
+};
+const declaresGenerationIntent = (annotate) => {
+	const options = annotate.arguments[0];
+	if (options === void 0 || options.type !== "ObjectExpression") return false;
+	return options.properties.some((property) => property.type === "Property" && property.key.type === "Identifier" && (property.key.name === "toCodecArbitrary" || property.key.name === "recursionBudget"));
+};
+/**
+* Sanctioned origins (a) and (b): the union is the body or argument of an inline function passed to a
+* named local builder or an imported helper, optionally through a `.annotate(...)` chain. An IIFE is
+* not sanctioned — its callee is the inline function itself, not a named binding — so it reports.
+*/
+const isNamedBuilderOrigin = (union, getScope) => {
+	let current = union;
+	for (let depth = 0; depth <= MAX_WALK_DEPTH; depth += 1) {
+		const parent = current.parent;
+		if (parent === null) return false;
+		if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") {
+			const call = parent.parent;
+			if (call === null || call.type !== "CallExpression") return false;
+			if (call.callee.type !== "Identifier") return false;
+			return isNamedBuilder(call.callee.name, call, getScope);
+		}
+		if (parent.type === "CallExpression") {
+			if (!parent.arguments.some((argument) => argument === current)) return false;
+			if (parent.callee.type !== "Identifier") return false;
+			return isNamedBuilder(parent.callee.name, parent, getScope);
+		}
+		if (parent.type === "MemberExpression" && parent.object === current) {
+			const call = parent.parent;
+			if (call === null || call.type !== "CallExpression" || call.callee !== parent) return false;
+			current = call;
+			continue;
+		}
+		if (parent.type === "VariableDeclarator" || parent.type === "ReturnStatement" || parent.type === "BlockStatement") {
+			current = parent;
+			continue;
+		}
+		return false;
+	}
+	return false;
+};
+const propFixtureSchemaOrigin = defineRule({
+	meta: meta$7,
+	create(context) {
+		const getScope = context.sourceCode.getScope;
+		return { CallExpression(node) {
+			const { callee } = node;
+			if (callee.type !== "MemberExpression" || callee.computed) return;
+			if (callee.property.type !== "Identifier" || callee.property.name !== "Union") return;
+			if (callee.object.type !== "Identifier") return;
+			if (!isTestScope(node, context.filename)) return;
+			if (!isRecursiveUnion(node, getScope)) return;
+			const annotate = annotateCallOf(node);
+			if (annotate !== void 0 && declaresGenerationIntent(annotate)) return;
+			if (isNamedBuilderOrigin(node, getScope)) return;
+			context.report({
+				node,
+				messageId: "handRolledRecursiveFixture",
+				data: {
+					name: VIOLATION_NAME,
+					expected: EXPECTED,
+					actual: ACTUAL,
+					fix: FIX
+				}
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/prop-generated-law-duplicate.config.ts
+const MESSAGE$1 = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const COMPILER_NAME = "a runtime probe of a compile-time guarantee";
+const COMPILER_EXPECTED = "the type checker owns brand and nominal-identity contracts — a dropped brand is a compile error at the consumer brand gate, not a failing property";
+const COMPILER_ACTUAL = "the predicate reflects over brand symbols at runtime, so it re-asserts what tsc already enforces and passes whenever the type system passes";
+const COMPILER_FIX = "delete the prop; state the brand contract where the compiler reads it — an expectTypeOf assertion or the consuming signature — never a symbol reflection loop";
+const NO_FUNCTION_NAME = "a property that tests no function";
+const NO_FUNCTION_EXPECTED = "every in-source property exercises domain logic — at least one call to a module-local function that is not a schema codec accessor — because a predicate that only feeds values through encode or decode tests the schema declaration, not code, and decode acceptance and refusal alike are generated or declared elsewhere";
+const NO_FUNCTION_ACTUAL = "no call in the predicate reaches module code — every call is a codec accessor, a schema wrapper, or an iteration combinator — so the property cannot fail unless the declaration it restates changes meaning";
+const NO_FUNCTION_FIX = "delete the prop; test the function that owns the decision — the workflow or a private helper in this module — with its input derived from a domain schema";
+const meta$6 = {
+	type: "problem",
+	docs: { description: "Inside an import.meta.vitest in-source block: a predicate that reflects over brand symbols re-asserts a compile-time guarantee, and a predicate containing no module-local non-codec function call tests a schema declaration instead of code. Both report." },
+	schema: [],
+	messages: {
+		compilerDuplicate: MESSAGE$1,
+		noDomainFunction: MESSAGE$1
+	}
+};
+//#endregion
+//#region src/rules/prop-generated-law-duplicate.ts
+/**
+* Codec accessors and iteration/string combinators: a call whose terminal name
+* lands in either list never counts as the function under test.
+*/
+const CODEC_ACCESSORS = {
+	encode: true,
+	encodeSync: true,
+	encodeExit: true,
+	encodeUnknownSync: true,
+	encodeUnknownExit: true,
+	encodeOption: true,
+	decode: true,
+	decodeSync: true,
+	decodeExit: true,
+	decodeUnknownSync: true,
+	decodeUnknownExit: true,
+	decodeOption: true,
+	decodeEither: true,
+	decodePromise: true,
+	decodeUnknownPromise: true,
+	isSuccess: true,
+	isFailure: true,
+	isRight: true,
+	isLeft: true,
+	isSome: true,
+	isNone: true,
+	toEquivalence: true,
+	toEncoded: true,
+	toCodecArbitrary: true,
+	Exit: true
+};
+const NEUTRAL_METHODS = {
+	every: true,
+	some: true,
+	includes: true,
+	map: true,
+	filter: true,
+	find: true,
+	join: true,
+	split: true,
+	trim: true,
+	toLowerCase: true,
+	toUpperCase: true,
+	replaceAll: true,
+	replace: true,
+	indexOf: true,
+	startsWith: true,
+	endsWith: true,
+	concat: true,
+	slice: true,
+	get: true,
+	set: true,
+	has: true,
+	keys: true,
+	values: true,
+	entries: true,
+	forEach: true,
+	reduce: true,
+	test: true,
+	match: true,
+	gen: true
+};
+const isNode = (value) => value !== null && typeof value === "object" && "type" in value;
+const mentionsImportMetaVitest = (value) => {
+	if (Array.isArray(value)) return value.some((item) => mentionsImportMetaVitest(item));
+	if (!isNode(value)) return false;
+	if (value.type === "MemberExpression" && value.property.type === "Identifier" && value.property.name === "vitest" && value.object.type === "MetaProperty" && value.object.meta.name === "import" && value.object.property.name === "meta") return true;
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "parent") continue;
+		if (mentionsImportMetaVitest(child)) return true;
+	}
+	return false;
+};
+const collectPredicateShape = (provenance, node, shape) => {
+	if (Array.isArray(node)) {
+		for (const item of node) collectPredicateShape(provenance, item, shape);
+		return;
+	}
+	if (!isNode(node)) return;
+	if (node.type === "MemberExpression" && node.property.type === "Identifier") {
+		if (node.property.name === "getOwnPropertySymbols" || node.property.name === "getOwnPropertyNames") shape.usesCompilerProbe = true;
+	}
+	if (node.type === "Identifier" && node.name.endsWith("TypeId")) shape.usesCompilerProbe = true;
+	if (node.type === "CallExpression") {
+		let callee = node.callee;
+		while (callee.type === "CallExpression") callee = callee.callee;
+		if (callee.type === "MemberExpression" && callee.property.type === "Identifier") {
+			const name = callee.property.name;
+			if (CODEC_ACCESSORS[name] !== true && NEUTRAL_METHODS[name] !== true) {
+				const receiverIsLocal = callee.object.type === "Identifier" && provenance.isLocalBinding(callee.object.name, node);
+				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;
+		}
+	}
+	for (const [key, child] of Object.entries(node)) {
+		if (key === "parent") continue;
+		collectPredicateShape(provenance, child, shape);
+	}
+};
+const checkPropCall = (provenance, context, call) => {
+	const predicate = call.arguments[call.arguments.length - 1];
+	if (predicate === void 0 || predicate.type !== "ArrowFunctionExpression") return;
+	const shape = {
+		usesCompilerProbe: false,
+		callsDomainFunction: false
+	};
+	collectPredicateShape(provenance, predicate.body, shape);
+	if (shape.usesCompilerProbe) {
+		context.report({
+			node: call,
+			messageId: "compilerDuplicate",
+			data: {
+				name: COMPILER_NAME,
+				expected: COMPILER_EXPECTED,
+				actual: COMPILER_ACTUAL,
+				fix: COMPILER_FIX
+			}
+		});
+		return;
+	}
+	if (!shape.callsDomainFunction) context.report({
+		node: call,
+		messageId: "noDomainFunction",
+		data: {
+			name: NO_FUNCTION_NAME,
+			expected: NO_FUNCTION_EXPECTED,
+			actual: NO_FUNCTION_ACTUAL,
+			fix: NO_FUNCTION_FIX
+		}
+	});
+};
+const propGeneratedLawDuplicate = defineRule({
+	meta: meta$6,
+	create(context) {
+		const provenance = new Provenance(context.sourceCode.getScope);
+		const collect = (value, out) => {
+			if (Array.isArray(value)) {
+				for (const item of value) collect(item, out);
+				return;
+			}
+			if (!isNode(value)) return;
+			if (value.type === "CallExpression" && isPropCallee(value.callee)) out.push(value);
+			for (const [key, child] of Object.entries(value)) {
+				if (key === "parent") continue;
+				collect(child, out);
+			}
+		};
+		return {
+			Program(node) {
+				for (const statement of node.body) {
+					if (statement.type !== "ImportDeclaration") continue;
+					const source = statement.source.value;
+					for (const specifier of statement.specifiers) if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier") provenance.imports.set(specifier.local.name, {
+						source,
+						imported: specifier.imported.name
+					});
+					else provenance.imports.set(specifier.local.name, {
+						source,
+						imported: null
+					});
+				}
+			},
+			IfStatement(node) {
+				if (!mentionsImportMetaVitest(node.test)) return;
+				const calls = [];
+				collect(node.consequent, calls);
+				collect(node.alternate, calls);
+				for (const call of calls) checkPropCall(provenance, context, call);
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/property-file-purity.config.ts
+const PROPERTY_TEST_SUFFIX = ".property.test.ts";
+const MESSAGE = "{{name}} is forbidden. Expected: {{expected}}. Actual: {{actual}}. Fix: {{fix}}.";
+const meta$5 = {
+	type: "problem",
+	docs: { description: "Property tests live ONLY in *.property.test.ts files, and those files contain ONLY property tests. In a property file: no plain it()/test()/it.effect(), no raw fc.assert/fc.check/fc.property/fc.asyncProperty. In any other test file: no FastCheck import and no it.prop/it.effect.prop — move the property to a *.property.test.ts file." },
+	schema: [],
+	messages: {
+		plainIt: MESSAGE,
+		plainEffectIt: MESSAGE,
+		rawFastCheck: MESSAGE,
+		fastCheckImport: MESSAGE,
+		propCall: MESSAGE
+	}
+};
+//#endregion
+//#region src/rules/property-file-purity.ts
+const RAW_FC_METHODS = /* @__PURE__ */ new Set([
+	"assert",
+	"check",
+	"property",
+	"asyncProperty"
+]);
+const reportPlain = (context, node, messageId, actual) => {
+	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",
+			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"
+		}
+	});
+};
+const createPropertyFileVisitors = (context) => ({ CallExpression(node) {
+	const callee = node.callee;
+	if (callee.type === "Identifier") {
+		if (callee.name === "it" || callee.name === "test") reportPlain(context, node, "plainIt", `${callee.name}(...)`);
+		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, ...)"
+			}
+		});
+		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}(...)`);
+		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}(...)`);
+} });
+const FAST_CHECK_IMPORT_DATA = {
+	name: "FastCheck import in a scenario test file",
+	expected: `property tests (and every FastCheck usage) live in ${PROPERTY_TEST_SUFFIX} files`,
+	actual: `FastCheck imported by a file that is not ${PROPERTY_TEST_SUFFIX}`,
+	fix: "move the property test to a *.property.test.ts file; this file keeps plain it() scenario tests only"
+};
+const reportFastCheckImport = (context, node) => {
+	context.report({
+		node,
+		messageId: "fastCheckImport",
+		data: FAST_CHECK_IMPORT_DATA
+	});
+};
+const createScenarioFileVisitors = (context) => ({
+	ImportDeclaration(node) {
+		if (node.source.value === "fast-check" || node.source.value.startsWith("fast-check/")) {
+			reportFastCheckImport(context, node);
+			return;
+		}
+		for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "FastCheck") reportFastCheckImport(context, specifier);
+	},
+	CallExpression(node) {
+		if (!isPropCallee(node.callee)) return;
+		context.report({
+			node,
+			messageId: "propCall",
+			data: {
+				name: "property test in a non-property test file",
+				expected: `it.prop / it.effect.prop calls live in ${PROPERTY_TEST_SUFFIX} files`,
+				actual: "a property test mixed into a test file that is not a property file",
+				fix: "move this test to a *.property.test.ts file — property and non-property tests never mix"
+			}
+		});
+	}
+});
+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);
+		return createScenarioFileVisitors(context);
+	}
+});
+//#endregion
+//#region src/rules/src-property-test-cell.config.ts
+const Options = Schema.Struct({ cellsRequiringTest: Schema.Array(Schema.String).pipe(Schema.annotate({ description: "Cell suffixes whose source files must carry a test, named without the leading dot (e.g. [\"kernel\", \"workflow\"]). Empty by default: a consumer who declares nothing is never accused. A cell listed here is satisfied by an in-source `if (import.meta.vitest)` block, which is the only form the rule can read from the file it is given." }), Schema.withDecodingDefaultType(Effect.succeed([]))) });
+const UNSANCTIONED_CELL_EXPECTED = "a property test named <stem>.workflow.property.test.ts inside __tests__, beside the <stem>.workflow.ts it covers";
+const UNSANCTIONED_CELL_ACTUAL = "a property test under src/ whose basename is not a single-segment <stem>.workflow.property.test.ts";
+const UNSANCTIONED_CELL_FIX = "rename it <stem>.workflow.property.test.ts beside the workflow it covers; a kernel/policy/schema property suite has no file home under the new taxonomy — convert it to an in-source if (import.meta.vitest) block in the module it covers";
+const MISSING_CELL_TEST_EXPECTED = "a test for every cell suffix the consumer lists in cellsRequiringTest";
+const MISSING_CELL_TEST_ACTUAL = "a declared cell whose own module carries no `if (import.meta.vitest)` block";
+const MISSING_CELL_TEST_FIX = "add an `if (import.meta.vitest)` block to this module, or drop this cell from cellsRequiringTest and cover it with a colocated test in a sanctioned test directory — the rule reads the file it is given, so a sibling test file is invisible to it and a declared cell must satisfy the requirement from its own source";
+const meta$4 = {
+	type: "problem",
+	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$7,
+		missingCellTest: ABSENCE_MESSAGE
+	}
+};
+//#endregion
+//#region src/rules/src-property-test-cell.ts
+const carriesInSourceBlock = (body) => body.some((statement) => statement.type === "IfStatement" && isVitestGuard(statement.test));
+const srcPropertyTestCell = defineRule({
+	meta: meta$4,
+	create(context) {
+		const { cellsRequiringTest } = Schema.decodeUnknownSync(Options)(context.options[0] ?? {});
+		const filename = context.filename;
+		const basename = basenameOf(filename);
+		if (!isUnderSrc(filename)) return {};
+		if (basename.endsWith(".property.test.ts")) {
+			if (WORKFLOW_TEST_BASENAME.test(basename)) return {};
+			return { Program(node) {
+				context.report({
+					node,
+					messageId: "unsanctionedCell",
+					data: {
+						name: basename,
+						expected: UNSANCTIONED_CELL_EXPECTED,
+						actual: UNSANCTIONED_CELL_ACTUAL,
+						fix: UNSANCTIONED_CELL_FIX
+					}
+				});
+			} };
+		}
+		if (isTestFile(basename)) return {};
+		const cell = cellOf(basename);
+		if (cell === void 0) return {};
+		if (!cellsRequiringTest.includes(cell)) return {};
+		return { Program(node) {
+			if (carriesInSourceBlock(node.body)) return;
+			context.report({
+				node,
+				messageId: "missingCellTest",
+				data: {
+					name: basename,
+					expected: MISSING_CELL_TEST_EXPECTED,
+					actual: MISSING_CELL_TEST_ACTUAL,
+					fix: MISSING_CELL_TEST_FIX
+				}
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/test-file-outside-tests-dir.config.ts
+const SANCTIONED_DIRS = [...SANCTIONED_TEST_DIRS].map((dir) => `${dir}/`).join(" or ");
+const STRAY_TEST_FILE_EXPECTED = `test files outside src/ under a ${SANCTIONED_DIRS} directory`;
+const STRAY_TEST_FILE_ACTUAL = "a test file outside src/ and outside any tests directory";
+const STRAY_TEST_FILE_FIX = `move it into the package ${SANCTIONED_DIRS} directory`;
+//#endregion
+//#region src/rules/test-file-outside-tests-dir.ts
+const testFileOutsideTestsDir = defineRule({
+	meta: {
+		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$7 }
+	},
+	create(context) {
+		if (isUnderSrc(context.filename)) return {};
+		if (!isTestFile(basenameOf(context.filename))) return {};
+		if (isInSanctionedTestDir(context.filename)) return {};
+		return { Program(node) {
+			context.report({
+				node,
+				messageId: "strayTestFile",
+				data: {
+					name: basenameOf(context.filename),
+					expected: STRAY_TEST_FILE_EXPECTED,
+					actual: STRAY_TEST_FILE_ACTUAL,
+					fix: STRAY_TEST_FILE_FIX
+				}
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/test-suffix-outside-src.config.ts
+const UNSANCTIONED_SUFFIX_EXPECTED = "exactly *.integration.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";
+//#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." },
+		schema: [],
+		messages: { unsanctionedSuffix: MESSAGE$7 }
+	},
+	create(context) {
+		const filename = context.filename;
+		const basename = basenameOf(filename);
+		const suffixIsAllowed = basename.endsWith(INTEGRATION_SUFFIX);
+		return { Program(node) {
+			if (isUnderSrc(filename)) return;
+			if (!isTestFile(basename)) return;
+			if (suffixIsAllowed) return;
+			context.report({
+				node,
+				messageId: "unsanctionedSuffix",
+				data: {
+					name: basename,
+					expected: UNSANCTIONED_SUFFIX_EXPECTED,
+					actual: UNSANCTIONED_SUFFIX_ACTUAL,
+					fix: UNSANCTIONED_SUFFIX_FIX
+				}
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/tests-dir-helpers-in-fixtures.config.ts
+const HELPER_EXPECTED = "non-test helper and fixture modules under tests/ to live inside tests/__fixtures__/";
+const HELPER_ACTUAL = "a non-test module in tests/ outside __fixtures__/";
+const HELPER_FIX = "move it under tests/__fixtures__/ — *.schema.ts if it declares schemas, <stem>.workflow.ts if it constructs a workflow";
+//#endregion
+//#region src/rules/tests-dir-helpers-in-fixtures.ts
+const testsDirHelpersInFixtures = defineRule({
+	meta: {
+		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$7 }
+	},
+	create(context) {
+		const filename = context.filename;
+		if (isUnderSrc(filename)) return {};
+		const basename = basenameOf(filename);
+		if (isTestFile(basename)) return {};
+		const dirs = directoriesOf(filename);
+		if (!dirs.includes("tests")) return {};
+		if (dirs.includes("__fixtures__")) return {};
+		return { Program(node) {
+			context.report({
+				node,
+				messageId: "helperOutsideFixtures",
+				data: {
+					name: basename,
+					expected: HELPER_EXPECTED,
+					actual: HELPER_ACTUAL,
+					fix: HELPER_FIX
+				}
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/tests-import-public-api.config.ts
+const REACH_IN_EXPECTED = "a package name or subpath, or a sibling helper under the test tree";
+const REACH_IN_ACTUAL = "a relative import that reaches src or climbs into an internal folder";
+const REACH_IN_FIX = "rewrite onto the published package name when the binding is public. Delete the test when the subject is an internal";
+const meta = {
+	type: "problem",
+	docs: { description: "Forbid package-level tests from relative-importing src or climbing into an internal folder" },
+	schema: [],
+	messages: { sourceReachIn: MESSAGE$7 }
+};
+//#endregion
+//#region src/rules/tests-import-public-api.ts
+const isForbiddenRelativeSpecifier = (value) => {
+	if (!value.startsWith(".")) return false;
+	let sawDotDot = false;
+	for (const segment of value.split("/")) {
+		if (segment === "..") sawDotDot = true;
+		if (segment === "src") return true;
+		if (sawDotDot && segment === "internal") return true;
+	}
+	return false;
+};
+const specifierOf = (node) => {
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+};
+const testsImportPublicApi = defineRule({
+	meta,
+	create(context) {
+		if (!isInTestsImportScope(context.filename)) return {};
+		const reportIfForbidden = (sourceNode) => {
+			const value = specifierOf(sourceNode);
+			if (value === void 0 || !isForbiddenRelativeSpecifier(value)) return;
+			context.report({
+				node: sourceNode,
+				messageId: "sourceReachIn",
+				data: {
+					name: value,
+					expected: REACH_IN_EXPECTED,
+					actual: REACH_IN_ACTUAL,
+					fix: REACH_IN_FIX
+				}
+			});
+		};
+		return {
+			ImportDeclaration(node) {
+				reportIfForbidden(node.source);
+			},
+			ExportNamedDeclaration(node) {
+				if (node.source !== null) reportIfForbidden(node.source);
+			},
+			ExportAllDeclaration(node) {
+				reportIfForbidden(node.source);
+			},
+			ImportExpression(node) {
+				reportIfForbidden(node.source);
+			},
+			TSImportEqualsDeclaration(node) {
+				if (node.moduleReference.type === "TSExternalModuleReference") reportIfForbidden(node.moduleReference.expression);
+			}
+		};
+	}
+});
+//#endregion
+//#region src/index.ts
+const PLUGIN_NAME = "@systemfsoftware/oxlint-plugin-test-discipline";
+const rule = (name) => `${PLUGIN_NAME}/${name}`;
+const recommendedRules = {
+	[rule("damp-test-naming")]: "error",
+	[rule("no-behaviourless-assertion")]: "error",
+	[rule("pbt-naming")]: "error",
+	[rule("no-silent-return")]: "error",
+	[rule("no-assert-in-property")]: "error",
+	[rule("property-file-purity")]: "error",
+	[rule("no-nested-quantification")]: "error",
+	[rule("prop-arbitrary-schema-origin")]: "error",
+	[rule("prop-fixture-schema-origin")]: "error",
+	[rule("prop-generated-law-duplicate")]: "error",
+	[rule("in-source-test-prop-only")]: "error",
+	[rule("in-source-test-targets-private")]: "error",
+	[rule("no-test-file-in-src")]: "error",
+	[rule("src-property-test-cell")]: "error",
+	[rule("test-file-outside-tests-dir")]: "error",
+	[rule("test-suffix-outside-src")]: "error",
+	[rule("behaviour-test-requires-gherkin")]: "error",
+	[rule("behaviour-exercises-use-case")]: "error",
+	[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"
+};
+var src_default = {
+	meta: { name: PLUGIN_NAME },
+	rules: {
+		"damp-test-naming": dampTestNaming,
+		"no-behaviourless-assertion": noBehaviourlessAssertion,
+		"pbt-naming": pbtNaming,
+		"no-silent-return": noSilentReturn,
+		"no-assert-in-property": noAssertInProperty,
+		"property-file-purity": propertyFilePurity,
+		"no-nested-quantification": noNestedQuantification,
+		"prop-generated-law-duplicate": propGeneratedLawDuplicate,
+		"prop-arbitrary-schema-origin": propArbitrarySchemaOrigin,
+		"prop-fixture-schema-origin": propFixtureSchemaOrigin,
+		"in-source-test-prop-only": inSourceTestPropOnly,
+		"in-source-test-targets-private": inSourceTestTargetsPrivate,
+		"no-test-file-in-src": noTestFileInSrc,
+		"src-property-test-cell": srcPropertyTestCell,
+		"test-file-outside-tests-dir": testFileOutsideTestsDir,
+		"test-suffix-outside-src": testSuffixOutsideSrc,
+		"behaviour-test-requires-gherkin": behaviourTestRequiresGherkin,
+		"behaviour-exercises-use-case": behaviourExercisesUseCase,
+		"behaviour-one-feature-per-file": behaviourOneFeaturePerFile,
+		"no-pseudo-gherkin-unit-tests": noPseudoGherkinUnitTests,
+		"tests-dir-helpers-in-fixtures": testsDirHelpersInFixtures,
+		"no-io-module-in-source-test": noIoModuleInSourceTest,
+		"tests-import-public-api": testsImportPublicApi
+	},
+	configs: { recommended: { rules: recommendedRules } }
+};
+//#endregion
+export { src_default as default };