@@ -1702,6 +1702,12 @@ class JavascriptModulesPlugin {
 						buf2.push(
 							"// This entry module is referenced by other modules so it can't be inlined"
 						);
+						// Its exports are then read off the exports object, and a property
+						// read is not something a consumer of the bundle can drop.
+						runtimeTemplate.analyzableBailout(
+							entryModule,
+							"the entry is referenced by other modules, so its exports are read off the exports object and a consumer cannot drop them"
+						);
 						result.allowInlineStartup = false;
 					}
 
 
@@ -830,6 +830,16 @@ class RuntimeTemplate {
 		return true;
 	}
 
+	/**
+	 * Reports an analyzable-ESM bailout from outside this class.
+	 * @param {Module | undefined} module the module the reference is emitted into
+	 * @param {string} reason why no literal could be baked
+	 * @returns {void}
+	 */
+	analyzableBailout(module, reason) {
+		this._analyzableBailout(module, reason);
+	}
+
 	/**
 	 * Records why a reference kept the runtime form, on the module that wrote it —
 	 * the channel `ModuleConcatenationPlugin` already reports through, so it reaches
 
@@ -0,0 +1,19 @@
+import { helper } from "./refs-entry.js";
+
+export const value = 42;
+
+it("should still compute", () => {
+	expect(helper()).toBe(42);
+});
+
+it("should report why the entry's exports cannot be dropped", () => {
+	const entry = __STATS__.modules.find((module) =>
+		module.name.endsWith("index.js")
+	);
+
+	expect(entry.optimizationBailout).toContainEqual(
+		expect.stringContaining(
+			"Analyzable ESM bailout: the entry is referenced by other modules"
+		)
+	);
+});
@@ -0,0 +1,7 @@
+// Importing the entry back keeps webpack from inlining it, which is what the
+// bailout below reports.
+import { value } from "./index.js";
+
+export function helper() {
+	return value;
+}
@@ -0,0 +1,19 @@
+"use strict";
+
+/** @type {import("../../../../types").Configuration} */
+module.exports = {
+	target: "node",
+	mode: "production",
+	output: {
+		filename: "bundle0.mjs",
+		library: { type: "module" },
+		module: true
+	},
+	optimization: {
+		// Concatenation would pull the referencing module in and leave the entry
+		// inlinable, which is the case that needs no report.
+		concatenateModules: false
+	},
+	stats: { optimizationBailout: true },
+	experiments: { outputModule: true }
+};
@@ -26582,6 +26582,11 @@ declare abstract class RuntimeTemplate {
 		runtime?: RuntimeSpec
 	): boolean;
 
+	/**
+	 * Reports an analyzable-ESM bailout from outside this class.
+	 */
+	analyzableBailout(module: undefined | Module, reason: string): void;
+
 	/**
 	 * Names the module whose code generation starts, so the reasons its references
 	 * record are handed back by `finishAnalyzableBailouts` and attributed to it.