oxlint-plugin-effect 0.6.0 → 0.8.0

package/dist/rules/no-known-value-widening.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-known-value-widening.d.ts
+/** Detect sound syntactic cases where a known value is explicitly widened and loses evidence. */
+declare const noKnownValueWidening: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noKnownValueWidening };

package/dist/rules/no-known-value-widening.js

@@ -0,0 +1,144 @@
+import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { classifyWideningTarget, createTypeEnvironment, isKnownEvidenceExpression } from "./_anti-slop-dictionary-types.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-known-value-widening.ts
+/**
+* Ported from dmmulroy/anti-slop at
+* b5d2288db1f00469a1d5f2e3b0e265e5a5676fd0.
+*/
+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(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(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(sourceCode, unwrapped);
+	if (variable === null || visitedVariables.has(variable)) return false;
+	const declarator = variableDeclarator(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 noKnownValueWidening = define({
+	name: "no-known-value-widening",
+	meta: meta({
+		type: "problem",
+		description: "Disallow syntactically established values from flowing into explicitly broad or anonymous target types that discard useful evidence.",
+		messages: { widening: "The known initializer supplying {{subject}} carries established type evidence, but the explicit {{target}} target type discards it. Preserve inference, use `satisfies`, or introduce/use a named owner contract; parse genuinely external data once at its boundary." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		let environment = null;
+		const reportFlow = (expression, destination, subject, options = {}) => {
+			if (destination === null) return Effect.void;
+			if (options.allowEmptyDictionaryAccumulator === true && isDictionaryAccumulatorTarget(destination) && isEmptyObjectExpression(expression)) return Effect.void;
+			if (!hasKnownEvidence(context.sourceCode, expression)) return Effect.void;
+			return context.report(fromId({
+				node: expression,
+				messageId: "widening",
+				data: {
+					subject,
+					target: destination.kind
+				}
+			}));
+		};
+		const targetFromAnnotation = (annotation) => environment === null ? null : annotationTarget(annotation, environment);
+		return {
+			Program: (node) => {
+				environment = createTypeEnvironment(node);
+				return Effect.void;
+			},
+			VariableDeclarator: (node) => {
+				if (node.init === null || node.id.type !== "Identifier") return Effect.void;
+				return reportFlow(node.init, targetFromAnnotation(node.id.typeAnnotation), `binding \`${node.id.name}\``, { allowEmptyDictionaryAccumulator: true });
+			},
+			PropertyDefinition: (node) => {
+				if (node.value === null) return Effect.void;
+				return reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+			},
+			AccessorProperty: (node) => {
+				if (node.value === null) return Effect.void;
+				return reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+			},
+			AssignmentExpression: (node) => {
+				if (node.operator !== "=" || node.left.type !== "Identifier") return Effect.void;
+				const variable = resolveVariable(context.sourceCode, node.left);
+				if (variable === null) return Effect.void;
+				const declarator = variableDeclarator(variable);
+				if (declarator === null || declarator.id.type !== "Identifier") return Effect.void;
+				return reportFlow(node.right, targetFromAnnotation(declarator.id.typeAnnotation), `binding \`${declarator.id.name}\``);
+			},
+			ReturnStatement: (node) => {
+				if (node.argument === null) return Effect.void;
+				const owner = enclosingFunction(node);
+				return reportFlow(node.argument, targetFromAnnotation(owner?.returnType), `return value of \`${functionName(context.sourceCode, owner)}\``);
+			},
+			ArrowFunctionExpression: (node) => {
+				if (node.body.type === "BlockStatement") return Effect.void;
+				return reportFlow(node.body, targetFromAnnotation(node.returnType), `return value of \`${functionName(context.sourceCode, node)}\``);
+			},
+			TSAsExpression: (node) => environment === null || hasParentAssertion(node) ? Effect.void : reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion"),
+			TSTypeAssertion: (node) => environment === null || hasParentAssertion(node) ? Effect.void : reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion")
+		};
+	}
+});
+//#endregion
+export { noKnownValueWidening };

package/dist/rules/no-nullish.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-nullish.d.ts
+declare const noNullish: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noNullish };

package/dist/rules/no-nullish.js

@@ -0,0 +1,50 @@
+import { narrow } from "../vendor/effect-oxlint/AST.js";
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import { isGlobalReference } from "../vendor/effect-oxlint/SourceCode.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-nullish.ts
+const message = "Avoid null and undefined. Use Option for presence or absence. Use a domain enum when the state has more than two cases.";
+const noNullish = define({
+	name: "no-nullish",
+	meta: meta({
+		type: "problem",
+		description: "Use Option or a domain enum instead of null and undefined."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const report = (node) => ctx.report(make({
+			node,
+			message
+		}));
+		return {
+			Identifier: (node) => Option.match(narrow(node, "Identifier"), {
+				onNone: () => Effect.void,
+				onSome: (identifier) => {
+					if (identifier.name !== "undefined") return Effect.void;
+					return isGlobalReference(identifier).pipe(Effect.flatMap((isGlobal) => {
+						if (!isGlobal) return Effect.void;
+						return report(identifier);
+					}));
+				}
+			}),
+			Literal: (node) => Option.match(narrow(node, "Literal"), {
+				onNone: () => Effect.void,
+				onSome: (literal) => literal.value === null && !("regex" in literal) ? report(literal) : Effect.void
+			}),
+			TSNullKeyword: (node) => Option.match(narrow(node, "TSNullKeyword"), {
+				onNone: () => Effect.void,
+				onSome: report
+			}),
+			TSUndefinedKeyword: (node) => Option.match(narrow(node, "TSUndefinedKeyword"), {
+				onNone: () => Effect.void,
+				onSome: report
+			})
+		};
+	}
+});
+//#endregion
+export { noNullish };

package/dist/rules/no-object-parameters.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-object-parameters.d.ts
+/** Ban the broad object type on function inputs, including local aliases to object. */
+declare const noObjectParameters: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noObjectParameters };

package/dist/rules/no-object-parameters.js

@@ -0,0 +1,70 @@
+import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-object-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, 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 noObjectParameters = define({
+	name: "no-object-parameters",
+	meta: meta({
+		type: "problem",
+		description: "Disallow object function parameters; inputs must use an owner-provided type and be parsed at their boundary.",
+		messages: { objectParameter: "Parameter `{{parameter}}` accepts the broad `object` type. Use the expected owner type or decode the external input at its boundary." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		const aliases = /* @__PURE__ */ new Map();
+		const resolvesToObject = (type, visited = /* @__PURE__ */ new Set()) => {
+			if (type.type === "TSObjectKeyword") return true;
+			if (type.type === "TSParenthesizedType") return resolvesToObject(type.typeAnnotation, visited);
+			if (type.type === "TSUnionType") return type.types.some((member) => resolvesToObject(member, 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)) 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, nextVisited);
+		};
+		const checkParameters = (node) => Effect.forEach(node.params, (parameter) => {
+			const annotation = parameterAnnotation(parameter);
+			if (annotation === null || annotation === void 0) return Effect.void;
+			if (!resolvesToObject(annotation.typeAnnotation)) return Effect.void;
+			return context.report(fromId({
+				node: annotation.typeAnnotation,
+				messageId: "objectParameter",
+				data: { parameter: parameterName(parameter, context.sourceCode) }
+			}));
+		}, { discard: true });
+		return {
+			Program: (node) => {
+				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);
+				}
+				return Effect.void;
+			},
+			ArrowFunctionExpression: checkParameters,
+			FunctionDeclaration: checkParameters,
+			FunctionExpression: checkParameters,
+			TSCallSignatureDeclaration: checkParameters,
+			TSConstructSignatureDeclaration: checkParameters,
+			TSConstructorType: checkParameters,
+			TSDeclareFunction: checkParameters,
+			TSEmptyBodyFunctionExpression: checkParameters,
+			TSFunctionType: checkParameters,
+			TSMethodSignature: checkParameters
+		};
+	}
+});
+//#endregion
+export { noObjectParameters };

package/dist/rules/no-runtime-typeof.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-runtime-typeof.d.ts
+/** Disallow runtime typeof checks that narrow unparsed values instead of decoding them. */
+declare const noRuntimeTypeof: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noRuntimeTypeof };

package/dist/rules/no-runtime-typeof.js

@@ -0,0 +1,24 @@
+import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-runtime-typeof.ts
+/** Disallow runtime typeof checks that narrow unparsed values instead of decoding them. */
+const noRuntimeTypeof = define({
+	name: "no-runtime-typeof",
+	meta: meta({
+		type: "problem",
+		description: "Disallow runtime typeof checks; external values must be decoded into meaningful types at their I/O boundary.",
+		messages: { runtimeTypeof: "A runtime `typeof` check only narrows an unparsed representation; it does not establish the expected contract. Parse the value into a strongly typed domain type at the earliest possible point, as close as possible to the I/O boundary where the data originated." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		return { UnaryExpression: (node) => node.operator === "typeof" ? context.report(fromId({
+			node,
+			messageId: "runtimeTypeof"
+		})) : Effect.void };
+	}
+});
+//#endregion
+export { noRuntimeTypeof };

package/dist/rules/no-shape-in-symbol-names.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-shape-in-symbol-names.d.ts
+/** Ban the case-insensitive substring "shape" in every JavaScript and TypeScript symbol name. */
+declare const noShapeInSymbolNames: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noShapeInSymbolNames };

package/dist/rules/no-shape-in-symbol-names.js

@@ -0,0 +1,34 @@
+import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-shape-in-symbol-names.ts
+const forbiddenSymbolName = "shape";
+function containsForbiddenSymbolName(name) {
+	return name.toLowerCase().includes(forbiddenSymbolName);
+}
+/** Ban the case-insensitive substring "shape" in every JavaScript and TypeScript symbol name. */
+const noShapeInSymbolNames = define({
+	name: "no-shape-in-symbol-names",
+	meta: meta({
+		type: "problem",
+		description: "Disallow the case-insensitive substring \"shape\" in JavaScript, TypeScript, private, and JSX symbol names.",
+		messages: { forbiddenSymbolName: "Do not use the case-insensitive substring \"shape\" in symbol names (found \"{{name}}\")." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		const reportForbiddenSymbolName = (node) => containsForbiddenSymbolName(node.name) ? context.report(fromId({
+			node,
+			messageId: "forbiddenSymbolName",
+			data: { name: node.name }
+		})) : Effect.void;
+		return {
+			Identifier: reportForbiddenSymbolName,
+			PrivateIdentifier: reportForbiddenSymbolName,
+			JSXIdentifier: reportForbiddenSymbolName
+		};
+	}
+});
+//#endregion
+export { noShapeInSymbolNames };

package/dist/rules/no-unknown-parameters.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-unknown-parameters.d.ts
+/** Disallow unknown inputs except explicitly named error-cause enrichment. */
+declare const noUnknownParameters: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noUnknownParameters };

package/dist/rules/no-unknown-parameters.js

@@ -0,0 +1,55 @@
+import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Effect from "effect/Effect";
+//#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 noUnknownParameters = define({
+	name: "no-unknown-parameters",
+	meta: meta({
+		type: "problem",
+		description: "Disallow explicitly unknown function parameters except `cause`; decode unknown input at its I/O boundary instead.",
+		messages: { unknownParameter: "Parameter `{{parameter}}` accepts `unknown` without establishing its contract. Define the expected schema or parser so the value becomes a strongly typed domain type at the earliest possible point, as close as possible to the I/O boundary where the data originated." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		const checkParameters = (node) => Effect.forEach(node.params, (parameter) => {
+			const annotation = parameterAnnotation(parameter);
+			if (annotation?.typeAnnotation.type !== "TSUnknownKeyword") return Effect.void;
+			const name = parameterName(parameter, context.sourceCode.getText(parameter));
+			if (name === "cause") return Effect.void;
+			return context.report(fromId({
+				node: annotation.typeAnnotation,
+				messageId: "unknownParameter",
+				data: { parameter: name }
+			}));
+		}, { discard: true });
+		return {
+			ArrowFunctionExpression: checkParameters,
+			FunctionDeclaration: checkParameters,
+			FunctionExpression: checkParameters,
+			TSCallSignatureDeclaration: checkParameters,
+			TSConstructSignatureDeclaration: checkParameters,
+			TSConstructorType: checkParameters,
+			TSDeclareFunction: checkParameters,
+			TSEmptyBodyFunctionExpression: checkParameters,
+			TSFunctionType: checkParameters,
+			TSMethodSignature: checkParameters
+		};
+	}
+});
+//#endregion
+export { noUnknownParameters };

package/dist/rules/no-unknown-type-aliases.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-unknown-type-aliases.d.ts
+/** Ban named aliases that merely conceal TypeScript's unknown top type. */
+declare const noUnknownTypeAliases: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noUnknownTypeAliases };

package/dist/rules/no-unknown-type-aliases.js

@@ -0,0 +1,48 @@
+import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Effect from "effect/Effect";
+//#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 noUnknownTypeAliases = define({
+	name: "no-unknown-type-aliases",
+	meta: meta({
+		type: "problem",
+		description: "Disallow type aliases whose resolved type is unknown; unknown must remain visible at an allowed boundary.",
+		messages: { unknownAlias: "Type alias `{{alias}}` only renames `unknown`. Keep `unknown` explicit on an allowed `cause` field or replace it with the parsed owner type." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		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) => {
+			for (const statement of node.body) {
+				const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+				if (declaration?.type === "TSTypeAliasDeclaration") aliases.set(declaration.id.name, declaration);
+			}
+			return Effect.forEach(aliases.values(), (alias) => resolvesToUnknown(alias.typeAnnotation, new Set([alias.id.name])) ? context.report(fromId({
+				node: alias.id,
+				messageId: "unknownAlias",
+				data: { alias: alias.id.name }
+			})) : Effect.void, { discard: true });
+		} };
+	}
+});
+//#endregion
+export { noUnknownTypeAliases };

package/dist/rules/no-unsafe-dictionary-type.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-unsafe-dictionary-type.d.ts
+/** Disallow object-dictionary contracts whose direct value type is an unsafe escape hatch. */
+declare const noUnsafeDictionaryType: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noUnsafeDictionaryType };

