@bamboocss/extractor 1.45.5 → 1.46.1

package/dist/index.cjs

@@ -306,6 +306,65 @@ const box = {
 	}
 };
 //#endregion
+//#region src/dependency-cache.ts
+const EMPTY_DEPENDENCIES = [];
+/** One synchronous extraction context owns one nested capture stack. */
+const trackers = /* @__PURE__ */ new WeakMap();
+/**
+* Attribute one resolved local module to every cache computation currently enclosing it.
+*
+* Paths, rather than SourceFile objects, are the replay payload. A source replacement may
+* retire every node in a file, while its stable path is exactly the fact a fresh ParserResult
+* needs. The caller-facing callback stays outside the cache and therefore belongs to the
+* current query/environment rather than whichever parse populated the entry.
+*/
+const recordModuleDependency = (ctx, filePath) => {
+	const normalized = filePath.replaceAll("\\", "/");
+	const tracker = trackers.get(ctx);
+	if (tracker) for (const frame of tracker.frames) {
+		frame.dependencies ??= /* @__PURE__ */ new Set();
+		frame.dependencies.add(normalized);
+	}
+	ctx.recordDependency?.(normalized);
+};
+/** Begin one nested cache computation without allocating a Set on dependency-free paths. */
+const beginDependencyCapture = (ctx) => {
+	let tracker = trackers.get(ctx);
+	if (!tracker) {
+		tracker = { frames: [] };
+		trackers.set(ctx, tracker);
+	}
+	const frame = {};
+	tracker.frames.push(frame);
+	return {
+		entry(value) {
+			return {
+				dependencies: frame.dependencies ? [...frame.dependencies].sort() : EMPTY_DEPENDENCIES,
+				resolveModule: ctx.resolveModule,
+				value
+			};
+		},
+		end() {
+			tracker.frames.pop();
+		}
+	};
+};
+/**
+* Replay a hit only inside the resolver scope which computed it.
+*
+* The same ts-morph node can be inspected under two extractor contexts with different module
+* placement rules. Returning the first context's value or dependency paths to the second would
+* be cross-Project leakage, so a scope mismatch is a cache miss and gets overwritten normally.
+*/
+const replayDependencyCache = (entry, ctx) => {
+	if (entry.resolveModule !== ctx.resolveModule) return { hit: false };
+	for (const dependency of entry.dependencies) recordModuleDependency(ctx, dependency);
+	return {
+		hit: true,
+		value: entry.value
+	};
+};
+//#endregion
 //#region src/resolve-imported-value.ts
 /**
 * The values an expression borrows from other modules, resolved by reading the imports.
@@ -322,9 +381,9 @@ const box = {
 * rather than with the number of style calls — a large project reported a 5.4x extraction
 * slowdown and an OOM in CI.
 *
-* Following an import is two cheap steps this package already had: resolve the specifier to
-* a file (`ts.resolveModuleName`, path lookup, no checker), then read that file's exported
-* declaration. Crossing the import boundary is the only thing the checker was doing here.
+* Following an import is two cheap steps: ask the caller's source-graph resolver to place the
+* specifier, then read that file's exported declaration. Crossing the import boundary is the
+* only thing the checker was doing here.
 *
 * The evaluator resolves everything *within* a module by walking scopes, so a helper that
 * refers to another binding in its own file needs nothing from us.
@@ -332,7 +391,14 @@ const box = {
 /** How far a chain of helpers importing helpers is followed. */
 const MAX_DEPTH = 4;
 /** Evaluated once per declaration, however many call sites reach it. */
