@yahoo/uds 3.162.0 → 3.162.2

package/dist/css/dist/purger/optimized/ast/spread.cjs

@@ -0,0 +1,87 @@
+/*! © 2026 Yahoo, Inc. UDS v0.0.0-development */
+require("../../../../../_virtual/_rolldown/runtime.cjs");
+const require_jsx = require("./jsx.cjs");
+const require_props = require("./props.cjs");
+let ts_morph = require("ts-morph");
+//#region ../css/dist/purger/optimized/ast/spread.mjs
+/*! © 2026 Yahoo, Inc. UDS CSS v0.0.0-development */
+/**
+* Find all usages of a component across the entire project.
+* This is the key function for spread resolution - when we encounter
+* {...props} on a UDS component inside a wrapper, we trace back to
+* find all places where the wrapper is used and extract actual values.
+*
+* @param componentName Name of the component to find usages of
+* @param project The ts-morph project
+* @param cache Optional cache to avoid re-scanning
+* @returns Array of component usages with their props
+*/
+const findComponentUsages = (componentName, project, cache) => {
+	if (cache?.has(componentName)) return cache.get(componentName);
+	const usages = [];
+	project.getSourceFiles().forEach((sourceFile) => {
+		if (!fileReferencesComponent(sourceFile, componentName)) return;
+		[...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxSelfClosingElement), ...sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.JsxOpeningElement)].filter((el) => el.getTagNameNode().getText() === componentName).forEach((element) => {
+			const props = require_props.extractExplicitProps(element);
+			usages.push({
+				componentName,
+				filePath: sourceFile.getFilePath(),
+				line: element.getStartLineNumber(),
+				props
+			});
+		});
+	});
+	if (cache) cache.set(componentName, usages);
+	return usages;
+};
+/**
+* Check if a source file references a component (by import or definition)
+*/
+const fileReferencesComponent = (sourceFile, componentName) => {
+	if (sourceFile.getImportDeclarations().some((imp) => imp.getNamedImports().some((named) => named.getName() === componentName))) return true;
+	if (sourceFile.getVariableDeclaration(componentName)) return true;
+	if (sourceFile.getFunction(componentName)) return true;
+	return false;
+};
+/**
+* Resolve spread props by tracing component usage.
+*
+* When we encounter {...props} on a UDS component inside a wrapper:
+* 1. Find the parent component that contains this spread
+* 2. Search ALL files for usages of that parent component
+* 3. Extract actual prop values passed at each usage site
+* 4. Return ONLY those values - never fall back to type properties
+*
+* @param element The JSX element with the spread
+* @param spreadIdentifier The identifier being spread (e.g., 'rest' from {...rest})
+* @param context The purge context for caching
+* @returns Map of prop names to their resolved values, or undefined if couldn't trace
+*/
+const resolveSpreadFromUsages = (element, spreadIdentifier, context) => {
+	const parentInfo = require_jsx.getParentComponentInfo(element);
+	if (!parentInfo) return;
+	if (!(parentInfo.spreadRestIdentifier === spreadIdentifier || parentInfo.paramIdentifier === spreadIdentifier)) return;
+	const usages = findComponentUsages(parentInfo.componentName, context.project, context.componentUsageCache);
+	if (usages.length === 0) return;
+	context.stats.spreadsTraced++;
+	const resolvedProps = /* @__PURE__ */ new Map();
+	usages.forEach((usage) => {
+		usage.props.forEach((prop) => {
+			if (prop.fromSpread) return;
+			const existing = resolvedProps.get(prop.name) ?? [];
+			prop.values.forEach((value) => {
+				if (!existing.includes(value)) existing.push(value);
+			});
+			resolvedProps.set(prop.name, existing);
+		});
+	});
+	const cacheKey = `${element.getSourceFile().getFilePath()}:${element.getStartLineNumber()}:${spreadIdentifier}`;
+	context.spreadCache.set(cacheKey, Array.from(resolvedProps).map(([name, values]) => ({
+		name,
+		values,
+		fromSpread: true
+	})));
+	return resolvedProps;
+};
+//#endregion
+exports.resolveSpreadFromUsages = resolveSpreadFromUsages;

