@generaltranslation/vue-extractor 0.0.0 → 0.1.0-iris.1

package/dist/internal/script/analyze.js

@@ -1,11 +1,12 @@
-import { addVueError, babelLocation, readStaticPrimitive, unwrapExpression } from "../utils.js";
+import { parseScriptAst } from "./parser.js";
+import { isKnownNonVueGTRuntime } from "./runtimeModules.js";
+import { addVueError, babelLocation, readStaticGlobalPrimitive, readStaticPrimitive, unwrapExpression } from "../utils.js";
 import { processVueStringCall } from "../stringCalls.js";
 import { appendTemplatePath, unknownTemplatePathSegment } from "../templatePath.js";
 import { createReplayAnalysis } from "./replay.js";
 import { createSnapshotAnalysis } from "./snapshot.js";
 import { COMPONENT_IMPORTS, ORDINARY_GLOBAL_VALUES, READONLY_ARRAY_TRANSFORMS, VUE_BUILTIN_IMPORTS, knownExport, knownValueKey } from "./knownValues.js";
 import { extractVueJSXTranslation, isNestedInVueJSXTranslation, resolveVueJSXElementIdentity, validateVueJSXVariableComponent } from "./jsx.js";
-import { parseScriptAst } from "./parser.js";
 import { isAssignmentTargetWrapper, isBindingPattern, isStaticallyUndefined, patternContains, readMemberProperty, readPatternIdentifier, readPropertyKey } from "./syntax.js";
 import traverseModule from "@babel/traverse";
 //#region src/internal/script/analyze.ts