package/dist/rules/no-unsafe-dictionary-type.js

@@ -0,0 +1,75 @@
+import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { classifyUnsafeDictionary, classifyUnsafeDictionaryValue, createTypeEnvironment } from "./_anti-slop-dictionary-types.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-unsafe-dictionary-type.ts
+function isTypeNode(node) {
+	return node.type.startsWith("TS") && node.type !== "TSTypeAnnotation";
+}
+function typeReferenceName(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(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 noUnsafeDictionaryType = define({
+	name: "no-unsafe-dictionary-type",
+	meta: meta({
+		type: "problem",
+		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 object dictionary's direct value type is an unsafe {{value}} escape hatch. Replace it with a concrete owner/schema-derived value type and parse external data at its boundary." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		let environment = null;
+		const report = (node, value) => context.report(fromId({
+			node,
+			messageId: "unsafeDictionary",
+			data: { value }
+		}));
+		const reportIfUnsafe = (node) => {
+			if (environment === null || !shouldReportType(node, environment)) return Effect.void;
+			const unsafe = classifyUnsafeDictionary(node, environment);
+			return unsafe === null ? Effect.void : report(node, unsafe.unsafeValue);
+		};
+		return {
+			Program: (node) => {
+				environment = createTypeEnvironment(node);
+				return Effect.void;
+			},
+			TSTypeReference: reportIfUnsafe,
+			TSTypeLiteral: reportIfUnsafe,
+			TSMappedType: reportIfUnsafe,
+			TSIndexSignature: (node) => {
+				if (environment === null || node.typeAnnotation === null || node.parent?.type === "TSTypeLiteral") return Effect.void;
+				const unsafe = classifyUnsafeDictionaryValue(node.typeAnnotation.typeAnnotation, environment);
+				return unsafe === null ? Effect.void : report(node, unsafe.unsafeValue);
+			}
+		};
+	}
+});
+//#endregion
+export { noUnsafeDictionaryType };

package/dist/rules/no-widen-then-assert.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-widen-then-assert.d.ts
+/** Detect immutable local bindings that erase a known type and are later asserted back to a narrower type. */
+declare const noWidenThenAssert: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noWidenThenAssert };