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

package/dist/internal/script/localModules.js

@@ -1,7 +1,9 @@
 import { parseScriptAst } from "./parser.js";
+import { isKnownNonVueGTRuntime } from "./runtimeModules.js";
 import fs from "node:fs";
 import path from "node:path";
 import traverseModule from "@babel/traverse";
+import { initSync, parse } from "es-module-lexer";
 //#region src/internal/script/localModules.ts
 const traverse = traverseModule.default || traverseModule;
 const SOURCE_EXTENSIONS = [
@@ -27,6 +29,13 @@ const GT_EXPORT_NAMES = [
 	"useGT",
 	"useMessages"
 ];
+/** Complete public value surface currently exported by the gt-vue runtime. */
+const GT_RUNTIME_EXPORT_NAMES = [
+	...GT_EXPORT_NAMES,
+	"createGT",
+	"useLocale",
+	"useSetLocale"
+];
 const VUE_EXPORT_NAMES = [
 	"Suspense",
 	"computed",
@@ -51,9 +60,14 @@ const VUE_EXPORT_NAMES = [
 * The resolver reads and parses source text but never imports or executes it.
 * Bare aliases are accepted only through the caller's explicit resolver hook.
 */
-function createLocalModuleResolver(resolveModuleOption) {
+function createLocalModuleResolver(resolveModuleOption, options = {}) {
 	const records = /* @__PURE__ */ new Map();
+	const recoveredRecords = /* @__PURE__ */ new Map();
 	const resolutions = /* @__PURE__ */ new Map();
+	const recordPaths = /* @__PURE__ */ new WeakMap();
+	const isProjectModule = (filePath) => {
+		return !readRealPath(path.resolve(filePath)).split(path.sep).includes("node_modules");
+	};
 	const resolveModule = (importer, specifier) => {
 		if (specifier === "gt-vue" || specifier === "vue") return void 0;
 		let requested;
@@ -66,6 +80,7 @@ function createLocalModuleResolver(resolveModuleOption) {
 	};
 	const getRecord = (filePath) => {
 		const normalized = path.resolve(filePath);
+		if (!isProjectModule(normalized)) return void 0;
 		const cached = records.get(normalized);
 		if (cached !== void 0) return cached ?? void 0;
 		records.set(normalized, null);
@@ -73,33 +88,375 @@ function createLocalModuleResolver(resolveModuleOption) {
 		records.set(normalized, parsed ?? null);
 		return parsed;
 	};
+	const getRecoveredRecord = (filePath) => {
+		const normalized = path.resolve(filePath);
+		if (!isProjectModule(normalized)) return void 0;
+		const cached = recoveredRecords.get(normalized);
+		if (cached !== void 0) return cached ?? void 0;
+		const recovered = recoverMalformedModuleExports(normalized);
+		recoveredRecords.set(normalized, recovered ?? null);
+		return recovered;
+	};
 	const resolveExportInternal = (filePath, exportName, seen) => {
 		const normalized = path.resolve(filePath);
+		if (!isProjectModule(normalized)) return {
+			status: "resolved",
+			target: {
+				originKey: `${normalized}#${exportName}`,
+				type: "ordinary-external"
+			}
+		};
 		const cycleKey = `${normalized}\0${exportName}`;
 		if (seen.has(cycleKey)) return { status: "absent" };
-		const record = getRecord(normalized);
-		if (!record) return { status: "invalid" };
 		const nextSeen = new Set(seen).add(cycleKey);
+		const record = getRecord(normalized);
+		if (!record) {
+			const recovered = getRecoveredRecord(normalized);
+			return recovered ? resolveRecoveredExport(recovered, exportName, nextSeen) : { status: "invalid" };
+		}
 		const explicit = record.explicitExports.get(exportName);
 		if (explicit === "ambiguous") return { status: "ambiguous" };
 		if (explicit) return resolveDeclaredExport(record, exportName, explicit, nextSeen);
 		if (exportName === "default") return { status: "absent" };
 		const candidates = [];
+		let ambiguous = false;
 		let invalid = false;
+		let invalidGTExportName;
+		let invalidGTSourceReference = false;
+		let recoveredTargets = [];
 		for (const source of record.starExports) {
 			const candidate = resolveFromSource(record, source, exportName, nextSeen);
-			if (candidate.status === "resolved") candidates.push(candidate.target);
-			if (candidate.status === "ambiguous") return candidate;
-			if (candidate.status === "invalid") invalid = true;
+			if (candidate.status === "absent") continue;
+			const candidateGTExportName = readGTExportName(candidate, nextSeen);
+			invalidGTSourceReference ||= candidateGTExportName !== void 0;
+			invalidGTExportName ??= candidateGTExportName;
+			if (candidate.status === "resolved") {
+				candidates.push(candidate.target);
+				recoveredTargets?.push(candidate.target);
+			}
+			if (candidate.status === "ambiguous") {
+				ambiguous = true;
+				recoveredTargets = void 0;
+			}
+			if (candidate.status === "invalid") {
+				invalid = true;
+				invalidGTSourceReference ||= candidate.hasGTSourceReference === true;
+				invalidGTExportName ??= candidate.gtExportName;
+				if (recoveredTargets && candidate.recoveredTargets) recoveredTargets.push(...candidate.recoveredTargets);
+				else recoveredTargets = void 0;
+			}
 		}
-		if (candidates.length === 0) return { status: invalid ? "invalid" : "absent" };
-		return new Set(candidates.map(({ originKey }) => originKey)).size === 1 ? {
+		if (new Set(candidates.map(({ originKey }) => originKey)).size > 1) {
+			ambiguous = true;
+			recoveredTargets = void 0;
+		}
+		if (recoveredTargets && new Set(recoveredTargets.map(({ originKey }) => originKey)).size > 1) {
+			ambiguous = true;
+			recoveredTargets = void 0;
+		}
+		if (invalid) return {
+			...invalidGTSourceReference && { hasGTSourceReference: true },
+			...invalidGTExportName && { gtExportName: invalidGTExportName },
+			...recoveredTargets?.length && { recoveredTargets: uniqueRecoveredTargets(recoveredTargets) },
+			status: "invalid"
+		};
+		if (ambiguous) return { status: "ambiguous" };
+		return candidates.length === 0 ? { status: "absent" } : {
 			status: "resolved",
 			target: candidates[0]
-		} : { status: "ambiguous" };
+		};
+	};
+	const resolveRecoveredExport = (record, exportName, seen) => {
+		const explicit = record.explicitExports.get(exportName);
+		if (explicit === "ambiguous") return { status: "ambiguous" };
+		if (explicit) return invalidateRecoveredResolution(explicit.type === "reexport" ? resolveFromSource(record, explicit.source, explicit.importedName, seen) : resolveRecoveredNamespace(record, explicit.source), seen);
+		if (exportName === "default") return { status: "invalid" };
+		let gtExportName;
+		let recoveredTargets = [];
+		for (const source of record.starExports) {
+			const candidate = resolveFromSource(record, source, exportName, seen);
+			if (candidate.status === "absent") continue;
+			gtExportName ??= readGTExportName(candidate, seen);
+			if (recoveredTargets && candidate.status === "resolved") recoveredTargets.push(candidate.target);
+			else if (recoveredTargets && candidate.status === "invalid" && candidate.recoveredTargets) recoveredTargets.push(...candidate.recoveredTargets);
+			else recoveredTargets = void 0;
+		}
+		if (recoveredTargets && new Set(recoveredTargets.map(({ originKey }) => originKey)).size > 1) recoveredTargets = void 0;
+		return {
+			...gtExportName && {
+				gtExportName,
+				hasGTSourceReference: true
+			},
+			...recoveredTargets?.length && { recoveredTargets: uniqueRecoveredTargets(recoveredTargets) },
+			status: "invalid"
+		};
+	};
+	const resolveRecoveredNamespace = (record, source) => {
+		if (isKnownNonVueGTRuntime(source)) return {
+			status: "resolved",
+			target: {
+				originKey: `${source}#namespace`,
+				type: "ordinary-external"
+			}
+		};
+		if (isExternalModule(source)) return {
+			status: "resolved",
+			target: {
+				originKey: `${source}#namespace`,
+				source,
+				type: "external-namespace"
+			}
+		};
+		const modulePath = resolveModule(record.filePath, source);
+		if (!modulePath) return { status: "invalid" };
+		if (!isProjectModule(modulePath)) return {
+			status: "resolved",
+			target: {
+				originKey: `${modulePath}#namespace`,
+				type: "ordinary-external"
+			}
+		};
+		return {
+			status: "resolved",
+			target: {
+				modulePath,
+				originKey: `${modulePath}#namespace`,
+				type: "namespace"
+			}
+		};
+	};
+	const invalidateRecoveredResolution = (resolution, seen) => {
+		const gtExportName = readGTExportName(resolution, seen);
+		return {
+			...gtExportName && {
+				gtExportName,
+				hasGTSourceReference: true
+			},
+			...resolution.status === "resolved" ? { recoveredTargets: [resolution.target] } : resolution.status === "invalid" && resolution.recoveredTargets ? { recoveredTargets: resolution.recoveredTargets } : {},
+			status: "invalid"
+		};
+	};
+	const readGTExportName = (resolution, seen, allowNamespaceContainers = true) => {
+		if (resolution.status === "invalid") return allowNamespaceContainers || resolution.gtExportName !== "*" ? resolution.gtExportName : void 0;
+		if (resolution.status !== "resolved") return void 0;
+		const { target } = resolution;
+		if (target.type === "external") return target.source === "gt-vue" ? target.exportName : void 0;
+		if (target.type === "external-namespace") return allowNamespaceContainers && target.source === "gt-vue" ? "*" : void 0;
+		if (target.type === "namespace") {
+			if (!allowNamespaceContainers) return void 0;
+			return (options.recognizeAllGTRuntimeExports ? [...GT_RUNTIME_EXPORT_NAMES] : [...GT_EXPORT_NAMES]).some((name) => Boolean(readGTExportName(resolveExportInternal(target.modulePath, name, seen), seen, allowNamespaceContainers))) ? "*" : void 0;
+		}
+		if (target.type === "ordinary-external") return void 0;
+		const state = {
+			bindings: /* @__PURE__ */ new Set(),
+			nodes: /* @__PURE__ */ new Set(),
+			record: target.record,
+			resolutions: seen,
+			allowNamespaceContainers
+		};
+		if (target.type === "expression") return readDerivedGT(target.node, state);
+		const binding = target.record.programScope.getBinding(target.exportName);
+		return binding ? readDerivedGTBinding(binding, state) : void 0;
+	};
+	/** Lazily indexes lexical paths only when package provenance needs them. */
+	const readNodePath = (record, node) => {
+		let paths = recordPaths.get(record);
+		if (!paths) {
+			paths = /* @__PURE__ */ new WeakMap();
+			traverse(record.ast, { enter(nodePath) {
+				paths.set(nodePath.node, nodePath);
+			} });
+			recordPaths.set(record, paths);
+		}
+		return paths.get(node);
+	};
+	/** Rejects a namespace member whose value is overwritten in this module. */
+	const namespaceMemberIsWritten = (binding, exportName) => {
+		return binding.referencePaths.some((reference) => {
+			const member = reference.parentPath;
+			if (!member?.isMemberExpression() && !member?.isOptionalMemberExpression() || member.node.object !== reference.node || readStaticMemberName(member.node) !== exportName) return false;
+			const parent = member.parentPath?.node;
+			return Boolean(parent?.type === "AssignmentExpression" && parent.left === member.node || parent?.type === "UpdateExpression" && parent.argument === member.node || parent?.type === "UnaryExpression" && parent.operator === "delete" && parent.argument === member.node || (parent?.type === "ForInStatement" || parent?.type === "ForOfStatement") && parent.left === member.node);
+		});
+	};
+	/** Follows immutable aliases while rejecting mutation and lexical shadows. */
+	const readDerivedGTBinding = (binding, state) => {
+		if (!binding.constant || state.bindings.has(binding)) return void 0;
+		const next = {
+			...state,
+			bindings: new Set(state.bindings).add(binding)
+		};
+		if (binding.kind === "module") {
+			const imported = state.record.imports.get(binding.identifier.name);
+			if (!imported) return void 0;
+			if (imported.importedName === "*") return state.allowNamespaceContainers && imported.source === "gt-vue" ? "*" : void 0;
+			return readGTExportName(resolveFromSource(state.record, imported.source, imported.importedName, state.resolutions), state.resolutions, state.allowNamespaceContainers);
+		}
+		const declaration = binding.path.node;
+		if (declaration.type === "VariableDeclarator") {
+			if (declaration.id.type === "Identifier") return readDerivedGT(declaration.init, next);
+			return readDestructuredGTBinding(binding, declaration, next);
+		}
+		return declaration.type === "FunctionDeclaration" ? readDerivedGT(declaration, next) : void 0;
+	};
+	/** Resolves one exact leaf destructured from a direct gt-vue namespace. */
+	const readDestructuredGTBinding = (binding, declaration, state) => {
+		if (declaration.id.type !== "ObjectPattern" || declaration.id.properties.some((property) => property.type === "RestElement")) return;
+		const property = declaration.id.properties.find((candidate) => candidate.type === "ObjectProperty" && !candidate.computed && candidate.value.type === "Identifier" && candidate.value === binding.identifier);
+		const exportName = property ? readStaticObjectKey(property) : void 0;
+		if (!exportName || !knownExternalExport("gt-vue", exportName, options.recognizeAllGTRuntimeExports === true)) return;
+		const namespace = unwrapLocalExpression(declaration.init);
+		if (!namespace || namespace.type !== "Identifier") return void 0;
+		const namespaceBinding = readNodePath(state.record, namespace)?.scope.getBinding(namespace.name);
+		const imported = namespaceBinding ? state.record.imports.get(namespaceBinding.identifier.name) : void 0;
+		return namespaceBinding?.kind === "module" && namespaceBinding.constant && imported?.source === "gt-vue" && imported.importedName === "*" && !namespaceMemberIsWritten(namespaceBinding, exportName) ? exportName : void 0;
+	};
+	/** Resolves a direct gt-vue value, including immutable local aliases. */
+	const readDirectGT = (node, state) => {
+		const expression = unwrapLocalExpression(node);
+		if (!expression || state.nodes.has(expression)) return void 0;
+		const next = {
+			...state,
+			nodes: new Set(state.nodes).add(expression)
+		};
+		if (expression.type === "Identifier") {
+			const binding = readNodePath(state.record, expression)?.scope.getBinding(expression.name);
+			return binding ? readDerivedGTBinding(binding, next) : void 0;
+		}
+		if (expression.type !== "MemberExpression" && expression.type !== "OptionalMemberExpression") return;
+		const property = readStaticMemberName(expression);
+		const object = unwrapLocalExpression(expression.object);
+		if (!property || object?.type !== "Identifier") return void 0;
+		const binding = readNodePath(state.record, object)?.scope.getBinding(object.name);
+		if (!binding || binding.kind !== "module" || !binding.constant) return;
+		const imported = state.record.imports.get(binding.identifier.name);
+		if (!imported || imported.importedName !== "*") return void 0;
+		if (namespaceMemberIsWritten(binding, property)) return void 0;
+		if (imported.source === "gt-vue") return knownExternalExport(imported.source, property, options.recognizeAllGTRuntimeExports === true) ? property : void 0;
+		const modulePath = resolveModule(state.record.filePath, imported.source);
+		return modulePath && isProjectModule(modulePath) ? readGTExportName(resolveExportInternal(modulePath, property, state.resolutions), state.resolutions, state.allowNamespaceContainers) : void 0;
+	};
+	/** Recognizes only explicit aliases and Vue component wrapper forms. */
+	const readDerivedGT = (node, state) => {
+		const direct = readDirectGT(node, state);
+		if (direct) return direct;
+		const expression = unwrapLocalExpression(node);
+		if (!expression || state.nodes.has(expression)) return void 0;
+		const next = {
+			...state,
+			nodes: new Set(state.nodes).add(expression)
+		};
+		if (expression.type === "ArrowFunctionExpression" || expression.type === "FunctionExpression" || expression.type === "FunctionDeclaration" || expression.type === "ObjectMethod") return readFunctionRenderedGT(expression, next);
+		if (expression.type === "ObjectExpression") return readComponentObjectGT(expression, next);
+		if ((expression.type === "CallExpression" || expression.type === "OptionalCallExpression") && isVueHelper(expression.callee, state, "defineComponent")) {
+			const component = expression.arguments[0];
+			return component && component.type !== "SpreadElement" && component.type !== "ArgumentPlaceholder" ? readDerivedGT(component, next) : void 0;
+		}
+		return readRenderedGT(expression, state);
+	};
+	/** Checks only return values owned by the wrapper function itself. */
+	const readFunctionRenderedGT = (fn, state) => {
+		if (fn.type === "ArrowFunctionExpression" && fn.body.type !== "BlockStatement") return readRenderedGT(fn.body, state);
+		const functionPath = readNodePath(state.record, fn);
+		if (!functionPath) return void 0;
+		let result;
+		functionPath.traverse({ ReturnStatement(returnPath) {
+			if (result || returnPath.getFunctionParent()?.node !== fn) return;
+			result = readRenderedGT(returnPath.node.argument, state);
+		} });
+		return result;
+	};
+	/** Checks the two component options that can directly produce rendered output. */
+	const readComponentObjectGT = (object, state) => {
+		for (const property of object.properties) {
+			if (property.type === "SpreadElement") continue;
+			const name = readStaticObjectKey(property);
+			if (name !== "render" && name !== "setup") continue;
+			const result = readDerivedGT(property.type === "ObjectProperty" ? property.value : property, state);
+			if (result) return result;
+		}
+	};
+	/** Recognizes GT only in returned JSX or the h/createVNode component slot. */
+	const readRenderedGT = (node, state) => {
+		const expression = unwrapLocalExpression(node);
+		if (!expression || state.nodes.has(expression)) return void 0;
+		const next = {
+			...state,
+			nodes: new Set(state.nodes).add(expression)
+		};
+		if (expression.type === "ArrowFunctionExpression" || expression.type === "FunctionExpression") return readFunctionRenderedGT(expression, next);
+		if (expression.type === "JSXElement") {
+			const component = readJSXComponentGT(expression.openingElement.name, next);
+			if (component) return component;
+			for (const child of expression.children) {
+				const result = readRenderedGT(child.type === "JSXExpressionContainer" ? child.expression.type === "JSXEmptyExpression" ? void 0 : child.expression : child, next);
+				if (result) return result;
+			}
+			return;
+		}
+		if (expression.type === "JSXFragment") {
+			for (const child of expression.children) {
+				const result = readRenderedGT(child.type === "JSXExpressionContainer" ? child.expression.type === "JSXEmptyExpression" ? void 0 : child.expression : child, next);
+				if (result) return result;
+			}
+			return;
+		}
+		if (expression.type === "ConditionalExpression") return readRenderedGT(expression.consequent, next) ?? readRenderedGT(expression.alternate, next);
+		if (expression.type === "LogicalExpression") return readRenderedGT(expression.left, next) ?? readRenderedGT(expression.right, next);
+		if (expression.type !== "CallExpression" && expression.type !== "OptionalCallExpression" || !isVueHelper(expression.callee, state, "h") && !isVueHelper(expression.callee, state, "createVNode")) return;
+		const component = expression.arguments[0];
+		return component && component.type !== "SpreadElement" && component.type !== "ArgumentPlaceholder" ? readDirectGT(component, next) : void 0;
+	};
+	/** Resolves an imported GT component used as a JSX element name. */
+	const readJSXComponentGT = (name, state) => {
+		if (name.type === "JSXMemberExpression") {
+			if (name.object.type !== "JSXIdentifier") return void 0;
+			const binding = readNodePath(state.record, name.object)?.scope.getBinding(name.object.name);
+			if (!binding || binding.kind !== "module" || !binding.constant) return;
+			const imported = state.record.imports.get(binding.identifier.name);
+			if (!imported || imported.importedName !== "*") return void 0;
+			const property = name.property.name;
+			if (namespaceMemberIsWritten(binding, property)) return void 0;
+			if (imported.source === "gt-vue") return knownExternalExport(imported.source, property, options.recognizeAllGTRuntimeExports === true) ? property : void 0;
+			const modulePath = resolveModule(state.record.filePath, imported.source);
+			return modulePath && isProjectModule(modulePath) ? readGTExportName(resolveExportInternal(modulePath, property, state.resolutions), state.resolutions, state.allowNamespaceContainers) : void 0;
+		}
+		if (name.type !== "JSXIdentifier" || /^[a-z]/.test(name.name)) return;
+		const binding = readNodePath(state.record, name)?.scope.getBinding(name.name);
+		return binding ? readDerivedGTBinding(binding, state) : void 0;
+	};
+	/** Matches a direct or namespace ESM import from Vue without evaluating calls. */
+	const isVueHelper = (node, state, exportName) => {
+		const expression = unwrapLocalExpression(node);
+		if (!expression) return false;
+		const identifier = expression.type === "Identifier" ? expression : (expression.type === "MemberExpression" || expression.type === "OptionalMemberExpression") && readStaticMemberName(expression) === exportName ? unwrapLocalExpression(expression.object) : void 0;
+		if (!identifier || identifier.type !== "Identifier") return false;
+		const binding = readNodePath(state.record, identifier)?.scope.getBinding(identifier.name);
+		const imported = binding?.kind === "module" ? state.record.imports.get(binding.identifier.name) : void 0;
+		const expectedImport = expression.type === "Identifier" ? exportName : "*";
+		return binding?.constant === true && imported?.source === "vue" && imported.importedName === expectedImport && (expectedImport !== "*" || !namespaceMemberIsWritten(binding, exportName));
+	};
+	const readStaticMemberName = (member) => {
+		if (!member.computed && member.property.type === "Identifier") return member.property.name;
+		return member.computed && member.property.type === "StringLiteral" ? member.property.value : void 0;
+	};
+	const readStaticObjectKey = (property) => {
+		if (!property.key) return void 0;
+		if (!property.computed && property.key.type === "Identifier") return property.key.name;
+		return property.key.type === "StringLiteral" ? property.key.value : void 0;
+	};
+	const resolutionReferencesGT = (resolution, seen) => {
+		return readGTExportName(resolution, seen) !== void 0;
 	};
 	const resolveFromSource = (record, source, exportName, seen) => {
-		if (isExternalModule(source)) return knownExternalExport(source, exportName) ? {
+		if (isKnownNonVueGTRuntime(source)) return {
+			status: "resolved",
+			target: {
+				originKey: `${source}#${exportName}`,
+				type: "ordinary-external"
+			}
+		};
+		if (isExternalModule(source)) return knownExternalExport(source, exportName, options.recognizeAllGTRuntimeExports === true) ? {
 			status: "resolved",
 			target: {
 				exportName,
@@ -109,11 +466,26 @@ function createLocalModuleResolver(resolveModuleOption) {
 			}
 		} : { status: "absent" };
 		const modulePath = resolveModule(record.filePath, source);
-		return modulePath ? resolveExportInternal(modulePath, exportName, seen) : { status: "invalid" };
+		if (!modulePath) return { status: "invalid" };
+		if (!isProjectModule(modulePath)) return {
+			status: "resolved",
+			target: {
+				originKey: `${modulePath}#${exportName}`,
+				type: "ordinary-external"
+			}
+		};
+		return resolveExportInternal(modulePath, exportName, seen);
 	};
 	const resolveDeclaredExport = (record, exportName, declared, seen) => {
 		if (declared.type === "reexport") return resolveFromSource(record, declared.source, declared.importedName, seen);
 		if (declared.type === "namespace") {
+			if (isKnownNonVueGTRuntime(declared.source)) return {
+				status: "resolved",
+				target: {
+					originKey: `${declared.source}#namespace`,
+					type: "ordinary-external"
+				}
+			};
 			if (isExternalModule(declared.source)) return {
 				status: "resolved",
 				target: {
@@ -123,6 +495,13 @@ function createLocalModuleResolver(resolveModuleOption) {
 				}
 			};
 			const modulePath = resolveModule(record.filePath, declared.source);
+			if (modulePath && !isProjectModule(modulePath)) return {
+				status: "resolved",
+				target: {
+					originKey: `${modulePath}#namespace`,
+					type: "ordinary-external"
+				}
+			};
 			return modulePath ? {
 				status: "resolved",
 				target: {
@@ -136,6 +515,13 @@ function createLocalModuleResolver(resolveModuleOption) {
 			const imported = record.imports.get(declared.name);
 			if (imported) {
 				if (imported.importedName === "*") {
+					if (isKnownNonVueGTRuntime(imported.source)) return {
+						status: "resolved",
+						target: {
+							originKey: `${imported.source}#namespace`,
+							type: "ordinary-external"
+						}
+					};
 					if (isExternalModule(imported.source)) return {
 						status: "resolved",
 						target: {
@@ -145,6 +531,13 @@ function createLocalModuleResolver(resolveModuleOption) {
 						}
 					};
 					const modulePath = resolveModule(record.filePath, imported.source);
+					if (modulePath && !isProjectModule(modulePath)) return {
+						status: "resolved",
+						target: {
+							originKey: `${modulePath}#namespace`,
+							type: "ordinary-external"
+						}
+					};
 					return modulePath ? {
 						status: "resolved",
 						target: {
@@ -191,26 +584,49 @@ function createLocalModuleResolver(resolveModuleOption) {
 		const normalized = path.resolve(filePath);
 		if (seen.has(normalized)) return /* @__PURE__ */ new Set();
 		const record = getRecord(normalized);
-		if (!record) return /* @__PURE__ */ new Set();
+		const recovered = record ? void 0 : getRecoveredRecord(normalized);
+		if (!record && !recovered) return /* @__PURE__ */ new Set();
+		const moduleRecord = record ?? recovered;
 		const nextSeen = new Set(seen).add(normalized);
-		const names = new Set(record.explicitExports.keys());
-		for (const source of record.starExports) if (source === "gt-vue") for (const name of GT_EXPORT_NAMES) names.add(name);
+		const names = new Set(moduleRecord.explicitExports.keys());
+		for (const source of moduleRecord.starExports) if (source === "gt-vue") for (const name of GT_EXPORT_NAMES) names.add(name);
 		else if (source === "vue") for (const name of VUE_EXPORT_NAMES) names.add(name);
+		else if (isKnownNonVueGTRuntime(source)) continue;
 		else {
-			const modulePath = resolveModule(record.filePath, source);
-			if (!modulePath) continue;
+			const modulePath = resolveModule(moduleRecord.filePath, source);
+			if (!modulePath || !isProjectModule(modulePath)) continue;
 			for (const name of collectExportNames(modulePath, nextSeen)) if (name !== "default") names.add(name);
 		}
 		return names;
 	};
+	const hasGTExportReference = (filePath, exportName) => {
+		return resolutionReferencesGT(resolveExportInternal(filePath, exportName, /* @__PURE__ */ new Set()), /* @__PURE__ */ new Set());
+	};
+	const getGTExportName = (filePath, exportName) => {
+		const resolution = resolveExportInternal(filePath, exportName, /* @__PURE__ */ new Set());
+		return resolution.status === "resolved" ? readGTExportName(resolution, /* @__PURE__ */ new Set(), false) : void 0;
+	};
 	return {
 		getRecord,
+		getGTExportName,
 		hasCustomResolver: resolveModuleOption !== void 0,
+		hasGTExportReference,
+		isProjectModule,
 		listExportNames,
 		resolveExport,
 		resolveModule
 	};
 }
+/** Removes syntax-only wrappers without importing the compiler-facing utilities. */
+function unwrapLocalExpression(input) {
+	let current = input ?? void 0;
+	while (current && (current.type === "TSAsExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSInstantiationExpression" || current.type === "TypeCastExpression" || current.type === "ParenthesizedExpression")) current = current.expression;
+	return current;
+}
+/** Deduplicates recovered graph targets without discarding their identities. */
+function uniqueRecoveredTargets(targets) {
+	return [...new Map(targets.map((target) => [target.originKey, target])).values()];
+}
 function resolveSourceFile(requested) {
 	const candidates = [requested];
 	const extension = path.extname(requested).toLowerCase();
@@ -234,6 +650,14 @@ function isReadableFile(filePath) {
 		return false;
 	}
 }
+/** Resolves symlinks when possible while retaining missing-path diagnostics. */
+function readRealPath(filePath) {
+	try {
+		return fs.realpathSync.native(filePath);
+	} catch {
+		return filePath;
+	}
+}
 function parseLocalModule(filePath) {
 	let source;
 	try {
@@ -276,11 +700,95 @@ function parseLocalModule(filePath) {
 	collectExports(record);
 	return record;
 }
+let moduleLexerInitialized = false;
+/**
+* Recovers only source-bound runtime exports from an otherwise invalid module.
+*
+* The recovered declarations establish provenance, but never become executable
+* analyzer input. Their resolutions remain invalid so consumers fail closed
+* while type-only and unrelated module references stay invisible.
+*/
+function recoverMalformedModuleExports(filePath) {
+	const extension = path.extname(filePath).toLowerCase();
+	if (extension === ".cjs" || extension === ".cts" || extension === ".vue") return;
+	let source;
+	try {
+		source = fs.readFileSync(filePath, "utf8");
+	} catch {
+		return;
+	}
+	if (!moduleLexerInitialized) {
+		initSync();
+		moduleLexerInitialized = true;
+	}
+	let moduleImports;
+	try {
+		[moduleImports] = parse(source);
+	} catch {
+		return;
+	}
+	const record = {
+		explicitExports: /* @__PURE__ */ new Map(),
+		filePath,
+		starExports: []
+	};
+	const statements = /* @__PURE__ */ new Set();
+	for (const moduleImport of moduleImports) {
+		if (moduleImport.d !== -1 || moduleImport.ss < 0 || moduleImport.se <= moduleImport.ss) continue;
+		statements.add(source.slice(moduleImport.ss, moduleImport.se));
+	}
+	for (const statementSource of statements) {
+		const statement = parseRecoveredModuleStatement(statementSource, extension);
+		if (!statement) continue;
+		collectRecoveredExport(record, statement);
+	}
+	return record.explicitExports.size > 0 || record.starExports.length > 0 ? record : void 0;
+}
+/** Parses one lexed declaration under the source file's supported grammars. */
+function parseRecoveredModuleStatement(source, extension) {
+	const declaredLanguage = extension === ".mjs" ? "js" : extension === ".mts" ? "ts" : extension.slice(1);
+	const languages = new Set([declaredLanguage]);
+	if (declaredLanguage === "js" || declaredLanguage === "jsx") languages.add("flow");
+	languages.add("tsx");
+	for (const language of languages) try {
+		const ast = parseScriptAst(source, language);
+		if (ast.program.body.length === 1) return ast.program.body[0];
+	} catch {}
+}
+/** Adds runtime re-exports without trusting declarations around the syntax error. */
+function collectRecoveredExport(record, statement) {
+	if (statement.type === "ExportAllDeclaration") {
+		if (statement.exportKind !== "type") record.starExports.push(statement.source.value);
+		return;
+	}
+	if (statement.type !== "ExportNamedDeclaration" || statement.exportKind === "type" || !statement.source) return;
+	for (const specifier of statement.specifiers) {
+		if (specifier.type === "ExportSpecifier" && specifier.exportKind === "type") continue;
+		const exportedName = specifier.exported.type === "Identifier" ? specifier.exported.name : specifier.exported.value;
+		if (specifier.type === "ExportNamespaceSpecifier") {
+			addRecoveredExplicitExport(record, exportedName, {
+				source: statement.source.value,
+				type: "namespace"
+			});
+			continue;
+		}
+		if (specifier.type !== "ExportSpecifier") continue;
+		addRecoveredExplicitExport(record, exportedName, {
+			importedName: specifier.local.name,
+			source: statement.source.value,
+			type: "reexport"
+		});
+	}
+}
+/** Preserves ambiguity instead of selecting an arbitrary recovered identity. */
+function addRecoveredExplicitExport(record, name, value) {
+	record.explicitExports.set(name, record.explicitExports.has(name) ? "ambiguous" : value);
+}
 function collectImportedBindings(ast) {
 	const imports = /* @__PURE__ */ new Map();
 	for (const statement of ast.program.body) {
-		if (statement.type !== "ImportDeclaration" || statement.importKind === "type") continue;
-		for (const specifier of statement.specifiers) if (specifier.type === "ImportSpecifier" && specifier.importKind !== "type") imports.set(specifier.local.name, {
+		if (statement.type !== "ImportDeclaration" || isTypeOnlyImportKind(statement.importKind)) continue;
+		for (const specifier of statement.specifiers) if (specifier.type === "ImportSpecifier" && !isTypeOnlyImportKind(specifier.importKind)) imports.set(specifier.local.name, {
 			importedName: specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value,
 			source: statement.source.value
 		});
@@ -295,6 +803,10 @@ function collectImportedBindings(ast) {
 	}
 	return imports;
 }
+/** Returns whether Babel classified an ESM binding as type-only. */
+function isTypeOnlyImportKind(kind) {
+	return kind === "type" || kind === "typeof";
+}
 function collectExports(record) {
 	for (const statement of record.ast.program.body) {
 		if (statement.type === "ExportAllDeclaration") {
@@ -355,8 +867,9 @@ function patternNames(pattern) {
 function isExternalModule(source) {
 	return source === "gt-vue" || source === "vue";
 }
-function knownExternalExport(source, exportName) {
-	return source === "gt-vue" ? GT_EXPORT_NAMES.includes(exportName) : VUE_EXPORT_NAMES.includes(exportName);
+function knownExternalExport(source, exportName, recognizeAllGTRuntimeExports) {
+	if (source === "vue") return VUE_EXPORT_NAMES.includes(exportName);
+	return (recognizeAllGTRuntimeExports ? GT_RUNTIME_EXPORT_NAMES : GT_EXPORT_NAMES).includes(exportName);
 }
 //#endregion
 export { createLocalModuleResolver };