-const evaluatedValues = /* @__PURE__ */ new WeakMap();
+let evaluatedValues = /* @__PURE__ */ new WeakMap();
+let hasEvaluatedValues = false;
+/** @internal Drop imported declarations whose closure may include an edited module. */
+const clearImportedValueCache = () => {
+	if (!hasEvaluatedValues) return;
+	evaluatedValues = /* @__PURE__ */ new WeakMap();
+	hasEvaluatedValues = false;
+};
 /**
 * Local name to the name and declaration it was imported from.
 *
@@ -362,17 +428,28 @@ const importBindingsFor = (sourceFile) => {
 };
 /** What an imported name refers to, or nothing if it cannot be reached safely. */
 const valueForBinding = (binding, ctx, stack, depth, evaluateExpression) => {
-	const sourceFile = getModuleSpecifierSourceFile(binding.declaration);
+	const sourceFile = getModuleSpecifierSourceFile(binding.declaration, ctx);
 	if (!sourceFile) return;
 	if (sourceFile.isInNodeModules()) return;
 	const declaration = getExportedVarDeclarationWithName(binding.exportedName, sourceFile, stack, ctx);
 	if (!declaration) return;
-	if (evaluatedValues.has(declaration)) return { value: evaluatedValues.get(declaration) };
+	const cached = evaluatedValues.get(declaration);
+	if (cached) {
+		const replayed = replayDependencyCache(cached, ctx);
+		if (replayed.hit) return { value: replayed.value };
+	}
 	const initializer = declaration.getInitializer();
 	if (!initializer) return;
-	const value = evaluateExpression(initializer, stack, ctx, depth + 1);
+	const capture = beginDependencyCapture(ctx);
+	let value;
+	try {
+		value = evaluateExpression(initializer, stack, ctx, depth + 1);
+	} finally {
+		capture.end();
+	}
 	if (value === void 0) return;
-	evaluatedValues.set(declaration, value);
+	evaluatedValues.set(declaration, capture.entry(value));
+	hasEvaluatedValues = true;
 	return { value };
 };
 /**
@@ -385,27 +462,34 @@ const valueForBinding = (binding, ctx, stack, depth, evaluateExpression) => {
 */
 const importedEnvironmentFor = (node, ctx, stack, depth, evaluateExpression) => {
 	if (depth >= MAX_DEPTH) return;
-	const calls = node.getDescendantsOfKind(ts_morph.SyntaxKind.CallExpression);
-	if (ts_morph.Node.isCallExpression(node)) calls.unshift(node);
-	if (!calls.length) return;
 	const bindings = importBindingsFor(node.getSourceFile());
 	if (!bindings.size) return;
+	const references = node.getDescendantsOfKind(ts_morph.SyntaxKind.Identifier);
+	if (ts_morph.Node.isIdentifier(node)) references.unshift(node);
+	if (!references.length) return;
 	let environment;
-	for (const call of calls) {
-		const callee = call.getExpression();
-		const binding = bindings.get(callee.getText());
-		if (!binding || environment?.[callee.getText()] !== void 0) continue;
+	for (const reference of references) {
+		const name = reference.getText();
+		const binding = bindings.get(name);
+		if (!binding || environment?.[name] !== void 0) continue;
 		const resolved = valueForBinding(binding, ctx, stack, depth, evaluateExpression);
 		if (!resolved) continue;
 		environment ??= {};
-		environment[callee.getText()] = resolved.value;
+		environment[name] = resolved.value;
 	}
 	return environment;
 };
 //#endregion
 //#region src/evaluate-node.ts
 const TsEvalError = Symbol("EvalError");
-const cacheMap$2 = /* @__PURE__ */ new WeakMap();
+let cacheMap$2 = /* @__PURE__ */ new WeakMap();
+let hasCachedEntries$1 = false;
+/** @internal Drop values whose expression may close over an edited source file. */
+const clearEvaluateNodeCache = () => {
+	if (!hasCachedEntries$1) return;
+	cacheMap$2 = /* @__PURE__ */ new WeakMap();
+	hasCachedEntries$1 = false;
+};
 /** @see https://github.com/wessberg/ts-evaluator#setting-up-policies */
 const POLICY = {
 	console: false,
@@ -436,13 +520,39 @@ const POLICY = {
 const evaluateNode = (node, stack, ctx, depth = 0) => {
 	if (ctx.flags?.skipEvaluate) return;
 	if (ctx.canEval && !ctx.canEval?.(node, stack)) return;
-	if (depth === 0 && cacheMap$2.has(node)) return cacheMap$2.get(node);
-	const options = {
+	const cached = depth === 0 ? cacheMap$2.get(node) : void 0;
+	if (cached) {
+		const replayed = replayDependencyCache(cached, ctx);
+		if (replayed.hit) return replayed.value;
+	}
+	const capture = depth === 0 ? beginDependencyCapture(ctx) : void 0;
+	try {
+		return evaluateNodeUncached(node, stack, ctx, depth, capture?.entry);
+	} finally {
+		capture?.end();
+	}
+};
+const evaluateNodeUncached = (node, stack, ctx, depth, dependencyEntry) => {
+	let options = {
 		policy: { ...POLICY },
 		...ctx.getEvaluateOptions?.(node, stack),
 		node: node.compilerNode,
 		typescript: ts_morph.ts
 	};
+	let imported = depth > 0 ? importedEnvironmentFor(node, ctx, stack, depth, safeEvaluateNode) : void 0;
+	if (imported) {
+		const environment = options.environment;
+		options = {
+			...options,
+			environment: {
+				...environment,
+				extra: {
+					...environment?.extra,
+					...imported
+				}
+			}
+		};
+	}
 	let result = (0, ts_evaluator.evaluate)(options);
 	/**
 	* Retried only on failure, with whatever this expression imports put in scope.
@@ -454,17 +564,26 @@ const evaluateNode = (node, stack, ctx, depth = 0) => {
 	* the path of every build.
 	*/
 	if (!result.success) {
-		const imported = importedEnvironmentFor(node, ctx, stack, depth, safeEvaluateNode);
-		if (imported) result = (0, ts_evaluator.evaluate)({
-			...options,
-			environment: {
-				...options.environment,
-				extra: imported
-			}
-		});
+		imported ??= importedEnvironmentFor(node, ctx, stack, depth, safeEvaluateNode);
+		if (imported) {
+			const environment = options.environment;
+			result = (0, ts_evaluator.evaluate)({
+				...options,
+				environment: {
+					...environment,
+					extra: {
+						...environment?.extra,
+						...imported
+					}
+				}
+			});
+		}
 	}
 	const expr = result.success ? result.value : TsEvalError;
-	if (depth === 0) cacheMap$2.set(node, expr);
+	if (depth === 0) {
+		cacheMap$2.set(node, dependencyEntry(expr));
+		hasCachedEntries$1 = true;
+	}
 	return expr;
 };
 const safeEvaluateNode = (node, stack, ctx, depth = 0) => {
@@ -487,7 +606,7 @@ function getDeclarationFor(node, stack, ctx) {
 		declaration = parent;
 	} else if (ts_morph.Node.isImportSpecifier(parent) && (parent.getNameNode() == node || parent.getAliasNode() == node)) {
 		if (ctx.flags?.skipTraverseFiles) return;
-		const sourceFile = getModuleSpecifierSourceFile(parent.getImportDeclaration());
+		const sourceFile = getModuleSpecifierSourceFile(parent.getImportDeclaration(), ctx);
 		if (sourceFile) {
 			const exportStack = [parent, sourceFile];
 			const maybeVar = getExportedVarDeclarationWithName(parent.getNameNode().getText(), sourceFile, exportStack, ctx);
@@ -505,53 +624,74 @@ const getInnermostScope = (from) => {
 	while (scope && !isScope(scope)) scope = scope.getParent();
 	return scope;
 };
+/**
+* Keyed on the compiler node, never the ts-morph wrapper.
+*
+* `Project.replaceWithText` — which is how a re-parse installs a source transform — keeps the
+* wrapper identity and swaps the compiler node underneath it. A wrapper-keyed cache would
+* therefore answer a rebuild from the previous revision of the file, which is a wrong
+* stylesheet rather than a slow one. Keying on the compiler node makes the cache
+* self-invalidating: ts-morph reuses a compiler node exactly when its subtree did not change.
+*/
+const declarationIndexes = /* @__PURE__ */ new WeakMap();
+const isDeclarationName = (node, parent) => {
+	if (ts_morph.Node.isVariableDeclaration(parent) || ts_morph.Node.isParameterDeclaration(parent) || ts_morph.Node.isFunctionDeclaration(parent) || ts_morph.Node.isEnumDeclaration(parent) || ts_morph.Node.isBindingElement(parent)) return parent.getNameNode() == node;
+	return ts_morph.Node.isImportSpecifier(parent) && (parent.getNameNode() == node || parent.getAliasNode() == node);
+};
+/**
+* Walk a scope once, so that every later lookup inside it is a map read.
+*
+* This used to be a `forEachDescendant` per identifier, widening to each enclosing scope and
+* re-walking from scratch, calling `getText()` on every identifier it passed. A module whose
+* declarations are referenced n times paid n full traversals of itself, and traversal is where
+* ts-morph charges for wrapping each node — it measured ~10% of extraction on its own.
+*/
+const declarationIndexFor = (scope) => {
+	const cached = declarationIndexes.get(scope.compilerNode);
+	if (cached) return cached;
+	const index = /* @__PURE__ */ new Map();
+	scope.forEachDescendant((node) => {
+		if (!ts_morph.Node.isIdentifier(node)) return;
+		const parent = node.getParent();
+		if (!parent || !isDeclarationName(node, parent)) return;
+		const name = node.getText();
+		const declared = index.get(name);
+		if (declared) declared.push(node);
+		else index.set(name, [node]);
+	});
+	declarationIndexes.set(scope.compilerNode, index);
+	return index;
+};
 function findIdentifierValueDeclaration(identifier, stack, ctx, visitedsWithStack = /* @__PURE__ */ new Map()) {
 	let scope = identifier;
-	let foundNode;
-	let isUnresolvable = false;
 	let count = 0;
 	const innerStack = [];
+	const refName = identifier.getText();
 	do {
 		scope = getInnermostScope(scope);
 		count++;
 		if (!scope) return;
-		const refName = identifier.getText();
-		scope.forEachDescendant((node, traversal) => {
-			if (visitedsWithStack.has(node)) {
-				traversal.skip();
-				innerStack.push(...visitedsWithStack.get(node));
-				return;
+		for (const candidate of declarationIndexFor(scope).get(refName) ?? []) {
+			if (candidate == identifier) continue;
+			if (visitedsWithStack.has(candidate)) continue;
+			visitedsWithStack.set(candidate, innerStack);
+			const declarationStack = [candidate];
+			const maybeDeclaration = getDeclarationFor(candidate, declarationStack, ctx);
+			if (!maybeDeclaration) continue;
+			if (ts_morph.Node.isParameterDeclaration(maybeDeclaration)) {
+				const initializer = maybeDeclaration.getInitializer();
+				const typeNode = maybeDeclaration.getTypeNode();
+				if (initializer) innerStack.push(...declarationStack.concat(initializer));
+				else if (typeNode && ts_morph.Node.isTypeLiteral(typeNode)) innerStack.push(...declarationStack.concat(typeNode));
+				else return;
+				stack.push(...innerStack);
+				return maybeDeclaration;
 			}
-			if (node == identifier) return;
-			visitedsWithStack.set(node, innerStack);
-			if (ts_morph.Node.isIdentifier(node) && node.getText() == refName) {
-				const declarationStack = [node];
-				const maybeDeclaration = getDeclarationFor(node, declarationStack, ctx);
-				if (maybeDeclaration) {
-					if (ts_morph.Node.isParameterDeclaration(maybeDeclaration)) {
-						const initializer = maybeDeclaration.getInitializer();
-						const typeNode = maybeDeclaration.getTypeNode();
-						if (initializer) {
-							innerStack.push(...declarationStack.concat(initializer));
-							foundNode = maybeDeclaration;
-						} else if (typeNode && ts_morph.Node.isTypeLiteral(typeNode)) {
-							innerStack.push(...declarationStack.concat(typeNode));
-							foundNode = maybeDeclaration;
-						} else isUnresolvable = true;
-						traversal.stop();
-						return;
-					}
-					innerStack.push(...declarationStack);
-					foundNode = maybeDeclaration;
-					traversal.stop();
-				}
-			}
-		});
-		if (foundNode || isUnresolvable) {
-			if (foundNode) stack.push(...innerStack);
-			return foundNode;
+			innerStack.push(...declarationStack);
+			stack.push(...innerStack);
+			return maybeDeclaration;
 		}
-	} while (scope && !ts_morph.Node.isSourceFile(scope) && !foundNode && !isUnresolvable && count < 100);
+	} while (scope && !ts_morph.Node.isSourceFile(scope) && count < 100);
 }
 //#endregion
 //#region src/get-property-name.ts
@@ -665,7 +805,6 @@ const getObjectLiteralExpressionPropPairs = (expression, expressionStack, ctx, m
 //#endregion
 //#region src/maybe-box-node.ts
 let cacheMap$1 = /* @__PURE__ */ new WeakMap();
-const isCached = (node) => cacheMap$1.has(node);
 const getCached = (node) => cacheMap$1.get(node);
 /**
 * Drops every memoized resolution.
@@ -676,6 +815,8 @@ const getCached = (node) => cacheMap$1.get(node);
 * otherwise keep serving the value read before the edit.
 */
 const clearBoxNodeCache = () => {
+	clearEvaluateNodeCache();
+	clearImportedValueCache();
 	if (!hasCachedEntries) return;
 	cacheMap$1 = /* @__PURE__ */ new WeakMap();
 	hasCachedEntries = false;
@@ -688,12 +829,24 @@ const canReturnWhenTrueInLogicalExpression = (op) => {
 	return op === ts_morph.ts.SyntaxKind.BarBarToken || op === ts_morph.ts.SyntaxKind.QuestionQuestionToken;
 };
 function maybeBoxNode(node, stack, ctx, matchProp) {
+	const cached = getCached(node);
+	if (cached) {
+		const replayed = replayDependencyCache(cached, ctx);
+		if (replayed.hit) return replayed.value;
+	}
+	const capture = beginDependencyCapture(ctx);
+	try {
+		return maybeBoxNodeUncached(node, stack, ctx, matchProp, capture.entry);
+	} finally {
+		capture.end();
+	}
+}
+function maybeBoxNodeUncached(node, stack, ctx, matchProp, dependencyEntry) {
 	const cache = (value) => {
-		cacheMap$1.set(node, value);
+		cacheMap$1.set(node, dependencyEntry(value));
 		hasCachedEntries = true;
 		return value;
 	};
-	if (isCached(node)) return getCached(node);
 	if (ts_morph.Node.isStringLiteral(node) || ts_morph.Node.isNoSubstitutionTemplateLiteral(node)) {
 		const value = trimWhitespace(node.getLiteralValue());
 		return cache(box.literal(value, node, stack));
@@ -1127,21 +1280,19 @@ const resolveExportedName = (name, exportDeclaration) => {
 * which costs a minimum of around 90ms (and scales up with the file/project, could be hundreds of ms)
 * @see https://github.com/dsherret/ts-morph/blob/42d811ed9a5177fc678a5bfec4923a2048124fe0/packages/ts-morph/src/compiler/ast/module/ExportDeclaration.ts#L160
 */
-const getModuleSpecifierSourceFile = (declaration) => {
-	const project = declaration.getProject();
+const getModuleSpecifierSourceFile = (declaration, ctx) => {
 	const moduleName = declaration.getModuleSpecifierValue();
 	if (!moduleName) return;
-	const containingFile = declaration.getSourceFile().getFilePath();
-	const resolved = ts_morph.ts.resolveModuleName(moduleName, containingFile, project.getCompilerOptions(), project.getModuleResolutionHost());
-	if (!resolved.resolvedModule) return;
-	return project.addSourceFileAtPath(resolved.resolvedModule.resolvedFileName);
+	const sourceFile = ctx.resolveModule?.(moduleName, declaration.getSourceFile());
+	if (sourceFile) recordModuleDependency(ctx, sourceFile.getFilePath());
+	return sourceFile;
 };
 function resolveVarDeclarationFromExportWithName(symbolName, sourceFile, stack, ctx, visited) {
 	for (const exportDeclaration of sourceFile.getExportDeclarations()) {
 		const exportStack = [exportDeclaration];
 		const sourceName = resolveExportedName(symbolName, exportDeclaration);
 		if (sourceName === void 0) continue;
-		const maybeFile = getModuleSpecifierSourceFile(exportDeclaration);
+		const maybeFile = getModuleSpecifierSourceFile(exportDeclaration, ctx);
 		if (!maybeFile) {
 			const localVar = sourceFile.getVariableDeclaration(sourceName);
 			if (localVar) {

package/dist/index.d.cts

@@ -184,7 +184,18 @@ interface ComponentMatchers {
   matchTag: (element: MatchTagArgs) => boolean;
   matchProp: (prop: Pick<MatchTagArgs, 'tagName' | 'tagNode'> & MatchPropArgs) => boolean;
 }
+/**
+ * Place a module specifier inside the source graph owned by the caller.
+ *
+ * @internal Bamboo's parser supplies its Project resolver. The extractor deliberately has
+ * no filesystem fallback: a cross-file read that bypasses the owner cannot be invalidated or
+ * represented in the owner's dependency graph.
+ */
+type ResolveModule = (specifier: string, from: SourceFile) => SourceFile | undefined;
 interface BoxContext {
+  resolveModule?: ResolveModule;
+  /** @internal Receives local source paths crossed by this exact extraction context. */
+  recordDependency?: (filePath: string) => void;
   getEvaluateOptions?: (node: Expression, stack: Node[]) => Omit<EvaluateOptions, 'node' | 'policy'> | void;
   canEval?: (node: Expression, stack: Node[]) => boolean;
   tokens?: {
@@ -324,4 +335,4 @@ interface Unboxed {
 }
 declare const unbox: (node: BoxNodeType, ctx?: Pick<UnboxContext, "cache">) => Unboxed;
 //#endregion
-export { type BoxContext, type BoxNode, BoxNodeArray, BoxNodeConditional, BoxNodeEmptyInitializer, BoxNodeLiteral, BoxNodeMap, BoxNodeObject, BoxNodeUnresolvable, type EvaluateOptions, type ExtractOptions, type ExtractResultByName, type ExtractResultItem, type ExtractedComponentInstance, type ExtractedComponentResult, type ExtractedFunctionInstance, type ExtractedFunctionResult, type NodeRange, type PrimitiveType, type Unboxed, box, clearBoxNodeCache, extract, extractCallExpressionArguments, extractJsxAttribute, extractJsxElementProps, extractJsxSpreadAttributeValues, findIdentifierValueDeclaration, isBoxNode, maybeBoxNode, maybeIdentifierValue, unbox, unwrapExpression };
+export { type BoxContext, type BoxNode, BoxNodeArray, BoxNodeConditional, BoxNodeEmptyInitializer, BoxNodeLiteral, BoxNodeMap, BoxNodeObject, BoxNodeUnresolvable, type EvaluateOptions, type ExtractOptions, type ExtractResultByName, type ExtractResultItem, type ExtractedComponentInstance, type ExtractedComponentResult, type ExtractedFunctionInstance, type ExtractedFunctionResult, type NodeRange, type PrimitiveType, type ResolveModule, type Unboxed, box, clearBoxNodeCache, extract, extractCallExpressionArguments, extractJsxAttribute, extractJsxElementProps, extractJsxSpreadAttributeValues, findIdentifierValueDeclaration, isBoxNode, maybeBoxNode, maybeIdentifierValue, unbox, unwrapExpression };

package/dist/index.d.mts

@@ -184,7 +184,18 @@ interface ComponentMatchers {
   matchTag: (element: MatchTagArgs) => boolean;
   matchProp: (prop: Pick<MatchTagArgs, 'tagName' | 'tagNode'> & MatchPropArgs) => boolean;
 }
+/**
+ * Place a module specifier inside the source graph owned by the caller.
+ *
+ * @internal Bamboo's parser supplies its Project resolver. The extractor deliberately has
+ * no filesystem fallback: a cross-file read that bypasses the owner cannot be invalidated or
+ * represented in the owner's dependency graph.
+ */
+type ResolveModule = (specifier: string, from: SourceFile) => SourceFile | undefined;
 interface BoxContext {
+  resolveModule?: ResolveModule;
+  /** @internal Receives local source paths crossed by this exact extraction context. */
+  recordDependency?: (filePath: string) => void;
   getEvaluateOptions?: (node: Expression, stack: Node[]) => Omit<EvaluateOptions, 'node' | 'policy'> | void;
   canEval?: (node: Expression, stack: Node[]) => boolean;
   tokens?: {
@@ -324,4 +335,4 @@ interface Unboxed {
 }
 declare const unbox: (node: BoxNodeType, ctx?: Pick<UnboxContext, "cache">) => Unboxed;
 //#endregion
-export { type BoxContext, type BoxNode, BoxNodeArray, BoxNodeConditional, BoxNodeEmptyInitializer, BoxNodeLiteral, BoxNodeMap, BoxNodeObject, BoxNodeUnresolvable, type EvaluateOptions, type ExtractOptions, type ExtractResultByName, type ExtractResultItem, type ExtractedComponentInstance, type ExtractedComponentResult, type ExtractedFunctionInstance, type ExtractedFunctionResult, type NodeRange, type PrimitiveType, type Unboxed, box, clearBoxNodeCache, extract, extractCallExpressionArguments, extractJsxAttribute, extractJsxElementProps, extractJsxSpreadAttributeValues, findIdentifierValueDeclaration, isBoxNode, maybeBoxNode, maybeIdentifierValue, unbox, unwrapExpression };
+export { type BoxContext, type BoxNode, BoxNodeArray, BoxNodeConditional, BoxNodeEmptyInitializer, BoxNodeLiteral, BoxNodeMap, BoxNodeObject, BoxNodeUnresolvable, type EvaluateOptions, type ExtractOptions, type ExtractResultByName, type ExtractResultItem, type ExtractedComponentInstance, type ExtractedComponentResult, type ExtractedFunctionInstance, type ExtractedFunctionResult, type NodeRange, type PrimitiveType, type ResolveModule, type Unboxed, box, clearBoxNodeCache, extract, extractCallExpressionArguments, extractJsxAttribute, extractJsxElementProps, extractJsxSpreadAttributeValues, findIdentifierValueDeclaration, isBoxNode, maybeBoxNode, maybeIdentifierValue, unbox, unwrapExpression };

package/dist/index.mjs

@@ -305,6 +305,65 @@ const box = {
 	}
 };
 //#endregion
+//#region src/dependency-cache.ts
+const EMPTY_DEPENDENCIES = [];
+/** One synchronous extraction context owns one nested capture stack. */
+const trackers = /* @__PURE__ */ new WeakMap();
+/**
+* Attribute one resolved local module to every cache computation currently enclosing it.
+*
+* Paths, rather than SourceFile objects, are the replay payload. A source replacement may
+* retire every node in a file, while its stable path is exactly the fact a fresh ParserResult
+* needs. The caller-facing callback stays outside the cache and therefore belongs to the
+* current query/environment rather than whichever parse populated the entry.
+*/
+const recordModuleDependency = (ctx, filePath) => {
+	const normalized = filePath.replaceAll("\\", "/");
+	const tracker = trackers.get(ctx);
+	if (tracker) for (const frame of tracker.frames) {
+		frame.dependencies ??= /* @__PURE__ */ new Set();
+		frame.dependencies.add(normalized);
+	}
+	ctx.recordDependency?.(normalized);
+};
+/** Begin one nested cache computation without allocating a Set on dependency-free paths. */
+const beginDependencyCapture = (ctx) => {
+	let tracker = trackers.get(ctx);
+	if (!tracker) {
+		tracker = { frames: [] };
+		trackers.set(ctx, tracker);
+	}
+	const frame = {};
+	tracker.frames.push(frame);
+	return {
+		entry(value) {
+			return {
+				dependencies: frame.dependencies ? [...frame.dependencies].sort() : EMPTY_DEPENDENCIES,
+				resolveModule: ctx.resolveModule,
+				value
+			};
+		},
+		end() {
+			tracker.frames.pop();
+		}
+	};
+};
+/**
+* Replay a hit only inside the resolver scope which computed it.
+*
+* The same ts-morph node can be inspected under two extractor contexts with different module
+* placement rules. Returning the first context's value or dependency paths to the second would
+* be cross-Project leakage, so a scope mismatch is a cache miss and gets overwritten normally.
+*/
+const replayDependencyCache = (entry, ctx) => {
+	if (entry.resolveModule !== ctx.resolveModule) return { hit: false };
+	for (const dependency of entry.dependencies) recordModuleDependency(ctx, dependency);
+	return {
+		hit: true,
+		value: entry.value
+	};
+};
+//#endregion
 //#region src/resolve-imported-value.ts
 /**
 * The values an expression borrows from other modules, resolved by reading the imports.
@@ -321,9 +380,9 @@ const box = {
 * rather than with the number of style calls — a large project reported a 5.4x extraction
 * slowdown and an OOM in CI.
 *
-* Following an import is two cheap steps this package already had: resolve the specifier to
-* a file (`ts.resolveModuleName`, path lookup, no checker), then read that file's exported
-* declaration. Crossing the import boundary is the only thing the checker was doing here.
+* Following an import is two cheap steps: ask the caller's source-graph resolver to place the
+* specifier, then read that file's exported declaration. Crossing the import boundary is the
+* only thing the checker was doing here.
 *
 * The evaluator resolves everything *within* a module by walking scopes, so a helper that
 * refers to another binding in its own file needs nothing from us.
@@ -331,7 +390,14 @@ const box = {
 /** How far a chain of helpers importing helpers is followed. */
 const MAX_DEPTH = 4;
 /** Evaluated once per declaration, however many call sites reach it. */
-const evaluatedValues = /* @__PURE__ */ new WeakMap();
+let evaluatedValues = /* @__PURE__ */ new WeakMap();
+let hasEvaluatedValues = false;
+/** @internal Drop imported declarations whose closure may include an edited module. */
+const clearImportedValueCache = () => {
+	if (!hasEvaluatedValues) return;
+	evaluatedValues = /* @__PURE__ */ new WeakMap();
+	hasEvaluatedValues = false;
+};
 /**
 * Local name to the name and declaration it was imported from.
 *
@@ -361,17 +427,28 @@ const importBindingsFor = (sourceFile) => {
 };
 /** What an imported name refers to, or nothing if it cannot be reached safely. */
 const valueForBinding = (binding, ctx, stack, depth, evaluateExpression) => {
-	const sourceFile = getModuleSpecifierSourceFile(binding.declaration);
+	const sourceFile = getModuleSpecifierSourceFile(binding.declaration, ctx);
 	if (!sourceFile) return;
 	if (sourceFile.isInNodeModules()) return;
 	const declaration = getExportedVarDeclarationWithName(binding.exportedName, sourceFile, stack, ctx);
 	if (!declaration) return;
-	if (evaluatedValues.has(declaration)) return { value: evaluatedValues.get(declaration) };
+	const cached = evaluatedValues.get(declaration);
+	if (cached) {
+		const replayed = replayDependencyCache(cached, ctx);
+		if (replayed.hit) return { value: replayed.value };
+	}
 	const initializer = declaration.getInitializer();
 	if (!initializer) return;
-	const value = evaluateExpression(initializer, stack, ctx, depth + 1);
+	const capture = beginDependencyCapture(ctx);
+	let value;
+	try {
+		value = evaluateExpression(initializer, stack, ctx, depth + 1);
+	} finally {
+		capture.end();
+	}
 	if (value === void 0) return;
-	evaluatedValues.set(declaration, value);
+	evaluatedValues.set(declaration, capture.entry(value));
+	hasEvaluatedValues = true;
 	return { value };
 };
 /**
@@ -384,27 +461,34 @@ const valueForBinding = (binding, ctx, stack, depth, evaluateExpression) => {
 */
 const importedEnvironmentFor = (node, ctx, stack, depth, evaluateExpression) => {
 	if (depth >= MAX_DEPTH) return;
-	const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
-	if (Node.isCallExpression(node)) calls.unshift(node);
-	if (!calls.length) return;
 	const bindings = importBindingsFor(node.getSourceFile());
 	if (!bindings.size) return;
+	const references = node.getDescendantsOfKind(SyntaxKind.Identifier);
+	if (Node.isIdentifier(node)) references.unshift(node);
+	if (!references.length) return;
 	let environment;
-	for (const call of calls) {
-		const callee = call.getExpression();
-		const binding = bindings.get(callee.getText());
-		if (!binding || environment?.[callee.getText()] !== void 0) continue;
+	for (const reference of references) {
+		const name = reference.getText();
+		const binding = bindings.get(name);
+		if (!binding || environment?.[name] !== void 0) continue;
 		const resolved = valueForBinding(binding, ctx, stack, depth, evaluateExpression);
 		if (!resolved) continue;
 		environment ??= {};
-		environment[callee.getText()] = resolved.value;
+		environment[name] = resolved.value;
 	}
 	return environment;
 };
 //#endregion
 //#region src/evaluate-node.ts
 const TsEvalError = Symbol("EvalError");
-const cacheMap$2 = /* @__PURE__ */ new WeakMap();
+let cacheMap$2 = /* @__PURE__ */ new WeakMap();
+let hasCachedEntries$1 = false;
+/** @internal Drop values whose expression may close over an edited source file. */
+const clearEvaluateNodeCache = () => {
+	if (!hasCachedEntries$1) return;
+	cacheMap$2 = /* @__PURE__ */ new WeakMap();
+	hasCachedEntries$1 = false;
+};
 /** @see https://github.com/wessberg/ts-evaluator#setting-up-policies */
 const POLICY = {
 	console: false,
@@ -435,13 +519,39 @@ const POLICY = {
 const evaluateNode = (node, stack, ctx, depth = 0) => {
 	if (ctx.flags?.skipEvaluate) return;
 	if (ctx.canEval && !ctx.canEval?.(node, stack)) return;
-	if (depth === 0 && cacheMap$2.has(node)) return cacheMap$2.get(node);
-	const options = {
+	const cached = depth === 0 ? cacheMap$2.get(node) : void 0;
+	if (cached) {
+		const replayed = replayDependencyCache(cached, ctx);
+		if (replayed.hit) return replayed.value;
+	}
+	const capture = depth === 0 ? beginDependencyCapture(ctx) : void 0;
+	try {
+		return evaluateNodeUncached(node, stack, ctx, depth, capture?.entry);
+	} finally {
+		capture?.end();
+	}
+};
+const evaluateNodeUncached = (node, stack, ctx, depth, dependencyEntry) => {
+	let options = {
 		policy: { ...POLICY },
 		...ctx.getEvaluateOptions?.(node, stack),
 		node: node.compilerNode,
 		typescript: ts
 	};
+	let imported = depth > 0 ? importedEnvironmentFor(node, ctx, stack, depth, safeEvaluateNode) : void 0;
+	if (imported) {
+		const environment = options.environment;
+		options = {
+			...options,
+			environment: {
+				...environment,
+				extra: {
+					...environment?.extra,
+					...imported
+				}
+			}
+		};
+	}
 	let result = evaluate(options);
 	/**
 	* Retried only on failure, with whatever this expression imports put in scope.
@@ -453,17 +563,26 @@ const evaluateNode = (node, stack, ctx, depth = 0) => {
 	* the path of every build.
 	*/
 	if (!result.success) {
-		const imported = importedEnvironmentFor(node, ctx, stack, depth, safeEvaluateNode);
-		if (imported) result = evaluate({
-			...options,
-			environment: {
-				...options.environment,
-				extra: imported
-			}
-		});
+		imported ??= importedEnvironmentFor(node, ctx, stack, depth, safeEvaluateNode);
+		if (imported) {
+			const environment = options.environment;
+			result = evaluate({
+				...options,
+				environment: {
+					...environment,
+					extra: {
+						...environment?.extra,
+						...imported
+					}
+				}
+			});
+		}
 	}
 	const expr = result.success ? result.value : TsEvalError;
-	if (depth === 0) cacheMap$2.set(node, expr);
+	if (depth === 0) {
+		cacheMap$2.set(node, dependencyEntry(expr));
+		hasCachedEntries$1 = true;
+	}
 	return expr;
 };
 const safeEvaluateNode = (node, stack, ctx, depth = 0) => {
@@ -486,7 +605,7 @@ function getDeclarationFor(node, stack, ctx) {
 		declaration = parent;
 	} else if (Node.isImportSpecifier(parent) && (parent.getNameNode() == node || parent.getAliasNode() == node)) {
 		if (ctx.flags?.skipTraverseFiles) return;
-		const sourceFile = getModuleSpecifierSourceFile(parent.getImportDeclaration());
+		const sourceFile = getModuleSpecifierSourceFile(parent.getImportDeclaration(), ctx);
 		if (sourceFile) {
 			const exportStack = [parent, sourceFile];
 			const maybeVar = getExportedVarDeclarationWithName(parent.getNameNode().getText(), sourceFile, exportStack, ctx);
@@ -504,53 +623,74 @@ const getInnermostScope = (from) => {
 	while (scope && !isScope(scope)) scope = scope.getParent();
 	return scope;
 };
+/**
+* Keyed on the compiler node, never the ts-morph wrapper.
+*
+* `Project.replaceWithText` — which is how a re-parse installs a source transform — keeps the
+* wrapper identity and swaps the compiler node underneath it. A wrapper-keyed cache would
+* therefore answer a rebuild from the previous revision of the file, which is a wrong
+* stylesheet rather than a slow one. Keying on the compiler node makes the cache
+* self-invalidating: ts-morph reuses a compiler node exactly when its subtree did not change.
+*/
+const declarationIndexes = /* @__PURE__ */ new WeakMap();
+const isDeclarationName = (node, parent) => {
+	if (Node.isVariableDeclaration(parent) || Node.isParameterDeclaration(parent) || Node.isFunctionDeclaration(parent) || Node.isEnumDeclaration(parent) || Node.isBindingElement(parent)) return parent.getNameNode() == node;
+	return Node.isImportSpecifier(parent) && (parent.getNameNode() == node || parent.getAliasNode() == node);
+};
+/**
+* Walk a scope once, so that every later lookup inside it is a map read.
+*
+* This used to be a `forEachDescendant` per identifier, widening to each enclosing scope and
+* re-walking from scratch, calling `getText()` on every identifier it passed. A module whose
+* declarations are referenced n times paid n full traversals of itself, and traversal is where
+* ts-morph charges for wrapping each node — it measured ~10% of extraction on its own.
+*/
+const declarationIndexFor = (scope) => {
+	const cached = declarationIndexes.get(scope.compilerNode);
+	if (cached) return cached;
+	const index = /* @__PURE__ */ new Map();
+	scope.forEachDescendant((node) => {
+		if (!Node.isIdentifier(node)) return;
+		const parent = node.getParent();
+		if (!parent || !isDeclarationName(node, parent)) return;
+		const name = node.getText();
+		const declared = index.get(name);
+		if (declared) declared.push(node);
+		else index.set(name, [node]);
+	});
+	declarationIndexes.set(scope.compilerNode, index);
+	return index;
+};
 function findIdentifierValueDeclaration(identifier, stack, ctx, visitedsWithStack = /* @__PURE__ */ new Map()) {
 	let scope = identifier;
-	let foundNode;
-	let isUnresolvable = false;
 	let count = 0;
 	const innerStack = [];
+	const refName = identifier.getText();
 	do {
 		scope = getInnermostScope(scope);
 		count++;
 		if (!scope) return;
-		const refName = identifier.getText();
-		scope.forEachDescendant((node, traversal) => {
-			if (visitedsWithStack.has(node)) {
-				traversal.skip();
-				innerStack.push(...visitedsWithStack.get(node));
-				return;
+		for (const candidate of declarationIndexFor(scope).get(refName) ?? []) {
+			if (candidate == identifier) continue;
+			if (visitedsWithStack.has(candidate)) continue;
+			visitedsWithStack.set(candidate, innerStack);
+			const declarationStack = [candidate];
+			const maybeDeclaration = getDeclarationFor(candidate, declarationStack, ctx);
+			if (!maybeDeclaration) continue;
+			if (Node.isParameterDeclaration(maybeDeclaration)) {
+				const initializer = maybeDeclaration.getInitializer();
+				const typeNode = maybeDeclaration.getTypeNode();
+				if (initializer) innerStack.push(...declarationStack.concat(initializer));
+				else if (typeNode && Node.isTypeLiteral(typeNode)) innerStack.push(...declarationStack.concat(typeNode));
+				else return;
+				stack.push(...innerStack);
+				return maybeDeclaration;
 			}
-			if (node == identifier) return;
-			visitedsWithStack.set(node, innerStack);
-			if (Node.isIdentifier(node) && node.getText() == refName) {
-				const declarationStack = [node];
-				const maybeDeclaration = getDeclarationFor(node, declarationStack, ctx);
-				if (maybeDeclaration) {
-					if (Node.isParameterDeclaration(maybeDeclaration)) {
-						const initializer = maybeDeclaration.getInitializer();
-						const typeNode = maybeDeclaration.getTypeNode();
-						if (initializer) {
-							innerStack.push(...declarationStack.concat(initializer));
-							foundNode = maybeDeclaration;
-						} else if (typeNode && Node.isTypeLiteral(typeNode)) {
-							innerStack.push(...declarationStack.concat(typeNode));
-							foundNode = maybeDeclaration;
-						} else isUnresolvable = true;
-						traversal.stop();
-						return;
-					}
-					innerStack.push(...declarationStack);
-					foundNode = maybeDeclaration;
-					traversal.stop();
-				}
-			}
-		});
-		if (foundNode || isUnresolvable) {
-			if (foundNode) stack.push(...innerStack);
-			return foundNode;
+			innerStack.push(...declarationStack);
+			stack.push(...innerStack);
+			return maybeDeclaration;
 		}
-	} while (scope && !Node.isSourceFile(scope) && !foundNode && !isUnresolvable && count < 100);
+	} while (scope && !Node.isSourceFile(scope) && count < 100);
 }
 //#endregion
 //#region src/get-property-name.ts
@@ -664,7 +804,6 @@ const getObjectLiteralExpressionPropPairs = (expression, expressionStack, ctx, m
 //#endregion
 //#region src/maybe-box-node.ts
 let cacheMap$1 = /* @__PURE__ */ new WeakMap();
-const isCached = (node) => cacheMap$1.has(node);
 const getCached = (node) => cacheMap$1.get(node);
 /**
 * Drops every memoized resolution.
@@ -675,6 +814,8 @@ const getCached = (node) => cacheMap$1.get(node);
 * otherwise keep serving the value read before the edit.
 */
 const clearBoxNodeCache = () => {
+	clearEvaluateNodeCache();
+	clearImportedValueCache();
 	if (!hasCachedEntries) return;
 	cacheMap$1 = /* @__PURE__ */ new WeakMap();
 	hasCachedEntries = false;
@@ -687,12 +828,24 @@ const canReturnWhenTrueInLogicalExpression = (op) => {
 	return op === ts.SyntaxKind.BarBarToken || op === ts.SyntaxKind.QuestionQuestionToken;
 };
 function maybeBoxNode(node, stack, ctx, matchProp) {
+	const cached = getCached(node);
+	if (cached) {
+		const replayed = replayDependencyCache(cached, ctx);
+		if (replayed.hit) return replayed.value;
+	}
+	const capture = beginDependencyCapture(ctx);
+	try {
+		return maybeBoxNodeUncached(node, stack, ctx, matchProp, capture.entry);
+	} finally {
+		capture.end();
+	}
+}
+function maybeBoxNodeUncached(node, stack, ctx, matchProp, dependencyEntry) {
 	const cache = (value) => {
-		cacheMap$1.set(node, value);
+		cacheMap$1.set(node, dependencyEntry(value));
 		hasCachedEntries = true;
 		return value;
 	};
-	if (isCached(node)) return getCached(node);
 	if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) {
 		const value = trimWhitespace(node.getLiteralValue());
 		return cache(box.literal(value, node, stack));
@@ -1126,21 +1279,19 @@ const resolveExportedName = (name, exportDeclaration) => {
 * which costs a minimum of around 90ms (and scales up with the file/project, could be hundreds of ms)
 * @see https://github.com/dsherret/ts-morph/blob/42d811ed9a5177fc678a5bfec4923a2048124fe0/packages/ts-morph/src/compiler/ast/module/ExportDeclaration.ts#L160
 */
-const getModuleSpecifierSourceFile = (declaration) => {
-	const project = declaration.getProject();
+const getModuleSpecifierSourceFile = (declaration, ctx) => {
 	const moduleName = declaration.getModuleSpecifierValue();
 	if (!moduleName) return;
-	const containingFile = declaration.getSourceFile().getFilePath();
-	const resolved = ts.resolveModuleName(moduleName, containingFile, project.getCompilerOptions(), project.getModuleResolutionHost());
-	if (!resolved.resolvedModule) return;
-	return project.addSourceFileAtPath(resolved.resolvedModule.resolvedFileName);
+	const sourceFile = ctx.resolveModule?.(moduleName, declaration.getSourceFile());
+	if (sourceFile) recordModuleDependency(ctx, sourceFile.getFilePath());
+	return sourceFile;
 };
 function resolveVarDeclarationFromExportWithName(symbolName, sourceFile, stack, ctx, visited) {
 	for (const exportDeclaration of sourceFile.getExportDeclarations()) {
 		const exportStack = [exportDeclaration];
 		const sourceName = resolveExportedName(symbolName, exportDeclaration);
 		if (sourceName === void 0) continue;
-		const maybeFile = getModuleSpecifierSourceFile(exportDeclaration);
+		const maybeFile = getModuleSpecifierSourceFile(exportDeclaration, ctx);
 		if (!maybeFile) {
 			const localVar = sourceFile.getVariableDeclaration(sourceName);
 			if (localVar) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bamboocss/extractor",
-  "version": "1.45.5",
+  "version": "1.46.1",
   "description": "The css extractor for css bamboo",
   "homepage": "https://bamboocss.com",
   "license": "MIT",
@@ -35,7 +35,7 @@
   "dependencies": {
     "ts-evaluator": "2.0.0",
     "ts-morph": "28.0.0",
-    "@bamboocss/shared": "1.45.5"
+    "@bamboocss/shared": "1.46.1"
   },
   "scripts": {
     "build": "tsdown src/index.ts --format=cjs,esm --shims --dts",