@mkrz/oxlint-config 0.1.0

package/dist/plugin/index.js

@@ -0,0 +1,1957 @@
+import { defineRule, eslintCompatPlugin } from "@oxlint/plugins";
+import ignore from "ignore";
+//#region src/plugin/rules/bindings.ts
+function findVariable(scope, name) {
+	return scope?.set.get(name) ?? (scope?.upper ? findVariable(scope.upper, name) : void 0);
+}
+/** Resolve the declaration, including imports below their uses and shadowing. */
+function importedBinding(sourceCode, identifier) {
+	const definition = findVariable(sourceCode.getScope(identifier), identifier.name)?.defs.find((entry) => entry.type === "ImportBinding");
+	if (definition?.parent?.type !== "ImportDeclaration") return null;
+	const specifier = definition.node;
+	return {
+		source: definition.parent.source.value,
+		name: specifier.type === "ImportSpecifier" ? specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value : null
+	};
+}
+/** An unresolved name or an environment global has no local declaration. */
+function isGlobalIdentifier(sourceCode, identifier) {
+	return (findVariable(sourceCode.getScope(identifier), identifier.name)?.defs.length ?? 0) === 0;
+}
+/** Resolve a static member name, including bracket strings and templates. */
+function memberName(node) {
+	if (!node.computed) return node.property.type === "Identifier" ? node.property.name : null;
+	return staticString(node.property);
+}
+function staticString(node) {
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	return node.type === "TemplateLiteral" && node.expressions.length === 0 ? node.quasis[0]?.value.cooked ?? null : null;
+}
+/** Follow direct imports and namespace/default-import members at the call site. */
+function importedCall(sourceCode, callee) {
+	if (callee.type === "Identifier") return importedBinding(sourceCode, callee);
+	if (callee.type !== "MemberExpression" || callee.object.type !== "Identifier") return null;
+	const binding = importedBinding(sourceCode, callee.object);
+	if (binding === null || binding.name !== null && binding.name !== "default") return null;
+	return {
+		source: binding.source,
+		name: memberName(callee)
+	};
+}
+//#endregion
+//#region src/plugin/rules/no-app-requires.ts
+function isRequire(sourceCode, callee) {
+	if (callee.type === "Identifier") return callee.name === "require" && isGlobalIdentifier(sourceCode, callee);
+	return callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "module" && isGlobalIdentifier(sourceCode, callee.object) && memberName(callee) === "require";
+}
+function moduleName(argument) {
+	if (argument?.type === "Literal" && typeof argument.value === "string") return argument.value;
+	return argument?.type === "TemplateLiteral" && argument.expressions.length === 0 ? argument.quasis[0]?.value.cooked ?? null : null;
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function stringPatterns(value) {
+	return Array.isArray(value) && value.every(isString);
+}
+/** CommonJS counterpart to the monorepo's native no-restricted-imports rule. */
+const noAppRequiresRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-app-requires",
+			description: "Disallow requiring application packages from shared packages."
+		},
+		schema: [{
+			type: "array",
+			items: { type: "string" }
+		}],
+		messages: { applicationImport: "Move shared code into a package and import it from there instead." }
+	},
+	createOnce(context) {
+		const state = { matcher: ignore({ ignorecase: true }) };
+		return {
+			before() {
+				const patterns = context.options[0];
+				if (patterns !== void 0 && !stringPatterns(patterns)) throw new Error("mkrz/no-app-requires expects an array of gitignore patterns.");
+				state.matcher = ignore({ ignorecase: true }).add(patterns ?? []);
+			},
+			CallExpression(node) {
+				if (!isRequire(context.sourceCode, node.callee)) return;
+				const name = moduleName(node.arguments[0]);
+				if (name !== null && ignore.isPathValid(name) && state.matcher.ignores(name)) context.report({
+					node,
+					messageId: "applicationImport"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/no-let.ts
+/** Require immutable variable bindings. */
+const noLetRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-let",
+			description: "Disallow variables declared with let."
+		},
+		messages: { mutableBinding: "Use `const` and derive a new value instead of reassigning a binding." }
+	},
+	createOnce(context) {
+		return { VariableDeclaration(node) {
+			if (node.kind === "let" && node.declare !== true) context.report({
+				node,
+				messageId: "mutableBinding"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/oxlint-directives.ts
+const directivePattern = /^\s*(?:oxlint|eslint)-(?:disable(?:-(?:next-)?line)?|enable)(?=\s|$)/u;
+const allowedPackageDirective = "oxlint-disable-next-line";
+const ruleNamePattern = /^(?:@?[\w-]+\/)?[\w-]+$/u;
+const reasonSeparatorPattern = /\s-{2,}\s/u;
+/** Oxlint also honors eslint-flavored directives, so both count. */
+function isOxlintDirective(value) {
+	return directivePattern.test(value);
+}
+function isAllowedPackageDirective(value) {
+	const directive = value.trim();
+	if (!directive.startsWith(allowedPackageDirective)) return false;
+	const remainder = directive.slice(24);
+	if (remainder !== "" && !/^\s/u.test(remainder)) return false;
+	const separator = reasonSeparatorPattern.exec(remainder);
+	if (separator === null) return false;
+	const rule = remainder.slice(0, separator.index).trim();
+	return remainder.slice(separator.index + separator[0].length).trim().length > 0 && ruleNamePattern.test(rule);
+}
+//#endregion
+//#region src/plugin/rules/no-oxlint-disable.ts
+/**
+* Applications must fix violations rather than suppress them.
+*
+* Caveat: a file-level `oxlint-disable mkrz/no-oxlint-disable` suppresses
+* this rule's own report and counts as "used", so
+* reportUnusedDisableDirectives stays silent too. The bare `oxlint-disable`
+* form is still caught by `unicorn/no-abusive-eslint-disable`. Lint rules
+* cannot exempt themselves from suppression; catching the named form needs an
+* out-of-band check (for example a CI grep for `oxlint-disable mkrz/`).
+*/
+const noOxlintDisableRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-oxlint-disable",
+			description: "Disallow Oxlint and ESLint disable directives."
+		},
+		messages: { forbiddenDirective: "Remove this Oxlint directive and fix the reported rule violation instead." }
+	},
+	createOnce(context) {
+		return { Program() {
+			for (const comment of context.sourceCode.getAllComments()) if (isOxlintDirective(comment.value)) context.report({
+				node: comment,
+				messageId: "forbiddenDirective"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/hook-calls.ts
+/**
+* Matches the TanStack query hooks and the wrapper convention built on them,
+* such as `useUserQuery`. Names like `useQueryClient` do not match because
+* they do not end in Query, Queries, or Mutation.
+*/
+const queryHookPattern = /^use(?:[A-Z].*)?(?:Query|Queries|Mutation)$/u;
+function isQueryHook(name) {
+	return queryHookPattern.test(name);
+}
+function calleeName(callee) {
+	if (callee.type === "Identifier") return callee.name;
+	if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier") return callee.property.name;
+	return null;
+}
+/** Casts and parentheses do not change what a call returns, so they must not hide it. */
+function unwrapCast(expression) {
+	return expression.type === "ParenthesizedExpression" || expression.type === "TSAsExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSSatisfiesExpression" ? unwrapCast(expression.expression) : expression;
+}
+function initializedByHook(node, predicate) {
+	if (node.id.type !== "ObjectPattern" || node.init == null) return false;
+	const init = unwrapCast(node.init);
+	return init.type === "CallExpression" && predicate(calleeName(init.callee) ?? "");
+}
+/**
+* A zustand hook bound to one store, named after it: `useCartStore`. The bare
+* `useStore` is not one; it takes the store as an argument and is recognised
+* by its import from `zustand` instead. React's own subscription hook is not
+* an application state store.
+*/
+function isBoundStoreHook(name) {
+	return name !== "useSyncExternalStore" && /^use[A-Z]\w*Store$/u.test(name);
+}
+//#endregion
+//#region src/plugin/rules/no-query-result-destructuring.ts
+/** Keep query fields qualified by their result object as a project convention. */
+const noQueryResultDestructuringRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-query-result-destructuring",
+			description: "Disallow object destructuring of query results."
+		},
+		messages: { destructuredQuery: "Keep the query result as one variable so fields stay qualified, for example `query.data` and `query.isSuccess`." }
+	},
+	createOnce(context) {
+		return { VariableDeclarator(node) {
+			if (initializedByHook(node, isQueryHook)) context.report({
+				node: node.id,
+				messageId: "destructuredQuery"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/no-restricted-react-hooks.ts
+const restrictedHooks = /* @__PURE__ */ new Set([
+	"useCallback",
+	"useEffect",
+	"useInsertionEffect",
+	"useLayoutEffect",
+	"useMemo",
+	"useReducer",
+	"useSyncExternalStore"
+]);
+/** Reject React APIs that fight render-time derivation and the compiler. */
+const noRestrictedReactHooksRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-restricted-react-hooks",
+			description: "Disallow restricted React hooks."
+		},
+		messages: { restrictedHook: "Replace `{{hook}}` with an event handler, render-time derivation, useState, or a selector-based store; let React Compiler handle memoization." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const binding = importedCall(context.sourceCode, node.callee);
+			if (binding?.source === "react" && binding.name !== null && restrictedHooks.has(binding.name)) context.report({
+				node,
+				messageId: "restrictedHook",
+				data: { hook: binding.name }
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/no-type-assertion.ts
+function isConstAssertion$1(node) {
+	return node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const";
+}
+/**
+* The first ancestor that is not parentheses or `!` around `node`. Both wrap
+* a single expression, so climbing them keeps the operand relationship.
+*/
+function outerNode(node) {
+	const { parent } = node;
+	return parent.type === "ParenthesizedExpression" || parent.type === "TSNonNullExpression" ? outerNode(parent) : parent;
+}
+/** True when this assertion is the operand of another assertion, which reports the whole chain. */
+function isInnerAssertion(node) {
+	const outer = outerNode(node);
+	return outer.type === "TSAsExpression" || outer.type === "TSTypeAssertion";
+}
+/** Reject type assertions; unsafe data should be validated instead of asserted. */
+const noTypeAssertionRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-type-assertion",
+			description: "Disallow TypeScript type assertions except const assertions."
+		},
+		messages: { noTypeAssertion: "Avoid type assertions. Validate the value with a runtime schema library such as zod, arktype, or valibot, or narrow it with a type guard, so the type is proven instead of asserted." }
+	},
+	createOnce(context) {
+		const checkAssertion = (node) => {
+			if (isConstAssertion$1(node) || isInnerAssertion(node)) return;
+			context.report({
+				node,
+				messageId: "noTypeAssertion"
+			});
+		};
+		return {
+			TSAsExpression: checkAssertion,
+			TSTypeAssertion: checkAssertion
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/package-disable-policy.ts
+/**
+* Packages may suppress one named violation when they document why.
+*
+* Caveat: a blanket disable directive suppresses this rule's own report; see
+* no-oxlint-disable for details.
+*/
+const packageDisablePolicyRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#package-disable-policy",
+			description: "Require narrow, explained Oxlint directives."
+		},
+		messages: { invalidDirective: "Use `oxlint-disable-next-line <rule> -- <reason>` for one named rule instead." }
+	},
+	createOnce(context) {
+		return { Program() {
+			for (const comment of context.sourceCode.getAllComments()) if (isOxlintDirective(comment.value) && !isAllowedPackageDirective(comment.value)) context.report({
+				node: comment,
+				messageId: "invalidDirective"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/require-store-selector.ts
+/** Modules that export zustand's bare `useStore(store, selector)`. */
+const zustandModules = /* @__PURE__ */ new Set(["zustand", "zustand/react"]);
+function returnedExpression(body) {
+	if (body === null) return null;
+	if (body.type !== "BlockStatement") return body;
+	const [statement] = body.body;
+	return body.body.length === 1 && statement?.type === "ReturnStatement" ? statement.argument : null;
+}
+/** `(state) => state` subscribes to the whole store, the same as no selector. */
+function isIdentitySelector(argument) {
+	if (argument.type !== "ArrowFunctionExpression" && argument.type !== "FunctionExpression" || argument.params.length !== 1) return false;
+	const [parameter] = argument.params;
+	const returned = returnedExpression(argument.body);
+	return parameter?.type === "Identifier" && returned?.type === "Identifier" && returned.name === parameter.name;
+}
+function isMissingSelector(sourceCode, selector) {
+	return selector === void 0 || selector.type === "Identifier" && selector.name === "undefined" && isGlobalIdentifier(sourceCode, selector) || selector.type === "UnaryExpression" && selector.operator === "void";
+}
+/**
+* Require zustand subscriptions to select only the state they consume.
+*
+* Two call shapes are checked: a bound hook named after its store, such as
+* `useCartStore(selector)`, and the bare `useStore(store, selector)` when it
+* is imported from zustand. A `useStore` from any other module is a different
+* library's hook and is left alone.
+*/
+const requireStoreSelectorRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#require-store-selector",
+			description: "Require a selector argument for zustand hooks."
+		},
+		messages: {
+			missingSelector: "Pass a selector such as `useFeatureStore((state) => state.value)` instead.",
+			identitySelector: "Select one value such as `(state) => state.value`; returning the whole state subscribes to every change."
+		}
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const binding = importedCall(context.sourceCode, node.callee);
+			const bare = binding?.name === "useStore" && zustandModules.has(binding.source);
+			const name = calleeName(node.callee);
+			if (!bare && (name === null || !isBoundStoreHook(name))) return;
+			const selector = node.arguments[bare ? 1 : 0];
+			if (isMissingSelector(context.sourceCode, selector)) context.report({
+				node,
+				messageId: "missingSelector"
+			});
+			else if (selector !== void 0 && isIdentitySelector(selector)) context.report({
+				node: selector,
+				messageId: "identitySelector"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/vendor/anti-slop/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.type === "TSNonNullExpression") current = current.expression;
+	return current;
+}
+function isConstAssertion(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.type === "TSNonNullExpression") && 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(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: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-chained-type-assertions",
+			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/plugin/rules/vendor/anti-slop/dictionary-types.ts
+const BUILT_INS = /* @__PURE__ */ new Set([
+	"Record",
+	"Readonly",
+	"Partial",
+	"Required",
+	"Pick",
+	"Omit",
+	"PropertyKey",
+	"NonNullable",
+	"Promise",
+	"PromiseLike"
+]);
+const TRANSPARENT_WRAPPERS = /* @__PURE__ */ new Set([
+	"Readonly",
+	"Partial",
+	"Required",
+	"NonNullable"
+]);
+/** Marks a name bound by an enclosing type parameter; it never resolves to a module alias. */
+const OPAQUE = Symbol("opaque type parameter");
+/** Substitutions that hide module aliases shadowed by lexical type parameters. */
+function shadowedSubstitutions(shadowed) {
+	return new Map([...shadowed].map((name) => [name, OPAQUE]));
+}
+function substitutionFor(substitutions, name) {
+	const substitution = substitutions.get(name);
+	if (substitution === void 0) return;
+	if (substitution === OPAQUE || isUnappliedReferenceTo(substitution, name)) return "opaque";
+	return substitution;
+}
+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) {
+			if (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 === null || unwrapped.typeArguments === void 0 || unwrapped.typeArguments.params.length === 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 isEffectivelyEmptyMember(member) {
+	return member.type === "TSPropertySignature" && member.optional && member.typeAnnotation !== null && member.typeAnnotation !== void 0 && isNeverType(member.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(type, base, resolving = /* @__PURE__ */ new Set()) {
+	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 = substitutionFor(base, name);
+	if (substitution === void 0 || substitution === "opaque") return type;
+	const nextResolving = new Set(resolving);
+	nextResolving.add(name);
+	return resolvedSubstitutionArgument(substitution, base, nextResolving);
+}
+function aliasSubstitution(alias, type, base) {
+	const parameters = alias.typeParameters?.params ?? [];
+	const typeArguments = type.typeArguments?.params ?? [];
+	const next = new Map(base);
+	for (const [index, parameter] of parameters.entries()) {
+		const argument = typeArguments[index] ?? parameter.default;
+		if (argument === null || argument === void 0) return null;
+		next.set(parameter.name.name, resolvedSubstitutionArgument(argument, next));
+	}
+	return next;
+}
+function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
+	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(member, environment, substitutions, resolvingAliases) !== null) ? "union" : null;
+	if (unwrapped.type === "TSIntersectionType") {
+		const unsafeMembers = unwrapped.types.map((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases));
+		if (unsafeMembers.includes("any")) return "any";
+		const [first] = unsafeMembers;
+		return first !== void 0 && unsafeMembers.every((member) => member !== null) ? first : null;
+	}
+	if (unwrapped.type !== "TSTypeReference") return null;
+	const name = typeReferenceName$2(unwrapped);
+	if (name === null) return null;
+	const substitution = substitutionFor(substitutions, name);
+	if (substitution !== void 0) return substitution === "opaque" ? null : unsafeDirectValue(substitution, environment, substitutions, resolvingAliases);
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? null : unsafeDirectValue(wrapped, environment, 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, unwrapped, substitutions);
+	if (nextSubstitutions === null) return null;
+	const nextResolving = new Set(resolvingAliases);
+	nextResolving.add(name);
+	return unsafeDirectValue(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+function dictionaryValueTypes(type, environment, substitutions, resolvingAliases) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.flatMap((member) => member.type === "TSIndexSignature" && member.typeAnnotation !== null ? [{
+		type: member.typeAnnotation.typeAnnotation,
+		substitutions
+	}] : []);
+	if (unwrapped.type === "TSMappedType") return unwrapped.typeAnnotation === null || !isBroadMappedKey(unwrapped.constraint, environment, substitutions) ? [] : [{
+		type: unwrapped.typeAnnotation,
+		substitutions
+	}];
+	if (unwrapped.type !== "TSTypeReference") return [];
+	const name = typeReferenceName$2(unwrapped);
+	if (name === null) return [];
+	const substitution = substitutionFor(substitutions, name);
+	if (substitution !== void 0) return substitution === "opaque" ? [] : dictionaryValueTypes(substitution, environment, substitutions, resolvingAliases);
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? [] : dictionaryValueTypes(wrapped, environment, 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(source, environment, substitutions, resolvingAliases);
+	}
+	const alias = environment.aliases.get(name);
+	if (alias === void 0 || resolvingAliases.has(name)) return [];
+	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+	if (nextSubstitutions === null) return [];
+	const nextResolving = new Set(resolvingAliases);
+	nextResolving.add(name);
+	return dictionaryValueTypes(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+function classifyUnsafeDictionaryValue(valueType, environment, shadowed = /* @__PURE__ */ new Set()) {
+	const unsafeValue = unsafeDirectValue(valueType, environment, shadowedSubstitutions(shadowed), /* @__PURE__ */ new Set());
+	return unsafeValue === null ? null : {
+		kind: "unsafe-dictionary",
+		unsafeValue
+	};
+}
+function classifyUnsafeDictionary(type, environment, shadowed = /* @__PURE__ */ new Set()) {
+	for (const valueType of dictionaryValueTypes(type, environment, shadowedSubstitutions(shadowed), /* @__PURE__ */ new Set())) {
+		const unsafeValue = unsafeDirectValue(valueType.type, environment, valueType.substitutions, /* @__PURE__ */ new Set());
+		if (unsafeValue !== null) return {
+			kind: "unsafe-dictionary",
+			unsafeValue
+		};
+	}
+	return null;
+}
+function resolvesToDictionary(type, environment, substitutions, resolvingAliases) {
+	return dictionaryValueTypes(type, environment, substitutions, resolvingAliases).length > 0;
+}
+function classifyWideningTarget(type, environment, shadowed = /* @__PURE__ */ new Set()) {
+	const shadowedMap = shadowedSubstitutions(shadowed);
+	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" } : unwrapped.members.length > 0 ? { kind: "anonymous object" } : null;
+	if (unwrapped.type === "TSMappedType") return isBroadMappedKey(unwrapped.constraint, environment, shadowedMap) ? { kind: "open dictionary" } : { kind: "anonymous object" };
+	if (unwrapped.type !== "TSTypeReference") return null;
+	const name = typeReferenceName$2(unwrapped);
+	if (name === null || shadowed.has(name)) return null;
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? null : classifyWideningTarget(wrapped, environment, shadowed);
+	}
+	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 = aliasSubstitution(alias, unwrapped, shadowedMap);
+		return substitutions !== null && resolvesToDictionary(alias.typeAnnotation, environment, substitutions, /* @__PURE__ */ new Set([name])) ? { kind: "generic container" } : null;
+	}
+	const substitutions = aliasSubstitution(alias, unwrapped, shadowedMap);
+	if (substitutions === null) return null;
+	return classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, /* @__PURE__ */ new Set([name]));
+}
+function isBroadMappedKey(type, environment, substitutions, resolvingAliases = /* @__PURE__ */ new Set()) {
+	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(member, environment, substitutions, resolvingAliases));
+	if (unwrapped.type !== "TSTypeReference") return false;
+	const name = typeReferenceName$2(unwrapped);
+	if (name === null) return false;
+	const substitution = substitutionFor(substitutions, name);
+	if (substitution !== void 0) return substitution !== "opaque" && isBroadMappedKey(substitution, environment, substitutions, resolvingAliases);
+	if (name === "PropertyKey" && isBuiltIn(name, environment)) return true;
+	const alias = environment.aliases.get(name);
+	if (alias === void 0 || resolvingAliases.has(name)) return false;
+	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+	if (nextSubstitutions === null) return false;
+	const nextResolving = new Set(resolvingAliases);
+	nextResolving.add(name);
+	return isBroadMappedKey(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+function classifyAliasBroadTarget(type, environment, substitutions, resolvingAliases) {
+	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(unwrapped.constraint, environment, substitutions) ? { kind: "open dictionary" } : null;
+	if (unwrapped.type !== "TSTypeReference") return null;
+	const name = typeReferenceName$2(unwrapped);
+	if (name === null) return null;
+	const substitution = substitutionFor(substitutions, name);
+	if (substitution !== void 0) return substitution === "opaque" ? null : classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? null : classifyAliasBroadTarget(wrapped, environment, 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, unwrapped, substitutions);
+	if (nextSubstitutions === null) return null;
+	const nextResolving = new Set(resolvingAliases);
+	nextResolving.add(name);
+	return classifyAliasBroadTarget(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+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/plugin/rules/vendor/anti-slop/lexical-type-parameters.ts
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function collectInferTypeParameterNames(node, visitorKeys, names) {
+	if (node.type === "TSInferType") names.add(node.typeParameter.name.name);
+	const keys = new Set(visitorKeys[node.type] ?? []);
+	for (const [key, value] of Object.entries(node)) {
+		if (!keys.has(key)) continue;
+		if (isNode(value)) {
+			collectInferTypeParameterNames(value, visitorKeys, names);
+			continue;
+		}
+		if (!Array.isArray(value)) continue;
+		for (const child of value) if (isNode(child)) collectInferTypeParameterNames(child, visitorKeys, names);
+	}
+}
+/** Local aliases, interfaces, classes, and enums shadow module-level aliases. */
+function collectLocalTypeDeclarationNames(statements, names) {
+	for (const statement of statements) {
+		const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+		if (declaration?.type === "TSTypeAliasDeclaration" || declaration?.type === "TSInterfaceDeclaration" || declaration?.type === "ClassDeclaration" || declaration?.type === "TSEnumDeclaration") {
+			if (declaration.id !== null) names.add(declaration.id.name);
+		}
+	}
+}
+/** 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 !== null && current.type !== "Program") {
+		if ("typeParameters" in current) for (const parameter of current.typeParameters?.params ?? []) names.add(parameter.name.name);
+		if (current.type === "BlockStatement" || current.type === "StaticBlock" || current.type === "TSModuleBlock") collectLocalTypeDeclarationNames(current.body, names);
+		if (current.type === "TSMappedType" && (descendant === current.nameType || descendant === current.typeAnnotation)) names.add(current.key.name);
+		if (current.type === "TSConditionalType" && descendant === current.trueType) collectInferTypeParameterNames(current.extendsType, visitorKeys, names);
+		descendant = current;
+		current = current.parent;
+	}
+	return names;
+}
+//#endregion
+//#region src/plugin/rules/vendor/anti-slop/no-known-value-widening.ts
+function unwrapExpression(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 resolveVariable$2(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;
+}
+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(sourceCode, expression, visitedVariables = /* @__PURE__ */ new Set()) {
+	if (isKnownEvidenceExpression(expression)) return true;
+	const unwrapped = unwrapExpression(expression);
+	if (unwrapped.type !== "Identifier") return false;
+	const variable = resolveVariable$2(sourceCode, unwrapped);
+	if (variable === null || visitedVariables.has(variable)) return false;
+	const declarator = variableDeclarator$1(variable);
+	if (declarator === null || declarator.init === null || !isStableConstVariable(variable, declarator)) return false;
+	visitedVariables.add(variable);
+	return hasKnownEvidence(sourceCode, declarator.init, visitedVariables);
+}
+function typeTarget(sourceCode, type, environment) {
+	return classifyWideningTarget(type, environment, lexicalTypeParameterNames(type, sourceCode.visitorKeys));
+}
+function annotationTarget(sourceCode, annotation, environment) {
+	return annotation === null || annotation === void 0 ? null : typeTarget(sourceCode, 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 isEmptyObjectExpression(expression) {
+	const unwrapped = unwrapExpression(expression);
+	return unwrapped.type === "ObjectExpression" && unwrapped.properties.length === 0;
+}
+function isDictionaryAccumulatorTarget(destination) {
+	return destination.kind === "open dictionary" || destination.kind === "generic container";
+}
+function hasParentAssertion(node) {
+	let parent = node.parent;
+	while (parent?.type === "TSNonNullExpression" || parent?.type === "ParenthesizedExpression") parent = parent.parent;
+	return parent?.type === "TSAsExpression" || parent?.type === "TSTypeAssertion";
+}
+/** Detect sound syntactic cases where a known value is explicitly widened and loses evidence. */
+const noKnownValueWideningRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-known-value-widening",
+			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 = (expression, destination, subject) => {
+			if (destination === null) return;
+			if (isDictionaryAccumulatorTarget(destination) && isEmptyObjectExpression(expression)) return;
+			if (!hasKnownEvidence(context.sourceCode, expression)) return;
+			context.report({
+				node: expression,
+				messageId: "widening",
+				data: {
+					subject,
+					target: destination.kind
+				}
+			});
+		};
+		const targetFromAnnotation = (annotation) => environment === null ? null : annotationTarget(context.sourceCode, annotation, environment);
+		return {
+			Program(node) {
+				environment = createTypeEnvironment(node);
+			},
+			VariableDeclarator(node) {
+				if (node.init === null || node.id.type !== "Identifier") return;
+				reportFlow(node.init, targetFromAnnotation(node.id.typeAnnotation), `binding \`${node.id.name}\``);
+			},
+			PropertyDefinition(node) {
+				if (node.value === null) return;
+				reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+			},
+			AccessorProperty(node) {
+				if (node.value === null) return;
+				reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+			},
+			AssignmentExpression(node) {
+				if (node.operator !== "=" || node.left.type !== "Identifier") return;
+				const variable = resolveVariable$2(context.sourceCode, node.left);
+				if (variable === null) return;
+				const declarator = variableDeclarator$1(variable);
+				if (declarator === null || declarator.id.type !== "Identifier") return;
+				reportFlow(node.right, targetFromAnnotation(declarator.id.typeAnnotation), `binding \`${declarator.id.name}\``);
+			},
+			ReturnStatement(node) {
+				if (node.argument === null) return;
+				const owner = enclosingFunction(node);
+				reportFlow(node.argument, targetFromAnnotation(owner?.returnType), `return value of \`${functionName(context.sourceCode, owner)}\``);
+			},
+			ArrowFunctionExpression(node) {
+				if (node.body.type === "BlockStatement") return;
+				reportFlow(node.body, targetFromAnnotation(node.returnType), `return value of \`${functionName(context.sourceCode, node)}\``);
+			},
+			TSAsExpression(node) {
+				if (environment === null || hasParentAssertion(node)) return;
+				reportFlow(node.expression, typeTarget(context.sourceCode, node.typeAnnotation, environment), "assertion");
+			},
+			TSTypeAssertion(node) {
+				if (environment === null || hasParentAssertion(node)) return;
+				reportFlow(node.expression, typeTarget(context.sourceCode, node.typeAnnotation, environment), "assertion");
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/vendor/anti-slop/reflect-method.ts
+function resolveVariable$1(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;
+}
+function isGlobalReflect(sourceCode, expression) {
+	if (expression.type !== "Identifier" || expression.name !== "Reflect") return false;
+	if (sourceCode.isGlobalReference(expression)) return true;
+	const variable = resolveVariable$1(sourceCode, expression);
+	return variable === null || variable.defs.length === 0;
+}
+/** Reports whether a call target names one method on the global Reflect object. */
+function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
+	if (!("property" in callee) || !("object" in callee) || !("computed" in callee)) return false;
+	if (!isGlobalReflect(sourceCode, callee.object)) return false;
+	return staticPropertyName(callee.property, callee.computed) === methodName;
+}
+/** Resolves a member name from an identifier, string literal, or expression-free template. */
+function staticPropertyName(property, computed) {
+	if (!computed) return property.type === "Identifier" ? property.name : null;
+	if (property.type === "Literal" && typeof property.value === "string") return property.value;
+	if (property.type === "TemplateLiteral" && property.expressions.length === 0) return property.quasis[0]?.value.cooked ?? null;
+	return null;
+}
+//#endregion
+//#region src/plugin/rules/vendor/anti-slop/no-module-mocking.ts
+const moduleMockMethods = /* @__PURE__ */ new Set([
+	"doMock",
+	"mock",
+	"unstable_mockModule"
+]);
+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;
+}
+function importedName(node) {
+	if (node.type !== "ImportSpecifier") return null;
+	return node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
+}
+function isTestFrameworkObject(sourceCode, expression) {
+	if (expression.type !== "Identifier") return false;
+	if ((expression.name === "vi" || expression.name === "jest") && sourceCode.isGlobalReference(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 method = staticPropertyName(callee.property, callee.computed);
+	return method !== null && moduleMockMethods.has(method);
+}
+/** Ban test framework module mocking in favor of real dependency seams. */
+const noModuleMockingRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-module-mocking",
+			description: "Disallow Vitest and Jest module mocking; tests must replace dependencies through real interfaces."
+		},
+		messages: { moduleMock: "Replace module mocking with dependency injection through a real interface, service layer, or faithful test implementation." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return;
+			if (moduleMockCall(context.sourceCode, node.callee)) context.report({
+				node,
+				messageId: "moduleMock"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/vendor/anti-slop/no-reflect-apply.ts
+/** Ban Reflect.apply, which bypasses ordinary typed function calls. */
+const noReflectApplyRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-reflect-apply",
+			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(context.sourceCode, node.callee, "apply")) context.report({
+				node,
+				messageId: "reflectApply"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/vendor/anti-slop/no-reflect-get.ts
+/** Ban Reflect.get, which bypasses ordinary property access and useful type evidence. */
+const noReflectGetRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-reflect-get",
+			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(context.sourceCode, node.callee, "get")) context.report({
+				node,
+				messageId: "reflectGet"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/vendor/anti-slop/no-unknown-parameters.ts
+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.typeAnnotation ?? parameter.left.typeAnnotation;
+	return parameter.typeAnnotation;
+}
+/** The parameter a type guard narrows; only that parameter may be unknown. */
+function guardedParameterName(node) {
+	const annotation = node.returnType?.typeAnnotation;
+	if (annotation?.type !== "TSTypePredicate") return null;
+	return annotation.parameterName.type === "Identifier" ? annotation.parameterName.name : "this";
+}
+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, "");
+}
+/** Disallow unknown inputs except type guards and `cause`. */
+const noUnknownParametersRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-unknown-parameters",
+			description: "Disallow explicitly unknown function parameters except `cause` and type guards."
+		},
+		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." }
+	},
+	createOnce(context) {
+		const checkParameters = (node) => {
+			const guarded = guardedParameterName(node);
+			for (const parameter of node.params) {
+				const annotation = parameterAnnotation(parameter);
+				if (annotation?.typeAnnotation.type !== "TSUnknownKeyword") continue;
+				const name = parameterName(parameter, context.sourceCode.getText(parameter));
+				if (name === "cause" || name === "this" || name === guarded) continue;
+				context.report({
+					node: annotation.typeAnnotation,
+					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/plugin/rules/vendor/anti-slop/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 === null || type.typeArguments === void 0 || type.typeArguments.params.length === 0 ? type.typeName.name : null;
+}
+/** Ban function contracts that return unknown instead of a parsed domain type. */
+const noUnknownReturnsRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-unknown-returns",
+			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 aliases = /* @__PURE__ */ new Map();
+		const shadowedBuiltIns = /* @__PURE__ */ new Set();
+		const resolvesToUnknown = (type, shadowedAliases, visited = /* @__PURE__ */ new Set()) => {
+			if (type.type === "TSUnknownKeyword") return true;
+			if (type.type === "TSParenthesizedType") return resolvesToUnknown(type.typeAnnotation, shadowedAliases, visited);
+			if (type.type === "TSUnionType") return type.types.some((member) => resolvesToUnknown(member, shadowedAliases, visited));
+			if (type.type === "TSTypeReference" && type.typeName.type === "Identifier" && (type.typeName.name === "Promise" || type.typeName.name === "PromiseLike") && !shadowedAliases.has(type.typeName.name) && !shadowedBuiltIns.has(type.typeName.name)) {
+				const value = type.typeArguments?.params[0];
+				return value !== void 0 && resolvesToUnknown(value, shadowedAliases, visited);
+			}
+			const name = referencedAliasName$1(type);
+			if (name === null || visited.has(name) || shadowedAliases.has(name)) return false;
+			const alias = aliases.get(name);
+			if (alias === void 0 || alias.typeParameters !== null && alias.typeParameters !== void 0) return false;
+			const nextVisited = new Set(visited);
+			nextVisited.add(name);
+			return resolvesToUnknown(alias.typeAnnotation, shadowedAliases, nextVisited);
+		};
+		const checkReturnType = (node) => {
+			const annotation = node.returnType;
+			if (annotation === null || annotation === void 0) return;
+			if (!resolvesToUnknown(annotation.typeAnnotation, lexicalTypeParameterNames(node, context.sourceCode.visitorKeys))) return;
+			context.report({
+				node: annotation.typeAnnotation,
+				messageId: "unknownReturn"
+			});
+		};
+		return {
+			Program(node) {
+				aliases.clear();
+				shadowedBuiltIns.clear();
+				for (const name of createTypeEnvironment(node).shadowedBuiltIns) shadowedBuiltIns.add(name);
+				for (const statement of node.body) {
+					const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+					if (declaration?.type === "TSTypeAliasDeclaration") aliases.set(declaration.id.name, declaration);
+				}
+			},
+			ArrowFunctionExpression: checkReturnType,
+			FunctionDeclaration: checkReturnType,
+			FunctionExpression: checkReturnType,
+			TSCallSignatureDeclaration: checkReturnType,
+			TSConstructSignatureDeclaration: checkReturnType,
+			TSConstructorType: checkReturnType,
+			TSDeclareFunction: checkReturnType,
+			TSEmptyBodyFunctionExpression: checkReturnType,
+			TSFunctionType: checkReturnType,
+			TSMethodSignature: checkReturnType
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/vendor/anti-slop/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 === null || type.typeArguments === void 0 || type.typeArguments.params.length === 0 ? type.typeName.name : null;
+}
+/** Ban named aliases that merely conceal TypeScript's unknown top type. */
+const noUnknownTypeAliasesRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-unknown-type-aliases",
+			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 aliases = /* @__PURE__ */ new Map();
+		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;
+			if (lexicalTypeParameterNames(type, context.sourceCode.visitorKeys).has(name)) return false;
+			const alias = aliases.get(name);
+			if (alias === void 0 || alias.typeParameters !== null && alias.typeParameters !== void 0) return false;
+			const nextVisited = new Set(visited);
+			nextVisited.add(name);
+			return resolvesToUnknown(alias.typeAnnotation, nextVisited);
+		};
+		return { Program(node) {
+			aliases.clear();
+			for (const statement of node.body) {
+				const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+				if (declaration?.type === "TSTypeAliasDeclaration") aliases.set(declaration.id.name, declaration);
+			}
+			for (const alias of aliases.values()) {
+				if (!resolvesToUnknown(alias.typeAnnotation, /* @__PURE__ */ new Set([alias.id.name]))) continue;
+				context.report({
+					node: alias.id,
+					messageId: "unknownAlias",
+					data: { alias: alias.id.name }
+				});
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/vendor/anti-slop/no-unsafe-dictionary-type.ts
+const typeNodeKinds = /* @__PURE__ */ 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) return false;
+	const name = typeReferenceName$1(node);
+	return name !== null && environment.aliases.has(name) && !isInsideTypeAliasDeclaration(node);
+}
+function shouldReportType(node, environment, shadowed) {
+	if (isPlainAliasConsumerUse(node, environment)) return false;
+	if (classifyUnsafeDictionary(node, environment, shadowed) === null) return false;
+	let child = node;
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (current.type === "TSTypeOperator" && current.operator === "keyof") return false;
+		if (current.type === "TSIndexedAccessType" && current.objectType === child) return false;
+		if (isTypeNode(current) && classifyUnsafeDictionary(current, environment, shadowed) !== null) return false;
+		child = current;
+		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: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-unsafe-dictionary-type",
+			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 = null;
+		const report = (node, value) => {
+			context.report({
+				node,
+				messageId: "unsafeDictionary",
+				data: { value }
+			});
+		};
+		const shadowedNames = (node) => lexicalTypeParameterNames(node, context.sourceCode.visitorKeys);
+		const reportIfUnsafe = (node) => {
+			if (environment === null) return;
+			const shadowed = shadowedNames(node);
+			if (!shouldReportType(node, environment, shadowed)) return;
+			const unsafe = classifyUnsafeDictionary(node, environment, shadowed);
+			if (unsafe === null) return;
+			report(node, unsafe.unsafeValue);
+		};
+		return {
+			Program(node) {
+				environment = createTypeEnvironment(node);
+			},
+			TSTypeReference: reportIfUnsafe,
+			TSTypeLiteral: reportIfUnsafe,
+			TSMappedType: reportIfUnsafe,
+			TSIndexSignature(node) {
+				if (environment === null || node.typeAnnotation === null || node.parent.type === "TSTypeLiteral") return;
+				const unsafe = classifyUnsafeDictionaryValue(node.typeAnnotation.typeAnnotation, environment, shadowedNames(node));
+				if (unsafe !== null) report(node, unsafe.unsafeValue);
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/vendor/anti-slop/no-widen-then-assert.ts
+const functionBoundaryTypes = /* @__PURE__ */ 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) {
+	let current = unwrapExpressionParentheses(node.expression);
+	while (current.type === "TSNonNullExpression") current = unwrapExpressionParentheses(current.expression);
+	return current;
+}
+function assertionFromExpression(expression) {
+	const unwrapped = unwrapExpressionParentheses(expression);
+	return unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion" ? unwrapped : null;
+}
+function normalizedTypeText(sourceText, type) {
+	return sourceText.slice(type.start, type.end).replaceAll(/\s+/gu, "");
+}
+function typesHaveSameSyntax(sourceText, left, right) {
+	return left !== null && normalizedTypeText(sourceText, unwrapTypeParentheses(left)) === normalizedTypeText(sourceText, unwrapTypeParentheses(right));
+}
+function isDefinitelyObjectType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	switch (unwrapped.type) {
+		case "TSArrayType":
+		case "TSConstructorType":
+		case "TSFunctionType":
+		case "TSMappedType":
+		case "TSObjectKeyword":
+		case "TSTupleType": return true;
+		case "TSTypeLiteral": return unwrapped.members.length > 0;
+		case "TSIntersectionType": return unwrapped.types.every(isDefinitelyObjectType);
+		case "TSTypeOperator": return unwrapped.operator === "readonly" && isDefinitelyObjectType(unwrapped.typeAnnotation);
+		default: 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.start === identifier.start && candidate.identifier.end === identifier.end);
+		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(expression, scopes, boundary, visitedVariables) {
+	const unwrapped = unwrapExpressionParentheses(expression);
+	if (unwrapped.type === "TSSatisfiesExpression") return knownValueEvidence(unwrapped.expression, scopes, boundary, visitedVariables);
+	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 === null || 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(declarator.init, scopes, boundary, /* @__PURE__ */ new Set([...visitedVariables, variable]));
+}
+function widenedBinding(variable, scopes) {
+	const declarator = variableDeclarator(variable);
+	if (declarator === null || 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(initializerAssertion !== null && initializerBroadKind !== null ? assertedExpression(initializerAssertion) : declarator.init, scopes, boundary, /* @__PURE__ */ new Set([variable]));
+	return evidence === null ? null : {
+		broadKind,
+		evidence,
+		declaredAt: declarator.end,
+		boundary
+	};
+}
+function assertionIsNarrower(sourceText, broadKind, evidence, assertedType) {
+	if (broadTypeKind(assertedType) !== null) return false;
+	if (broadKind === "top") return true;
+	if (typesHaveSameSyntax(sourceText, evidence.type, assertedType)) 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: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#no-widen-then-assert",
+			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.start <= widened.declaredAt || functionBoundary(node) !== widened.boundary || !assertionIsNarrower(context.sourceCode.text, widened.broadKind, widened.evidence, node.typeAnnotation)) return;
+			context.report({
+				node,
+				messageId: "widenThenAssert",
+				data: { name: expression.name }
+			});
+		};
+		return {
+			Program() {
+				scopes = context.sourceCode.scopeManager.scopes;
+			},
+			TSAsExpression: checkAssertion,
+			TSTypeAssertion: checkAssertion
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/vendor/stylistic/padding-line-between-statements.ts
+const CJS_EXPORT = /^(?:module\s*\.\s*)?exports(?:\s*\.|\s*\[|$)/u;
+const LT = "[\\r\\n\\u2028\\u2029]";
+const PADDING_LINE_SEQUENCE = new RegExp(String.raw`^(\s*?${LT})\s*${LT}(\s*;?)$`, "u");
+const paddingTypes = /* @__PURE__ */ new Set([
+	"always",
+	"any",
+	"never"
+]);
+const lineModes = /* @__PURE__ */ new Set([
+	"any",
+	"multiline",
+	"singleline"
+]);
+const statementContainers = /* @__PURE__ */ new Set([
+	"BlockStatement",
+	"Program",
+	"StaticBlock",
+	"SwitchCase",
+	"SwitchStatement",
+	"TSInterfaceBody",
+	"TSModuleBlock",
+	"TSTypeLiteral"
+]);
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSelectorOption(value) {
+	return isPlainObject(value) && "selector" in value && typeof value.selector === "string" && (!("lineMode" in value) || value.lineMode === void 0 || typeof value.lineMode === "string" && lineModes.has(value.lineMode));
+}
+function isStatementMatcher(value) {
+	return typeof value === "string" && statementTypes.has(value) || isSelectorOption(value);
+}
+function isStatementOption(value) {
+	return Array.isArray(value) ? value.length > 0 && value.every(isStatementMatcher) : isStatementMatcher(value);
+}
+function isPaddingOption(value) {
+	return isPlainObject(value) && "blankLine" in value && typeof value.blankLine === "string" && paddingTypes.has(value.blankLine) && "prev" in value && isStatementOption(value.prev) && "next" in value && isStatementOption(value.next);
+}
+function isSingleLine(node) {
+	return node.loc.start.line === node.loc.end.line;
+}
+function isTokenOnSameLine(left, right) {
+	return left.loc.end.line === right.loc.start.line;
+}
+function isSemicolonToken(token) {
+	return token.type === "Punctuator" && token.value === ";";
+}
+function isNotSemicolonToken(token) {
+	return !isSemicolonToken(token);
+}
+function isClosingBraceToken(token) {
+	return token.type === "Punctuator" && token.value === "}";
+}
+function isFunction(node) {
+	return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
+}
+function skipChainExpression(node) {
+	return node.type === "ChainExpression" ? node.expression : node;
+}
+function isParenthesized(node, sourceCode) {
+	const previousToken = sourceCode.getTokenBefore(node);
+	const nextToken = sourceCode.getTokenAfter(node);
+	return previousToken !== null && nextToken !== null && previousToken.type === "Punctuator" && previousToken.value === "(" && previousToken.range[1] <= node.range[0] && nextToken.type === "Punctuator" && nextToken.value === ")" && nextToken.range[0] >= node.range[1];
+}
+function isTopLevelExpressionStatement(node) {
+	if (node.type !== "ExpressionStatement") return false;
+	const { parent } = node;
+	return parent.type === "Program" || parent.type === "BlockStatement" && isFunction(parent.parent);
+}
+function isIIFEStatement(node) {
+	if (node.type !== "ExpressionStatement") return false;
+	let expression = skipChainExpression(node.expression);
+	if (expression.type === "UnaryExpression") expression = skipChainExpression(expression.argument);
+	if (expression.type !== "CallExpression") return false;
+	let callee = expression.callee;
+	while (callee.type === "SequenceExpression") {
+		callee = callee.expressions[callee.expressions.length - 1] ?? callee;
+		if (callee.type === "SequenceExpression") break;
+	}
+	return isFunction(callee);
+}
+function isCJSRequire(node) {
+	if (node.type !== "VariableDeclaration") return false;
+	const init = node.declarations[0]?.init;
+	if (init === null || init === void 0) return false;
+	let call = init;
+	while (call.type === "MemberExpression") call = call.object;
+	return call.type === "CallExpression" && call.callee.type === "Identifier" && call.callee.name === "require";
+}
+function isBlockLikeStatement(node, sourceCode) {
+	if (node.type === "DoWhileStatement" && node.body.type === "BlockStatement") return true;
+	if (isIIFEStatement(node)) return true;
+	const lastToken = sourceCode.getLastToken(node, isNotSemicolonToken);
+	const belongingNode = lastToken !== null && isClosingBraceToken(lastToken) ? sourceCode.getNodeByRangeIndex(lastToken.range[0]) : null;
+	return belongingNode !== null && (belongingNode.type === "BlockStatement" || belongingNode.type === "SwitchStatement");
+}
+function isDirective(node, sourceCode) {
+	return isTopLevelExpressionStatement(node) && node.expression.type === "Literal" && typeof node.expression.value === "string" && !isParenthesized(node.expression, sourceCode);
+}
+function isDirectivePrologue(node, sourceCode) {
+	if (!isDirective(node, sourceCode)) return false;
+	const { parent } = node;
+	if (parent.type !== "Program" && parent.type !== "BlockStatement") return false;
+	for (const sibling of parent.body) {
+		if (sibling === node) break;
+		if (!isDirective(sibling, sourceCode)) return false;
+	}
+	return true;
+}
+function isCJSExport(node) {
+	if (node.type !== "ExpressionStatement") return false;
+	const { expression } = node;
+	if (expression.type !== "AssignmentExpression") return false;
+	let left = expression.left;
+	if (left.type !== "MemberExpression") return false;
+	while (left.object.type === "MemberExpression") left = left.object;
+	return left.object.type === "Identifier" && (left.object.name === "exports" || left.object.name === "module" && left.property.type === "Identifier" && left.property.name === "exports");
+}
+function isExpression(node, sourceCode) {
+	return node.type === "ExpressionStatement" && !isDirectivePrologue(node, sourceCode);
+}
+function newKeywordTester(types, keyword) {
+	return (node, sourceCode) => types.includes(node.type) && sourceCode.getFirstToken(node)?.value === keyword;
+}
+function newNodeTypeTester(type) {
+	return (node) => node.type === type;
+}
+const maybeMultilineStatementEntries = [
+	["block-like", isBlockLikeStatement],
+	["const", newKeywordTester(["VariableDeclaration"], "const")],
+	["export", newKeywordTester([
+		"ExportAllDeclaration",
+		"ExportDefaultDeclaration",
+		"ExportNamedDeclaration"
+	], "export")],
+	["expression", isExpression],
+	["let", newKeywordTester(["VariableDeclaration"], "let")],
+	["return", newKeywordTester(["ReturnStatement"], "return")],
+	["type", newKeywordTester(["TSTypeAliasDeclaration"], "type")],
+	["using", (node) => node.type === "VariableDeclaration" && (node.kind === "using" || node.kind === "await using")],
+	["var", newKeywordTester(["VariableDeclaration"], "var")]
+];
+const statementEntries = [
+	["*", () => true],
+	["block", newNodeTypeTester("BlockStatement")],
+	["break", newKeywordTester(["BreakStatement"], "break")],
+	["case", newKeywordTester(["SwitchCase"], "case")],
+	["cjs-export", (node, sourceCode) => node.type === "ExpressionStatement" && node.expression.type === "AssignmentExpression" && CJS_EXPORT.test(sourceCode.getText(node.expression.left))],
+	["cjs-import", (node, sourceCode) => {
+		if (node.type !== "VariableDeclaration") return false;
+		const init = node.declarations[0]?.init;
+		return init !== null && init !== void 0 && sourceCode.getText(init).startsWith("require(");
+	}],
+	["class", newKeywordTester(["ClassDeclaration"], "class")],
+	["continue", newKeywordTester(["ContinueStatement"], "continue")],
+	["debugger", newKeywordTester(["DebuggerStatement"], "debugger")],
+	["default", newKeywordTester(["SwitchCase", "ExportDefaultDeclaration"], "default")],
+	["directive", isDirectivePrologue],
+	["do", newKeywordTester(["DoWhileStatement"], "do")],
+	["empty", newNodeTypeTester("EmptyStatement")],
+	["enum", newKeywordTester(["TSEnumDeclaration"], "enum")],
+	["exports", isCJSExport],
+	["for", newKeywordTester([
+		"ForStatement",
+		"ForInStatement",
+		"ForOfStatement"
+	], "for")],
+	["function", newNodeTypeTester("FunctionDeclaration")],
+	["function-overload", newNodeTypeTester("TSDeclareFunction")],
+	["if", newKeywordTester(["IfStatement"], "if")],
+	["iife", isIIFEStatement],
+	["import", newKeywordTester(["ImportDeclaration"], "import")],
+	["interface", newKeywordTester(["TSInterfaceDeclaration"], "interface")],
+	["require", isCJSRequire],
+	["switch", newKeywordTester(["SwitchStatement"], "switch")],
+	["throw", newKeywordTester(["ThrowStatement"], "throw")],
+	["try", newKeywordTester(["TryStatement"], "try")],
+	["ts-method", newNodeTypeTester("TSMethodSignature")],
+	["while", newKeywordTester(["WhileStatement", "DoWhileStatement"], "while")],
+	["with", newKeywordTester(["WithStatement"], "with")],
+	...maybeMultilineStatementEntries.flatMap(([key, test]) => [
+		[key, test],
+		[`singleline-${key}`, (node, sourceCode) => test(node, sourceCode) && isSingleLine(node)],
+		[`multiline-${key}`, (node, sourceCode) => test(node, sourceCode) && !isSingleLine(node)]
+	])
+];
+const statementTypes = new Map(statementEntries);
+const statementTypeNames = [...statementTypes.keys()];
+/** Nodes that take part in padding checks when they are direct children of a container. */
+function isStatementLike(node) {
+	return node.type.endsWith("Statement") || node.type.endsWith("Declaration") || node.type === "SwitchCase" || node.type === "TSDeclareFunction" || node.type === "TSMethodSignature";
+}
+function containerChildren(node) {
+	switch (node.type) {
+		case "BlockStatement":
+		case "Program":
+		case "StaticBlock":
+		case "TSInterfaceBody":
+		case "TSModuleBlock": return node.body;
+		case "SwitchCase": return node.consequent;
+		case "SwitchStatement": return node.cases;
+		case "TSTypeLiteral": return node.members;
+		default: return [];
+	}
+}
+function getActualLastToken(node, sourceCode) {
+	const semiToken = sourceCode.getLastToken(node);
+	if (semiToken === null) throw new Error("padding-line-between-statements: statement has no tokens");
+	const prevToken = sourceCode.getTokenBefore(semiToken);
+	const nextToken = sourceCode.getTokenAfter(semiToken);
+	return prevToken !== null && nextToken !== null && prevToken.range[0] >= node.range[0] && isSemicolonToken(semiToken) && !isTokenOnSameLine(prevToken, semiToken) && isTokenOnSameLine(semiToken, nextToken) ? prevToken : semiToken;
+}
+function getPaddingLineSequences(prevNode, nextNode, sourceCode) {
+	const pairs = [];
+	let prevToken = getActualLastToken(prevNode, sourceCode);
+	if (nextNode.loc.start.line - prevToken.loc.end.line < 2) return pairs;
+	do {
+		const token = sourceCode.getTokenAfter(prevToken, { includeComments: true });
+		if (token === null) break;
+		if (token.loc.start.line - prevToken.loc.end.line >= 2) pairs.push([prevToken, token]);
+		prevToken = token;
+	} while (prevToken.range[0] < nextNode.range[0]);
+	return pairs;
+}
+function getReportLoc(node, sourceCode) {
+	if (isSingleLine(node)) return node.loc;
+	const { line } = node.loc.start;
+	return {
+		start: node.loc.start,
+		end: {
+			line,
+			column: sourceCode.lines[line - 1]?.length ?? 0
+		}
+	};
+}
+function replacerToRemovePaddingLines(_match, trailingSpaces, indentSpaces) {
+	return trailingSpaces + indentSpaces;
+}
+function matchesSelector(node, option) {
+	if (option.selector !== "*" && option.selector !== node.type) return false;
+	if (option.lineMode === "singleline") return isSingleLine(node);
+	if (option.lineMode === "multiline") return !isSingleLine(node);
+	return true;
+}
+function matches(node, option, sourceCode) {
+	let statement = node;
+	while (statement.type === "LabeledStatement") statement = statement.body;
+	if (typeof option === "string") return statementTypes.get(option)?.(statement, sourceCode) ?? false;
+	if (isSelectorOption(option)) return matchesSelector(statement, option);
+	return option.some((item) => matches(statement, item, sourceCode));
+}
+function paddingTypeFor(options, prevNode, nextNode, sourceCode) {
+	for (let index = options.length - 1; index >= 0; index -= 1) {
+		const option = options[index];
+		if (option !== void 0 && matches(prevNode, option.prev, sourceCode) && matches(nextNode, option.next, sourceCode)) return option.blankLine;
+	}
+	return "any";
+}
+/** Require or disallow padding lines between statements. */
+const paddingLineBetweenStatementsRule = defineRule({
+	meta: {
+		type: "layout",
+		docs: {
+			url: "https://github.com/mkrz/oxlint-config/blob/main/docs/rules.md#padding-line-between-statements",
+			description: "Require or disallow padding lines between statements."
+		},
+		fixable: "whitespace",
+		schema: {
+			$defs: {
+				paddingType: {
+					type: "string",
+					enum: [
+						"any",
+						"never",
+						"always"
+					]
+				},
+				statementType: {
+					type: "string",
+					enum: statementTypeNames
+				},
+				selectorOption: {
+					type: "object",
+					properties: {
+						selector: { type: "string" },
+						lineMode: {
+							type: "string",
+							enum: [
+								"any",
+								"singleline",
+								"multiline"
+							]
+						}
+					},
+					required: ["selector"],
+					additionalProperties: false
+				},
+				statementMatcher: { anyOf: [{ $ref: "#/$defs/statementType" }, { $ref: "#/$defs/selectorOption" }] },
+				statementOption: { anyOf: [{ $ref: "#/$defs/statementMatcher" }, {
+					type: "array",
+					items: { $ref: "#/$defs/statementMatcher" },
+					minItems: 1,
+					uniqueItems: true,
+					additionalItems: false
+				}] }
+			},
+			type: "array",
+			additionalItems: false,
+			items: {
+				type: "object",
+				properties: {
+					blankLine: { $ref: "#/$defs/paddingType" },
+					prev: { $ref: "#/$defs/statementOption" },
+					next: { $ref: "#/$defs/statementOption" }
+				},
+				additionalProperties: false,
+				required: [
+					"blankLine",
+					"prev",
+					"next"
+				]
+			}
+		},
+		messages: {
+			expectedBlankLine: "Expected blank line before this statement.",
+			unexpectedBlankLine: "Unexpected blank line before this statement."
+		}
+	},
+	createOnce(context) {
+		const options = [];
+		const verifyNever = (nextNode, paddingLines) => {
+			if (paddingLines.length === 0) return;
+			context.report({
+				node: nextNode,
+				messageId: "unexpectedBlankLine",
+				loc: getReportLoc(nextNode, context.sourceCode),
+				fix(fixer) {
+					const [pair] = paddingLines;
+					if (paddingLines.length >= 2 || pair === void 0) return null;
+					const [prevToken, nextToken] = pair;
+					const start = prevToken.range[1];
+					const end = nextToken.range[0];
+					const text = context.sourceCode.text.slice(start, end).replace(PADDING_LINE_SEQUENCE, replacerToRemovePaddingLines);
+					return fixer.replaceTextRange([start, end], text);
+				}
+			});
+		};
+		const verifyAlways = (prevNode, nextNode, paddingLines) => {
+			if (paddingLines.length > 0) return;
+			context.report({
+				node: nextNode,
+				messageId: "expectedBlankLine",
+				loc: getReportLoc(nextNode, context.sourceCode),
+				fix(fixer) {
+					let prevToken = getActualLastToken(prevNode, context.sourceCode);
+					const nextToken = context.sourceCode.getFirstTokenBetween(prevToken, nextNode, {
+						includeComments: true,
+						filter(token) {
+							if (isTokenOnSameLine(prevToken, token)) {
+								prevToken = token;
+								return false;
+							}
+							return true;
+						}
+					}) ?? nextNode;
+					const newline = /\r\n|[\r\n\u2028\u2029]/u.exec(context.sourceCode.text)?.[0] ?? "\n";
+					const insertText = isTokenOnSameLine(prevToken, nextToken) ? newline + newline : newline;
+					return fixer.insertTextAfter(prevToken, insertText);
+				}
+			});
+		};
+		const verifyPair = (prevNode, nextNode) => {
+			const paddingType = paddingTypeFor(options, prevNode, nextNode, context.sourceCode);
+			if (paddingType === "any") return;
+			const paddingLines = getPaddingLineSequences(prevNode, nextNode, context.sourceCode);
+			if (paddingType === "never") verifyNever(nextNode, paddingLines);
+			else verifyAlways(prevNode, nextNode, paddingLines);
+		};
+		const verifyContainer = (node) => {
+			if (!statementContainers.has(node.type)) return;
+			let prevNode = null;
+			for (const child of containerChildren(node)) {
+				if (!isStatementLike(child)) continue;
+				if (prevNode !== null) verifyPair(prevNode, child);
+				prevNode = child;
+			}
+		};
+		return {
+			before() {
+				options.length = 0;
+				for (const option of context.options) if (isPaddingOption(option)) options.push(option);
+				return options.length > 0;
+			},
+			BlockStatement: verifyContainer,
+			Program: verifyContainer,
+			StaticBlock: verifyContainer,
+			SwitchCase: verifyContainer,
+			SwitchStatement: verifyContainer,
+			TSInterfaceBody: verifyContainer,
+			TSModuleBlock: verifyContainer,
+			TSTypeLiteral: verifyContainer
+		};
+	}
+});
+//#endregion
+//#region src/plugin/index.ts
+const plugin = eslintCompatPlugin({
+	meta: { name: "@mkrz/oxlint-config" },
+	rules: {
+		"no-app-requires": noAppRequiresRule,
+		"no-chained-type-assertions": noChainedTypeAssertionsRule,
+		"no-known-value-widening": noKnownValueWideningRule,
+		"no-let": noLetRule,
+		"no-module-mocking": noModuleMockingRule,
+		"no-oxlint-disable": noOxlintDisableRule,
+		"no-query-result-destructuring": noQueryResultDestructuringRule,
+		"no-reflect-apply": noReflectApplyRule,
+		"no-reflect-get": noReflectGetRule,
+		"no-restricted-react-hooks": noRestrictedReactHooksRule,
+		"no-type-assertion": noTypeAssertionRule,
+		"no-unknown-parameters": noUnknownParametersRule,
+		"no-unknown-returns": noUnknownReturnsRule,
+		"no-unknown-type-aliases": noUnknownTypeAliasesRule,
+		"no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
+		"no-widen-then-assert": noWidenThenAssertRule,
+		"package-disable-policy": packageDisablePolicyRule,
+		"padding-line-between-statements": paddingLineBetweenStatementsRule,
+		"require-store-selector": requireStoreSelectorRule
+	}
+});
+//#endregion
+export { plugin as default };