oxlint-plugin-effect 0.7.0 → 0.8.0

package/README.md

@@ -39,9 +39,30 @@ If the project uses JSON configuration, copy the exported rule map into `rules`;
 | `effect/noDynamicImports`     | Allows import() only behind a named lazy-loading boundary; bans require()                 |
 | `effect/noEffectDo`           | Bans Effect.Do                                                                            |
 | `effect/noEffectBind`         | Bans Effect.bind                                                                          |
+| `effect/preferEffectFn`       | Requires `Effect.fn` for a generator operation that adds a span                           |
 | `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             |
 
+## 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 |
+
+See `THIRD_PARTY_NOTICES.md` for the source revision and license.
+
 The preset intentionally allows `Effect.as`, `Option.as`, `Effect.never`, `Effect.async`, ordinary `if` and `switch` statements, and runtime runners at explicit application boundaries.
 
 ## Platform Boundaries

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,27 @@
+# Third-Party Notices
+
+The anti-slop rules include code derived from
+[`dmmulroy/anti-slop`](https://github.com/dmmulroy/anti-slop) at commit
+`b5d2288db1f00469a1d5f2e3b0e265e5a5676fd0`.
+
+MIT License
+
+Copyright (c) 2026 Dillon Mulroy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/presets/recommended.d.ts

@@ -3,18 +3,29 @@
 declare const recommended: {
   readonly "effect/noAs": "error";
   readonly "effect/noAsyncFunction": "error";
+  readonly "effect/noChainedTypeAssertions": "error";
+  readonly "effect/noConditionalEmptyObjectSpread": "error";
   readonly "effect/noDynamicImports": "error";
   readonly "effect/noEffectBind": "error";
   readonly "effect/noEffectDo": "error";
   readonly "effect/noGlobals": "error";
+  readonly "effect/noKnownValueWidening": "error";
   readonly "effect/noNewError": "error";
   readonly "effect/noNewPromise": "error";
   readonly "effect/noNodeBuiltinImport": "error";
   readonly "effect/noNullish": "error";
+  readonly "effect/noObjectParameters": "error";
+  readonly "effect/noRuntimeTypeof": "error";
+  readonly "effect/noShapeInSymbolNames": "error";
+  readonly "effect/preferEffectFn": "error";
   readonly "effect/noTernary": "error";
   readonly "effect/noTestLifecycleHooks": "error";
   readonly "effect/noThrowStatement": "error";
   readonly "effect/noTryCatch": "error";
+  readonly "effect/noUnknownParameters": "error";
+  readonly "effect/noUnknownTypeAliases": "error";
+  readonly "effect/noUnsafeDictionaryType": "error";
+  readonly "effect/noWidenThenAssert": "error";
 };
 //#endregion
 export { recommended };

package/dist/presets/recommended.js

@@ -3,18 +3,29 @@
 const recommended = {
 	"effect/noAs": "error",
 	"effect/noAsyncFunction": "error",
+	"effect/noChainedTypeAssertions": "error",
+	"effect/noConditionalEmptyObjectSpread": "error",
 	"effect/noDynamicImports": "error",
 	"effect/noEffectBind": "error",
 	"effect/noEffectDo": "error",
 	"effect/noGlobals": "error",
+	"effect/noKnownValueWidening": "error",
 	"effect/noNewError": "error",
 	"effect/noNewPromise": "error",
 	"effect/noNodeBuiltinImport": "error",
 	"effect/noNullish": "error",
+	"effect/noObjectParameters": "error",
+	"effect/noRuntimeTypeof": "error",
+	"effect/noShapeInSymbolNames": "error",
+	"effect/preferEffectFn": "error",
 	"effect/noTernary": "error",
 	"effect/noTestLifecycleHooks": "error",
 	"effect/noThrowStatement": "error",
-	"effect/noTryCatch": "error"
+	"effect/noTryCatch": "error",
+	"effect/noUnknownParameters": "error",
+	"effect/noUnknownTypeAliases": "error",
+	"effect/noUnsafeDictionaryType": "error",
+	"effect/noWidenThenAssert": "error"
 };
 //#endregion
 export { recommended };

package/dist/rules/_anti-slop-dictionary-types.d.ts

@@ -0,0 +1,24 @@
+import { ESTree } from "@oxlint/plugins";
+
+//#region src/rules/_anti-slop-dictionary-types.d.ts
+type UnsafeDictionary = {
+  readonly kind: "unsafe-dictionary";
+  readonly unsafeValue: "any" | "empty-object" | "object" | "union" | "unknown";
+};
+type WideningTargetKind = "anonymous object" | "generic container" | "object" | "open dictionary" | "unknown";
+type WideningTarget = {
+  readonly kind: WideningTargetKind;
+};
+type TypeEnvironment = {
+  readonly aliases: ReadonlyMap<string, ESTree.TSTypeAliasDeclaration>;
+  readonly interfaces: ReadonlyMap<string, readonly ESTree.TSInterfaceDeclaration[]>;
+  readonly shadowedBuiltIns: ReadonlySet<string>;
+};
+declare function createTypeEnvironment(program: ESTree.Program): TypeEnvironment;
+declare function classifyUnsafeDictionaryValue(valueType: ESTree.TSType, environment: TypeEnvironment): UnsafeDictionary | null;
+declare function classifyUnsafeDictionary(type: ESTree.TSType, environment: TypeEnvironment): UnsafeDictionary | null;
+declare function classifyWideningTarget(type: ESTree.TSType, environment: TypeEnvironment): WideningTarget | null;
+declare function isPopulatedObjectExpression(expression: ESTree.Expression): boolean;
+declare function isKnownEvidenceExpression(expression: ESTree.Expression): boolean;
+//#endregion
+export { TypeEnvironment, UnsafeDictionary, WideningTarget, WideningTargetKind, classifyUnsafeDictionary, classifyUnsafeDictionaryValue, classifyWideningTarget, createTypeEnvironment, isKnownEvidenceExpression, isPopulatedObjectExpression };

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

@@ -0,0 +1,248 @@
+//#region src/rules/_anti-slop-dictionary-types.ts
+const BUILT_INS = new Set([
+	"Record",
+	"Readonly",
+	"Partial",
+	"Required",
+	"Pick",
+	"Omit",
+	"PropertyKey",
+	"NonNullable"
+]);
+const TRANSPARENT_WRAPPERS = new Set([
+	"Readonly",
+	"Partial",
+	"Required",
+	"NonNullable"
+]);
+function declaredStatement(statement) {
+	return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration ?? null : statement;
+}
+function createTypeEnvironment(program) {
+	const aliases = /* @__PURE__ */ new Map();
+	const interfaces = /* @__PURE__ */ new Map();
+	const shadowedBuiltIns = /* @__PURE__ */ new Set();
+	for (const statement of program.body) {
+		const declaration = declaredStatement(statement);
+		if (declaration?.type === "ImportDeclaration") {
+			for (const specifier of declaration.specifiers) if (BUILT_INS.has(specifier.local.name)) shadowedBuiltIns.add(specifier.local.name);
+			continue;
+		}
+		if (declaration?.type === "TSTypeAliasDeclaration") {
+			if (aliases.get(declaration.id.name) === void 0) aliases.set(declaration.id.name, declaration);
+			else shadowedBuiltIns.add(declaration.id.name);
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+			continue;
+		}
+		if (declaration?.type === "TSInterfaceDeclaration") {
+			const declarations = interfaces.get(declaration.id.name) ?? [];
+			declarations.push(declaration);
+			interfaces.set(declaration.id.name, declarations);
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+			continue;
+		}
+		if (declaration?.type === "TSEnumDeclaration") {
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+			continue;
+		}
+		if ((declaration?.type === "ClassDeclaration" || declaration?.type === "FunctionDeclaration") && declaration.id !== null) {
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+		}
+	}
+	return {
+		aliases,
+		interfaces,
+		shadowedBuiltIns
+	};
+}
+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 isUnappliedReferenceTo(type, name) {
+	const unwrapped = unwrapTransparentType(type);
+	return unwrapped.type === "TSTypeReference" && typeReferenceName(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) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type !== "TSTypeReference") return type;
+	const name = typeReferenceName(unwrapped);
+	if (name === null) return type;
+	const substitution = base.get(name);
+	return substitution === void 0 ? type : resolvedSubstitutionArgument(substitution, base);
+}
+function aliasSubstitution(alias, type, base) {
+	const parameters = alias.typeParameters?.params ?? [];
+	const typeArguments = type.typeArguments?.params ?? [];
+	const next = new Map(base);
+	for (const [index, parameter] of parameters.entries()) {
+		const argument = typeArguments[index] ?? parameter.default;
+		if (argument === null || argument === void 0) return null;
+		next.set(parameter.name.name, resolvedSubstitutionArgument(argument, next));
+	}
+	return next;
+}
+function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSUnknownKeyword") return "unknown";
+	if (unwrapped.type === "TSAnyKeyword") return "any";
+	if (unwrapped.type === "TSObjectKeyword") return "object";
+	if (unwrapped.type === "TSTypeLiteral" && isEffectivelyEmptyTypeLiteral(unwrapped)) return "empty-object";
+	if (unwrapped.type === "TSUnionType") return unwrapped.types.some((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases) !== null) ? "union" : null;
+	if (unwrapped.type === "TSIntersectionType") {
+		const unsafeMembers = unwrapped.types.map((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases));
+		if (unsafeMembers.includes("any")) return "any";
+		return unsafeMembers.length > 0 && unsafeMembers.every((member) => member !== null) ? unsafeMembers[0] ?? null : null;
+	}
+	if (unwrapped.type !== "TSTypeReference") return null;
+	const name = typeReferenceName(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(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(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, 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, new Set([name]));
+}
+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 !== "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;
+	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 isPopulatedObjectExpression(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") current = current.expression;
+	return current.type === "ObjectExpression" && current.properties.length > 0;
+}
+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
+export { classifyUnsafeDictionary, classifyUnsafeDictionaryValue, classifyWideningTarget, createTypeEnvironment, isKnownEvidenceExpression, isPopulatedObjectExpression };

package/dist/rules/index.d.ts

@@ -2,20 +2,31 @@ import { noEffectBind } from "./no-effect-bind.js";
 import { noEffectDo } from "./no-effect-do.js";
 import { noAs } from "./no-as.js";
 import { noAsyncFunction } from "./no-async-function.js";
+import { noChainedTypeAssertions } from "./no-chained-type-assertions.js";
+import { noConditionalEmptyObjectSpread } from "./no-conditional-empty-object-spread.js";
 import { noDynamicImports } from "./no-dynamic-imports.js";
 import { noGlobals } from "./no-globals.js";
+import { noKnownValueWidening } from "./no-known-value-widening.js";
 import { noNewError } from "./no-new-error.js";
 import { noNewPromise } from "./no-new-promise.js";
 import { noNodeBuiltinImport } from "./no-node-builtin-import.js";
 import { noNullish } from "./no-nullish.js";
+import { noObjectParameters } from "./no-object-parameters.js";
+import { noRuntimeTypeof } from "./no-runtime-typeof.js";
+import { noShapeInSymbolNames } from "./no-shape-in-symbol-names.js";
 import { noTernary } from "./no-ternary.js";
 import { noTestLifecycleHooks } from "./no-test-lifecycle-hooks.js";
 import { noThrowStatement } from "./no-throw-statement.js";
 import { noTryCatch } from "./no-try-catch.js";
+import { noUnknownParameters } from "./no-unknown-parameters.js";
+import { noUnknownTypeAliases } from "./no-unknown-type-aliases.js";
+import { noUnsafeDictionaryType } from "./no-unsafe-dictionary-type.js";
+import { noWidenThenAssert } from "./no-widen-then-assert.js";
+import { preferEffectFn } from "./prefer-effect-fn.js";
 
 //#region src/rules/index.d.ts
 declare namespace index_d_exports {
-  export { noAs, noAsyncFunction, noDynamicImports, noEffectBind, noEffectDo, noGlobals, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch };
+  export { noAs, noAsyncFunction, noChainedTypeAssertions, noConditionalEmptyObjectSpread, noDynamicImports, noEffectBind, noEffectDo, noGlobals, noKnownValueWidening, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noObjectParameters, noRuntimeTypeof, noShapeInSymbolNames, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch, noUnknownParameters, noUnknownTypeAliases, noUnsafeDictionaryType, noWidenThenAssert, preferEffectFn };
 }
 //#endregion
-export { index_d_exports, noAs, noAsyncFunction, noDynamicImports, noEffectBind, noEffectDo, noGlobals, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch };
+export { index_d_exports, noAs, noAsyncFunction, noChainedTypeAssertions, noConditionalEmptyObjectSpread, noDynamicImports, noEffectBind, noEffectDo, noGlobals, noKnownValueWidening, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noObjectParameters, noRuntimeTypeof, noShapeInSymbolNames, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch, noUnknownParameters, noUnknownTypeAliases, noUnsafeDictionaryType, noWidenThenAssert, preferEffectFn };

package/dist/rules/index.js

@@ -3,32 +3,54 @@ import { noEffectBind } from "./no-effect-bind.js";
 import { noEffectDo } from "./no-effect-do.js";
 import { noAs } from "./no-as.js";
 import { noAsyncFunction } from "./no-async-function.js";
+import { noChainedTypeAssertions } from "./no-chained-type-assertions.js";
+import { noConditionalEmptyObjectSpread } from "./no-conditional-empty-object-spread.js";
 import { noDynamicImports } from "./no-dynamic-imports.js";
 import { noGlobals } from "./no-globals.js";
+import { noKnownValueWidening } from "./no-known-value-widening.js";
 import { noNewError } from "./no-new-error.js";
 import { noNewPromise } from "./no-new-promise.js";
 import { noNodeBuiltinImport } from "./no-node-builtin-import.js";
 import { noNullish } from "./no-nullish.js";
+import { noObjectParameters } from "./no-object-parameters.js";
+import { noRuntimeTypeof } from "./no-runtime-typeof.js";
+import { noShapeInSymbolNames } from "./no-shape-in-symbol-names.js";
 import { noTernary } from "./no-ternary.js";
 import { noTestLifecycleHooks } from "./no-test-lifecycle-hooks.js";
 import { noThrowStatement } from "./no-throw-statement.js";
 import { noTryCatch } from "./no-try-catch.js";
+import { noUnknownParameters } from "./no-unknown-parameters.js";
+import { noUnknownTypeAliases } from "./no-unknown-type-aliases.js";
+import { noUnsafeDictionaryType } from "./no-unsafe-dictionary-type.js";
+import { noWidenThenAssert } from "./no-widen-then-assert.js";
+import { preferEffectFn } from "./prefer-effect-fn.js";
 //#region src/rules/index.ts
 var rules_exports = /* @__PURE__ */ __exportAll({
 	noAs: () => noAs,
 	noAsyncFunction: () => noAsyncFunction,
+	noChainedTypeAssertions: () => noChainedTypeAssertions,
+	noConditionalEmptyObjectSpread: () => noConditionalEmptyObjectSpread,
 	noDynamicImports: () => noDynamicImports,
 	noEffectBind: () => noEffectBind,
 	noEffectDo: () => noEffectDo,
 	noGlobals: () => noGlobals,
+	noKnownValueWidening: () => noKnownValueWidening,
 	noNewError: () => noNewError,
 	noNewPromise: () => noNewPromise,
 	noNodeBuiltinImport: () => noNodeBuiltinImport,
 	noNullish: () => noNullish,
+	noObjectParameters: () => noObjectParameters,
+	noRuntimeTypeof: () => noRuntimeTypeof,
+	noShapeInSymbolNames: () => noShapeInSymbolNames,
 	noTernary: () => noTernary,
 	noTestLifecycleHooks: () => noTestLifecycleHooks,
 	noThrowStatement: () => noThrowStatement,
-	noTryCatch: () => noTryCatch
+	noTryCatch: () => noTryCatch,
+	noUnknownParameters: () => noUnknownParameters,
+	noUnknownTypeAliases: () => noUnknownTypeAliases,
+	noUnsafeDictionaryType: () => noUnsafeDictionaryType,
+	noWidenThenAssert: () => noWidenThenAssert,
+	preferEffectFn: () => preferEffectFn
 });
 //#endregion
-export { noAs, noAsyncFunction, noDynamicImports, noEffectBind, noEffectDo, noGlobals, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch, rules_exports };
+export { noAs, noAsyncFunction, noChainedTypeAssertions, noConditionalEmptyObjectSpread, noDynamicImports, noEffectBind, noEffectDo, noGlobals, noKnownValueWidening, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noObjectParameters, noRuntimeTypeof, noShapeInSymbolNames, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch, noUnknownParameters, noUnknownTypeAliases, noUnsafeDictionaryType, noWidenThenAssert, preferEffectFn, rules_exports };

package/dist/rules/no-chained-type-assertions.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-chained-type-assertions.d.ts
+/** Disallow nested TypeScript type assertions, while permitting chains made only of const assertions. */
+declare const noChainedTypeAssertions: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noChainedTypeAssertions };

package/dist/rules/no-chained-type-assertions.js

@@ -0,0 +1,60 @@
+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-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(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(current);
+		current = unwrapParenthesizedExpression(current.expression);
+	}
+	return assertionCount > 1 && hasNonConstAssertion;
+}
+/** Disallow nested TypeScript type assertions, while permitting chains made only of const assertions. */
+const noChainedTypeAssertions = define({
+	name: "no-chained-type-assertions",
+	meta: meta({
+		type: "problem",
+		description: "Disallow chained TypeScript as and angle-bracket assertions, including parenthesized chains.",
+		messages: { chained: "Chained type assertions discard existing type evidence and fabricate the target type without parsing. Preserve the value's original precise type, or parse genuinely unknown input at its boundary before using it." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		const checkTypeAssertion = (node) => isOutermostAssertionInChain(node) && isForbiddenAssertionChain(node) ? context.report(fromId({
+			node,
+			messageId: "chained"
+		})) : Effect.void;
+		return {
+			TSAsExpression: checkTypeAssertion,
+			TSTypeAssertion: checkTypeAssertion
+		};
+	}
+});
+//#endregion
+export { noChainedTypeAssertions };

package/dist/rules/no-conditional-empty-object-spread.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-conditional-empty-object-spread.d.ts
+/** Ban conditional empty-object spreads and autofix equivalent direct property declarations. */
+declare const noConditionalEmptyObjectSpread: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noConditionalEmptyObjectSpread };

package/dist/rules/no-conditional-empty-object-spread.js

@@ -0,0 +1,79 @@
+import { fromId, replaceText, withFix } 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-conditional-empty-object-spread.ts
+function unwrapParentheses(node) {
+	let current = node;
+	while (current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
+function isEmptyObjectExpression(node) {
+	return node.type === "ObjectExpression" && node.properties.length === 0;
+}
+function singleObjectProperty(node) {
+	if (node.type !== "ObjectExpression" || node.properties.length !== 1) return null;
+	const [property] = node.properties;
+	if (property?.type !== "Property" || property.kind !== "init" || property.method || property.computed) return null;
+	return property;
+}
+function conditionalEmptyObjectSpread(node) {
+	const conditional = unwrapParentheses(node);
+	if (conditional.type !== "ConditionalExpression") return null;
+	if (isEmptyObjectExpression(conditional.consequent)) return {
+		conditional,
+		property: singleObjectProperty(conditional.alternate)
+	};
+	if (isEmptyObjectExpression(conditional.alternate)) return {
+		conditional,
+		property: singleObjectProperty(conditional.consequent)
+	};
+	return null;
+}
+function undefinedCheckedExpression(test) {
+	const binary = unwrapParentheses(test);
+	if (binary.type !== "BinaryExpression") return null;
+	if (binary.operator !== "===" && binary.operator !== "!==") return null;
+	const left = unwrapParentheses(binary.left);
+	const right = unwrapParentheses(binary.right);
+	const leftIsUndefined = left.type === "Identifier" && left.name === "undefined";
+	if (leftIsUndefined === (right.type === "Identifier" && right.name === "undefined")) return null;
+	return {
+		expression: leftIsUndefined ? right : left,
+		isDefinedWhenTrue: binary.operator === "!=="
+	};
+}
+function canAutofixConditionalEmptyObjectSpread(sourceCode, conditional, property) {
+	const checked = undefinedCheckedExpression(conditional.test);
+	if (checked === null) return false;
+	if (conditional.consequent === property.parent !== checked.isDefinedWhenTrue) return false;
+	return sourceCode.getText(unwrapParentheses(checked.expression)) === sourceCode.getText(property.value);
+}
+/** Ban conditional empty-object spreads and autofix equivalent direct property declarations. */
+const noConditionalEmptyObjectSpread = define({
+	name: "no-conditional-empty-object-spread",
+	meta: meta({
+		type: "suggestion",
+		fixable: "code",
+		description: "Disallow object spreads that conditionally spread an empty object to omit fields.",
+		messages: { avoid: "Do not use conditional empty-object spreads. Prefer a direct property or build the object in separate statements." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		return { SpreadElement: (node) => {
+			if (node.parent?.type !== "ObjectExpression") return Effect.void;
+			const match = conditionalEmptyObjectSpread(node.argument);
+			if (match === null) return Effect.void;
+			const { conditional, property } = match;
+			const diagnostic = fromId({
+				node,
+				messageId: "avoid"
+			});
+			if (property === null || !canAutofixConditionalEmptyObjectSpread(context.sourceCode, conditional, property)) return context.report(diagnostic);
+			return context.report(withFix(diagnostic, replaceText(node, context.sourceCode.getText(property))));
+		} };
+	}
+});
+//#endregion
+export { noConditionalEmptyObjectSpread };