@@ -2,4 +2,4 @@
 "webpack": patch
 ---
 
-Inherit sideEffects past type-only nested package.json under node_modules.
+Inherit sideEffects past a type-only nested package.json for files under node_modules.
@@ -38,17 +38,6 @@ const getUnsupportedFeatureWarning = memoize(() =>
  * 	Property
  * } from "estree"
  */
-/** @typedef {import("../ContextModule").ContextModuleOptions} ContextModuleOptions */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").ObjectExpression} ObjectExpression */
-/** @typedef {import("estree").Property} Property */
-/** @typedef {import("./ImportMetaGlobDependency").ImportMetaGlobDependencyOptions} ImportMetaGlobDependencyOptions */
-
 /**
  * @typedef {object} ParsedImportMetaGlobOptions
  * @property {string[]} patterns patterns
 
@@ -19,6 +19,7 @@ const formatLocation = require("../util/formatLocation");
 const { dirname, join, readJson, relative } = require("../util/fs");
 const { getGlobToRegExpSource } = require("../util/globUtils");
 const {
+	NODE_MODULES_REGEXP,
 	WINDOWS_PATH_SEPARATOR_REGEXP,
 	relativePathToRequest
 } = require("../util/identifier");
@@ -43,6 +44,8 @@ const { CompilerHintNotationRegExp } = require("../util/magicComment");
 /** @import ModuleGraphConnection from "../ModuleGraphConnection" */
 /** @import { ExportInfo, TargetItemWithConnection } from "../ExportsInfo" */
 /** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
+/** @import { InputFileSystem } from "../util/fs" */
+/** @import { CreateData, ResolveData } from "../NormalModuleFactory" */
 /**
  * @import {
  * 	JavascriptParserOptions
@@ -57,9 +60,7 @@ const { CompilerHintNotationRegExp } = require("../util/magicComment");
  * @property {boolean} checked if the export is conditional
  */
 
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("../util/fs").JsonObject} JsonObject */
-/** @typedef {import("../NormalModuleFactory").CreateData} CreateData */
+/** @typedef {NonNullable<CreateData["resourceResolveData"]>} ResourceResolveData */
 
 /** @typedef {string | boolean | string[] | undefined} SideEffectsFlagValue */
 
@@ -72,14 +73,21 @@ const { CompilerHintNotationRegExp } = require("../util/magicComment");
  */
 
 /**
- * Owning-package sideEffects resolution cached per descriptionFileRoot.
- * `null` means the walk finished with no applicable flag.
  * @typedef {object} OwningSideEffectsFlag
  * @property {SideEffectsFlagValue} sideEffects package.json sideEffects value
  * @property {string} packageRoot directory of the declaring package.json
  */
 
-/** @typedef {Map<string, OwningSideEffectsFlag | null>} OwningSideEffectsFlagCache */
+/**
+ * A finished ancestor walk, kept per descriptionFileRoot. The package.json
+ * paths it consulted are replayed as dependencies for every module reusing it.
+ * @typedef {object} OwningSideEffectsFlagWalk
+ * @property {OwningSideEffectsFlag | null} owning declaring package, `null` when the walk found none
+ * @property {string[]} read package.json files the walk read
+ * @property {string[]} missing package.json files the walk did not find
+ */
+
+/** @typedef {Map<string, OwningSideEffectsFlagWalk>} OwningSideEffectsFlagCache */
 
 /**
  * Whether a resolved re-export target is reached through an `import defer` edge.
@@ -98,30 +106,21 @@ const isDeferredTargetConnection = (connection) =>
 /** @type {WeakMap<Compiler, CacheItem>} */
 const globToRegexpCache = new WeakMap();
 
-/** @type {WeakMap<EXPECTED_OBJECT, OwningSideEffectsFlagCache>} */
+/** @type {WeakMap<Compiler, OwningSideEffectsFlagCache>} */
 const owningSideEffectsFlagCache = new WeakMap();
 
 /** @type {WeakMap<Partial<CreateData>, ResolvedSideEffectsFlag>} */
 const resolvedSideEffectsFlags = new WeakMap();
 
 /**
- * Ancestor package.json read failures that must not fail unrelated modules.
+ * Whether a failed ancestor package.json read means nothing is there, as
+ * opposed to something being there that cannot be used.
  * @param {NodeJS.ErrnoException | SyntaxError | Error} err error from readJson
- * @returns {boolean} true when the walk should skip this directory
+ * @returns {boolean} true when no file was found at that path
  */
