@@ -1650,6 +1650,7 @@ class NormalModule extends Module {
 			pureFunctions: undefined,
 			inlineExports: undefined,
 			stableExports: undefined,
+			classHeritageNames: undefined,
 			moduleConcatenationBailout: undefined,
 			moduleConcatenationRootBailout: undefined,
 			needCreateRequire: undefined,
 
@@ -234,16 +234,27 @@ class HarmonyImportDependencyParserPlugin {
 			this.options.sourceImport
 		);
 
-		// Parsers are reused across modules, so both are reset per program.
+		// Parsers are reused across modules, so all three are reset per program.
 		/** @type {HarmonySettings[]} */
 		const declaredSpecifiers = [];
+		/** @type {Set<string>} */
+		const classHeritageNames = new Set();
 		/** @type {HarmonyImportSideEffectDependency | undefined} */
 		let lastSideEffectDependency;
 
 		parser.hooks.program.tap(PLUGIN_NAME, () => {
 			declaredSpecifiers.length = 0;
+			classHeritageNames.clear();
 			lastSideEffectDependency = undefined;
 		});
+		// The heritage clause is walked before the class name enters scope, so a
+		// reference to that name resolves here to whatever the enclosing scope has.
+		parser.hooks.classExtendsExpression.tap(
+			PLUGIN_NAME,
+			(_expression, classy) => {
+				if (classy.id) classHeritageNames.add(classy.id.name);
+			}
+		);
 		parser.hooks.finish.tap(PLUGIN_NAME, () => {
 			for (const settings of declaredSpecifiers) {
 				const dependency = settings.dependency;
@@ -268,7 +279,14 @@ class HarmonyImportDependencyParserPlugin {
 					settings.name
 				]);
 			}
+			if (classHeritageNames.size > 0) {
+				/** @type {JavascriptModuleBuildInfo} */
+				(parser.state.module.buildInfo).classHeritageNames = new Set(
+					classHeritageNames
+				);
+			}
 			declaredSpecifiers.length = 0;
+			classHeritageNames.clear();
 			lastSideEffectDependency = undefined;
 		});
 
 
@@ -36,6 +36,7 @@ const { ImportPhaseUtils } = require("./ImportPhase");
 /** @import { GetConditionFn, ReferencedExports } from "../Dependency" */
 /** @import { DependencyTemplateContext } from "../DependencyTemplate" */
 /** @import Module, { BuildMeta } from "../Module" */
+/** @import { JavascriptModuleBuildInfo } from "../javascript/JavascriptModule" */
 /** @import ModuleGraph from "../ModuleGraph" */
 /**
  * @import ModuleGraphConnection, {
@@ -772,6 +773,18 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 			return;
 		}
 		if (!isDeclarableBindingName(dep.name)) return;
+		// A class heritage clause reads the class' own binding, which is in its
+		// temporal dead zone there, so only a name user code cannot bind survives.
+		const originBuildInfo =
+			/** @type {JavascriptModuleBuildInfo | undefined} */
+			(/** @type {Module} */ (module).buildInfo);
+		if (
+			originBuildInfo !== undefined &&
+			originBuildInfo.classHeritageNames !== undefined &&
+			originBuildInfo.classHeritageNames.has(dep.name)
+		) {
+			return;
+		}
 		const importedModule = connection && connection.module;
 		if (!importedModule) return;
 		if (
 
@@ -25,6 +25,7 @@ const makeSerializable = require("../util/makeSerializable");
  * @property {Set<string>=} pureFunctions names of locally declared functions known to be free of side effects
  * @property {boolean=} inlineExports whether this module was parsed with `optimization.inlineExports` enabled (gates inlining of its exports)
  * @property {Set<string>=} stableExports names of own exports the language pins to one value, so an importer may read them into a local binding
+ * @property {Set<string>=} classHeritageNames names a class binds while its own heritage clause is parsed in the enclosing scope, so a reference there resolves to the class at runtime but to the outer name here
  * @property {boolean=} usesTopLevelUsingDeclaration module scope holds a `using`/`await using` declaration, so its resources must be disposed when the module finished evaluating
  */
 
 
@@ -0,0 +1,2 @@
+export const Base = class Base {};
+export const Untouched = "untouched";
@@ -0,0 +1,13 @@
+import { Base, Untouched } from "./exports";
+
+const extend = (fn) => class Base extends fn(Base) {};
+const selfExtend = () => class Untouched extends Object {};
+
+it("should not capture a heritage reference with the class' own name", () => {
+	expect(new (extend((x) => x))()).toBeInstanceOf(Base);
+});
+
+it("should read the import where no class shadows the name", () => {
+	expect(Untouched).toBe("untouched");
+	expect(typeof selfExtend()).toBe("function");
+});
@@ -0,0 +1,11 @@
+"use strict";
+
+/** @type {import("../../../../").Configuration} */
+module.exports = {
+	mode: "development",
+	devtool: false,
+	optimization: {
+		localImportBindings: true,
+		concatenateModules: false
+	}
+};
@@ -15251,6 +15251,11 @@ declare interface KnownJavascriptModuleBuildInfo {
 	 */
 	stableExports?: Set<string>;
 
+	/**
+	 * names a class binds while its own heritage clause is parsed in the enclosing scope, so a reference there resolves to the class at runtime but to the outer name here
+	 */
+	classHeritageNames?: Set<string>;
+
 	/**
 	 * module scope holds a `using`/`await using` declaration, so its resources must be disposed when the module finished evaluating
 	 */
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+export const Base = class Base {};`
	`2`	`+export const Untouched = "untouched";`