@bamboocss/parser 1.25.0 → 1.28.0

package/dist/index.cjs

@@ -410,6 +410,11 @@ function createReportMaps() {
 }
 //#endregion
 //#region src/get-module-specifier-value.ts
+/**
+* Both declaration kinds carry a specifier, and `export { x } from './m'` is how a barrel
+* forwards a recipe — so this reads either. An `export { x }` with no `from` returns
+* undefined, which is the same answer the throwing case gives.
+*/
 const getModuleSpecifierValue = (node) => {
 	try {
 		return node.getModuleSpecifierValue();
@@ -418,6 +423,194 @@ const getModuleSpecifierValue = (node) => {
 	}
 };
 //#endregion
+//#region src/imported-recipes.ts
+/**
+* A module's exported recipes, memoized.
+*
+* Per *target*, so a barrel imported by two hundred files is walked once. Cleared alongside
+* the box-node cache, which is the same invalidation this needs: both memoize a conclusion
+* drawn from another file's contents.
+*/
+const exportedRecipes = /* @__PURE__ */ new Map();
+const clearImportedRecipeCache = () => {
+	exportedRecipes.clear();
+};
+/** The names a file bound `cva`/`sva` to, or empty when it imports neither. */
+const recipeFactoryAliases = (sourceFile, imports) => {
+	const aliases = /* @__PURE__ */ new Set();
+	for (const declaration of sourceFile.getImportDeclarations()) {
+		if (declaration.isTypeOnly()) continue;
+		const mod = getModuleSpecifierValue(declaration);
+		if (!mod) continue;
+		for (const specifier of declaration.getNamedImports()) {
+			if (specifier.isTypeOnly()) continue;
+			const name = specifier.getNameNode().getText();
+			if (name !== "cva" && name !== "sva") continue;
+			const alias = specifier.getAliasNode()?.getText() || name;
+			if (!imports.match({
+				name,
+				alias,
+				mod,
+				kind: "named"
+			})) continue;
+			aliases.add(alias);
+		}
+	}
+	return aliases;
+};
+/** Recipes this module declares itself, by the name it declared them under. */
+const declaredRecipes = (sourceFile, imports) => {
+	const declared = /* @__PURE__ */ new Map();
+	const exported = /* @__PURE__ */ new Set();
+	const factories = recipeFactoryAliases(sourceFile, imports);
+	if (factories.size === 0) return {
+		declared,
+		exported
+	};
+	const filePath = sourceFile.getFilePath();
+	for (const statement of sourceFile.compilerNode.statements) {
+		if (!ts_morph.ts.isVariableStatement(statement)) continue;
+		if (!(statement.declarationList.flags & ts_morph.ts.NodeFlags.Const)) continue;
+		for (const declaration of statement.declarationList.declarations) {
+			const initializer = declaration.initializer;
+			if (!initializer || !ts_morph.ts.isCallExpression(initializer)) continue;
+			const callee = initializer.expression;
+			if (!ts_morph.ts.isIdentifier(callee) || !ts_morph.ts.isIdentifier(declaration.name)) continue;
+			if (!factories.has(callee.text)) continue;
+			declared.set(declaration.name.text, {
+				filePath,
+				name: declaration.name.text
+			});
+			if (statement.modifiers?.some((modifier) => modifier.kind === ts_morph.ts.SyntaxKind.ExportKeyword)) exported.add(declaration.name.text);
+		}
+	}
+	return {
+		declared,
+		exported
+	};
+};
+/**
+* Every name this module exports that is bound to a recipe, and where it was declared.
+*
+* Follows `export { x } from './m'`, `export * from './m'`, and `import { x } … export { x }`,
+* because a barrel is how these are reached in practice. The origin is carried through each
+* hop rather than recomputed, so a consumer learns the *declaring* module however many
+* re-exports stand between them.
+*
+* A star export contributes only names nothing else exports, which is what the language does:
+* an explicit export shadows one arriving through `export *`. Resolving that the other way
+* folded a call against a config it would never have run.
+*/
+const walkExports = (sourceFile, imports, resolveModule, seen) => {
+	const cached = exportedRecipes.get(sourceFile);
+	if (cached) return {
+		names: cached,
+		complete: true
+	};
+	if (seen.has(sourceFile)) return {
+		names: /* @__PURE__ */ new Map(),
+		complete: false
+	};
+	seen.add(sourceFile);
+	const names = /* @__PURE__ */ new Map();
+	/** Reachable under a local name — declarations, plus recipes this module imports. */
+	const local = /* @__PURE__ */ new Map();
+	/** Held back so an explicit export of the same name wins. */
+	const starred = /* @__PURE__ */ new Map();
+	/** Names two different star exports both carry, which resolve to neither. */
+	const ambiguous = /* @__PURE__ */ new Set();
+	let complete = true;
+	const { declared, exported } = declaredRecipes(sourceFile, imports);
+	for (const [name, origin] of declared) {
+		local.set(name, origin);
+		if (exported.has(name)) names.set(name, origin);
+	}
+	const imported = walkImports(sourceFile, imports, resolveModule, seen);
+	complete &&= imported.complete;
+	for (const [alias, origin] of imported.bindings) if (!local.has(alias)) local.set(alias, origin);
+	for (const declaration of sourceFile.getExportDeclarations()) {
+		if (declaration.isTypeOnly()) continue;
+		const specifier = getModuleSpecifierValue(declaration);
+		const target = specifier ? resolveModule(specifier, sourceFile) : void 0;
+		if (specifier && !target) continue;
+		if (declaration.getNamespaceExport()) continue;
+		if (declaration.isNamespaceExport()) {
+			if (!target) continue;
+			const walk = walkExports(target, imports, resolveModule, seen);
+			complete &&= walk.complete;
+			for (const [name, origin] of walk.names) {
+				const existing = starred.get(name);
+				if (existing && (existing.filePath !== origin.filePath || existing.name !== origin.name)) {
+					ambiguous.add(name);
+					continue;
+				}
+				starred.set(name, origin);
+			}
+			continue;
+		}
+		let source = local;
+		if (target) {
+			const walk = walkExports(target, imports, resolveModule, seen);
+			complete &&= walk.complete;
+			source = walk.names;
+		}
+		for (const exportSpecifier of declaration.getNamedExports()) {
+			if (exportSpecifier.isTypeOnly()) continue;
+			const name = exportSpecifier.getNameNode().getText();
+			const origin = source.get(name);
+			if (origin) names.set(exportSpecifier.getAliasNode()?.getText() || name, origin);
+		}
+	}
+	for (const [name, origin] of starred) if (!names.has(name) && !ambiguous.has(name)) names.set(name, origin);
+	if (complete) exportedRecipes.set(sourceFile, names);
+	return {
+		names,
+		complete
+	};
+};
+/**
+* Local names in this file bound, through an import, to a recipe declared elsewhere.
+*
+* Reports truncation for the same reason `walkExports` does: `export { x }` with no `from`
+* resolves through here, so a walk cut short by a cycle can leave a name out — and caching
+* that as the whole answer is what makes visibility depend on where the walk began.
+*/
+const walkImports = (sourceFile, imports, resolveModule, seen) => {
+	const bindings = /* @__PURE__ */ new Map();
+	let complete = true;
+	for (const declaration of sourceFile.getImportDeclarations()) {
+		if (declaration.isTypeOnly()) continue;
+		const named = declaration.getNamedImports();
+		if (named.length === 0) continue;
+		const specifier = getModuleSpecifierValue(declaration);
+		if (!specifier) continue;
+		const target = resolveModule(specifier, sourceFile);
+		if (!target || target === sourceFile) continue;
+		const walk = walkExports(target, imports, resolveModule, seen);
+		complete &&= walk.complete;
+		const { names } = walk;
+		if (names.size === 0) continue;
+		for (const importSpecifier of named) {
+			if (importSpecifier.isTypeOnly()) continue;
+			const origin = names.get(importSpecifier.getNameNode().getText());
+			if (!origin) continue;
+			bindings.set(importSpecifier.getAliasNode()?.getText() || importSpecifier.getNameNode().getText(), origin);
+		}
+	}
+	return {
+		bindings,
+		complete
+	};
+};
+/**
+* Local names in this file bound, through an import, to a recipe declared elsewhere.
+*
+* Only specifiers the caller's resolver can place inside the project. A recipe outside the
+* project's `include` is never parsed, so it has no rules in the stylesheet and could not be
+* folded against even if the binding resolved.
+*/
+const importedRecipeBindings = (sourceFile, imports, resolveModule) => walkImports(sourceFile, imports, resolveModule, new Set([sourceFile])).bindings;
+//#endregion
 //#region src/get-import-declarations.ts
 function getImportDeclarations(context, sourceFile) {
 	const { imports, tsOptions } = context;
@@ -860,14 +1053,16 @@ const fallbackImpl = (...values) => values.some((value) => value === void 0) ? v
 const evaluateOptions = { environment: defaultEnv };
 function createParser(context) {
 	const { jsx, imports, recipes } = context;
-	return function parse(sourceFile, encoder, options) {
+	return function parse(sourceFile, encoder, options, resolveModule) {
 		if (!sourceFile) return;
 		const importDeclarations = getImportDeclarations(context, sourceFile);
 		const file = imports.file(importDeclarations);
 		const filePath = sourceFile.getFilePath();
 		_bamboocss_logger.logger.debug("ast:import", !file.isEmpty() ? `Found import { ${file.toString()} } in ${filePath}` : `No import found in ${filePath}`);
 		const parserResult = new ParserResult(context, encoder);
-		if (file.isEmpty() && !jsx.isEnabled) return parserResult;
+		const importedRecipes = resolveModule ? importedRecipeBindings(sourceFile, imports, resolveModule) : /* @__PURE__ */ new Map();
+		if (file.isEmpty() && !jsx.isEnabled && importedRecipes.size === 0) return parserResult;
+		for (const binding of importedRecipes.keys()) file.addLocalRecipe(binding);
 		if (file.importsRecipeFactory()) for (const statement of sourceFile.compilerNode.statements) {
 			if (!ts_morph.ts.isVariableStatement(statement)) continue;
 			if (!(statement.declarationList.flags & ts_morph.ts.NodeFlags.Const)) continue;
@@ -882,6 +1077,27 @@ function createParser(context) {
 				file.addLocalRecipe(declaration.name.text);
 			}
 		}
+		/**
+		* `css(recipe.raw(props), …)` loses what the recipe would have contributed.
+		*
+		* `.raw` on a recipe or pattern takes props and returns styles; the build reads it as the
+		* identity `css.raw` means. Resolving it properly would mean running the recipe here, and
+		* emitting the wrong styles is worse than emitting none — so this says so rather than
+		* guessing.
+		*
+		* Defined out here rather than inside `getEvaluateOptions`, which runs per call node.
+		*/
+		const reportUnresolvedRaw = (base, at) => {
+			const { line, column } = sourceFile.getLineAndColumnAtPos(at.getStart());
+			parserResult.unresolved.push({
+				kind: "atomic",
+				prop: base,
+				filePath,
+				line,
+				column,
+				reason: "unresolved-raw"
+			});
+		};
 		(0, _bamboocss_extractor.extract)({
 			ast: sourceFile,
 			tokens: context.tokens ? {
@@ -920,8 +1136,14 @@ function createParser(context) {
 				}
 				if (!ts_morph.Node.isPropertyAccessExpression(propAccessExpr)) return evaluateOptions;
 				let name = propAccessExpr.getText();
+				const rawBase = name.endsWith(".raw") ? name.slice(0, -4) : void 0;
+				if (rawBase && file.isLocalRecipe(rawBase)) {
+					reportUnresolvedRaw(rawBase, node);
+					return evaluateOptions;
+				}
 				if (!file.isRawFn(name)) return evaluateOptions;
 				name = name.replace(".raw", "");
+				if (file.isValidRecipe(name) || file.isValidPattern(name)) reportUnresolvedRaw(name, node);
 				return { environment: Object.assign({}, defaultEnv, { extra: { [name]: { raw: (v) => v } } }) };
 			},
 			flags: { skipTraverseFiles: false }
@@ -937,7 +1159,8 @@ function createParser(context) {
 						if (query.kind === "call-expression") parserResult.setCvaCall(alias, {
 							name: alias,
 							box: query.box.value[0] ?? _bamboocss_extractor.box.fallback(query.box),
-							data: combineResult((0, _bamboocss_extractor.unbox)(query.box.value[0]))
+							data: combineResult((0, _bamboocss_extractor.unbox)(query.box.value[0])),
+							origin: importedRecipes.get(alias)
 						});
 					});
 					return;
@@ -1009,6 +1232,17 @@ function createParser(context) {
 }
 //#endregion
 //#region src/project.ts
+/**
+* Everything memoized against another file's contents.
+*
+* Both caches answer a question about a *different* module than the one being parsed — what
+* an identifier resolved to, and which recipes a module exports — so both go stale on exactly
+* the same events, and clearing one without the other leaves the pair disagreeing.
+*/
+const invalidateResolutions = () => {
+	(0, _bamboocss_extractor.clearBoxNodeCache)();
+	clearImportedRecipeCache();
+};
 const normalizeCompilerOptions = (raw) => {
 	if (!raw) return {};
 	const { options } = ts_morph.ts.convertCompilerOptionsFromJson(raw, process.cwd());
@@ -1092,6 +1326,18 @@ var Project = class {
 	* `.d.ts` into the project. The graph only tracks files bamboo already scans.
 	*/
 	moduleResolutionCache;
+	/**
+	* Everything memoized against the shape of the file tree, including the negative half.
+	*
+	* `resolveModuleName` caches failures too, so a specifier that resolved to nothing before
+	* its target existed stays unresolved for the life of the process. That silently dropped a
+	* dependency edge; now it would also leave a recipe permanently invisible to the module
+	* importing it, since resolution is what finds one.
+	*/
+	invalidate = (fileTreeChanged = true) => {
+		invalidateResolutions();
+		if (fileTreeChanged) this.moduleResolutionCache = void 0;
+	};
 	resolveImport = (decl) => {
 		const moduleName = decl.getModuleSpecifierValue();
 		if (!moduleName) return;
@@ -1100,6 +1346,16 @@ var Project = class {
 		const name = ts_morph.ts.resolveModuleName(moduleName, decl.getSourceFile().getFilePath(), compilerOptions, this.project.getModuleResolutionHost(), this.moduleResolutionCache).resolvedModule?.resolvedFileName;
 		return name ? this.project.getSourceFile(name) : void 0;
 	};
+	/**
+	* `resolveImport` in the shape a caller can use, for a specifier read off any declaration.
+	*
+	* Shares the module resolution cache above, so a barrel resolved while tracking
+	* dependencies is not resolved again while looking for recipes.
+	*/
+	resolveModule = (specifier, from) => this.resolveImport({
+		getModuleSpecifierValue: () => specifier,
+		getSourceFile: () => from
+	});
 	trackDependencies = (filePath, sourceFile) => {
 		const importer = this.normalizePath(sourceFile.getFilePath());
 		this.canonicalPaths.set(this.normalizePath(filePath), importer);
@@ -1146,7 +1402,7 @@ var Project = class {
 	};
 	createSourceFile = (filePath) => {
 		const { readFile } = this.options;
-		(0, _bamboocss_extractor.clearBoxNodeCache)();
+		this.invalidate();
 		return this.project.createSourceFile(filePath, readFile(filePath), {
 			overwrite: true,
 			scriptKind: ts_morph.ScriptKind.TSX
@@ -1157,7 +1413,7 @@ var Project = class {
 		for (const file of files) this.createSourceFile(file);
 	};
 	addSourceFile = (filePath, content) => {
-		(0, _bamboocss_extractor.clearBoxNodeCache)();
+		this.invalidate(!(filePath.includes("/") && this.project.getSourceFile(filePath)));
 		return this.project.createSourceFile(filePath, content, {
 			overwrite: true,
 			scriptKind: ts_morph.ScriptKind.TSX
@@ -1166,18 +1422,18 @@ var Project = class {
 	removeSourceFile = (filePath) => {
 		const sourceFile = this.project.getSourceFile(filePath);
 		if (sourceFile) {
-			(0, _bamboocss_extractor.clearBoxNodeCache)();
+			this.invalidate();
 			return this.project.removeSourceFile(sourceFile);
 		}
 		return false;
 	};
 	reloadSourceFile = (filePath) => {
-		(0, _bamboocss_extractor.clearBoxNodeCache)();
+		this.invalidate(false);
 		return this.getSourceFile(filePath)?.refreshFromFileSystemSync();
 	};
 	reloadSourceFiles = () => {
 		const files = this.getFiles();
-		(0, _bamboocss_extractor.clearBoxNodeCache)();
+		this.invalidate();
 		for (const file of files) this.getSourceFile(file)?.refreshFromFileSystemSync() ?? this.project.addSourceFileAtPath(file);
 	};
 	get readFile() {
@@ -1211,7 +1467,7 @@ var Project = class {
 			}
 		}) ?? this.transformFile(filePath, original);
 		if (original !== transformed) sourceFile.replaceWithText(transformed);
-		const result = this.parser(sourceFile, encoder, options)?.setFilePath(filePath);
+		const result = this.parser(sourceFile, encoder, options, this.resolveModule)?.setFilePath(filePath);
 		hooks["parser:after"]?.({
 			filePath,
 			result

package/dist/index.d.cts

@@ -136,6 +136,9 @@ declare class Generator extends Context {
  * Get CSS for a specific theme
  */
 //#endregion
+//#region src/imported-recipes.d.ts
+type ResolveModule = (specifier: string, from: SourceFile) => SourceFile | undefined;
+//#endregion
 //#region src/unresolved-styles.d.ts
 interface UnresolvedStyle {
   /**
@@ -162,7 +165,17 @@ interface UnresolvedStyle {
    *   pair of alternatives.
    * - `too-many-combinations` — more ternary branches than it will enumerate.
    */
-  reason: 'unresolvable-value' | 'missing-property' | 'unenumerable-keys';
+  reason: 'unresolvable-value' | 'missing-property' | 'unenumerable-keys'
+  /**
+   * `css(recipe.raw(props), …)` — the build reads `.raw` as returning what it was passed.
+   *
+   * True of `css.raw`, which is the identity it was written for. A recipe or pattern's
+   * `.raw` takes *props* and returns *styles*, so the build composes the props instead: the
+   * recipe's own declarations never reach the stylesheet, and its variant names are handed
+   * to the encoder as if they were properties. The browser then asks for classes no rule
+   * backs, and the element renders without them.
+   */
+  | 'unresolved-raw';
 }
 declare const findUnresolvedStyles: (item: ResultItem, kind: "atomic") => UnresolvedStyle[];
 //#endregion
@@ -241,7 +254,16 @@ declare class ParserResult implements ParserResultInterface {
 }
 //#endregion
 //#region src/parser.d.ts
-declare function createParser(context: ParserOptions): (sourceFile: SourceFile | undefined, encoder?: Generator["encoder"], options?: ParserResultConfigureOptions) => ParserResult | undefined;
+declare function createParser(context: ParserOptions): (sourceFile: SourceFile | undefined, encoder?: Generator["encoder"], options?: ParserResultConfigureOptions,
+/**
+ * How to place a module specifier inside the project.
+ *
+ * Supplied by the caller because it owns the resolution cache, and because the cheap
+ * implementation is a filesystem lookup rather than a symbol-table walk. Absent, a
+ * recipe declared in another module stays invisible exactly as before.
+ */
+
+resolveModule?: ResolveModule) => ParserResult | undefined;
 //#endregion
 //#region src/project.d.ts
 interface ProjectOptions extends ProjectOptions$1 {
@@ -305,7 +327,23 @@ declare class Project {
    * `.d.ts` into the project. The graph only tracks files bamboo already scans.
    */
   private moduleResolutionCache;
+  /**
+   * Everything memoized against the shape of the file tree, including the negative half.
+   *
+   * `resolveModuleName` caches failures too, so a specifier that resolved to nothing before
+   * its target existed stays unresolved for the life of the process. That silently dropped a
+   * dependency edge; now it would also leave a recipe permanently invisible to the module
+   * importing it, since resolution is what finds one.
+   */
+  private invalidate;
   private resolveImport;
+  /**
+   * `resolveImport` in the shape a caller can use, for a specifier read off any declaration.
+   *
+   * Shares the module resolution cache above, so a barrel resolved while tracking
+   * dependencies is not resolved again while looking for recipes.
+   */
+  private resolveModule;
   private trackDependencies;
   /**
    * Every file that transitively imports `filePath`, so a watcher can re-parse the

package/dist/index.d.mts

@@ -136,6 +136,9 @@ declare class Generator extends Context {
  * Get CSS for a specific theme
  */
 //#endregion
+//#region src/imported-recipes.d.ts
+type ResolveModule = (specifier: string, from: SourceFile) => SourceFile | undefined;
+//#endregion
 //#region src/unresolved-styles.d.ts
 interface UnresolvedStyle {
   /**
@@ -162,7 +165,17 @@ interface UnresolvedStyle {
    *   pair of alternatives.
    * - `too-many-combinations` — more ternary branches than it will enumerate.
    */
-  reason: 'unresolvable-value' | 'missing-property' | 'unenumerable-keys';
+  reason: 'unresolvable-value' | 'missing-property' | 'unenumerable-keys'
+  /**
+   * `css(recipe.raw(props), …)` — the build reads `.raw` as returning what it was passed.
+   *
+   * True of `css.raw`, which is the identity it was written for. A recipe or pattern's
+   * `.raw` takes *props* and returns *styles*, so the build composes the props instead: the
+   * recipe's own declarations never reach the stylesheet, and its variant names are handed
+   * to the encoder as if they were properties. The browser then asks for classes no rule
+   * backs, and the element renders without them.
+   */
+  | 'unresolved-raw';
 }
 declare const findUnresolvedStyles: (item: ResultItem, kind: "atomic") => UnresolvedStyle[];
 //#endregion
@@ -241,7 +254,16 @@ declare class ParserResult implements ParserResultInterface {
 }
 //#endregion
 //#region src/parser.d.ts
-declare function createParser(context: ParserOptions): (sourceFile: SourceFile | undefined, encoder?: Generator["encoder"], options?: ParserResultConfigureOptions) => ParserResult | undefined;
+declare function createParser(context: ParserOptions): (sourceFile: SourceFile | undefined, encoder?: Generator["encoder"], options?: ParserResultConfigureOptions,
+/**
+ * How to place a module specifier inside the project.
+ *
+ * Supplied by the caller because it owns the resolution cache, and because the cheap
+ * implementation is a filesystem lookup rather than a symbol-table walk. Absent, a
+ * recipe declared in another module stays invisible exactly as before.
+ */
+
+resolveModule?: ResolveModule) => ParserResult | undefined;
 //#endregion
 //#region src/project.d.ts
 interface ProjectOptions extends ProjectOptions$1 {
@@ -305,7 +327,23 @@ declare class Project {
    * `.d.ts` into the project. The graph only tracks files bamboo already scans.
    */
   private moduleResolutionCache;
+  /**
+   * Everything memoized against the shape of the file tree, including the negative half.
+   *
+   * `resolveModuleName` caches failures too, so a specifier that resolved to nothing before
+   * its target existed stays unresolved for the life of the process. That silently dropped a
+   * dependency edge; now it would also leave a recipe permanently invisible to the module
+   * importing it, since resolution is what finds one.
+   */
+  private invalidate;
   private resolveImport;
+  /**
+   * `resolveImport` in the shape a caller can use, for a specifier read off any declaration.
+   *
+   * Shares the module resolution cache above, so a barrel resolved while tracking
+   * dependencies is not resolved again while looking for recipes.
+   */
+  private resolveModule;
   private trackDependencies;
   /**
    * Every file that transitively imports `filePath`, so a watcher can re-parse the

package/dist/index.mjs

@@ -409,6 +409,11 @@ function createReportMaps() {
 }
 //#endregion
 //#region src/get-module-specifier-value.ts
+/**
+* Both declaration kinds carry a specifier, and `export { x } from './m'` is how a barrel
+* forwards a recipe — so this reads either. An `export { x }` with no `from` returns
+* undefined, which is the same answer the throwing case gives.
+*/
 const getModuleSpecifierValue = (node) => {
 	try {
 		return node.getModuleSpecifierValue();
@@ -417,6 +422,194 @@ const getModuleSpecifierValue = (node) => {
 	}
 };
 //#endregion
+//#region src/imported-recipes.ts
+/**
+* A module's exported recipes, memoized.
+*
+* Per *target*, so a barrel imported by two hundred files is walked once. Cleared alongside
+* the box-node cache, which is the same invalidation this needs: both memoize a conclusion
+* drawn from another file's contents.
+*/
+const exportedRecipes = /* @__PURE__ */ new Map();
+const clearImportedRecipeCache = () => {
+	exportedRecipes.clear();
+};
+/** The names a file bound `cva`/`sva` to, or empty when it imports neither. */
+const recipeFactoryAliases = (sourceFile, imports) => {
+	const aliases = /* @__PURE__ */ new Set();
+	for (const declaration of sourceFile.getImportDeclarations()) {
+		if (declaration.isTypeOnly()) continue;
+		const mod = getModuleSpecifierValue(declaration);
+		if (!mod) continue;
+		for (const specifier of declaration.getNamedImports()) {
+			if (specifier.isTypeOnly()) continue;
+			const name = specifier.getNameNode().getText();
+			if (name !== "cva" && name !== "sva") continue;
+			const alias = specifier.getAliasNode()?.getText() || name;
+			if (!imports.match({
+				name,
+				alias,
+				mod,
+				kind: "named"
+			})) continue;
+			aliases.add(alias);
+		}
+	}
+	return aliases;
+};
+/** Recipes this module declares itself, by the name it declared them under. */
+const declaredRecipes = (sourceFile, imports) => {
+	const declared = /* @__PURE__ */ new Map();
+	const exported = /* @__PURE__ */ new Set();
+	const factories = recipeFactoryAliases(sourceFile, imports);
+	if (factories.size === 0) return {
+		declared,
+		exported
+	};
+	const filePath = sourceFile.getFilePath();
+	for (const statement of sourceFile.compilerNode.statements) {
+		if (!ts.isVariableStatement(statement)) continue;
+		if (!(statement.declarationList.flags & ts.NodeFlags.Const)) continue;
+		for (const declaration of statement.declarationList.declarations) {
+			const initializer = declaration.initializer;
+			if (!initializer || !ts.isCallExpression(initializer)) continue;
+			const callee = initializer.expression;
+			if (!ts.isIdentifier(callee) || !ts.isIdentifier(declaration.name)) continue;
+			if (!factories.has(callee.text)) continue;
+			declared.set(declaration.name.text, {
+				filePath,
+				name: declaration.name.text
+			});
+			if (statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) exported.add(declaration.name.text);
+		}
+	}
+	return {
+		declared,
+		exported
+	};
+};
+/**
+* Every name this module exports that is bound to a recipe, and where it was declared.
+*
+* Follows `export { x } from './m'`, `export * from './m'`, and `import { x } … export { x }`,
+* because a barrel is how these are reached in practice. The origin is carried through each
+* hop rather than recomputed, so a consumer learns the *declaring* module however many
+* re-exports stand between them.
+*
+* A star export contributes only names nothing else exports, which is what the language does:
+* an explicit export shadows one arriving through `export *`. Resolving that the other way
+* folded a call against a config it would never have run.
+*/
+const walkExports = (sourceFile, imports, resolveModule, seen) => {
+	const cached = exportedRecipes.get(sourceFile);
+	if (cached) return {
+		names: cached,
+		complete: true
+	};
+	if (seen.has(sourceFile)) return {
+		names: /* @__PURE__ */ new Map(),
+		complete: false
+	};
+	seen.add(sourceFile);
+	const names = /* @__PURE__ */ new Map();
+	/** Reachable under a local name — declarations, plus recipes this module imports. */
+	const local = /* @__PURE__ */ new Map();
+	/** Held back so an explicit export of the same name wins. */
+	const starred = /* @__PURE__ */ new Map();
+	/** Names two different star exports both carry, which resolve to neither. */
+	const ambiguous = /* @__PURE__ */ new Set();
+	let complete = true;
+	const { declared, exported } = declaredRecipes(sourceFile, imports);
+	for (const [name, origin] of declared) {
+		local.set(name, origin);
+		if (exported.has(name)) names.set(name, origin);
+	}
+	const imported = walkImports(sourceFile, imports, resolveModule, seen);
+	complete &&= imported.complete;
+	for (const [alias, origin] of imported.bindings) if (!local.has(alias)) local.set(alias, origin);
+	for (const declaration of sourceFile.getExportDeclarations()) {
+		if (declaration.isTypeOnly()) continue;
+		const specifier = getModuleSpecifierValue(declaration);
+		const target = specifier ? resolveModule(specifier, sourceFile) : void 0;
+		if (specifier && !target) continue;
+		if (declaration.getNamespaceExport()) continue;
+		if (declaration.isNamespaceExport()) {
+			if (!target) continue;
+			const walk = walkExports(target, imports, resolveModule, seen);
+			complete &&= walk.complete;
+			for (const [name, origin] of walk.names) {
+				const existing = starred.get(name);
+				if (existing && (existing.filePath !== origin.filePath || existing.name !== origin.name)) {
+					ambiguous.add(name);
+					continue;
+				}
+				starred.set(name, origin);
+			}
+			continue;
+		}
+		let source = local;
+		if (target) {
+			const walk = walkExports(target, imports, resolveModule, seen);
+			complete &&= walk.complete;
+			source = walk.names;
+		}
+		for (const exportSpecifier of declaration.getNamedExports()) {
+			if (exportSpecifier.isTypeOnly()) continue;
+			const name = exportSpecifier.getNameNode().getText();
+			const origin = source.get(name);
+			if (origin) names.set(exportSpecifier.getAliasNode()?.getText() || name, origin);
+		}
+	}
+	for (const [name, origin] of starred) if (!names.has(name) && !ambiguous.has(name)) names.set(name, origin);
+	if (complete) exportedRecipes.set(sourceFile, names);
+	return {
+		names,
+		complete
+	};
+};
+/**
+* Local names in this file bound, through an import, to a recipe declared elsewhere.
+*
+* Reports truncation for the same reason `walkExports` does: `export { x }` with no `from`
+* resolves through here, so a walk cut short by a cycle can leave a name out — and caching
+* that as the whole answer is what makes visibility depend on where the walk began.
+*/
+const walkImports = (sourceFile, imports, resolveModule, seen) => {
+	const bindings = /* @__PURE__ */ new Map();
+	let complete = true;
+	for (const declaration of sourceFile.getImportDeclarations()) {
+		if (declaration.isTypeOnly()) continue;
+		const named = declaration.getNamedImports();
+		if (named.length === 0) continue;
+		const specifier = getModuleSpecifierValue(declaration);
+		if (!specifier) continue;
+		const target = resolveModule(specifier, sourceFile);
+		if (!target || target === sourceFile) continue;
+		const walk = walkExports(target, imports, resolveModule, seen);
+		complete &&= walk.complete;
+		const { names } = walk;
+		if (names.size === 0) continue;
+		for (const importSpecifier of named) {
+			if (importSpecifier.isTypeOnly()) continue;
+			const origin = names.get(importSpecifier.getNameNode().getText());
+			if (!origin) continue;
+			bindings.set(importSpecifier.getAliasNode()?.getText() || importSpecifier.getNameNode().getText(), origin);
+		}
+	}
+	return {
+		bindings,
+		complete
+	};
+};
+/**
+* Local names in this file bound, through an import, to a recipe declared elsewhere.
+*
+* Only specifiers the caller's resolver can place inside the project. A recipe outside the
+* project's `include` is never parsed, so it has no rules in the stylesheet and could not be
+* folded against even if the binding resolved.
+*/
+const importedRecipeBindings = (sourceFile, imports, resolveModule) => walkImports(sourceFile, imports, resolveModule, new Set([sourceFile])).bindings;
+//#endregion
 //#region src/get-import-declarations.ts
 function getImportDeclarations(context, sourceFile) {
 	const { imports, tsOptions } = context;
@@ -859,14 +1052,16 @@ const fallbackImpl = (...values) => values.some((value) => value === void 0) ? v
 const evaluateOptions = { environment: defaultEnv };
 function createParser(context) {
 	const { jsx, imports, recipes } = context;
-	return function parse(sourceFile, encoder, options) {
+	return function parse(sourceFile, encoder, options, resolveModule) {
 		if (!sourceFile) return;
 		const importDeclarations = getImportDeclarations(context, sourceFile);
 		const file = imports.file(importDeclarations);
 		const filePath = sourceFile.getFilePath();
 		logger.debug("ast:import", !file.isEmpty() ? `Found import { ${file.toString()} } in ${filePath}` : `No import found in ${filePath}`);
 		const parserResult = new ParserResult(context, encoder);
-		if (file.isEmpty() && !jsx.isEnabled) return parserResult;
+		const importedRecipes = resolveModule ? importedRecipeBindings(sourceFile, imports, resolveModule) : /* @__PURE__ */ new Map();
+		if (file.isEmpty() && !jsx.isEnabled && importedRecipes.size === 0) return parserResult;
+		for (const binding of importedRecipes.keys()) file.addLocalRecipe(binding);
 		if (file.importsRecipeFactory()) for (const statement of sourceFile.compilerNode.statements) {
 			if (!ts.isVariableStatement(statement)) continue;
 			if (!(statement.declarationList.flags & ts.NodeFlags.Const)) continue;
@@ -881,6 +1076,27 @@ function createParser(context) {
 				file.addLocalRecipe(declaration.name.text);
 			}
 		}
+		/**
+		* `css(recipe.raw(props), …)` loses what the recipe would have contributed.
+		*
+		* `.raw` on a recipe or pattern takes props and returns styles; the build reads it as the
+		* identity `css.raw` means. Resolving it properly would mean running the recipe here, and
+		* emitting the wrong styles is worse than emitting none — so this says so rather than
+		* guessing.
+		*
+		* Defined out here rather than inside `getEvaluateOptions`, which runs per call node.
+		*/
+		const reportUnresolvedRaw = (base, at) => {
+			const { line, column } = sourceFile.getLineAndColumnAtPos(at.getStart());
+			parserResult.unresolved.push({
+				kind: "atomic",
+				prop: base,
+				filePath,
+				line,
+				column,
+				reason: "unresolved-raw"
+			});
+		};
 		extract({
 			ast: sourceFile,
 			tokens: context.tokens ? {
@@ -919,8 +1135,14 @@ function createParser(context) {
 				}
 				if (!Node.isPropertyAccessExpression(propAccessExpr)) return evaluateOptions;
 				let name = propAccessExpr.getText();
+				const rawBase = name.endsWith(".raw") ? name.slice(0, -4) : void 0;
+				if (rawBase && file.isLocalRecipe(rawBase)) {
+					reportUnresolvedRaw(rawBase, node);
+					return evaluateOptions;
+				}
 				if (!file.isRawFn(name)) return evaluateOptions;
 				name = name.replace(".raw", "");
+				if (file.isValidRecipe(name) || file.isValidPattern(name)) reportUnresolvedRaw(name, node);
 				return { environment: Object.assign({}, defaultEnv, { extra: { [name]: { raw: (v) => v } } }) };
 			},
 			flags: { skipTraverseFiles: false }
@@ -936,7 +1158,8 @@ function createParser(context) {
 						if (query.kind === "call-expression") parserResult.setCvaCall(alias, {
 							name: alias,
 							box: query.box.value[0] ?? box.fallback(query.box),
-							data: combineResult(unbox(query.box.value[0]))
+							data: combineResult(unbox(query.box.value[0])),
+							origin: importedRecipes.get(alias)
 						});
 					});
 					return;
@@ -1008,6 +1231,17 @@ function createParser(context) {
 }
 //#endregion
 //#region src/project.ts
+/**
+* Everything memoized against another file's contents.
+*
+* Both caches answer a question about a *different* module than the one being parsed — what
+* an identifier resolved to, and which recipes a module exports — so both go stale on exactly
+* the same events, and clearing one without the other leaves the pair disagreeing.
+*/
+const invalidateResolutions = () => {
+	clearBoxNodeCache();
+	clearImportedRecipeCache();
+};
 const normalizeCompilerOptions = (raw) => {
 	if (!raw) return {};
 	const { options } = ts.convertCompilerOptionsFromJson(raw, process.cwd());
@@ -1091,6 +1325,18 @@ var Project = class {
 	* `.d.ts` into the project. The graph only tracks files bamboo already scans.
 	*/
 	moduleResolutionCache;
+	/**
+	* Everything memoized against the shape of the file tree, including the negative half.
+	*
+	* `resolveModuleName` caches failures too, so a specifier that resolved to nothing before
+	* its target existed stays unresolved for the life of the process. That silently dropped a
+	* dependency edge; now it would also leave a recipe permanently invisible to the module
+	* importing it, since resolution is what finds one.
+	*/
+	invalidate = (fileTreeChanged = true) => {
+		invalidateResolutions();
+		if (fileTreeChanged) this.moduleResolutionCache = void 0;
+	};
 	resolveImport = (decl) => {
 		const moduleName = decl.getModuleSpecifierValue();
 		if (!moduleName) return;
@@ -1099,6 +1345,16 @@ var Project = class {
 		const name = ts.resolveModuleName(moduleName, decl.getSourceFile().getFilePath(), compilerOptions, this.project.getModuleResolutionHost(), this.moduleResolutionCache).resolvedModule?.resolvedFileName;
 		return name ? this.project.getSourceFile(name) : void 0;
 	};
+	/**
+	* `resolveImport` in the shape a caller can use, for a specifier read off any declaration.
+	*
+	* Shares the module resolution cache above, so a barrel resolved while tracking
+	* dependencies is not resolved again while looking for recipes.
+	*/
+	resolveModule = (specifier, from) => this.resolveImport({
+		getModuleSpecifierValue: () => specifier,
+		getSourceFile: () => from
+	});
 	trackDependencies = (filePath, sourceFile) => {
 		const importer = this.normalizePath(sourceFile.getFilePath());
 		this.canonicalPaths.set(this.normalizePath(filePath), importer);
@@ -1145,7 +1401,7 @@ var Project = class {
 	};
 	createSourceFile = (filePath) => {
 		const { readFile } = this.options;
-		clearBoxNodeCache();
+		this.invalidate();
 		return this.project.createSourceFile(filePath, readFile(filePath), {
 			overwrite: true,
 			scriptKind: ScriptKind.TSX
@@ -1156,7 +1412,7 @@ var Project = class {
 		for (const file of files) this.createSourceFile(file);
 	};
 	addSourceFile = (filePath, content) => {
-		clearBoxNodeCache();
+		this.invalidate(!(filePath.includes("/") && this.project.getSourceFile(filePath)));
 		return this.project.createSourceFile(filePath, content, {
 			overwrite: true,
 			scriptKind: ScriptKind.TSX
@@ -1165,18 +1421,18 @@ var Project = class {
 	removeSourceFile = (filePath) => {
 		const sourceFile = this.project.getSourceFile(filePath);
 		if (sourceFile) {
-			clearBoxNodeCache();
+			this.invalidate();
 			return this.project.removeSourceFile(sourceFile);
 		}
 		return false;
 	};
 	reloadSourceFile = (filePath) => {
-		clearBoxNodeCache();
+		this.invalidate(false);
 		return this.getSourceFile(filePath)?.refreshFromFileSystemSync();
 	};
 	reloadSourceFiles = () => {
 		const files = this.getFiles();
-		clearBoxNodeCache();
+		this.invalidate();
 		for (const file of files) this.getSourceFile(file)?.refreshFromFileSystemSync() ?? this.project.addSourceFileAtPath(file);
 	};
 	get readFile() {
@@ -1210,7 +1466,7 @@ var Project = class {
 			}
 		}) ?? this.transformFile(filePath, original);
 		if (original !== transformed) sourceFile.replaceWithText(transformed);
-		const result = this.parser(sourceFile, encoder, options)?.setFilePath(filePath);
+		const result = this.parser(sourceFile, encoder, options, this.resolveModule)?.setFilePath(filePath);
 		hooks["parser:after"]?.({
 			filePath,
 			result

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bamboocss/parser",
-  "version": "1.25.0",
+  "version": "1.28.0",
   "description": "The static parser for bamboo css",
   "homepage": "https://bamboocss.com",
   "license": "MIT",
@@ -34,17 +34,17 @@
   "dependencies": {
     "ts-morph": "28.0.0",
     "ts-pattern": "5.9.0",
-    "@bamboocss/config": "^1.25.0",
-    "@bamboocss/core": "^1.25.0",
-    "@bamboocss/extractor": "1.25.0",
-    "@bamboocss/logger": "1.25.0",
-    "@bamboocss/shared": "1.25.0",
-    "@bamboocss/types": "1.25.0"
+    "@bamboocss/config": "^1.28.0",
+    "@bamboocss/core": "^1.28.0",
+    "@bamboocss/extractor": "1.28.0",
+    "@bamboocss/logger": "1.28.0",
+    "@bamboocss/shared": "1.28.0",
+    "@bamboocss/types": "1.28.0"
   },
   "devDependencies": {
-    "@bamboocss/generator": "1.25.0",
-    "@bamboocss/plugin-svelte": "1.25.0",
-    "@bamboocss/plugin-vue": "1.25.0"
+    "@bamboocss/generator": "1.28.0",
+    "@bamboocss/plugin-svelte": "1.28.0",
+    "@bamboocss/plugin-vue": "1.28.0"
   },
   "scripts": {
     "build": "tsdown src/index.ts --format=esm,cjs --dts",