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

package/dist/internal/template.js

@@ -1,4 +1,4 @@
-import { addVueError, createInlineMetadata, readStaticPrimitive, unwrapExpression } from "./utils.js";
+import { addVueError, applyStaticTMetadataValue, createInlineMetadata, normalizeTMetadataKey, readStaticGlobalPrimitive, readStaticPrimitive, unwrapExpression } from "./utils.js";
 import { processVueStringCall } from "./stringCalls.js";
 import { appendTemplatePath, recursiveTemplatePathSegment, unknownTemplatePathSegment } from "./templatePath.js";
 import { ElementTypes, NodeTypes } from "./compilerAst.js";
@@ -89,8 +89,9 @@ function visitTemplateChildren(children, shadowed, bindings, expressionPlugins,
 		}
 		for (const property of child.props) {
 			if (property.type !== NodeTypes.DIRECTIVE) continue;
-			if (property.arg?.type === NodeTypes.SIMPLE_EXPRESSION && !property.arg.isStatic) processTemplateExpression(property.arg, childShadowed, childBindings, expressionPlugins, context);
+			if (property.name !== "is" && property.arg?.type === NodeTypes.SIMPLE_EXPRESSION && !property.arg.isStatic) processTemplateExpression(property.arg, childShadowed, childBindings, expressionPlugins, context);
 			if (property.name === "slot" || !property.exp) continue;
+			if (property.name === "is" && !isEffectiveValuedVIsSelector(child, property, context.valuedVIsReplacesElement)) continue;
 			if (property.name === "for") {
 				const parseResult = readForParseResult(property);
 				if (parseResult?.source) processTemplateExpression(parseResult.source, shadowed, bindings, expressionPlugins, context);
@@ -98,22 +99,45 @@ function visitTemplateChildren(children, shadowed, bindings, expressionPlugins,
 			}
 			processTemplateExpression(property.exp, property.name === "if" || property.name === "else-if" ? shadowed : childShadowed, property.name === "if" || property.name === "else-if" ? bindings : childBindings, expressionPlugins, context);
 		}
-		const component = resolveGTComponent(child, childBindings, expressionPlugins, childShadowed);
-		const suspense = resolveSuspenseComponent(child, childBindings, expressionPlugins, childShadowed);
-		const fragment = resolveFragmentComponent(child, childBindings, expressionPlugins, childShadowed);
-		const uncertainGTComponent = resolveUncertainComponentBinding(child, childBindings, childBindings.uncertainGTComponents, childBindings.uncertainRegisteredGTComponents, childBindings.gtComponentFactories, expressionPlugins, childShadowed);
-		const possibleDynamicT = component ? void 0 : resolvePossibleDynamicT(child, childBindings, expressionPlugins, childShadowed);
+		const component = resolveGTComponent(child, childBindings, expressionPlugins, childShadowed, context.valuedVIsReplacesElement);
+		const uncertainGTComponent = resolveUncertainComponentBinding(child, childBindings, childBindings.uncertainGTComponents, childBindings.uncertainRegisteredGTComponents, childBindings.gtComponentFactories, expressionPlugins, childShadowed, context.valuedVIsReplacesElement);
+		const possibleDynamicT = component ? void 0 : resolvePossibleDynamicT(child, childBindings, expressionPlugins, childShadowed, context.valuedVIsReplacesElement);
 		const unresolvedGTComponent = uncertainGTComponent ?? possibleDynamicT;
 		if (!insideTranslation && !component && unresolvedGTComponent) addVueError(context, child.loc, `Could not statically resolve possible gt-vue component alias "${unresolvedGTComponent}"`, "Use a direct gt-vue import or an immutable alias that does not escape static analysis");
 		if (component?.originalName === "Var" || component?.originalName === "Num" || component?.originalName === "DateTime" || component?.originalName === "Currency") validateVariableComponentShape(child, component.originalName, context);
 		if (component?.originalName === "T" && !insideTranslation) extractTranslationComponent(child, childShadowed, childBindings, expressionPlugins, context);
-		const childInsideTranslation = component?.originalName === "Var" || insideTranslation && isOpaqueComponent(child, component, suspense ?? fragment) ? false : insideTranslation || component?.originalName === "T";
-		if (childInsideTranslation && suspense) {
-			const suspenseElementIsFallback = hasStaticSlotName(child, "fallback");
-			for (const suspenseChild of child.children) visitTemplateChildren([suspenseChild], childShadowed, childBindings, expressionPlugins, context, suspenseElementIsFallback ? false : !isSuspenseFallbackTemplate(suspenseChild));
-		} else visitTemplateChildren(child.children, childShadowed, childBindings, expressionPlugins, context, childInsideTranslation);
+		const childInsideTranslation = component?.originalName === "Var" ? false : insideTranslation || component?.originalName === "T";
+		if (childInsideTranslation && child.tagType === ElementTypes.COMPONENT) visitComponentSlotChildren(child, childShadowed, childBindings, expressionPlugins, context, component?.originalName === "Branch" || component?.originalName === "Plural" || component?.originalName === "T");
+		else visitTemplateChildren(child.children, childShadowed, childBindings, expressionPlugins, context, childInsideTranslation);
 	}
 }
