adamantite 0.35.0 → 0.37.0

package/dist/presets/lint/vendor/antislop/plugin.mjs

@@ -0,0 +1,1629 @@
+// Vendored build of the anti-slop oxlint plugin.
+// Source: https://github.com/dmmulroy/anti-slop (MIT) at commit 446268e5d15baa968eaec669ff65358d36ae6259.
+// Its dependencies (MIT) are inlined so this file is self-contained.
+// See license.md for the full license text.
+//
+// Generated by scripts/vendor-plugins.ts — do not edit by hand.
+//#region node_modules/.pnpm/@oxlint+plugins@1.78.0/node_modules/@oxlint/plugins/index.js
+/**
+* Define a rule.
+*
+* No-op function, just to provide type safety. Input is passed through unchanged.
+*
+* @param rule - Rule to define
+* @returns Same rule as passed in
+*/
+function defineRule(rule) {
+	return rule;
+}
+const EMPTY_VISITOR = {};
+/**
+* Convert a plugin which used Oxlint's `createOnce` API to also work with ESLint.
+*
+* If any of the plugin's rules use the Oxlint alternative `createOnce` API,
+* add ESLint-compatible `create` methods to those rules, which delegate to `createOnce`.
+* This makes the plugin compatible with ESLint.
+*
+* The `plugin` object passed in is mutated in-place.
+*
+* @param plugin - Plugin to convert
+* @returns Plugin with all rules having `create` method
+* @throws {Error} If `plugin` is not an object, or `plugin.rules` is not an object
+*/
+function eslintCompatPlugin(plugin) {
+	if (typeof plugin != "object" || !plugin) throw Error("Plugin must be an object");
+	let { rules } = plugin;
+	if (typeof rules != "object" || !rules) throw Error("Plugin must have an object as `rules` property");
+	let afterHooksState = new AfterHooksState();
+	for (let ruleName in rules) Object.hasOwn(rules, ruleName) && convertRule(rules[ruleName], afterHooksState);
+	return plugin;
+}
+/**
+* Class containing state for tracking if any `after` hooks for a plugin's rules need to be called.
+*
+* # Aims
+*
+* Aims are:
+* 1. `after` hook of each rule runs after all other AST visit functions, and CFG event handlers.
+* 2. `after` hooks for *all* a plugin's rules run after *all* that plugin's rules have completed visiting AST.
+* 3. `after` hooks for *all* a plugin's rules run before *any* of plugin's rules begin linting another file.
+* 4. In the case of an error during AST traversal, `after` hooks are always still run.
+*
+* The above exactly matches the behavior when running a `createOnce` rule in Oxlint.
+*
+* # Why this is important
+*
+* All the complication comes from ensuring `after` hooks run even after an error during AST traversal.
+*
+* In ESLint CLI, an error will crash the process, so it doesn't particularly matter if `after` hooks run or not,
+* but language servers will typically swallow errors, and keep the process running.
+*
+* Rules using `before` and `after` hooks will often rely on both hooks running in a predictable order,
+* to maintain some internal state. For example, they may use `before` and `after` hooks to maintain a per-file
+* cache of data which is shared between rules. The cache use case is why rule (2) above is important.
+*
+* Below is an example of using `before` and `after` hooks to maintain a per-file cache, shared between rules.
+* It relies on all `before` hooks running before any rule starts visiting the AST,
+* and all `after` hooks running after all rules have finished visiting the AST.
+*
+* ```ts
+* let cache: Data | null = null;
+*
+* let numRunningRules = 0;
+*
+* const setupCache = (context) => {
+*   if (cache === null) cache = new Data(context);
+*   numRunningRules++;
+* };
+*
+* const teardownCache = () => {
+*   numRunningRules--;
+*   if (numRunningRules === 0) cache = null;
+* };
+*
+* const rule1 = {
+*   createOnce(context) {
+*     return {
+*       before() {
+*         setupCache(context);
+*       },
+*       Identifier(node) {
+*         // Use `cache`
+*       },
+*       after: teardownCache,
+*     };
+*   },
+* };
+*
+* const rule2 = {
+*   // Same as above
+* };
+*
+* const rule3 = {
+*   // Same as above
+* };
+* ```
+*
+* If `after` hooks did not always run, the next lint run could get stale state, and malfunction.
+* If `after` hooks ran in the wrong order (e.g. after some `before` hooks for next file),
+* `numRunningRules` would never get to 0, and cache would never be cleared.
+*
+* Note that because all rules run together in a single AST traversal, if a rule from plugin X throws an error,
+* it can disrupt rules from plugin Y. This would make it hard to debug.
+*
+* # Mechanism
+*
+* ## Initialization
+*
+* Rules with an `after` hook register themselves by:
+*
+* 1. Calling `registerResetFunction` to register a function to run `after` hook and clean up internal state.
+*    This call adds the reset fn to `resetFunctions`, and adds `AFTER_HOOK_INACTIVE` to `pendingStates`.
+* 2. Adding an `onCodePathEnd` CFG event handler to the visitor which calls `ruleFinished` at end of AST traversal.
+*
+* ## Per-file setup
+*
+* Before linting a file, `create` will call `setupAfterHook` which is created by `createContextAndVisitor`.
+* This registers that the `after` hook for the rule needs to run, by setting `pendingStates[ruleIndex]`
+* to `AFTER_HOOK_PENDING`, and incrementing `pendingCount`.
+*
+* If a cleanup microtask has not been scheduled yet, one is scheduled now (see reason below).
+*
+* ## Normal operation
+*
+* AST traversal for each rule ends with `ruleFinished` hook being called from `onCodePathEnd` CFG event handler.
+* It increments `lintFinishedCount`. If `lintFinishedCount` equals `pendingCount`, all rules have finished linting
+* the file, and `reset` is called, which calls all the pending `after` hooks.
+*
+* ## Error handling
+*
+* If an error is thrown during AST traversal, we ensure that `after` hooks are still run by 2 mechanisms:
+*
+* ### 1. Next microtick
+*
+* Before any rules began linting files, a microtask was scheduled, which runs on next micro-tick.
+* All language servers we're aware of run each lint task in a separate tick, so this microtask will run in next tick
+* after a linting run, before the next lint task starts.
+*
+* If the linting run completed successfully, the microtask does nothing.
+*
+* But if an error was thrown during AST traversal, this will be visible from the state of `pendingCount`.
+* The microtask will run any `after` hooks which need to be run, and reset state to reflect that there are
+* no more pending `after` hooks.
+*
+* ### 2. Fallback: Next lint run
+*
+* Before linting any file, the state of `pendingCount` is checked.
+* If any `after` hooks are still pending, they are run immediately.
+* They're run before the `context` objects in `createOnce` closures are updated to the next file,
+* so they run with access to the old `context` object from the last file.
+*
+* This fallback should not be required, but it's included as "belt and braces", to handle if any language server
+* or other environment running ESLint programmatically, does not pause a tick between linting runs.
+*/
+var AfterHooksState = class {
+	resetFunctions = [];
+	pendingStates = [];
+	pendingCount = 0;
+	lintFinishedCount = 0;
+	resetIsScheduled = !1;
+	sourceCode = null;
+	resetMicrotask = this.resetMicrotaskImpl.bind(this);
+	/**
+	* Register a function to run `after` hook for a rule, and reset state.
+	* @param reset - Function to run `after` hook and reset state
+	* @returns Index of rule
+	*/
+	registerResetFunction(reset) {
+		let { pendingStates } = this, index = pendingStates.length;
+		return pendingStates.push(0), this.resetFunctions.push(reset), index;
+	}
+	/**
+	* Register that a rule with `after` hook has completed linting a file.
+	* Called by `onCodePathEnd` CFG event handler which is added to visitor for rules with `after` hooks.
+	*
+	* If all rules with an `after` hook which needs to be run have completed linting the file, run all `after` hooks.
+	*/
+	ruleFinished() {
+		this.lintFinishedCount++, this.lintFinishedCount === this.pendingCount && this.reset(!1);
+	}
+	/**
+	* Call all reset functions where corresponding entry in `pendingStates` is `AFTER_HOOK_PENDING`.
+	* Should only be called when some `after` hooks are pending.
+	*
+	* @param ignoreErrors - `true` to catch and silently ignore any errors which occur in `after` hooks.
+	*   `false` to throw them,
+	* @throws {unknown} If `ignoreErrors` is `false` and an error occurs in any `after` hooks.
+	*/
+	reset(ignoreErrors) {
+		this.pendingCount;
+		let { resetFunctions, pendingStates } = this, hooksLen = pendingStates.length, hasError = !1, error;
+		for (let i = 0; i < hooksLen; i++) if (pendingStates[i] !== 0) {
+			pendingStates[i] = 0;
+			try {
+				resetFunctions[i]();
+			} catch (e) {
+				hasError === !1 && (hasError = !0, error = e);
+			}
+		}
+		if (this.pendingCount = 0, this.lintFinishedCount = 0, this.sourceCode = null, hasError === !0 && ignoreErrors === !1) throw error;
+	}
+	/**
+	* Schedule a microtask to run `reset` functions.
+	*/
+	scheduleReset() {
+		queueMicrotask(this.resetMicrotask), this.resetIsScheduled = !0;
+	}
+	/**
+	* Function which is scheduled as the cleanup microtask.
+	* `scheduleReset` uses `resetMicrotask` which is this method bound to `this`.
+	*/
+	resetMicrotaskImpl() {
+		this.resetIsScheduled = !1, this.pendingCount !== 0 && this.reset(!0);
+	}
+};
+/**
+* Convert a rule.
+*
+* The `rule` object passed in is mutated in-place.
+*
+* @param rule - Rule to convert
+* @param afterHooksState - State of `after` hooks
+* @throws {Error} If `rule` is not an object
+*/
+function convertRule(rule, afterHooksState) {
+	if (typeof rule != "object" || !rule) throw Error("Rule must be an object");
+	if ("create" in rule) return;
+	let context = null, visitor, beforeHook, setupAfterHook;
+	rule.create = (eslintContext) => {
+		context === null && ({context, visitor, beforeHook, setupAfterHook} = createContextAndVisitor(rule, afterHooksState));
+		let eslintFileContext = Object.getPrototypeOf(eslintContext);
+		if (setupAfterHook !== null) {
+			let { sourceCode } = eslintFileContext;
+			afterHooksState.sourceCode !== sourceCode && (afterHooksState.sourceCode = sourceCode, afterHooksState.pendingCount !== 0 && afterHooksState.reset(!0));
+		}
+		return Object.defineProperties(context, {
+			id: { value: eslintContext.id },
+			options: { value: eslintContext.options },
+			report: { value: eslintContext.report }
+		}), Object.setPrototypeOf(context, eslintFileContext), beforeHook !== null && beforeHook() === !1 ? EMPTY_VISITOR : (setupAfterHook !== null && (setupAfterHook(eslintFileContext.sourceCode.ast), afterHooksState.resetIsScheduled === !1 && afterHooksState.scheduleReset()), visitor);
+	};
+}
+const FILE_CONTEXT = Object.freeze({
+	get filename() {
+		throw Error("Cannot access `context.filename` in `createOnce`");
+	},
+	getFilename() {
+		throw Error("Cannot call `context.getFilename` in `createOnce`");
+	},
+	get physicalFilename() {
+		throw Error("Cannot access `context.physicalFilename` in `createOnce`");
+	},
+	getPhysicalFilename() {
+		throw Error("Cannot call `context.getPhysicalFilename` in `createOnce`");
+	},
+	get cwd() {
+		throw Error("Cannot access `context.cwd` in `createOnce`");
+	},
+	getCwd() {
+		throw Error("Cannot call `context.getCwd` in `createOnce`");
+	},
+	get sourceCode() {
+		throw Error("Cannot access `context.sourceCode` in `createOnce`");
+	},
+	getSourceCode() {
+		throw Error("Cannot call `context.getSourceCode` in `createOnce`");
+	},
+	get languageOptions() {
+		throw Error("Cannot access `context.languageOptions` in `createOnce`");
+	},
+	get settings() {
+		throw Error("Cannot access `context.settings` in `createOnce`");
+	},
+	extend(extension) {
+		return Object.freeze(Object.assign(Object.create(this), extension));
+	},
+	get parserOptions() {
+		throw Error("Cannot access `context.parserOptions` in `createOnce`");
+	},
+	get parserPath() {
+		throw Error("Cannot access `context.parserPath` in `createOnce`");
+	}
+});
+/**
+* Call `createOnce` method of rule, and return `Context`, `Visitor`, and `beforeHook` (if any).
+*
+* @param rule - Rule with `createOnce` method
+* @param afterHooksState - State of `after` hooks
+* @returns Object with `context`, `visitor`, and `beforeHook` properties,
+*   and `setupAfterHook` function if visitor has an `after` hook
+*/
+function createContextAndVisitor(rule, afterHooksState) {
+	let { createOnce } = rule;
+	if (createOnce == null) throw Error("Rules must define either a `create` or `createOnce` method");
+	if (typeof createOnce != "function") throw Error("Rule `createOnce` property must be a function");
+	let context = Object.create(FILE_CONTEXT, {
+		id: {
+			value: null,
+			enumerable: !0,
+			configurable: !0
+		},
+		options: {
+			value: null,
+			enumerable: !0,
+			configurable: !0
+		},
+		report: {
+			value() {
+				throw Error("Cannot report errors in `createOnce`");
+			},
+			enumerable: !0,
+			configurable: !0
+		}
+	}), { before: beforeHook, after: afterHook, ...visitor } = createOnce.call(rule, context);
+	if (beforeHook === void 0) beforeHook = null;
+	else if (beforeHook !== null && typeof beforeHook != "function") throw Error("`before` property of visitor must be a function if defined");
+	let setupAfterHook = null;
+	if (afterHook != null) {
+		if (typeof afterHook != "function") throw Error("`after` property of visitor must be a function if defined");
+		let program = null, ruleIndex = afterHooksState.registerResetFunction(() => {
+			program = null, afterHook();
+		});
+		setupAfterHook = (ast) => {
+			program = ast, afterHooksState.pendingStates[ruleIndex] = 1, afterHooksState.pendingCount++;
+		};
+		let onCodePathEnd = visitor.onCodePathEnd;
+		visitor.onCodePathEnd = onCodePathEnd == null ? function(_codePath, node) {
+			node === program && afterHooksState.ruleFinished();
+		} : function(codePath, node) {
+			onCodePathEnd.call(this, codePath, node), node === program && afterHooksState.ruleFinished();
+		};
+	}
+	return {
+		context,
+		visitor,
+		beforeHook,
+		setupAfterHook
+	};
+}
+//#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/rules/no-conditional-empty-object-spread.ts
+function unwrapParentheses(node) {
+	let current = node;
+	while (current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
+function isEmptyObjectExpression$1(node) {
+	return node.type === "ObjectExpression" && node.properties.length === 0;
+}
+function isConditionalEmptyObjectSpread(node) {
+	const conditional = unwrapParentheses(node);
+	return conditional.type === "ConditionalExpression" && (isEmptyObjectExpression$1(conditional.consequent) || isEmptyObjectExpression$1(conditional.alternate));
+}
+/** Ban conditional empty-object spreads without changing their omission semantics. */
+const noConditionalEmptyObjectSpreadRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow object spreads that conditionally spread an empty object to omit fields." },
+		messages: { avoid: "This conditional spread hides property omission behind an empty object. Build the object in separate statements and add the property only when present." }
+	},
+	createOnce(context) {
+		return { SpreadElement(node) {
+			if (node.parent.type !== "ObjectExpression") return;
+			if (isConditionalEmptyObjectSpread(node.argument)) context.report({
+				node,
+				messageId: "avoid"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/shared/dictionary-types.ts
+const BUILT_INS = /* @__PURE__ */ new Set([
+	"Record",
+	"Readonly",
+	"Partial",
+	"Required",
+	"Pick",
+	"Omit",
+	"PropertyKey",
+	"NonNullable"
+]);
+const TRANSPARENT_WRAPPERS = /* @__PURE__ */ 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) {
+			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 === true && 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 !== void 0 && 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 = base.get(name);
+	if (substitution === void 0) 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 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 || 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";
+		return unsafeMembers.length > 0 && unsafeMembers.every((member) => member !== null) ? unsafeMembers[0] : 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(wrapped, environment, substitutions, resolvingAliases);
+	}
+	const substitution = substitutions.get(name);
+	if (substitution !== void 0) return isUnappliedReferenceTo(substitution, name) ? null : unsafeDirectValue(substitution, 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 ? [] : [{
+		type: unwrapped.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(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) {
+	const unsafeValue = unsafeDirectValue(valueType, environment, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+	return unsafeValue === null ? null : {
+		kind: "unsafe-dictionary",
+		unsafeValue
+	};
+}
+function classifyUnsafeDictionary(type, environment) {
+	for (const valueType of dictionaryValueTypes(type, environment, /* @__PURE__ */ new Map(), /* @__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) {
+	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 { 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 = aliasSubstitution(alias, unwrapped, /* @__PURE__ */ new Map());
+		return substitutions !== null && resolvesToDictionary(alias.typeAnnotation, environment, substitutions, /* @__PURE__ */ new Set([name])) ? { kind: "generic container" } : null;
+	}
+	const substitutions = aliasSubstitution(alias, unwrapped, /* @__PURE__ */ new Map());
+	if (substitutions === null) return null;
+	return classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, /* @__PURE__ */ new Set([name]));
+}
+function isBroadMappedKey(type, environment, substitutions) {
+	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));
+	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(substitution, environment, substitutions);
+	return name === "PropertyKey" && isBuiltIn(name, environment);
+}
+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 = substitutions.get(name);
+	if (substitution !== void 0) return isUnappliedReferenceTo(substitution, name) ? 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/rules/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 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 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) {
+	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 = (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(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, classifyWideningTarget(node.typeAnnotation, environment), "assertion");
+			},
+			TSTypeAssertion(node) {
+				if (environment === null || hasParentAssertion(node)) return;
+				reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion");
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-module-mocking.ts
+const moduleMockMethods = /* @__PURE__ */ new Set([
+	"doMock",
+	"mock",
+	"unstable_mockModule"
+]);
+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 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$1(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;
+	const method = callee.computed ? property.type === "Literal" && (property.value === "doMock" || property.value === "mock" || property.value === "unstable_mockModule") ? property.value : null : property.type === "Identifier" ? property.name : null;
+	return method !== null && moduleMockMethods.has(method);
+}
+/** Ban test framework module mocking in favor of real dependency seams. */
+const noModuleMockingRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { 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/shared/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 record = node;
+	for (const key of visitorKeys[node.type] ?? []) {
+		const value = record[key];
+		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);
+	}
+}
+/** 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 === "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/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.typeAnnotation ?? parameter.left.typeAnnotation;
+	return parameter.typeAnnotation;
+}
+function parameterName$1(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 aliases = /* @__PURE__ */ new Map();
+		const resolvesToObject = (type, shadowedAliases, visited = /* @__PURE__ */ new Set()) => {
+			if (type.type === "TSObjectKeyword") return true;
+			if (type.type === "TSParenthesizedType") return resolvesToObject(type.typeAnnotation, shadowedAliases, visited);
+			if (type.type === "TSUnionType") return type.types.some((member) => resolvesToObject(member, shadowedAliases, visited));
+			if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier" || type.typeArguments !== null && type.typeArguments !== void 0 && type.typeArguments.params.length > 0 || visited.has(type.typeName.name) || shadowedAliases.has(type.typeName.name)) return false;
+			const alias = aliases.get(type.typeName.name);
+			if (alias === void 0) return false;
+			const nextVisited = new Set(visited);
+			nextVisited.add(type.typeName.name);
+			return resolvesToObject(alias, shadowedAliases, nextVisited);
+		};
+		const checkParameters = (node) => {
+			const shadowedAliases = lexicalTypeParameterNames(node, context.sourceCode.visitorKeys);
+			for (const parameter of node.params) {
+				const annotation = parameterAnnotation$1(parameter);
+				if (annotation === null || annotation === void 0) continue;
+				if (!resolvesToObject(annotation.typeAnnotation, shadowedAliases)) continue;
+				context.report({
+					node: annotation.typeAnnotation,
+					messageId: "objectParameter",
+					data: { parameter: parameterName$1(parameter, context.sourceCode) }
+				});
+			}
+		};
+		return {
+			Program(node) {
+				aliases.clear();
+				for (const statement of node.body) {
+					const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+					if (declaration?.type === "TSTypeAliasDeclaration" && (declaration.typeParameters === null || declaration.typeParameters === void 0)) aliases.set(declaration.id.name, declaration.typeAnnotation);
+				}
+			},
+			ArrowFunctionExpression: checkParameters,
+			FunctionDeclaration: checkParameters,
+			FunctionExpression: checkParameters,
+			TSCallSignatureDeclaration: checkParameters,
+			TSConstructSignatureDeclaration: checkParameters,
+			TSConstructorType: checkParameters,
+			TSDeclareFunction: checkParameters,
+			TSEmptyBodyFunctionExpression: checkParameters,
+			TSFunctionType: checkParameters,
+			TSMethodSignature: checkParameters
+		};
+	}
+});
+//#endregion
+//#region src/shared/reflect-method.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;
+}
+function isGlobalReflect(sourceCode, expression) {
+	if (expression.type !== "Identifier" || expression.name !== "Reflect") return false;
+	if (sourceCode.isGlobalReference(expression)) return true;
+	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(sourceCode, callee, methodName) {
+	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(context.sourceCode, node.callee, "apply")) 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(context.sourceCode, node.callee, "get")) context.report({
+				node,
+				messageId: "reflectGet"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-runtime-typeof.ts
+function isRuntimeFunction(node) {
+	return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
+}
+function isInsideTypeGuard(node) {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (isRuntimeFunction(current)) return current.returnType?.typeAnnotation.type === "TSTypePredicate";
+		current = current.parent;
+	}
+	return false;
+}
+/** Disallow runtime typeof checks that narrow unparsed values instead of decoding them. */
+const noRuntimeTypeofRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow runtime typeof checks; external values must be decoded into meaningful types at their I/O boundary." },
+		messages: { runtimeTypeof: "A `typeof` check narrows a representation without establishing its contract. Parse input at its I/O boundary, then branch on the domain value." },
+		schema: [{
+			type: "object",
+			properties: { allowInTypeGuards: { type: "boolean" } },
+			additionalProperties: false
+		}],
+		defaultOptions: [{ allowInTypeGuards: false }]
+	},
+	createOnce(context) {
+		return { UnaryExpression(node) {
+			const option = context.options?.[0];
+			const allowInTypeGuards = typeof option === "object" && option !== null && !Array.isArray(option) && option.allowInTypeGuards === true;
+			if (node.operator === "typeof" && (!allowInTypeGuards || !isInsideTypeGuard(node))) context.report({
+				node,
+				messageId: "runtimeTypeof"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-shape-in-symbol-names.ts
+const FORBIDDEN_SYMBOL_NAME = "shape";
+function containsForbiddenSymbolName(name) {
+	return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
+}
+/** Ban the case-insensitive substring "shape" in every JavaScript and TypeScript symbol name. */
+const noForbiddenTermInSymbolNamesRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow the case-insensitive substring \"shape\" in JavaScript, TypeScript, private, and JSX symbol names." },
+		messages: { forbiddenSymbolName: "Rename symbol \"{{name}}\" for its domain role; \"shape\" describes structure rather than ownership." }
+	},
+	createOnce(context) {
+		const reportForbiddenSymbolName = (node) => {
+			if (!containsForbiddenSymbolName(node.name)) return;
+			context.report({
+				node,
+				messageId: "forbiddenSymbolName",
+				data: { name: node.name }
+			});
+		};
+		return {
+			Identifier: reportForbiddenSymbolName,
+			PrivateIdentifier: reportForbiddenSymbolName,
+			JSXIdentifier: reportForbiddenSymbolName
+		};
+	}
+});
+//#endregion
+//#region src/rules/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;
+}
+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 explicitly named error-cause enrichment. */
+const noUnknownParametersRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow explicitly unknown function parameters except `cause`; decode unknown input at its I/O boundary instead." },
+		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) => {
+			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") 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/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 === 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: { 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 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")) {
+				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();
+				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/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 === 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: { 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);
+			const name = referencedAliasName(type);
+			if (name === null || visited.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/rules/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) {
+	if (isPlainAliasConsumerUse(node, environment)) return false;
+	if (classifyUnsafeDictionary(node, environment) === null) return false;
+	let current = node.parent;
+	while (current !== null && 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 = null;
+		const report = (node, value) => {
+			context.report({
+				node,
+				messageId: "unsafeDictionary",
+				data: { value }
+			});
+		};
+		const reportIfUnsafe = (node) => {
+			if (environment === null || !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 (environment === null || node.typeAnnotation === null || 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 = /* @__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) {
+	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.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 === "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: { 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/rules/require-safety-comment-for-type-assertion.ts
+const commentOwnerKinds = /* @__PURE__ */ new Set([
+	"ExpressionStatement",
+	"PropertyDefinition",
+	"ReturnStatement",
+	"ThrowStatement",
+	"VariableDeclaration"
+]);
+function isConstAssertion(node) {
+	return node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const";
+}
+function hasSafetyComment(sourceCode, node) {
+	let current = node;
+	while (true) {
+		if (sourceCode.getCommentsBefore(current).some((comment) => comment.end <= node.start && /\bSAFETY\s*:/u.test(comment.value))) return true;
+		if (commentOwnerKinds.has(current.type) || current.parent.type === "Program") return false;
+		current = current.parent;
+	}
+}
+//#endregion
+//#region src/index.ts
+/** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */
+const antiSlopPlugin = eslintCompatPlugin({
+	meta: { name: "anti-slop" },
+	rules: {
+		"no-chained-type-assertions": noChainedTypeAssertionsRule,
+		"no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
+		"no-known-value-widening": noKnownValueWideningRule,
+		"no-module-mocking": noModuleMockingRule,
+		"no-object-parameters": noObjectParametersRule,
+		"no-reflect-apply": noReflectApplyRule,
+		"no-reflect-get": noReflectGetRule,
+		"no-runtime-typeof": noRuntimeTypeofRule,
+		"no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
+		"no-shape-in-symbol-names": noForbiddenTermInSymbolNamesRule,
+		"no-unknown-parameters": noUnknownParametersRule,
+		"no-unknown-returns": noUnknownReturnsRule,
+		"no-unknown-type-aliases": noUnknownTypeAliasesRule,
+		"no-widen-then-assert": noWidenThenAssertRule,
+		"require-safety-comment-for-type-assertion": defineRule({
+			meta: {
+				type: "problem",
+				docs: { description: "Require a nearby SAFETY comment for every 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) || hasSafetyComment(context.sourceCode, node)) return;
+					context.report({
+						node,
+						messageId: "missingSafetyComment"
+					});
+				};
+				return {
+					TSAsExpression: checkAssertion,
+					TSTypeAssertion: checkAssertion
+				};
+			}
+		})
+	}
+});
+//#endregion
+export { antiSlopPlugin as default };