oxlint-plugin-effect 0.13.0 → 0.14.0

package/README.md

@@ -34,10 +34,13 @@ If the project uses JSON configuration, copy the exported rule map into `rules`;
 | `effect/noThrowStatement`              | Bans every throw statement                                                                |
 | `effect/noNewPromise`                  | Bans new Promise, Promise calls, and Promise static APIs                                  |
 | `effect/noNewError`                    | Allows native Error values only as direct arguments to Effect.die, Cause.die, or Exit.die |
-| `effect/noNullish`                     | Bans null and undefined; permits `Object.create(null)` for prototype-free dictionaries   |
+| `effect/noNullish`                     | Bans null and undefined; permits `Object.create(null)` for prototype-free dictionaries    |
 | `effect/noModuleMocks`                 | Bans Vitest and Jest module mocks and method spies; use Effect service test layers        |
 | `effect/noTernary`                     | Bans conditional expressions while allowing ordinary if statements                        |
 | `effect/noManagedRuntimeInEffect`      | Keeps ManagedRuntime construction at non-Effect host boundaries                           |
+| `effect/noModuleLevelMutableState`     | Bans module-level `let` and `var` outside tests; hold shared state in a Layer-owned `Ref` |
+| `effect/noEagerAcquire`                | Bans `acquireRelease` acquires that build or capture the resource before acquire runs     |
+| `effect/noEffectRunInTests`            | Bans `Effect.run*` and `ManagedRuntime.make` in tests; use `it.effect` or `it.layer`      |
 | `effect/noInlineProvide`               | Keeps dependency provisioning at explicit composition boundaries                          |
 | `effect/noNestedEffectGen`             | Flattens directly yielded nested generators                                               |
 | `effect/noPerCallCacheConstruction`    | Constructs shared caches once in their owning layer                                       |
@@ -55,26 +58,34 @@ If the project uses JSON configuration, copy the exported rule map into `rules`;
 | `effect/preferPredicateIsTagged`       | Replaces combined `_tag` comparisons with a named `Predicate` refinement                  |
 | `effect/preferServiceOf`               | Checks inline Layer implementations through `Service.of`                                  |
 | `effect/requireNamedEffectFn`          | Requires stable names for `Effect.fn` operations                                          |
+| `effect/requireSuppressionReason`      | Requires lint, Effect, and TS suppressions to name their target and give a `--` reason    |
 | `effect/noGlobals`                     | Bans ambient capabilities with direct Effect replacements; allows `process.std*.isTTY`    |
 | `effect/noNodeBuiltinImport`           | Bans fully replaced Node modules and replaced operations from partial modules             |
 
