@utilfirst/eslint-plugin 0.3.0 → 0.4.1

package/dist/src-Bthhlf8v.js

@@ -0,0 +1,3869 @@
+import { defineRule, eslintCompatPlugin } from "@oxlint/plugins";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { z } from "zod";
+
+//#region package.json
+var version = "0.4.1";
+
+//#endregion
+//#region src/rules/consistent-blank-lines.ts
+const SKIP_KEYS = new Set([
+	"parent",
+	"loc",
+	"range",
+	"start",
+	"end"
+]);
+const FN_DECL_TYPES = new Set([
+	AST_NODE_TYPES.FunctionDeclaration,
+	AST_NODE_TYPES.FunctionExpression,
+	AST_NODE_TYPES.ArrowFunctionExpression
+]);
+const IMPORT_SPECIFIER_TYPES = new Set([
+	AST_NODE_TYPES.ImportSpecifier,
+	AST_NODE_TYPES.ImportDefaultSpecifier,
+	AST_NODE_TYPES.ImportNamespaceSpecifier
+]);
+const OPAQUE_BODY_TYPES = new Set([AST_NODE_TYPES.FunctionDeclaration, AST_NODE_TYPES.ClassDeclaration]);
+const EXPRESSION_CONTINUATION_TYPES = new Set([
+	AST_NODE_TYPES.IfStatement,
+	AST_NODE_TYPES.ReturnStatement,
+	AST_NODE_TYPES.ThrowStatement,
+	AST_NODE_TYPES.BreakStatement,
+	AST_NODE_TYPES.ContinueStatement
+]);
+const HEAVY_NEXT_TYPES = new Set([
+	AST_NODE_TYPES.VariableDeclaration,
+	AST_NODE_TYPES.FunctionDeclaration,
+	AST_NODE_TYPES.ClassDeclaration,
+	AST_NODE_TYPES.TSInterfaceDeclaration,
+	AST_NODE_TYPES.TSDeclareFunction,
+	AST_NODE_TYPES.ReturnStatement,
+	AST_NODE_TYPES.ThrowStatement
+]);
+const TERMINATING_STATEMENT_TYPES = new Set([
+	AST_NODE_TYPES.ReturnStatement,
+	AST_NODE_TYPES.ThrowStatement,
+	AST_NODE_TYPES.BreakStatement,
+	AST_NODE_TYPES.ContinueStatement
+]);
+function parentOf(node) {
+	return node.parent;
+}
+const consistentBlankLines = {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "Apply explicit gap policies between adjacent statement-list and JSXChild items.",
+			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 require a tight gap.",
+			missing: "Expected one blank line between items that require separation."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const lineBreak = sourceCode.text.includes("\r\n") ? "\r\n" : "\n";
+		function checkBlock(statements) {
+			for (let i = 0; i < statements.length - 1; i++) {
+				const prev = statements[i];
+				const next = statements[i + 1];
+				if (prev && next) {
+					const { effectiveEnd, leadingComments } = partitionStatementComments({
+						comments: sourceCode.getCommentsBefore(next),
+						prev
+					});
+					checkPair({
+						effectiveEnd,
+						effectiveStart: leadingComments[0] ?? next,
+						next,
+						policy: statementGapPolicy({
+							leadingComments,
+							next,
+							prev,
+							sourceCode
+						}),
+						prev
+					});
+				}
+			}
+		}
+		function checkJsxChildren(children) {
+			const siblings = [];
+			let pendingLeading = [];
+			for (const child of children) {
+				if (child.type === AST_NODE_TYPES.JSXText && child.value.trim() === "") continue;
+				if (isCommentOnlyContainer(child)) {
+					pendingLeading.push(child);
+					continue;
+				}
+				siblings.push({
+					leading: pendingLeading,
+					node: child
+				});
+				pendingLeading = [];
+			}
+			for (let i = 0; i < siblings.length - 1; i++) {
+				const prevSibling = siblings[i];
+				const nextSibling = siblings[i + 1];
+				if (prevSibling && nextSibling) {
+					const { node: prev } = prevSibling;
+					const { leading, node: next } = nextSibling;
+					checkPair({
+						effectiveEnd: prev,
+						effectiveStart: leading[0] ?? next,
+						next,
+						policy: jsxGapPolicy({
+							leading,
+							next,
+							prev
+						}),
+						prev
+					});
+				}
+			}
+		}
+		function checkPair({ effectiveEnd, effectiveStart, next, policy, prev }) {
+			if (policy === "preserve") return;
+			const prevEndLine = effectiveEnd.loc.end.line;
+			const nextStartLine = effectiveStart.loc.start.line;
+			if (nextStartLine === prevEndLine) {
+				if (policy === "tight") return;
+				const indentation = indentationOf(prev, sourceCode);
+				context.report({
+					node: next,
+					messageId: "missing",
+					fix: (fixer) => fixer.replaceTextRange([effectiveEnd.range[1], effectiveStart.range[0]], `${lineBreak}${lineBreak}${indentation}`)
+				});
+				return;
+			}
+			const paddingCount = nextStartLine - prevEndLine - 1;
+			const targetPadding = policy === "separate" ? 1 : 0;
+			if (paddingCount === targetPadding) return;
+			context.report({
+				node: next,
+				messageId: paddingCount < targetPadding ? "missing" : "extra",
+				fix(fixer) {
+					const start = sourceCode.getIndexFromLoc({
+						line: prevEndLine + 1,
+						column: 0
+					});
+					const end = sourceCode.getIndexFromLoc({
+						line: nextStartLine,
+						column: 0
+					});
+					return fixer.replaceTextRange([start, end], lineBreak.repeat(targetPadding));
+				}
+			});
+		}
+		return {
+			Program(node) {
+				checkBlock(node.body);
+			},
+			BlockStatement(node) {
+				checkBlock(node.body);
+			},
+			SwitchCase(node) {
+				checkBlock(node.consequent);
+			},
+			StaticBlock(node) {
+				checkBlock(node.body);
+			},
+			JSXElement(node) {
+				checkJsxChildren(node.children);
+			},
+			JSXFragment(node) {
+				checkJsxChildren(node.children);
+			}
+		};
+	}
+};
+function partitionStatementComments({ comments, prev }) {
+	let effectiveEnd = prev;
+	let leadingIndex = 0;
+	while (true) {
+		const comment = comments[leadingIndex];
+		if (!comment || comment.loc.start.line !== effectiveEnd.loc.end.line) break;
+		effectiveEnd = comment;
+		leadingIndex++;
+	}
+	return {
+		effectiveEnd,
+		leadingComments: comments.slice(leadingIndex)
+	};
+}
+function indentationOf(node, sourceCode) {
+	const lineStart = sourceCode.getIndexFromLoc({
+		line: node.loc.start.line,
+		column: 0
+	});
+	const linePrefix = sourceCode.text.slice(lineStart, node.range[0]);
+	return /^[\t ]*/u.exec(linePrefix)?.[0] ?? "";
+}
+function statementGapPolicy({ leadingComments, next, prev, sourceCode }) {
+	if (itemsSpanMultipleLines(leadingComments)) return "separate";
+	const prevHook = hookStatementOf(prev);
+	const nextHook = hookStatementOf(next);
+	if (prevHook || nextHook) return prevHook?.kind === "variable" && nextHook?.kind === "variable" && declarationsHaveSameShell({
+		next,
+		prev
+	}) ? "tight" : "separate";
+	if (isImportPair(prev, next) || isReExport(prev) && isReExport(next) || isExpressionStatementPair(prev, next)) return "preserve";
+	if (sharesNameFlow({
+		next,
+		prev,
+		sourceCode
+	}) || statementsRequireTightGap({
+		next,
+		prev,
+		sourceCode
+	})) return "tight";
+	return "separate";
+}
+function hookStatementOf(stmt) {
+	const declaration = unwrapExport(stmt);
+	if (declaration.type === AST_NODE_TYPES.VariableDeclaration && declaration.declarations.length === 1 && isHookCall(declaration.declarations[0].init)) return { kind: "variable" };
+	if (declaration.type === AST_NODE_TYPES.ExpressionStatement && isHookCall(declaration.expression)) return { kind: "expression" };
+	return null;
+}
+function declarationsHaveSameShell({ next, prev }) {
+	const previousDeclaration = unwrapExport(prev);
+	const nextDeclaration = unwrapExport(next);
+	return previousDeclaration.type === AST_NODE_TYPES.VariableDeclaration && nextDeclaration.type === AST_NODE_TYPES.VariableDeclaration && isExported(prev) === isExported(next) && !isMultiLine(prev) && !isMultiLine(next) && previousDeclaration.declarations.length === 1 && nextDeclaration.declarations.length === 1;
+}
+function isExported(stmt) {
+	return stmt.type === AST_NODE_TYPES.ExportNamedDeclaration || stmt.type === AST_NODE_TYPES.ExportDefaultDeclaration;
+}
+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;
+	if (nextType === AST_NODE_TYPES.TSTypeAliasDeclaration) return false;
+	const introduced = collectIntroducedOrAssignedNames(prev);
+	if (introduced.size === 0) return false;
+	const referenced = collectReferencedNames(next, sourceCode);
+	for (const name of introduced) if (referenced.has(name)) return true;
+	return false;
+}
+function isHookCall(node) {
+	return node?.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.Identifier && /^use[A-Z]/u.test(node.callee.name);
+}
+function statementsRequireTightGap({ next, prev, sourceCode }) {
+	if (isMatchingVarDeclPair({
+		next,
+		prev,
+		sourceCode
+	})) return true;
+	if (isMatchingTypeAliasPair(prev, next)) return true;
+	if (prev.type === AST_NODE_TYPES.IfStatement && next.type === AST_NODE_TYPES.IfStatement) return !(isGuardIf(prev) && !isGuardIf(next));
+	if (prev.type === AST_NODE_TYPES.ExpressionStatement && EXPRESSION_CONTINUATION_TYPES.has(next.type)) {
+		if (HEAVY_NEXT_TYPES.has(next.type) && isMultiLine(next)) return false;
+		return !(next.type === AST_NODE_TYPES.IfStatement && isGuardIf(next));
+	}
+	return false;
+}
+function isImportPair(prev, next) {
+	return prev.type === AST_NODE_TYPES.ImportDeclaration && next.type === AST_NODE_TYPES.ImportDeclaration;
+}
+function isExpressionStatementPair(prev, next) {
+	return prev.type === AST_NODE_TYPES.ExpressionStatement && next.type === AST_NODE_TYPES.ExpressionStatement;
+}
+function isReExport(stmt) {
+	return stmt.type === AST_NODE_TYPES.ExportNamedDeclaration && stmt.source !== null || stmt.type === AST_NODE_TYPES.ExportAllDeclaration;
+}
+function isMatchingVarDeclPair({ next, prev, sourceCode }) {
+	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 (!initializersBelongTogether({
+		nextInit: nextDeclaration.declarations[0].init,
+		prevInit: previousDeclaration.declarations[0].init,
+		sourceCode
+	})) return false;
+	return isExported(prev) === isExported(next);
+}
+function isMatchingTypeAliasPair(prev, next) {
+	const previousDeclaration = unwrapExport(prev);
+	const nextDeclaration = unwrapExport(next);
+	if (previousDeclaration.type !== AST_NODE_TYPES.TSTypeAliasDeclaration || nextDeclaration.type !== AST_NODE_TYPES.TSTypeAliasDeclaration) return false;
+	if (isMultiLine(prev) || isMultiLine(next)) return false;
+	return isExported(prev) === isExported(next);
+}
+function unwrapExport(stmt) {
+	if (stmt.type === AST_NODE_TYPES.ExportNamedDeclaration && stmt.declaration) return stmt.declaration;
+	if (stmt.type === AST_NODE_TYPES.ExportDefaultDeclaration) return stmt.declaration;
+	return stmt;
+}
+function isConstOrLet(decl) {
+	return decl.kind === "const" || decl.kind === "let";
+}
+function initializersBelongTogether({ nextInit, prevInit, sourceCode }) {
+	const previousCallIdentity = callIdentityOf(prevInit, sourceCode);
+	const nextCallIdentity = callIdentityOf(nextInit, sourceCode);
+	if (previousCallIdentity !== null && nextCallIdentity !== null) return previousCallIdentity === nextCallIdentity;
+	if (previousCallIdentity !== null || nextCallIdentity !== null) return false;
+	return true;
+}
+function callIdentityOf(expr, sourceCode) {
+	if (!expr) return null;
+	const call = expr.type === AST_NODE_TYPES.ChainExpression ? expr.expression : expr;
+	if (call.type !== AST_NODE_TYPES.CallExpression) return null;
+	return `${call.optional ? "optional" : "direct"}:${sourceCode.getText(call.callee)}`;
+}
+function isGuardIf(stmt) {
+	return stmt.type === AST_NODE_TYPES.IfStatement && blockAlwaysTerminates(stmt.consequent);
+}
+function blockAlwaysTerminates(node) {
+	if (TERMINATING_STATEMENT_TYPES.has(node.type)) return true;
+	if (node.type === AST_NODE_TYPES.BlockStatement) {
+		const last = node.body.at(-1);
+		return last ? blockAlwaysTerminates(last) : false;
+	}
+	if (node.type === AST_NODE_TYPES.IfStatement) {
+		if (!node.alternate) return false;
+		return blockAlwaysTerminates(node.consequent) && blockAlwaysTerminates(node.alternate);
+	}
+	if (node.type === AST_NODE_TYPES.TryStatement) {
+		if (node.finalizer && blockAlwaysTerminates(node.finalizer)) return true;
+		if (!blockAlwaysTerminates(node.block)) return false;
+		if (!node.handler) return true;
+		return blockAlwaysTerminates(node.handler.body);
+	}
+	return false;
+}
+function collectIntroducedOrAssignedNames(stmt) {
+	const set = /* @__PURE__ */ new Set();
+	const s = unwrapExport(stmt);
+	if (s.type === AST_NODE_TYPES.VariableDeclaration) for (const decl of s.declarations) collectBindingNames(decl.id, set);
+	else if (s.type === AST_NODE_TYPES.FunctionDeclaration && s.id) set.add(s.id.name);
+	else if (s.type === AST_NODE_TYPES.ClassDeclaration && s.id) set.add(s.id.name);
+	else if (s.type === AST_NODE_TYPES.TSInterfaceDeclaration) set.add(s.id.name);
+	else if (s.type === AST_NODE_TYPES.TSDeclareFunction && s.id) set.add(s.id.name);
+	else if (s.type === AST_NODE_TYPES.ExpressionStatement) {
+		const expr = s.expression;
+		if (expr.type === AST_NODE_TYPES.AssignmentExpression) collectAssignmentRoots(expr.left, set);
+		else if (expr.type === AST_NODE_TYPES.UpdateExpression && expr.argument.type === AST_NODE_TYPES.Identifier) set.add(expr.argument.name);
+	}
+	return set;
+}
+function collectBindingNames(node, set) {
+	switch (node.type) {
+		case AST_NODE_TYPES.Identifier:
+			set.add(node.name);
+			break;
+		case AST_NODE_TYPES.ObjectPattern:
+			for (const prop of node.properties) if (prop.type === AST_NODE_TYPES.Property) collectBindingNames(prop.value, set);
+			else collectBindingNames(prop.argument, set);
+			break;
+		case AST_NODE_TYPES.ArrayPattern:
+			for (const el of node.elements) if (el) collectBindingNames(el, set);
+			break;
+		case AST_NODE_TYPES.RestElement:
+			collectBindingNames(node.argument, set);
+			break;
+		case AST_NODE_TYPES.AssignmentPattern:
+			collectBindingNames(node.left, set);
+			break;
+		default: break;
+	}
+}
+function collectAssignmentRoots(target, set) {
+	if (target.type === AST_NODE_TYPES.Identifier) set.add(target.name);
+	else if (target.type === AST_NODE_TYPES.MemberExpression) {
+		let root = target;
+		while (root.type === AST_NODE_TYPES.MemberExpression) root = root.object;
+		if (root.type === AST_NODE_TYPES.Identifier) set.add(root.name);
+		else if (root.type === AST_NODE_TYPES.ThisExpression) set.add("this");
+	} else if (target.type === AST_NODE_TYPES.ObjectPattern || target.type === AST_NODE_TYPES.ArrayPattern) collectBindingNames(target, set);
+}
+function collectReferencedNames(root, sourceCode) {
+	const set = /* @__PURE__ */ new Set();
+	walk(root, (node) => {
+		if (node.type === AST_NODE_TYPES.Identifier && !isDeclarationOrPropertyKey(node)) {
+			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) && resolvesOutsideRoot({
+			idNode: node,
+			root,
+			sourceCode
+		})) set.add(node.name);
+	});
+	return set;
+}
+function resolvesOutsideRoot({ idNode, root, sourceCode }) {
+	let scope = sourceCode.getScope(idNode);
+	while (scope) {
+		const variable = scope.variables.find((v) => v.name === idNode.name);
+		if (variable) {
+			for (const def of variable.defs) if (isInSubtree(def.node, root)) return false;
+			return true;
+		}
+		scope = scope.upper;
+	}
+	return true;
+}
+function thisResolvesOutsideRoot(thisNode, root) {
+	let parent = parentOf(thisNode);
+	while (parent) {
+		if (parent.type === AST_NODE_TYPES.FunctionDeclaration || parent.type === AST_NODE_TYPES.FunctionExpression) return !isInSubtree(parent, root);
+		parent = parentOf(parent);
+	}
+	return true;
+}
+function isJsxComponentIdentifier(node) {
+	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;
+	if (parent.type === AST_NODE_TYPES.JSXMemberExpression && parent.object === node) return true;
+	return false;
+}
+function isInSubtree(node, root) {
+	let cur = node;
+	while (cur) {
+		if (cur === root) return true;
+		cur = parentOf(cur);
+	}
+	return false;
+}
+function isDeclarationOrPropertyKey(idNode) {
+	const parent = idNode.parent;
+	if (parent.type === AST_NODE_TYPES.LabeledStatement && parent.label === idNode || (parent.type === AST_NODE_TYPES.BreakStatement || parent.type === AST_NODE_TYPES.ContinueStatement) && parent.label === idNode) return true;
+	if (parent.type === AST_NODE_TYPES.VariableDeclarator && parent.id === idNode) return true;
+	if (FN_DECL_TYPES.has(parent.type) && "id" in parent && parent.id === idNode) return true;
+	if ((parent.type === AST_NODE_TYPES.ClassDeclaration || parent.type === AST_NODE_TYPES.ClassExpression) && parent.id === idNode) return true;
+	if (parent.type === AST_NODE_TYPES.MemberExpression && parent.property === idNode && !parent.computed) return true;
+	if (IMPORT_SPECIFIER_TYPES.has(parent.type) && "local" in parent && parent.local === idNode) return true;
+	if (parent.type === AST_NODE_TYPES.ImportSpecifier) return true;
+	if (parent.type === AST_NODE_TYPES.ExportSpecifier && parent.exported === idNode && parent.local !== idNode) return true;
+	if (parent.type === AST_NODE_TYPES.MetaProperty) return true;
+	if (parent.type === AST_NODE_TYPES.TSQualifiedName && parent.right === idNode) return true;
+	if ((parent.type === AST_NODE_TYPES.MethodDefinition || parent.type === AST_NODE_TYPES.PropertyDefinition || parent.type === AST_NODE_TYPES.AccessorProperty || parent.type === AST_NODE_TYPES.TSMethodSignature || parent.type === AST_NODE_TYPES.TSPropertySignature) && parent.key === idNode && !parent.computed) return true;
+	if (parent.type === AST_NODE_TYPES.Property && parent.key === idNode && !parent.computed && !parent.shorthand) return true;
+	if (isInBindingPosition(idNode)) return true;
+	return false;
+}
+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)) {
+			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;
+			cur = parent;
+			parent = parentOf(parent);
+			continue;
+		}
+		if (parent.type === AST_NODE_TYPES.AssignmentPattern) {
+			if (parent.right === cur) return false;
+			cur = parent;
+			parent = parentOf(parent);
+			continue;
+		}
+		if (parent.type === AST_NODE_TYPES.RestElement) {
+			cur = parent;
+			parent = parentOf(parent);
+			continue;
+		}
+		return false;
+	}
+	return false;
+}
+function jsxGapPolicy({ leading, next, prev }) {
+	if (itemsSpanMultipleLines(leading)) return "separate";
+	if (isLiteralTextChild(prev) || isLiteralTextChild(next)) return "tight";
+	return isMultiLine(prev) || isMultiLine(next) ? "separate" : "tight";
+}
+function isCommentOnlyContainer(child) {
+	return child.type === AST_NODE_TYPES.JSXExpressionContainer && child.expression.type === AST_NODE_TYPES.JSXEmptyExpression;
+}
+function isLiteralTextChild(child) {
+	if (child.type === AST_NODE_TYPES.JSXText) return child.value.trim() !== "";
+	return child.type === AST_NODE_TYPES.JSXExpressionContainer && expressionProducesTextOrNothing(child.expression);
+}
+function expressionProducesTextOrNothing(expr) {
+	if (expr.type === AST_NODE_TYPES.Literal) return typeof expr.value === "string";
+	if (expr.type === AST_NODE_TYPES.TemplateLiteral) return true;
+	if (expr.type === AST_NODE_TYPES.TSAsExpression || expr.type === AST_NODE_TYPES.TSTypeAssertion || expr.type === AST_NODE_TYPES.TSNonNullExpression || expr.type === AST_NODE_TYPES.TSSatisfiesExpression) return expressionProducesTextOrNothing(expr.expression);
+	if (expr.type === AST_NODE_TYPES.LogicalExpression && expr.operator === "&&") return expressionProducesTextOrNothing(expr.right);
+	if (expr.type === AST_NODE_TYPES.ConditionalExpression) return expressionProducesTextOrNothing(expr.consequent) && expressionProducesTextOrNothing(expr.alternate);
+	return false;
+}
+function isNode$1(value) {
+	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+function isArray$1(value) {
+	return Array.isArray(value);
+}
+function walk(node, fn) {
+	fn(node);
+	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;
+		if (isArray$1(child)) {
+			for (const childNode of child) if (isNode$1(childNode)) walk(childNode, fn);
+		} else if (isNode$1(child)) walk(child, fn);
+	}
+}
+function isMultiLine(node) {
+	return node.loc.start.line !== node.loc.end.line;
+}
+function itemsSpanMultipleLines(items) {
+	const first = items[0];
+	const last = items.at(-1);
+	if (!first || !last) return false;
+	return last.loc.end.line > first.loc.start.line;
+}
+
+//#endregion
+//#region src/shared/estree.ts
+function staticMemberName(expression) {
+	if (!expression.computed && expression.property.type === "Identifier") return expression.property.name;
+	if (expression.computed && expression.property.type === "Literal" && typeof expression.property.value === "string") return expression.property.value;
+	return null;
+}
+
+//#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/shared/node-assert.ts
+const nodeAssertSources = new Set(["node:assert", "node:assert/strict"]);
+function importedName$1(node) {
+	if (node.type !== "ImportSpecifier") return null;
+	return node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
+}
+function nodeAssertDefinitions(sourceCode, identifier) {
+	const variable = resolveVariable(sourceCode, identifier);
+	if (variable === null) return [];
+	return variable.defs.filter((definition) => definition.type === "ImportBinding" && definition.parent?.type === "ImportDeclaration" && nodeAssertSources.has(definition.parent.source.value));
+}
+function isNodeAssertModule(sourceCode, identifier) {
+	return nodeAssertDefinitions(sourceCode, identifier).some((definition) => definition.node.type === "ImportDefaultSpecifier" || definition.node.type === "ImportNamespaceSpecifier");
+}
+function isNodeAssertObject(sourceCode, identifier) {
+	return isNodeAssertModule(sourceCode, identifier) || nodeAssertDefinitions(sourceCode, identifier).some((definition) => importedName$1(definition.node) === "strict");
+}
+function isNodeAssertMemberObject(sourceCode, expression) {
+	if (expression.type === "Identifier") return isNodeAssertObject(sourceCode, expression);
+	return expression.type === "MemberExpression" && staticMemberName(expression) === "strict" && expression.object.type === "Identifier" && isNodeAssertModule(sourceCode, expression.object);
+}
+function importedAssertFunctionName(sourceCode, identifier) {
+	for (const definition of nodeAssertDefinitions(sourceCode, identifier)) {
+		if (definition.node.type === "ImportDefaultSpecifier") return "ok";
+		const name = importedName$1(definition.node);
+		if (name !== null) return name === "strict" ? "ok" : name;
+	}
+	return null;
+}
+/** Resolve a Node assert call through supported import and strict-object forms. */
+function nodeAssertCall(sourceCode, node) {
+	if (node.callee.type === "Identifier") {
+		const methodName$1 = importedAssertFunctionName(sourceCode, node.callee);
+		return methodName$1 === null ? null : {
+			arguments: node.arguments,
+			methodName: methodName$1
+		};
+	}
+	if (node.callee.type !== "MemberExpression" || !isNodeAssertMemberObject(sourceCode, node.callee.object)) return null;
+	const methodName = staticMemberName(node.callee);
+	if (methodName === "strict" && node.callee.object.type === "Identifier" && isNodeAssertModule(sourceCode, node.callee.object)) return {
+		arguments: node.arguments,
+		methodName: "ok"
+	};
+	return methodName === null ? null : {
+		arguments: node.arguments,
+		methodName
+	};
+}
+
+//#endregion
+//#region src/shared/test-framework.ts
+const testFrameworkSources = new Set([
+	"@jest/globals",
+	"node:test",
+	"vitest"
+]);
+const testCaseNames = new Set(["it", "test"]);
+const testControllerNames = new Set(["jest", "vi"]);
+const expectationNames = new Set(["expect"]);
+const testHookNames = new Set([
+	"afterAll",
+	"afterEach",
+	"beforeAll",
+	"beforeEach"
+]);
+const testSetupHookNames = new Set(["beforeAll", "beforeEach"]);
+const testSuiteNames = new Set(["describe", "suite"]);
+function hasExpectationModifier(expression, modifierName) {
+	let currentExpression = expression;
+	while (currentExpression.type === "MemberExpression") {
+		if (staticMemberName(currentExpression) === modifierName) return true;
+		currentExpression = currentExpression.object;
+	}
+	return false;
+}
+function importedName(node) {
+	if (node.type !== "ImportSpecifier") return null;
+	return node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
+}
+function memberChain(expression) {
+	if (expression.type === "Identifier") return {
+		names: [],
+		root: expression
+	};
+	if (expression.type === "MemberExpression") {
+		const parentChain = memberChain(expression.object);
+		const memberName = staticMemberName(expression);
+		if (parentChain === null || memberName === null) return null;
+		return {
+			names: [...parentChain.names, memberName],
+			root: parentChain.root
+		};
+	}
+	if (expression.type === "CallExpression" && expression.callee.type !== "Super" && expression.callee.type !== "V8IntrinsicExpression") return memberChain(expression.callee);
+	return null;
+}
+function isTestFrameworkReference({ acceptedNames, expression, sourceCode }) {
+	return testFrameworkReferenceName({
+		acceptedNames,
+		expression,
+		sourceCode
+	}) !== null;
+}
+function testFrameworkReferenceName({ acceptedNames, expression, sourceCode }) {
+	const chain = memberChain(expression);
+	if (chain === null) return null;
+	const variable = resolveVariable(sourceCode, chain.root);
+	if (variable === null || variable.defs.length === 0) return acceptedNames.has(chain.root.name) ? chain.root.name : null;
+	for (const definition of variable.defs) {
+		if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration" || !testFrameworkSources.has(definition.parent.source.value)) continue;
+		const name = importedName(definition.node);
+		if (name !== null && acceptedNames.has(name)) return name;
+		if (definition.parent.source.value === "node:test" && definition.node.type === "ImportDefaultSpecifier" && acceptedNames.has("test")) return "test";
+		if (definition.node.type === "ImportNamespaceSpecifier") {
+			const [frameworkMember] = chain.names;
+			if (frameworkMember !== void 0 && acceptedNames.has(frameworkMember)) return frameworkMember;
+		}
+	}
+	return null;
+}
+function unwrapExpression$3(expression) {
+	let current = expression;
+	while (current.type === "ChainExpression" || current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion") current = current.expression;
+	return current;
+}
+function isStableVariable(variable) {
+	return variable !== null && variable.references.every((reference) => reference.init || !reference.isWrite());
+}
+function functionFromIdentifier(sourceCode, identifier) {
+	const variable = resolveVariable(sourceCode, identifier);
+	if (!isStableVariable(variable)) return null;
+	for (const definition of variable.defs) {
+		if (definition.type === "FunctionName" && (definition.node.type === "FunctionDeclaration" || definition.node.type === "FunctionExpression")) return definition.node;
+		if (definition.type === "Variable" && definition.node.type === "VariableDeclarator" && definition.node.init !== null) {
+			const callback = functionFromExpression(sourceCode, definition.node.init);
+			if (callback !== null) return callback;
+		}
+	}
+	return null;
+}
+function functionFromExpression(sourceCode, expression) {
+	const unwrapped = unwrapExpression$3(expression);
+	if (unwrapped.type === "ArrowFunctionExpression" || unwrapped.type === "FunctionExpression") return unwrapped;
+	if (unwrapped.type === "Identifier") return functionFromIdentifier(sourceCode, unwrapped);
+	return null;
+}
+function callbackFromArguments(sourceCode, arguments_) {
+	for (let index = arguments_.length - 1; index >= 0; index -= 1) {
+		const argument = arguments_[index];
+		if (argument === void 0 || argument.type === "SpreadElement") continue;
+		const callback = functionFromExpression(sourceCode, argument);
+		if (callback !== null) return {
+			callback,
+			hasCallback: true
+		};
+		if (index > 0 && (argument.type === "Identifier" || argument.type === "MemberExpression")) return {
+			callback: null,
+			hasCallback: true
+		};
+	}
+	return {
+		callback: null,
+		hasCallback: false
+	};
+}
+function getTestFrameworkCall(sourceCode, node) {
+	if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return null;
+	const testName = testFrameworkReferenceName({
+		acceptedNames: testCaseNames,
+		expression: node.callee,
+		sourceCode
+	});
+	const hookName = testFrameworkReferenceName({
+		acceptedNames: testHookNames,
+		expression: node.callee,
+		sourceCode
+	});
+	const suiteName = testFrameworkReferenceName({
+		acceptedNames: testSuiteNames,
+		expression: node.callee,
+		sourceCode
+	});
+	if (testName === null && hookName === null && suiteName === null) return null;
+	const { callback, hasCallback } = callbackFromArguments(sourceCode, node.arguments);
+	if (!hasCallback) return null;
+	if (testName !== null) return {
+		callback,
+		kind: "test"
+	};
+	if (suiteName !== null) return {
+		callback,
+		kind: "suite"
+	};
+	return {
+		callback,
+		kind: hookName !== null && testSetupHookNames.has(hookName) ? "setup-hook" : "teardown-hook"
+	};
+}
+function isNode(value) {
+	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+function visitExecutedNodes({ root, sourceCode, visit }) {
+	const activeFunctions = /* @__PURE__ */ new Set();
+	const walkFunction = (callback) => {
+		if (activeFunctions.has(callback)) return;
+		activeFunctions.add(callback);
+		for (const parameter of callback.params) walkNode(parameter);
+		if (callback.body !== null) walkNode(callback.body);
+		activeFunctions.delete(callback);
+	};
+	const walkNode = (node) => {
+		if (node !== root && (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression")) return;
+		const frameworkCall = node.type === "CallExpression" ? getTestFrameworkCall(sourceCode, node) : null;
+		const visitorKeys = new Set(sourceCode.visitorKeys[node.type] ?? []);
+		const entries = Object.entries(node);
+		for (const [key, child] of entries) {
+			if (!visitorKeys.has(key)) continue;
+			if (isArray(child)) {
+				for (const childNode of child) if (isNode(childNode) && childNode !== frameworkCall?.callback) walkNode(childNode);
+			} else if (isNode(child) && child !== frameworkCall?.callback) walkNode(child);
+		}
+		visit(node);
+		if (node.type !== "CallExpression" || node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return;
+		const calledFunction = functionFromExpression(sourceCode, node.callee);
+		if (calledFunction !== null) walkFunction(calledFunction);
+		if (frameworkCall === null) for (const argument of node.arguments) {
+			if (argument.type === "SpreadElement") continue;
+			const callback = functionFromExpression(sourceCode, argument);
+			if (callback?.type === "ArrowFunctionExpression" || callback?.type === "FunctionExpression") walkFunction(callback);
+		}
+	};
+	if (root.type === "Program") walkNode(root);
+	else walkFunction(root);
+}
+function isTestFrameworkControlCall(sourceCode, node) {
+	if (node.callee.type !== "MemberExpression") return false;
+	return isTestFrameworkReference({
+		acceptedNames: testControllerNames,
+		expression: node.callee.object,
+		sourceCode
+	});
+}
+function isExpectationMatcher(sourceCode, node) {
+	if (node.callee.type !== "MemberExpression") return false;
+	let expression = node.callee.object;
+	while (expression.type === "MemberExpression") expression = expression.object;
+	if (expression.type !== "CallExpression") return false;
+	return isTestFrameworkReference({
+		acceptedNames: expectationNames,
+		expression: expression.callee,
+		sourceCode
+	});
+}
+function isExpectationMemberCall(sourceCode, node) {
+	if (node.callee.type !== "MemberExpression") return false;
+	return isTestFrameworkReference({
+		acceptedNames: expectationNames,
+		expression: node.callee.object,
+		sourceCode
+	});
+}
+
+//#endregion
+//#region src/rules/no-call-count-only-test.ts
+const interactionMatchers = new Set([
+	"toBeCalled",
+	"toBeCalledTimes",
+	"toHaveBeenCalled",
+	"toHaveBeenCalledOnce",
+	"toHaveBeenCalledTimes"
+]);
+/** Require interaction assertions to accompany observable outcome evidence. */
+const noCallCountOnlyTestRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow tests whose assertions only inspect mock call counts or omission." },
+		messages: { callCountOnly: "Assert an observable outcome, or document why call multiplicity or omission is the boundary contract." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const frameworkCall = getTestFrameworkCall(context.sourceCode, node);
+			if (frameworkCall?.kind !== "test" || frameworkCall.callback === null) return;
+			let assertionCount = 0;
+			let interactionCount = 0;
+			visitExecutedNodes({
+				root: frameworkCall.callback,
+				sourceCode: context.sourceCode,
+				visit(candidate) {
+					if (candidate.type !== "CallExpression") return;
+					if (nodeAssertCall(context.sourceCode, candidate) !== null) {
+						assertionCount += 1;
+						return;
+					}
+					if (!isExpectationMatcher(context.sourceCode, candidate)) return;
+					assertionCount += 1;
+					if (candidate.callee.type === "MemberExpression" && interactionMatchers.has(staticMemberName(candidate.callee) ?? "")) interactionCount += 1;
+				}
+			});
+			if (assertionCount > 0 && assertionCount === interactionCount) context.report({
+				node,
+				messageId: "callCountOnly"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/shared/type-assertion.ts
+function isTypeAssertionExpression(node) {
+	return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
+}
+function unwrapTypeAssertionBoundary(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSInstantiationExpression" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression") current = current.expression;
+	return current;
+}
+function isTransparentAssertionParent(parent, expression) {
+	return (parent.type === "ParenthesizedExpression" || parent.type === "TSInstantiationExpression" || parent.type === "TSNonNullExpression" || parent.type === "TSSatisfiesExpression") && parent.expression === expression;
+}
+function isOutermostTypeAssertion(node) {
+	let current = node;
+	let parent = node.parent;
+	while (isTransparentAssertionParent(parent, current)) {
+		current = parent;
+		parent = parent.parent;
+	}
+	return !isTypeAssertionExpression(parent) || parent.expression !== current;
+}
+
+//#endregion
+//#region src/rules/no-chained-type-assertions.ts
+function isConstAssertion$1(node) {
+	const { typeAnnotation } = node;
+	return typeAnnotation.type === "TSTypeReference" && typeAnnotation.typeName.type === "Identifier" && typeAnnotation.typeName.name === "const";
+}
+function isForbiddenAssertionChain(node) {
+	let assertionCount = 0;
+	let hasNonConstAssertion = false;
+	let current = node;
+	while (isTypeAssertionExpression(current)) {
+		assertionCount += 1;
+		hasNonConstAssertion ||= !isConstAssertion$1(current);
+		current = unwrapTypeAssertionBoundary(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 (!isOutermostTypeAssertion(node) || !isForbiddenAssertionChain(node)) return;
+			context.report({
+				node,
+				messageId: "chained"
+			});
+		};
+		return {
+			TSAsExpression: checkTypeAssertion,
+			TSTypeAssertion: checkTypeAssertion
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/no-conditional-undefined-properties.ts
+function unwrapTransparentExpression(expression) {
+	let current = expression;
+	while (current.type === "ChainExpression" || current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion") current = current.expression;
+	return current;
+}
+function isUndefinedExpression(sourceCode, expression) {
+	const unwrapped = unwrapTransparentExpression(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 = unwrapTransparentExpression(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/rules/no-imported-constant-restatement.ts
+const equalityMatchers = new Set([
+	"toBe",
+	"toEqual",
+	"toStrictEqual"
+]);
+const nodeAssertEqualityMethods = new Set([
+	"deepEqual",
+	"deepStrictEqual",
+	"equal",
+	"strictEqual"
+]);
+const importedConstantName = /^[A-Z][A-Z0-9_]*$/u;
+function expectationSubject(node) {
+	if (node.callee.type !== "MemberExpression") return null;
+	let expression = node.callee.object;
+	while (expression.type === "MemberExpression") expression = expression.object;
+	if (expression.type !== "CallExpression") return null;
+	const [subject] = expression.arguments;
+	return subject === void 0 || subject.type === "SpreadElement" ? null : subject;
+}
+function importedConstantRoot(expression) {
+	let currentExpression = expression;
+	while (currentExpression.type === "MemberExpression") {
+		if (staticMemberName(currentExpression) === null) return null;
+		currentExpression = currentExpression.object;
+	}
+	return currentExpression.type === "Identifier" ? currentExpression : null;
+}
+function nodeAssertSubject(sourceCode, node) {
+	const assertion = nodeAssertCall(sourceCode, node);
+	if (assertion === null || !nodeAssertEqualityMethods.has(assertion.methodName)) return null;
+	const [subject] = assertion.arguments;
+	return subject === void 0 || subject.type === "SpreadElement" ? null : subject;
+}
+function isStaticValue(expression) {
+	if (expression.type === "Literal") return true;
+	if (expression.type === "TemplateLiteral") return expression.expressions.length === 0;
+	if (expression.type === "UnaryExpression") return isStaticValue(expression.argument);
+	if (expression.type === "ArrayExpression") return expression.elements.every((element) => element !== null && element.type !== "SpreadElement" && isStaticValue(element));
+	if (expression.type === "ObjectExpression") return expression.properties.every((property) => {
+		if (property.type !== "Property" || property.kind !== "init" || property.method) return false;
+		if (property.computed && (property.key.type === "PrivateIdentifier" || !isStaticValue(property.key))) return false;
+		return isStaticValue(property.value);
+	});
+	return false;
+}
+function isImportedConstant(sourceCode, identifier) {
+	if (!importedConstantName.test(identifier.name)) return false;
+	const variable = resolveVariable(sourceCode, identifier);
+	return variable !== null && variable.defs.some((definition) => definition.type === "ImportBinding");
+}
+function isImportedConstantExpression(sourceCode, expression) {
+	const constantRoot = importedConstantRoot(expression);
+	return constantRoot !== null && isImportedConstant(sourceCode, constantRoot);
+}
+function isImportedConstantRestatement({ left, right, sourceCode }) {
+	return isImportedConstantExpression(sourceCode, left) && isStaticValue(right) || isStaticValue(left) && isImportedConstantExpression(sourceCode, right);
+}
+/** Require tests to exercise behavior instead of restating imported constants. */
+const noImportedConstantRestatementRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow equality assertions that restate an imported constant through a static literal." },
+		messages: { importedConstantRestatement: "Exercise behavior that consumes this constant. Use a reasoned suppression only when the exact literal is an external contract." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const isExpectEquality = node.callee.type === "MemberExpression" && isExpectationMatcher(context.sourceCode, node) && equalityMatchers.has(staticMemberName(node.callee) ?? "") && !hasExpectationModifier(node.callee.object, "not");
+			const subject = isExpectEquality ? expectationSubject(node) : nodeAssertSubject(context.sourceCode, node);
+			const expected = node.arguments[isExpectEquality ? 0 : 1];
+			if (subject === null || expected === void 0 || expected.type === "SpreadElement" || !isImportedConstantRestatement({
+				left: subject,
+				right: expected,
+				sourceCode: context.sourceCode
+			})) return;
+			context.report({
+				node,
+				messageId: "importedConstantRestatement"
+			});
+		} };
+	}
+});
+
+//#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 ownsTypeName(definition) {
+	return definition.type === "Type" || definition.type === "ClassName" || definition.type === "ImportBinding";
+}
+function typeDefinitions(sourceCode, reference) {
+	if (reference.typeName.type !== "Identifier") return [];
+	let scope = sourceCode.getScope(reference);
+	while (scope !== null) {
+		const definitions = (scope.set.get(reference.typeName.name)?.defs ?? []).filter((definition) => ownsTypeName(definition));
+		if (definitions.length > 0) return definitions;
+		scope = scope.upper;
+	}
+	return [];
+}
+function resolveTypeAlias(sourceCode, reference) {
+	if (reference.typeName.type !== "Identifier") return null;
+	for (const definition of typeDefinitions(sourceCode, reference)) {
+		const alias = typeAliasDeclarationOf(definition);
+		if (alias !== null) return alias;
+	}
+	return null;
+}
+function hasTypeDefinition(sourceCode, reference) {
+	return typeDefinitions(sourceCode, reference).length > 0;
+}
+function resolveTypeInterfaces(sourceCode, reference) {
+	if (reference.typeName.type !== "Identifier") return [];
+	return typeDefinitions(sourceCode, reference).flatMap((definition) => {
+		const runtimeDefinition = definition;
+		return runtimeDefinition.type === "Type" && runtimeDefinition.node.type === "TSInterfaceDeclaration" ? [runtimeDefinition.node] : [];
+	});
+}
+function aliasSubstitutions({ alias, base, reference }) {
+	const parameters = alias.typeParameters?.params ?? [];
+	const arguments_ = reference.typeArguments?.params ?? [];
+	const substitutions = new Map(base);
+	for (const [index, parameter] of parameters.entries()) {
+		const argument = arguments_[index] ?? parameter.default;
+		if (argument === null) return null;
+		substitutions.set(parameter.name.name, {
+			substitutions: new Map(substitutions),
+			type: argument
+		});
+	}
+	return substitutions;
+}
+function resolvedTypeIncludes({ isMatch, resolvingAliases, shadowedTypeNames, sourceCode, substitutions, transparentTypeNames, type }) {
+	if (isMatch(type)) return true;
+	if (type.type === "TSParenthesizedType") return resolvedTypeIncludes({
+		isMatch,
+		resolvingAliases,
+		shadowedTypeNames,
+		sourceCode,
+		substitutions,
+		transparentTypeNames,
+		type: type.typeAnnotation
+	});
+	if (type.type === "TSUnionType") return type.types.some((member) => resolvedTypeIncludes({
+		isMatch,
+		resolvingAliases,
+		shadowedTypeNames,
+		sourceCode,
+		substitutions,
+		transparentTypeNames,
+		type: member
+	}));
+	if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier") return false;
+	const name = type.typeName.name;
+	const substitution = substitutions.get(name);
+	if (substitution !== void 0) return resolvedTypeIncludes({
+		isMatch,
+		resolvingAliases,
+		shadowedTypeNames,
+		sourceCode,
+		substitutions: substitution.substitutions,
+		transparentTypeNames,
+		type: substitution.type
+	});
+	if (shadowedTypeNames?.has(name) === true) return false;
+	const alias = resolveTypeAlias(sourceCode, type);
+	if (alias !== null) {
+		if (resolvingAliases.has(alias)) return false;
+		const nextSubstitutions = aliasSubstitutions({
+			alias,
+			base: substitutions,
+			reference: type
+		});
+		if (nextSubstitutions !== null) return resolvedTypeIncludes({
+			isMatch,
+			resolvingAliases: new Set([...resolvingAliases, alias]),
+			shadowedTypeNames,
+			sourceCode,
+			substitutions: nextSubstitutions,
+			transparentTypeNames,
+			type: alias.typeAnnotation
+		});
+		return false;
+	}
+	if (transparentTypeNames?.has(name) !== true) return false;
+	if (hasTypeDefinition(sourceCode, type)) return false;
+	const wrappedType = type.typeArguments?.params[0];
+	return wrappedType !== void 0 && resolvedTypeIncludes({
+		isMatch,
+		resolvingAliases,
+		shadowedTypeNames,
+		sourceCode,
+		substitutions,
+		transparentTypeNames,
+		type: wrappedType
+	});
+}
+/** Match a type after resolving local aliases and their generic arguments. */
+function resolvedTypeIncludesMatch({ isMatch, shadowedTypeNames, sourceCode, transparentTypeNames, type }) {
+	return resolvedTypeIncludes({
+		isMatch,
+		resolvingAliases: /* @__PURE__ */ new Set(),
+		shadowedTypeNames,
+		sourceCode,
+		substitutions: /* @__PURE__ */ new Map(),
+		transparentTypeNames,
+		type
+	});
+}
+
+//#endregion
+//#region src/shared/dictionary-types.ts
+const BUILT_INS = new Set([
+	"Map",
+	"ReadonlyMap",
+	"Record",
+	"Readonly",
+	"Partial",
+	"Required",
+	"Pick",
+	"Omit",
+	"PropertyKey",
+	"NonNullable",
+	"WeakMap"
+]);
+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, sourceCode) {
+	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,
+		sourceCode
+	};
+}
+function typeReferenceName$2(type) {
+	return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function isBuiltIn({ environment, name, reference }) {
+	return BUILT_INS.has(name) && !environment.shadowedBuiltIns.has(name) && !hasTypeDefinition(environment.sourceCode, reference);
+}
+function resolvedAlias(environment, reference) {
+	return resolveTypeAlias(environment.sourceCode, reference) ?? environment.aliases.get(typeReferenceName$2(reference) ?? "");
+}
+function resolvedInterfaces(environment, reference) {
+	const lexicalInterfaces = resolveTypeInterfaces(environment.sourceCode, reference);
+	return lexicalInterfaces.length > 0 ? lexicalInterfaces : environment.interfaces.get(typeReferenceName$2(reference) ?? "");
+}
+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({
+		environment,
+		name,
+		reference: unwrapped
+	})) {
+		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 = resolvedInterfaces(environment, unwrapped);
+	if (interfaceDeclarations !== void 0) return isEffectivelyEmptyInterface(interfaceDeclarations) ? "empty-object" : null;
+	const alias = resolvedAlias(environment, unwrapped);
+	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({
+		environment,
+		name,
+		reference: unwrapped
+	})) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? [] : dictionaryValueTypes({
+			environment,
+			type: wrapped,
+			substitutions,
+			resolvingAliases
+		});
+	}
+	if (name === "Record" && isBuiltIn({
+		environment,
+		name,
+		reference: unwrapped
+	})) {
+		const value = unwrapped.typeArguments?.params[1] ?? null;
+		return value === null ? [] : [{
+			type: value,
+			substitutions
+		}];
+	}
+	if ((name === "Map" || name === "ReadonlyMap" || name === "WeakMap") && isBuiltIn({
+		environment,
+		name,
+		reference: unwrapped
+	})) {
+		const value = unwrapped.typeArguments?.params[1] ?? null;
+		return value === null ? [] : [{
+			type: value,
+			substitutions
+		}];
+	}
+	if ((name === "Pick" || name === "Omit") && isBuiltIn({
+		environment,
+		name,
+		reference: unwrapped
+	})) {
+		const source = unwrapped.typeArguments?.params[0];
+		return source === void 0 ? [] : dictionaryValueTypes({
+			environment,
+			type: source,
+			substitutions,
+			resolvingAliases
+		});
+	}
+	const alias = resolvedAlias(environment, unwrapped);
+	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 === "TSAnyKeyword") return { kind: "any" };
+	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({
+		environment,
+		name,
+		reference: unwrapped
+	})) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? null : classifyWideningTarget(wrapped, environment);
+	}
+	if (name === "Record" && isBuiltIn({
+		environment,
+		name,
+		reference: unwrapped
+	})) return { kind: "open dictionary" };
+	const alias = resolvedAlias(environment, unwrapped);
+	if (alias === void 0) return null;
+	if ((alias.typeParameters?.params.length ?? 0) > 0) {
+		const substitutions$1 = aliasSubstitution({
+			alias,
+			base: /* @__PURE__ */ new Map(),
+			type: unwrapped
+		});
+		if (substitutions$1 === null) return null;
+		const resolvingAliases = new Set([name]);
+		const broadTarget = classifyAliasBroadTarget({
+			environment,
+			resolvingAliases,
+			substitutions: substitutions$1,
+			type: alias.typeAnnotation
+		});
+		if (broadTarget !== null && broadTarget.kind !== "open dictionary") return broadTarget;
+		return resolvesToDictionary({
+			environment,
+			type: alias.typeAnnotation,
+			substitutions: substitutions$1,
+			resolvingAliases
+		}) ? { kind: "generic container" } : broadTarget;
+	}
+	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({
+		environment,
+		name,
+		reference: unwrapped
+	});
+}
+function classifyAliasBroadTarget({ environment, resolvingAliases, substitutions, type }) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSAnyKeyword") return { kind: "any" };
+	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({
+		environment,
+		name,
+		reference: unwrapped
+	})) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? null : classifyAliasBroadTarget({
+			environment,
+			type: wrapped,
+			substitutions,
+			resolvingAliases
+		});
+	}
+	if (name === "Record" && isBuiltIn({
+		environment,
+		name,
+		reference: unwrapped
+	})) return { kind: "open dictionary" };
+	const alias = resolvedAlias(environment, unwrapped);
+	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$2(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$2(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$2(expression).type === "ObjectExpression";
+}
+function hasParentAssertion(node) {
+	return (node.type === "TSAsExpression" || node.type === "TSTypeAssertion") && !isOutermostTypeAssertion(node);
+}
+/** 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, context.sourceCode);
+			},
+			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/shared/repository-module.ts
+const repositoryModulePrefixes = [
+	".",
+	"/",
+	"#",
+	"@/",
+	"~/"
+];
+const RepositoryModuleContextOptionsSchema = ruleContextOptionsSchema(z.object({ internalModulePrefixes: z.array(z.string().min(1)).optional() }));
+const repositoryModuleRuleSchema = [{
+	type: "object",
+	properties: { internalModulePrefixes: {
+		type: "array",
+		items: {
+			type: "string",
+			minLength: 1
+		},
+		uniqueItems: true
+	} },
+	additionalProperties: false
+}];
+function getInternalModulePrefixes(rawOptions) {
+	const parsedOptions = RepositoryModuleContextOptionsSchema.safeParse(rawOptions);
+	return parsedOptions.success ? parsedOptions.data?.internalModulePrefixes ?? [] : [];
+}
+function isRepositoryOwnedModuleSpecifier({ additionalPrefixes = [], internalModulePrefixes, specifier }) {
+	return repositoryModulePrefixes.some((prefix) => specifier.startsWith(prefix)) || additionalPrefixes.some((prefix) => specifier.startsWith(prefix)) || internalModulePrefixes.some((prefix) => specifier.startsWith(prefix));
+}
+
+//#endregion
+//#region src/rules/no-module-mocking.ts
+const moduleMockMethods = new Set([
+	"doMock",
+	"mock",
+	"unstable_mockModule"
+]);
+function moduleMockCall(sourceCode, node) {
+	if (node.callee.type !== "MemberExpression") return false;
+	if (!isTestFrameworkControlCall(sourceCode, node)) return false;
+	return moduleMockMethods.has(staticMemberName(node.callee) ?? "");
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function moduleSpecifier(argument) {
+	if (argument?.type === "Literal" && isString(argument.value)) return argument.value;
+	if (argument?.type === "ImportExpression" && argument.source.type === "Literal" && isString(argument.source.value)) return argument.source.value;
+	return null;
+}
+/** 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: repositoryModuleRuleSchema,
+		defaultOptions: [{ internalModulePrefixes: [] }]
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return;
+			if (!moduleMockCall(context.sourceCode, node)) return;
+			const internalModulePrefixes = getInternalModulePrefixes(context.options);
+			const specifier = moduleSpecifier(node.arguments[0]);
+			if (specifier === null || !isRepositoryOwnedModuleSpecifier({
+				internalModulePrefixes,
+				specifier
+			})) return;
+			context.report({
+				node,
+				messageId: "moduleMock"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/no-negated-throw-assertion.ts
+const throwMatchers = new Set(["toThrow", "toThrowError"]);
+const nodeNegatedThrowMethods = new Set(["doesNotReject", "doesNotThrow"]);
+/** Require direct execution instead of redundant non-throw assertions. */
+const noNegatedThrowAssertionRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow negated throw assertions because direct execution already fails on an exception." },
+		messages: { negatedThrow: "Invoke this function directly, then assert its observable result or effect." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const assertion = nodeAssertCall(context.sourceCode, node);
+			if (assertion !== null && nodeNegatedThrowMethods.has(assertion.methodName)) {
+				context.report({
+					node,
+					messageId: "negatedThrow"
+				});
+				return;
+			}
+			if (node.callee.type !== "MemberExpression" || !isExpectationMatcher(context.sourceCode, node) || !throwMatchers.has(staticMemberName(node.callee) ?? "") || !hasExpectationModifier(node.callee.object, "not")) return;
+			context.report({
+				node,
+				messageId: "negatedThrow"
+			});
+		} };
+	}
+});
+
+//#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/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 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 (!resolvedTypeIncludesMatch({
+					isMatch: (candidate) => candidate.type === "TSObjectKeyword",
+					shadowedTypeNames: shadowedAliases,
+					sourceCode: context.sourceCode,
+					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" || node.type === "TSDeclareFunction") && node.id !== null) return node.id.name;
+	if (node.type === "TSMethodSignature") return getStaticPropertyName({
+		isComputed: node.computed,
+		key: node.key
+	});
+	if (node.type === "TSCallSignatureDeclaration" || node.type === "TSConstructSignatureDeclaration" || node.type === "TSConstructorType" || node.type === "TSFunctionType") return getDeclarationOwnerName(node);
+	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 getDeclarationOwnerName(node) {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (current.type === "TSTypeAliasDeclaration") return current.id.name;
+		if (current.type === "TSInterfaceDeclaration") return current.id.name;
+		if (current.type === "TSPropertySignature") return getStaticPropertyName({
+			isComputed: current.computed,
+			key: current.key
+		});
+		if (current.type === "TSInterfaceBody") return current.parent.type === "TSInterfaceDeclaration" ? current.parent.id.name : null;
+		if (current.type !== "TSIntersectionType" && current.type !== "TSParenthesizedType" && current.type !== "TSTypeAnnotation" && current.type !== "TSTypeLiteral" && current.type !== "TSUnionType") return null;
+		current = current.parent;
+	}
+	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);
+}
+function isBooleanType(type) {
+	return type.type === "TSBooleanKeyword" || type.type === "TSLiteralType" && "value" in type.literal && typeof type.literal.value === "boolean";
+}
+/** 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 === null || annotation === void 0 || !resolvedTypeIncludesMatch({
+					isMatch: isBooleanType,
+					shadowedTypeNames: lexicalTypeParameterNames(node, context.sourceCode.visitorKeys),
+					sourceCode: context.sourceCode,
+					type: annotation.typeAnnotation
+				})) 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,
+			TSCallSignatureDeclaration: checkFunction,
+			TSConstructSignatureDeclaration: checkFunction,
+			TSConstructorType: checkFunction,
+			TSDeclareFunction: checkFunction,
+			TSEmptyBodyFunctionExpression: checkFunction,
+			TSFunctionType: checkFunction,
+			TSMethodSignature: checkFunction
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/no-promise-settlement-only-assertion.ts
+/** Require promise assertions to describe a result or specific failure. */
+const noPromiseSettlementOnlyAssertionRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow promise assertions that only prove fulfillment or rejection." },
+		messages: {
+			fulfillmentOnly: "Await this promise directly, then assert its observable result or effect.",
+			rejectionOnly: "Assert the rejection's class, code, message, or other behavioral contract."
+		}
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			if (node.callee.type !== "MemberExpression" || !isExpectationMatcher(context.sourceCode, node)) return;
+			const matcherName = staticMemberName(node.callee);
+			if (matcherName === "toBeUndefined" && hasExpectationModifier(node.callee.object, "resolves")) {
+				context.report({
+					node,
+					messageId: "fulfillmentOnly"
+				});
+				return;
+			}
+			if (matcherName === "toBeDefined" && hasExpectationModifier(node.callee.object, "rejects")) context.report({
+				node,
+				messageId: "rejectionOnly"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/shared/reflect-method.ts
+function isGlobalReflect(sourceCode, expression) {
+	if (expression.type === "Identifier" && expression.name === "Reflect") {
+		const variable$1 = resolveVariable(sourceCode, expression);
+		return variable$1 === null || variable$1.defs.length === 0;
+	}
+	if (expression.type !== "MemberExpression" || staticMemberName(expression) !== "Reflect" || expression.object.type !== "Identifier" || expression.object.name !== "globalThis") return false;
+	const variable = resolveVariable(sourceCode, expression.object);
+	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;
+	return staticMemberName(callee) === 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-test-snapshots.ts
+const snapshotMatchers = new Set([
+	"addSnapshotSerializer",
+	"toMatchFileSnapshot",
+	"toMatchInlineSnapshot",
+	"toMatchSnapshot",
+	"toThrowErrorMatchingInlineSnapshot",
+	"toThrowErrorMatchingSnapshot"
+]);
+/** Require explicit assertions instead of stored or inline snapshots. */
+const noTestSnapshotsRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow snapshot assertions because they obscure the behavior a test protects." },
+		messages: { snapshot: "Replace this snapshot with explicit assertions for the observable contract." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			if (node.callee.type !== "MemberExpression" || !isExpectationMatcher(context.sourceCode, node) && !isExpectationMemberCall(context.sourceCode, node) || !snapshotMatchers.has(staticMemberName(node.callee) ?? "")) return;
+			context.report({
+				node,
+				messageId: "snapshot"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/no-truthy-falsy-assertion.ts
+const truthinessMatchers = new Set(["toBeFalsy", "toBeTruthy"]);
+function isBareNodeTruthinessSubject(expression) {
+	let currentExpression = expression;
+	while (currentExpression.type === "ChainExpression" || currentExpression.type === "ParenthesizedExpression" || currentExpression.type === "TSAsExpression" || currentExpression.type === "TSNonNullExpression" || currentExpression.type === "TSSatisfiesExpression" || currentExpression.type === "TSTypeAssertion") currentExpression = currentExpression.expression;
+	return currentExpression.type === "Identifier" || currentExpression.type === "MemberExpression";
+}
+/** Require exact expected values instead of truthiness assertions. */
+const noTruthyFalsyAssertionRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow truthiness assertions because they discard value and type information." },
+		messages: { truthiness: "Assert the exact expected value instead of relying on truthiness." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const assertion = nodeAssertCall(context.sourceCode, node);
+			const [subject] = assertion?.arguments ?? [];
+			if (assertion?.methodName === "ok" && subject !== void 0 && subject.type !== "SpreadElement" && isBareNodeTruthinessSubject(subject)) {
+				context.report({
+					node,
+					messageId: "truthiness"
+				});
+				return;
+			}
+			if (node.callee.type !== "MemberExpression" || !isExpectationMatcher(context.sourceCode, node) || !truthinessMatchers.has(staticMemberName(node.callee) ?? "")) return;
+			context.report({
+				node,
+				messageId: "truthiness"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/no-uncontrolled-time-in-test.ts
+function isGlobalDate(sourceCode, identifier) {
+	const variable = resolveVariable(sourceCode, identifier);
+	return variable === null || variable.defs.length === 0;
+}
+function hasNowOption(expression) {
+	if (expression.type !== "ObjectExpression") return false;
+	return expression.properties.some((property) => {
+		if (property.type !== "Property") return false;
+		if (!property.computed && property.key.type === "Identifier") return property.key.name === "now";
+		return property.computed && property.key.type === "Literal" && property.key.value === "now";
+	});
+}
+function controlsTime(sourceCode, node) {
+	if (node.callee.type !== "MemberExpression" || !isTestFrameworkControlCall(sourceCode, node)) return false;
+	const memberName = staticMemberName(node.callee);
+	if (memberName === "setSystemTime") return true;
+	if (memberName !== "useFakeTimers") return false;
+	const [options] = node.arguments;
+	return options !== void 0 && options.type !== "SpreadElement" ? hasNowOption(options) : false;
+}
+function wallClockRead(sourceCode, node) {
+	if (node.type === "CallExpression") {
+		if (node.callee.type === "MemberExpression" && staticMemberName(node.callee) === "now" && node.callee.object.type === "Identifier" && node.callee.object.name === "Date" && isGlobalDate(sourceCode, node.callee.object)) return node;
+		if (node.callee.type === "Identifier" && node.callee.name === "Date" && isGlobalDate(sourceCode, node.callee)) return node;
+	}
+	if (node.type === "NewExpression" && node.arguments.length === 0 && node.callee.type === "Identifier" && node.callee.name === "Date" && isGlobalDate(sourceCode, node.callee)) return node;
+	return null;
+}
+function timeEvent(sourceCode, node) {
+	if (node.type === "CallExpression" && controlsTime(sourceCode, node)) return { kind: "control" };
+	const read = wallClockRead(sourceCode, node);
+	return read === null ? null : {
+		kind: "read",
+		node: read
+	};
+}
+function getTimeEvents({ root, sourceCode }) {
+	const events = [];
+	visitExecutedNodes({
+		root,
+		sourceCode,
+		visit(node) {
+			const event = timeEvent(sourceCode, node);
+			if (event !== null) events.push(event);
+		}
+	});
+	return events;
+}
+function getSuiteExecution({ root, sourceCode }) {
+	const suite = {
+		events: [],
+		hooks: [],
+		suites: [],
+		tests: []
+	};
+	visitExecutedNodes({
+		root,
+		sourceCode,
+		visit(node) {
+			const event = timeEvent(sourceCode, node);
+			if (event !== null) suite.events.push(event);
+			if (node.type !== "CallExpression") return;
+			const frameworkCall = getTestFrameworkCall(sourceCode, node);
+			if (frameworkCall === null) return;
+			if (frameworkCall.kind === "test") {
+				suite.tests.push(frameworkCall);
+				return;
+			}
+			if (frameworkCall.kind === "suite") {
+				if (frameworkCall.callback !== null) suite.suites.push(getSuiteExecution({
+					root: frameworkCall.callback,
+					sourceCode
+				}));
+				return;
+			}
+			suite.hooks.push(frameworkCall);
+		}
+	});
+	return suite;
+}
+function testCountOf(suite) {
+	return suite.tests.length + suite.suites.reduce((count, childSuite) => count + testCountOf(childSuite), 0);
+}
+/** Require tests to control wall-clock inputs. */
+const noUncontrolledTimeInTestRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow uncontrolled wall-clock reads in files that contain tests." },
+		messages: { uncontrolledTime: "Control the test clock before reading the current time, or inject the time as an input." }
+	},
+	createOnce(context) {
+		const reportedReads = /* @__PURE__ */ new Set();
+		function reportUncontrolledEvents({ events, hasInitialControl }) {
+			let hasControl = hasInitialControl;
+			for (const event of events) {
+				if (event.kind === "control") {
+					hasControl = true;
+					continue;
+				}
+				if (hasControl || reportedReads.has(event.node)) continue;
+				reportedReads.add(event.node);
+				context.report({
+					node: event.node,
+					messageId: "uncontrolledTime"
+				});
+			}
+			return hasControl;
+		}
+		function checkSuite({ suite, hasInheritedControl }) {
+			let hasSharedControl = reportUncontrolledEvents({
+				events: suite.events,
+				hasInitialControl: hasInheritedControl
+			});
+			for (const hook of suite.hooks) {
+				if (hook.callback === null) continue;
+				const hasHookControl = reportUncontrolledEvents({
+					events: getTimeEvents({
+						root: hook.callback,
+						sourceCode: context.sourceCode
+					}),
+					hasInitialControl: false
+				});
+				if (hook.kind === "setup-hook" && hasHookControl) hasSharedControl = true;
+			}
+			for (const test of suite.tests) {
+				if (test.callback === null) continue;
+				reportUncontrolledEvents({
+					events: getTimeEvents({
+						root: test.callback,
+						sourceCode: context.sourceCode
+					}),
+					hasInitialControl: hasSharedControl
+				});
+			}
+			for (const childSuite of suite.suites) checkSuite({
+				suite: childSuite,
+				hasInheritedControl: hasSharedControl
+			});
+		}
+		return { "Program:exit"(node) {
+			reportedReads.clear();
+			const suite = getSuiteExecution({
+				root: node,
+				sourceCode: context.sourceCode
+			});
+			if (testCountOf(suite) > 0) checkSuite({
+				suite,
+				hasInheritedControl: false
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/no-unhandled-detached-promises.ts
+function unwrapExpression$1(expression) {
+	if (expression.type === "ChainExpression" || expression.type === "ParenthesizedExpression" || expression.type === "TSAsExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSTypeAssertion") return unwrapExpression$1(expression.expression);
+	return expression;
+}
+function isRejectionHandler(argument) {
+	if (argument === void 0 || argument.type === "SpreadElement") return false;
+	const unwrapped = unwrapExpression$1(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$1(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]);
+		if (memberName === "finally") return false;
+	}
+	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$1(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);
+}
+function bindingIdentifiers(parameter) {
+	if (parameter.type === "Identifier") return [parameter];
+	if (parameter.type === "TSParameterProperty") return bindingIdentifiers(parameter.parameter);
+	if (parameter.type === "AssignmentPattern") return bindingIdentifiers(parameter.left);
+	if (parameter.type === "RestElement") return bindingIdentifiers(parameter.argument);
+	if (parameter.type === "ArrayPattern") return parameter.elements.flatMap((element) => element === null ? [] : bindingIdentifiers(element));
+	return parameter.properties.flatMap((property) => property.type === "Property" ? bindingIdentifiers(property.value) : bindingIdentifiers(property.argument));
+}
+function executableBody(owner) {
+	return owner.body ?? null;
+}
+function readsParameter({ owner, parameter, sourceCode }) {
+	const body = executableBody(owner);
+	if (body === null) return false;
+	return bindingIdentifiers(parameter).some((identifier) => {
+		return resolveVariable(sourceCode, identifier)?.references.some((reference) => reference.isRead() && reference.identifier.range[0] >= body.range[0] && reference.identifier.range[1] <= body.range[1]) === true;
+	});
+}
+/** Identify a boundary that converts an explicitly untrusted input into a typed result. */
+function isBoundaryDecoder({ owner, parameter, sourceCode }) {
+	return parameterType$1(parameter)?.type === "TSUnknownKeyword" && hasDecodedReturnType(owner) && (executableBody(owner) === null || readsParameter({
+		owner,
+		parameter,
+		sourceCode
+	}));
+}
+
+//#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) => {
+			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 || isBoundaryDecoder({
+					owner: node,
+					parameter,
+					sourceCode: context.sourceCode
+				})) 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
+/** 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 checkReturnType = (node) => {
+			const annotation = node.returnType;
+			if (annotation === null || annotation === void 0) return;
+			if (!resolvedTypeIncludesMatch({
+				isMatch: (type) => type.type === "TSUnknownKeyword",
+				shadowedTypeNames: lexicalTypeParameterNames(node, context.sourceCode.visitorKeys),
+				sourceCode: context.sourceCode,
+				transparentTypeNames: new Set(["Promise", "PromiseLike"]),
+				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
+/** 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) {
+		return { TSTypeAliasDeclaration(node) {
+			if (!resolvedTypeIncludesMatch({
+				isMatch: (type) => type.type === "TSUnknownKeyword",
+				shadowedTypeNames: lexicalTypeParameterNames(node, context.sourceCode.visitorKeys),
+				sourceCode: context.sourceCode,
+				type: node.typeAnnotation
+			})) 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) || resolveTypeAlias(environment.sourceCode, node) !== null) && !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 dictionary contracts whose direct value type is an unsafe escape hatch. */
+const noUnsafeDictionaryTypeRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow 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." }
+	},
+	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, context.sourceCode);
+			},
+			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-forwarded-props-order.ts
+function isPropsSpread(attribute) {
+	return attribute.type === "JSXSpreadAttribute" && attribute.argument.type === "Identifier" && attribute.argument.name === "props";
+}
+/** Put forwarded props before component-controlled JSX attributes. */
+const preferForwardedPropsOrderRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require forwarded props before component-controlled JSX attributes." },
+		messages: { propsFirst: "Spread `{...props}` before component-controlled attributes so the component retains its owned values." }
+	},
+	createOnce(context) {
+		return { JSXOpeningElement(node) {
+			const propsIndex = node.attributes.findIndex(isPropsSpread);
+			if (propsIndex <= 0) return;
+			context.report({
+				node: node.attributes[propsIndex] ?? node,
+				messageId: "propsFirst"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/prefer-hook-order.ts
+const HOOK_ORDER = new Map([
+	["use", 0],
+	["useContext", 0],
+	["useReducer", 1],
+	["useRef", 1],
+	["useState", 1],
+	["useCallback", 2],
+	["useMemo", 2],
+	["useEffect", 3],
+	["useInsertionEffect", 3],
+	["useLayoutEffect", 3]
+]);
+function directCallOf(statement) {
+	if (statement.type === "ExpressionStatement" && statement.expression.type === "CallExpression") return {
+		bindingName: null,
+		call: statement.expression
+	};
+	if (statement.type !== "VariableDeclaration") return null;
+	const declaration = statement.declarations[0];
+	if (declaration?.init?.type !== "CallExpression") return null;
+	return {
+		bindingName: declaration.id.type === "Identifier" ? declaration.id.name : null,
+		call: declaration.init
+	};
+}
+function hookNameOf(call) {
+	return call.callee.type === "Identifier" ? call.callee.name : null;
+}
+/** Keep built-in hooks in context, state, derivation, and effect order. */
+const preferHookOrderRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Order built-in React hooks by context, state, derivation, and effect role." },
+		messages: { hookOrder: "Move `{{hook}}` before later hook families so hooks read as context, state and refs, derivations, then effects." }
+	},
+	createOnce(context) {
+		const checkFunction = (node) => {
+			if (node.body === null || node.body.type !== "BlockStatement") return;
+			let latestOrder = -1;
+			const derivationBindings = /* @__PURE__ */ new Set();
+			for (const statement of node.body.body) {
+				const directCall = directCallOf(statement);
+				if (directCall === null) continue;
+				const { bindingName, call } = directCall;
+				const hookName = hookNameOf(call);
+				const order = hookName === null ? void 0 : HOOK_ORDER.get(hookName);
+				if (order === void 0) continue;
+				if (order === 2 && bindingName !== null) derivationBindings.add(bindingName);
+				if (order < latestOrder) {
+					const seed = call.arguments[0];
+					if (order === 1 && seed?.type === "Identifier" && derivationBindings.has(seed.name)) continue;
+					context.report({
+						node: call,
+						messageId: "hookOrder",
+						data: { hook: hookName }
+					});
+					continue;
+				}
+				latestOrder = order;
+			}
+		};
+		return {
+			ArrowFunctionExpression: checkFunction,
+			FunctionDeclaration: checkFunction,
+			FunctionExpression: checkFunction
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/prefer-jsx-boolean-and.ts
+const BOOLEAN_BINARY_OPERATORS = new Set([
+	"!=",
+	"!==",
+	"<",
+	"<=",
+	"==",
+	"===",
+	">",
+	">=",
+	"in",
+	"instanceof"
+]);
+function unwrapExpression(expression) {
+	if (expression.type === "ParenthesizedExpression" || expression.type === "TSAsExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSTypeAssertion") return unwrapExpression(expression.expression);
+	return expression;
+}
+function propertyNameOf$1(key) {
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "Literal" && typeof key.value === "string") return key.value;
+	return null;
+}
+function propertyTypeInMembers(members, propertyName) {
+	for (const member of members) if (member.type === "TSPropertySignature" && !member.computed && propertyNameOf$1(member.key) === propertyName) return member.typeAnnotation?.typeAnnotation ?? null;
+	return null;
+}
+function propertyTypeOf({ propertyName, resolvingAliases = /* @__PURE__ */ new Set(), sourceCode, type }) {
+	if (type.type === "TSParenthesizedType") return propertyTypeOf({
+		propertyName,
+		resolvingAliases,
+		sourceCode,
+		type: type.typeAnnotation
+	});
+	if (type.type === "TSTypeLiteral") return propertyTypeInMembers(type.members, propertyName);
+	if (type.type !== "TSTypeReference") return null;
+	const alias = resolveTypeAlias(sourceCode, type);
+	if (alias !== null && !resolvingAliases.has(alias)) return propertyTypeOf({
+		propertyName,
+		resolvingAliases: new Set([...resolvingAliases, alias]),
+		sourceCode,
+		type: alias.typeAnnotation
+	});
+	for (const declaration of resolveTypeInterfaces(sourceCode, type)) {
+		const propertyType = propertyTypeInMembers(declaration.body.body, propertyName);
+		if (propertyType !== null) return propertyType;
+	}
+	return null;
+}
+function destructuredTypeOf(sourceCode, identifier) {
+	let pattern = identifier;
+	let propertyName = null;
+	while (pattern.parent.type === "AssignmentPattern" || pattern.parent.type === "Property") {
+		pattern = pattern.parent;
+		if (pattern.type === "Property") propertyName = propertyNameOf$1(pattern.key);
+	}
+	if (propertyName === null || pattern.parent.type !== "ObjectPattern" || pattern.parent.typeAnnotation === null || pattern.parent.typeAnnotation === void 0) return null;
+	return propertyTypeOf({
+		propertyName,
+		sourceCode,
+		type: pattern.parent.typeAnnotation.typeAnnotation
+	});
+}
+function declaredTypeOf(sourceCode, identifier) {
+	const variable = resolveVariable(sourceCode, identifier);
+	if (variable === null) return null;
+	for (const definition of variable.defs) {
+		if (definition.name.typeAnnotation != null) return definition.name.typeAnnotation.typeAnnotation;
+		const destructuredType = destructuredTypeOf(sourceCode, definition.name);
+		if (destructuredType !== null) return destructuredType;
+	}
+	return null;
+}
+function declaredTypeOfExpression(sourceCode, expression) {
+	const unwrapped = unwrapExpression(expression);
+	if (unwrapped.type === "Identifier") return declaredTypeOf(sourceCode, unwrapped);
+	if (unwrapped.type !== "MemberExpression" || unwrapped.computed || unwrapped.property.type !== "Identifier") return null;
+	const objectType = declaredTypeOfExpression(sourceCode, unwrapped.object);
+	return objectType === null ? null : propertyTypeOf({
+		propertyName: unwrapped.property.name,
+		sourceCode,
+		type: objectType
+	});
+}
+function guardTypeOfType({ resolvingAliases = /* @__PURE__ */ new Set(), sourceCode, type }) {
+	if (type.type === "TSParenthesizedType") return guardTypeOfType({
+		resolvingAliases,
+		sourceCode,
+		type: type.typeAnnotation
+	});
+	if (type.type === "TSBooleanKeyword") return "boolean";
+	if (type.type === "TSNumberKeyword") return "number";
+	if (type.type === "TSStringKeyword") return "string";
+	if (type.type === "TSLiteralType" && "value" in type.literal) {
+		if (typeof type.literal.value === "boolean") return "boolean";
+		if (typeof type.literal.value === "number") return "number";
+		if (typeof type.literal.value === "string") return "string";
+	}
+	if (type.type === "TSUnionType") {
+		const memberTypes = new Set(type.types.filter((member) => member.type !== "TSNullKeyword" && member.type !== "TSUndefinedKeyword" && member.type !== "TSVoidKeyword").map((member) => guardTypeOfType({
+			resolvingAliases,
+			sourceCode,
+			type: member
+		})));
+		if (memberTypes.size === 1) return memberTypes.values().next().value ?? "unknown";
+		if (memberTypes.has("number") || memberTypes.has("string")) return "non-boolean";
+		return "unknown";
+	}
+	if (type.type === "TSIntersectionType") {
+		const primitiveTypes = new Set(type.types.map((member) => guardTypeOfType({
+			resolvingAliases,
+			sourceCode,
+			type: member
+		})).filter((member) => member !== "unknown"));
+		return primitiveTypes.size === 1 ? primitiveTypes.values().next().value ?? "unknown" : "unknown";
+	}
+	if (type.type === "TSTypeReference") {
+		const alias = resolveTypeAlias(sourceCode, type);
+		if (alias !== null && !resolvingAliases.has(alias)) return guardTypeOfType({
+			resolvingAliases: new Set([...resolvingAliases, alias]),
+			sourceCode,
+			type: alias.typeAnnotation
+		});
+	}
+	return "unknown";
+}
+function guardTypeOfExpression(sourceCode, expression) {
+	const unwrapped = unwrapExpression(expression);
+	if (unwrapped.type === "Literal") {
+		if (typeof unwrapped.value === "boolean") return "boolean";
+		if (typeof unwrapped.value === "number") return "number";
+		if (typeof unwrapped.value === "string") return "string";
+	}
+	if (unwrapped.type === "UnaryExpression" && unwrapped.operator === "!") return "boolean";
+	if (unwrapped.type === "BinaryExpression" && BOOLEAN_BINARY_OPERATORS.has(unwrapped.operator)) return "boolean";
+	if (unwrapped.type === "LogicalExpression") {
+		const leftType = guardTypeOfExpression(sourceCode, unwrapped.left);
+		return leftType === guardTypeOfExpression(sourceCode, unwrapped.right) ? leftType : "unknown";
+	}
+	if (unwrapped.type === "ConditionalExpression") {
+		const consequentType = guardTypeOfExpression(sourceCode, unwrapped.consequent);
+		return consequentType === guardTypeOfExpression(sourceCode, unwrapped.alternate) ? consequentType : "unknown";
+	}
+	const declaredType = declaredTypeOfExpression(sourceCode, unwrapped);
+	return declaredType === null ? "unknown" : guardTypeOfType({
+		sourceCode,
+		type: declaredType
+	});
+}
+function isNull(expression) {
+	const unwrapped = unwrapExpression(expression);
+	return unwrapped.type === "Literal" && unwrapped.value === null;
+}
+function needsConditionParentheses(expression) {
+	const unwrapped = unwrapExpression(expression);
+	return unwrapped.type === "AssignmentExpression" || unwrapped.type === "ConditionalExpression" || unwrapped.type === "SequenceExpression" || unwrapped.type === "LogicalExpression" && unwrapped.operator !== "&&";
+}
+function conditionTextOf(sourceCode, expression) {
+	const text = sourceCode.getText(expression);
+	return needsConditionParentheses(expression) ? `(${text})` : text;
+}
+function negatedConditionTextOf(sourceCode, expression) {
+	const unwrapped = unwrapExpression(expression);
+	const text = sourceCode.getText(expression);
+	if (unwrapped.type === "CallExpression" || unwrapped.type === "Identifier" || unwrapped.type === "Literal" || unwrapped.type === "MemberExpression" || unwrapped.type === "UnaryExpression") return `!${text}`;
+	return `!(${text})`;
+}
+function renderedTextOf(sourceCode, expression) {
+	const unwrapped = unwrapExpression(expression);
+	const text = sourceCode.getText(expression);
+	return unwrapped.type === "AssignmentExpression" || unwrapped.type === "ConditionalExpression" || unwrapped.type === "SequenceExpression" || unwrapped.type === "LogicalExpression" && unwrapped.operator !== "&&" ? `(${text})` : text;
+}
+/** Require boolean guards and canonical `&&` JSX conditionals. */
+const preferJsxBooleanAndRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require boolean JSX guards and replace boolean null-branch conditionals with logical AND." },
+		fixable: "code",
+		messages: {
+			explicitPredicate: "Use an explicit {{type}} predicate before conditionally rendering JSX.",
+			preferAnd: "Replace this boolean null-branch conditional with logical AND."
+		}
+	},
+	createOnce(context) {
+		const checkLogicalExpression = (expression) => {
+			if (expression.parent.type !== "JSXExpressionContainer" || expression.operator !== "&&") return;
+			const guardType = guardTypeOfExpression(context.sourceCode, expression.left);
+			if (guardType === "non-boolean" || guardType === "number" || guardType === "string") context.report({
+				node: expression.left,
+				messageId: "explicitPredicate",
+				data: { type: guardType }
+			});
+		};
+		const checkConditionalExpression = (expression) => {
+			if (expression.parent.type !== "JSXExpressionContainer") return;
+			const isConsequentNull = isNull(expression.consequent);
+			if (isConsequentNull === isNull(expression.alternate)) return;
+			if (guardTypeOfExpression(context.sourceCode, expression.test) !== "boolean") return;
+			const unwrappedTest = unwrapExpression(expression.test);
+			if (isConsequentNull && unwrappedTest.type === "UnaryExpression" && unwrappedTest.operator === "!" && guardTypeOfExpression(context.sourceCode, unwrappedTest.argument) !== "boolean") return;
+			let condition = expression.test;
+			let isNegated = isConsequentNull;
+			if (isConsequentNull && unwrappedTest.type === "UnaryExpression" && unwrappedTest.operator === "!") {
+				condition = unwrappedTest.argument;
+				isNegated = false;
+			}
+			const rendered = isConsequentNull ? expression.alternate : expression.consequent;
+			const replacement = `${isNegated ? negatedConditionTextOf(context.sourceCode, condition) : conditionTextOf(context.sourceCode, condition)} && ${renderedTextOf(context.sourceCode, rendered)}`;
+			context.report({
+				node: expression,
+				messageId: "preferAnd",
+				fix(fixer) {
+					return fixer.replaceText(expression, replacement);
+				}
+			});
+		};
+		return {
+			ConditionalExpression: checkConditionalExpression,
+			LogicalExpression: checkLogicalExpression
+		};
+	}
+});
+
+//#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,
+			TSCallSignatureDeclaration: checkFunction,
+			TSConstructSignatureDeclaration: checkFunction,
+			TSConstructorType: checkFunction,
+			TSDeclareFunction: checkFunction,
+			TSEmptyBodyFunctionExpression: checkFunction,
+			TSFunctionType: checkFunction,
+			TSMethodSignature: checkFunction
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/prefer-react-props-reference.ts
+const HTTP_METHOD_EXPORT_NAMES = new Set([
+	"DELETE",
+	"GET",
+	"HEAD",
+	"OPTIONS",
+	"PATCH",
+	"POST",
+	"PUT"
+]);
+function componentNameOf(node) {
+	if (node.type !== "ArrowFunctionExpression") return node.id?.name ?? null;
+	if (node.parent.type === "VariableDeclarator" && node.parent.id.type === "Identifier") return node.parent.id.name;
+	return null;
+}
+function isComponent(node) {
+	const name = componentNameOf(node);
+	return name !== null && !HTTP_METHOD_EXPORT_NAMES.has(name) && /^\p{Lu}/u.test(name);
+}
+function propertyNameOf(key) {
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "Literal" && typeof key.value === "string") return key.value;
+	return null;
+}
+function membersHaveChildren(members) {
+	return members.some((member) => member.type === "TSPropertySignature" && !member.computed && propertyNameOf(member.key) === "children");
+}
+function typeHasChildren({ resolvingAliases = /* @__PURE__ */ new Set(), sourceCode, type }) {
+	if (type.type === "TSParenthesizedType") return typeHasChildren({
+		resolvingAliases,
+		sourceCode,
+		type: type.typeAnnotation
+	});
+	if (type.type === "TSIntersectionType") return type.types.some((member) => typeHasChildren({
+		resolvingAliases,
+		sourceCode,
+		type: member
+	}));
+	if (type.type === "TSTypeLiteral") return membersHaveChildren(type.members);
+	if (type.type !== "TSTypeReference") return false;
+	const alias = resolveTypeAlias(sourceCode, type);
+	if (alias !== null && !resolvingAliases.has(alias) && typeHasChildren({
+		resolvingAliases: new Set([...resolvingAliases, alias]),
+		sourceCode,
+		type: alias.typeAnnotation
+	})) return true;
+	return resolveTypeInterfaces(sourceCode, type).some((declaration) => membersHaveChildren(declaration.body.body));
+}
+function isChildrenReference(identifier) {
+	return identifier.parent.type === "MemberExpression" && !identifier.parent.computed && identifier.parent.object === identifier && identifier.parent.property.type === "Identifier" && identifier.parent.property.name === "children";
+}
+function patternBinding(property) {
+	if (property.value.type === "Identifier") return property.value;
+	if (property.value.type === "AssignmentPattern" && property.value.left.type === "Identifier") return property.value.left;
+	return null;
+}
+function canDestructure(sourceCode, pattern) {
+	if (pattern.properties.length === 0) return false;
+	const rest = pattern.properties.find((property) => property.type === "RestElement");
+	if (rest !== void 0) {
+		if (rest.argument.type !== "Identifier") return false;
+		return resolveVariable(sourceCode, rest.argument)?.references.some((reference) => reference.identifier.parent.type === "JSXSpreadAttribute" && reference.identifier.parent.argument === reference.identifier) ?? false;
+	}
+	return pattern.properties.every((property) => {
+		if (property.type !== "Property") return false;
+		const binding = patternBinding(property);
+		if (binding === null) return false;
+		return (resolveVariable(sourceCode, binding)?.references.filter((reference) => reference.isRead()).length ?? 0) >= 3;
+	});
+}
+/** Keep React props available through one named component boundary. */
+const preferReactPropsReferenceRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Keep React component props behind one named parameter and bounded body-local destructuring." },
+		messages: {
+			canonicalName: "Name the React component parameter `props` so prop access has one canonical form.",
+			childrenReference: "Render `props.children` explicitly when the component props contract declares children.",
+			destructureLocally: "Keep prop access as `props.X`; destructure inside the body only to strip owned fields before forwarding or when every field is read at least three times.",
+			nameProps: "Accept one named props parameter and reference fields through it; destructure component-owned fields inside the body when forwarding requires it."
+		}
+	},
+	createOnce(context) {
+		const checkComponent = (node) => {
+			if (!isComponent(node)) return;
+			const parameter = node.params[0];
+			if (parameter?.type === "ObjectPattern") {
+				context.report({
+					node: parameter,
+					messageId: "nameProps"
+				});
+				return;
+			}
+			if (parameter?.type !== "Identifier") return;
+			if (parameter.name !== "props") {
+				context.report({
+					node: parameter,
+					messageId: "canonicalName"
+				});
+				return;
+			}
+			const variable = resolveVariable(context.sourceCode, parameter);
+			for (const reference of variable?.references ?? []) {
+				const parent = reference.identifier.parent;
+				if (parent.type === "VariableDeclarator" && parent.init === reference.identifier && parent.id.type === "ObjectPattern" && !canDestructure(context.sourceCode, parent.id)) context.report({
+					node: parent.id,
+					messageId: "destructureLocally"
+				});
+			}
+			const annotation = parameter.typeAnnotation?.typeAnnotation;
+			if (annotation === void 0 || !typeHasChildren({
+				sourceCode: context.sourceCode,
+				type: annotation
+			})) return;
+			if (variable !== null && !variable.references.some((reference) => isChildrenReference(reference.identifier))) context.report({
+				node: parameter,
+				messageId: "childrenReference"
+			});
+		};
+		return {
+			ArrowFunctionExpression: checkComponent,
+			FunctionDeclaration: checkComponent,
+			FunctionExpression: checkComponent
+		};
+	}
+});
+
+//#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-repository-test-subject.ts
+const runtimeRepositoryPrefixes = ["cloudflare:"];
+function hasRuntimeImport(node) {
+	if (node.importKind === "type") return false;
+	if (node.specifiers.length === 0) return true;
+	return node.specifiers.some((specifier) => specifier.type !== "ImportSpecifier" || specifier.importKind !== "type");
+}
+/** Require behavioral tests to exercise repository-owned code. */
+const requireRepositoryTestSubjectRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require files containing test cases to import a repository-owned subject." },
+		messages: { missingSubject: "This test file exercises no repository-owned subject. Remove the test or import the behavior it protects." },
+		schema: repositoryModuleRuleSchema,
+		defaultOptions: [{ internalModulePrefixes: [] }]
+	},
+	createOnce(context) {
+		let firstTestCall = null;
+		let hasRepositoryImport = false;
+		let internalModulePrefixes = [];
+		function isRepositorySpecifier(specifier) {
+			return isRepositoryOwnedModuleSpecifier({
+				additionalPrefixes: runtimeRepositoryPrefixes,
+				internalModulePrefixes,
+				specifier
+			});
+		}
+		return {
+			"Program"() {
+				firstTestCall = null;
+				hasRepositoryImport = false;
+				internalModulePrefixes = getInternalModulePrefixes(context.options);
+			},
+			"ImportDeclaration"(node) {
+				if (typeof node.source.value === "string" && isRepositorySpecifier(node.source.value) && hasRuntimeImport(node)) hasRepositoryImport = true;
+			},
+			"ImportExpression"(node) {
+				if (node.source.type === "Literal" && typeof node.source.value === "string" && isRepositorySpecifier(node.source.value)) hasRepositoryImport = true;
+			},
+			"CallExpression"(node) {
+				if (firstTestCall === null && getTestFrameworkCall(context.sourceCode, node)?.kind === "test") firstTestCall = node;
+			},
+			"Program:exit"() {
+				if (firstTestCall !== null && !hasRepositoryImport) context.report({
+					node: firstTestCall,
+					messageId: "missingSubject"
+				});
+			}
+		};
+	}
+});
+
+//#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 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) || !isOutermostTypeAssertion(node) || hasSafetyComment(context.sourceCode, node)) return;
+			context.report({
+				node,
+				messageId: "missingSafetyComment"
+			});
+		};
+		return {
+			TSAsExpression: checkAssertion,
+			TSTypeAssertion: checkAssertion
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/require-special-comment-tag.ts
+const SPECIAL_TAG = /^\s*(fixme|hack|note|todo)\b(?!:)/iu;
+/** Require canonical uppercase tags and a colon on special comments. */
+const requireSpecialCommentTagRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require canonical uppercase tags and a colon on special comments." },
+		fixable: "code",
+		messages: { invalidTag: "Write the special comment tag as `{{tag}}:` before its context." }
+	},
+	createOnce(context) {
+		return { Program() {
+			for (const comment of context.sourceCode.getAllComments()) {
+				const match = SPECIAL_TAG.exec(comment.value);
+				if (match?.[1] === void 0) continue;
+				const matchedTag = match[1];
+				const tag = matchedTag.toUpperCase();
+				const leadingLength = comment.value.length - comment.value.trimStart().length;
+				context.report({
+					loc: {
+						start: comment.loc.start,
+						end: comment.loc.end
+					},
+					messageId: "invalidTag",
+					data: { tag },
+					fix(fixer) {
+						const start = comment.range[0] + 2 + leadingLength;
+						return fixer.replaceTextRange([start, start + matchedTag.length], `${tag}:`);
+					}
+				});
+			}
+		} };
+	}
+});
+
+//#endregion
+//#region src/index.ts
+const meta = {
+	name: "@utilfirst/eslint-plugin",
+	version
+};
+const antiSlopPlugin = eslintCompatPlugin({
+	meta,
+	rules: {
+		"no-call-count-only-test": noCallCountOnlyTestRule,
+		"no-chained-type-assertions": noChainedTypeAssertionsRule,
+		"no-conditional-undefined-properties": noConditionalUndefinedPropertiesRule,
+		"no-enum-declarations": noEnumDeclarationsRule,
+		"no-imported-constant-restatement": noImportedConstantRestatementRule,
+		"no-known-value-widening": noKnownValueWideningRule,
+		"no-module-mocking": noModuleMockingRule,
+		"no-negated-throw-assertion": noNegatedThrowAssertionRule,
+		"no-object-parameters": noObjectParametersRule,
+		"no-positional-boolean-parameters": noPositionalBooleanParametersRule,
+		"no-promise-settlement-only-assertion": noPromiseSettlementOnlyAssertionRule,
+		"no-reflect-apply": noReflectApplyRule,
+		"no-reflect-get": noReflectGetRule,
+		"no-test-snapshots": noTestSnapshotsRule,
+		"no-truthy-falsy-assertion": noTruthyFalsyAssertionRule,
+		"no-uncontrolled-time-in-test": noUncontrolledTimeInTestRule,
+		"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-forwarded-props-order": preferForwardedPropsOrderRule,
+		"prefer-hook-order": preferHookOrderRule,
+		"prefer-jsx-boolean-and": preferJsxBooleanAndRule,
+		"prefer-options-parameter": preferOptionsParameterRule,
+		"prefer-react-props-reference": preferReactPropsReferenceRule,
+		"prefer-switch-discriminator-chain": preferSwitchDiscriminatorChainRule,
+		"prefer-top-level-function-declarations": preferTopLevelFunctionDeclarationsRule,
+		"require-lint-suppression-reason": requireLintSuppressionReasonRule,
+		"require-repository-test-subject": requireRepositoryTestSubjectRule,
+		"require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
+		"require-special-comment-tag": requireSpecialCommentTagRule
+	}
+});
+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: recommendedRules
+};
+var src_default = plugin;
+
+//#endregion
+export { src_default as t };