package/dist/css/dist/purger/optimized/ast/spread.js

@@ -0,0 +1,86 @@
+/*! © 2026 Yahoo, Inc. UDS v0.0.0-development */
+import { getParentComponentInfo } from "./jsx.js";
+import { extractExplicitProps } from "./props.js";
+import { SyntaxKind } from "ts-morph";
+//#region ../css/dist/purger/optimized/ast/spread.mjs
+/*! © 2026 Yahoo, Inc. UDS CSS v0.0.0-development */
+/**
+* Find all usages of a component across the entire project.
+* This is the key function for spread resolution - when we encounter
+* {...props} on a UDS component inside a wrapper, we trace back to
+* find all places where the wrapper is used and extract actual values.
+*
+* @param componentName Name of the component to find usages of
+* @param project The ts-morph project
+* @param cache Optional cache to avoid re-scanning
+* @returns Array of component usages with their props
+*/
+const findComponentUsages = (componentName, project, cache) => {
+	if (cache?.has(componentName)) return cache.get(componentName);
+	const usages = [];
+	project.getSourceFiles().forEach((sourceFile) => {
+		if (!fileReferencesComponent(sourceFile, componentName)) return;
+		[...sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement), ...sourceFile.getDescendantsOfKind(SyntaxKind.JsxOpeningElement)].filter((el) => el.getTagNameNode().getText() === componentName).forEach((element) => {
+			const props = extractExplicitProps(element);
+			usages.push({
+				componentName,
+				filePath: sourceFile.getFilePath(),
+				line: element.getStartLineNumber(),
+				props
+			});
+		});
+	});
+	if (cache) cache.set(componentName, usages);
+	return usages;
+};
+/**
+* Check if a source file references a component (by import or definition)
+*/
+const fileReferencesComponent = (sourceFile, componentName) => {
+	if (sourceFile.getImportDeclarations().some((imp) => imp.getNamedImports().some((named) => named.getName() === componentName))) return true;
+	if (sourceFile.getVariableDeclaration(componentName)) return true;
+	if (sourceFile.getFunction(componentName)) return true;
+	return false;
+};
+/**
+* Resolve spread props by tracing component usage.
+*
+* When we encounter {...props} on a UDS component inside a wrapper:
+* 1. Find the parent component that contains this spread
+* 2. Search ALL files for usages of that parent component
+* 3. Extract actual prop values passed at each usage site
+* 4. Return ONLY those values - never fall back to type properties
+*
+* @param element The JSX element with the spread
+* @param spreadIdentifier The identifier being spread (e.g., 'rest' from {...rest})
+* @param context The purge context for caching
+* @returns Map of prop names to their resolved values, or undefined if couldn't trace
+*/
+const resolveSpreadFromUsages = (element, spreadIdentifier, context) => {
+	const parentInfo = getParentComponentInfo(element);
+	if (!parentInfo) return;
+	if (!(parentInfo.spreadRestIdentifier === spreadIdentifier || parentInfo.paramIdentifier === spreadIdentifier)) return;
+	const usages = findComponentUsages(parentInfo.componentName, context.project, context.componentUsageCache);
+	if (usages.length === 0) return;
+	context.stats.spreadsTraced++;
+	const resolvedProps = /* @__PURE__ */ new Map();
+	usages.forEach((usage) => {
+		usage.props.forEach((prop) => {
+			if (prop.fromSpread) return;
+			const existing = resolvedProps.get(prop.name) ?? [];
+			prop.values.forEach((value) => {
+				if (!existing.includes(value)) existing.push(value);
+			});
+			resolvedProps.set(prop.name, existing);
+		});
+	});
+	const cacheKey = `${element.getSourceFile().getFilePath()}:${element.getStartLineNumber()}:${spreadIdentifier}`;
+	context.spreadCache.set(cacheKey, Array.from(resolvedProps).map(([name, values]) => ({
+		name,
+		values,
+		fromSpread: true
+	})));
+	return resolvedProps;
+};
+//#endregion
+export { resolveSpreadFromUsages };

