@utilfirst/eslint-plugin 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,7 +1,9 @@
+import { defineRule, eslintCompatPlugin } from "@oxlint/plugins";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { z } from "zod";
 
 //#region package.json
-var version = "0.1.1";
+var version = "0.2.0";
 
 //#endregion
 //#region src/rules/consistent-blank-lines.ts
@@ -61,20 +63,30 @@ const consistentBlankLines = {
 			url: "https://github.com/utilfirst/utilfirst-eslint-plugin/blob/main/docs/rules/consistent-blank-lines.md"
 		},
 		fixable: "whitespace",
+		defaultOptions: [],
 		schema: [],
 		messages: {
 			extra: "Unexpected blank line between items that continue the same paragraph.",
 			missing: "Expected a blank line between items that start a new paragraph."
 		}
 	},
-	defaultOptions: [],
 	create(context) {
 		const sourceCode = context.sourceCode;
 		function checkBlock(statements) {
 			for (let i = 0; i < statements.length - 1; i++) {
 				const prev = statements[i];
 				const next = statements[i + 1];
-				if (prev && next) checkPair(prev, next, sourceCode.getCommentsBefore(next)[0] ?? next, () => sameParagraph(prev, next, sourceCode), () => isImportPair(prev, next) || isReExport(prev) && isReExport(next) || isExpressionStatementPair(prev, next));
+				if (prev && next) checkPair({
+					effectiveStart: sourceCode.getCommentsBefore(next)[0] ?? next,
+					isSameParagraph: () => sameParagraph({
+						next,
+						prev,
+						sourceCode
+					}),
+					next,
+					prev,
+					shouldPreserveExtra: () => isImportPair(prev, next) || isReExport(prev) && isReExport(next) || isExpressionStatementPair(prev, next)
+				});
 			}
 		}
 		function checkJsxChildren(children) {
@@ -98,11 +110,21 @@ const consistentBlankLines = {
 				if (prevSibling && nextSibling) {
 					const { node: prev } = prevSibling;
 					const { leading, node: next } = nextSibling;
-					checkPair(prev, next, leading[0] ?? next, () => sameJsxParagraph(prev, next, leading), () => false);
+					checkPair({
+						effectiveStart: leading[0] ?? next,
+						isSameParagraph: () => sameJsxParagraph({
+							leading,
+							next,
+							prev
+						}),
+						next,
+						prev,
+						shouldPreserveExtra: () => false
+					});
 				}
 			}
 		}
-		function checkPair(prev, next, effectiveStart, isSameParagraph, shouldPreserveExtra) {
+		function checkPair({ effectiveStart, isSameParagraph, next, prev, shouldPreserveExtra }) {
 			const prevEndLine = prev.loc.end.line;
 			const nextStartLine = effectiveStart.loc.start.line;
 			if (nextStartLine - prevEndLine < 1) return;
@@ -149,19 +171,27 @@ const consistentBlankLines = {
 		};
 	}
 };
-function sameParagraph(prev, next, sourceCode) {
+function sameParagraph({ next, prev, sourceCode }) {
 	if (hasMultiLineLeadingComment(next, sourceCode)) return false;
 	const prevHook = isHookStatement(prev);
 	const nextHook = isHookStatement(next);
-	if (prevHook || nextHook) return prevHook && nextHook && isMatchingVarDeclPair(prev, next);
-	return sharesNameFlow(prev, next, sourceCode) || sameShape(prev, next);
+	if (prevHook || nextHook) return prevHook && nextHook && isMatchingVarDeclPair({
+		next,
+		prev,
+		shouldMatchInitializers: false
+	});
+	return sharesNameFlow({
+		next,
+		prev,
+		sourceCode
+	}) || statementsBelongTogether(prev, next);
 }
 function isHookStatement(stmt) {
 	if (stmt.type === AST_NODE_TYPES.VariableDeclaration && stmt.declarations.length === 1) return isHookCall(stmt.declarations[0].init);
 	if (stmt.type === AST_NODE_TYPES.ExpressionStatement) return isHookCall(stmt.expression);
 	return false;
 }
-function sharesNameFlow(prev, next, sourceCode) {
+function sharesNameFlow({ next, prev, sourceCode }) {
 	if (isMultiLine(prev)) return false;
 	const nextType = unwrapExport(next).type;
 	if (isMultiLine(next) && HEAVY_NEXT_TYPES.has(nextType)) return false;
@@ -173,12 +203,15 @@ function sharesNameFlow(prev, next, sourceCode) {
 	return false;
 }
 function isHookCall(node) {
-	return node?.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.Identifier && /^use[A-Z]/.test(node.callee.name);
+	return node?.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.Identifier && /^use[A-Z]/u.test(node.callee.name);
 }
-function sameShape(prev, next) {
+function statementsBelongTogether(prev, next) {
 	if (isImportPair(prev, next)) return true;
 	if (isReExport(prev) && isReExport(next)) return true;
-	if (isMatchingVarDeclPair(prev, next)) return true;
+	if (isMatchingVarDeclPair({
+		next,
+		prev
+	})) return true;
 	if (isMatchingTypeAliasPair(prev, next)) return true;
 	if (FLOW_PREV_TYPES.has(prev.type) && FLOW_NEXT_TYPES.has(next.type)) {
 		if (HEAVY_NEXT_TYPES.has(next.type) && isMultiLine(next)) return false;
@@ -199,14 +232,14 @@ function isExpressionStatementPair(prev, next) {
 function isReExport(stmt) {
 	return stmt.type === AST_NODE_TYPES.ExportNamedDeclaration && stmt.source !== null || stmt.type === AST_NODE_TYPES.ExportAllDeclaration;
 }
-function isMatchingVarDeclPair(prev, next) {
+function isMatchingVarDeclPair({ next, prev, shouldMatchInitializers = true }) {
 	const previousDeclaration = unwrapExport(prev);
 	const nextDeclaration = unwrapExport(next);
 	if (previousDeclaration.type !== AST_NODE_TYPES.VariableDeclaration || nextDeclaration.type !== AST_NODE_TYPES.VariableDeclaration) return false;
 	if (!isConstOrLet(previousDeclaration) || !isConstOrLet(nextDeclaration)) return false;
 	if (isMultiLine(prev) || isMultiLine(next)) return false;
 	if (previousDeclaration.declarations.length !== 1 || nextDeclaration.declarations.length !== 1) return false;
-	if (!initsMatchByShape(previousDeclaration.declarations[0].init, nextDeclaration.declarations[0].init)) return false;
+	if (shouldMatchInitializers && !initializersBelongTogether(previousDeclaration.declarations[0].init, nextDeclaration.declarations[0].init)) return false;
 	return prev.type === AST_NODE_TYPES.ExportNamedDeclaration === (next.type === AST_NODE_TYPES.ExportNamedDeclaration);
 }
 function isMatchingTypeAliasPair(prev, next) {
@@ -223,13 +256,10 @@ function unwrapExport(stmt) {
 function isConstOrLet(decl) {
 	return decl.kind === "const" || decl.kind === "let";
 }
-function initsMatchByShape(prevInit, nextInit) {
+function initializersBelongTogether(prevInit, nextInit) {
 	const prevCall = asCall(prevInit);
 	const nextCall = asCall(nextInit);
-	if (prevCall && nextCall) {
-		if (calleesEqual(prevCall.callee, nextCall.callee)) return true;
-		return prevCall.arguments.length === 0 && nextCall.arguments.length === 0;
-	}
+	if (prevCall && nextCall) return calleesEqual(prevCall.callee, nextCall.callee);
 	if (prevCall || nextCall) return false;
 	return true;
 }
@@ -246,6 +276,8 @@ function calleesEqual(a, b) {
 		if (a.computed !== b.computed) return false;
 		if (!calleesEqual(a.object, b.object)) return false;
 		if (!a.computed && a.property.type === AST_NODE_TYPES.Identifier && b.property.type === AST_NODE_TYPES.Identifier) return a.property.name === b.property.name;
+		if (a.computed && a.property.type === AST_NODE_TYPES.Identifier && b.property.type === AST_NODE_TYPES.Identifier) return a.property.name === b.property.name;
+		if (a.computed && a.property.type === AST_NODE_TYPES.Literal && b.property.type === AST_NODE_TYPES.Literal) return a.property.value === b.property.value;
 		return false;
 	}
 	if (a.type === AST_NODE_TYPES.CallExpression && b.type === AST_NODE_TYPES.CallExpression) return calleesEqual(a.callee, b.callee);
@@ -257,7 +289,7 @@ function isGuardIf(stmt) {
 function blockAlwaysTerminates(node) {
 	if (TERMINATING_STATEMENT_TYPES.has(node.type)) return true;
 	if (node.type === AST_NODE_TYPES.BlockStatement) {
-		const last = node.body[node.body.length - 1];
+		const last = node.body.at(-1);
 		return last ? blockAlwaysTerminates(last) : false;
 	}
 	if (node.type === AST_NODE_TYPES.IfStatement) {
@@ -304,6 +336,7 @@ function collectBindingNames(node, set) {
 		case AST_NODE_TYPES.AssignmentPattern:
 			collectBindingNames(node.left, set);
 			break;
+		default: break;
 	}
 }
 function collectAssignmentRoots(target, set) {
@@ -319,16 +352,22 @@ function collectReferencedNames(root, sourceCode) {
 	const set = /* @__PURE__ */ new Set();
 	walk(root, (node) => {
 		if (node.type === AST_NODE_TYPES.Identifier && !isDeclarationOrPropertyKey(node)) {
-			if (resolvesOutsideRoot(node, root, sourceCode)) set.add(node.name);
+			if (resolvesOutsideRoot({
+				idNode: node,
+				root,
+				sourceCode
+			})) set.add(node.name);
 		} else if (node.type === AST_NODE_TYPES.ThisExpression) {
 			if (thisResolvesOutsideRoot(node, root)) set.add("this");
-		} else if (node.type === AST_NODE_TYPES.JSXIdentifier && isJsxComponentIdentifier(node)) {
-			if (resolvesOutsideRoot(node, root, sourceCode)) set.add(node.name);
-		}
+		} else if (node.type === AST_NODE_TYPES.JSXIdentifier && isJsxComponentIdentifier(node) && resolvesOutsideRoot({
+			idNode: node,
+			root,
+			sourceCode
+		})) set.add(node.name);
 	});
 	return set;
 }
-function resolvesOutsideRoot(idNode, root, sourceCode) {
+function resolvesOutsideRoot({ idNode, root, sourceCode }) {
 	let scope = sourceCode.getScope(idNode);
 	while (scope) {
 		const variable = scope.variables.find((v) => v.name === idNode.name);
@@ -349,7 +388,7 @@ function thisResolvesOutsideRoot(thisNode, root) {
 	return true;
 }
 function isJsxComponentIdentifier(node) {
-	if (!/^[A-Z]/.test(node.name)) return false;
+	if (!/^[A-Z]/u.test(node.name)) return false;
 	const parent = node.parent;
 	if (parent.type === AST_NODE_TYPES.JSXOpeningElement && parent.name === node) return true;
 	if (parent.type === AST_NODE_TYPES.JSXClosingElement && parent.name === node) return true;
@@ -379,7 +418,9 @@ function isInBindingPosition(idNode) {
 	let cur = idNode;
 	let parent = parentOf(cur);
 	while (parent) {
-		if (FN_DECL_TYPES.has(parent.type) && "params" in parent && Array.isArray(parent.params) && parent.params.includes(cur)) return true;
+		if (FN_DECL_TYPES.has(parent.type) && "params" in parent && Array.isArray(parent.params)) {
+			for (const parameter of parent.params) if (parameter === cur) return true;
+		}
 		if (parent.type === AST_NODE_TYPES.ObjectPattern || parent.type === AST_NODE_TYPES.ArrayPattern) return true;
 		if (parent.type === AST_NODE_TYPES.Property) {
 			if (parent.computed && parent.key === cur) return false;
@@ -402,9 +443,9 @@ function isInBindingPosition(idNode) {
 	}
 	return false;
 }
-function sameJsxParagraph(prev, next, leading) {
+function sameJsxParagraph({ leading, next, prev }) {
 	const firstLeading = leading[0];
-	const lastLeading = leading[leading.length - 1];
+	const lastLeading = leading.at(-1);
 	if (firstLeading && lastLeading && lastLeading.loc.end.line > firstLeading.loc.start.line) return false;
 	if (siblingsIncludeLiteralText(next)) return true;
 	return !(isMultiLine(prev) || isMultiLine(next));
@@ -422,22 +463,30 @@ function siblingsIncludeLiteralText(node) {
 	return false;
 }
 function expressionYieldsStringLiteral(expr) {
-	if (expr.type === AST_NODE_TYPES.Literal) return typeof expr.value === "string";
+	if (expr.type === AST_NODE_TYPES.Literal) return isString$2(expr.value);
 	if (expr.type === AST_NODE_TYPES.TemplateLiteral) return true;
 	if (expr.type === AST_NODE_TYPES.LogicalExpression) return expressionYieldsStringLiteral(expr.right);
 	if (expr.type === AST_NODE_TYPES.ConditionalExpression) return expressionYieldsStringLiteral(expr.consequent) || expressionYieldsStringLiteral(expr.alternate);
 	return false;
 }
+function isString$2(value) {
+	return typeof value === "string";
+}
+function isNode(value) {
+	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
 function walk(node, fn) {
-	if (!node || typeof node !== "object" || typeof node.type !== "string") return;
 	fn(node);
-	const nodeFields = node;
-	for (const key of Object.keys(nodeFields)) {
+	const nodeEntries = Object.entries(node);
+	for (const [key, child] of nodeEntries) {
 		if (SKIP_KEYS.has(key)) continue;
 		if (key === "body" && OPAQUE_BODY_TYPES.has(node.type)) continue;
-		const child = nodeFields[key];
-		if (Array.isArray(child)) for (const c of child) walk(c, fn);
-		else walk(child, fn);
+		if (isArray(child)) {
+			for (const childNode of child) if (isNode(childNode)) walk(childNode, fn);
+		} else if (isNode(child)) walk(child, fn);
 	}
 }
 function isMultiLine(node) {
@@ -447,23 +496,1940 @@ function hasMultiLineLeadingComment(node, sourceCode) {
 	const comments = sourceCode.getCommentsBefore(node);
 	if (comments.length === 0) return false;
 	const first = comments[0];
-	const last = comments[comments.length - 1];
+	const last = comments.at(-1);
 	return Boolean(first && last && last.loc.end.line > first.loc.start.line);
 }
 
 //#endregion
-//#region src/index.ts
-const plugin = {
+//#region src/rules/no-chained-type-assertions.ts
+function isTypeAssertionExpression(node) {
+	return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
+}
+function unwrapParenthesizedExpression(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
+function isConstAssertion$1(node) {
+	const { typeAnnotation } = node;
+	return typeAnnotation.type === "TSTypeReference" && typeAnnotation.typeName.type === "Identifier" && typeAnnotation.typeName.name === "const";
+}
+function isOutermostAssertionInChain(node) {
+	let current = node;
+	let parent = node.parent;
+	while (parent.type === "ParenthesizedExpression" && parent.expression === current) {
+		current = parent;
+		parent = parent.parent;
+	}
+	return !isTypeAssertionExpression(parent) || parent.expression !== current;
+}
+function isForbiddenAssertionChain(node) {
+	let assertionCount = 0;
+	let hasNonConstAssertion = false;
+	let current = node;
+	while (isTypeAssertionExpression(current)) {
+		assertionCount += 1;
+		hasNonConstAssertion ||= !isConstAssertion$1(current);
+		current = unwrapParenthesizedExpression(current.expression);
+	}
+	return assertionCount > 1 && hasNonConstAssertion;
+}
+/** Disallow nested TypeScript type assertions, while permitting chains made only of const assertions. */
+const noChainedTypeAssertionsRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow chained TypeScript as and angle-bracket assertions, including parenthesized chains." },
+		messages: { chained: "This assertion chain discards type evidence. Keep the original precise type, or parse untrusted input at its boundary before narrowing it." }
+	},
+	createOnce(context) {
+		const checkTypeAssertion = (node) => {
+			if (!isOutermostAssertionInChain(node) || !isForbiddenAssertionChain(node)) return;
+			context.report({
+				node,
+				messageId: "chained"
+			});
+		};
+		return {
+			TSAsExpression: checkTypeAssertion,
+			TSTypeAssertion: checkTypeAssertion
+		};
+	}
+});
+
+//#endregion
+//#region src/shared/scope.ts
+function resolveVariable(sourceCode, identifier) {
+	let scope = sourceCode.getScope(identifier);
+	while (scope !== null) {
+		const variable = scope.set.get(identifier.name);
+		if (variable !== void 0) return variable;
+		scope = scope.upper;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/rules/no-conditional-undefined-properties.ts
+function unwrapParentheses(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
+function isUndefinedExpression(sourceCode, expression) {
+	const unwrapped = unwrapParentheses(expression);
+	const undefinedVariable = unwrapped.type === "Identifier" && unwrapped.name === "undefined" ? resolveVariable(sourceCode, unwrapped) : void 0;
+	return unwrapped.type === "Identifier" && unwrapped.name === "undefined" && (undefinedVariable === null || undefinedVariable?.defs.length === 0) || unwrapped.type === "UnaryExpression" && unwrapped.operator === "void";
+}
+function hasConditionalUndefinedValue(sourceCode, value) {
+	const unwrapped = unwrapParentheses(value);
+	if (unwrapped.type !== "ConditionalExpression") return false;
+	return [unwrapped.consequent, unwrapped.alternate].some((branch) => isUndefinedExpression(sourceCode, branch) || hasConditionalUndefinedValue(sourceCode, branch));
+}
+function isObjectExpressionProperty(node) {
+	return node.type === "Property" && node.parent.type === "ObjectExpression";
+}
+/** Disallow conditional undefined values that retain an optional property. */
+const noConditionalUndefinedPropertiesRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow object properties whose conditional value is undefined." },
+		messages: { conditionalUndefined: "This conditional keeps the property present with an undefined value. Build a typed object and add the property only when present." }
+	},
+	createOnce(context) {
+		return { Property(node) {
+			if (isObjectExpressionProperty(node) && node.kind === "init" && !node.method && hasConditionalUndefinedValue(context.sourceCode, node.value)) context.report({
+				node,
+				messageId: "conditionalUndefined"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/no-enum-declarations.ts
+function isInsideAmbientModule(node) {
+	let current = node.parent;
+	while (current.type !== "Program") {
+		if (current.type === "TSModuleDeclaration" && current.declare) return true;
+		current = current.parent;
+	}
+	return false;
+}
+/** Prefer literal unions or constant objects over repository-owned TypeScript enums. */
+const noEnumDeclarationsRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow repository-owned enum declarations while preserving ambient enums." },
+		messages: { enumDeclaration: "Replace this enum with a literal union or an inferred constant object. Keep ambient enums only when their boundary requires them." }
+	},
+	create(context) {
+		const isDeclarationFile = /\.d\.[cm]?ts$/u.test(context.filename);
+		return { TSEnumDeclaration(node) {
+			if (!node.declare && !isDeclarationFile && !isInsideAmbientModule(node)) context.report({
+				node,
+				messageId: "enumDeclaration"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/shared/dictionary-types.ts
+const BUILT_INS = new Set([
+	"Record",
+	"Readonly",
+	"Partial",
+	"Required",
+	"Pick",
+	"Omit",
+	"PropertyKey",
+	"NonNullable"
+]);
+const TRANSPARENT_WRAPPERS = new Set([
+	"Readonly",
+	"Partial",
+	"Required",
+	"NonNullable"
+]);
+function declaredStatement(statement) {
+	return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration ?? null : statement;
+}
+function createTypeEnvironment(program) {
+	const aliases = /* @__PURE__ */ new Map();
+	const interfaces = /* @__PURE__ */ new Map();
+	const shadowedBuiltIns = /* @__PURE__ */ new Set();
+	for (const statement of program.body) {
+		const declaration = declaredStatement(statement);
+		if (declaration?.type === "ImportDeclaration") {
+			for (const specifier of declaration.specifiers) if (BUILT_INS.has(specifier.local.name)) shadowedBuiltIns.add(specifier.local.name);
+			continue;
+		}
+		if (declaration?.type === "TSTypeAliasDeclaration") {
+			if (aliases.get(declaration.id.name) === void 0) aliases.set(declaration.id.name, declaration);
+			else shadowedBuiltIns.add(declaration.id.name);
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+			continue;
+		}
+		if (declaration?.type === "TSInterfaceDeclaration") {
+			const declarations = interfaces.get(declaration.id.name) ?? [];
+			declarations.push(declaration);
+			interfaces.set(declaration.id.name, declarations);
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+			continue;
+		}
+		if (declaration?.type === "TSEnumDeclaration") {
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+			continue;
+		}
+		if ((declaration?.type === "ClassDeclaration" || declaration?.type === "FunctionDeclaration") && declaration.id !== null && BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+	}
+	return {
+		aliases,
+		interfaces,
+		shadowedBuiltIns
+	};
+}
+function typeReferenceName$2(type) {
+	return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function isBuiltIn(name, environment) {
+	return BUILT_INS.has(name) && !environment.shadowedBuiltIns.has(name);
+}
+function isUnappliedReferenceTo(type, name) {
+	const unwrapped = unwrapTransparentType(type);
+	return unwrapped.type === "TSTypeReference" && typeReferenceName$2(unwrapped) === name && (unwrapped.typeArguments?.params.length ?? 0) === 0;
+}
+function unwrapTransparentType(type) {
+	let current = type;
+	while (current.type === "TSParenthesizedType" || current.type === "TSTypeOperator" && current.operator === "readonly") current = current.typeAnnotation;
+	return current;
+}
+function isNeverType(type) {
+	return unwrapTransparentType(type).type === "TSNeverKeyword";
+}
+function optionalPropertyTypeAnnotation(member) {
+	return member.typeAnnotation;
+}
+function optionalMappedTypeAnnotation(type) {
+	return type.typeAnnotation;
+}
+function isEffectivelyEmptyMember(member) {
+	if (member.type !== "TSPropertySignature" || !member.optional) return false;
+	const typeAnnotation = optionalPropertyTypeAnnotation(member);
+	return typeAnnotation !== null && typeAnnotation !== void 0 && isNeverType(typeAnnotation.typeAnnotation);
+}
+function isEffectivelyEmptyTypeLiteral(type) {
+	return type.members.length === 0 || type.members.every(isEffectivelyEmptyMember);
+}
+function isEffectivelyEmptyInterface(declarations) {
+	if (declarations.length !== 1) return false;
+	const [type] = declarations;
+	return type?.extends.length === 0 && (type.body.body.length === 0 || type.body.body.every(isEffectivelyEmptyMember));
+}
+function resolvedSubstitutionArgument({ base, resolving = /* @__PURE__ */ new Set(), type }) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type !== "TSTypeReference") return type;
+	const name = typeReferenceName$2(unwrapped);
+	if (name === null || resolving.has(name)) return type;
+	const substitution = base.get(name);
+	if (substitution === void 0) return type;
+	return resolvedSubstitutionArgument({
+		base,
+		resolving: new Set([...resolving, name]),
+		type: substitution
+	});
+}
+function aliasSubstitution({ alias, base, type }) {
+	const parameters = alias.typeParameters?.params ?? [];
+	const arguments_ = type.typeArguments?.params ?? [];
+	const next = new Map(base);
+	for (const [index, parameter] of parameters.entries()) {
+		const argument = arguments_[index] ?? parameter.default;
+		if (argument === null) return null;
+		next.set(parameter.name.name, resolvedSubstitutionArgument({
+			base: next,
+			type: argument
+		}));
+	}
+	return next;
+}
+function unsafeDirectValue({ environment, resolvingAliases, substitutions, type }) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSUnknownKeyword") return "unknown";
+	if (unwrapped.type === "TSAnyKeyword") return "any";
+	if (unwrapped.type === "TSObjectKeyword") return "object";
+	if (unwrapped.type === "TSTypeLiteral" && isEffectivelyEmptyTypeLiteral(unwrapped)) return "empty-object";
+	if (unwrapped.type === "TSUnionType") return unwrapped.types.some((member) => unsafeDirectValue({
+		environment,
+		type: member,
+		substitutions,
+		resolvingAliases
+	}) !== null) ? "union" : null;
+	if (unwrapped.type === "TSIntersectionType") {
+		const unsafeMembers = unwrapped.types.map((member) => unsafeDirectValue({
+			environment,
+			resolvingAliases,
+			substitutions,
+			type: member
+		}));
+		if (unsafeMembers.includes("any")) return "any";
+		return unsafeMembers.length > 0 && unsafeMembers.every((member) => member !== null) ? unsafeMembers[0] ?? null : null;
+	}
+	if (unwrapped.type !== "TSTypeReference") return null;
+	const name = typeReferenceName$2(unwrapped);
+	if (name === null) return null;
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? null : unsafeDirectValue({
+			environment,
+			type: wrapped,
+			substitutions,
+			resolvingAliases
+		});
+	}
+	const substitution = substitutions.get(name);
+	if (substitution !== void 0) return isUnappliedReferenceTo(substitution, name) ? null : unsafeDirectValue({
+		environment,
+		type: substitution,
+		substitutions,
+		resolvingAliases
+	});
+	const interfaceDeclarations = environment.interfaces.get(name);
+	if (interfaceDeclarations !== void 0) return isEffectivelyEmptyInterface(interfaceDeclarations) ? "empty-object" : null;
+	const alias = environment.aliases.get(name);
+	if (alias === void 0 || resolvingAliases.has(name)) return null;
+	const nextSubstitutions = aliasSubstitution({
+		alias,
+		base: substitutions,
+		type: unwrapped
+	});
+	if (nextSubstitutions === null) return null;
+	return unsafeDirectValue({
+		environment,
+		resolvingAliases: new Set([...resolvingAliases, name]),
+		substitutions: nextSubstitutions,
+		type: alias.typeAnnotation
+	});
+}
+function dictionaryValueTypes({ environment, resolvingAliases, substitutions, type }) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.flatMap((member) => member.type === "TSIndexSignature" ? [{
+		type: member.typeAnnotation.typeAnnotation,
+		substitutions
+	}] : []);
+	if (unwrapped.type === "TSMappedType") {
+		const typeAnnotation = optionalMappedTypeAnnotation(unwrapped);
+		return typeAnnotation === null || typeAnnotation === void 0 ? [] : [{
+			type: typeAnnotation,
+			substitutions
+		}];
+	}
+	if (unwrapped.type !== "TSTypeReference") return [];
+	const name = typeReferenceName$2(unwrapped);
+	if (name === null) return [];
+	const substitution = substitutions.get(name);
+	if (substitution !== void 0) return isUnappliedReferenceTo(substitution, name) ? [] : dictionaryValueTypes({
+		environment,
+		type: substitution,
+		substitutions,
+		resolvingAliases
+	});
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? [] : dictionaryValueTypes({
+			environment,
+			type: wrapped,
+			substitutions,
+			resolvingAliases
+		});
+	}
+	if (name === "Record" && isBuiltIn(name, environment)) {
+		const value = unwrapped.typeArguments?.params[1] ?? null;
+		return value === null ? [] : [{
+			type: value,
+			substitutions
+		}];
+	}
+	if ((name === "Pick" || name === "Omit") && isBuiltIn(name, environment)) {
+		const source = unwrapped.typeArguments?.params[0];
+		return source === void 0 ? [] : dictionaryValueTypes({
+			environment,
+			type: source,
+			substitutions,
+			resolvingAliases
+		});
+	}
+	const alias = environment.aliases.get(name);
+	if (alias === void 0 || resolvingAliases.has(name)) return [];
+	const nextSubstitutions = aliasSubstitution({
+		alias,
+		base: substitutions,
+		type: unwrapped
+	});
+	if (nextSubstitutions === null) return [];
+	return dictionaryValueTypes({
+		environment,
+		resolvingAliases: new Set([...resolvingAliases, name]),
+		substitutions: nextSubstitutions,
+		type: alias.typeAnnotation
+	});
+}
+function classifyUnsafeDictionaryValue(valueType, environment) {
+	const unsafeValue = unsafeDirectValue({
+		environment,
+		resolvingAliases: /* @__PURE__ */ new Set(),
+		substitutions: /* @__PURE__ */ new Map(),
+		type: valueType
+	});
+	return unsafeValue === null ? null : {
+		kind: "unsafe-dictionary",
+		unsafeValue
+	};
+}
+function classifyUnsafeDictionary(type, environment) {
+	for (const valueType of dictionaryValueTypes({
+		environment,
+		resolvingAliases: /* @__PURE__ */ new Set(),
+		substitutions: /* @__PURE__ */ new Map(),
+		type
+	})) {
+		const unsafeValue = unsafeDirectValue({
+			environment,
+			resolvingAliases: /* @__PURE__ */ new Set(),
+			substitutions: valueType.substitutions,
+			type: valueType.type
+		});
+		if (unsafeValue !== null) return {
+			kind: "unsafe-dictionary",
+			unsafeValue
+		};
+	}
+	return null;
+}
+function resolvesToDictionary({ environment, resolvingAliases, substitutions, type }) {
+	return dictionaryValueTypes({
+		environment,
+		resolvingAliases,
+		substitutions,
+		type
+	}).length > 0;
+}
+function classifyWideningTarget(type, environment) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSUnknownKeyword") return { kind: "unknown" };
+	if (unwrapped.type === "TSObjectKeyword") return { kind: "object" };
+	if (unwrapped.type === "TSTypeLiteral") {
+		if (unwrapped.members.some((member) => member.type === "TSIndexSignature")) return { kind: "open dictionary" };
+		return unwrapped.members.length > 0 ? { kind: "anonymous object" } : null;
+	}
+	if (unwrapped.type === "TSMappedType") return { kind: "open dictionary" };
+	if (unwrapped.type !== "TSTypeReference") return null;
+	const name = typeReferenceName$2(unwrapped);
+	if (name === null) return null;
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? null : classifyWideningTarget(wrapped, environment);
+	}
+	if (name === "Record" && isBuiltIn(name, environment)) return { kind: "open dictionary" };
+	const alias = environment.aliases.get(name);
+	if (alias === void 0) return null;
+	if ((alias.typeParameters?.params.length ?? 0) > 0) {
+		const substitutions$1 = aliasSubstitution({
+			alias,
+			base: /* @__PURE__ */ new Map(),
+			type: unwrapped
+		});
+		return substitutions$1 !== null && resolvesToDictionary({
+			environment,
+			type: alias.typeAnnotation,
+			substitutions: substitutions$1,
+			resolvingAliases: new Set([name])
+		}) ? { kind: "generic container" } : null;
+	}
+	const substitutions = aliasSubstitution({
+		alias,
+		base: /* @__PURE__ */ new Map(),
+		type: unwrapped
+	});
+	if (substitutions === null) return null;
+	return classifyAliasBroadTarget({
+		environment,
+		type: alias.typeAnnotation,
+		substitutions,
+		resolvingAliases: new Set([name])
+	});
+}
+function isBroadMappedKey({ environment, substitutions, type }) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSStringKeyword" || unwrapped.type === "TSNumberKeyword" || unwrapped.type === "TSSymbolKeyword") return true;
+	if (unwrapped.type === "TSUnionType") return unwrapped.types.every((member) => isBroadMappedKey({
+		environment,
+		substitutions,
+		type: member
+	}));
+	if (unwrapped.type !== "TSTypeReference") return false;
+	const name = typeReferenceName$2(unwrapped);
+	if (name === null) return false;
+	const substitution = substitutions.get(name);
+	if (substitution !== void 0 && !isUnappliedReferenceTo(substitution, name)) return isBroadMappedKey({
+		environment,
+		substitutions,
+		type: substitution
+	});
+	return name === "PropertyKey" && isBuiltIn(name, environment);
+}
+function classifyAliasBroadTarget({ environment, resolvingAliases, substitutions, type }) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSUnknownKeyword") return { kind: "unknown" };
+	if (unwrapped.type === "TSObjectKeyword") return { kind: "object" };
+	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.some((member) => member.type === "TSIndexSignature") ? { kind: "open dictionary" } : null;
+	if (unwrapped.type === "TSMappedType") return isBroadMappedKey({
+		environment,
+		substitutions,
+		type: unwrapped.constraint
+	}) ? { kind: "open dictionary" } : null;
+	if (unwrapped.type !== "TSTypeReference") return null;
+	const name = typeReferenceName$2(unwrapped);
+	if (name === null) return null;
+	const substitution = substitutions.get(name);
+	if (substitution !== void 0) return isUnappliedReferenceTo(substitution, name) ? null : classifyAliasBroadTarget({
+		environment,
+		type: substitution,
+		substitutions,
+		resolvingAliases
+	});
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? null : classifyAliasBroadTarget({
+			environment,
+			type: wrapped,
+			substitutions,
+			resolvingAliases
+		});
+	}
+	if (name === "Record" && isBuiltIn(name, environment)) return { kind: "open dictionary" };
+	const alias = environment.aliases.get(name);
+	if (alias === void 0 || resolvingAliases.has(name)) return null;
+	const nextSubstitutions = aliasSubstitution({
+		alias,
+		base: substitutions,
+		type: unwrapped
+	});
+	if (nextSubstitutions === null) return null;
+	return classifyAliasBroadTarget({
+		environment,
+		resolvingAliases: new Set([...resolvingAliases, name]),
+		substitutions: nextSubstitutions,
+		type: alias.typeAnnotation
+	});
+}
+function isKnownEvidenceExpression(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression") current = current.expression;
+	if (current.type === "ObjectExpression") return true;
+	return current.type === "ArrayExpression" || current.type === "ArrowFunctionExpression" || current.type === "ClassExpression" || current.type === "FunctionExpression" || current.type === "NewExpression" || current.type === "Literal" || current.type === "TemplateLiteral" || current.type === "UnaryExpression";
+}
+
+//#endregion
+//#region src/rules/no-known-value-widening.ts
+function unwrapExpression$1(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") current = current.expression;
+	return current;
+}
+function variableDeclarator$1(variable) {
+	if (variable.defs.length !== 1) return null;
+	const [definition] = variable.defs;
+	return definition?.type === "Variable" && definition.node.type === "VariableDeclarator" ? definition.node : null;
+}
+function isStableConstVariable(variable, declarator) {
+	return declarator.parent.type === "VariableDeclaration" && declarator.parent.kind === "const" && variable.references.every((reference) => reference.init || !reference.isWrite());
+}
+function hasKnownEvidence({ expression, sourceCode, visitedVariables = /* @__PURE__ */ new Set() }) {
+	if (isKnownEvidenceExpression(expression)) return true;
+	const unwrapped = unwrapExpression$1(expression);
+	if (unwrapped.type !== "Identifier") return false;
+	const variable = resolveVariable(sourceCode, unwrapped);
+	if (variable === null || visitedVariables.has(variable)) return false;
+	const declarator = variableDeclarator$1(variable);
+	if (declarator === null) return false;
+	if (declarator.init === null || !isStableConstVariable(variable, declarator)) return false;
+	visitedVariables.add(variable);
+	return hasKnownEvidence({
+		expression: declarator.init,
+		sourceCode,
+		visitedVariables
+	});
+}
+function annotationTarget(annotation, environment) {
+	return annotation === null || annotation === void 0 ? null : classifyWideningTarget(annotation.typeAnnotation, environment);
+}
+function enclosingFunction(node) {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (current.type === "ArrowFunctionExpression" || current.type === "FunctionDeclaration" || current.type === "FunctionExpression") return current;
+		current = current.parent;
+	}
+	return null;
+}
+function sourceKeyName(sourceCode, key) {
+	if (key.type === "Identifier" || key.type === "PrivateIdentifier") return key.name;
+	if (key.type === "Literal") return String(key.value);
+	return sourceCode.getText(key);
+}
+function functionName(sourceCode, owner) {
+	if (owner === null) return "anonymous function";
+	if (owner.id !== null) return owner.id.name;
+	const parent = owner.parent;
+	if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") return parent.id.name;
+	if (parent.type === "MethodDefinition") return sourceKeyName(sourceCode, parent.key);
+	return "anonymous function";
+}
+function isDictionaryAccumulatorTarget(destination) {
+	return destination.kind === "open dictionary" || destination.kind === "generic container";
+}
+function isObjectExpression(expression) {
+	return unwrapExpression$1(expression).type === "ObjectExpression";
+}
+function hasParentAssertion(node) {
+	return node.parent?.type === "TSAsExpression" || node.parent?.type === "TSTypeAssertion";
+}
+/** Detect sound syntactic cases where a known value is explicitly widened and loses evidence. */
+const noKnownValueWideningRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow syntactically established values from flowing into explicitly broad or anonymous target types that discard useful evidence." },
+		messages: { widening: "The explicit {{target}} type on {{subject}} discards known type evidence. Keep inference, validate with `satisfies`, or use a named owner contract." }
+	},
+	createOnce(context) {
+		let environment = null;
+		const reportFlow = ({ destination, expression, subject }) => {
+			if (destination === null) return;
+			if (isDictionaryAccumulatorTarget(destination) && isObjectExpression(expression)) return;
+			if (!hasKnownEvidence({
+				expression,
+				sourceCode: context.sourceCode
+			})) return;
+			context.report({
+				node: expression,
+				messageId: "widening",
+				data: {
+					subject,
+					target: destination.kind
+				}
+			});
+		};
+		const targetFromAnnotation = (annotation) => environment === null ? null : annotationTarget(annotation, environment);
+		return {
+			Program(node) {
+				environment = createTypeEnvironment(node);
+			},
+			VariableDeclarator(node) {
+				if (node.init === null || node.id.type !== "Identifier") return;
+				reportFlow({
+					destination: targetFromAnnotation(node.id.typeAnnotation),
+					expression: node.init,
+					subject: `binding \`${node.id.name}\``
+				});
+			},
+			PropertyDefinition(node) {
+				if (node.value === null) return;
+				reportFlow({
+					destination: targetFromAnnotation(node.typeAnnotation),
+					expression: node.value,
+					subject: `property \`${sourceKeyName(context.sourceCode, node.key)}\``
+				});
+			},
+			AccessorProperty(node) {
+				if (node.value === null) return;
+				reportFlow({
+					destination: targetFromAnnotation(node.typeAnnotation),
+					expression: node.value,
+					subject: `property \`${sourceKeyName(context.sourceCode, node.key)}\``
+				});
+			},
+			AssignmentExpression(node) {
+				if (node.operator !== "=" || node.left.type !== "Identifier") return;
+				const variable = resolveVariable(context.sourceCode, node.left);
+				if (variable === null) return;
+				const declarator = variableDeclarator$1(variable);
+				if (declarator?.id.type !== "Identifier") return;
+				reportFlow({
+					destination: targetFromAnnotation(declarator.id.typeAnnotation),
+					expression: node.right,
+					subject: `binding \`${declarator.id.name}\``
+				});
+			},
+			ReturnStatement(node) {
+				if (node.argument === null) return;
+				const owner = enclosingFunction(node);
+				reportFlow({
+					destination: targetFromAnnotation(owner?.returnType),
+					expression: node.argument,
+					subject: `return value of \`${functionName(context.sourceCode, owner)}\``
+				});
+			},
+			ArrowFunctionExpression(node) {
+				if (node.body.type === "BlockStatement") return;
+				reportFlow({
+					destination: targetFromAnnotation(node.returnType),
+					expression: node.body,
+					subject: `return value of \`${functionName(context.sourceCode, node)}\``
+				});
+			},
+			TSAsExpression(node) {
+				if (environment === null || hasParentAssertion(node)) return;
+				reportFlow({
+					destination: classifyWideningTarget(node.typeAnnotation, environment),
+					expression: node.expression,
+					subject: "assertion"
+				});
+			},
+			TSTypeAssertion(node) {
+				if (environment === null || hasParentAssertion(node)) return;
+				reportFlow({
+					destination: classifyWideningTarget(node.typeAnnotation, environment),
+					expression: node.expression,
+					subject: "assertion"
+				});
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/shared/rule-options.ts
+/** Normalize the option shapes exposed by the ESLint and Oxlint contexts. */
+function ruleContextOptionsSchema(optionsSchema) {
+	return z.union([optionsSchema, z.array(optionsSchema)]).nullable().transform((options) => {
+		if (options === null) return;
+		if (Array.isArray(options)) return options[0];
+		return options;
+	});
+}
+
+//#endregion
+//#region src/rules/no-module-mocking.ts
+const moduleMockMethods = new Set([
+	"doMock",
+	"mock",
+	"unstable_mockModule"
+]);
+const ModuleMockContextOptionsSchema = ruleContextOptionsSchema(z.object({ internalModulePrefixes: z.array(z.string()).optional() }));
+function importedName(node) {
+	if (node.type !== "ImportSpecifier") return null;
+	return node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
+}
+function isGlobalReference(sourceCode, expression) {
+	const variable = resolveVariable(sourceCode, expression);
+	return variable === null || variable.defs.length === 0;
+}
+function isTestFrameworkObject(sourceCode, expression) {
+	if (expression.type !== "Identifier") return false;
+	if ((expression.name === "vi" || expression.name === "jest") && isGlobalReference(sourceCode, expression)) return true;
+	const variable = resolveVariable(sourceCode, expression);
+	if (variable === null || variable.defs.length === 0) return expression.name === "vi" || expression.name === "jest";
+	return variable.defs.some((definition) => {
+		if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") return false;
+		const source = definition.parent.source.value;
+		const name = importedName(definition.node);
+		return source === "vitest" && name === "vi" || source === "@jest/globals" && name === "jest";
+	});
+}
+function moduleMockCall(sourceCode, callee) {
+	if (!("property" in callee) || !("object" in callee) || !("computed" in callee)) return false;
+	if (!isTestFrameworkObject(sourceCode, callee.object)) return false;
+	const property = callee.property;
+	let method = null;
+	if (callee.computed && property.type === "Literal" && (property.value === "doMock" || property.value === "mock" || property.value === "unstable_mockModule")) method = property.value;
+	else if (!callee.computed && property.type === "Identifier") method = property.name;
+	return method !== null && moduleMockMethods.has(method);
+}
+function isRepositoryOwnedSpecifier(specifier, internalModulePrefixes) {
+	return specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#") || internalModulePrefixes.some((prefix) => specifier.startsWith(prefix));
+}
+function isString$1(value) {
+	return typeof value === "string";
+}
+/** Ban test framework mocking of repository-owned modules. */
+const noModuleMockingRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow Vitest and Jest mocking of repository-owned modules; tests must replace local dependencies through production seams." },
+		messages: { moduleMock: "Replace this local module mock through a production dependency seam and a faithful test implementation." },
+		schema: [{
+			type: "object",
+			properties: { internalModulePrefixes: {
+				type: "array",
+				items: {
+					type: "string",
+					minLength: 1
+				},
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}],
+		defaultOptions: [{ internalModulePrefixes: [] }]
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return;
+			if (!moduleMockCall(context.sourceCode, node.callee)) return;
+			const rawOptions = context.options;
+			const parsedOptions = ModuleMockContextOptionsSchema.safeParse(rawOptions);
+			const internalModulePrefixes = (parsedOptions.success ? parsedOptions.data : void 0)?.internalModulePrefixes ?? [];
+			const [specifier] = node.arguments;
+			if (specifier?.type !== "Literal" || !isString$1(specifier.value) || !isRepositoryOwnedSpecifier(specifier.value, internalModulePrefixes)) return;
+			context.report({
+				node,
+				messageId: "moduleMock"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/shared/lexical-type-parameters.ts
+const AstNodeSchema = z.custom((value) => z.object({ type: z.string() }).safeParse(value).success);
+function collectInferTypeParameterNames({ names, node, visitorKeys }) {
+	if (node.type === "TSInferType") names.add(node.typeParameter.name.name);
+	const childKeys = visitorKeys[node.type] ?? [];
+	for (const [key, value] of Object.entries(node)) {
+		if (!childKeys.includes(key)) continue;
+		const parsedNode = AstNodeSchema.safeParse(value);
+		if (parsedNode.success) {
+			collectInferTypeParameterNames({
+				names,
+				node: parsedNode.data,
+				visitorKeys
+			});
+			continue;
+		}
+		if (!Array.isArray(value)) continue;
+		for (const child of value) {
+			const parsedChild = AstNodeSchema.safeParse(child);
+			if (parsedChild.success) collectInferTypeParameterNames({
+				names,
+				node: parsedChild.data,
+				visitorKeys
+			});
+		}
+	}
+}
+/** Collect type binders that are in scope at a node and can shadow module aliases. */
+function lexicalTypeParameterNames(node, visitorKeys) {
+	const names = /* @__PURE__ */ new Set();
+	let descendant = node;
+	let current = node;
+	while (current.type !== "Program") {
+		if ("typeParameters" in current) for (const parameter of current.typeParameters?.params ?? []) names.add(parameter.name.name);
+		if (current.type === "TSMappedType" && (descendant === current.nameType || descendant === current.typeAnnotation)) names.add(current.key.name);
+		if (current.type === "TSConditionalType" && descendant === current.trueType) collectInferTypeParameterNames({
+			names,
+			node: current.extendsType,
+			visitorKeys
+		});
+		descendant = current;
+		current = current.parent;
+	}
+	return names;
+}
+
+//#endregion
+//#region src/shared/type-alias.ts
+function typeAliasDeclarationOf(definition) {
+	const runtimeDefinition = definition;
+	return runtimeDefinition.type === "Type" && runtimeDefinition.node.type === "TSTypeAliasDeclaration" ? runtimeDefinition.node : null;
+}
+function resolveTypeAlias(sourceCode, reference) {
+	if (reference.typeName.type !== "Identifier") return null;
+	let scope = sourceCode.getScope(reference);
+	while (scope !== null) {
+		const variable = scope.set.get(reference.typeName.name);
+		for (const definition of variable?.defs ?? []) {
+			const alias = typeAliasDeclarationOf(definition);
+			if (alias !== null) return alias;
+		}
+		scope = scope.upper;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/rules/no-object-parameters.ts
+function parameterAnnotation$1(parameter) {
+	if (parameter.type === "TSParameterProperty") return parameterAnnotation$1(parameter.parameter);
+	if (parameter.type === "RestElement") return parameter.typeAnnotation ?? parameterAnnotation$1(parameter.argument);
+	if (parameter.type === "AssignmentPattern") return parameter.left.typeAnnotation;
+	return parameter.typeAnnotation;
+}
+function parameterType$2(parameter) {
+	const annotation = parameterAnnotation$1(parameter);
+	if (annotation === null || annotation === void 0) return null;
+	const type = annotation.typeAnnotation;
+	return parameter.type === "RestElement" && type.type === "TSArrayType" ? type.elementType : type;
+}
+function parameterName$2(parameter, sourceCode) {
+	return parameter.type === "Identifier" ? parameter.name : sourceCode.getText(parameter).replace(/\s*:\s*object\s*$/u, "");
+}
+/** Ban the broad object type on function inputs, including local aliases to object. */
+const noObjectParametersRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow object function parameters; inputs must use an owner-provided type and be parsed at their boundary." },
+		messages: { objectParameter: "Parameter `{{parameter}}` uses the broad `object` type. Accept a named owner type; parse external input at its boundary before calling this function." }
+	},
+	createOnce(context) {
+		const resolvesToObject = ({ shadowedAliases, type, visited = /* @__PURE__ */ new Set() }) => {
+			if (type.type === "TSObjectKeyword") return true;
+			if (type.type === "TSParenthesizedType") return resolvesToObject({
+				shadowedAliases,
+				type: type.typeAnnotation,
+				visited
+			});
+			if (type.type === "TSUnionType") return type.types.some((member) => resolvesToObject({
+				shadowedAliases,
+				type: member,
+				visited
+			}));
+			if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier" || (type.typeArguments?.params.length ?? 0) > 0 || visited.has(type.typeName.name) || shadowedAliases.has(type.typeName.name)) return false;
+			const alias = resolveTypeAlias(context.sourceCode, type);
+			if (alias === null || (alias.typeParameters?.params.length ?? 0) > 0) return false;
+			const nextVisited = new Set([...visited, type.typeName.name]);
+			return resolvesToObject({
+				shadowedAliases,
+				type: alias.typeAnnotation,
+				visited: nextVisited
+			});
+		};
+		const checkParameters = (node) => {
+			const shadowedAliases = lexicalTypeParameterNames(node, context.sourceCode.visitorKeys);
+			for (const parameter of node.params) {
+				const type = parameterType$2(parameter);
+				if (type === null) continue;
+				if (!resolvesToObject({
+					shadowedAliases,
+					type
+				})) continue;
+				context.report({
+					node: type,
+					messageId: "objectParameter",
+					data: { parameter: parameterName$2(parameter, context.sourceCode) }
+				});
+			}
+		};
+		return {
+			ArrowFunctionExpression: checkParameters,
+			FunctionDeclaration: checkParameters,
+			FunctionExpression: checkParameters,
+			TSCallSignatureDeclaration: checkParameters,
+			TSConstructSignatureDeclaration: checkParameters,
+			TSConstructorType: checkParameters,
+			TSDeclareFunction: checkParameters,
+			TSEmptyBodyFunctionExpression: checkParameters,
+			TSFunctionType: checkParameters,
+			TSMethodSignature: checkParameters
+		};
+	}
+});
+
+//#endregion
+//#region src/shared/owned-function.ts
+function getOwnedFunctionName(node) {
+	if (node.type === "FunctionDeclaration") return node.id?.name ?? null;
+	const { parent } = node;
+	if (parent.type === "VariableDeclarator" && parent.init === node && parent.id.type === "Identifier") return parent.id.name;
+	if (parent.type === "Property" && parent.value === node && parent.parent.type === "ObjectExpression") return getStaticPropertyName({
+		isComputed: parent.computed,
+		key: parent.key
+	});
+	if ((parent.type === "MethodDefinition" || parent.type === "TSAbstractMethodDefinition") && parent.value === node) return getStaticPropertyName({
+		isComputed: parent.computed,
+		key: parent.key
+	});
+	if ((parent.type === "PropertyDefinition" || parent.type === "TSAbstractPropertyDefinition") && parent.value === node) return getStaticPropertyName({
+		isComputed: parent.computed,
+		key: parent.key
+	});
+	return null;
+}
+function getStaticPropertyName({ isComputed, key }) {
+	if (key.type === "PrivateIdentifier") return `#${key.name}`;
+	if (!isComputed && key.type === "Identifier") return key.name;
+	if (key.type === "Literal") return parseStaticPropertyValue(key.value);
+	return null;
+}
+function parseStaticPropertyValue(value) {
+	if (typeof value === "string" || typeof value === "number") return String(value);
+	return null;
+}
+
+//#endregion
+//#region src/rules/no-positional-boolean-parameters.ts
+const ContextOptionsSchema$2 = ruleContextOptionsSchema(z.object({ allowFunctionNames: z.array(z.string()).optional() }));
+function annotationOf(parameter) {
+	if (parameter.type === "TSParameterProperty") return annotationOf(parameter.parameter);
+	if (parameter.type === "AssignmentPattern") return parameter.left.typeAnnotation;
+	return parameter.typeAnnotation;
+}
+function parameterName$1(parameter, sourceCode) {
+	if (parameter.type === "TSParameterProperty") return parameterName$1(parameter.parameter, sourceCode);
+	if (parameter.type === "AssignmentPattern") return parameter.left.type === "Identifier" ? parameter.left.name : sourceCode.getText(parameter.left);
+	return parameter.type === "Identifier" ? parameter.name : sourceCode.getText(parameter);
+}
+/** Disallow positional boolean flags on repository-owned named callables. */
+const noPositionalBooleanParametersRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow explicit boolean parameters on repository-owned named callables." },
+		messages: { positionalBoolean: "Parameter `{{parameter}}` is a positional boolean flag on `{{functionName}}`. Replace it with a named options object." },
+		schema: [{
+			type: "object",
+			properties: { allowFunctionNames: {
+				type: "array",
+				items: {
+					type: "string",
+					minLength: 1
+				},
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}],
+		defaultOptions: [{ allowFunctionNames: [] }]
+	},
+	createOnce(context) {
+		const checkFunction = (node) => {
+			const functionName$1 = getOwnedFunctionName(node);
+			if (functionName$1 === null) return;
+			const rawOptions = context.options;
+			const parsedOptions = ContextOptionsSchema$2.safeParse(rawOptions);
+			if ((parsedOptions.success ? parsedOptions.data : void 0)?.allowFunctionNames?.includes(functionName$1) === true) return;
+			for (const parameter of node.params) {
+				if (parameter.type === "RestElement") continue;
+				const annotation = annotationOf(parameter);
+				if (annotation?.typeAnnotation.type !== "TSBooleanKeyword") continue;
+				context.report({
+					node: annotation.typeAnnotation,
+					messageId: "positionalBoolean",
+					data: {
+						functionName: functionName$1,
+						parameter: parameterName$1(parameter, context.sourceCode)
+					}
+				});
+			}
+		};
+		return {
+			ArrowFunctionExpression: checkFunction,
+			FunctionDeclaration: checkFunction,
+			FunctionExpression: checkFunction
+		};
+	}
+});
+
+//#endregion
+//#region src/shared/reflect-method.ts
+function isGlobalReflect(sourceCode, expression) {
+	if (expression.type !== "Identifier" || expression.name !== "Reflect") return false;
+	const variable = resolveVariable(sourceCode, expression);
+	return variable === null || variable.defs.length === 0;
+}
+/** Reports whether a call target names one method on the global Reflect object. */
+function isGlobalReflectMethodCall({ callee, methodName, sourceCode }) {
+	if (!("property" in callee) || !("object" in callee) || !("computed" in callee)) return false;
+	if (!isGlobalReflect(sourceCode, callee.object)) return false;
+	const property = callee.property;
+	return callee.computed ? property.type === "Literal" && property.value === methodName : property.type === "Identifier" && property.name === methodName;
+}
+
+//#endregion
+//#region src/rules/no-reflect-apply.ts
+/** Ban Reflect.apply, which bypasses ordinary typed function calls. */
+const noReflectApplyRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow Reflect.apply; call typed functions directly or model dynamic dispatch behind an interface." },
+		messages: { reflectApply: "Replace `Reflect.apply` with a typed function call. Model dynamic dispatch behind a named interface." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return;
+			if (isGlobalReflectMethodCall({
+				callee: node.callee,
+				methodName: "apply",
+				sourceCode: context.sourceCode
+			})) context.report({
+				node,
+				messageId: "reflectApply"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/no-reflect-get.ts
+/** Ban Reflect.get, which bypasses ordinary property access and useful type evidence. */
+const noReflectGetRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow Reflect.get; use typed property access or parse dynamic input into a domain type." },
+		messages: { reflectGet: "Replace `Reflect.get` with typed property access. Parse dynamic input into a named domain type before reading it." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return;
+			if (isGlobalReflectMethodCall({
+				callee: node.callee,
+				methodName: "get",
+				sourceCode: context.sourceCode
+			})) context.report({
+				node,
+				messageId: "reflectGet"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/no-unhandled-detached-promises.ts
+function unwrapExpression(expression) {
+	if (expression.type === "ChainExpression" || expression.type === "ParenthesizedExpression" || expression.type === "TSAsExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSTypeAssertion") return unwrapExpression(expression.expression);
+	return expression;
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function staticMemberName(expression) {
+	if (!expression.computed && expression.property.type === "Identifier") return expression.property.name;
+	if (expression.computed && expression.property.type === "Literal" && isString(expression.property.value)) return expression.property.value;
+	return null;
+}
+function isRejectionHandler(argument) {
+	if (argument === void 0 || argument.type === "SpreadElement") return false;
+	const unwrapped = unwrapExpression(argument);
+	if (unwrapped.type === "Identifier") return unwrapped.name !== "undefined";
+	return ![
+		"ArrayExpression",
+		"BinaryExpression",
+		"JSXElement",
+		"JSXFragment",
+		"Literal",
+		"ObjectExpression",
+		"TemplateLiteral"
+	].includes(unwrapped.type);
+}
+function hasRejectionHandler(expression) {
+	const unwrapped = unwrapExpression(expression);
+	if (unwrapped.type !== "CallExpression") return false;
+	if (unwrapped.callee.type !== "Super" && unwrapped.callee.type !== "V8IntrinsicExpression" && "object" in unwrapped.callee && "property" in unwrapped.callee) {
+		const memberName = staticMemberName(unwrapped.callee);
+		if (memberName === "catch") return isRejectionHandler(unwrapped.arguments[0]);
+		if (memberName === "then") return isRejectionHandler(unwrapped.arguments[1]);
+		return hasRejectionHandler(unwrapped.callee.object);
+	}
+	return false;
+}
+/** Treat `void` calls as detached work and require a rejection handler. */
+const noUnhandledDetachedPromisesRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow void-marked detached call chains that do not install a rejection handler." },
+		messages: { unhandledDetachedPromise: "A `void` call marks detached work and must handle rejection. Add `.catch(...)` or a second `.then(...)` callback at this boundary." }
+	},
+	createOnce(context) {
+		return { UnaryExpression(node) {
+			if (node.operator === "void" && unwrapExpression(node.argument).type === "CallExpression" && !hasRejectionHandler(node.argument)) context.report({
+				node,
+				messageId: "unhandledDetachedPromise"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/shared/boundary-decoder.ts
+function parameterType$1(parameter) {
+	if (parameter.type === "TSParameterProperty") return parameterType$1(parameter.parameter);
+	if (parameter.type === "AssignmentPattern") return parameterType$1(parameter.left);
+	if (parameter.type === "RestElement") {
+		const annotation = parameter.typeAnnotation;
+		if (annotation?.typeAnnotation.type === "TSArrayType") return annotation.typeAnnotation.elementType;
+		return parameterType$1(parameter.argument);
+	}
+	return parameter.typeAnnotation?.typeAnnotation ?? null;
+}
+function hasDecodedReturnType(owner) {
+	const returnType = owner.returnType?.typeAnnotation;
+	if (returnType === void 0) return false;
+	return ![
+		"TSAnyKeyword",
+		"TSUndefinedKeyword",
+		"TSUnknownKeyword",
+		"TSVoidKeyword"
+	].includes(returnType.type);
+}
+/** Identify a boundary that converts an explicitly untrusted input into a typed result. */
+function isBoundaryDecoder(owner) {
+	return owner.params.some((parameter) => parameterType$1(parameter)?.type === "TSUnknownKeyword") && hasDecodedReturnType(owner);
+}
+
+//#endregion
+//#region src/rules/no-unknown-parameters.ts
+const ContextOptionsSchema$1 = ruleContextOptionsSchema(z.object({ allowParameterNames: z.array(z.string()).optional() }));
+function parameterAnnotation(parameter) {
+	if (parameter.type === "TSParameterProperty") return parameterAnnotation(parameter.parameter);
+	if (parameter.type === "RestElement") return parameter.typeAnnotation ?? parameterAnnotation(parameter.argument);
+	if (parameter.type === "AssignmentPattern") return parameter.left.typeAnnotation;
+	return parameter.typeAnnotation;
+}
+function parameterType(parameter) {
+	const annotation = parameterAnnotation(parameter);
+	if (annotation === null || annotation === void 0) return null;
+	const type = annotation.typeAnnotation;
+	return parameter.type === "RestElement" && type.type === "TSArrayType" ? type.elementType : type;
+}
+function parameterName(parameter, sourceText) {
+	if (parameter.type === "TSParameterProperty") return parameterName(parameter.parameter, sourceText);
+	if (parameter.type === "AssignmentPattern") return parameterName(parameter.left, sourceText);
+	if (parameter.type === "RestElement") return parameterName(parameter.argument, sourceText);
+	return parameter.type === "Identifier" ? parameter.name : sourceText.replace(/\s*:\s*unknown\s*$/u, "");
+}
+/** Keep unknown inputs at explicit decoding and error-enrichment boundaries. */
+const noUnknownParametersRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow explicitly unknown parameters outside decoders and error-cause enrichment boundaries." },
+		messages: { unknownParameter: "Parameter `{{parameter}}` leaves input unparsed. Accept a named domain type; run the expected schema or parser at the I/O boundary before calling this function." },
+		schema: [{
+			type: "object",
+			properties: { allowParameterNames: {
+				type: "array",
+				items: {
+					type: "string",
+					minLength: 1
+				},
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}],
+		defaultOptions: [{ allowParameterNames: [] }]
+	},
+	createOnce(context) {
+		const checkParameters = (node) => {
+			if (isBoundaryDecoder(node)) return;
+			const parsedOptions = ContextOptionsSchema$1.safeParse(context.options);
+			const options = parsedOptions.success ? parsedOptions.data : void 0;
+			for (const parameter of node.params) {
+				const type = parameterType(parameter);
+				if (type?.type !== "TSUnknownKeyword") continue;
+				const name = parameterName(parameter, context.sourceCode.getText(parameter));
+				if (name === "cause" || options?.allowParameterNames?.includes(name) === true) continue;
+				context.report({
+					node: type,
+					messageId: "unknownParameter",
+					data: { parameter: name }
+				});
+			}
+		};
+		return {
+			ArrowFunctionExpression: checkParameters,
+			FunctionDeclaration: checkParameters,
+			FunctionExpression: checkParameters,
+			TSCallSignatureDeclaration: checkParameters,
+			TSConstructSignatureDeclaration: checkParameters,
+			TSConstructorType: checkParameters,
+			TSDeclareFunction: checkParameters,
+			TSEmptyBodyFunctionExpression: checkParameters,
+			TSFunctionType: checkParameters,
+			TSMethodSignature: checkParameters
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/no-unknown-returns.ts
+function referencedAliasName$1(type) {
+	if (type.type === "TSParenthesizedType") return referencedAliasName$1(type.typeAnnotation);
+	if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier") return null;
+	return (type.typeArguments?.params.length ?? 0) === 0 ? type.typeName.name : null;
+}
+/** Ban function contracts that return unknown instead of a parsed domain type. */
+const noUnknownReturnsRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow functions whose explicit return contract is unknown or Promise<unknown>." },
+		messages: { unknownReturn: "This function exposes `unknown` to its caller. Parse the value at its boundary and return a named domain type." }
+	},
+	createOnce(context) {
+		const resolvesToUnknown = ({ shadowedAliases, type, visited = /* @__PURE__ */ new Set() }) => {
+			if (type.type === "TSUnknownKeyword") return true;
+			if (type.type === "TSParenthesizedType") return resolvesToUnknown({
+				shadowedAliases,
+				type: type.typeAnnotation,
+				visited
+			});
+			if (type.type === "TSUnionType") return type.types.some((member) => resolvesToUnknown({
+				shadowedAliases,
+				type: member,
+				visited
+			}));
+			if (type.type === "TSTypeReference" && type.typeName.type === "Identifier" && (type.typeName.name === "Promise" || type.typeName.name === "PromiseLike")) {
+				const value = type.typeArguments?.params[0];
+				return value !== void 0 && resolvesToUnknown({
+					shadowedAliases,
+					type: value,
+					visited
+				});
+			}
+			const name = referencedAliasName$1(type);
+			if (name === null || visited.has(name) || shadowedAliases.has(name)) return false;
+			const alias = type.type === "TSTypeReference" ? resolveTypeAlias(context.sourceCode, type) : null;
+			if (alias === null || (alias.typeParameters?.params.length ?? 0) > 0) return false;
+			const nextVisited = new Set([...visited, name]);
+			return resolvesToUnknown({
+				shadowedAliases,
+				type: alias.typeAnnotation,
+				visited: nextVisited
+			});
+		};
+		const checkReturnType = (node) => {
+			const annotation = node.returnType;
+			if (annotation === null || annotation === void 0) return;
+			if (!resolvesToUnknown({
+				shadowedAliases: lexicalTypeParameterNames(node, context.sourceCode.visitorKeys),
+				type: annotation.typeAnnotation
+			})) return;
+			context.report({
+				node: annotation.typeAnnotation,
+				messageId: "unknownReturn"
+			});
+		};
+		return {
+			ArrowFunctionExpression: checkReturnType,
+			FunctionDeclaration: checkReturnType,
+			FunctionExpression: checkReturnType,
+			TSCallSignatureDeclaration: checkReturnType,
+			TSConstructSignatureDeclaration: checkReturnType,
+			TSConstructorType: checkReturnType,
+			TSDeclareFunction: checkReturnType,
+			TSEmptyBodyFunctionExpression: checkReturnType,
+			TSFunctionType: checkReturnType,
+			TSMethodSignature: checkReturnType
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/no-unknown-type-aliases.ts
+function referencedAliasName(type) {
+	if (type.type === "TSParenthesizedType") return referencedAliasName(type.typeAnnotation);
+	if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier") return null;
+	return (type.typeArguments?.params.length ?? 0) === 0 ? type.typeName.name : null;
+}
+/** Ban named aliases that merely conceal TypeScript's unknown top type. */
+const noUnknownTypeAliasesRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow type aliases whose resolved type is unknown; unknown must remain visible at an allowed boundary." },
+		messages: { unknownAlias: "Type alias `{{alias}}` hides `unknown`. Keep `unknown` explicit at the parsing boundary or on an allowed `cause` field; otherwise use the parsed owner type." }
+	},
+	createOnce(context) {
+		const resolvesToUnknown = (type, visited = /* @__PURE__ */ new Set()) => {
+			if (type.type === "TSUnknownKeyword") return true;
+			if (type.type === "TSParenthesizedType") return resolvesToUnknown(type.typeAnnotation, visited);
+			if (type.type === "TSUnionType") return type.types.some((member) => resolvesToUnknown(member, visited));
+			const name = referencedAliasName(type);
+			if (name === null || visited.has(name)) return false;
+			const alias = type.type === "TSTypeReference" ? resolveTypeAlias(context.sourceCode, type) : null;
+			if (alias === null || (alias.typeParameters?.params.length ?? 0) > 0) return false;
+			const nextVisited = new Set([...visited, name]);
+			return resolvesToUnknown(alias.typeAnnotation, nextVisited);
+		};
+		return { TSTypeAliasDeclaration(node) {
+			if (!resolvesToUnknown(node.typeAnnotation, new Set([node.id.name]))) return;
+			context.report({
+				node: node.id,
+				messageId: "unknownAlias",
+				data: { alias: node.id.name }
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/no-unsafe-dictionary-type.ts
+const typeNodeKinds = new Set([
+	"JSDocNonNullableType",
+	"JSDocNullableType",
+	"JSDocUnknownType",
+	"TSAnyKeyword",
+	"TSArrayType",
+	"TSBigIntKeyword",
+	"TSBooleanKeyword",
+	"TSConditionalType",
+	"TSConstructorType",
+	"TSFunctionType",
+	"TSImportType",
+	"TSIndexedAccessType",
+	"TSInferType",
+	"TSIntersectionType",
+	"TSIntrinsicKeyword",
+	"TSLiteralType",
+	"TSMappedType",
+	"TSNamedTupleMember",
+	"TSNeverKeyword",
+	"TSNullKeyword",
+	"TSNumberKeyword",
+	"TSObjectKeyword",
+	"TSParenthesizedType",
+	"TSStringKeyword",
+	"TSSymbolKeyword",
+	"TSTemplateLiteralType",
+	"TSThisType",
+	"TSTupleType",
+	"TSTypeLiteral",
+	"TSTypeOperator",
+	"TSTypePredicate",
+	"TSTypeQuery",
+	"TSTypeReference",
+	"TSUndefinedKeyword",
+	"TSUnionType",
+	"TSUnknownKeyword",
+	"TSVoidKeyword"
+]);
+function isTypeNode(node) {
+	return typeNodeKinds.has(node.type);
+}
+function typeReferenceName$1(type) {
+	return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function isInsideTypeAliasDeclaration(node) {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (current.type === "TSTypeAliasDeclaration") return true;
+		current = current.parent;
+	}
+	return false;
+}
+function isPlainAliasConsumerUse(node, environment) {
+	if (node.type !== "TSTypeReference" || (node.typeArguments?.params.length ?? 0) > 0) return false;
+	const name = typeReferenceName$1(node);
+	return name !== null && environment.aliases.has(name) && !isInsideTypeAliasDeclaration(node);
+}
+function shouldReportType(node, environment) {
+	if (isPlainAliasConsumerUse(node, environment)) return false;
+	if (classifyUnsafeDictionary(node, environment) === null) return false;
+	let current = node.parent;
+	while (current.type !== "Program") {
+		if (isTypeNode(current) && classifyUnsafeDictionary(current, environment) !== null) return false;
+		current = current.parent;
+	}
+	return true;
+}
+/** Disallow object-dictionary contracts whose direct value type is an unsafe escape hatch. */
+const noUnsafeDictionaryTypeRule = defineRule({
 	meta: {
-		name: "@utilfirst/eslint-plugin",
-		version
+		type: "problem",
+		docs: { description: "Disallow object-dictionary contracts whose direct value type is unknown, any, object, {}, or a union/alias containing one of those escape hatches." },
+		messages: { unsafeDictionary: "This dictionary's {{value}} value type gives callers no concrete value contract. Use an owner/schema-derived value type; parse external payloads before insertion." }
 	},
-	rules: { "consistent-blank-lines": consistentBlankLines },
-	configs: {}
+	createOnce(context) {
+		let environment;
+		const report = (node, value) => {
+			context.report({
+				node,
+				messageId: "unsafeDictionary",
+				data: { value }
+			});
+		};
+		const reportIfUnsafe = (node) => {
+			if (!shouldReportType(node, environment)) return;
+			const unsafe = classifyUnsafeDictionary(node, environment);
+			if (unsafe === null) return;
+			report(node, unsafe.unsafeValue);
+		};
+		return {
+			Program(node) {
+				environment = createTypeEnvironment(node);
+			},
+			TSTypeReference: reportIfUnsafe,
+			TSTypeLiteral: reportIfUnsafe,
+			TSMappedType: reportIfUnsafe,
+			TSIndexSignature(node) {
+				if (node.parent.type === "TSTypeLiteral") return;
+				const unsafe = classifyUnsafeDictionaryValue(node.typeAnnotation.typeAnnotation, environment);
+				if (unsafe !== null) report(node, unsafe.unsafeValue);
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/no-widen-then-assert.ts
+const functionBoundaryTypes = new Set([
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"TSDeclareFunction",
+	"TSEmptyBodyFunctionExpression"
+]);
+function unwrapExpressionParentheses(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
+function unwrapTypeParentheses(type) {
+	let current = type;
+	while (current.type === "TSParenthesizedType") current = current.typeAnnotation;
+	return current;
+}
+function typeReferenceName(type) {
+	return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function isUnknownOrAnyType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	return unwrapped.type === "TSUnknownKeyword" || unwrapped.type === "TSAnyKeyword";
+}
+function isBroadRecordKeyType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	if (unwrapped.type === "TSStringKeyword" || unwrapped.type === "TSNumberKeyword" || unwrapped.type === "TSSymbolKeyword") return true;
+	if (unwrapped.type === "TSUnionType") return unwrapped.types.every(isBroadRecordKeyType);
+	return unwrapped.type === "TSTypeReference" && typeReferenceName(unwrapped) === "PropertyKey";
+}
+function isBroadRecordType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	if (unwrapped.type === "TSTypeReference") {
+		if (typeReferenceName(unwrapped) === "Readonly") {
+			const [inner] = unwrapped.typeArguments?.params ?? [];
+			return inner !== void 0 && isBroadRecordType(inner);
+		}
+		if (typeReferenceName(unwrapped) !== "Record") return false;
+		const parameters = unwrapped.typeArguments?.params ?? [];
+		return parameters.length === 2 && parameters[0] !== void 0 && parameters[1] !== void 0 && isBroadRecordKeyType(parameters[0]) && isUnknownOrAnyType(parameters[1]);
+	}
+	if (unwrapped.type !== "TSTypeLiteral" || unwrapped.members.length !== 1) return false;
+	const [member] = unwrapped.members;
+	const [parameter] = member?.type === "TSIndexSignature" ? member.parameters : [];
+	return member?.type === "TSIndexSignature" && member.parameters.length === 1 && parameter !== void 0 && isBroadRecordKeyType(parameter.typeAnnotation.typeAnnotation) && isUnknownOrAnyType(member.typeAnnotation.typeAnnotation);
+}
+function broadTypeKind(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	if (unwrapped.type === "TSUnknownKeyword" || unwrapped.type === "TSAnyKeyword") return "top";
+	if (unwrapped.type === "TSObjectKeyword") return "object";
+	return isBroadRecordType(unwrapped) ? "record" : null;
+}
+function assertedExpression(node) {
+	return unwrapExpressionParentheses(node.expression);
+}
+function assertionFromExpression(expression) {
+	const unwrapped = unwrapExpressionParentheses(expression);
+	return unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion" ? unwrapped : null;
+}
+function normalizedTypeText(sourceText, type) {
+	return sourceText.slice(type.range[0], type.range[1]).replaceAll(/\s+/gu, "");
+}
+function typesHaveSameSyntax({ left, right, sourceText }) {
+	return left !== null && normalizedTypeText(sourceText, unwrapTypeParentheses(left)) === normalizedTypeText(sourceText, unwrapTypeParentheses(right));
+}
+function isDefinitelyObjectType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	if (unwrapped.type === "TSArrayType" || unwrapped.type === "TSConstructorType" || unwrapped.type === "TSFunctionType" || unwrapped.type === "TSMappedType" || unwrapped.type === "TSObjectKeyword" || unwrapped.type === "TSTupleType") return true;
+	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.length > 0;
+	if (unwrapped.type === "TSIntersectionType") return unwrapped.types.every(isDefinitelyObjectType);
+	if (unwrapped.type === "TSTypeOperator") return unwrapped.operator === "readonly" && isDefinitelyObjectType(unwrapped.typeAnnotation);
+	return false;
+}
+function isDefinitelyNarrowerRecordType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.some((member) => member.type !== "TSIndexSignature");
+	if (unwrapped.type !== "TSTypeReference") return false;
+	if (typeReferenceName(unwrapped) === "Readonly") {
+		const [inner] = unwrapped.typeArguments?.params ?? [];
+		return inner !== void 0 && isDefinitelyNarrowerRecordType(inner);
+	}
+	if (typeReferenceName(unwrapped) !== "Record") return false;
+	const parameters = unwrapped.typeArguments?.params ?? [];
+	return parameters.length === 2 && parameters[1] !== void 0 && !isUnknownOrAnyType(parameters[1]);
+}
+function functionBoundary(node) {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (functionBoundaryTypes.has(current.type)) return current;
+		current = current.parent;
+	}
+	return null;
+}
+function resolvedVariableForIdentifier(scopes, identifier) {
+	for (const scope of scopes) {
+		const reference = scope.references.find((candidate) => candidate.identifier.range[0] === identifier.range[0] && candidate.identifier.range[1] === identifier.range[1]);
+		if (reference !== void 0) return reference.resolved;
+	}
+	return null;
+}
+function variableDeclarator(variable) {
+	for (const definition of variable.defs) if (definition.type === "Variable" && definition.node.type === "VariableDeclarator") return definition.node;
+	return null;
+}
+function knownValueEvidence({ boundary, expression, scopes, visitedVariables }) {
+	const unwrapped = unwrapExpressionParentheses(expression);
+	if (unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion") {
+		if (broadTypeKind(unwrapped.typeAnnotation) !== null) return null;
+		return { type: unwrapped.typeAnnotation };
+	}
+	if (unwrapped.type === "Literal" || unwrapped.type === "TemplateLiteral") return { type: null };
+	if (unwrapped.type === "ArrayExpression" || unwrapped.type === "ArrowFunctionExpression" || unwrapped.type === "ClassExpression" || unwrapped.type === "FunctionExpression" || unwrapped.type === "NewExpression" || unwrapped.type === "ObjectExpression") return { type: null };
+	if (unwrapped.type !== "Identifier") return null;
+	const variable = resolvedVariableForIdentifier(scopes, unwrapped);
+	if (variable === null || visitedVariables.has(variable)) return null;
+	const annotatedIdentifier = variable.identifiers.find((identifier) => identifier.typeAnnotation !== null && identifier.typeAnnotation !== void 0);
+	const annotation = annotatedIdentifier?.typeAnnotation?.typeAnnotation;
+	if (annotation !== void 0 && annotatedIdentifier !== void 0) {
+		if (functionBoundary(annotatedIdentifier) !== boundary || broadTypeKind(annotation) !== null) return null;
+		return { type: annotation };
+	}
+	const declarator = variableDeclarator(variable);
+	if (declarator?.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init) || functionBoundary(declarator) !== boundary) return null;
+	return knownValueEvidence({
+		scopes,
+		boundary,
+		expression: declarator.init,
+		visitedVariables: new Set([...visitedVariables, variable])
+	});
+}
+function widenedBinding(variable, scopes) {
+	const declarator = variableDeclarator(variable);
+	if (declarator?.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.id.type !== "Identifier" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init)) return null;
+	const boundary = functionBoundary(declarator);
+	const declaredType = declarator.id.typeAnnotation?.typeAnnotation;
+	const initializerAssertion = assertionFromExpression(declarator.init);
+	const initializerBroadKind = initializerAssertion === null ? null : broadTypeKind(initializerAssertion.typeAnnotation);
+	const broadKind = (declaredType === void 0 ? null : broadTypeKind(declaredType)) ?? initializerBroadKind;
+	if (broadKind === null) return null;
+	const evidence = knownValueEvidence({
+		expression: initializerAssertion !== null && initializerBroadKind !== null ? assertedExpression(initializerAssertion) : declarator.init,
+		scopes,
+		boundary,
+		visitedVariables: new Set([variable])
+	});
+	return evidence === null ? null : {
+		broadKind,
+		evidence,
+		declaredAt: declarator.range[1],
+		boundary
+	};
+}
+function assertionIsNarrower({ assertedType, broadKind, evidence, sourceText }) {
+	if (broadTypeKind(assertedType) !== null) return false;
+	if (broadKind === "top") return true;
+	if (typesHaveSameSyntax({
+		left: evidence.type,
+		right: assertedType,
+		sourceText
+	})) return true;
+	if (broadKind === "object") return isDefinitelyObjectType(assertedType);
+	return isDefinitelyNarrowerRecordType(assertedType);
+}
+/** Detect immutable local bindings that erase a known type and are later asserted back to a narrower type. */
+const noWidenThenAssertRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow local const flows that explicitly widen a known value before asserting the widened binding to a narrower type." },
+		messages: { widenThenAssert: "Binding \"{{name}}\" discards type evidence and later recreates it with an assertion. Keep the precise type from initialization through use; parse boundary input once." }
+	},
+	createOnce(context) {
+		let scopes = [];
+		const checkAssertion = (node) => {
+			const expression = assertedExpression(node);
+			if (expression.type !== "Identifier") return;
+			const variable = resolvedVariableForIdentifier(scopes, expression);
+			if (variable === null) return;
+			const widened = widenedBinding(variable, scopes);
+			if (widened === null || node.range[0] <= widened.declaredAt || functionBoundary(node) !== widened.boundary || !assertionIsNarrower({
+				assertedType: node.typeAnnotation,
+				broadKind: widened.broadKind,
+				evidence: widened.evidence,
+				sourceText: context.sourceCode.text
+			})) return;
+			context.report({
+				node,
+				messageId: "widenThenAssert",
+				data: { name: expression.name }
+			});
+		};
+		return {
+			Program() {
+				scopes = context.sourceCode.scopeManager.scopes;
+			},
+			TSAsExpression: checkAssertion,
+			TSTypeAssertion: checkAssertion
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/prefer-options-parameter.ts
+const ContextOptionsSchema = ruleContextOptionsSchema(z.object({ allowFunctionNames: z.array(z.string()).optional() }));
+/** Require repository-owned named callables with 3+ inputs to use options. */
+const preferOptionsParameterRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require repository-owned named callables with three or more inputs to use one options object." },
+		messages: { preferOptions: "Function `{{functionName}}` has {{parameterCount}} parameters. Replace them with one named options object." },
+		schema: [{
+			type: "object",
+			properties: { allowFunctionNames: {
+				type: "array",
+				items: {
+					type: "string",
+					minLength: 1
+				},
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}],
+		defaultOptions: [{ allowFunctionNames: [] }]
+	},
+	createOnce(context) {
+		const checkFunction = (node) => {
+			const functionName$1 = getOwnedFunctionName(node);
+			const parameterCount = node.params.filter((parameter) => !(parameter.type === "Identifier" && parameter.name === "this")).length;
+			if (functionName$1 === null || parameterCount < 3) return;
+			const rawOptions = context.options;
+			const parsedOptions = ContextOptionsSchema.safeParse(rawOptions);
+			if ((parsedOptions.success ? parsedOptions.data : void 0)?.allowFunctionNames?.includes(functionName$1) === true) return;
+			context.report({
+				node,
+				messageId: "preferOptions",
+				data: {
+					functionName: functionName$1,
+					parameterCount
+				}
+			});
+		};
+		return {
+			ArrowFunctionExpression: checkFunction,
+			FunctionDeclaration: checkFunction,
+			FunctionExpression: checkFunction
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/prefer-switch-discriminator-chain.ts
+const MINIMUM_BRANCH_COUNT = 4;
+function discriminatorKey(node) {
+	return node.type === "Identifier" ? node.name : null;
+}
+function comparisonDiscriminator(node) {
+	if (node.type !== "BinaryExpression" || node.operator !== "===") return null;
+	if (node.right.type === "Literal") return discriminatorKey(node.left);
+	if (node.left.type === "Literal") return discriminatorKey(node.right);
+	return null;
+}
+function discriminatorChain(node) {
+	let branchCount = 0;
+	let current = node;
+	let discriminator = null;
+	while (current !== null) {
+		const branchDiscriminator = comparisonDiscriminator(current.test);
+		if (branchDiscriminator === null) return null;
+		if (discriminator !== null && discriminator !== branchDiscriminator) return null;
+		discriminator = branchDiscriminator;
+		branchCount += 1;
+		current = current.alternate?.type === "IfStatement" ? current.alternate : null;
+	}
+	return discriminator === null ? null : {
+		branchCount,
+		discriminator
+	};
+}
+/** Prefer a switch when repeated equality branches dispatch on one value. */
+const preferSwitchDiscriminatorChainRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require a switch for four or more equality branches on one discriminator." },
+		messages: { preferSwitch: "This chain has {{branchCount}} equality branches on one discriminator. Replace it with a switch so the finite dispatch structure is explicit." }
+	},
+	createOnce(context) {
+		return { IfStatement(node) {
+			if (node.parent.type === "IfStatement" && node.parent.alternate === node) return;
+			const chain = discriminatorChain(node);
+			if (chain === null || chain.branchCount < MINIMUM_BRANCH_COUNT) return;
+			context.report({
+				node,
+				messageId: "preferSwitch",
+				data: { branchCount: chain.branchCount }
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/prefer-top-level-function-declarations.ts
+function isFunctionExpression(node) {
+	if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") return true;
+	if (node.type === "ParenthesizedExpression" || node.type === "TSAsExpression" || node.type === "TSNonNullExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion") return isFunctionExpression(node.expression);
+	return false;
+}
+function isTopLevelVariable(node) {
+	if (node.id.type !== "Identifier") return false;
+	const declaration = node.parent;
+	if (declaration.type !== "VariableDeclaration") return false;
+	return declaration.parent.type === "Program" || declaration.parent.type === "ExportNamedDeclaration" && declaration.parent.parent.type === "Program";
+}
+/** Prefer hoistable declarations for repository-owned top-level functions. */
+const preferTopLevelFunctionDeclarationsRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require function declarations for direct top-level function bindings and named default exports." },
+		messages: {
+			anonymousDefaultExport: "Name this default-exported function with a function declaration so stack frames and searches identify its owner.",
+			topLevelBinding: "Top-level function `{{functionName}}` uses a function expression. Replace it with a function declaration so its owner is explicit and hoistable."
+		}
+	},
+	createOnce(context) {
+		return {
+			ExportDefaultDeclaration(node) {
+				if (node.declaration.type === "ArrowFunctionExpression" || node.declaration.type === "FunctionExpression" || node.declaration.type === "FunctionDeclaration" && node.declaration.id === null || (node.declaration.type === "ParenthesizedExpression" || node.declaration.type === "TSAsExpression" || node.declaration.type === "TSNonNullExpression" || node.declaration.type === "TSSatisfiesExpression" || node.declaration.type === "TSTypeAssertion") && isFunctionExpression(node.declaration)) context.report({
+					node,
+					messageId: "anonymousDefaultExport"
+				});
+			},
+			VariableDeclarator(node) {
+				if (node.init === null || !isTopLevelVariable(node) || !isFunctionExpression(node.init)) return;
+				context.report({
+					node,
+					messageId: "topLevelBinding",
+					data: { functionName: node.id.name }
+				});
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/require-lint-suppression-reason.ts
+const suppressionDirectivePattern = /^(?:eslint|oxlint)-disable(?:-next-line|-line)?(?:\s|$)/u;
+const suppressionReasonPattern = /\s--\s+\S/u;
+/** Require an explicit forcing reason on ESLint and Oxlint suppressions. */
+const requireLintSuppressionReasonRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require ESLint and Oxlint disable directives to state their forcing reason." },
+		messages: { missingReason: "Add a reason after `--` that explains why this lint suppression is required." }
+	},
+	createOnce(context) {
+		return { Program() {
+			for (const comment of context.sourceCode.getAllComments()) {
+				const directive = comment.value.trim();
+				if (suppressionDirectivePattern.test(directive) && !suppressionReasonPattern.test(directive)) context.report({
+					loc: context.sourceCode.getLoc(comment),
+					messageId: "missingReason"
+				});
+			}
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/require-safety-comment-for-type-assertion.ts
+const commentOwnerKinds = new Set([
+	"ExpressionStatement",
+	"PropertyDefinition",
+	"ReturnStatement",
+	"ThrowStatement",
+	"VariableDeclaration"
+]);
+function isConstAssertion(node) {
+	return node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const";
+}
+function isNestedAssertion(node) {
+	let current = node;
+	let parent = node.parent;
+	while (parent.type === "ParenthesizedExpression" && parent.expression === current) {
+		current = parent;
+		parent = parent.parent;
+	}
+	return (parent.type === "TSAsExpression" || parent.type === "TSTypeAssertion") && parent.expression === current;
+}
+function hasSafetyComment(sourceCode, node) {
+	let current = node;
+	while (true) {
+		if (sourceCode.getCommentsBefore(current).some((comment) => comment.range[1] <= node.range[0] && /\bSAFETY\s*:/u.test(comment.value))) return true;
+		if (commentOwnerKinds.has(current.type) || current.parent.type === "Program") return false;
+		current = current.parent;
+	}
+}
+/** Require every non-const type assertion to state the invariant TypeScript cannot express. */
+const requireSafetyCommentForTypeAssertionRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require a nearby SAFETY comment for every outermost TypeScript type assertion except const assertions." },
+		messages: { missingSafetyComment: "This type assertion has no `SAFETY:` justification. State the checked invariant immediately before the assertion or its containing statement." }
+	},
+	createOnce(context) {
+		const checkAssertion = (node) => {
+			if (isConstAssertion(node) || isNestedAssertion(node) || hasSafetyComment(context.sourceCode, node)) return;
+			context.report({
+				node,
+				messageId: "missingSafetyComment"
+			});
+		};
+		return {
+			TSAsExpression: checkAssertion,
+			TSTypeAssertion: checkAssertion
+		};
+	}
+});
+
+//#endregion
+//#region src/index.ts
+const meta = {
+	name: "@utilfirst/eslint-plugin",
+	version
+};
+const antiSlopPlugin = eslintCompatPlugin({
+	meta,
+	rules: {
+		"no-chained-type-assertions": noChainedTypeAssertionsRule,
+		"no-conditional-undefined-properties": noConditionalUndefinedPropertiesRule,
+		"no-enum-declarations": noEnumDeclarationsRule,
+		"no-known-value-widening": noKnownValueWideningRule,
+		"no-module-mocking": noModuleMockingRule,
+		"no-object-parameters": noObjectParametersRule,
+		"no-positional-boolean-parameters": noPositionalBooleanParametersRule,
+		"no-reflect-apply": noReflectApplyRule,
+		"no-reflect-get": noReflectGetRule,
+		"no-unknown-parameters": noUnknownParametersRule,
+		"no-unknown-returns": noUnknownReturnsRule,
+		"no-unknown-type-aliases": noUnknownTypeAliasesRule,
+		"no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
+		"no-unhandled-detached-promises": noUnhandledDetachedPromisesRule,
+		"no-widen-then-assert": noWidenThenAssertRule,
+		"prefer-options-parameter": preferOptionsParameterRule,
+		"prefer-switch-discriminator-chain": preferSwitchDiscriminatorChainRule,
+		"prefer-top-level-function-declarations": preferTopLevelFunctionDeclarationsRule,
+		"require-lint-suppression-reason": requireLintSuppressionReasonRule,
+		"require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule
+	}
+});
+function assertEslintCompatibleRules(candidateRules) {
+	for (const candidateRule of Object.values(candidateRules)) if (candidateRule.create === void 0) throw new Error("ESLint compatibility adapter did not install `create`");
+}
+assertEslintCompatibleRules(antiSlopPlugin.rules);
+const antiSlopRules = antiSlopPlugin.rules;
+const rules = {
+	"consistent-blank-lines": consistentBlankLines,
+	...antiSlopRules
+};
+const recommendedRules = Object.fromEntries(Object.keys(rules).map((ruleName) => [`utilfirst/${ruleName}`, "error"]));
+const plugin = {
+	meta,
+	rules,
+	configs: { recommended: {} }
 };
 plugin.configs.recommended = {
 	plugins: { utilfirst: plugin },
-	rules: { "utilfirst/consistent-blank-lines": "error" }
+	rules: recommendedRules
 };
 var src_default = plugin;