@utilfirst/eslint-plugin 0.3.0 → 0.4.1

package/dist/index.js

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