@@ -33,6 +34,7 @@ function createVueScriptAnalysis(stats) {
 		directBindings: /* @__PURE__ */ new Set(),
 		gtComponentFactories: /* @__PURE__ */ new Set(),
 		gtContainerFactories: /* @__PURE__ */ new Set(),
+		hasGTSourceReference: false,
 		possibleGTContainers: /* @__PURE__ */ new Set(),
 		possibleStaticStrings: /* @__PURE__ */ new Map(),
 		staticValues: /* @__PURE__ */ new Map(),
@@ -81,6 +83,7 @@ function collectVueScriptImports(source, language, analysis) {
 /** Extracts calls and component bindings from one padded Vue script block. */
 function parseVueScript(source, language, context, templateBindings, exposeToTemplate, analysis = createVueScriptAnalysis(), analyzeOptionsApi = true) {
 	if (!source.trim()) return true;
+	const initialErrorCount = context.errors.length;
 	let ast;
 	try {
 		ast = parseScriptAst(source, language);
@@ -121,18 +124,25 @@ function parseVueScript(source, language, context, templateBindings, exposeToTem
 		if (state.activeTranslationFunctions.size > 0 && resolveKnownCallTargetWithoutParameterSubstitutions(path.node.callee, path.scope, path.node.start ?? Number.POSITIVE_INFINITY, state).value?.type === "string") return;
 		const vueHelper = readImportedFunctionName(path.node.callee, path.scope, "vue", state);
 		const firstArgument = path.node.arguments[0];
-		if (vueHelper && ["createVNode", "h"].includes(vueHelper) && firstArgument && firstArgument.type !== "ArgumentPlaceholder" && firstArgument.type !== "SpreadElement" && expressionContainsGTReference(firstArgument, path.scope, state)) addVueError(context, consumerLocation, "Found an unsupported gt-vue <T> component in a Vue render function", "Move the rich translation into a Vue single-file component template");
-		if (vueHelper === "defineAsyncComponent" && firstArgument && firstArgument.type !== "ArgumentPlaceholder" && firstArgument.type !== "SpreadElement" && expressionContainsGTReference(firstArgument, path.scope, state)) addVueError(context, consumerLocation, "Could not statically extract a gt-vue <T> component behind defineAsyncComponent()", "Use a direct gt-vue component binding in the Vue template");
+		if (vueHelper && ["createVNode", "h"].includes(vueHelper) && firstArgument && firstArgument.type !== "ArgumentPlaceholder" && firstArgument.type !== "SpreadElement" && expressionContainsGTReference(firstArgument, path.scope, state)) {
+			state.analysis.hasGTSourceReference = true;
+			addVueError(context, consumerLocation, "Found an unsupported gt-vue <T> component in a Vue render function", "Move the rich translation into a Vue single-file component template");
+		}
+		if (vueHelper === "defineAsyncComponent" && firstArgument && firstArgument.type !== "ArgumentPlaceholder" && firstArgument.type !== "SpreadElement" && expressionContainsGTReference(firstArgument, path.scope, state)) {
+			state.analysis.hasGTSourceReference = true;
+			addVueError(context, consumerLocation, "Could not statically extract a gt-vue <T> component behind defineAsyncComponent()", "Use a direct gt-vue component binding in the Vue template");
+		}
 		const callTarget = resolveKnownCallTargetAtPosition(path.node.callee, path.scope, path.node.start ?? Number.POSITIVE_INFINITY, state);
 		const value = callTarget.value;
 		if (value?.type !== "string") {
 			const localCallable = resolveCalledFunction(path.node.callee, path.scope, state, /* @__PURE__ */ new Set());
 			const calleePath = readResolvedMemberPath(path.node.callee, path.scope, state);
 			const uncertainTranslationHelper = Boolean(calleePath && pathMayReferenceUncertainTranslationHelper(path.node.callee, calleePath, path.scope, state) && callArgumentsMayProvideTranslationFunction(path.node, path.scope, state));
-			if (!callTarget.definitelyOrdinary && !localCallable && calleePath && (callTarget.possibleStringFunction || uncertainTranslationHelper || templateBindings.uncertainStringFunctions.has(calleePath) || state.analysis.uncertainStringFunctions.has(calleePath) || calleePath.endsWith(".value") && templateBindings.uncertainStringFunctions.has(calleePath.slice(0, -6)))) addVueError(context, consumerLocation, `Could not statically resolve possible gt-vue string function alias "${calleePath}"`, "Use a direct, immutable alias of useGT(), useMessages(), or msg()");
+			if (!callTarget.definitelyOrdinary && !localCallable && calleePath && (callTarget.possibleStringFunction || uncertainTranslationHelper || templateBindings.uncertainStringFunctions.has(calleePath) || state.analysis.uncertainStringFunctions.has(calleePath) || calleePath.endsWith(".value") && templateBindings.uncertainStringFunctions.has(calleePath.slice(0, -6)))) addVueError(context, consumerLocation, `Could not statically resolve possible gt-vue string function alias "${calleePath}"`, "Use a direct, immutable alias of useGT(), useMessages(), msg(), or t()");
 			processForwardedTranslationCalls(path, consumerLocation);
 			return;
 		}
+		state.analysis.hasGTSourceReference = true;
 		processVueStringCall(path.node, value.kind, consumerLocation, context, (node) => {
 			if (!node) return { ok: false };
 			const materialized = materializeParameterExpression(node, path.scope, state);
@@ -172,16 +182,20 @@ function parseVueScript(source, language, context, templateBindings, exposeToTem
 		OptionalCallExpression: processCall,
 		TaggedTemplateExpression(path) {
 			if (resolveKnownExpression(path.node.tag, path.scope, state, /* @__PURE__ */ new Set())?.type !== "string") return;
+			state.analysis.hasGTSourceReference = true;
 			addVueError(context, babelLocation(path.node.loc), "Found an unsupported tagged template translation in gt-vue", "Call the translation function with a string literal instead");
 		},
 		JSXElement(path) {
 			const value = resolveVueJSXElementIdentity(path.node.openingElement.name, path.scope, jsxAnalysis);
+			if (value?.type === "component") state.analysis.hasGTSourceReference = true;
 			if (value?.type === "component" && (value.name === "Var" || value.name === "Num" || value.name === "DateTime" || value.name === "Currency")) validateVueJSXVariableComponent(path.node, value.name, context);
 			if (value?.type !== "component" || value.name !== "T") return;
 			if (isNestedInVueJSXTranslation(path, jsxAnalysis)) return;
 			extractVueJSXTranslation(path, context, jsxAnalysis);
 		}
 	});
+	if (state.unsupportedDynamicGTReference && context.errors.length === initialErrorCount) addVueError(context, void 0, "Could not statically resolve possible gt-vue string function alias from a dynamic import", "Use a static gt-vue import so translation ownership can be extracted deterministically");
+	if (state.unsupportedMalformedGTReference && context.errors.length === initialErrorCount) addVueError(context, void 0, "Could not statically resolve a gt-vue reference imported through a malformed local module", "Fix the local module syntax so translation ownership can be extracted deterministically");
 	return true;
 }
 /** Indexes Babel's lexical scopes so deferred function analysis stays exact. */
@@ -234,6 +248,8 @@ function createScriptState(ast, analysis) {
 		transformArrayEntries: /* @__PURE__ */ new Map(),
 		transformArrayEntriesInProgress: /* @__PURE__ */ new Set(),
 		uncertainTranslationHelperBindings: /* @__PURE__ */ new Set(),
+		unsupportedDynamicGTReference: false,
+		unsupportedMalformedGTReference: false,
 		unsafeMutableNamespaceSources: /* @__PURE__ */ new Set()
 	};
 	traverse(ast, { enter(path) {
@@ -281,8 +297,9 @@ function memberChainWrites(memberPath) {
 function collectImports(ast, state, importerFile = state.analysis.entryFile) {
 	traverse(ast, {
 		ImportDeclaration(path) {
-			if (path.node.importKind === "type") return;
+			if (isTypeOnlyImportKind(path.node.importKind)) return;
 			const source = path.node.source.value;
+			if (source === "gt-vue" && hasRuntimeImport(path.node) && importerFile === state.analysis.entryFile) state.analysis.hasGTSourceReference = true;
 			if (source !== "gt-vue" && source !== "vue") {
 				registerLocalImportDeclaration(path.node, path.scope, importerFile, state);
 				return;
@@ -297,16 +314,32 @@ function collectImports(ast, state, importerFile = state.analysis.entryFile) {
 					}, specifierPath.scope, state);
 					continue;
 				}
-				if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type") continue;
+				if (specifier.type !== "ImportSpecifier" || isTypeOnlyImportKind(specifier.importKind)) continue;
 				const value = knownExport(source, specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value);
 				if (value) registerImport(specifier.local.name, value, specifierPath.scope, state);
 			}
 		},
+		ExportNamedDeclaration(path) {
+			if (path.node.exportKind === "type" || !path.node.source || importerFile !== state.analysis.entryFile) return;
+			const exportNames = path.node.specifiers.flatMap((specifier) => {
+				if (specifier.type === "ExportSpecifier" && isTypeOnlyImportKind(specifier.exportKind)) return [];
+				if (specifier.type === "ExportNamespaceSpecifier") return ["*"];
+				if (specifier.type !== "ExportSpecifier") return [];
+				return [specifier.local.name];
+			});
+			recordRuntimeReexport(path.node.source.value, exportNames, importerFile, state);
+		},
+		ExportAllDeclaration(path) {
+			if (path.node.exportKind === "type" || importerFile !== state.analysis.entryFile) return;
+			recordRuntimeReexport(path.node.source.value, ["*"], importerFile, state);
+		},
 		TSImportEqualsDeclaration(path) {
+			if (path.node.importKind === "type") return;
 			const reference = path.node.moduleReference;
 			if (reference.type !== "TSExternalModuleReference" || reference.expression.type !== "StringLiteral") return;
 			const source = reference.expression.value;
 			if (source !== "gt-vue" && source !== "vue") return;
+			if (source === "gt-vue" && importerFile === state.analysis.entryFile) state.analysis.hasGTSourceReference = true;
 			registerImport(path.node.id.name, {
 				type: "namespace",
 				source,
@@ -321,11 +354,39 @@ function collectImports(ast, state, importerFile = state.analysis.entryFile) {
 			}
 			const namespace = readRequireNamespace(path.node.init, path.scope);
 			if (!namespace) return;
+			if (namespace.source === "gt-vue" && importerFile === state.analysis.entryFile) state.analysis.hasGTSourceReference = true;
 			registerRequirePattern(path.node.id, namespace, path.scope, state);
 		}
 	});
 	propagateUncertainTranslationHelperAliases(ast, state);
 }
+/** Marks only runtime re-exports statically connected to gt-vue. */
+function recordRuntimeReexport(source, exportNames, importerFile, state) {
+	if (!importerFile || exportNames.length === 0) return;
+	if (source === "gt-vue") {
+		state.analysis.hasGTSourceReference = true;
+		return;
+	}
+	if (source === "vue" || isKnownNonVueGTRuntime(source)) return;
+	const resolver = state.analysis.localModules;
+	const modulePath = resolver?.resolveModule(importerFile, source);
+	if (!resolver || !modulePath || !resolver.isProjectModule(modulePath)) return;
+	if ((exportNames.includes("*") ? [
+		...COMPONENT_IMPORTS,
+		"msg",
+		"t",
+		"useGT",
+		"useMessages"
+	] : exportNames).some((name) => resolver.hasGTExportReference(modulePath, name))) state.analysis.hasGTSourceReference = true;
+}
+/** Returns whether an import causes a runtime module reference. */
+function hasRuntimeImport(declaration) {
+	return declaration.specifiers.length === 0 || declaration.specifiers.some((specifier) => specifier.type !== "ImportSpecifier" || !isTypeOnlyImportKind(specifier.importKind));
+}
+/** Returns whether Babel classified an ESM binding as type-only. */
+function isTypeOnlyImportKind(kind) {
+	return kind === "type" || kind === "typeof";
+}
 /** Retains unresolved-helper provenance through simple immutable aliases. */
 function propagateUncertainTranslationHelperAliases(ast, state) {
 	const candidates = [];
@@ -371,28 +432,39 @@ function readDynamicImport(node) {
 /** Marks GT-shaped values selected from a dynamic namespace as unresolved. */
 function recordDynamicImportPattern(pattern, source, scope, importerFile, state) {
 	if (pattern.type === "VoidPattern") return;
+	if (source && isKnownNonVueGTRuntime(source)) return;
+	if (source === "gt-vue" && importerFile === state.analysis.entryFile) {
+		state.analysis.hasGTSourceReference = true;
+		state.unsupportedDynamicGTReference = true;
+	}
 	const resolver = state.analysis.localModules;
 	const modulePath = source && source !== "gt-vue" && source !== "vue" && importerFile ? resolver?.resolveModule(importerFile, source) : void 0;
 	if (source === "vue") return;
 	if (source && source !== "gt-vue" && !modulePath) return;
+	if (modulePath && resolver && !resolver.isProjectModule(modulePath)) return;
 	if (pattern.type === "Identifier") {
-		if (modulePath && resolver) for (const exportName of [
-			...COMPONENT_IMPORTS,
-			"msg",
-			"useGT",
-			"useMessages"
-		]) recordDynamicImportBinding(appendTemplatePath(pattern.name, exportName), exportName, modulePath, state);
-		else {
+		if (modulePath && resolver) {
+			const binding = scope.getBinding(pattern.name);
+			for (const exportName of [
+				...COMPONENT_IMPORTS,
+				"msg",
+				"t",
+				"useGT",
+				"useMessages"
+			]) recordDynamicImportBinding(appendTemplatePath(pattern.name, exportName), exportName, modulePath, state, bindingReferencesNamespaceMember(binding, exportName, state));
+		} else {
 			for (const component of COMPONENT_IMPORTS) {
 				const path = appendTemplatePath(pattern.name, component);
 				state.analysis.uncertainComponents.add(path);
 				state.analysis.uncertainGTComponents.add(path);
 			}
-			for (const name of [
+			const stringFunctions = [
 				"msg",
 				"useGT",
 				"useMessages"
-			]) state.analysis.uncertainStringFunctions.add(appendTemplatePath(pattern.name, name));
+			];
+			if (source === "gt-vue") stringFunctions.push("t");
+			for (const name of stringFunctions) state.analysis.uncertainStringFunctions.add(appendTemplatePath(pattern.name, name));
 		}
 		return;
 	}
@@ -401,61 +473,102 @@ function recordDynamicImportPattern(pattern, source, scope, importerFile, state)
 		if (property.type !== "ObjectProperty") continue;
 		const exportedName = readPropertyKey(property);
 		const localName = readPatternIdentifier(property.value);
-		if (exportedName && localName) if (modulePath) recordDynamicImportBinding(localName, exportedName, modulePath, state);
-		else recordUnresolvedGTShapedBinding(localName, exportedName, state);
+		if (exportedName && localName) if (modulePath) recordDynamicImportBinding(localName, exportedName, modulePath, state, importerFile === state.analysis.entryFile);
+		else recordUnresolvedGTShapedBinding(localName, exportedName, state, source === "gt-vue");
 	}
 	for (const property of pattern.properties) {
 		if (property.type !== "ObjectProperty" || !property.computed) continue;
 		const exportedName = readResolvedPropertyKey(property, scope, state);
 		const localName = readPatternIdentifier(property.value);
-		if (exportedName && localName) if (modulePath) recordDynamicImportBinding(localName, exportedName, modulePath, state);
-		else recordUnresolvedGTShapedBinding(localName, exportedName, state);
+		if (exportedName && localName) if (modulePath) recordDynamicImportBinding(localName, exportedName, modulePath, state, importerFile === state.analysis.entryFile);
+		else recordUnresolvedGTShapedBinding(localName, exportedName, state, source === "gt-vue");
 	}
 }
+/** Returns whether one namespace binding is used through a static member. */
+function bindingReferencesNamespaceMember(binding, memberName, state, seen = /* @__PURE__ */ new Set()) {
+	if (!binding || seen.has(binding)) return false;
+	const nextSeen = new Set(seen).add(binding);
+	return Boolean(binding.referencePaths.some((referencePath) => {
+		let reference = referencePath;
+		while (reference.parentPath && unwrapExpression(reference.parentPath.node) === reference.node) reference = reference.parentPath;
+		const parent = reference.parentPath;
+		if (parent?.isMemberExpression() || parent?.isOptionalMemberExpression()) return parent.node.object === reference.node && readResolvedMemberProperty(parent.node, parent.scope, state) === memberName;
+		if (parent?.isJSXMemberExpression()) return parent.node.object === reference.node && parent.node.property.name === memberName;
+		if (parent?.isVariableDeclarator() && parent.node.init === reference.node) {
+			if (parent.node.id.type === "Identifier") return bindingReferencesNamespaceMember(parent.scope.getBinding(parent.node.id.name), memberName, state, nextSeen);
+			if (parent.node.id.type === "ObjectPattern") return parent.node.id.properties.some((property) => property.type === "RestElement" || property.type === "ObjectProperty" && readResolvedPropertyKey(property, parent.scope, state) === memberName);
+		}
+		if (parent?.isCallExpression() || parent?.isNewExpression() || parent?.isReturnStatement() || parent?.isSpreadElement() || parent?.isArrayExpression() || parent?.isObjectProperty()) return true;
+		return false;
+	}));
+}
 /** Marks only GT roles proven reachable from one static dynamic import. */
-function recordDynamicImportBinding(localName, exportName, modulePath, state) {
+function recordDynamicImportBinding(localName, exportName, modulePath, state, establishesEntryProvenance) {
 	const resolution = state.analysis.localModules?.resolveExport(modulePath, exportName);
 	if (!resolution || resolution.status === "absent") return;
 	if (resolution.status !== "resolved") {
-		recordUnresolvedGTShapedBinding(localName, exportName, state);
+		if (resolution.status === "invalid" && materializeRecoveredOrdinaryResolution(resolution, state) !== void 0) return;
+		if (establishesEntryProvenance && resolution.status === "invalid" && resolution.hasGTSourceReference) {
+			state.analysis.hasGTSourceReference = true;
+			state.unsupportedDynamicGTReference = true;
+			state.unsupportedMalformedGTReference = true;
+		}
+		if (resolution.status === "invalid" && resolution.hasGTSourceReference) recordInvalidGTResolution(localName, resolution, state);
+		else recordUnresolvedGTShapedBinding(localName, exportName, state);
 		return;
 	}
-	recordMaterializedLocalUncertainty(localName, materializeLocalExport(resolution.target, state), state, true);
+	const materialized = materializeLocalExport(resolution.target, state);
+	if (establishesEntryProvenance && materialized.hasGTSourceReference) {
+		state.analysis.hasGTSourceReference = true;
+		state.unsupportedDynamicGTReference = true;
+	}
+	recordMaterializedLocalUncertainty(localName, materialized, state, true);
 }
 /** Resolves one ESM import through a local, read-only source module graph. */
 function registerLocalImportDeclaration(declaration, scope, importerFile, state) {
 	const resolver = state.analysis.localModules;
 	const source = declaration.source.value;
+	if (isKnownNonVueGTRuntime(source)) return;
 	const modulePath = resolver && importerFile ? resolver.resolveModule(importerFile, source) : void 0;
-	if (!modulePath || !resolver?.getRecord(modulePath)) {
+	if (modulePath && resolver && !resolver.isProjectModule(modulePath)) return;
+	if (!resolver || !modulePath) {
 		recordUnresolvedTranslationHelperImports(declaration, scope, state);
 		if (source.startsWith(".") || source.startsWith("/") || resolver?.hasCustomResolver) recordUnresolvedGTShapedImports(declaration, state);
 		return;
 	}
 	for (const specifier of declaration.specifiers) {
-		if (specifier.type === "ImportSpecifier" && specifier.importKind === "type") continue;
+		if (specifier.type === "ImportSpecifier" && isTypeOnlyImportKind(specifier.importKind)) continue;
 		if (specifier.type === "ImportNamespaceSpecifier") {
 			const value = {
 				type: "local-namespace",
 				modulePath
 			};
 			registerImport(specifier.local.name, value, scope, state);
-			if (importerFile === state.analysis.entryFile) recordLocalNamespaceMembers(specifier.local.name, modulePath, state);
+			if (importerFile === state.analysis.entryFile) recordLocalNamespaceMembers(specifier.local.name, modulePath, state, scope.getBinding(specifier.local.name));
 			continue;
 		}
 		const exportName = specifier.type === "ImportDefaultSpecifier" ? "default" : specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
 		const resolution = resolver.resolveExport(modulePath, exportName);
+		let materialized;
 		if (resolution.status !== "resolved") {
-			recordUncertainTranslationHelperBinding(specifier.local.name, scope, state);
-			if (resolution.status === "ambiguous") recordAmbiguousLocalBinding(specifier.local.name, state);
-			else recordUnresolvedGTShapedBinding(specifier.local.name, exportName, state);
-			continue;
-		}
-		const materialized = materializeLocalExport(resolution.target, state);
+			if (resolution.status === "invalid") materialized = materializeRecoveredOrdinaryResolution(resolution, state, true);
+			if (!materialized) {
+				if (importerFile === state.analysis.entryFile && resolution.status === "invalid" && resolution.hasGTSourceReference) {
+					state.analysis.hasGTSourceReference = true;
+					state.unsupportedMalformedGTReference = true;
+				}
+				recordUncertainTranslationHelperBinding(specifier.local.name, scope, state);
+				if (resolution.status === "ambiguous") recordAmbiguousLocalBinding(specifier.local.name, state);
+				else if (resolution.status === "invalid" && resolution.hasGTSourceReference) recordInvalidGTResolution(specifier.local.name, resolution, state);
+				else recordUnresolvedGTShapedBinding(specifier.local.name, exportName, state);
+				continue;
+			}
+		} else materialized = materializeLocalExport(resolution.target, state);
+		if (importerFile === state.analysis.entryFile && materialized.hasGTSourceReference) state.analysis.hasGTSourceReference = true;
 		const binding = scope.getBinding(specifier.local.name);
 		if (materialized.value) {
 			registerImport(specifier.local.name, materialized.value, scope, state);
-			if (materialized.value.type === "local-namespace" && importerFile === state.analysis.entryFile) recordLocalNamespaceMembers(specifier.local.name, materialized.value.modulePath, state);
+			if (materialized.value.type === "local-namespace" && importerFile === state.analysis.entryFile) recordLocalNamespaceMembers(specifier.local.name, materialized.value.modulePath, state, binding);
 		}
 		if (binding && materialized.callable) state.localCallableBindings.set(binding, materialized.callable);
 		recordMaterializedLocalUncertainty(specifier.local.name, materialized, state);
@@ -472,25 +585,35 @@ function attachLocalModule(record, state) {
 	} });
 	collectImports(record.ast, state, record.filePath);
 }
-/** Converts a graph export into an analyzer identity or callable. */
 function materializeLocalExport(target, state) {
-	if (target.type === "external") return { value: knownExport(target.source, target.exportName) };
-	if (target.type === "external-namespace") return { value: {
-		mutable: false,
-		source: target.source,
-		type: "namespace"
-	} };
+	if (target.type === "ordinary-external") return {};
+	if (target.type === "external") return {
+		hasGTSourceReference: target.source === "gt-vue",
+		value: knownExport(target.source, target.exportName)
+	};
+	if (target.type === "external-namespace") return {
+		hasGTSourceReference: target.source === "gt-vue",
+		value: {
+			mutable: false,
+			source: target.source,
+			type: "namespace"
+		}
+	};
 	if (target.type === "namespace") return { value: {
 		type: "local-namespace",
 		modulePath: target.modulePath
 	} };
 	attachLocalModule(target.record, state);
-	if (target.type === "expression") return {
-		callable: resolveCalledFunction(target.node, target.record.programScope, state, /* @__PURE__ */ new Set()),
-		value: resolveKnownExpression(target.node, target.record.programScope, state, /* @__PURE__ */ new Set()),
-		possibleGTComponent: expressionMayProduceComponent(target.node, target.record.programScope, state, /* @__PURE__ */ new Set(), "translation"),
-		possibleStringFunction: expressionMayProduceStringFunction(target.node, target.record.programScope, state, /* @__PURE__ */ new Set())
-	};
+	if (target.type === "expression") {
+		const materialized = {
+			callable: resolveCalledFunction(target.node, target.record.programScope, state, /* @__PURE__ */ new Set()),
+			value: resolveKnownExpression(target.node, target.record.programScope, state, /* @__PURE__ */ new Set()),
+			possibleGTComponent: expressionMayProduceComponent(target.node, target.record.programScope, state, /* @__PURE__ */ new Set(), "translation"),
+			possibleStringFunction: expressionMayProduceStringFunction(target.node, target.record.programScope, state, /* @__PURE__ */ new Set())
+		};
+		materialized.hasGTSourceReference = isKnownGTValue(materialized.value);
+		return materialized;
+	}
 	const binding = target.record.programScope.getBinding(target.exportName);
 	if (!binding) return {};
 	const possibleGTComponent = expressionMayProduceComponent(binding.identifier, target.record.programScope, state, /* @__PURE__ */ new Set(), "translation");
@@ -500,21 +623,66 @@ function materializeLocalExport(target, state) {
 		possibleStringFunction,
 		unsafeCallable: bindingMayReferenceLocalCallable(binding, state)
 	};
-	return {
+	const materialized = {
 		callable: resolveCalledFunction(binding.identifier, target.record.programScope, state, /* @__PURE__ */ new Set()),
 		possibleGTComponent,
 		possibleStringFunction,
 		value: resolveKnownBinding(binding, state, /* @__PURE__ */ new Set())
 	};
+	materialized.hasGTSourceReference = isKnownGTValue(materialized.value);
+	return materialized;
+}
+/** Returns whether an exact analyzer identity came from gt-vue. */
+function isKnownGTValue(value) {
+	return value?.type === "component" || value?.type === "hook" || value?.type === "string" || value?.type === "namespace" && value.source === "gt-vue";
+}
+/** Materializes the one ordinary origin proven through a malformed module. */
+function materializeRecoveredOrdinaryResolution(resolution, state, preserveLocalIdentity = false) {
+	if (resolution.hasGTSourceReference || resolution.gtExportName || resolution.recoveredTargets?.length !== 1) return;
+	const target = resolution.recoveredTargets[0];
+	if (target.type === "ordinary-external") return {};
+	if (target.type === "external" || target.type === "external-namespace") return target.source === "vue" ? materializeLocalExport(target, state) : void 0;
+	if (target.type === "namespace") return void 0;
+	const materialized = materializeLocalExport(target, state);
+	if (materialized.hasGTSourceReference || materialized.possibleGTComponent || materialized.possibleStringFunction || materialized.unsafeCallable || isKnownGTValue(materialized.value)) return;
+	if (localTargetAliasesKnownNonVueRuntime(target)) return materialized;
+	return preserveLocalIdentity && materialized.callable && isOrdinaryIdentityFunction(materialized.callable.node) ? materialized : void 0;
+}
+/** Proves a direct immutable alias back to an official non-Vue GT runtime. */
+function localTargetAliasesKnownNonVueRuntime(target) {
+	if (target.type === "expression") return expressionAliasesKnownNonVueRuntime(target.node, target.record.programScope, /* @__PURE__ */ new Set());
+	const binding = target.record.programScope.getBinding(target.exportName);
+	if (!binding) return false;
+	const source = getBindingSource(binding);
+	if (!source || source.pattern.type !== "Identifier") return false;
+	return expressionAliasesKnownNonVueRuntime(source.expression.node, source.expression.scope, new Set([binding]));
+}
+/** Follows only immutable identifier aliases to named or default imports. */
+function expressionAliasesKnownNonVueRuntime(node, scope, seen) {
+	const expression = unwrapExpression(node);
+	if (expression?.type !== "Identifier") return false;
+	const binding = scope.getBinding(expression.name);
+	if (!binding || seen.has(binding)) return false;
+	const declaration = binding.path.parentPath;
+	if (declaration?.isImportDeclaration() && isKnownNonVueGTRuntime(declaration.node.source.value)) return true;
+	const source = getBindingSource(binding);
+	return Boolean(source && source.pattern.type === "Identifier" && expressionAliasesKnownNonVueRuntime(source.expression.node, source.expression.scope, new Set(seen).add(binding)));
+}
+/** Proves the narrow local helper form without following unknown dependencies. */
+function isOrdinaryIdentityFunction(node) {
+	if (node.async || node.generator || node.params.length !== 1 || node.params[0]?.type !== "Identifier") return false;
+	const expression = unwrapExpression(node.body.type === "BlockStatement" ? node.body.body.length === 1 && node.body.body[0]?.type === "ReturnStatement" ? node.body.body[0].argument : void 0 : node.body);
+	return expression?.type === "Identifier" && expression.name === node.params[0].name;
 }
 /** Makes statically known members of a local namespace visible to templates. */
-function recordLocalNamespaceMembers(localName, modulePath, state) {
+function recordLocalNamespaceMembers(localName, modulePath, state, binding) {
 	const resolver = state.analysis.localModules;
 	if (!resolver) return;
 	const exportNames = new Set([
 		...resolver.listExportNames(modulePath),
 		...COMPONENT_IMPORTS,
 		"msg",
+		"t",
 		"useGT",
 		"useMessages"
 	]);
@@ -523,8 +691,14 @@ function recordLocalNamespaceMembers(localName, modulePath, state) {
 		const resolution = resolver.resolveExport(modulePath, exportName);
 		if (resolution.status === "absent") continue;
 		if (resolution.status !== "resolved") {
+			if (resolution.status === "invalid" && materializeRecoveredOrdinaryResolution(resolution, state) !== void 0) continue;
+			if (resolution.status === "invalid" && resolution.hasGTSourceReference && bindingReferencesNamespaceMember(binding, exportName, state)) {
+				state.analysis.hasGTSourceReference = true;
+				state.unsupportedMalformedGTReference = true;
+			}
 			state.analysis.uncertainTranslationHelpers.add(memberPath);
 			if (resolution.status === "ambiguous") recordAmbiguousLocalBinding(memberPath, state);
+			else if (resolution.status === "invalid" && resolution.hasGTSourceReference) recordInvalidGTResolution(memberPath, resolution, state);
 			else recordUnresolvedGTShapedBinding(memberPath, exportName, state);
 			continue;
 		}
@@ -533,6 +707,33 @@ function recordLocalNamespaceMembers(localName, modulePath, state) {
 		recordMaterializedLocalUncertainty(memberPath, materialized, state);
 	}
 }
+/** Retains the original gt-vue role hidden by a malformed re-export alias. */
+function recordInvalidGTResolution(localName, resolution, state) {
+	if (resolution.gtExportName === "*") {
+		recordUnresolvedGTNamespace(localName, state, true);
+		return;
+	}
+	if (resolution.gtExportName) {
+		recordUnresolvedGTShapedBinding(localName, resolution.gtExportName, state, true);
+		return;
+	}
+	state.analysis.uncertainTranslationHelpers.add(localName);
+}
+/** Marks the GT-shaped members of one unresolved namespace path. */
+function recordUnresolvedGTNamespace(localName, state, includeImmediateTranslation = false) {
+	for (const component of COMPONENT_IMPORTS) {
+		const componentPath = appendTemplatePath(localName, component);
+		state.analysis.uncertainComponents.add(componentPath);
+		state.analysis.uncertainGTComponents.add(componentPath);
+	}
+	const stringFunctions = [
+		"msg",
+		"useGT",
+		"useMessages"
+	];
+	if (includeImmediateTranslation) stringFunctions.push("t");
+	for (const name of stringFunctions) state.analysis.uncertainStringFunctions.add(appendTemplatePath(localName, name));
+}
 /** Records unresolved roles only when a local export can actually be GT. */
 function recordMaterializedLocalUncertainty(localName, materialized, state, forceKnownValues = false) {
 	if (materialized.possibleGTComponent || forceKnownValues && materialized.value?.type === "component") {
@@ -552,19 +753,10 @@ function bindingMayReferenceLocalCallable(binding, state) {
 function recordUnresolvedGTShapedImports(declaration, state) {
 	for (const specifier of declaration.specifiers) {
 		if (specifier.type === "ImportNamespaceSpecifier") {
-			for (const component of COMPONENT_IMPORTS) {
-				const path = appendTemplatePath(specifier.local.name, component);
-				state.analysis.uncertainComponents.add(path);
-				state.analysis.uncertainGTComponents.add(path);
-			}
-			for (const name of [
-				"msg",
-				"useGT",
-				"useMessages"
-			]) state.analysis.uncertainStringFunctions.add(appendTemplatePath(specifier.local.name, name));
+			recordUnresolvedGTNamespace(specifier.local.name, state);
 			continue;
 		}
-		if (specifier.type === "ImportSpecifier" && specifier.importKind === "type") continue;
+		if (specifier.type === "ImportSpecifier" && isTypeOnlyImportKind(specifier.importKind)) continue;
 		const importedName = specifier.type === "ImportDefaultSpecifier" ? specifier.local.name : specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
 		recordUnresolvedGTShapedBinding(specifier.local.name, importedName, state);
 	}
@@ -572,7 +764,7 @@ function recordUnresolvedGTShapedImports(declaration, state) {
 /** Marks unresolved imports only when a call later passes a translator. */
 function recordUnresolvedTranslationHelperImports(declaration, scope, state) {
 	for (const specifier of declaration.specifiers) {
-		if (specifier.type === "ImportSpecifier" && specifier.importKind === "type") continue;
+		if (specifier.type === "ImportSpecifier" && isTypeOnlyImportKind(specifier.importKind)) continue;
 		recordUncertainTranslationHelperBinding(specifier.local.name, scope, state);
 	}
 }
@@ -583,12 +775,12 @@ function recordUncertainTranslationHelperBinding(localName, scope, state) {
 	if (binding) state.uncertainTranslationHelperBindings.add(binding);
 }
 /** Records the conservative GT roles implied by an unresolved export name. */
-function recordUnresolvedGTShapedBinding(localName, exportName, state) {
+function recordUnresolvedGTShapedBinding(localName, exportName, state, includeImmediateTranslation = false) {
 	if (COMPONENT_IMPORTS.has(exportName)) {
 		state.analysis.uncertainComponents.add(localName);
 		state.analysis.uncertainGTComponents.add(localName);
 	}
-	if (exportName === "msg" || exportName === "useGT" || exportName === "useMessages") state.analysis.uncertainStringFunctions.add(localName);
+	if (exportName === "msg" || includeImmediateTranslation && exportName === "t" || exportName === "useGT" || exportName === "useMessages") state.analysis.uncertainStringFunctions.add(localName);
 }
 /** Fails closed when a resolved local export is ambiguous or mutable. */
 function recordAmbiguousLocalBinding(localName, state) {
@@ -875,6 +1067,7 @@ function exposeKnownValue(localName, value, templateBindings, analysis) {
 	else if (value.type === "namespace" && value.source === "gt-vue") {
 		for (const component of COMPONENT_IMPORTS) templateBindings.components.set(appendTemplatePath(localName, component), component);
 		templateBindings.stringFunctions.set(appendTemplatePath(localName, "msg"), "msg");
+		templateBindings.stringFunctions.set(appendTemplatePath(localName, "t"), "t");
 	} else if (value.type === "namespace" && value.source === "vue") {
 		for (const builtin of VUE_BUILTIN_IMPORTS) templateBindings.vueBuiltins.set(appendTemplatePath(localName, builtin), builtin);
 		templateBindings.identityFunctions.add(appendTemplatePath(localName, "markRaw"));
@@ -919,6 +1112,7 @@ function exposeUncertainKnownValue(localName, value, uncertainComponents, uncert
 			uncertainGTComponents.add(appendTemplatePath(localName, component));
 		}
 		uncertainStringFunctions.add(appendTemplatePath(localName, "msg"));
+		uncertainStringFunctions.add(appendTemplatePath(localName, "t"));
 	} else if (value.type === "namespace" && value.source === "vue") for (const builtin of VUE_BUILTIN_IMPORTS) uncertainComponents.add(appendTemplatePath(localName, builtin));
 }
 /** Exposes a callable whose return can affect template component identity. */
@@ -1139,21 +1333,28 @@ function collectNamespaceRestMemberCandidates(localName, binding, pattern, value
 		return key !== void 0 ? [key] : [];
 	}));
 	const certain = isSafelyReadContainerBinding(binding, binding.identifier, Number.POSITIVE_INFINITY, true, state);
-	return (namespace.source === "gt-vue" ? [...[...COMPONENT_IMPORTS].map((name) => ({
-		type: "component",
-		name
-	})), {
-		type: "string",
-		kind: "msg"
-	}] : [...VUE_BUILTIN_IMPORTS].map((name) => ({
+	return (namespace.source === "gt-vue" ? [
+		...[...COMPONENT_IMPORTS].map((name) => ({
+			type: "component",
+			name
+		})),
+		{
+			type: "string",
+			kind: "msg"
+		},
+		{
+			type: "string",
+			kind: "t"
+		}
+	] : [...VUE_BUILTIN_IMPORTS].map((name) => ({
 		type: "vue-builtin",
 		name
 	}))).filter((entry) => {
-		const name = entry.type === "component" ? entry.name : entry.type === "string" ? "msg" : entry.name;
+		const name = entry.type === "component" ? entry.name : entry.type === "string" ? entry.kind : entry.name;
 		return !excluded.has(name);
 	}).map((entry) => ({
 		certain,
-		name: appendTemplatePath(localName, entry.type === "component" ? entry.name : entry.type === "string" ? "msg" : entry.name),
+		name: appendTemplatePath(localName, entry.type === "component" ? entry.name : entry.type === "string" ? entry.kind : entry.name),
 		value: entry
 	}));
 }
@@ -1986,13 +2187,12 @@ function resolveKnownExpression(node, scope, state, seen) {
 	if (expression.type === "LogicalExpression") {
 		const left = resolveKnownExpression(expression.left, scope, state, new Set(seen));
 		if (left) return expression.operator === "&&" ? resolveKnownExpression(expression.right, scope, state, new Set(seen)) : left;
-		const staticLeft = readStaticFromScope(expression.left, scope, /* @__PURE__ */ new Set(), expression.left.end ?? Number.POSITIVE_INFINITY, state.analysis);
-		if (!staticLeft.ok) return void 0;
-		return (expression.operator === "??" ? staticLeft.value == null : expression.operator === "||" ? !staticLeft.value : Boolean(staticLeft.value)) ? resolveKnownExpression(expression.right, scope, state, new Set(seen)) : void 0;
+		const selection = readStaticLogicalSelection(expression, scope, state, new Set(seen));
+		return selection ? resolveKnownExpression(expression[selection], scope, state, new Set(seen)) : void 0;
 	}
 	if (expression.type === "ConditionalExpression") {
-		const condition = readStaticFromScope(expression.test, scope, /* @__PURE__ */ new Set(), expression.test.end ?? Number.POSITIVE_INFINITY, state.analysis);
-		if (condition.ok) return resolveKnownExpression(condition.value ? expression.consequent : expression.alternate, scope, state, new Set(seen));
+		const condition = readStaticTruthiness(expression.test, scope, state, new Set(seen));
+		if (condition) return resolveKnownExpression(condition === "truthy" ? expression.consequent : expression.alternate, scope, state, new Set(seen));
 		const consequent = resolveKnownExpression(expression.consequent, scope, state, new Set(seen));
 		const alternate = resolveKnownExpression(expression.alternate, scope, state, new Set(seen));
 		return consequent && alternate && knownValueKey(consequent) === knownValueKey(alternate) ? consequent : void 0;
@@ -3444,6 +3644,31 @@ function bindingMayReferenceStringFunction(binding, state) {
 	if (declaration.type === "VariableDeclarator" && declaration.init && patternMayProduceStringFunction(declaration.id, declaration.init, binding.identifier.name, binding.path.scope, state, new Set([binding]))) return true;
 	return binding.constantViolations.some((violation) => violation.isAssignmentExpression() && patternContains(violation.node.left, binding.identifier.name) && expressionMayProduceStringFunction(violation.node.right, violation.scope, state, new Set([binding])));
 }
+/** Evaluates only side-effect-free truthiness needed for static branch choice. */
+function readStaticTruthiness(node, scope, state, seen) {
+	const expression = unwrapExpression(node);
+	if (!expression) return void 0;
+	const primitive = readStaticFromScope(expression, scope, new Set(seen), expression.end ?? Number.POSITIVE_INFINITY, state.analysis);
+	if (primitive.ok) {
+		if (primitive.value == null) return "nullish";
+		return primitive.value ? "truthy" : "falsy";
+	}
+	if (expression.type === "ConditionalExpression" || expression.type === "LogicalExpression") return;
+	if (resolveKnownExpression(expression, scope, state, new Set(seen))) return "truthy";
+	if (expression.type === "ArrayExpression" || expression.type === "ArrowFunctionExpression" || expression.type === "ClassExpression" || expression.type === "FunctionExpression" || expression.type === "ObjectExpression" || expression.type === "RegExpLiteral") return "truthy";
+	if (expression.type === "Identifier") {
+		const binding = scope.getBinding(expression.name);
+		if (!binding) return expression.name !== "undefined" && ORDINARY_GLOBAL_VALUES.has(expression.name) ? "truthy" : void 0;
+		if (!binding.constant || seen.has(binding)) return void 0;
+		if (binding.path.isClassDeclaration() || binding.path.isFunctionDeclaration()) return "truthy";
+	}
+}
+/** Selects a logical branch when the left value's truthiness is static. */
+function readStaticLogicalSelection(expression, scope, state, seen = /* @__PURE__ */ new Set()) {
+	const value = readStaticTruthiness(expression.left, scope, state, seen);
+	if (!value) return void 0;
+	return (expression.operator === "??" ? value === "nullish" : expression.operator === "||" ? value !== "truthy" : value === "truthy") ? "right" : "left";
+}
 /** Tracks expressions whose resulting value can be a gt-vue string function. */
 function expressionMayProduceStringFunction(node, scope, state, seen) {
 	if (state.analysis.stats) state.analysis.stats.stringFunctionVisits += 1;
@@ -3482,8 +3707,16 @@ function expressionMayProduceStringFunction(node, scope, state, seen) {
 		}
 		return expression.arguments.some((argument) => argument.type !== "ArgumentPlaceholder" && (expressionMayProduceStringFunction(argument.type === "SpreadElement" ? argument.argument : argument, scope, state, seen) || containerMayContainStringFunction(argument.type === "SpreadElement" ? argument.argument : argument, scope, state, /* @__PURE__ */ new Set())));
 	}
-	if (expression.type === "ConditionalExpression") return expressionMayProduceStringFunction(expression.consequent, scope, state, seen) || expressionMayProduceStringFunction(expression.alternate, scope, state, seen);
-	if (expression.type === "LogicalExpression") return expressionMayProduceStringFunction(expression.left, scope, state, seen) || expressionMayProduceStringFunction(expression.right, scope, state, seen);
+	if (expression.type === "ConditionalExpression") {
+		const condition = readStaticTruthiness(expression.test, scope, state, seen);
+		if (condition) return expressionMayProduceStringFunction(condition === "truthy" ? expression.consequent : expression.alternate, scope, state, seen);
+		return expressionMayProduceStringFunction(expression.consequent, scope, state, seen) || expressionMayProduceStringFunction(expression.alternate, scope, state, seen);
+	}
+	if (expression.type === "LogicalExpression") {
+		const selection = readStaticLogicalSelection(expression, scope, state);
+		if (selection) return expressionMayProduceStringFunction(expression[selection], scope, state, seen);
+		return expressionMayProduceStringFunction(expression.left, scope, state, seen) || expressionMayProduceStringFunction(expression.right, scope, state, seen);
+	}
 	if (expression.type === "SequenceExpression") return expressionMayProduceStringFunction(expression.expressions.at(-1), scope, state, seen);
 	if (expression.type === "AssignmentExpression") return expressionMayProduceStringFunction(expression.right, scope, state, seen);
 	if (expression.type === "AwaitExpression" || expression.type === "YieldExpression") return expressionMayProduceStringFunction(expression.argument, scope, state, seen);
@@ -4187,7 +4420,7 @@ function collectTransformArrayEntries(node, scope, state, seen, atPosition = nod
 			ok: true,
 			value: fallback
 		};
-		const value = readStaticFromScope(node, scope, /* @__PURE__ */ new Set(), node.end ?? atPosition, state.analysis, true);
+		const value = readStaticFromScope(node, scope, /* @__PURE__ */ new Set(), node.end ?? atPosition, state.analysis);
 		if (!value.ok || typeof value.value === "bigint") return { ok: false };
 		try {
 			const numeric = Number(value.value);
@@ -4402,7 +4635,7 @@ function collectTransformArrayEntries(node, scope, state, seen, atPosition = nod
 		let entries = collectTransformArrayEntries(callee.object, scope, state, nextSeen, atPosition);
 		if (!entries) return void 0;
 		const depthNode = argument(0);
-		const staticDepth = depthNode ? readStaticFromScope(depthNode, scope, /* @__PURE__ */ new Set(), depthNode.end ?? atPosition, state.analysis, true) : {
+		const staticDepth = depthNode ? readStaticFromScope(depthNode, scope, /* @__PURE__ */ new Set(), depthNode.end ?? atPosition, state.analysis) : {
 			ok: true,
 			value: 1
 		};
@@ -4640,35 +4873,24 @@ function memberChainCanMutate(memberPath, allowCalls) {
 	}
 	return true;
 }
-function readStaticFromScope(node, scope, seen, atPosition, analysis, allowNumericGlobals = false) {
+function readStaticFromScope(node, scope, seen, atPosition, analysis) {
 	return readStaticPrimitive(node, (identifier) => {
 		const binding = scope.getBinding(identifier.name);
 		if (!binding) {
-			const value = analysis?.staticValues.get(identifier.name);
 			if (analysis?.staticValues.has(identifier.name)) return {
 				ok: true,
-				value
-			};
-			if (allowNumericGlobals && identifier.name === "Infinity") return {
-				ok: true,
-				value: Number.POSITIVE_INFINITY
-			};
-			if (allowNumericGlobals && identifier.name === "NaN") return {
-				ok: true,
-				value: NaN
+				value: analysis.staticValues.get(identifier.name)
 			};
-			return { ok: false };
+			return readStaticGlobalPrimitive(identifier.name);
 		}
 		const cacheable = analysis !== void 0 && atPosition === Number.POSITIVE_INFINITY;
-		const cached = cacheable ? staticBindingResults.get(analysis)?.get(binding)?.get(allowNumericGlobals) : void 0;
+		const cached = cacheable ? staticBindingResults.get(analysis)?.get(binding) : void 0;
 		if (cached) return cached;
 		if (seen.has(binding)) return { ok: false };
 		if (cacheable) {
-			const active = staticBindingsInProgress.get(analysis) ?? /* @__PURE__ */ new Map();
-			const modes = active.get(binding) ?? /* @__PURE__ */ new Set();
-			if (modes.has(allowNumericGlobals)) return { ok: false };
-			modes.add(allowNumericGlobals);
-			active.set(binding, modes);
+			const active = staticBindingsInProgress.get(analysis) ?? /* @__PURE__ */ new Set();
+			if (active.has(binding)) return { ok: false };
+			active.add(binding);
 			staticBindingsInProgress.set(analysis, active);
 		}
 		const nextSeen = new Set(seen);
@@ -4676,22 +4898,15 @@ function readStaticFromScope(node, scope, seen, atPosition, analysis, allowNumer
 		try {
 			const source = getBindingSource(binding);
 			const expression = source && (source.expression.node.end ?? 0) <= atPosition ? selectPatternExpression(source.pattern, source.expression.node, binding.identifier.name, source.expression.scope, source.expression.node.end ?? Number.POSITIVE_INFINITY) : void 0;
-			const result = expression ? readStaticFromScope(expression.node, expression.scope, nextSeen, atPosition, analysis, allowNumericGlobals) : { ok: false };
+			const result = expression ? readStaticFromScope(expression.node, expression.scope, nextSeen, atPosition, analysis) : { ok: false };
 			if (cacheable) {
 				const results = staticBindingResults.get(analysis) ?? /* @__PURE__ */ new Map();
-				const modes = results.get(binding) ?? /* @__PURE__ */ new Map();
-				modes.set(allowNumericGlobals, result);
-				results.set(binding, modes);
+				results.set(binding, result);
 				staticBindingResults.set(analysis, results);
 			}
 			return result;
 		} finally {
-			if (cacheable) {
-				const active = staticBindingsInProgress.get(analysis);
-				const modes = active?.get(binding);
-				modes?.delete(allowNumericGlobals);
-				if (modes?.size === 0) active?.delete(binding);
-			}
+			if (cacheable) staticBindingsInProgress.get(analysis)?.delete(binding);
 		}
 	});
 }