-const isSkippablePackageJsonError = (err) => {
-	if (err instanceof SyntaxError) return true;
-	if (!("code" in err)) return false;
-	switch (err.code) {
-		case "ENOENT":
-		case "ENOTDIR":
-		case "EISDIR":
-		case "ENAMETOOLONG":
-			return true;
-		default:
-			return false;
-	}
-};
+const isMissingPackageJsonError = (err) =>
+	"code" in err && err.code === "ENOENT";
+
 /**
  * Returns a regular expression.
  * @param {string} glob the pattern
@@ -166,26 +165,33 @@ const notSideEffectsTag = Symbol("NoSideEffects");
 const RETURNS_FALSE = () => false;
 
 /**
- * Resolve sideEffects from the owning package, inheriting past type-only nested
- * package.json under node_modules. Globs are matched relative to that package root.
+ * Resolve sideEffects from the package that declares it, inheriting past a nested
+ * package.json that declares none. Globs are rebased on the declaring package root,
+ * and each package.json the walk consults becomes a dependency of the resolve.
  * @param {InputFileSystem} fs file system
+ * @param {ResolveData} resolveData resolve data
  * @param {string} descriptionFileRoot root directory of the nearest description file
- * @param {JsonObject} descriptionFileData nearest description file data
- * @param {string} relativePath path relative to descriptionFileRoot
  * @param {OwningSideEffectsFlagCache} owningCache walk cache keyed by descriptionFileRoot
- * @param {(err?: null | Error, result?: ResolvedSideEffectsFlag) => void} callback callback
+ * @param {(result?: ResolvedSideEffectsFlag) => void} callback callback
  * @returns {void}
  */
 const resolveSideEffectsFlag = (
 	fs,
+	resolveData,
 	descriptionFileRoot,
-	descriptionFileData,
-	relativePath,
 	owningCache,
 	callback
 ) => {
+	const resolveInfo = /** @type {ResourceResolveData} */ (
+		resolveData.createData.resourceResolveData
+	);
+	const descriptionFileData =
+		/** @type {NonNullable<ResourceResolveData["descriptionFileData"]>} */ (
+			resolveInfo.descriptionFileData
+		);
+	const relativePath = /** @type {string} */ (resolveInfo.relativePath);
 	if (descriptionFileData.sideEffects !== undefined) {
-		return callback(null, {
+		return callback({
 			sideEffects: /** @type {SideEffectsFlagValue} */ (
 				descriptionFileData.sideEffects
 			),
@@ -196,82 +202,99 @@ const resolveSideEffectsFlag = (
 	if (descriptionFileData.name !== undefined) {
 		return callback();
 	}
-	// Only inherit inside node_modules; app-local nests must keep shadowing parents.
-	const normalizedRoot = descriptionFileRoot.replace(
-		WINDOWS_PATH_SEPARATOR_REGEXP,
-		"/"
-	);
-	if (!/(?:^|\/)node_modules(?:\/|$)/.test(normalizedRoot)) {
+	// Only inherit for a file living under node_modules; app-local nests keep shadowing.
+	// Read the resolved path so a symlinked package flags all of its files alike.
+	if (
+		typeof resolveInfo.path !== "string" ||
+		!NODE_MODULES_REGEXP.test(resolveInfo.path)
+	) {
 		return callback();
 	}
 
+	// stays in descriptionFileRoot's space, which is the space packageRoot is found in
 	const resourcePath = join(fs, descriptionFileRoot, relativePath);
 
 	/**
-	 * @param {OwningSideEffectsFlag | null} owning owning package flag or null
+	 * @param {OwningSideEffectsFlagWalk} walk finished walk
 	 * @returns {void}
 	 */
-	const finishFromOwning = (owning) => {
+	const finishFromWalk = (walk) => {
+		for (const file of walk.read) resolveData.fileDependencies.add(file);
+		for (const file of walk.missing) resolveData.missingDependencies.add(file);
+		const owning = walk.owning;
 		if (owning === null) return callback();
 		const ancestorRelative = relative(
 			fs,
 			owning.packageRoot,
 			resourcePath
 		).replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/");
-		return callback(null, {
+		return callback({
 			sideEffects: owning.sideEffects,
 			relativePath: relativePathToRequest(ancestorRelative)
 		});
 	};
 
 	const cached = owningCache.get(descriptionFileRoot);
 	if (cached !== undefined) {
-		return finishFromOwning(cached);
+		return finishFromWalk(cached);
 	}
 
+	/** @type {string[]} */
+	const read = [];
+	/** @type {string[]} */
+	const missing = [];
+
+	/**
+	 * @param {OwningSideEffectsFlag | null} owning declaring package or null
+	 * @returns {void}
+	 */
+	const done = (owning) => {
+		/** @type {OwningSideEffectsFlagWalk} */
+		const walk = { owning, read, missing };
+		owningCache.set(descriptionFileRoot, walk);
+		return finishFromWalk(walk);
+	};
+
 	let dir = dirname(fs, descriptionFileRoot);
 
 	const next = () => {
 		const parent = dirname(fs, dir);
-		if (!parent || parent === dir) {
-			owningCache.set(descriptionFileRoot, null);
-			return callback();
-		}
+		if (!parent || parent === dir) return done(null);
 		const baseName = relative(fs, parent, dir).replace(
 			WINDOWS_PATH_SEPARATOR_REGEXP,
 			"/"
 		);
 		// Do not inherit an application's sideEffects across an install boundary.
-		if (baseName === "node_modules") {
-			owningCache.set(descriptionFileRoot, null);
-			return callback();
-		}
+		if (baseName === "node_modules") return done(null);
 
-		readJson(fs, join(fs, dir, "package.json"), (err, data) => {
+		const packageJsonPath = join(fs, dir, "package.json");
+
+		readJson(fs, packageJsonPath, (err, data) => {
 			if (err) {
-				if (isSkippablePackageJsonError(err)) {
-					dir = parent;
-					return next();
+				if (!isMissingPackageJsonError(err)) {
+					// it is there but unreadable, so what it declares is unknown:
+					// decline rather than let an outer flag speak for it
+					read.push(packageJsonPath);
+					return done(null);
 				}
-				return callback(err);
+				missing.push(packageJsonPath);
+				dir = parent;
+				return next();
 			}
+			read.push(packageJsonPath);
 			if (!data || typeof data !== "object" || Array.isArray(data)) {
 				dir = parent;
 				return next();
 			}
 			if (data.sideEffects !== undefined) {
-				/** @type {OwningSideEffectsFlag} */
-				const owning = {
+				return done({
 					sideEffects: /** @type {SideEffectsFlagValue} */ (data.sideEffects),
 					packageRoot: dir
-				};
-				owningCache.set(descriptionFileRoot, owning);
-				return finishFromOwning(owning);
-			}
-			if (data.name !== undefined) {
-				owningCache.set(descriptionFileRoot, null);
-				return callback();
+				});
 			}
+			// An unnamed manifest deeper in the package keeps the walk going; a named one
+			// is a package of its own, and its silence is its answer.
+			if (data.name !== undefined) return done(null);
 			dir = parent;
 			next();
 		});
@@ -359,12 +382,10 @@ class SideEffectsFlagPlugin {
 						if (descriptionFileRoot === undefined) return callback();
 						resolveSideEffectsFlag(
 							inputFileSystem,
+							resolveData,
 							descriptionFileRoot,
-							resolveInfo.descriptionFileData,
-							resolveInfo.relativePath,
 							owningCache,
-							(err, resolved) => {
-								if (err) return callback(err);
+							(resolved) => {
 								if (resolved !== undefined) {
 									resolvedSideEffectsFlags.set(createData, resolved);
 								}
 
@@ -0,0 +1,23 @@
+import { light } from "symlinked-sef";
+
+const SYMLINKED_HEAVY = ["HEAVY", "SYMLINKED", "WORKSPACE"].join("_");
+
+/**
+ * @param {string} marker
+ * @returns {boolean}
+ */
+function moduleSourceIncludes(marker) {
+	return Object.keys(__webpack_modules__).some((id) =>
+		String(__webpack_modules__[id]).includes(marker)
+	);
+}
+
+it("still runs the used export", () => {
+	expect(light).toBe("light");
+});
+
+it("flags every file of a symlinked package alike", () => {
+	// The package request arrives through node_modules and its own imports through
+	// the real path; reading the resolved file keeps both on one answer.
+	expect(moduleSourceIncludes(SYMLINKED_HEAVY)).toBe(true);
+});
@@ -0,0 +1,4 @@
+{
+  "name": "nested-package-json-sideEffects-symlinked",
+  "sideEffects": false
+}
@@ -0,0 +1,6 @@
+export var HeavyMode;
+(function (HeavyMode) {
+	HeavyMode[(HeavyMode.A = 0)] = "A";
+})(HeavyMode || (HeavyMode = {}));
+
+export const heavy = "HEAVY_SYMLINKED_WORKSPACE";
@@ -0,0 +1,8 @@
+import { heavy } from "./heavy.js";
+import { light } from "./light.js";
+
+export function useHeavy() {
+	return heavy;
+}
+
+export { light, heavy };
@@ -0,0 +1 @@
+export const light = "light";
@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}
@@ -0,0 +1,11 @@
+{
+  "name": "symlinked-sef",
+  "version": "1.0.0",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "default": "./esm/index.js"
+    }
+  }
+}
-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +{
 +  "name": "nested-package-json-sideEffects-symlinked",
 +  "sideEffects": false
 +}