+/**
+* Walks a component's authored slots with the same boundary used at runtime.
+*
+* A static default slot is React-equivalent `children` and therefore belongs
+* to the surrounding translation. Ordinary named slots are not materialized
+* by gt-vue's runtime, so they remain outside that translation and may contain
+* their own independent T. Branch and Plural are the deliberate exception:
+* their named slots are persisted as translation branches.
+*/
+function visitComponentSlotChildren(element, shadowed, bindings, expressionPlugins, context, namedSlotsParticipate) {
+	const componentSlot = element.props.find((property) => property.type === NodeTypes.DIRECTIVE && property.name === "slot");
+	if (componentSlot) {
+		const name = readStaticSlotName(componentSlot);
+		visitTemplateChildren(element.children, shadowed, bindings, expressionPlugins, context, name === "default" || name === void 0 || namedSlotsParticipate);
+		return;
+	}
+	for (const child of element.children) {
+		const slotDirective = child.type === NodeTypes.ELEMENT && child.tag === "template" ? child.props.find((property) => property.type === NodeTypes.DIRECTIVE && property.name === "slot") : void 0;
+		const slotName = slotDirective ? readStaticSlotName(slotDirective) : "default";
+		visitTemplateChildren([child], shadowed, bindings, expressionPlugins, context, slotName === "default" || slotName === void 0 || namedSlotsParticipate);
+	}
+}
+/** Reads only a literal slot name without emitting extraction diagnostics. */
+function readStaticSlotName(directive) {
+	if (!directive.arg) return "default";
+	return directive.arg.type === NodeTypes.SIMPLE_EXPRESSION && directive.arg.isStatic ? directive.arg.content : void 0;
+}
 /** Finds local Vue aliases whose runtime value can be a GT component. */
 function collectPossibleScopedComponentAliases(element, bindings, shadowed, expressionPlugins) {
 	const aliases = /* @__PURE__ */ new Set();
@@ -399,14 +423,31 @@ function resolvePossibleTemplateStringFunction(input, scope, shadowed, bindings)
 /** Reads a script-exposed primitive unless a Vue or expression scope masks it. */
 function readTemplatePrimitive(input, scope, shadowed, bindings) {
 	return readStaticPrimitive(input, (identifier) => {
-		if (shadowed.has(identifier.name) || scope.hasBinding(identifier.name)) return { ok: false };
-		const value = bindings.staticValues.get(identifier.name);
-		return bindings.staticValues.has(identifier.name) ? {
-			ok: true,
-			value
-		} : { ok: false };
+		if (scope.hasBinding(identifier.name)) return { ok: false };
+		return readTemplateIdentifierPrimitive(identifier, shadowed, bindings);
 	});
 }
+/**
+* Resolves a template primitive using Vue's compiler binding precedence.
+*
+* Script-setup bindings are compiler-visible and can shadow global names.
+* Options API return keys live on the render context, but Vue emits immutable
+* globals directly before consulting that context, so those exposures cannot
+* shadow `undefined`, `NaN`, or `Infinity`.
+*/
+function readTemplateIdentifierPrimitive(identifier, shadowed, bindings) {
+	if (shadowed.has(identifier.name)) return { ok: false };
+	if (bindings.directBindings.has(identifier.name)) return bindings.staticValues.has(identifier.name) ? {
+		ok: true,
+		value: bindings.staticValues.get(identifier.name)
+	} : { ok: false };
+	const global = readStaticGlobalPrimitive(identifier.name);
+	if (global.ok) return global;
+	return bindings.staticValues.has(identifier.name) ? {
+		ok: true,
+		value: bindings.staticValues.get(identifier.name)
+	} : { ok: false };
+}
 /** Resolves a template call back to a statically imported gt-vue function. */
 function resolveTemplateStringFunction(input, scope, shadowed, bindings) {
 	const node = unwrapExpression(input);
@@ -442,75 +483,88 @@ function visitBindingDefaultExpressions(pattern, visit) {
 }
 function extractTranslationComponent(element, shadowed, bindings, expressionPlugins, context) {
 	const errorCount = context.errors.length;
-	const translationContext = readTContext(element, shadowed, bindings, expressionPlugins, context);
-	const slots = getSlotLayout(element, shadowed, expressionPlugins, context);
+	const translationMetadata = readTMetadata(element, shadowed, bindings, expressionPlugins, context);
+	const slots = getSlotLayout(element, shadowed, expressionPlugins, context, "reject");
 	if (slots.namedSlots.size > 0) addVueError(context, element.loc, "Found a named slot on a gt-vue <T> component", "Place translatable content in the default slot");
 	const serialized = serializeChildren(slots.defaultSlot.children, { value: 0 }, slots.defaultSlot.shadowed, bindings, expressionPlugins, context);
 	if (context.errors.length !== errorCount) return;
 	context.results.push({
 		dataFormat: "JSX",
-		source: collapseChildren(serialized),
-		metadata: createInlineMetadata(context, element.loc, translationContext)
+		source: serialized.length > 0 ? collapseChildren(serialized) : void 0,
+		metadata: createInlineMetadata(context, element.loc, translationMetadata)
 	});
 }
-function readTContext(element, shadowed, bindings, expressionPlugins, context) {
-	let translationContext;
-	let hasContext = false;
+function readTMetadata(element, shadowed, bindings, expressionPlugins, context) {
+	const metadata = {};
+	const seen = /* @__PURE__ */ new Set();
+	const staticVueIsSelector = readStaticVueIsSelector(element);
 	for (const property of element.props) {
 		if (isDynamicComponentSelector(element, property)) continue;
+		if (staticVueIsSelector?.property === property) continue;
 		if (property.type === NodeTypes.ATTRIBUTE) {
 			if (RESERVED_T_PROPS.has(property.name)) continue;
-			if (property.name !== "context" && property.name !== "$context") {
-				addVueError(context, property.loc, `Found unsupported prop "${property.name}" on a gt-vue <T> component`, "gt-vue <T> currently supports only context");
+			const key = normalizeTMetadataKey(property.name, true);
+			if (!key) {
+				addVueError(context, property.loc, `Found unsupported prop "${property.name}" on a gt-vue <T> component`, "Use only static context, id, maxChars, or requiresReview metadata");
 				continue;
 			}
-			if (hasContext) {
-				addDuplicateContextError(property.loc, context);
-				continue;
-			}
-			hasContext = true;
-			translationContext = property.value?.content ?? "";
+			if (!registerTMetadataKey(key, seen, property.loc, context)) continue;
+			const value = key === "requiresReview" && property.value === void 0 ? true : property.value?.content ?? "";
+			if (key === "maxChars" || !applyStaticTMetadataValue(metadata, key, value)) addInvalidTMetadataValueError(key, property.loc, context);
 			continue;
 		}
 		if (property.name !== "bind") continue;
 		if (property.modifiers.length > 0) {
-			const directive = property.rawName ?? "v-bind";
-			addVueError(context, property.loc, `Found unsupported directive ${directive} on a gt-vue <T> component`, "Pass context without a v-bind modifier");
+			const directive = readDirectiveSourceName(property);
+			addVueError(context, property.loc, `Found unsupported directive ${directive} on a gt-vue <T> component`, "Pass translation metadata without a v-bind modifier");
 			continue;
 		}
 		const key = readDirectiveKey(property);
 		if (key === void 0) {
-			addVueError(context, property.loc, "Found a dynamic or spread binding on a gt-vue <T> component", "Pass context as a static context or $context prop");
+			addVueError(context, property.loc, "Found a dynamic or spread binding on a gt-vue <T> component", "Pass each metadata value through an explicit static prop");
 			continue;
 		}
 		if (RESERVED_T_PROPS.has(key)) continue;
-		if (key !== "context" && key !== "$context") {
-			addVueError(context, property.loc, `Found unsupported prop "${key}" on a gt-vue <T> component`, "gt-vue <T> currently supports only context");
+		const metadataKey = normalizeTMetadataKey(key, true);
+		if (!metadataKey) {
+			addVueError(context, property.loc, `Found unsupported prop "${key}" on a gt-vue <T> component`, "Use only static context, id, maxChars, or requiresReview metadata");
 			continue;
 		}
-		if (hasContext) {
-			addDuplicateContextError(property.loc, context);
-			continue;
-		}
-		hasContext = true;
+		if (!registerTMetadataKey(metadataKey, seen, property.loc, context)) continue;
 		const value = readExpressionPrimitive(property.exp, expressionPlugins, shadowed, bindings);
-		if (!value.ok || typeof value.value !== "string") {
-			addVueError(context, property.loc, "Found a dynamic context on a gt-vue <T> component", "Use a string literal or a template literal without expressions");
+		if (!value.ok || !applyStaticTMetadataValue(metadata, metadataKey, value.value)) {
+			addInvalidTMetadataValueError(metadataKey, property.loc, context);
 			continue;
 		}
-		translationContext = value.value;
 	}
-	return translationContext;
+	return metadata;
+}
+function registerTMetadataKey(key, seen, location, context) {
+	if (!seen.has(key)) {
+		seen.add(key);
+		return true;
+	}
+	addVueError(context, location, `Found duplicate ${key} props on a gt-vue <T> component`, `Pass only one ${key} prop or its $-prefixed alias`);
+	return false;
 }
-function addDuplicateContextError(location, context) {
-	addVueError(context, location, "Found duplicate context props on a gt-vue <T> component", "Pass only one context prop");
+function addInvalidTMetadataValueError(key, location, context) {
+	const expected = key === "context" || key === "id" ? "a static string" : key === "maxChars" ? "a static integer through v-bind" : "a static boolean or a bare requiresReview prop";
+	addVueError(context, location, `Found an invalid or dynamic ${key} on a gt-vue <T> component`, `Use ${expected}`);
 }
 function serializeChildren(children, counter, shadowed, bindings, expressionPlugins, context) {
 	validateCommentWhitespaceParity(children, context);
 	const result = [];
+	let mergeWithPrevious = true;
 	for (const child of children) {
+		if (child.type === NodeTypes.COMMENT) {
+			mergeWithPrevious = false;
+			continue;
+		}
 		const values = serializeChild(child, counter, shadowed, bindings, expressionPlugins, context);
-		for (const value of values) appendSerializedChild(result, value);
+		for (const value of values) {
+			appendSerializedChild(result, value, mergeWithPrevious);
+			mergeWithPrevious = true;
+		}
 	}
 	return result;
 }
@@ -551,22 +605,47 @@ function serializeChild(child, counter, shadowed, bindings, expressionPlugins, c
 		addVueError(context, child.loc, "Found unsupported template syntax inside a gt-vue <T> component", "Use static template content and gt-vue rich translation components");
 		return [];
 	}
-	if (resolveFragmentComponent(child, bindings, expressionPlugins, shadowed)) return serializeFragmentElement(child, counter, shadowed, bindings, expressionPlugins, context);
+	if (resolveFragmentComponent(child, bindings, expressionPlugins, shadowed, context.valuedVIsReplacesElement)) return [serializeFragmentElement(child, counter, shadowed, bindings, expressionPlugins, context)];
 	return [serializeElement(child, counter, shadowed, bindings, expressionPlugins, context)];
 }
-/** Flattens an exact Vue Fragment default slot without consuming an ID. */
+/** Serializes an authored Vue Fragment while leaving compiler wrappers flat. */
 function serializeFragmentElement(element, counter, shadowed, bindings, expressionPlugins, context) {
+	counter.value += 1;
+	const id = counter.value;
 	validateRichElement(element, context, true);
-	const slots = getSlotLayout(element, shadowed, expressionPlugins, context);
-	if (slots.namedSlots.size > 0) addVueError(context, element.loc, "Found a named slot on Vue Fragment inside a gt-vue <T> component", "Keep Fragment content in its default slot");
-	return serializeChildren(slots.defaultSlot.children, counter, slots.defaultSlot.shadowed, bindings, expressionPlugins, context);
+	const slots = getSlotLayout(element, shadowed, expressionPlugins, context, "opaque");
+	const children = serializeChildren(slots.defaultSlot.children, counter, slots.defaultSlot.shadowed, bindings, expressionPlugins, context);
+	const data = readContentProps(element, shadowed, bindings, expressionPlugins, context);
+	return {
+		t: `C${id}`,
+		i: id,
+		...Object.keys(data).length > 0 && { d: data },
+		...children.length > 0 && { c: collapseChildren(children) }
+	};
 }
 function serializeElement(element, counter, shadowed, bindings, expressionPlugins, context) {
 	counter.value += 1;
 	const id = counter.value;
-	const component = resolveGTComponent(element, bindings, expressionPlugins, shadowed);
-	const suspense = resolveSuspenseComponent(element, bindings, expressionPlugins, shadowed);
-	const uncertainComponent = !component && !suspense ? resolveUncertainComponent(element, bindings, expressionPlugins, shadowed) : void 0;
+	const component = resolveGTComponent(element, bindings, expressionPlugins, shadowed, context.valuedVIsReplacesElement);
+	const suspense = resolveSuspenseComponent(element, bindings, expressionPlugins, shadowed, context.valuedVIsReplacesElement);
+	const staticVueIsTarget = readStaticVueIsTarget(element);
+	const directTagBindings = staticVueIsTarget === void 0 && element.tagType === ElementTypes.COMPONENT ? getNormalizedDirectTemplateBindings(element.tag, bindings.directBindings) : [];
+	const hasShapeConflictingDirectTag = directTagBindings.length > 1 || directTagBindings.some((localName) => bindings.staticValues.has(localName) || bindings.possibleStaticStrings.has(localName));
+	if (!component && !suspense && hasShapeConflictingDirectTag) {
+		addVueError(context, element.loc, `Found unsupported direct binding for component tag <${element.tag}> inside a gt-vue <T> component`, "Use a literal native tag, a statically known GT or Vue component, or move the binding outside <T>");
+		return {
+			t: element.tag,
+			i: id
+		};
+	}
+	if (staticVueIsTarget !== void 0 && !component && !suspense) {
+		addVueError(context, element.loc, `Found unsupported is="vue:${staticVueIsTarget}" content inside a gt-vue <T> component`, "Use a direct literal or component tag, or move the selector outside <T>");
+		return {
+			t: staticVueIsTarget,
+			i: id
+		};
+	}
+	const uncertainComponent = !component && !suspense ? resolveUncertainComponent(element, bindings, expressionPlugins, shadowed, context.valuedVIsReplacesElement) : void 0;
 	if (uncertainComponent) addVueError(context, element.loc, `Could not statically resolve component alias "${uncertainComponent}" inside a gt-vue <T> component`, "Use a direct component import or an immutable alias that does not escape static analysis");
 	validateRichElement(element, context, Boolean(component || suspense || uncertainComponent));
 	const originalName = component?.originalName;
@@ -593,12 +672,7 @@ function serializeElement(element, counter, shadowed, bindings, expressionPlugin
 		};
 	}
 	const data = readContentProps(element, shadowed, bindings, expressionPlugins, context);
-	if (isOpaqueComponent(element, component, suspense)) return {
-		t: element.tag,
-		i: id,
-		...Object.keys(data).length > 0 && { d: data }
-	};
-	const slotLayout = element.tagType === ElementTypes.COMPONENT ? getSlotLayout(element, shadowed, expressionPlugins, context) : {
+	const slotLayout = element.tagType === ElementTypes.COMPONENT ? getSlotLayout(element, shadowed, expressionPlugins, context, originalName === "Branch" || originalName === "Plural" ? "serialize" : "opaque") : {
 		defaultSlot: {
 			children: element.children,
 			rootCount: countVueSlotRoots(element.children),
@@ -608,7 +682,6 @@ function serializeElement(element, counter, shadowed, bindings, expressionPlugin
 	};
 	const children = serializeChildren(slotLayout.defaultSlot.children, counter, slotLayout.defaultSlot.shadowed, bindings, expressionPlugins, context);
 	if (suspense && slotLayout.defaultSlot.rootCount > 1) addVueError(context, element.loc, "Found more than one default root inside Vue <Suspense> within a gt-vue <T> component", "Wrap the Suspense default content in a single element or move <T> inside <Suspense>");
-	if ([...slotLayout.namedSlots].filter(([name]) => !suspense || name !== "fallback").length > 0 && originalName !== "Branch" && originalName !== "Plural") addVueError(context, element.loc, `Found named slots on <${originalName ?? element.tag}> inside a gt-vue <T> component`, "Move named-slot content outside <T> or use only the component default slot");
 	if (originalName === "Branch" || originalName === "Plural") {
 		const branches = readBranches(element, slotLayout, id, originalName, shadowed, bindings, expressionPlugins, context);
 		if (Object.keys(branches).length > 0) {
@@ -617,54 +690,57 @@ function serializeElement(element, counter, shadowed, bindings, expressionPlugin
 		}
 	}
 	return {
-		t: originalName ?? suspense?.originalName ?? element.tag,
+		t: originalName ?? suspense?.originalName ?? readStaticVueIsTarget(element) ?? element.tag,
 		i: id,
 		...Object.keys(data).length > 0 && { d: data },
 		...children.length > 0 && { c: collapseChildren(children) }
 	};
 }
-/** Returns true when the runtime preserves a component's slots as opaque. */
-function isOpaqueComponent(element, component, vueBuiltin) {
-	return element.tagType === ElementTypes.COMPONENT && !component && !vueBuiltin;
-}
 /** Resolves literal Suspense and statically proven aliases of Vue's builtin. */
-function resolveSuspenseComponent(element, bindings, expressionPlugins, shadowed) {
-	if (element.tagType === ElementTypes.COMPONENT && element.tag.toLowerCase() === "suspense") return {
+function resolveSuspenseComponent(element, bindings, expressionPlugins, shadowed, valuedVIsReplacesElement) {
+	const dynamicSelector = readDynamicComponentSelector(element, expressionPlugins, bindings, shadowed, valuedVIsReplacesElement);
+	const staticVueIsTarget = dynamicSelector ? void 0 : readStaticVueIsTarget(element);
+	if (staticVueIsTarget && isLiteralSuspenseName(staticVueIsTarget)) return {
+		localName: staticVueIsTarget,
+		originalName: "Suspense"
+	};
+	if (element.tagType === ElementTypes.COMPONENT && isLiteralSuspenseName(element.tag) && staticVueIsTarget === void 0 && !dynamicSelector) return {
 		localName: element.tag,
 		originalName: "Suspense"
 	};
-	const builtin = resolveVueBuiltinComponent(element, bindings, expressionPlugins, shadowed);
+	const builtin = resolveVueBuiltinComponent(element, bindings, expressionPlugins, shadowed, valuedVIsReplacesElement);
 	return builtin?.originalName === "Suspense" ? {
 		localName: builtin.localName,
 		originalName: "Suspense"
 	} : void 0;
 }
 /** Resolves an imported Vue Fragment alias without matching an ordinary tag. */
-function resolveFragmentComponent(element, bindings, expressionPlugins, shadowed) {
-	const builtin = resolveVueBuiltinComponent(element, bindings, expressionPlugins, shadowed);
+function resolveFragmentComponent(element, bindings, expressionPlugins, shadowed, valuedVIsReplacesElement) {
+	const builtin = resolveVueBuiltinComponent(element, bindings, expressionPlugins, shadowed, valuedVIsReplacesElement);
 	return builtin?.originalName === "Fragment" ? {
 		localName: builtin.localName,
 		originalName: "Fragment"
 	} : void 0;
 }
 /** Resolves a statically proven Vue builtin through direct or registered use. */
-function resolveVueBuiltinComponent(element, bindings, expressionPlugins, shadowed) {
-	return resolveComponentBinding(element, bindings, bindings.vueBuiltins, bindings.registeredVueBuiltins, bindings.directBindings, expressionPlugins, shadowed);
+function resolveVueBuiltinComponent(element, bindings, expressionPlugins, shadowed, valuedVIsReplacesElement) {
+	return resolveComponentBinding(element, bindings, bindings.vueBuiltins, bindings.registeredVueBuiltins, bindings.directBindings, expressionPlugins, shadowed, valuedVIsReplacesElement);
 }
 /** Resolves a component-shaped binding whose exact identity is uncertain. */
-function resolveUncertainComponent(element, bindings, expressionPlugins, shadowed) {
-	return resolveUncertainComponentBinding(element, bindings, bindings.uncertainComponents, bindings.uncertainRegisteredComponents, bindings.componentFactories, expressionPlugins, shadowed);
+function resolveUncertainComponent(element, bindings, expressionPlugins, shadowed, valuedVIsReplacesElement) {
+	return resolveUncertainComponentBinding(element, bindings, bindings.uncertainComponents, bindings.uncertainRegisteredComponents, bindings.componentFactories, expressionPlugins, shadowed, valuedVIsReplacesElement);
 }
 /** Resolves uncertainty while preserving direct versus registered precedence. */
-function resolveUncertainComponentBinding(element, bindings, uncertainDirectBindings, uncertainRegisteredBindings, uncertainFactories, expressionPlugins, shadowed) {
+function resolveUncertainComponentBinding(element, bindings, uncertainDirectBindings, uncertainRegisteredBindings, uncertainFactories, expressionPlugins, shadowed, valuedVIsReplacesElement) {
 	if (element.tagType !== ElementTypes.COMPONENT) return void 0;
-	const selector = readDynamicComponentSelector(element, expressionPlugins, bindings, shadowed);
+	const selector = readDynamicComponentSelector(element, expressionPlugins, bindings, shadowed, valuedVIsReplacesElement);
 	if (selector) {
 		if ([...selector.componentFactories].some((name) => uncertainFactories.has(name)) || [...selector.gtComponentFactories].some((name) => uncertainFactories.has(name))) return selector.displayName;
 		for (const candidate of selector.candidates) for (const localName of normalizeTemplateBindingNames(candidate.name)) if (candidate.kind === "string" ? uncertainRegisteredBindings.has(localName) : uncertainDirectBindings.has(localName)) return localName;
 		return;
 	}
-	for (const localName of normalizeTemplateBindingNames(element.tag)) {
+	const effectiveTag = readStaticVueIsTarget(element) ?? element.tag;
+	for (const localName of normalizeTemplateBindingNames(effectiveTag)) {
 		const direct = uncertainDirectBindings.has(localName);
 		const registered = uncertainRegisteredBindings.has(localName);
 		if (isDirectTemplateBinding(localName, bindings.directBindings)) {
@@ -673,28 +749,19 @@ function resolveUncertainComponentBinding(element, bindings, uncertainDirectBind
 	}
 }
 /** Detects an unresolved dynamic selector whose possible result includes T. */
-function resolvePossibleDynamicT(element, bindings, expressionPlugins, shadowed) {
-	const selector = readDynamicComponentSelector(element, expressionPlugins, bindings, shadowed);
+function resolvePossibleDynamicT(element, bindings, expressionPlugins, shadowed, valuedVIsReplacesElement) {
+	const selector = readDynamicComponentSelector(element, expressionPlugins, bindings, shadowed, valuedVIsReplacesElement);
 	if (!selector) return void 0;
 	if (selector.possibleGT || selector.gtComponentFactories.size > 0) return selector.displayName;
 	for (const candidate of selector.candidates) for (const localName of normalizeTemplateBindingNames(candidate.name)) if ((candidate.kind === "string" ? bindings.registeredComponents.get(localName) : bindings.components.get(localName)) === "T") return selector.displayName;
 }
-/** Identifies a statically named Suspense fallback slot during tree walking. */
-function isSuspenseFallbackTemplate(child) {
-	return child.type === NodeTypes.ELEMENT && child.tag === "template" && hasStaticSlotName(child, "fallback");
-}
-/** Matches one statically named slot directive without emitting diagnostics. */
-function hasStaticSlotName(element, name) {
-	const directive = element.props.find((property) => property.type === NodeTypes.DIRECTIVE && property.name === "slot");
-	return directive?.arg?.type === NodeTypes.SIMPLE_EXPRESSION && directive.arg.isStatic && directive.arg.content === name;
-}
 function validateRichElement(element, context, resolvedDynamicComponent) {
 	if (element.tagType === ElementTypes.SLOT || element.tag === "slot") addVueError(context, element.loc, "Found a <slot> inside a gt-vue <T> component", "Move runtime slot content outside <T> or wrap a stable value in <Var>");
 	if (element.tag === "template" && !element.props.some((property) => property.type === NodeTypes.DIRECTIVE && property.name === "slot")) addVueError(context, element.loc, "Found a bare <template> inside a gt-vue <T> component", "Use an ordinary element or a statically named slot template");
-	if (element.tag.toLowerCase() === "component" && !resolvedDynamicComponent) addVueError(context, element.loc, "Found a dynamic <component> inside a gt-vue <T> component", "Use a statically named element or component");
+	if ((element.tag.toLowerCase() === "component" || element.props.some((property) => isEffectiveValuedVIsSelector(element, property, context.valuedVIsReplacesElement))) && !resolvedDynamicComponent) addVueError(context, element.loc, "Found a dynamic <component> inside a gt-vue <T> component", "Use a statically named element or component");
 	for (const property of element.props) {
 		if (property.type !== NodeTypes.DIRECTIVE) continue;
-		if (SOURCE_SHAPING_DIRECTIVES.has(property.name)) addVueError(context, property.loc, `Found source-shaping directive ${property.rawName ?? `v-${property.name}`} inside a gt-vue <T> component`, "Move conditional or repeated content outside <T>, or use Branch/Plural");
+		if (SOURCE_SHAPING_DIRECTIVES.has(property.name)) addVueError(context, property.loc, `Found source-shaping directive ${readDirectiveSourceName(property)} inside a gt-vue <T> component`, "Move conditional or repeated content outside <T>, or use Branch/Plural");
 		else if (property.name === "bind" && !readDirectiveKey(property)) addVueError(context, property.loc, "Found a dynamic or spread v-bind inside a gt-vue <T> component", "Bind props by a static name so their effect on the translation source is known");
 	}
 }
@@ -704,6 +771,8 @@ function validateVariableComponentShape(element, component, context) {
 	context.validatedVariableComponents.add(element);
 	if (component !== "Var") {
 		if (!hasTemplateProp(element, "value")) addVueError(context, element.loc, `Found a gt-vue <${component}> component without a value prop`, `Pass the runtime value through <${component} :value="value" />`);
+		const nameProp = findTemplateProp(element, "name");
+		if (nameProp) addVueError(context, nameProp.loc, `Found unsupported name prop on a gt-vue <${component}> component`, "Remove name; named variables are not supported by gt-vue yet");
 		if (hasMeaningfulSlotContent(element.children, context)) addVueError(context, element.loc, `Found children on a gt-vue <${component}> component`, `Use only the required value prop: <${component} :value="value" />`);
 		return;
 	}
@@ -715,7 +784,10 @@ function validateVariableComponentShape(element, component, context) {
 }
 /** Returns whether a statically named template prop is explicitly present. */
 function hasTemplateProp(element, expected) {
-	return element.props.some((property) => {
+	return findTemplateProp(element, expected) !== void 0;
+}
+function findTemplateProp(element, expected) {
+	return element.props.find((property) => {
 		if (property.type === NodeTypes.ATTRIBUTE) return property.name === expected;
 		return property.name === "bind" && readDirectiveKey(property) === expected;
 	});
@@ -741,13 +813,13 @@ function readBranches(element, slots, branchElementId, component, shadowed, bind
 		branches[name] = collapseChildren(serializeChildren(slot.children, { value: branchElementId }, slot.shadowed, bindings, expressionPlugins, context));
 	}
 	for (const property of element.props) {
-		if (isDynamicComponentSelector(element, property)) continue;
+		if (isCompilerConsumedComponentSelectorProperty(element, property)) continue;
 		if (property.type === NodeTypes.DIRECTIVE && property.name === "slot") continue;
 		const key = property.type === NodeTypes.ATTRIBUTE ? property.name : readDirectiveKey(property);
 		if (property.type === NodeTypes.DIRECTIVE && property.name === "on") continue;
 		if (key && (!isBranchAttributeName(key) || Object.prototype.hasOwnProperty.call(branches, key) || component === "Plural" && !isAcceptedPluralForm(key))) continue;
 		if (property.type === NodeTypes.DIRECTIVE && (property.name !== "bind" || property.modifiers.length > 0)) {
-			const directive = property.rawName ?? `v-${property.name}`;
+			const directive = readDirectiveSourceName(property);
 			addVueError(context, property.loc, `Found unsupported directive ${directive} on a gt-vue <${component}> component`, `Move ${directive} to an element outside <${component}>`);
 			continue;
 		}
@@ -758,12 +830,21 @@ function readBranches(element, slots, branchElementId, component, shadowed, bind
 			addVueError(context, property.loc, `Found dynamic branch prop "${key}" on a gt-vue <${component}> component`, "Use a static branch prop or a named slot");
 			continue;
 		}
+		if (value.value === void 0) continue;
 		branches[key] = branchPropToChildren(value.value);
 	}
 	return branches;
 }
+/**
+* Converts a direct branch prop into its persisted GT wire value.
+*
+* React preserves boolean and null branch props as typed wire values, while
+* the rich renderer handles their visible output separately. `JsxChildren`
+* predates those wire literals, so the cast is confined to this exact
+* compatibility boundary.
+*/
 function branchPropToChildren(value) {
-	if (value == null || typeof value === "boolean") return [];
+	if (value === null || typeof value === "boolean") return value;
 	return String(value);
 }
 /**
@@ -789,7 +870,7 @@ function isStaticallyNonBranchValue(property, expressionPlugins, shadowed, bindi
 	if (babel.isIdentifier(node, { name: "undefined" })) return !shadowed.has(node.name) && !bindings.staticValues.has(node.name);
 	return babel.isArrayExpression(node) || babel.isArrowFunctionExpression(node) || babel.isClassExpression(node) || babel.isFunctionExpression(node) || babel.isNewExpression(node) || babel.isObjectExpression(node) || babel.isRegExpLiteral(node) || babel.isUnaryExpression(node) && node.operator === "void";
 }
-function getSlotLayout(element, shadowed, expressionPlugins, context) {
+function getSlotLayout(element, shadowed, expressionPlugins, context, namedSlotPolicy) {
 	const namedSlots = /* @__PURE__ */ new Map();
 	let defaultSlot = {
 		children: [],
@@ -801,8 +882,8 @@ function getSlotLayout(element, shadowed, expressionPlugins, context) {
 	let reportedDefaultConflict = false;
 	const componentSlot = element.props.find((property) => property.type === NodeTypes.DIRECTIVE && property.name === "slot");
 	if (componentSlot) {
-		if (componentSlot.exp) addScopedSlotError(componentSlot.loc, context);
 		const slotName = readSlotName(componentSlot, context);
+		if (componentSlot.exp && (slotName === "default" || namedSlotPolicy !== "opaque")) addScopedSlotError(componentSlot.loc, context);
 		const slotShadowed = unionSets(shadowed, collectExpressionBindings(componentSlot.exp, expressionPlugins));
 		if (slotName === "default") defaultSlot = {
 			children: element.children,
@@ -827,9 +908,9 @@ function getSlotLayout(element, shadowed, expressionPlugins, context) {
 			continue;
 		}
 		hasTemplateSlots = true;
-		for (const property of child.props) if (property.type === NodeTypes.DIRECTIVE && property.name !== "slot") addVueError(context, property.loc, "Found a conditional or dynamic named slot inside a gt-vue <T> component", "Use an unconditional, statically named slot");
 		const slotName = readSlotName(slotDirective, context);
-		if (slotDirective.exp) addScopedSlotError(slotDirective.loc, context);
+		for (const property of child.props) if (property.type === NodeTypes.DIRECTIVE && property.name !== "slot" && (slotName === "default" || namedSlotPolicy !== "opaque")) addVueError(context, property.loc, "Found a conditional or dynamic named slot inside a gt-vue <T> component", "Use an unconditional, statically named slot");
+		if (slotDirective.exp && (slotName === "default" || namedSlotPolicy !== "opaque")) addScopedSlotError(slotDirective.loc, context);
 		const slotShadowed = unionSets(shadowed, collectExpressionBindings(slotDirective.exp, expressionPlugins));
 		if (slotName === "default") {
 			if (hasMeaningfulSlotContent(defaultChildren, context) || hasExplicitDefaultSlot) {
@@ -934,17 +1015,13 @@ function readPropertyValue(property, expressionPlugins, shadowed, bindings) {
 }
 function readExpressionPrimitive(expression, expressionPlugins, shadowed, bindings) {
 	return readStaticPrimitive(expression ? getExpressionNode(expression, expressionPlugins) : void 0, (identifier) => {
-		if (shadowed.has(identifier.name)) return { ok: false };
-		const value = bindings.staticValues.get(identifier.name);
-		return bindings.staticValues.has(identifier.name) ? {
-			ok: true,
-			value
-		} : { ok: false };
+		return readTemplateIdentifierPrimitive(identifier, shadowed, bindings);
 	});
 }
 function getExpressionNode(expression, expressionPlugins) {
 	if (expression.type !== NodeTypes.SIMPLE_EXPRESSION) return void 0;
-	if (expression.ast && typeof expression.ast === "object") return expression.ast;
+	const compilerAst = expression.ast;
+	if (compilerAst && typeof compilerAst === "object") return compilerAst;
 	try {
 		return parseExpression(expression.content, { plugins: expressionPlugins });
 	} catch {
@@ -1001,9 +1078,9 @@ function readForParseResult(property) {
 }
 /** Creates one parser-neutral v-for field from Vue's original expression. */
 function cloneForExpression(expression, content) {
+	const { ast: _ast, ...base } = expression;
 	return {
-		...expression,
-		ast: void 0,
+		...base,
 		content,
 		loc: {
 			...expression.loc,
@@ -1031,13 +1108,13 @@ function collectPatternNames(pattern, result) {
 	else collectPatternNames(property.value, result);
 	else if (pattern.type === "TSParameterProperty") collectPatternNames(pattern.parameter, result);
 }
-function resolveGTComponent(element, bindings, expressionPlugins, shadowed) {
-	return resolveComponentBinding(element, bindings, bindings.components, bindings.registeredComponents, bindings.directBindings, expressionPlugins, shadowed);
+function resolveGTComponent(element, bindings, expressionPlugins, shadowed, valuedVIsReplacesElement) {
+	return resolveComponentBinding(element, bindings, bindings.components, bindings.registeredComponents, bindings.directBindings, expressionPlugins, shadowed, valuedVIsReplacesElement);
 }
 /** Resolves a template tag or static dynamic selector through known bindings. */
-function resolveComponentBinding(element, bindings, directBindings, registeredBindings, directTemplateBindings, expressionPlugins, shadowed) {
+function resolveComponentBinding(element, bindings, directBindings, registeredBindings, directTemplateBindings, expressionPlugins, shadowed, valuedVIsReplacesElement) {
 	if (element.tagType !== ElementTypes.COMPONENT) return void 0;
-	const selector = readDynamicComponentSelector(element, expressionPlugins, bindings, shadowed);
+	const selector = readDynamicComponentSelector(element, expressionPlugins, bindings, shadowed, valuedVIsReplacesElement);
 	if (selector) {
 		if (selector.unknown || selector.possibleGT || selector.componentFactories.size > 0 || selector.gtComponentFactories.size > 0 || selector.candidates.length === 0) return;
 		const resolved = selector.candidates.map((candidate) => {
@@ -1052,8 +1129,18 @@ function resolveComponentBinding(element, bindings, directBindings, registeredBi
 		const first = resolved[0];
 		return first && resolved.every((candidate) => candidate?.originalName === first.originalName) ? first : void 0;
 	}
-	for (const localName of normalizeTemplateBindingNames(element.tag)) {
-		const originalName = isDirectTemplateBinding(localName, directTemplateBindings) ? directBindings.get(localName) : registeredBindings.get(localName);
+	const effectiveTag = readStaticVueIsTarget(element) ?? element.tag;
+	const normalizedNames = [...normalizeTemplateBindingNames(effectiveTag)];
+	const directNames = getNormalizedDirectTemplateBindings(effectiveTag, directTemplateBindings);
+	if (directNames.length > 0) {
+		const originalName = directBindings.get(directNames[0]);
+		return originalName && directNames.every((localName) => directBindings.get(localName) === originalName) ? {
+			localName: directNames[0],
+			originalName
+		} : void 0;
+	}
+	for (const localName of normalizedNames) {
+		const originalName = registeredBindings.get(localName);
 		if (originalName) return {
 			localName,
 			originalName
@@ -1069,14 +1156,17 @@ function normalizeTemplateBindingNames(sourceName) {
 		pascalized
 	]);
 }
+/** Returns every direct binding in one Vue-normalized template-name family. */
+function getNormalizedDirectTemplateBindings(sourceName, directBindings) {
+	return [...normalizeTemplateBindingNames(sourceName)].filter((localName) => isDirectTemplateBinding(localName, directBindings));
+}
 /** Returns whether a program binding shadows an Options API registration. */
 function isDirectTemplateBinding(localName, directBindings) {
 	return directBindings.has(localName) || directBindings.has(localName.split(".", 1)[0] ?? localName);
 }
 /** Resolves a statically knowable Vue dynamic-component selector. */
-function readDynamicComponentSelector(element, expressionPlugins, bindings, shadowed) {
-	if (element.tag.toLowerCase() !== "component") return void 0;
-	const property = element.props.find((candidate) => isDynamicComponentSelector(element, candidate));
+function readDynamicComponentSelector(element, expressionPlugins, bindings, shadowed, valuedVIsReplacesElement) {
+	const property = element.props.find((candidate) => isDynamicComponentSelector(element, candidate)) ?? element.props.find((candidate) => isEffectiveValuedVIsSelector(element, candidate, valuedVIsReplacesElement));
 	if (!property) return void 0;
 	if (property.type === NodeTypes.ATTRIBUTE) return property.value ? {
 		candidates: [{
@@ -1091,10 +1181,14 @@ function readDynamicComponentSelector(element, expressionPlugins, bindings, shad
 		unknown: false
 	} : void 0;
 	const node = property.exp ? getExpressionNode(property.exp, expressionPlugins) : void 0;
-	if (!node) return void 0;
+	const displayName = property.exp?.type === NodeTypes.SIMPLE_EXPRESSION && property.exp.content ? property.exp.content : "dynamic component";
+	if (!node) return {
+		...emptyDynamicSelectorAnalysis(true),
+		displayName
+	};
 	return {
 		...collectDynamicSelectorCandidates(node, bindings, shadowed, /* @__PURE__ */ new Set()),
-		displayName: property.exp?.type === NodeTypes.SIMPLE_EXPRESSION ? property.exp.content : "dynamic component"
+		displayName
 	};
 }
 /** Collects every statically visible result of a dynamic selector expression. */
@@ -1452,7 +1546,7 @@ function collectTemplateTransformCandidates(call, bindings, shadowed, seen) {
 	if (method === "flatMap") return flattenTemplateTransformAnalysis(mapValues(source, readArgument(0), true, readArgument(1)), 1, bindings, shadowed, seen);
 	if (method === "flat") {
 		const depthNode = readArgument(0);
-		const depthValue = depthNode ? readTemplateStaticPrimitive(depthNode, bindings, shadowed, true) : {
+		const depthValue = depthNode ? readTemplateStaticPrimitive(depthNode, bindings, shadowed) : {
 			ok: true,
 			value: 1
 		};
@@ -2141,22 +2235,9 @@ function readStaticTemplateMemberProperty(node, bindings, shadowed) {
 	const property = readTemplateStaticPrimitive(node.property, bindings, shadowed);
 	return property.ok && (typeof property.value === "string" || typeof property.value === "number") ? String(property.value) : void 0;
 }
-function readTemplateStaticPrimitive(node, bindings, shadowed, allowNumericGlobals = false) {
+function readTemplateStaticPrimitive(node, bindings, shadowed) {
 	return readStaticPrimitive(node, (identifier) => {
-		if (shadowed.has(identifier.name)) return { ok: false };
-		if (bindings.staticValues.has(identifier.name)) return {
-			ok: true,
-			value: bindings.staticValues.get(identifier.name)
-		};
-		if (allowNumericGlobals && !bindings.directBindings.has(identifier.name) && identifier.name === "Infinity") return {
-			ok: true,
-			value: Number.POSITIVE_INFINITY
-		};
-		if (allowNumericGlobals && !bindings.directBindings.has(identifier.name) && identifier.name === "NaN") return {
-			ok: true,
-			value: NaN
-		};
-		return { ok: false };
+		return readTemplateIdentifierPrimitive(identifier, shadowed, bindings);
 	});
 }
 /** Reads a dotted template member chain without evaluating runtime code. */
@@ -2175,15 +2256,56 @@ function isDynamicComponentSelector(element, property) {
 	if (property.type === NodeTypes.ATTRIBUTE) return property.name === "is";
 	return property.name === "bind" && readDirectiveKey(property) === "is";
 }
+/** Finds the first ordinary `is` property using Vue's own source-order rule. */
+function findFirstComponentIsProperty(element) {
+	return element.props.find((property) => {
+		if (property.type === NodeTypes.ATTRIBUTE) return property.name === "is";
+		return property.name === "bind" && readDirectiveKey(property) === "is";
+	});
+}
+/** Reads Vue's effective static `is="vue:..."` component replacement. */
+function readStaticVueIsSelector(element) {
+	if (element.tagType !== ElementTypes.COMPONENT || element.tag.toLowerCase() === "component") return;
+	const property = findFirstComponentIsProperty(element);
+	if (property?.type !== NodeTypes.ATTRIBUTE || !property.value?.content.startsWith("vue:")) return;
+	return {
+		property,
+		target: property.value.content.slice(4)
+	};
+}
+/** Reads only the target name of Vue's effective static replacement. */
+function readStaticVueIsTarget(element) {
+	return readStaticVueIsSelector(element)?.target;
+}
+/** Matches the only two spellings Vue treats as its built-in Suspense. */
+function isLiteralSuspenseName(name) {
+	return name === "Suspense" || name === "suspense";
+}
+/** Matches the selector directive actually consumed by Vue 3.3's transform. */
+function isEffectiveValuedVIsSelector(element, property, valuedVIsReplacesElement) {
+	return valuedVIsReplacesElement && element.tagType === ElementTypes.COMPONENT && element.tag.toLowerCase() !== "component" && property.type === NodeTypes.DIRECTIVE && property.name === "is" && property.exp !== void 0;
+}
+/** Mirrors selector properties omitted from Vue's generated VNode props. */
+function isCompilerConsumedComponentSelectorProperty(element, property) {
+	if (property.type === NodeTypes.ATTRIBUTE) return property.name === "is" && (element.tag.toLowerCase() === "component" || Boolean(property.value?.content.startsWith("vue:")));
+	if (property.name === "is") return true;
+	return property.name === "bind" && element.tag.toLowerCase() === "component" && readDirectiveKey(property) === "is";
+}
+/** Reads directive source spelling absent from Vue 3.3's public AST types. */
+function readDirectiveSourceName(directive) {
+	const rawName = "rawName" in directive && typeof directive.rawName === "string" ? directive.rawName : void 0;
+	if (rawName) return rawName;
+	return directive.loc.source.split("=", 1)[0]?.trim() || `v-${directive.name}`;
+}
 function readDirectiveKey(directive) {
 	return directive.arg?.type === NodeTypes.SIMPLE_EXPRESSION && directive.arg.isStatic ? directive.arg.content : void 0;
 }
 function toDisplayString(value) {
 	return value == null ? "" : String(value);
 }
-function appendSerializedChild(result, value) {
+function appendSerializedChild(result, value, mergeWithPrevious) {
 	const previous = result[result.length - 1];
-	if (typeof previous === "string" && typeof value === "string") result[result.length - 1] = previous + value;
+	if (mergeWithPrevious && typeof previous === "string" && typeof value === "string") result[result.length - 1] = previous + value;
 	else result.push(value);
 }
 function collapseChildren(children) {