+`effect/requireSuppressionReason` also rejects `@effect-diagnostics effect/name:off`: @effect/tsgo ignores the `effect/` prefix, so write the bare rule name. A blanket directive that covers its own line, such as a bare `// oxlint-disable-line` or a file-leading `/* eslint-disable */`, suppresses this rule's report too; oxlint applies the directive before the rule can report it.
+
 ## Anti-Slop Rules
 
 The recommended preset also includes these rules from
 [`dmmulroy/anti-slop`](https://github.com/dmmulroy/anti-slop):
 
-| Rule                                    | Contract                                                           |
-| --------------------------------------- | ------------------------------------------------------------------ |
-| `effect/noChainedTypeAssertions`        | Bans nested type assertions that invent type evidence              |
-| `effect/noConditionalEmptyObjectSpread` | Bans conditional spreads that use an empty object to omit fields   |
-| `effect/noKnownValueWidening`           | Bans broad target types that discard known value evidence          |
-| `effect/noObjectParameters`             | Bans the broad `object` type on function inputs                    |
-| `effect/noRuntimeTypeof`                | Requires boundary parsing instead of runtime `typeof` narrowing    |
-| `effect/noShapeInSymbolNames`           | Bans `shape` in symbol names                                       |
-| `effect/noUnknownParameters`            | Bans `unknown` inputs except an input named `cause`                |
-| `effect/noUnknownTypeAliases`           | Bans aliases that only hide `unknown`                              |
-| `effect/noUnsafeDictionaryType`         | Bans dictionaries with unsafe broad value types                    |
-| `effect/noWidenThenAssert`              | Bans local flows that widen known values and then assert them back |
+| Rule                                    | Contract                                                                         |
+| --------------------------------------- | -------------------------------------------------------------------------------- |
+| `effect/noArrayFilterMap`               | Bans adjacent array `filter`/`map` passes over a known array                     |
+| `effect/noChainedTypeAssertions`        | Bans nested type assertions that invent type evidence                            |
+| `effect/noConditionalEmptyObjectSpread` | Bans conditional spreads that use an empty object to omit fields                 |
+| `effect/noKnownValueWidening`           | Bans broad target types that discard known value evidence                        |
+| `effect/noObjectParameters`             | Bans the broad `object` type on function inputs                                  |
+| `effect/noReduceAccumulatorCopy`        | Bans copying a reducer accumulator on every iteration                            |
+| `effect/noReflectApply`                 | Bans `Reflect.apply`; call typed functions directly                              |
+| `effect/noReflectGet`                   | Bans `Reflect.get`; use typed property access                                    |
+| `effect/noRuntimeTypeof`                | Requires boundary parsing instead of `typeof` narrowing; allows existence probes |
+| `effect/noShapeInSymbolNames`           | Bans `shape` in symbol names                                                     |
+| `effect/noUnknownParameters`            | Bans `unknown` inputs except `cause`, type guards, and rejection reasons         |
+| `effect/noUnknownReturns`               | Bans return contracts of `unknown` or `Promise<unknown>`                         |
+| `effect/noUnknownTypeAliases`           | Bans aliases that only hide `unknown`                                            |
+| `effect/noUnsafeDictionaryType`         | Bans dictionaries with unsafe broad value types                                  |
+| `effect/noWidenThenAssert`              | Bans local flows that widen known values and then assert them back               |
 
 See `THIRD_PARTY_NOTICES.md` for the source revision and license.
 

package/THIRD_PARTY_NOTICES.md

@@ -1,8 +1,10 @@
 # Third-Party Notices
 
 The anti-slop rules include code derived from
-[`dmmulroy/anti-slop`](https://github.com/dmmulroy/anti-slop) at commit
-`b5d2288db1f00469a1d5f2e3b0e265e5a5676fd0`.
+[`dmmulroy/anti-slop`](https://github.com/dmmulroy/anti-slop), synced to commit
+`c44ef22ca116d0ba62a3ff663a0bd13a3f3fa40b`. The rejection-handler exemption in
+`noUnknownParameters` comes from the vendored copy in
+[`joelhooks/rat-stack`](https://github.com/joelhooks/rat-stack).
 
 MIT License
 

package/dist/presets/recommended.d.ts

@@ -14,17 +14,21 @@ declare const recommended: {
   readonly "effect/maxHalsteadDifficulty": readonly ["error", {
     readonly max: 79;
   }];
+  readonly "effect/noArrayFilterMap": "error";
   readonly "effect/noAs": "error";
   readonly "effect/noAsyncFunction": "error";
   readonly "effect/noChainedTypeAssertions": "error";
   readonly "effect/noConditionalEmptyObjectSpread": "error";
   readonly "effect/noDynamicImports": "error";
+  readonly "effect/noEagerAcquire": "error";
   readonly "effect/noEffectBind": "error";
   readonly "effect/noEffectDo": "error";
+  readonly "effect/noEffectRunInTests": "error";
   readonly "effect/noGlobals": "error";
   readonly "effect/noInlineProvide": "error";
   readonly "effect/noKnownValueWidening": "error";
   readonly "effect/noManagedRuntimeInEffect": "error";
+  readonly "effect/noModuleLevelMutableState": "error";
   readonly "effect/noModuleMocks": "error";
   readonly "effect/noNestedEffectGen": "error";
   readonly "effect/noNewError": "error";
@@ -33,6 +37,9 @@ declare const recommended: {
   readonly "effect/noNullish": "error";
   readonly "effect/noObjectParameters": "error";
   readonly "effect/noPerCallCacheConstruction": "error";
+  readonly "effect/noReduceAccumulatorCopy": "error";
+  readonly "effect/noReflectApply": "error";
+  readonly "effect/noReflectGet": "error";
   readonly "effect/noRunCollectOnUnboundedStream": "error";
   readonly "effect/noRuntimeTypeof": "error";
   readonly "effect/noSequentialEffectAll": "error";
@@ -45,6 +52,7 @@ declare const recommended: {
   readonly "effect/noUnboundedConcurrency": "error";
   readonly "effect/noUnboundedRetry": "error";
   readonly "effect/noUnknownParameters": "error";
+  readonly "effect/noUnknownReturns": "error";
   readonly "effect/noUnknownTypeAliases": "error";
   readonly "effect/noUnsafeDictionaryType": "error";
   readonly "effect/noWidenThenAssert": "error";
@@ -54,6 +62,7 @@ declare const recommended: {
   readonly "effect/preferPredicateIsTagged": "error";
   readonly "effect/preferServiceOf": "error";
   readonly "effect/requireNamedEffectFn": "error";
+  readonly "effect/requireSuppressionReason": "error";
 };
 //#endregion
 export { recommended };

package/dist/presets/recommended.js

@@ -8,17 +8,21 @@ const recommended = {
 	complexity: ["error", { max: 21 }],
 	"effect/maxCognitiveComplexity": ["error", { max: 21 }],
 	"effect/maxHalsteadDifficulty": ["error", { max: 79 }],
+	"effect/noArrayFilterMap": "error",
 	"effect/noAs": "error",
 	"effect/noAsyncFunction": "error",
 	"effect/noChainedTypeAssertions": "error",
 	"effect/noConditionalEmptyObjectSpread": "error",
 	"effect/noDynamicImports": "error",
+	"effect/noEagerAcquire": "error",
 	"effect/noEffectBind": "error",
 	"effect/noEffectDo": "error",
+	"effect/noEffectRunInTests": "error",
 	"effect/noGlobals": "error",
 	"effect/noInlineProvide": "error",
 	"effect/noKnownValueWidening": "error",
 	"effect/noManagedRuntimeInEffect": "error",
+	"effect/noModuleLevelMutableState": "error",
 	"effect/noModuleMocks": "error",
 	"effect/noNestedEffectGen": "error",
 	"effect/noNewError": "error",
@@ -27,6 +31,9 @@ const recommended = {
 	"effect/noNullish": "error",
 	"effect/noObjectParameters": "error",
 	"effect/noPerCallCacheConstruction": "error",
+	"effect/noReduceAccumulatorCopy": "error",
+	"effect/noReflectApply": "error",
+	"effect/noReflectGet": "error",
 	"effect/noRunCollectOnUnboundedStream": "error",
 	"effect/noRuntimeTypeof": "error",
 	"effect/noSequentialEffectAll": "error",
@@ -39,6 +46,7 @@ const recommended = {
 	"effect/noUnboundedConcurrency": "error",
 	"effect/noUnboundedRetry": "error",
 	"effect/noUnknownParameters": "error",
+	"effect/noUnknownReturns": "error",
 	"effect/noUnknownTypeAliases": "error",
 	"effect/noUnsafeDictionaryType": "error",
 	"effect/noWidenThenAssert": "error",
@@ -47,7 +55,8 @@ const recommended = {
 	"effect/preferMatchTagsExhaustive": "error",
 	"effect/preferPredicateIsTagged": "error",
 	"effect/preferServiceOf": "error",
-	"effect/requireNamedEffectFn": "error"
+	"effect/requireNamedEffectFn": "error",
+	"effect/requireSuppressionReason": "error"
 };
 //#endregion
 export { recommended };

package/dist/rules/_anti-slop-array-method.js

@@ -0,0 +1,70 @@
+//#region src/rules/_anti-slop-array-method.ts
+/** Unwrap syntax-only wrappers when inspecting array methods and accumulator references. */
+function unwrapArrayExpression(node) {
+	while (node.type === "ParenthesizedExpression" || node.type === "ChainExpression" || node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "TSSatisfiesExpression") node = node.expression;
+	return node;
+}
+/** Resolve a local binding by scope, not by identifier spelling. */
+function resolveArrayBinding(sourceCode, node) {
+	node = unwrapArrayExpression(node);
+	if (node.type !== "Identifier") return null;
+	let scope = sourceCode.getScope(node);
+	while (scope !== null) {
+		const variable = scope.set.get(node.name);
+		if (variable !== void 0) return variable;
+		scope = scope.upper;
+	}
+	return null;
+}
+/** Read static method names, including computed string literals, without evaluating expressions. */
+function arrayMethodTarget(node) {
+	node = unwrapArrayExpression(node);
+	if (node.type !== "MemberExpression") return null;
+	const property = node.property;
+	if (!node.computed && property.type === "Identifier") return {
+		name: property.name,
+		object: node.object
+	};
+	if (node.computed && property.type === "Literal" && typeof property.value === "string") return {
+		name: property.value,
+		object: node.object
+	};
+	return null;
+}
+function isArrayAnnotation(type) {
+	if (type.type === "TSArrayType" || type.type === "TSTupleType") return true;
+	if (type.type === "TSParenthesizedType") return isArrayAnnotation(type.typeAnnotation);
+	if (type.type === "TSTypeOperator" && type.operator === "readonly") return isArrayAnnotation(type.typeAnnotation);
+	return type.type === "TSTypeReference" && type.typeName.type === "Identifier" && (type.typeName.name === "Array" || type.typeName.name === "ReadonlyArray");
+}
+/** Recognize local array evidence; unknown receivers and iterator pipelines are deliberately excluded. */
+function isKnownArrayExpression(sourceCode, node, visited = /* @__PURE__ */ new Set()) {
+	node = unwrapArrayExpression(node);
+	if (node.type === "ArrayExpression") return true;
+	if (node.type === "CallExpression") {
+		const method = arrayMethodTarget(node.callee);
+		return method !== null && [
+			"map",
+			"filter",
+			"flatMap",
+			"slice",
+			"concat",
+			"toSorted",
+			"toReversed",
+			"toSpliced"
+		].includes(method.name) && isKnownArrayExpression(sourceCode, method.object, visited);
+	}
+	if (node.type !== "Identifier") return false;
+	const variable = resolveArrayBinding(sourceCode, node);
+	if (variable === null || visited.has(variable)) return false;
+	visited.add(variable);
+	if (variable.references.some((reference) => reference.isWrite() && !reference.init)) return false;
+	for (const identifier of variable.identifiers) {
+		const annotation = identifier.typeAnnotation?.typeAnnotation;
+		if (annotation !== void 0) return isArrayAnnotation(annotation);
+	}
+	for (const definition of variable.defs) if (definition.type === "Variable" && definition.node.type === "VariableDeclarator" && definition.node.id.type === "Identifier" && definition.node.init !== null && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const") return isKnownArrayExpression(sourceCode, definition.node.init, visited);
+	return false;
+}
+//#endregion
+export { arrayMethodTarget, isKnownArrayExpression, resolveArrayBinding, unwrapArrayExpression };

package/dist/rules/_anti-slop-dictionary-types.js

@@ -1,3 +1,4 @@
+import { createTypeAliasEnvironment, hasVisibleTypeBinding, visibleTypeAlias } from "./_anti-slop-type-alias-resolution.js";
 //#region src/rules/_anti-slop-dictionary-types.ts
 const BUILT_INS = new Set([
 	"Record",
@@ -18,48 +19,25 @@ const TRANSPARENT_WRAPPERS = new Set([
 function declaredStatement(statement) {
 	return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration ?? null : statement;
 }
-function createTypeEnvironment(program) {
-	const aliases = /* @__PURE__ */ new Map();
+function createTypeEnvironment(program, visitorKeys) {
 	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);
-		}
+		if (declaration?.type !== "TSInterfaceDeclaration") continue;
+		const declarations = interfaces.get(declaration.id.name) ?? [];
+		declarations.push(declaration);
+		interfaces.set(declaration.id.name, declarations);
 	}
 	return {
-		aliases,
 		interfaces,
-		shadowedBuiltIns
+		typeAliases: createTypeAliasEnvironment(program, visitorKeys)
 	};
 }
 function typeReferenceName(type) {
 	return type.typeName.type === "Identifier" ? type.typeName.name : null;
 }
-function isBuiltIn(name, environment) {
-	return BUILT_INS.has(name) && !environment.shadowedBuiltIns.has(name);
+function isBuiltIn(name, use, environment) {
+	return BUILT_INS.has(name) && !hasVisibleTypeBinding(name, use, environment.typeAliases);
 }
 function isUnappliedReferenceTo(type, name) {
 	const unwrapped = unwrapTransparentType(type);
@@ -84,13 +62,16 @@ function isEffectivelyEmptyInterface(declarations) {
 	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) {
+function resolvedSubstitutionArgument(type, base, resolving = /* @__PURE__ */ new Set()) {
 	const unwrapped = unwrapTransparentType(type);
 	if (unwrapped.type !== "TSTypeReference") return type;
 	const name = typeReferenceName(unwrapped);
-	if (name === null) return type;
+	if (name === null || resolving.has(name)) return type;
 	const substitution = base.get(name);
-	return substitution === void 0 ? type : resolvedSubstitutionArgument(substitution, base);
+	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 ?? [];
@@ -118,7 +99,7 @@ function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
 	if (unwrapped.type !== "TSTypeReference") return null;
 	const name = typeReferenceName(unwrapped);
 	if (name === null) return null;
-	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
 		const wrapped = unwrapped.typeArguments?.params[0];
 		return wrapped === void 0 ? null : unsafeDirectValue(wrapped, environment, substitutions, resolvingAliases);
 	}
@@ -126,8 +107,8 @@ function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
 	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 alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+	if (alias === null || resolvingAliases.has(name)) return null;
 	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
 	if (nextSubstitutions === null) return null;
 	const nextResolving = new Set(resolvingAliases);
@@ -149,23 +130,23 @@ function dictionaryValueTypes(type, environment, substitutions, resolvingAliases
 	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)) {
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
 		const wrapped = unwrapped.typeArguments?.params[0];
 		return wrapped === void 0 ? [] : dictionaryValueTypes(wrapped, environment, substitutions, resolvingAliases);
 	}
-	if (name === "Record" && isBuiltIn(name, environment)) {
+	if (name === "Record" && isBuiltIn(name, unwrapped, environment)) {
 		const value = unwrapped.typeArguments?.params[1] ?? null;
 		return value === null ? [] : [{
 			type: value,
 			substitutions
 		}];
 	}
-	if ((name === "Pick" || name === "Omit") && isBuiltIn(name, environment)) {
+	if ((name === "Pick" || name === "Omit") && isBuiltIn(name, unwrapped, 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 alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+	if (alias === null || resolvingAliases.has(name)) return [];
 	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
 	if (nextSubstitutions === null) return [];
 	const nextResolving = new Set(resolvingAliases);
@@ -189,9 +170,6 @@ function classifyUnsafeDictionary(type, environment) {
 	}
 	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" };
@@ -201,32 +179,59 @@ function classifyWideningTarget(type, environment) {
 	if (unwrapped.type !== "TSTypeReference") return null;
 	const name = typeReferenceName(unwrapped);
 	if (name === null) return null;
-	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, 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 (name === "Record" && isBuiltIn(name, unwrapped, environment)) return hasBroadRecordKey(unwrapped, environment, /* @__PURE__ */ new Map()) ? { kind: "open dictionary" } : null;
+	const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+	if (alias === null) 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, new Set([name])) ? { kind: "generic container" } : null;
+		return (substitutions === null ? null : classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, new Set([name])))?.kind === "open dictionary" ? { kind: "generic container" } : null;
 	}
 	const substitutions = aliasSubstitution(alias, unwrapped, /* @__PURE__ */ new Map());
 	if (substitutions === null) return null;
 	return classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, new Set([name]));
 }
+function hasBroadRecordKey(type, environment, substitutions) {
+	const key = type.typeArguments?.params[0];
+	return key === void 0 || isBroadMappedKey(key, environment, substitutions);
+}
+function isBroadMappedKey(type, environment, substitutions, visitedAliases = /* @__PURE__ */ new Set()) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSStringKeyword" || unwrapped.type === "TSNumberKeyword" || unwrapped.type === "TSSymbolKeyword") return true;
+	if (unwrapped.type === "TSUnionType") return unwrapped.types.some((member) => isBroadMappedKey(member, environment, substitutions, visitedAliases));
+	if (unwrapped.type !== "TSTypeReference") return false;
+	const name = typeReferenceName(unwrapped);
+	if (name === null) return false;
+	const substitution = substitutions.get(name);
+	if (substitution !== void 0 && !isUnappliedReferenceTo(substitution, name)) return isBroadMappedKey(substitution, environment, substitutions, visitedAliases);
+	if (name === "PropertyKey" && isBuiltIn(name, unwrapped, environment)) return true;
+	const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+	if (alias === null || (alias.typeParameters?.params.length ?? 0) > 0 || visitedAliases.has(name)) return false;
+	const nextVisited = new Set(visitedAliases);
+	nextVisited.add(name);
+	return isBroadMappedKey(alias.typeAnnotation, environment, substitutions, nextVisited);
+}
 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(unwrapped);
 	if (name === null) return null;
 	const substitution = substitutions.get(name);
-	if (substitution !== void 0) return classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
-	const alias = environment.aliases.get(name);
-	if (alias === void 0 || resolvingAliases.has(name)) return null;
+	if (substitution !== void 0) return isUnappliedReferenceTo(substitution, name) ? null : classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? null : classifyAliasBroadTarget(wrapped, environment, substitutions, resolvingAliases);
+	}
+	if (name === "Record" && isBuiltIn(name, unwrapped, environment)) return hasBroadRecordKey(unwrapped, environment, substitutions) ? { kind: "open dictionary" } : null;
+	const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+	if (alias === null || resolvingAliases.has(name)) return null;
 	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
 	if (nextSubstitutions === null) return null;
 	const nextResolving = new Set(resolvingAliases);

package/dist/rules/_anti-slop-function-parameters.js

@@ -0,0 +1,27 @@
+//#region src/rules/_anti-slop-function-parameters.ts
+/** Return whether a type is or contains TypeScript's absorbing unknown top type. */
+function containsUnknownType(type) {
+	if (type.type === "TSUnknownKeyword") return true;
+	if (type.type === "TSParenthesizedType") return containsUnknownType(type.typeAnnotation);
+	return type.type === "TSUnionType" && type.types.some(containsUnknownType);
+}
+/** Return the TypeScript annotation attached to a function parameter or its wrapped binding. */
+function functionParameterTypeAnnotation(parameter) {
+	if (parameter.type === "TSParameterProperty") return functionParameterTypeAnnotation(parameter.parameter);
+	if (parameter.type === "RestElement") return parameter.typeAnnotation ?? functionParameterTypeAnnotation(parameter.argument);
+	if (parameter.type === "AssignmentPattern") return parameter.typeAnnotation ?? functionParameterTypeAnnotation(parameter.left);
+	return parameter.typeAnnotation;
+}
+/** Return only a function parameter's local binding, excluding its annotation and default value. */
+function functionParameterBindingName(parameter, sourceCode) {
+	if (parameter.type === "TSParameterProperty") return functionParameterBindingName(parameter.parameter, sourceCode);
+	if (parameter.type === "AssignmentPattern") return functionParameterBindingName(parameter.left, sourceCode);
+	if (parameter.type === "RestElement") return functionParameterBindingName(parameter.argument, sourceCode);
+	const annotation = functionParameterTypeAnnotation(parameter);
+	const annotationOffset = annotation === null || annotation === void 0 ? void 0 : annotation.start - parameter.start;
+	if (parameter.type === "Identifier") return parameter.name;
+	const sourceText = sourceCode.getText(parameter);
+	return annotationOffset === void 0 ? sourceText : sourceText.slice(0, annotationOffset).trimEnd();
+}
+//#endregion
+export { containsUnknownType, functionParameterBindingName, functionParameterTypeAnnotation };

package/dist/rules/_anti-slop-lexical-type-parameters.js

@@ -0,0 +1,33 @@
+//#region src/rules/_anti-slop-lexical-type-parameters.ts
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function collectInferTypeParameterNames(node, visitorKeys, names) {
+	if (node.type === "TSInferType") names.add(node.typeParameter.name.name);
+	const 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
+export { lexicalTypeParameterNames };

package/dist/rules/_anti-slop-reflect-method.js

@@ -0,0 +1,21 @@
+import { resolveVariable } from "./_anti-slop-scope.js";
+//#region src/rules/_anti-slop-reflect-method.ts
+/**
+* Ported from dmmulroy/anti-slop at
+* c44ef22ca116d0ba62a3ff663a0bd13a3f3fa40b.
+*/
+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
+export { isGlobalReflectMethodCall };

package/dist/rules/_anti-slop-scope.js

@@ -0,0 +1,13 @@
+//#region src/rules/_anti-slop-scope.ts
+/** Resolve an identifier to its binding by walking lexical scopes upward. */
+function resolveVariable(sourceCode, identifier) {
+	let scope = sourceCode.getScope(identifier);
+	while (scope !== null) {
+		const variable = scope.set.get(identifier.name);
+		if (variable !== void 0) return variable;
+		scope = scope.upper;
+	}
+	return null;
+}
+//#endregion
+export { resolveVariable };