styled-components-to-stylex-codemod 0.0.56 → 0.0.57

package/README.md

@@ -384,7 +384,7 @@ await runTransform({
 
 ### Planning manual conversions
 
-`analyzeMigrationPlan` runs the codemod in analysis-only mode (it never writes files) and returns the bottom-up ordered list of files you must convert by hand — the genuine blockers the codemod can't convert — each with its consumer count, the exports to convert, how many files it unblocks, and the bail reasons. `formatMigrationPlan` renders it as a report (high-impact files first).
+`analyzeMigrationPlan` runs the codemod in analysis-only mode (it never writes files) and returns the bottom-up ordered list of files you must convert by hand — the genuine blockers the codemod can't convert — each with its consumer count, the exports to convert, direct auto-migration payoff, secondary blocker-chain context, and the bail reasons. `formatMigrationPlan` renders it as a report with direct unlocks emphasized first so raw chain involvement is not mistaken for files unlocked by one blocker alone.
 
 ```ts
 import { analyzeMigrationPlan, formatMigrationPlan } from "styled-components-to-stylex-codemod";

package/dist/{ast-walk-CLvMH7Lm.mjs → ast-walk-DVmYZ2mK.mjs}

@@ -1,7 +1,60 @@
 import { n as isTemplatePlaceholderInSelectorContext, r as PLACEHOLDER_RE } from "./selector-context-heuristic-Dptd93Xe.mjs";
-import path, { resolve } from "node:path";
+import path, { relative, resolve } from "node:path";
 import { readFileSync } from "node:fs";
 import { parse } from "@babel/parser";
+//#region src/internal/utilities/ast-safety.ts
+/**
+* AST safety checks for null nodes and structural issues.
+* Core concepts: recursive validation and error reporting.
+*/
+/**
+* `JSON.stringify` replacer that drops noisy AST positional metadata
+* (`loc`/`tokens`/`comments`/`start`/`end`) and replaces circular references
+* with `"[Circular]"`, so AST nodes can be serialized for logging or as a
+* stable structural key. Create a fresh replacer per `stringify` call — it
+* keeps per-serialization state.
+*/
+function createAstSafeJsonReplacer() {
+	const seen = /* @__PURE__ */ new WeakSet();
+	return (key, value) => {
+		if (key === "loc" || key === "tokens" || key === "comments" || key === "start" || key === "end") return;
+		if (value && typeof value === "object") {
+			if (seen.has(value)) return "[Circular]";
+			seen.add(value);
+		}
+		return value;
+	};
+}
+/** AST node types whose `elements` array legitimately contains `null` (holes/elisions). */
+const ARRAY_ELEMENT_HOLE_TYPES = new Set(["ArrayPattern", "ArrayExpression"]);
+function assertNoNullNodesInArrays(node) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const visit = (cur, path, allowNulls) => {
+		if (cur === null || cur === void 0) return;
+		if (Array.isArray(cur)) {
+			for (let i = 0; i < cur.length; i++) {
+				if (cur[i] === null) {
+					if (!allowNulls) throw new Error(`Null AST node in array at ${path}[${i}]`);
+					continue;
+				}
+				visit(cur[i], `${path}[${i}]`, false);
+			}
+			return;
+		}
+		if (typeof cur !== "object") return;
+		const curObj = cur;
+		if (seen.has(curObj)) return;
+		seen.add(curObj);
+		const nodeType = cur.type;
+		const hasValidElementHoles = typeof nodeType === "string" && ARRAY_ELEMENT_HOLE_TYPES.has(nodeType);
+		for (const [k, v] of Object.entries(cur)) {
+			if (v === null) continue;
+			if (typeof v === "object") visit(v, `${path}.${k}`, hasValidElementHoles && k === "elements");
+		}
+	};
+	visit(node, "root", false);
+}
+//#endregion
 //#region src/internal/logger.ts
 /**
 * Logger and warning types for transform diagnostics.
@@ -132,20 +185,9 @@ var Logger = class Logger {
 	}
 	static formatContext(context) {
 		if (typeof context === "undefined") return null;
-		return JSON.stringify(context, createContextReplacer(), 2);
+		return JSON.stringify(context, createAstSafeJsonReplacer(), 2);
 	}
 };
-function createContextReplacer() {
-	const seen = /* @__PURE__ */ new WeakSet();
-	return (key, value) => {
-		if (key === "loc" || key === "tokens" || key === "comments" || key === "start" || key === "end") return;
-		if (value && typeof value === "object") {
-			if (seen.has(value)) return "[Circular]";
-			seen.add(value);
-		}
-		return value;
-	};
-}
 const MAX_DEPENDED_FILE_GROUPS = 15;
 var LoggerReport = class {
 	warnings;
@@ -785,6 +827,31 @@ function isCssTag(tag, cssImportNames) {
 	if (!tag || !cssImportNames || cssImportNames.size === 0) return false;
 	return tag.type === "Identifier" && typeof tag.name === "string" && cssImportNames.has(tag.name);
 }
+/**
+* Build the shared `DEBUG_CODEMOD` report lines for cross-file prepass info.
+* `header` distinguishes the standalone scan from the unified prepass; callers
+* may append their own sections before writing.
+*/
+function buildCrossFileDebugLines(header, scannedFiles, info) {
+	const cwd = process.cwd();
+	const rel = (p) => relative(cwd, p);
+	const lines = [header];
+	lines.push(`  Scanned ${scannedFiles.length} file(s)`);
+	if (info.selectorUsages.size === 0) lines.push("  No cross-file selector usages found.");
+	else {
+		lines.push(`  Found cross-file selector usages in ${info.selectorUsages.size} file(s):`);
+		for (const [consumer, usages] of info.selectorUsages) for (const u of usages) lines.push(`    ${rel(consumer)} → ${u.importedName} (from ${rel(u.resolvedPath)}, transformed=${u.consumerIsTransformed})`);
+	}
+	if (info.componentsNeedingMarkerSidecar.size > 0) {
+		lines.push("  Components needing marker sidecar (both consumer and target transformed):");
+		for (const [file, names] of info.componentsNeedingMarkerSidecar) lines.push(`    ${rel(file)}: ${[...names].join(", ")}`);
+	}
+	if (info.componentsNeedingGlobalSelectorBridge.size > 0) {
+		lines.push("  Components needing global selector bridge className (consumer not transformed):");
+		for (const [file, names] of info.componentsNeedingGlobalSelectorBridge) lines.push(`    ${rel(file)}: ${[...names].join(", ")}`);
+	}
+	return lines;
+}
 /** Safely extract the name string from an AST identifier-like node. */
 function getNodeName(node) {
 	if (!node || typeof node !== "object") return;
@@ -811,22 +878,6 @@ function deduplicateAndResolve(filesToTransform, consumerPaths) {
 	return result;
 }
 //#endregion
-//#region src/internal/utilities/default-export-name.ts
-/**
-* Regex helpers for inspecting a module's default export by source text.
-*
-* These operate on raw source strings (not the AST) so they can be shared by
-* both prepass and transform-step layers without import-graph coupling.
-*/
-/**
-* Returns the local name of a PascalCase default export, supporting both
-* `export default Name` and `export { Name as default }` forms. Returns
-* `undefined` when no PascalCase default export is found.
-*/
-function findDefaultExportedLocalName(source) {
-	return source.match(/\bexport\s+default\s+([A-Z][A-Za-z0-9]*)\b/)?.[1] ?? source.match(/\bexport\s*\{[^}]*\b([A-Z][A-Za-z0-9]*)\s+as\s+default\b[^}]*\}/)?.[1];
-}
-//#endregion
 //#region src/internal/utilities/ast-walk.ts
 const SKIPPED_KEYS = new Set([
 	"loc",
@@ -852,4 +903,4 @@ function walkAst(root, visitor) {
 	visit(root);
 }
 //#endregion
-export { PARTIAL_MIGRATION_INCOMPLETE_WARNING as C, Logger as S, getCascadeDependedFilePath as T, findImportSource as _, buildImportMapFromNodes as a, resolveBarrelReExportBinding as b, deduplicateAndResolve as c, findStyledImportNameFromNodes as d, walkForImportsAndTemplates as f, fileImportsFrom as g, fileExports as h, applyBridgeFields as i, findComponentSelectorLocalsFromNodes as l, createPrepassParser as m, findDefaultExportedLocalName as n, categorizeSelectorUsages as o, addToSetMap as p, BARE_TEMPLATE_IDENTIFIER_RE as r, collectStyledLocalBindingNames as s, walkAst as t, findCssImportNamesFromNodes as u, getReExportedSourceName as v, UNSUPPORTED_SHOULD_FORWARD_PROP_WARNING as w, CASCADE_CONFLICT_WARNING as x, resolveBarrelReExport as y };
+export { PARTIAL_MIGRATION_INCOMPLETE_WARNING as C, createAstSafeJsonReplacer as D, assertNoNullNodesInArrays as E, Logger as S, getCascadeDependedFilePath as T, findImportSource as _, buildImportMapFromNodes as a, resolveBarrelReExportBinding as b, deduplicateAndResolve as c, findStyledImportNameFromNodes as d, walkForImportsAndTemplates as f, fileImportsFrom as g, fileExports as h, buildCrossFileDebugLines as i, findComponentSelectorLocalsFromNodes as l, createPrepassParser as m, BARE_TEMPLATE_IDENTIFIER_RE as n, categorizeSelectorUsages as o, addToSetMap as p, applyBridgeFields as r, collectStyledLocalBindingNames as s, walkAst as t, findCssImportNamesFromNodes as u, getReExportedSourceName as v, UNSUPPORTED_SHOULD_FORWARD_PROP_WARNING as w, CASCADE_CONFLICT_WARNING as x, resolveBarrelReExport as y };

package/dist/{bridge-consumer-patcher-B__X3jOg.mjs → bridge-consumer-patcher-jeeDUlId.mjs}

@@ -1,6 +1,6 @@
 import { t as isSelectorContext } from "./selector-context-heuristic-Dptd93Xe.mjs";
-import { r as toRealPath } from "./path-utils-ByFNVtHo.mjs";
-import { r as escapeRegex } from "./string-utils-4eeXGa48.mjs";
+import { r as toRealPath } from "./path-utils-BC4U8X_q.mjs";
+import { r as escapeRegex } from "./string-utils-Bo3cWgss.mjs";
 import { readFileSync } from "node:fs";
 //#region src/internal/bridge-consumer-patcher.ts
 /**

package/dist/{forwarded-as-consumer-patcher-Bs9ymhBa.mjs → forwarded-as-consumer-patcher-Do4PI4Qs.mjs}

@@ -1,5 +1,5 @@
-import { r as toRealPath } from "./path-utils-ByFNVtHo.mjs";
-import { r as escapeRegex } from "./string-utils-4eeXGa48.mjs";
+import { r as toRealPath } from "./path-utils-BC4U8X_q.mjs";
+import { r as escapeRegex } from "./string-utils-Bo3cWgss.mjs";
 import { readFileSync } from "node:fs";
 //#region src/internal/forwarded-as-consumer-patcher.ts
 /**

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as CollectedWarning, c as MarkerFileContext, l as defineAdapter, n as TransformMode, o as AdapterInput, s as ImportSource } from "./transform-types-BGGNjb8R.mjs";
+import { a as ImportSource, i as AdapterInput, o as MarkerFileContext, s as defineAdapter, t as CollectedWarning } from "./logger-ByYsVkrB.mjs";
 
 //#region src/run.d.ts
 interface RunTransformOptions {
@@ -69,17 +69,6 @@ interface RunTransformOptions {
    * @default false
    */
   silent?: boolean;
-  /**
-   * Controls which styled declarations are eligible for conversion.
-   *
-   * - `"all"` converts every supported styled declaration.
-   * - `"leavesOnly"` only converts declarations whose render base is intrinsic
-   *   after adapter resolution, or that wrap another leaf styled declaration in
-   *   the transform run (including cross-file imports).
-   *
-   * @default "all"
-   */
-  transformMode?: TransformMode;
   /**
    * When true, allow the codemod to leave individual styled declarations as-is when
    * they hit an unsupported pattern while transforming the rest of the file. This

package/dist/index.mjs

@@ -1,14 +1,173 @@
 import { t as createModuleResolver } from "./resolve-imports-DgSAddIF.mjs";
-import { $ as describeValue, Q as assertValidAdapterInput, Y as defineAdapter, q as mergeMarkerDeclarations, t as transformedComponentAcceptsSx, x as identifierName } from "./sx-surface-_Hjc6ZDq.mjs";
-import { S as Logger, T as getCascadeDependedFilePath, a as buildImportMapFromNodes, b as resolveBarrelReExportBinding, f as walkForImportsAndTemplates, m as createPrepassParser, t as walkAst, y as resolveBarrelReExport } from "./ast-walk-CLvMH7Lm.mjs";
-import { n as extractStyledDefBases } from "./compute-leaf-set-D5GvkV-H.mjs";
-import { r as toRealPath } from "./path-utils-ByFNVtHo.mjs";
+import { $ as assertValidAdapterInput, J as mergeMarkerDeclarations, X as defineAdapter, et as describeValue, t as transformedComponentAcceptsSx, x as identifierName } from "./sx-surface-Kv8zK8L4.mjs";
+import { S as Logger, T as getCascadeDependedFilePath, a as buildImportMapFromNodes, b as resolveBarrelReExportBinding, f as walkForImportsAndTemplates, m as createPrepassParser, s as collectStyledLocalBindingNames, t as walkAst, y as resolveBarrelReExport } from "./ast-walk-DVmYZ2mK.mjs";
+import { r as toRealPath } from "./path-utils-BC4U8X_q.mjs";
 import jscodeshift from "jscodeshift";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { dirname, join, relative, resolve } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { glob, readFile, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
+//#region src/internal/prepass/styled-def-bases.ts
+/**
+* Extracts styled-component definition bases for prepass consumers that need
+* component names and their root shape.
+*/
+const RX_EXPORT_DECL = String.raw`(?:export\s+)?(?:const|let|var)\s+`;
+/** `const Name = styled.tag` — intrinsic HTML/SVG tag member. */
+const STYLED_INTRINSIC_MEMBER_RE = new RegExp(String.raw`\b${RX_EXPORT_DECL}([A-Z][A-Za-z0-9]*)\b[^=]*=\s*styled\.([a-z][a-zA-Z0-9]*)\b`, "g");
+/** `const Name = styled("tag")` — intrinsic string tag. */
+const STYLED_INTRINSIC_STRING_RE = new RegExp(String.raw`\b${RX_EXPORT_DECL}([A-Z][A-Za-z0-9]*)\b[^=]*=\s*styled\s*\(\s*["']([^"']+)["']`, "g");
+/** `const Name = styled(Component)` — wraps another component identifier. */
+const STYLED_COMPONENT_RE = new RegExp(String.raw`\b${RX_EXPORT_DECL}([A-Z][A-Za-z0-9]*)\b[^=]*=\s*styled\s*\(\s*([A-Z][A-Za-z0-9]*)\s*\)`, "g");
+/**
+* Regex-derived styled definition bases for files in the transform set.
+* Later entries for the same component name overwrite earlier ones (rare).
+*/
+function extractStyledDefBasesFromSource(filePath, source, into) {
+	let map = into.get(filePath);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		into.set(filePath, map);
+	}
+	STYLED_INTRINSIC_MEMBER_RE.lastIndex = 0;
+	for (const m of source.matchAll(STYLED_INTRINSIC_MEMBER_RE)) {
+		const name = m[1];
+		if (name) map.set(name, { kind: "intrinsic" });
+	}
+	STYLED_INTRINSIC_STRING_RE.lastIndex = 0;
+	for (const m of source.matchAll(STYLED_INTRINSIC_STRING_RE)) {
+		const name = m[1];
+		if (name) map.set(name, { kind: "intrinsic" });
+	}
+	STYLED_COMPONENT_RE.lastIndex = 0;
+	for (const m of source.matchAll(STYLED_COMPONENT_RE)) {
+		const name = m[1];
+		const ident = m[2];
+		if (name && ident) map.set(name, {
+			kind: "component",
+			ident
+		});
+	}
+}
+/**
+* Regex baseline for styled defs, then an AST pass overrides/adds rows when the
+* source parses. The AST pass understands aliased/named `styled` imports
+* (`import { styled as sc }`) that the regexes (which assume the literal `styled`)
+* miss, so callers that only ran the regex extractor under-report components.
+*/
+function extractStyledDefBases(filePath, source, parser, into) {
+	extractStyledDefBasesFromSource(filePath, source, into);
+	try {
+		const ast = parser.parse(source);
+		const program = ast.program ?? ast;
+		const importNodes = [];
+		walkForImportsAndTemplates(program, importNodes, []);
+		extractStyledDefBasesFromAstProgram(filePath, program, collectStyledLocalBindingNames(importNodes), into);
+	} catch {}
+}
+/**
+* AST-based extraction: understands `let`/`var`, export blocks, named `styled` imports,
+* and `.attrs` / `.withConfig` chains before the tagged template.
+* Results merge into `into`; bindings found here override regex entries for the same name.
+*/
+function extractStyledDefBasesFromAstProgram(filePath, program, styledLocalNames, into) {
+	if (styledLocalNames.size === 0) return;
+	let map = into.get(filePath);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		into.set(filePath, map);
+	}
+	const body = program.body;
+	if (!body) return;
+	for (const stmt of body) walkStatement(stmt);
+	function walkStatement(stmt) {
+		if (stmt.type === "VariableDeclaration") {
+			for (const d of stmt.declarations ?? []) processDeclarator(d);
+			return;
+		}
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) walkStatement(stmt.declaration);
+	}
+	function processDeclarator(decl) {
+		if (decl.type !== "VariableDeclarator") return;
+		const id = decl.id;
+		if (id.type !== "Identifier" || typeof id.name !== "string") return;
+		const tpl = findTaggedTemplate(unwrapInitializer(decl.init));
+		if (!tpl || tpl.type !== "TaggedTemplateExpression") return;
+		const base = classifyStyledTemplateTag(tpl.tag, styledLocalNames);
+		if (base) map.set(id.name, base);
+	}
+}
+function unwrapInitializer(node) {
+	let cur = node ?? void 0;
+	while (cur) {
+		if (cur.type === "TSAsExpression" || cur.type === "AsExpression") {
+			cur = cur.expression;
+			continue;
+		}
+		if (cur.type === "ParenthesizedExpression") {
+			cur = cur.expression;
+			continue;
+		}
+		return cur;
+	}
+}
+function findTaggedTemplate(node) {
+	const n = unwrapInitializer(node);
+	if (!n) return;
+	if (n.type === "TaggedTemplateExpression") return n;
+}
+/** Peel `.attrs` / `.withConfig` / nested calls down to `styled.div` or `styled(X)`. */
+function peelStyledApplication(tag, styledNames) {
+	let cur = tag;
+	while (cur) {
+		if (cur.type === "CallExpression") {
+			const callee = cur.callee;
+			if (callee?.type === "MemberExpression") {
+				cur = callee;
+				continue;
+			}
+			if (callee?.type === "Identifier" && typeof callee.name === "string" && styledNames.has(callee.name)) return cur;
+			return null;
+		}
+		if (cur.type === "MemberExpression") {
+			const obj = cur.object;
+			if (obj?.type === "Identifier" && typeof obj.name === "string" && styledNames.has(obj.name)) return cur;
+			cur = obj;
+			continue;
+		}
+		break;
+	}
+	return null;
+}
+function classifyStyledTemplateTag(tag, styledNames) {
+	const root = peelStyledApplication(tag, styledNames);
+	if (!root) return null;
+	if (root.type === "MemberExpression") {
+		const obj = root.object;
+		const prop = root.property;
+		const objName = obj?.type === "Identifier" ? obj.name : void 0;
+		if (obj?.type !== "Identifier" || typeof objName !== "string" || !styledNames.has(objName)) return null;
+		const isComputed = Boolean(root.computed);
+		if (isComputed && prop?.type === "StringLiteral" && typeof prop.value === "string") return { kind: "intrinsic" };
+		if (!isComputed && prop?.type === "Identifier" && typeof prop.name === "string") return { kind: "intrinsic" };
+		return null;
+	}
+	if (root.type === "CallExpression") {
+		const callee = root.callee;
+		const arg0 = root.arguments?.[0];
+		const calleeName = callee?.type === "Identifier" ? callee.name : void 0;
+		if (callee?.type !== "Identifier" || typeof calleeName !== "string" || !styledNames.has(calleeName) || !arg0) return null;
+		if (arg0.type === "Identifier" && typeof arg0.name === "string") return {
+			kind: "component",
+			ident: arg0.name
+		};
+		if (arg0.type === "StringLiteral" && typeof arg0.value === "string") return { kind: "intrinsic" };
+		return null;
+	}
+	return null;
+}
+//#endregion
 //#region src/internal/prepass/resolve-static-members.ts
 /**
 * Resolves the underlying component name(s) a static member access like `Select.Option` refers to,
@@ -248,9 +407,6 @@ async function runTransform(options) {
 		"Example: consumerPaths: \"src/**/*.tsx\"  // scan for cross-file usage",
 		"Example: consumerPaths: null             // opt out"
 	].join("\n"));
-	const transformModeRaw = options.transformMode;
-	if (transformModeRaw !== void 0 && transformModeRaw !== "all" && transformModeRaw !== "leavesOnly") throw new Error(["runTransform(options): `transformMode` must be one of: \"all\", \"leavesOnly\".", `Received: transformMode=${describeValue(transformModeRaw)}`].join("\n"));
-	const leavesOnly = options.transformMode === "leavesOnly";
 	const { files, consumerPaths: consumerPathsOption, dryRun = false, print = false, parser = "tsx", formatterCommands, maxExamples } = options;
 	if (maxExamples !== void 0) Logger.setMaxExamples(maxExamples);
 	const adapterInput = options.adapter;
@@ -329,7 +485,7 @@ async function runTransform(options) {
 	const { createModuleResolver } = await import("./resolve-imports-DgSAddIF.mjs").then((n) => n.n);
 	const sharedResolver = createModuleResolver();
 	filePaths = orderFilesByLocalImportDependencies(filePaths, sharedResolver, toRealPath);
-	const { runPrepass } = await import("./run-prepass-BueJvYyf.mjs");
+	const { runPrepass } = await import("./run-prepass-CGL_ugPB.mjs");
 	const absoluteFiles = filePaths.map((f) => resolve(f));
 	const absoluteConsumers = consumerFilePaths.map((f) => resolve(f));
 	let prepassResult;
@@ -342,9 +498,7 @@ async function runTransform(options) {
 			resolver: sharedResolver,
 			parserName: parser,
 			createExternalInterface: adapterInput.externalInterface === "auto",
-			enableAstCache: true,
-			leavesOnly,
-			resolveBaseComponent: adapterInput.resolveBaseComponent
+			enableAstCache: true
 		});
 		Logger.info(`Prepass: completed in ${formatElapsedSeconds(prepassStartedAt)}s\n`);
 	} catch (err) {
@@ -356,8 +510,7 @@ async function runTransform(options) {
 				componentsNeedingMarkerSidecar: /* @__PURE__ */ new Map(),
 				componentsNeedingGlobalSelectorBridge: /* @__PURE__ */ new Map(),
 				propUsageByFile: /* @__PURE__ */ new Map(),
-				stylexComponentFiles: /* @__PURE__ */ new Map(),
-				globalLeafKeys: leavesOnly ? /* @__PURE__ */ new Set() : void 0
+				stylexComponentFiles: /* @__PURE__ */ new Map()
 			},
 			consumerAnalysis: void 0,
 			forwardedAsConsumers: /* @__PURE__ */ new Map(),
@@ -517,9 +670,7 @@ async function runTransform(options) {
 		transformedComponents,
 		transformedFileSources,
 		transientPropRenames,
-		allowPartialMigration: options.allowPartialMigration ?? (leavesOnly ? true : false),
-		transformMode: leavesOnly ? "leavesOnly" : options.transformMode ?? "all",
-		globalLeafKeys: crossFilePrepassResult.globalLeafKeys,
+		allowPartialMigration: options.allowPartialMigration ?? false,
 		resolveModule: (fromFile, specifier) => sharedResolver.resolve(resolve(fromFile), specifier),
 		runInBand: true,
 		silent: options.silent ?? false
@@ -570,7 +721,7 @@ async function runTransform(options) {
 	const result = await runTransformSequentially(transformModule, filePaths, runnerOptions);
 	if (sidecarFiles.size > 0 && !dryRun) for (const [sidecarPath, content] of sidecarFiles) await writeFile(sidecarPath, mergeSidecarContent(sidecarPath, content), "utf-8");
 	if (bridgeResults.size > 0 && !dryRun) {
-		const { buildConsumerReplacements, patchConsumerFile } = await import("./bridge-consumer-patcher-B__X3jOg.mjs");
+		const { buildConsumerReplacements, patchConsumerFile } = await import("./bridge-consumer-patcher-jeeDUlId.mjs");
 		const consumerReplacements = buildConsumerReplacements(crossFilePrepassResult.selectorUsages, bridgeResults, transformedFiles);
 		const patchedFiles = [];
 		for (const [consumerPath, replacements] of consumerReplacements) {
@@ -583,7 +734,7 @@ async function runTransform(options) {
 		if (formatterCommands && patchedFiles.length > 0) await runFormatters(formatterCommands, patchedFiles);
 	}
 	if (prepassResult.forwardedAsConsumers.size > 0 && !dryRun) {
-		const { buildForwardedAsReplacements, patchConsumerForwardedAs } = await import("./forwarded-as-consumer-patcher-Bs9ymhBa.mjs");
+		const { buildForwardedAsReplacements, patchConsumerForwardedAs } = await import("./forwarded-as-consumer-patcher-Do4PI4Qs.mjs");
 		const forwardedAsReplacements = buildForwardedAsReplacements(prepassResult.forwardedAsConsumers, transformedFiles);
 		const patchedFiles = [];
 		for (const [consumerPath, entries] of forwardedAsReplacements) {
@@ -596,7 +747,7 @@ async function runTransform(options) {
 		if (formatterCommands && patchedFiles.length > 0) await runFormatters(formatterCommands, patchedFiles);
 	}
 	if (transientPropRenames.size > 0 && !dryRun) {
-		const { collectTransientPropPatches } = await import("./transient-prop-consumer-patcher-BDruM1OI.mjs");
+		const { collectTransientPropPatches } = await import("./transient-prop-consumer-patcher-D-iqO8-T.mjs");
 		const patches = collectTransientPropPatches({
 			transientPropRenames,
 			consumerFilePaths: consumerFilePaths.map((p) => resolve(p)),
@@ -726,16 +877,10 @@ function createStandalonePrepassResult(prepass, filePath, transformedFiles, tran
 		selectorUsages,
 		componentsNeedingMarkerSidecar,
 		componentsNeedingGlobalSelectorBridge,
-		globalLeafKeys: getStandaloneGlobalLeafKeys(prepass.globalLeafKeys, standaloneFile),
 		transformedFiles,
 		transformedComponents
 	};
 }
-function getStandaloneGlobalLeafKeys(globalLeafKeys, standaloneFile) {
-	if (!globalLeafKeys) return;
-	const filePrefix = `${standaloneFile}:`;
-	return new Set([...globalLeafKeys].filter((key) => key.startsWith(filePrefix)));
-}
 function addSetMapEntry(map, key, value) {
 	const values = map.get(key);
 	if (values) {
@@ -950,7 +1095,10 @@ function formatMigrationPlan(plan) {
 	lines.push("Manual conversion plan");
 	lines.push("======================");
 	lines.push(`${manualConversionFiles.length} of ${totalFiles} file(s) need manual conversion.`);
-	if (unlocksFileCount > 0) lines.push(`Focus on the ${priority.length} file(s) below — converting them unblocks ${unlocksFileCount} file(s) for automatic migration.`);
+	if (unlocksFileCount > 0) {
+		lines.push(`Focus on the ${priority.length} file(s) below. Direct payoff: converting all listed blockers lets ${unlocksFileCount} file(s) auto-migrate.`);
+		lines.push(`Per-file "directly unlocks" counts are sole-blocker payoffs; chain context is secondary and may need other blockers or manual fixes too.`);
+	}
 	lines.push("");
 	if (priority.length > 0) {
 		const positionByPath = new Map(priority.map((file, index) => [file.filePath, index + 1]));
@@ -1052,8 +1200,12 @@ function collectFocusPaths(files) {
 function appendFileEntry(lines, file, position, positionByPath) {
 	lines.push(`${position}. ${file.filePath}`);
 	const impact = [];
-	if (file.soleBlockerFileCount > 0) impact.push(`sole blocker for ${file.soleBlockerFileCount} file(s)`);
-	if (file.blockedFileCount > 0) impact.push(`in blocker chain for ${file.blockedFileCount} file(s)`);
+	if (file.blockedFileCount > 0) impact.push(`directly unlocks ${file.soleBlockerFileCount} file(s)`);
+	const chainOnlyFileCount = file.blockedFileCount - file.soleBlockerFileCount;
+	if (chainOnlyFileCount > 0) {
+		const prefix = file.soleBlockerFileCount > 0 ? "also " : "";
+		impact.push(`chain context: ${chainOnlyFileCount} file(s) ${prefix}bail through this file but are not unlocked by it alone`);
+	}
 	if (file.consumerCount > 0) impact.push(`imported by ${file.consumerCount} file(s)`);
 	if (impact.length > 0) lines.push(`   → ${impact.join(" · ")}`);
 	if (file.dependsOn.length > 0) {