package/dist/css/dist/purger/optimized/purge.cjs

@@ -2,8 +2,8 @@
 const require_runtime = require("../../../../_virtual/_rolldown/runtime.cjs");
 const require_purgeFromCode = require("./purgeFromCode.cjs");
 const require_entryPoints = require("../../../../tailwind-internal/dist/utils/entryPoints.cjs");
-const require_safelist = require("./utils/safelist.cjs");
 const require_files = require("./utils/files.cjs");
+const require_safelist = require("./utils/safelist.cjs");
 let node_path = require("node:path");
 node_path = require_runtime.__toESM(node_path, 1);
 let node_fs = require("node:fs");
@@ -24,11 +24,11 @@ const clearWarnings = () => {
 * between CLI and playground.
 */
 const purgeOptimized = async (options) => {
-	const { entry = require_entryPoints.DEFAULT_ENTRY, output = "dist/safelist.ts", colorModes = ["dark"], variants, autoVariants, componentData } = options;
+	const { entry = require_entryPoints.DEFAULT_ENTRY, output = "dist/safelist.ts", colorModes = ["dark"], ignoreDevFiles = true, ignore = [], includeStories = false, variants, autoVariants, componentData } = options;
 	const startTime = performance.now();
 	clearWarnings();
 	const workspaceDir = process.env.PWD ?? process.cwd();
-	const files = await require_files.scanForFiles(entry);
+	const files = await require_files.scanForFiles(entry, ignoreDevFiles && !includeStories, ignoreDevFiles && includeStories ? [...ignore, ...require_files.TEST_FILE_IGNORE_GLOBS] : ignore);
 	const allClasses = [];
 	const allImports = /* @__PURE__ */ new Set();
 	const allComponents = /* @__PURE__ */ new Set();
@@ -37,26 +37,32 @@ const purgeOptimized = async (options) => {
 		timeMs: 0,
 		classesGenerated: 0,
 		spreadsTraced: 0,
+		spreadsUnresolved: 0,
 		expressionsResolved: 0
 	};
-	(await Promise.all(files.map(async (filePath) => {
-		return require_purgeFromCode.purgeFromCodeOptimized(node_fs.default.readFileSync(filePath, "utf-8"), {
+	const fileContents = files.map((filePath) => node_fs.default.readFileSync(filePath, "utf-8"));
+	const results = await Promise.all(fileContents.map(async (code) => {
+		return require_purgeFromCode.purgeFromCodeOptimized(code, {
 			colorModes,
 			variants,
 			autoVariants,
-			componentData
+			componentData,
+			deferWrapperSpreadResolution: true
 		});
-	}))).forEach((result) => {
+	}));
+	results.forEach((result) => {
 		allClasses.push(...result.safelist);
 		result.imports.forEach((imp) => allImports.add(imp));
 		result.components.forEach((comp) => allComponents.add(comp));
 		stats.spreadsTraced += result.stats.spreadsTraced;
+		stats.spreadsUnresolved += result.stats.spreadsUnresolved;
 		stats.expressionsResolved += result.stats.expressionsResolved;
 	});
+	allClasses.push(...require_purgeFromCode.resolveWrapperSpreadSafelist(results.flatMap((result) => result.unresolvedWrapperSpreads), fileContents, variants));
 	allClasses.push(...require_safelist.getThemeAndScaleClasses(colorModes));
 	allClasses.push(...require_safelist.getInternalSafelistClasses());
 	const finalSafelist = require_safelist.deduplicateSafelist(allClasses).sort();
-	await require_safelist.saveSafelistToFile(finalSafelist, node_path.default.join(workspaceDir, output));
+	await require_safelist.saveSafelistToFile(finalSafelist, node_path.default.isAbsolute(output) ? output : node_path.default.join(workspaceDir, output));
 	stats.timeMs = Math.round(performance.now() - startTime);
 	stats.classesGenerated = finalSafelist.length;
 	return {

package/dist/css/dist/purger/optimized/purge.js

@@ -1,8 +1,8 @@
 /*! © 2026 Yahoo, Inc. UDS v0.0.0-development */
-import { purgeFromCodeOptimized } from "./purgeFromCode.js";
+import { purgeFromCodeOptimized, resolveWrapperSpreadSafelist } from "./purgeFromCode.js";
 import { DEFAULT_ENTRY } from "../../../../tailwind-internal/dist/utils/entryPoints.js";
+import { TEST_FILE_IGNORE_GLOBS, scanForFiles } from "./utils/files.js";
 import { deduplicateSafelist, getInternalSafelistClasses, getThemeAndScaleClasses, saveSafelistToFile } from "./utils/safelist.js";
-import { scanForFiles } from "./utils/files.js";
 import path from "node:path";
 import fs from "node:fs";
 //#region ../css/dist/purger/optimized/purge.mjs
@@ -21,11 +21,11 @@ const clearWarnings = () => {
 * between CLI and playground.
 */
 const purgeOptimized = async (options) => {
-	const { entry = DEFAULT_ENTRY, output = "dist/safelist.ts", colorModes = ["dark"], variants, autoVariants, componentData } = options;
+	const { entry = DEFAULT_ENTRY, output = "dist/safelist.ts", colorModes = ["dark"], ignoreDevFiles = true, ignore = [], includeStories = false, variants, autoVariants, componentData } = options;
 	const startTime = performance.now();
 	clearWarnings();
 	const workspaceDir = process.env.PWD ?? process.cwd();
-	const files = await scanForFiles(entry);
+	const files = await scanForFiles(entry, ignoreDevFiles && !includeStories, ignoreDevFiles && includeStories ? [...ignore, ...TEST_FILE_IGNORE_GLOBS] : ignore);
 	const allClasses = [];
 	const allImports = /* @__PURE__ */ new Set();
 	const allComponents = /* @__PURE__ */ new Set();
@@ -34,26 +34,32 @@ const purgeOptimized = async (options) => {
 		timeMs: 0,
 		classesGenerated: 0,
 		spreadsTraced: 0,
+		spreadsUnresolved: 0,
 		expressionsResolved: 0
 	};
-	(await Promise.all(files.map(async (filePath) => {
-		return purgeFromCodeOptimized(fs.readFileSync(filePath, "utf-8"), {
+	const fileContents = files.map((filePath) => fs.readFileSync(filePath, "utf-8"));
+	const results = await Promise.all(fileContents.map(async (code) => {
+		return purgeFromCodeOptimized(code, {
 			colorModes,
 			variants,
 			autoVariants,
-			componentData
+			componentData,
+			deferWrapperSpreadResolution: true
 		});
-	}))).forEach((result) => {
+	}));
+	results.forEach((result) => {
 		allClasses.push(...result.safelist);
 		result.imports.forEach((imp) => allImports.add(imp));
 		result.components.forEach((comp) => allComponents.add(comp));
 		stats.spreadsTraced += result.stats.spreadsTraced;
+		stats.spreadsUnresolved += result.stats.spreadsUnresolved;
 		stats.expressionsResolved += result.stats.expressionsResolved;
 	});
+	allClasses.push(...resolveWrapperSpreadSafelist(results.flatMap((result) => result.unresolvedWrapperSpreads), fileContents, variants));
 	allClasses.push(...getThemeAndScaleClasses(colorModes));
 	allClasses.push(...getInternalSafelistClasses());
 	const finalSafelist = deduplicateSafelist(allClasses).sort();
-	await saveSafelistToFile(finalSafelist, path.join(workspaceDir, output));
+	await saveSafelistToFile(finalSafelist, path.isAbsolute(output) ? output : path.join(workspaceDir, output));
 	stats.timeMs = Math.round(performance.now() - startTime);
 	stats.classesGenerated = finalSafelist.length;
 	return {

package/dist/css/dist/purger/optimized/purgeFromCode.cjs

@@ -2,6 +2,8 @@
 require("../../../../_virtual/_rolldown/runtime.cjs");
 const require_perf = require("../../css/perf.cjs");
 const require_expressions = require("./ast/expressions.cjs");
+const require_jsx = require("./ast/jsx.cjs");
+const require_spread = require("./ast/spread.cjs");
 let ts_morph = require("ts-morph");
 //#region ../css/dist/purger/optimized/purgeFromCode.mjs
 /*! © 2026 Yahoo, Inc. UDS CSS v0.0.0-development */
@@ -71,10 +73,10 @@ const normalizeComponentName = (name) => {
 	return name.replace(/\W/g, "").toLowerCase();
 };
 /**
-* Fallback: infer prop -> variant key mapping from autoVariants when the
-* generated component data misses it (e.g., helpers like buildAvatarRootClasses).
+* All autoVariants group keys belonging to a component (by normalized name
+* prefix, e.g. Button -> buttonVariantRoot, buttonSizeIcon, ...).
 */
-const getAutoVariantKeysForProp = (componentName, propName) => {
+const getComponentAutoVariantKeys = (componentName) => {
 	if (!autoVariantsCache) return [];
 	const segments = componentName.match(/[A-Z][a-z0-9]*/g) ?? [];
 	const candidates = new Set([normalizeComponentName(componentName)]);
@@ -82,12 +84,19 @@ const getAutoVariantKeysForProp = (componentName, propName) => {
 		const partial = segments.slice(0, i).join("");
 		candidates.add(normalizeComponentName(partial));
 	});
-	const propLower = propName.toLowerCase();
 	return Object.keys(autoVariantsCache).filter((key) => {
 		const keyLower = key.toLowerCase();
-		return Array.from(candidates).some((candidate) => keyLower.startsWith(candidate) && keyLower.includes(propLower));
+		return Array.from(candidates).some((candidate) => keyLower.startsWith(candidate));
 	});
 };
+/**
+* Fallback: infer prop -> variant key mapping from autoVariants when the
+* generated component data misses it (e.g., helpers like buildAvatarRootClasses).
+*/
+const getAutoVariantKeysForProp = (componentName, propName) => {
+	const propLower = propName.toLowerCase();
+	return getComponentAutoVariantKeys(componentName).filter((key) => key.toLowerCase().includes(propLower));
+};
 const getVariantKeysForProp = (componentInfo, propName) => {
 	const keys = new Set(componentInfo.propToVariantKeys?.[propName] ?? []);
 	getAutoVariantKeysForProp(componentInfo.name, propName).forEach((inferred) => keys.add(inferred));
@@ -169,19 +178,30 @@ const purgeFromCodeOptimized = async (code, options) => {
 			timeMs: 0,
 			classesGenerated: 0,
 			spreadsTraced: 0,
+			spreadsUnresolved: 0,
 			expressionsResolved: 0
-		}
+		},
+		unresolvedWrapperSpreads: []
 	};
 	const projectCreateStart = performance.now();
-	const sourceFile = new ts_morph.Project({ useInMemoryFileSystem: true }).createSourceFile(options.filePath ?? "input.tsx", code, { overwrite: true });
+	const project = new ts_morph.Project({ useInMemoryFileSystem: true });
+	const sourceFile = project.createSourceFile(options.filePath ?? "input.tsx", code, { overwrite: true });
 	const projectCreateMs = performance.now() - projectCreateStart;
 	const stats = {
 		filesScanned: 1,
 		timeMs: 0,
 		classesGenerated: 0,
 		spreadsTraced: 0,
+		spreadsUnresolved: 0,
 		expressionsResolved: 0
 	};
+	const purgeContext = {
+		project,
+		componentUsageCache: /* @__PURE__ */ new Map(),
+		spreadCache: /* @__PURE__ */ new Map(),
+		udsImportingFiles: /* @__PURE__ */ new Set(),
+		stats
+	};
 	const importParseStart = performance.now();
 	const imports = [];
 	sourceFile.getImportDeclarations().forEach((importDecl) => {
@@ -192,6 +212,8 @@ const purgeFromCodeOptimized = async (code, options) => {
 	const importParseMs = performance.now() - importParseStart;
 	const componentProps = /* @__PURE__ */ new Map();
 	const componentUnresolvedSpreadProps = /* @__PURE__ */ new Map();
+	const componentsWithUnknownSpreads = /* @__PURE__ */ new Set();
+	const unresolvedWrapperSpreads = [];
 	const referencedComponents = /* @__PURE__ */ new Set();
 	const getStylesExtractStart = performance.now();
 	const getStylesProps = extractGetStylesCalls(sourceFile, stats, variants);
@@ -204,7 +226,8 @@ const purgeFromCodeOptimized = async (code, options) => {
 			referencedComponents.add(componentName);
 			const propsMap = componentProps.get(componentName) ?? /* @__PURE__ */ new Map();
 			const unresolvedSpreadProps = componentUnresolvedSpreadProps.get(componentName) ?? /* @__PURE__ */ new Set();
-			extractPropsFromReference(reference, stats, sourceFile).forEach(({ propName, values, fromSpread }) => {
+			const { props, unknownSpreadWrappers } = extractPropsFromReference(reference, stats, sourceFile, purgeContext);
+			props.forEach(({ propName, values, fromSpread }) => {
 				if (values.length > 0) {
 					const existing = propsMap.get(propName) ?? /* @__PURE__ */ new Set();
 					values.forEach((val) => existing.add(val));
@@ -213,6 +236,13 @@ const purgeFromCodeOptimized = async (code, options) => {
 				}
 				if (fromSpread) unresolvedSpreadProps.add(propName);
 			});
+			unknownSpreadWrappers.forEach((wrapperName) => {
+				if (wrapperName) unresolvedWrapperSpreads.push({
+					wrapperName,
+					targetComponent: componentName
+				});
+				if (!wrapperName || !options.deferWrapperSpreadResolution) componentsWithUnknownSpreads.add(componentName);
+			});
 			componentProps.set(componentName, propsMap);
 			componentUnresolvedSpreadProps.set(componentName, unresolvedSpreadProps);
 		});
@@ -242,6 +272,7 @@ const purgeFromCodeOptimized = async (code, options) => {
 	allComponents.forEach((componentInfo) => {
 		const userProps = componentProps.get(componentInfo.name) ?? /* @__PURE__ */ new Map();
 		const unresolvedSpreadProps = componentUnresolvedSpreadProps.get(componentInfo.name) ?? /* @__PURE__ */ new Set();
+		if (componentsWithUnknownSpreads.has(componentInfo.name)) collectUnknownSpreadClasses(componentInfo, variants, safelist);
 		Object.entries(componentInfo.defaultProps).forEach(([propName, propValue]) => {
 			if (userProps.has(propName)) return;
 			const variantGroup = variants[propName];
@@ -367,7 +398,8 @@ const purgeFromCodeOptimized = async (code, options) => {
 		safelist: finalSafelist,
 		imports,
 		components: [...seenComponents],
-		stats
+		stats,
+		unresolvedWrapperSpreads
 	};
 };
 /**
@@ -400,9 +432,16 @@ const findComponentReferences = (sourceFile, componentName, jsxElementsCache) =>
 };
 /**
 * Extract props from a JSX reference.
+*
+* Spread resolution order (UDS-2557):
+* 1. Same-file const object (`traceSpreadInFile`)
+* 2. Wrapper call sites within the project (`resolveSpreadFromUsages`)
+* 3. Otherwise the spread is unknown: reported via `unknownSpreadWrappers` so the
+*    caller can over-include variant classes and emit cross-file metadata.
 */
-const extractPropsFromReference = (reference, stats, sourceFile) => {
+const extractPropsFromReference = (reference, stats, sourceFile, purgeContext) => {
 	const props = [];
+	const unknownSpreadWrappers = [];
 	reference.getAttributes().forEach((attr) => {
 		if (attr.asKind(ts_morph.SyntaxKind.JsxAttribute)) {
 			const jsxAttr = attr.asKindOrThrow(ts_morph.SyntaxKind.JsxAttribute);
@@ -427,17 +466,40 @@ const extractPropsFromReference = (reference, stats, sourceFile) => {
 			});
 		}
 		if (attr.asKind(ts_morph.SyntaxKind.JsxSpreadAttribute)) {
-			stats.spreadsTraced++;
-			traceSpreadInFile(attr.asKindOrThrow(ts_morph.SyntaxKind.JsxSpreadAttribute).getExpression().getText(), sourceFile).forEach(([propName, values]) => {
-				props.push({
-					propName,
-					values,
-					fromSpread: true
+			const spreadName = attr.asKindOrThrow(ts_morph.SyntaxKind.JsxSpreadAttribute).getExpression().getText();
+			const resolvedSpreadProps = traceSpreadInFile(spreadName, sourceFile);
+			if (resolvedSpreadProps.length > 0) {
+				stats.spreadsTraced++;
+				resolvedSpreadProps.forEach(([propName, values]) => {
+					props.push({
+						propName,
+						values,
+						fromSpread: true
+					});
 				});
-			});
+				return;
+			}
+			const usageResolved = require_spread.resolveSpreadFromUsages(reference, spreadName, purgeContext);
+			if (usageResolved) {
+				usageResolved.forEach((values, propName) => {
+					props.push({
+						propName,
+						values,
+						fromSpread: true
+					});
+				});
+				return;
+			}
+			stats.spreadsUnresolved++;
+			const parentInfo = require_jsx.getParentComponentInfo(reference);
+			const isWrapperParamSpread = parentInfo && (parentInfo.spreadRestIdentifier === spreadName || parentInfo.paramIdentifier === spreadName);
+			unknownSpreadWrappers.push(isWrapperParamSpread ? parentInfo.componentName : void 0);
 		}
 	});
-	return props;
+	return {
+		props,
+		unknownSpreadWrappers
+	};
 };
 /**
 * Trace spread props to their source within the same file.
@@ -514,5 +576,101 @@ const extractGetStylesCalls = (sourceFile, stats, variants) => {
 	});
 	return props;
 };
+/**
+* Over-include every variant-prop class for a component (and its internal deps).
+* Used when a spread's props are unknown: any variant prop could flow through it,
+* so accuracy demands including all of them (UDS-2557).
+*/
+const collectUnknownSpreadClasses = (componentInfo, variants, safelist) => {
+	getComponentWithDeps(componentInfo.name).forEach((comp) => {
+		Object.keys(comp.propToVariantKeys ?? {}).forEach((propName) => {
+			addVariantGroupClasses(variants[propName] ?? autoVariantsCache?.[propName], safelist);
+			getVariantKeysForProp(comp, propName).forEach((variantKey) => {
+				addVariantGroupClasses(variants[variantKey] ?? autoVariantsCache?.[variantKey], safelist);
+			});
+		});
+		getComponentAutoVariantKeys(comp.name).forEach((variantKey) => {
+			addVariantGroupClasses(autoVariantsCache?.[variantKey], safelist);
+		});
+	});
+};
+/**
+* Cross-file pass for UDS-2557: resolve wrapper rest-spread props from wrapper
+* call sites found in other scanned files.
+*
+* `purgeFromCodeOptimized` analyzes one file at a time, so when a consumer
+* wrapper (e.g. an i13n wrapper) spreads its props onto a UDS component, the
+* wrapper's call sites usually live in other files. Aggregators pass the
+* unresolved wrapper spreads plus the raw source of every scanned file; this
+* parses only the files that mention a wrapper and maps the explicit prop
+* values at each call site to the target UDS component's classes.
+*
+* Must be called after at least one `purgeFromCodeOptimized` run so the
+* module-level component/autoVariants caches are populated.
+*/
+const resolveWrapperSpreadSafelist = (wrapperSpreads, sources, variants) => {
+	if (wrapperSpreads.length === 0) return [];
+	const targetsByWrapper = /* @__PURE__ */ new Map();
+	wrapperSpreads.forEach(({ wrapperName, targetComponent }) => {
+		const targets = targetsByWrapper.get(wrapperName) ?? /* @__PURE__ */ new Set();
+		targets.add(targetComponent);
+		targetsByWrapper.set(wrapperName, targets);
+	});
+	const wrapperNames = [...targetsByWrapper.keys()];
+	const usageProps = /* @__PURE__ */ new Map();
+	sources.filter((code) => wrapperNames.some((name) => code.includes(`<${name}`))).forEach((code) => {
+		new ts_morph.Project({ useInMemoryFileSystem: true }).createSourceFile("wrapper-usage.tsx", code, { overwrite: true }).getDescendants().forEach((node) => {
+			if (!ts_morph.Node.isJsxOpeningElement(node) && !ts_morph.Node.isJsxSelfClosingElement(node)) return;
+			const tagName = node.getTagNameNode().getText();
+			if (!targetsByWrapper.has(tagName)) return;
+			const propsMap = usageProps.get(tagName) ?? /* @__PURE__ */ new Map();
+			node.getAttributes().forEach((attr) => {
+				const jsxAttr = attr.asKind(ts_morph.SyntaxKind.JsxAttribute);
+				if (!jsxAttr) return;
+				const propName = jsxAttr.getNameNode().getText();
+				const values = [];
+				const initializer = jsxAttr.getInitializer();
+				if (initializer && ts_morph.Node.isStringLiteral(initializer)) values.push(initializer.getLiteralText());
+				else if (initializer && ts_morph.Node.isJsxExpression(initializer)) {
+					const expression = initializer.getExpression();
+					if (expression) values.push(...require_expressions.extractStringLiterals(expression));
+				}
+				if (values.length === 0) return;
+				const existing = propsMap.get(propName) ?? /* @__PURE__ */ new Set();
+				values.forEach((value) => existing.add(value));
+				propsMap.set(propName, existing);
+			});
+			usageProps.set(tagName, propsMap);
+		});
+	});
+	const safelist = [];
+	const pushClass = (variantGroup, value) => {
+		const cls = variantGroup?.[value];
+		if (cls) safelist.push(cls.replaceAll("\\", ""));
+	};
+	targetsByWrapper.forEach((targets, wrapperName) => {
+		const propsMap = usageProps.get(wrapperName);
+		targets.forEach((targetComponent) => {
+			const componentInfo = resolveComponentInfo(targetComponent);
+			if (!componentInfo) return;
+			if (!propsMap || propsMap.size === 0) {
+				collectUnknownSpreadClasses(componentInfo, variants, safelist);
+				return;
+			}
+			propsMap.forEach((values, propName) => {
+				const variantGroup = variants[propName];
+				values.forEach((value) => pushClass(variantGroup, value));
+				getComponentWithDeps(componentInfo.name).forEach((comp) => {
+					getVariantKeysForProp(comp, propName).forEach((variantKey) => {
+						const mappedVariantGroup = variants[variantKey] ?? autoVariantsCache?.[variantKey];
+						values.forEach((value) => pushClass(mappedVariantGroup, value));
+					});
+				});
+			});
+		});
+	});
+	return safelist;
+};
 //#endregion
 exports.purgeFromCodeOptimized = purgeFromCodeOptimized;
+exports.resolveWrapperSpreadSafelist = resolveWrapperSpreadSafelist;