@flint.fyi/ts 0.19.1 → 0.20.0

package/lib/plugin.d.ts

@@ -255,6 +255,13 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "preferShorthand", undefined>, _flint_fyi_core0.Rule<{
+  readonly description: "Reports async functions that do not use await.";
+  readonly id: "asyncFunctionAwaits";
+  readonly presets: readonly ["logicalStrict"];
+} & {
+  readonly pluginId: string;
+  readonly url: string;
+}, "missingAwait", undefined>, _flint_fyi_core0.Rule<{
   readonly description: "Reports using async functions as Promise executor functions.";
   readonly id: "asyncPromiseExecutors";
   readonly presets: readonly ["logical", "logicalStrict"];
@@ -1816,6 +1823,29 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly url: string;
 }, "restricted", {
   deny: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodString>>;
+}>, _flint_fyi_core0.Rule<{
+  readonly description: "Restricts specified modules from being imported.";
+  readonly id: "restrictedImports";
+} & {
+  readonly pluginId: string;
+  readonly url: string;
+}, "restricted" | "moduleRestricted" | "moduleRestrictedWithMessage" | "namespaceRestricted" | "namespaceRestrictedWithMessage" | "restrictedWithMessage", {
+  restrictions: zod_v40.ZodDefault<zod_v40.ZodArray<zod_v40.ZodObject<{
+    allowTypeImports: zod_v40.ZodOptional<zod_v40.ZodBoolean>;
+    message: zod_v40.ZodOptional<zod_v40.ZodString>;
+    specifier: zod_v40.ZodUnion<readonly [zod_v40.ZodObject<{
+      from: zod_v40.ZodLiteral<"file">;
+      name: zod_v40.ZodOptional<zod_v40.ZodUnion<readonly [zod_v40.ZodString, zod_v40.ZodArray<zod_v40.ZodString>]>>;
+      path: zod_v40.ZodOptional<zod_v40.ZodString>;
+    }, zod_v4_core0.$strip>, zod_v40.ZodObject<{
+      from: zod_v40.ZodLiteral<"lib">;
+      name: zod_v40.ZodOptional<zod_v40.ZodUnion<readonly [zod_v40.ZodString, zod_v40.ZodArray<zod_v40.ZodString>]>>;
+    }, zod_v4_core0.$strip>, zod_v40.ZodObject<{
+      from: zod_v40.ZodLiteral<"package">;
+      name: zod_v40.ZodOptional<zod_v40.ZodUnion<readonly [zod_v40.ZodString, zod_v40.ZodArray<zod_v40.ZodString>]>>;
+      package: zod_v40.ZodString;
+    }, zod_v4_core0.$strip>]>;
+  }, zod_v4_core0.$strip>>>;
 }>, _flint_fyi_core0.Rule<{
   readonly description: "Reports using assignment expressions in return statements.";
   readonly id: "returnAssignments";

package/lib/plugin.js

@@ -33,6 +33,7 @@ import arrayTypes_default from "./rules/arrayTypes.js";
 import arrayUnnecessaryLengthChecks_default from "./rules/arrayUnnecessaryLengthChecks.js";
 import asConstAssertions_default from "./rules/asConstAssertions.js";
 import assignmentOperatorShorthands_default from "./rules/assignmentOperatorShorthands.js";
+import asyncFunctionAwaits_default from "./rules/asyncFunctionAwaits.js";
 import asyncPromiseExecutors_default from "./rules/asyncPromiseExecutors.js";
 import asyncUnnecessaryPromiseWrappers_default from "./rules/asyncUnnecessaryPromiseWrappers.js";
 import atAccesses_default from "./rules/atAccesses.js";
@@ -248,6 +249,7 @@ import regexZeroQuantifiers_default from "./rules/regexZeroQuantifiers.js";
 import requireImports_default from "./rules/requireImports.js";
 import responseJsonMethods_default from "./rules/responseJsonMethods.js";
 import restrictedIdentifiers_default from "./rules/restrictedIdentifiers.js";
+import restrictedImports_default from "./rules/restrictedImports.js";
 import returnAssignments_default from "./rules/returnAssignments.js";
 import returnThisTypes_default from "./rules/returnThisTypes.js";
 import selfAssignments_default from "./rules/selfAssignments.js";
@@ -344,6 +346,7 @@ const ts = createPlugin({
 		arrayUnnecessaryLengthChecks_default,
 		asConstAssertions_default,
 		assignmentOperatorShorthands_default,
+		asyncFunctionAwaits_default,
 		asyncPromiseExecutors_default,
 		asyncUnnecessaryPromiseWrappers_default,
 		atAccesses_default,
@@ -560,6 +563,7 @@ const ts = createPlugin({
 		requireImports_default,
 		responseJsonMethods_default,
 		restrictedIdentifiers_default,
+		restrictedImports_default,
 		returnAssignments_default,
 		returnThisTypes_default,
 		selfAssignments_default,

package/lib/rules/asyncFunctionAwaits.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports async functions that do not use await.";
+    readonly id: "asyncFunctionAwaits";
+    readonly presets: readonly ["logicalStrict"];
+} & {
+    readonly pluginId: string;
+    readonly url: string;
+}, "missingAwait", undefined>;
+export default _default;
+//# sourceMappingURL=asyncFunctionAwaits.d.ts.map

package/lib/rules/asyncFunctionAwaits.js

@@ -0,0 +1,55 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/asyncFunctionAwaits.ts
+var asyncFunctionAwaits_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports async functions that do not use await.",
+		id: "asyncFunctionAwaits",
+		presets: ["logicalStrict"]
+	},
+	messages: { missingAwait: {
+		primary: "This function is marked `async` but does not contain an `await` expression or return a Promise.",
+		secondary: ["Async functions always wrap their return value in a Promise, which adds overhead if you're not using await.", "This may indicate incomplete implementation or leftover code after refactoring."],
+		suggestions: ["Add an `await` expression if you need to wait for asynchronous operations.", "Remove the `async` keyword if the function doesn't need to be asynchronous."]
+	} },
+	setup(context) {
+		function checkFunction(node, { sourceFile, typeChecker }) {
+			const asyncModifier = node.modifiers?.find((modifier) => modifier.kind === ts$1.SyntaxKind.AsyncKeyword);
+			if (!asyncModifier || node.asteriskToken || !node.body || isEmptyBody(node.body) || checkForAwait(node.body) || bodyReturnsThenable(node.body, typeChecker)) return;
+			context.report({
+				message: "missingAwait",
+				range: getTSNodeRange(asyncModifier, sourceFile)
+			});
+		}
+		return { visitors: {
+			ArrowFunction: checkFunction,
+			FunctionDeclaration: checkFunction,
+			FunctionExpression: checkFunction,
+			MethodDeclaration: checkFunction
+		} };
+	}
+});
+function bodyReturnsThenable(body, typeChecker) {
+	if (!ts$1.isBlock(body)) return tsutils.isThenableType(typeChecker, body);
+	function checkReturnStatements(node) {
+		if (ts$1.isReturnStatement(node) && node.expression && tsutils.isThenableType(typeChecker, node.expression)) return true;
+		if (tsutils.isFunctionScopeBoundary(node)) return false;
+		return ts$1.forEachChild(node, checkReturnStatements);
+	}
+	return ts$1.forEachChild(body, checkReturnStatements);
+}
+function checkForAwait(node) {
+	if (ts$1.isAwaitExpression(node)) return true;
+	if (ts$1.isForOfStatement(node) && node.awaitModifier) return true;
+	if (tsutils.isFunctionScopeBoundary(node)) return false;
+	return ts$1.forEachChild(node, checkForAwait);
+}
+function isEmptyBody(body) {
+	return ts$1.isBlock(body) && !body.statements.length;
+}
+//#endregion
+export { asyncFunctionAwaits_default as default };
+
+//# sourceMappingURL=asyncFunctionAwaits.js.map

package/lib/rules/classAssignments.js

@@ -1,5 +1,5 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { getModifyingReferences, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { getModifyingReferences, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 //#region src/rules/classAssignments.ts
 var classAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -13,15 +13,12 @@ var classAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Use a different variable name if you need to store a modified reference to a class."]
 	} },
 	setup(context) {
-		return { visitors: { ClassDeclaration: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { ClassDeclaration: (node, { sourceFile }) => {
 			if (!node.name) return;
-			const modifyingReferences = getModifyingReferences(node.name, sourceFile, typeChecker);
+			const modifyingReferences = getModifyingReferences(node.name, sourceFile);
 			for (const reference of modifyingReferences) context.report({
 				message: "noClassAssign",
-				range: {
-					begin: reference.getStart(sourceFile),
-					end: reference.getEnd()
-				}
+				range: getTSNodeRange(reference, sourceFile)
 			});
 		} } };
 	}

package/lib/rules/constantAssignments.js

@@ -1,5 +1,5 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { getModifyingReferences, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { getModifyingReferences, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 import ts, { SyntaxKind } from "typescript";
 //#region src/rules/constantAssignments.ts
 var constantAssignments_default = ruleCreator.createRule(typescriptLanguage, {
@@ -20,18 +20,15 @@ var constantAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 			for (const element of name.elements) if (element.kind === SyntaxKind.BindingElement) identifiers.push(...collectBindingElements(element.name));
 			return identifiers;
 		}
-		return { visitors: { VariableDeclarationList: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { VariableDeclarationList: (node, { sourceFile }) => {
 			if (!(node.flags & ts.NodeFlags.Const) || !node.declarations.length) return;
 			for (const declaration of node.declarations) {
 				const identifiers = collectBindingElements(declaration.name);
 				for (const identifier of identifiers) {
-					const modifyingReferences = getModifyingReferences(identifier, sourceFile, typeChecker);
+					const modifyingReferences = getModifyingReferences(identifier, sourceFile);
 					for (const reference of modifyingReferences) context.report({
 						message: "noConstAssign",
-						range: {
-							begin: reference.getStart(sourceFile),
-							end: reference.getEnd()
-						}
+						range: getTSNodeRange(reference, sourceFile)
 					});
 				}
 			}

package/lib/rules/exceptionAssignments.js

@@ -1,5 +1,5 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { getModifyingReferences, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { getModifyingReferences, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 import { SyntaxKind } from "typescript";
 //#region src/rules/exceptionAssignments.ts
 var exceptionAssignments_default = ruleCreator.createRule(typescriptLanguage, {
@@ -20,17 +20,14 @@ var exceptionAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 			else for (const element of name.elements) if (element.kind === SyntaxKind.BindingElement) identifiers.push(...collectBindingElements(element.name));
 			return identifiers;
 		}
-		return { visitors: { CatchClause: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { CatchClause: (node, { sourceFile }) => {
 			if (!node.variableDeclaration?.name) return;
 			const identifiers = collectBindingElements(node.variableDeclaration.name);
 			for (const identifier of identifiers) {
-				const modifyingReferences = getModifyingReferences(identifier, sourceFile, typeChecker);
+				const modifyingReferences = getModifyingReferences(identifier, sourceFile);
 				for (const reference of modifyingReferences) context.report({
 					message: "noExAssign",
-					range: {
-						begin: reference.getStart(sourceFile),
-						end: reference.getEnd()
-					}
+					range: getTSNodeRange(reference, sourceFile)
 				});
 			}
 		} } };

package/lib/rules/functionAssignments.js

@@ -1,5 +1,5 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { getModifyingReferences, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { getModifyingReferences, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 //#region src/rules/functionAssignments.ts
 var functionAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
@@ -13,15 +13,12 @@ var functionAssignments_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Use a function expression or const variable instead if you need to reassign the function."]
 	} },
 	setup(context) {
-		return { visitors: { FunctionDeclaration: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { FunctionDeclaration: (node, { sourceFile }) => {
 			if (!node.name) return;
-			const modifyingReferences = getModifyingReferences(node.name, sourceFile, typeChecker);
+			const modifyingReferences = getModifyingReferences(node.name, sourceFile);
 			for (const reference of modifyingReferences) context.report({
 				message: "noFunctionAssignment",
-				range: {
-					begin: reference.getStart(sourceFile),
-					end: reference.getEnd()
-				}
+				range: getTSNodeRange(reference, sourceFile)
 			});
 		} } };
 	}

package/lib/rules/nullishCoalescingOperators.js

@@ -111,6 +111,17 @@ function getComparisonOperator(node) {
 		default: return "";
 	}
 }
+function getIfStatementNullishCheckValue(node) {
+	switch (node.expression.kind) {
+		case ts.SyntaxKind.BinaryExpression:
+			if (isNullLikeComparison(node.expression)) return extractValueFromComparison(node.expression).value ?? void 0;
+			return;
+		case ts.SyntaxKind.PrefixUnaryExpression:
+			if (node.expression.operator === ts.SyntaxKind.ExclamationToken) return node.expression.operand;
+			return;
+		default: return;
+	}
+}
 function getTypeFlags(type) {
 	let flags = 0;
 	for (const constituent of tsutils.unionConstituents(type)) for (const subConstituent of tsutils.intersectionConstituents(constituent)) flags |= subConstituent.getFlags();
@@ -143,13 +154,6 @@ function isFalsyLiteralType(part) {
 	}
 	return false;
 }
-function isIfStatementNullishCheck(node) {
-	switch (node.expression.kind) {
-		case ts.SyntaxKind.BinaryExpression: return isNullLikeComparison(node.expression);
-		case ts.SyntaxKind.PrefixUnaryExpression: return node.expression.operator === ts.SyntaxKind.ExclamationToken;
-		default: return false;
-	}
-}
 function isMixedLogicalExpression(node) {
 	const seen = /* @__PURE__ */ new Set();
 	const queue = [
@@ -266,6 +270,13 @@ var nullishCoalescingOperators_default = ruleCreator.createRule(typescriptLangua
 				text: `${leftText} ?? ${getText(alternate)}`
 			};
 		}
+		function createNullishAssignmentFix(left, right, sourceFile, range) {
+			const getText = (node) => sourceFile.text.substring(node.getStart(sourceFile), node.getEnd());
+			return {
+				range,
+				text: `${getText(left)} ??= ${getText(right)};`
+			};
+		}
 		return { visitors: {
 			BinaryExpression: (node, { options, sourceFile, typeChecker }) => {
 				if (options.ignoreConditionalTests && isConditionalTest(node) || options.ignoreMixedLogicalExpressions && isMixedLogicalExpression(node) || ![ts.SyntaxKind.BarBarEqualsToken, ts.SyntaxKind.BarBarToken].includes(node.operatorToken.kind) || shouldIgnoreNode(node.left, options.ignorePrimitives, typeChecker)) return;
@@ -292,12 +303,13 @@ var nullishCoalescingOperators_default = ruleCreator.createRule(typescriptLangua
 				});
 			},
 			IfStatement: (node, { options, sourceFile, typeChecker }) => {
-				if (options.ignoreIfStatements || node.elseStatement || !isIfStatementNullishCheck(node)) return;
+				const checkedValue = getIfStatementNullishCheckValue(node);
+				if (options.ignoreIfStatements || node.elseStatement || !checkedValue) return;
 				const assignmentExpression = extractAssignmentFromIfStatement(node);
-				if (!assignmentExpression || shouldIgnoreNode(assignmentExpression.left, options.ignorePrimitives, typeChecker)) return;
+				if (!assignmentExpression || !hasSameTokens(assignmentExpression.left, checkedValue, sourceFile) || shouldIgnoreNode(assignmentExpression.left, options.ignorePrimitives, typeChecker)) return;
 				const range = getTSNodeRange(node, sourceFile);
 				context.report({
-					fix: createNullishNodesFix(assignmentExpression.left, assignmentExpression.right, sourceFile, range),
+					fix: createNullishAssignmentFix(assignmentExpression.left, assignmentExpression.right, sourceFile, range),
 					message: "preferNullishAssignment",
 					range
 				});

package/lib/rules/parameterReassignments.js

@@ -1,20 +1,6 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
+import { getScopeManager, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 //#region src/rules/parameterReassignments.ts
-function collectParameterNames(parameters) {
-	const names = /* @__PURE__ */ new Set();
-	const collectNames = (node) => {
-		if (node.kind === ts.SyntaxKind.Identifier) names.add(node.text);
-		else if (ts.isObjectBindingPattern(node)) {
-			for (const element of node.elements) if (!ts.isOmittedExpression(element)) collectNames(element.name);
-		} else if (ts.isArrayBindingPattern(node)) {
-			for (const element of node.elements) if (!ts.isOmittedExpression(element)) collectNames(element.name);
-		}
-	};
-	for (const parameter of parameters) collectNames(parameter.name);
-	return names;
-}
 var parameterReassignments_default = ruleCreator.createRule(typescriptLanguage, {
 	about: {
 		description: "Disallow reassignment of function parameters.",
@@ -31,42 +17,25 @@ var parameterReassignments_default = ruleCreator.createRule(typescriptLanguage,
 		suggestions: ["Use a new variable if you need to modify the value.", "Use a different pattern such as a helper function."]
 	} },
 	setup(context) {
-		const scopes = /* @__PURE__ */ new Map();
-		const checkParameterAssignment = (name, node, sourceFile) => {
-			let currentNode = node;
-			while (currentNode !== void 0) {
-				if (ts.isFunctionDeclaration(currentNode) || ts.isFunctionExpression(currentNode) || ts.isArrowFunction(currentNode)) {
-					if (scopes.get(currentNode)?.has(name)) context.report({
-						message: "parameterReassignment",
-						range: getTSNodeRange(node, sourceFile)
-					});
-					return;
-				}
-				currentNode = currentNode.parent;
+		function reportParameterReassignments(node, { sourceFile }) {
+			const scopeManager = getScopeManager(sourceFile);
+			const parameterVariables = new Set(node.parameters.flatMap((parameter) => scopeManager.getDeclaredVariables(parameter)));
+			for (const reference of scopeManager.getReferencesInScope(node)) {
+				if (!reference.isWrite || !reference.variable || !parameterVariables.has(reference.variable)) continue;
+				context.report({
+					message: "parameterReassignment",
+					range: getTSNodeRange(reference.identifier, sourceFile)
+				});
 			}
-		};
-		const handleUnaryExpression = (node, { sourceFile }) => {
-			if ((node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) && ts.isIdentifier(node.operand)) checkParameterAssignment(node.operand.text, node.operand, sourceFile);
-		};
+		}
 		return { visitors: {
-			ArrowFunction: (node) => {
-				scopes.set(node, collectParameterNames(node.parameters));
-			},
-			BinaryExpression: (node, { sourceFile }) => {
-				if (!(node.operatorToken.kind === ts.SyntaxKind.EqualsToken || node.operatorToken.kind === ts.SyntaxKind.PlusEqualsToken || node.operatorToken.kind === ts.SyntaxKind.MinusEqualsToken || node.operatorToken.kind === ts.SyntaxKind.AsteriskEqualsToken || node.operatorToken.kind === ts.SyntaxKind.SlashEqualsToken) || !ts.isIdentifier(node.left)) return;
-				checkParameterAssignment(node.left.text, node.left, sourceFile);
-			},
-			FunctionDeclaration: (node) => {
-				scopes.set(node, collectParameterNames(node.parameters));
-			},
-			FunctionExpression: (node) => {
-				scopes.set(node, collectParameterNames(node.parameters));
-			},
-			PostfixUnaryExpression: handleUnaryExpression,
-			PrefixUnaryExpression: handleUnaryExpression,
-			Program: () => {
-				scopes.clear();
-			}
+			ArrowFunction: reportParameterReassignments,
+			Constructor: reportParameterReassignments,
+			FunctionDeclaration: reportParameterReassignments,
+			FunctionExpression: reportParameterReassignments,
+			GetAccessor: reportParameterReassignments,
+			MethodDeclaration: reportParameterReassignments,
+			SetAccessor: reportParameterReassignments
 		} };
 	}
 });

package/lib/rules/restrictedImports.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod/v4";
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Restricts specified modules from being imported.";
+    readonly id: "restrictedImports";
+} & {
+    readonly pluginId: string;
+    readonly url: string;
+}, "restricted" | "moduleRestricted" | "moduleRestrictedWithMessage" | "namespaceRestricted" | "namespaceRestrictedWithMessage" | "restrictedWithMessage", {
+    restrictions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        allowTypeImports: z.ZodOptional<z.ZodBoolean>;
+        message: z.ZodOptional<z.ZodString>;
+        specifier: z.ZodUnion<readonly [z.ZodObject<{
+            from: z.ZodLiteral<"file">;
+            name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            from: z.ZodLiteral<"lib">;
+            name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>, z.ZodObject<{
+            from: z.ZodLiteral<"package">;
+            name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            package: z.ZodString;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>>>;
+}>;
+export default _default;
+//# sourceMappingURL=restrictedImports.d.ts.map

package/lib/rules/restrictedImports.js

@@ -0,0 +1,166 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getSpecifierNames } from "../type-utils/getSpecifierNames.js";
+import { matchesSpecifier } from "../type-utils/matchesSpecifier.js";
+import { typeOrValueSpecifierSchema } from "../type-utils/schemas.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+import { z } from "zod/v4";
+//#region src/rules/restrictedImports.ts
+const restrictionSchema = z.object({
+	allowTypeImports: z.boolean().optional().describe("Whether type-only imports are exempt from the restriction."),
+	message: z.string().optional().describe("A custom message to display when the restriction is triggered."),
+	specifier: typeOrValueSpecifierSchema.describe("A TypeOrValueSpecifier identifying the restricted import.")
+});
+function resolveModuleDeclarations(moduleSpecifier, typeChecker) {
+	return typeChecker.getSymbolAtLocation(moduleSpecifier)?.getDeclarations();
+}
+function resolveSymbolDeclarations(nameNode, typeChecker) {
+	let symbol = typeChecker.getSymbolAtLocation(nameNode);
+	if (!symbol) return;
+	if (symbol.flags & ts.SymbolFlags.Alias) symbol = typeChecker.getAliasedSymbol(symbol);
+	return symbol.getDeclarations();
+}
+var restrictedImports_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Restricts specified modules from being imported.",
+		id: "restrictedImports"
+	},
+	messages: {
+		moduleRestricted: {
+			primary: "'{{ source }}' import is restricted.",
+			secondary: ["This module has been restricted by project configuration."],
+			suggestions: ["Remove this import or replace it with an allowed alternative."]
+		},
+		moduleRestrictedWithMessage: {
+			primary: "'{{ source }}' import is restricted. {{ customMessage }}",
+			secondary: ["This module has been restricted by project configuration."],
+			suggestions: ["Remove this import or replace it with an allowed alternative."]
+		},
+		namespaceRestricted: {
+			primary: "* import is invalid because '{{ restrictedNames }}' from '{{ source }}' is restricted.",
+			secondary: ["This import uses a namespace or wildcard import, but specific names from this module are restricted."],
+			suggestions: ["Replace the namespace import with named imports that are allowed."]
+		},
+		namespaceRestrictedWithMessage: {
+			primary: "* import is invalid because '{{ restrictedNames }}' from '{{ source }}' is restricted. {{ customMessage }}",
+			secondary: ["This import uses a namespace or wildcard import, but specific names from this module are restricted."],
+			suggestions: ["Replace the namespace import with named imports that are allowed."]
+		},
+		restricted: {
+			primary: "'{{ importName }}' import from '{{ source }}' is restricted.",
+			secondary: ["This import name has been restricted by project configuration."],
+			suggestions: ["Remove this import or replace it with an allowed alternative."]
+		},
+		restrictedWithMessage: {
+			primary: "'{{ importName }}' import from '{{ source }}' is restricted. {{ customMessage }}",
+			secondary: ["This import name has been restricted by project configuration."],
+			suggestions: ["Remove this import or replace it with an allowed alternative."]
+		}
+	},
+	options: { restrictions: z.array(restrictionSchema).default([]).describe("Restrictions on imports, using TypeOrValueSpecifier to identify targets.") },
+	setup(context) {
+		function checkNamedRestrictions(restrictions, declarations, importedName, isTypeOnly, source, range, program) {
+			for (const restriction of restrictions) {
+				if (restriction.allowTypeImports && isTypeOnly) continue;
+				if (matchesSpecifier(importedName, declarations, restriction.specifier, program)) context.report({
+					data: {
+						customMessage: restriction.message ?? "",
+						importName: importedName,
+						source
+					},
+					message: restriction.message ? "restrictedWithMessage" : "restricted",
+					range
+				});
+			}
+		}
+		function checkWildcardRestrictions(restrictions, moduleDeclarations, source, topLevelTypeOnly, range, program) {
+			for (const restriction of restrictions) {
+				if (restriction.allowTypeImports && topLevelTypeOnly) continue;
+				const names = getSpecifierNames(restriction.specifier);
+				if (names !== void 0) {
+					if (matchesSpecifier(void 0, moduleDeclarations, {
+						...restriction.specifier,
+						name: void 0
+					}, program)) context.report({
+						data: {
+							customMessage: restriction.message ?? "",
+							restrictedNames: names.join("', '"),
+							source
+						},
+						message: restriction.message ? "namespaceRestrictedWithMessage" : "namespaceRestricted",
+						range
+					});
+				} else if (matchesSpecifier(void 0, moduleDeclarations, restriction.specifier, program)) context.report({
+					data: {
+						customMessage: restriction.message ?? "",
+						source
+					},
+					message: restriction.message ? "moduleRestrictedWithMessage" : "moduleRestricted",
+					range
+				});
+			}
+		}
+		return { visitors: {
+			ExportDeclaration: (node, { options, program, sourceFile, typeChecker }) => {
+				if (!node.moduleSpecifier || !ts.isStringLiteral(node.moduleSpecifier)) return;
+				const source = node.moduleSpecifier.text;
+				const topLevelTypeOnly = node.isTypeOnly;
+				const range = getTSNodeRange(node, sourceFile);
+				if (node.exportClause && ts.isNamedExports(node.exportClause)) for (const element of node.exportClause.elements) {
+					const isTypeOnly = topLevelTypeOnly || element.isTypeOnly;
+					const importedName = element.propertyName ? element.propertyName.text : element.name.text;
+					const declarations = resolveSymbolDeclarations(element.name, typeChecker);
+					if (!declarations?.length) continue;
+					checkNamedRestrictions(options.restrictions, declarations, importedName, isTypeOnly, source, range, program);
+				}
+				else {
+					const moduleDeclarations = resolveModuleDeclarations(node.moduleSpecifier, typeChecker);
+					if (!moduleDeclarations?.length) return;
+					checkWildcardRestrictions(options.restrictions, moduleDeclarations, source, topLevelTypeOnly, range, program);
+				}
+			},
+			ImportDeclaration: (node, { options, program, sourceFile, typeChecker }) => {
+				if (!ts.isStringLiteral(node.moduleSpecifier)) return;
+				const source = node.moduleSpecifier.text;
+				const range = getTSNodeRange(node, sourceFile);
+				if (!node.importClause) {
+					const moduleDeclarations = resolveModuleDeclarations(node.moduleSpecifier, typeChecker);
+					if (!moduleDeclarations?.length) return;
+					for (const restriction of options.restrictions) if (matchesSpecifier(void 0, moduleDeclarations, restriction.specifier, program)) context.report({
+						data: {
+							customMessage: restriction.message ?? "",
+							source
+						},
+						message: restriction.message ? "moduleRestrictedWithMessage" : "moduleRestricted",
+						range
+					});
+					return;
+				}
+				const topLevelTypeOnly = node.importClause.phaseModifier === SyntaxKind.TypeKeyword;
+				if (node.importClause.name) {
+					const declarations = resolveSymbolDeclarations(node.importClause.name, typeChecker);
+					if (declarations?.length) checkNamedRestrictions(options.restrictions, declarations, "default", topLevelTypeOnly, source, range, program);
+				}
+				const bindings = node.importClause.namedBindings;
+				if (!bindings) return;
+				if (ts.isNamedImports(bindings)) {
+					for (const element of bindings.elements) {
+						const isTypeOnly = topLevelTypeOnly || element.isTypeOnly;
+						const importedName = element.propertyName ? element.propertyName.text : element.name.text;
+						const declarations = resolveSymbolDeclarations(element.name, typeChecker);
+						if (!declarations?.length) continue;
+						checkNamedRestrictions(options.restrictions, declarations, importedName, isTypeOnly, source, range, program);
+					}
+					return;
+				}
+				const moduleDeclarations = resolveModuleDeclarations(node.moduleSpecifier, typeChecker);
+				if (!moduleDeclarations?.length) return;
+				checkWildcardRestrictions(options.restrictions, moduleDeclarations, source, topLevelTypeOnly, range, program);
+			}
+		} };
+	}
+});
+//#endregion
+export { restrictedImports_default as default };
+
+//# sourceMappingURL=restrictedImports.js.map

package/lib/rules/typeImports.js

@@ -1,6 +1,5 @@
 import { ruleCreator } from "./ruleCreator.js";
-import { forEachChild } from "./utils/forEachChild.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { forEachChild, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
 import ts, { SyntaxKind } from "typescript";
 import { z } from "zod/v4";
 //#region src/rules/typeImports.ts

package/lib/rules/unassignedVariables.js

@@ -14,13 +14,10 @@ var unassignedVariables_default = ruleCreator.createRule(typescriptLanguage, {
 		suggestions: ["Assign a value to the variable, either at declaration or before it is used.", "If the variable is meant to be `undefined`, consider making that explicit for clarity."]
 	} },
 	setup(context) {
-		function hasAssignments(identifier, sourceFile, typeChecker) {
-			return !!getModifyingReferences(identifier, sourceFile, typeChecker).length;
-		}
-		return { visitors: { VariableDeclaration: (node, { sourceFile, typeChecker }) => {
+		return { visitors: { VariableDeclaration: (node, { sourceFile }) => {
 			if (node.initializer || node.name.kind !== SyntaxKind.Identifier) return;
 			if (node.parent.kind === SyntaxKind.VariableDeclarationList && !!(node.parent.flags & ts.NodeFlags.Const)) return;
-			if (!hasAssignments(node.name, sourceFile, typeChecker)) context.report({
+			if (!getModifyingReferences(node.name, sourceFile).length) context.report({
 				data: { name: node.name.text },
 				message: "noUnassigned",
 				range: {

package/lib/rules/utils/collectAccessorPairs.d.ts

@@ -1,5 +1,5 @@
-import type { AST } from "@flint.fyi/typescript-language";
 import ts from "typescript";
+import type { AST } from "@flint.fyi/typescript-language";
 export interface AccessorInfo {
     index: number;
     node: AST.GetAccessorDeclaration | AST.SetAccessorDeclaration;

package/lib/rules/utils/discriminateAnyType.d.ts

@@ -1,5 +1,5 @@
-import type { Checker } from "@flint.fyi/typescript-language";
 import ts from "typescript";
+import type { Checker } from "@flint.fyi/typescript-language";
 export declare const AnyType: {
     readonly Any: "any";
     readonly AnyArray: "any[]";

package/lib/rules/utils/equalityOperators.d.ts

@@ -1,5 +1,5 @@
-import type { AST } from "@flint.fyi/typescript-language";
 import { SyntaxKind } from "typescript";
+import { type AST } from "@flint.fyi/typescript-language";
 export type EqualityOperator = "!=" | "!==" | "==" | "===";
 export declare function isNullishLiteral(node: AST.Expression): boolean;
 export declare function isUndefinedIdentifier(node: AST.Expression): boolean;

package/lib/rules/utils/formatReportedType.d.ts

@@ -1,4 +1,4 @@
-import type { Checker } from "@flint.fyi/typescript-language";
 import type ts from "typescript";
+import type { Checker } from "@flint.fyi/typescript-language";
 export declare function formatReportedType(type: ts.Type, typeChecker: Checker): string;
 //# sourceMappingURL=formatReportedType.d.ts.map

package/lib/rules/utils/getRegExpConstruction.d.ts

@@ -1,5 +1,5 @@
-import { type AST, type TypeScriptFileServices } from "@flint.fyi/typescript-language";
 import ts from "typescript";
+import { type AST, type TypeScriptFileServices } from "@flint.fyi/typescript-language";
 export declare function getRegExpConstruction(node: AST.CallExpression | AST.NewExpression, { sourceFile, typeChecker }: TypeScriptFileServices): {
     args: ts.NodeArray<AST.Expression>;
     flags: string;

package/lib/rules/utils/isDirectEqualityCheck.d.ts

@@ -1,4 +1,4 @@
-import type { AST } from "@flint.fyi/typescript-language";
 import * as ts from "typescript";
+import type { AST } from "@flint.fyi/typescript-language";
 export declare function isDirectEqualityCheck(node: AST.ArrowFunction | AST.FunctionExpression, operators: ts.SyntaxKind[], parameterName: string): AST.Expression | undefined;
 //# sourceMappingURL=isDirectEqualityCheck.d.ts.map

package/lib/rules/utils/isUnsafeAssignment.d.ts

@@ -1,5 +1,5 @@
-import type { AST } from "@flint.fyi/typescript-language";
 import ts from "typescript";
+import type { AST } from "@flint.fyi/typescript-language";
 /**
  * Does a simple check to see if there is an any being assigned to a non-any type.
  *

package/lib/type-utils/getSpecifierNames.d.ts

@@ -0,0 +1,3 @@
+import type { TypeOrValueSpecifier } from "./schemas.ts";
+export declare function getSpecifierNames(specifier: TypeOrValueSpecifier): string[] | undefined;
+//# sourceMappingURL=getSpecifierNames.d.ts.map

package/lib/type-utils/getSpecifierNames.js

@@ -0,0 +1,9 @@
+//#region src/type-utils/getSpecifierNames.ts
+function getSpecifierNames(specifier) {
+	if (specifier.name === void 0) return;
+	return Array.isArray(specifier.name) ? specifier.name : [specifier.name];
+}
+//#endregion
+export { getSpecifierNames };
+
+//# sourceMappingURL=getSpecifierNames.js.map

package/lib/type-utils/isDeclaredInModuleBlock.d.ts

@@ -0,0 +1,3 @@
+import ts from "typescript";
+export declare function isDeclaredInModuleBlock(declaration: ts.Declaration, packageName: string): boolean;
+//# sourceMappingURL=isDeclaredInModuleBlock.d.ts.map

package/lib/type-utils/isDeclaredInModuleBlock.js

@@ -0,0 +1,14 @@
+import ts from "typescript";
+//#region src/type-utils/isDeclaredInModuleBlock.ts
+function isDeclaredInModuleBlock(declaration, packageName) {
+	let current = declaration;
+	while (!ts.isSourceFile(current)) {
+		if (ts.isModuleDeclaration(current) && !(current.flags & ts.NodeFlags.Namespace) && ts.isStringLiteral(current.name) && current.name.text === packageName) return true;
+		current = current.parent;
+	}
+	return false;
+}
+//#endregion
+export { isDeclaredInModuleBlock };
+
+//# sourceMappingURL=isDeclaredInModuleBlock.js.map

package/lib/type-utils/isFromFile.d.ts

@@ -0,0 +1,3 @@
+import ts from "typescript";
+export declare function isFromFile(sourceFile: ts.SourceFile, specifiedPath: string | undefined, program: ts.Program): boolean;
+//# sourceMappingURL=isFromFile.d.ts.map

package/lib/type-utils/isFromFile.js

@@ -0,0 +1,13 @@
+import ts from "typescript";
+import { pathKey } from "@flint.fyi/utils";
+import path from "node:path";
+//#region src/type-utils/isFromFile.ts
+function isFromFile(sourceFile, specifiedPath, program) {
+	if (specifiedPath === void 0) return !sourceFile.fileName.includes("/node_modules/") && !program.isSourceFileDefaultLibrary(sourceFile);
+	const caseSensitive = ts.sys.useCaseSensitiveFileNames;
+	return pathKey(sourceFile.fileName, caseSensitive) === pathKey(path.resolve(program.getCurrentDirectory(), specifiedPath), caseSensitive);
+}
+//#endregion
+export { isFromFile };
+
+//# sourceMappingURL=isFromFile.js.map

package/lib/type-utils/isFromPackage.d.ts

@@ -0,0 +1,3 @@
+import ts from "typescript";
+export declare function isFromPackage(declaration: ts.Declaration, packageName: string, program: ts.Program): boolean;
+//# sourceMappingURL=isFromPackage.d.ts.map

package/lib/type-utils/isFromPackage.js

@@ -0,0 +1,16 @@
+import { isDeclaredInModuleBlock } from "./isDeclaredInModuleBlock.js";
+import "typescript";
+//#region src/type-utils/isFromPackage.ts
+function isFromPackage(declaration, packageName, program) {
+	if (isDeclaredInModuleBlock(declaration, packageName)) return true;
+	const sourceFile = declaration.getSourceFile();
+	if (!program.isSourceFileFromExternalLibrary(sourceFile)) return false;
+	const resolvedName = program.sourceFileToPackageName.get(sourceFile.path);
+	if (resolvedName === packageName || sourceFile.fileName.includes(`/node_modules/${packageName}/`)) return true;
+	const typesPackageName = packageName.replace(/^@([^/]+)\//, "$1__");
+	return resolvedName === typesPackageName || sourceFile.fileName.includes(`/node_modules/@types/${typesPackageName}/`);
+}
+//#endregion
+export { isFromPackage };
+
+//# sourceMappingURL=isFromPackage.js.map

package/lib/type-utils/matchesSpecifier.d.ts

@@ -0,0 +1,4 @@
+import type ts from "typescript";
+import type { TypeOrValueSpecifier } from "./schemas.ts";
+export declare function matchesSpecifier(importedName: string | undefined, declarations: ts.Declaration[], specifier: TypeOrValueSpecifier, program: ts.Program): boolean;
+//# sourceMappingURL=matchesSpecifier.d.ts.map

package/lib/type-utils/matchesSpecifier.js

@@ -0,0 +1,20 @@
+import { getSpecifierNames } from "./getSpecifierNames.js";
+import { isFromFile } from "./isFromFile.js";
+import { isFromPackage } from "./isFromPackage.js";
+import { declarationIncludesGlobal } from "@flint.fyi/typescript-language";
+//#region src/type-utils/matchesSpecifier.ts
+function matchesSpecifier(importedName, declarations, specifier, program) {
+	const names = getSpecifierNames(specifier);
+	if (names !== void 0 && (importedName === void 0 || !names.includes(importedName))) return false;
+	return declarations.some((declaration) => {
+		switch (specifier.from) {
+			case "file": return isFromFile(declaration.getSourceFile(), specifier.path, program);
+			case "lib": return declarationIncludesGlobal(declaration);
+			case "package": return isFromPackage(declaration, specifier.package, program);
+		}
+	});
+}
+//#endregion
+export { matchesSpecifier };
+
+//# sourceMappingURL=matchesSpecifier.js.map

package/lib/type-utils/schemas.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/v4";
+export declare const typeOrValueSpecifierSchema: z.ZodUnion<readonly [z.ZodObject<{
+    from: z.ZodLiteral<"file">;
+    name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    from: z.ZodLiteral<"lib">;
+    name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    from: z.ZodLiteral<"package">;
+    name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    package: z.ZodString;
+}, z.core.$strip>]>;
+export type TypeOrValueSpecifier = z.infer<typeof typeOrValueSpecifierSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/lib/type-utils/schemas.js

@@ -0,0 +1,25 @@
+import { z } from "zod/v4";
+//#region src/type-utils/schemas.ts
+const fileSpecifierSchema = z.object({
+	from: z.literal("file"),
+	name: z.union([z.string(), z.array(z.string())]).optional(),
+	path: z.string().optional()
+});
+const libSpecifierSchema = z.object({
+	from: z.literal("lib"),
+	name: z.union([z.string(), z.array(z.string())]).optional()
+});
+const packageSpecifierSchema = z.object({
+	from: z.literal("package"),
+	name: z.union([z.string(), z.array(z.string())]).optional(),
+	package: z.string()
+});
+const typeOrValueSpecifierSchema = z.union([
+	fileSpecifierSchema,
+	libSpecifierSchema,
+	packageSpecifierSchema
+]);
+//#endregion
+export { typeOrValueSpecifierSchema };
+
+//# sourceMappingURL=schemas.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flint.fyi/ts",
-  "version": "0.19.1",
+  "version": "0.20.0",
   "description": "[Experimental] TypeScript language plugin for Flint.",
   "homepage": "https://flint.fyi/rules/ts",
   "repository": {
@@ -10,8 +10,8 @@
   },
   "license": "MIT",
   "author": {
-    "name": "JoshuaKGoldberg",
-    "email": "npm@joshuakgoldberg.com"
+    "name": "Flint Team",
+    "url": "https://flint.fyi/team"
   },
   "sideEffects": false,
   "type": "module",
@@ -29,14 +29,14 @@
     "ts-api-utils": "^2.4.0",
     "typescript": "^5.9.3 || ^6.0.0",
     "zod": "^4.3.6",
-    "@flint.fyi/core": "^0.22.0",
+    "@flint.fyi/core": "^0.23.0",
     "@flint.fyi/utils": "^0.14.1",
-    "@flint.fyi/typescript-language": "^0.18.2"
+    "@flint.fyi/typescript-language": "^0.18.3"
   },
   "devDependencies": {
     "tsdown": "0.21.0",
     "vitest": "4.1.0",
-    "@flint.fyi/rule-tester": "^0.16.3"
+    "@flint.fyi/rule-tester": "^0.16.4"
   },
   "engines": {
     "node": ">=24.0.0"

package/lib/rules/utils/forEachChild.d.ts

@@ -1,4 +0,0 @@
-import type { AST } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-export declare const forEachChild: <T>(node: AST.AnyNode, cbNode: (node: AST.AnyNode) => T | undefined, cbNodes?: (nodes: ts.NodeArray<AST.AnyNode>) => T | undefined) => T | undefined;
-//# sourceMappingURL=forEachChild.d.ts.map

package/lib/rules/utils/forEachChild.js

@@ -1,7 +0,0 @@
-import ts from "typescript";
-//#region src/rules/utils/forEachChild.ts
-const forEachChild = ts.forEachChild;
-//#endregion
-export { forEachChild };
-
-//# sourceMappingURL=forEachChild.js.map