@bamboocss/parser 1.26.0 → 1.28.1

package/dist/index.cjs

@@ -65,7 +65,7 @@ function classifyProject(ctx, resultMap) {
 		const { item, kind, filepath, localMaps } = opts;
 		if (!item.box || _bamboocss_extractor.box.isUnresolvable(item.box)) return;
 		if (!item.data) return;
-		if (item.type === "cva-call") return;
+		if (item.type === "cva-call" || item.type === "tokenVar") return;
 		const componentReportItem = {
 			componentIndex: String(componentIndex++),
 			componentName: item.name,
@@ -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;
@@ -769,8 +962,14 @@ var ParserResult = class {
 		const unresolved = findUnresolvedRecipeStyles(result);
 		if (unresolved.length) this.unresolved.push(...unresolved);
 	}
-	setToken(result) {
-		this.token.add(this.append(Object.assign({ type: "token" }, result)));
+	/**
+	* `kind` separates `token()` from `token.var()`, which resolve to the value and to the
+	* variable reference respectively. They share this set deliberately: everything that reads
+	* a result for the token *path* — `collectTokenReferences`, keeping a declaration alive
+	* through pruning — wants both, and only the fold cares which half was asked for.
+	*/
+	setToken(result, kind = "token") {
+		this.token.add(this.append(Object.assign({ type: kind }, result)));
 	}
 	setViewTransition(result) {
 		this.viewTransition.add(this.append(Object.assign({ type: "viewTransition" }, result)));
@@ -860,14 +1059,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;
@@ -964,11 +1165,22 @@ 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;
 				}
+				if (file.isTokenVarFn(alias)) {
+					result.queryList.forEach((query) => {
+						if (query.kind === "call-expression") parserResult.setToken({
+							name: "token.var",
+							box: query.box.value[0] ?? _bamboocss_extractor.box.fallback(query.box),
+							data: combineResult((0, _bamboocss_extractor.unbox)(query.box.value[0]))
+						}, "tokenVar");
+					});
+					return;
+				}
 				(0, ts_pattern.match)(name).when(imports.matchers.css.match, (name) => {
 					result.queryList.forEach((query) => {
 						if (query.kind === "call-expression") if (query.box.value.length > 1) parserResult.set(name, {
@@ -1036,6 +1248,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());
@@ -1119,6 +1342,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;
@@ -1127,6 +1362,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);
@@ -1173,7 +1418,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
@@ -1184,7 +1429,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
@@ -1193,18 +1438,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() {
@@ -1238,7 +1483,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 {
   /**
@@ -226,7 +229,13 @@ declare class ParserResult implements ParserResultInterface {
    * hash except an explicit `className`, which is what the message says to reach for.
    */
   private reportUnresolvedRecipe;
-  setToken(result: ResultItem): void;
+  /**
+   * `kind` separates `token()` from `token.var()`, which resolve to the value and to the
+   * variable reference respectively. They share this set deliberately: everything that reads
+   * a result for the token *path* — `collectTokenReferences`, keeping a declaration alive
+   * through pruning — wants both, and only the fold cares which half was asked for.
+   */
+  setToken(result: ResultItem, kind?: 'token' | 'tokenVar'): void;
   setViewTransition(result: ResultItem): void;
   setPattern(name: string, result: ResultItem): void;
   setRecipe(recipeName: string, result: ResultItem): void;
@@ -251,7 +260,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 {
@@ -315,7 +333,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 {
   /**
@@ -226,7 +229,13 @@ declare class ParserResult implements ParserResultInterface {
    * hash except an explicit `className`, which is what the message says to reach for.
    */
   private reportUnresolvedRecipe;
-  setToken(result: ResultItem): void;
+  /**
+   * `kind` separates `token()` from `token.var()`, which resolve to the value and to the
+   * variable reference respectively. They share this set deliberately: everything that reads
+   * a result for the token *path* — `collectTokenReferences`, keeping a declaration alive
+   * through pruning — wants both, and only the fold cares which half was asked for.
+   */
+  setToken(result: ResultItem, kind?: 'token' | 'tokenVar'): void;
   setViewTransition(result: ResultItem): void;
   setPattern(name: string, result: ResultItem): void;
   setRecipe(recipeName: string, result: ResultItem): void;
@@ -251,7 +260,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 {
@@ -315,7 +333,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

@@ -64,7 +64,7 @@ function classifyProject(ctx, resultMap) {
 		const { item, kind, filepath, localMaps } = opts;
 		if (!item.box || box.isUnresolvable(item.box)) return;
 		if (!item.data) return;
-		if (item.type === "cva-call") return;
+		if (item.type === "cva-call" || item.type === "tokenVar") return;
 		const componentReportItem = {
 			componentIndex: String(componentIndex++),
 			componentName: item.name,
@@ -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;
@@ -768,8 +961,14 @@ var ParserResult = class {
 		const unresolved = findUnresolvedRecipeStyles(result);
 		if (unresolved.length) this.unresolved.push(...unresolved);
 	}
-	setToken(result) {
-		this.token.add(this.append(Object.assign({ type: "token" }, result)));
+	/**
+	* `kind` separates `token()` from `token.var()`, which resolve to the value and to the
+	* variable reference respectively. They share this set deliberately: everything that reads
+	* a result for the token *path* — `collectTokenReferences`, keeping a declaration alive
+	* through pruning — wants both, and only the fold cares which half was asked for.
+	*/
+	setToken(result, kind = "token") {
+		this.token.add(this.append(Object.assign({ type: kind }, result)));
 	}
 	setViewTransition(result) {
 		this.viewTransition.add(this.append(Object.assign({ type: "viewTransition" }, result)));
@@ -859,14 +1058,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;
@@ -963,11 +1164,22 @@ 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;
 				}
+				if (file.isTokenVarFn(alias)) {
+					result.queryList.forEach((query) => {
+						if (query.kind === "call-expression") parserResult.setToken({
+							name: "token.var",
+							box: query.box.value[0] ?? box.fallback(query.box),
+							data: combineResult(unbox(query.box.value[0]))
+						}, "tokenVar");
+					});
+					return;
+				}
 				match(name).when(imports.matchers.css.match, (name) => {
 					result.queryList.forEach((query) => {
 						if (query.kind === "call-expression") if (query.box.value.length > 1) parserResult.set(name, {
@@ -1035,6 +1247,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());
@@ -1118,6 +1341,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;
@@ -1126,6 +1361,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);
@@ -1172,7 +1417,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
@@ -1183,7 +1428,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
@@ -1192,18 +1437,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() {
@@ -1237,7 +1482,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.26.0",
+  "version": "1.28.1",
   "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.26.0",
-    "@bamboocss/core": "^1.26.0",
-    "@bamboocss/extractor": "1.26.0",
-    "@bamboocss/logger": "1.26.0",
-    "@bamboocss/shared": "1.26.0",
-    "@bamboocss/types": "1.26.0"
+    "@bamboocss/extractor": "1.28.1",
+    "@bamboocss/core": "^1.28.1",
+    "@bamboocss/config": "^1.28.1",
+    "@bamboocss/logger": "1.28.1",
+    "@bamboocss/shared": "1.28.1",
+    "@bamboocss/types": "1.28.1"
   },
   "devDependencies": {
-    "@bamboocss/generator": "1.26.0",
-    "@bamboocss/plugin-svelte": "1.26.0",
-    "@bamboocss/plugin-vue": "1.26.0"
+    "@bamboocss/generator": "1.28.1",
+    "@bamboocss/plugin-svelte": "1.28.1",
+    "@bamboocss/plugin-vue": "1.28.1"
   },
   "scripts": {
     "build": "tsdown src/index.ts --format=esm,cjs --dts",