@geajs/vite-plugin 1.4.1 → 1.4.2

package/dist/index.mjs

@@ -1,10 +1,11 @@
+import { parse } from "@babel/parser";
 import _traverse from "@babel/traverse";
 import _generate from "@babel/generator";
 import * as t from "@babel/types";
-import { parse } from "@babel/parser";
 import { id, js, jsExpr, jsImport } from "eszter";
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { dirname, relative, resolve } from "node:path";
+import { dirname, posix, relative, resolve } from "node:path";
+import { createHash } from "node:crypto";
 import { fileURLToPath } from "node:url";
 //#region src/utils/babel-interop.ts
 /**
@@ -277,215 +278,59 @@ function collectBindings(stmts, bindings) {
 				let localName;
 				if (t.isIdentifier(prop.value)) localName = prop.value.name;
 				else continue;
-				const mem = t.memberExpression(cloneExpr$2(decl.init), t.identifier(sourceKey));
+				const mem = t.memberExpression(cloneExpr$1(decl.init), t.identifier(sourceKey));
 				bindings.set(localName, mem);
 			}
-			else if (t.isIdentifier(decl.id)) bindings.set(decl.id.name, cloneExpr$2(decl.init));
+			else if (t.isIdentifier(decl.id)) bindings.set(decl.id.name, cloneExpr$1(decl.init));
 		}
 	}
 }
 /** Shallow clone to avoid AST aliasing hazards when substituting. */
-function cloneExpr$2(expr) {
+function cloneExpr$1(expr) {
 	return t.cloneNode(expr);
 }
 //#endregion
 //#region src/closure-codegen/emit/emit-substitution.ts
-function cloneExpr$1(expr) {
-	return t.cloneNode(expr);
-}
-/**
-* Walk an expression tree and replace Identifier references that match a
-* binding with the bound expression (also recursively). Used to rewrite
-* JSX-expression member chains so their root is the real reactive source.
-* Returns a new expression; does not mutate input.
-*/
+/** Resolve template aliases at free read/write sites, preserving lexical scope. */
 function substituteBindings(expr, bindings) {
 	if (!expr) return expr;
 	if (t.isTSAsExpression(expr) || t.isTSTypeAssertion(expr) || t.isTSNonNullExpression(expr) || t.isTSInstantiationExpression(expr)) return substituteBindings(expr.expression, bindings);
 	if (bindings.size === 0) return expr;
-	if (t.isIdentifier(expr)) {
-		const b = bindings.get(expr.name);
-		if (b) {
-			const scoped = new Map(bindings);
-			scoped.delete(expr.name);
-			return substituteBindings(cloneExpr$1(b), scoped);
+	const node = t.cloneNode(expr, true);
+	const statement = t.isStatement(node);
+	const container = t.isJSXExpressionContainer(node);
+	if (container && t.isJSXEmptyExpression(node.expression)) return node;
+	if (!statement && !container && !t.isExpression(node)) return node;
+	const file = t.file(t.program([statement ? node : t.expressionStatement(container ? node.expression : node)]));
+	traverse(file, { Identifier(path) {
+		const name = path.node.name;
+		if (!bindings.has(name) || path.scope.getBinding(name)) return;
+		if (!path.isReferencedIdentifier() && !isAssignmentTarget(path)) return;
+		const remaining = new Map(bindings);
+		remaining.delete(name);
+		const replacement = substituteBindings(bindings.get(name), remaining);
+		path.replaceWith(t.cloneNode(replacement, true));
+		path.skip();
+	} });
+	const result = statement ? file.program.body[0] : file.program.body[0].expression;
+	return container ? {
+		...node,
+		expression: result
+	} : result;
+}
+/** Assignment patterns write references; labels and declarations do not. */
+function isAssignmentTarget(path) {
+	let target = path;
+	while (target.parentPath) {
+		const parent = target.parentPath;
+		if (parent.isObjectProperty() && target.key === "value" || parent.isObjectPattern() || parent.isArrayPattern() || parent.isRestElement() && target.key === "argument" || parent.isAssignmentPattern() && target.key === "left") {
+			target = parent;
+			continue;
 		}
-		return expr;
+		return (parent.isAssignmentExpression() || parent.isForInStatement() || parent.isForOfStatement()) && target.key === "left" || parent.isUpdateExpression() && target.key === "argument";
 	}
-	if (t.isMemberExpression(expr)) return {
-		...expr,
-		object: substituteBindings(expr.object, bindings),
-		property: expr.computed ? substituteBindings(expr.property, bindings) : expr.property
-	};
-	if (t.isCallExpression(expr)) return {
-		...expr,
-		callee: substituteBindings(expr.callee, bindings),
-		arguments: expr.arguments.map((a) => substituteBindings(a, bindings))
-	};
-	if (t.isBinaryExpression(expr) || t.isLogicalExpression(expr)) return {
-		...expr,
-		left: substituteBindings(expr.left, bindings),
-		right: substituteBindings(expr.right, bindings)
-	};
-	if (t.isConditionalExpression(expr)) return {
-		...expr,
-		test: substituteBindings(expr.test, bindings),
-		consequent: substituteBindings(expr.consequent, bindings),
-		alternate: substituteBindings(expr.alternate, bindings)
-	};
-	if (t.isUnaryExpression(expr) || t.isUpdateExpression(expr)) return {
-		...expr,
-		argument: substituteBindings(expr.argument, bindings)
-	};
-	if (t.isTemplateLiteral(expr)) return {
-		...expr,
-		expressions: expr.expressions.map((e) => substituteBindings(e, bindings))
-	};
-	if (t.isOptionalMemberExpression(expr)) return {
-		...expr,
-		object: substituteBindings(expr.object, bindings),
-		property: expr.computed ? substituteBindings(expr.property, bindings) : expr.property
-	};
-	if (t.isOptionalCallExpression(expr)) return {
-		...expr,
-		callee: substituteBindings(expr.callee, bindings),
-		arguments: expr.arguments.map((a) => substituteBindings(a, bindings))
-	};
-	if (t.isArrowFunctionExpression(expr) || t.isFunctionExpression(expr)) {
-		const paramNames = /* @__PURE__ */ new Set();
-		for (const p of expr.params) if (t.isIdentifier(p)) paramNames.add(p.name);
-		else if (t.isObjectPattern(p)) {
-			for (const prop of p.properties) if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) paramNames.add(prop.value.name);
-		}
-		const shadowed = new Map(bindings);
-		for (const k of paramNames) shadowed.delete(k);
-		if (shadowed.size === 0) return expr;
-		return {
-			...expr,
-			body: substituteBindings(expr.body, shadowed)
-		};
-	}
-	if (t.isBlockStatement(expr)) return {
-		...expr,
-		body: expr.body.map((s) => substituteBindings(s, bindings))
-	};
-	if (t.isExpressionStatement(expr)) return {
-		...expr,
-		expression: substituteBindings(expr.expression, bindings)
-	};
-	if (t.isReturnStatement(expr)) return expr.argument ? {
-		...expr,
-		argument: substituteBindings(expr.argument, bindings)
-	} : expr;
-	if (t.isIfStatement(expr)) return {
-		...expr,
-		test: substituteBindings(expr.test, bindings),
-		consequent: substituteBindings(expr.consequent, bindings),
-		alternate: expr.alternate ? substituteBindings(expr.alternate, bindings) : null
-	};
-	if (t.isVariableDeclaration(expr)) return {
-		...expr,
-		declarations: expr.declarations.map((d) => ({
-			...d,
-			init: d.init ? substituteBindings(d.init, bindings) : null
-		}))
-	};
-	if (t.isTryStatement(expr)) return {
-		...expr,
-		block: substituteBindings(expr.block, bindings),
-		handler: expr.handler ? {
-			...expr.handler,
-			body: substituteBindings(expr.handler.body, bindings)
-		} : null,
-		finalizer: expr.finalizer ? substituteBindings(expr.finalizer, bindings) : null
-	};
-	if (t.isForStatement(expr) || t.isForInStatement(expr) || t.isForOfStatement(expr)) return {
-		...expr,
-		body: substituteBindings(expr.body, bindings)
-	};
-	if (t.isWhileStatement(expr) || t.isDoWhileStatement(expr)) return {
-		...expr,
-		test: substituteBindings(expr.test, bindings),
-		body: substituteBindings(expr.body, bindings)
-	};
-	if (t.isSwitchStatement(expr)) return {
-		...expr,
-		discriminant: substituteBindings(expr.discriminant, bindings),
-		cases: expr.cases.map((c) => ({
-			...c,
-			consequent: c.consequent.map((s) => substituteBindings(s, bindings))
-		}))
-	};
-	if (t.isArrayExpression(expr)) return {
-		...expr,
-		elements: expr.elements.map((e) => e ? substituteBindings(e, bindings) : e)
-	};
-	if (t.isObjectExpression(expr)) return {
-		...expr,
-		properties: expr.properties.map((p) => t.isObjectProperty(p) ? {
-			...p,
-			value: substituteBindings(p.value, bindings)
-		} : p)
-	};
-	if (t.isSpreadElement(expr)) return {
-		...expr,
-		argument: substituteBindings(expr.argument, bindings)
-	};
-	if (t.isNewExpression(expr)) return {
-		...expr,
-		callee: substituteBindings(expr.callee, bindings),
-		arguments: expr.arguments.map((a) => substituteBindings(a, bindings))
-	};
-	if (t.isSequenceExpression(expr)) return {
-		...expr,
-		expressions: expr.expressions.map((e) => substituteBindings(e, bindings))
-	};
-	if (t.isAssignmentExpression(expr)) return {
-		...expr,
-		right: substituteBindings(expr.right, bindings)
-	};
-	if (t.isJSXElement(expr)) {
-		const newOpening = {
-			...expr.openingElement,
-			attributes: expr.openingElement.attributes.map((a) => {
-				if (t.isJSXAttribute(a) && a.value && t.isJSXExpressionContainer(a.value) && !t.isJSXEmptyExpression(a.value.expression)) return {
-					...a,
-					value: {
-						...a.value,
-						expression: substituteBindings(a.value.expression, bindings)
-					}
-				};
-				return a;
-			})
-		};
-		const newChildren = expr.children.map((c) => substituteBindings(c, bindings));
-		return {
-			...expr,
-			openingElement: newOpening,
-			children: newChildren
-		};
-	}
-	if (t.isJSXFragment(expr)) return {
-		...expr,
-		children: expr.children.map((c) => substituteBindings(c, bindings))
-	};
-	if (t.isJSXExpressionContainer(expr) && !t.isJSXEmptyExpression(expr.expression)) return {
-		...expr,
-		expression: substituteBindings(expr.expression, bindings)
-	};
-	if (t.isJSXText(expr) || t.isJSXSpreadChild(expr) || t.isJSXEmptyExpression(expr)) return expr;
-	return expr;
+	return false;
 }
-/**
-* Compile a JSX element/fragment into a clone-and-wire expression.
-*
-* Returns a BlockStatement that:
-*   - declares `const root = (_tpl<N>_root || (_tpl<N>_root = _tpl<N>_create())).cloneNode(true)`
-*   - wires all slots
-*   - returns `root`
-*
-* Side effect: adds the lazy template root cache to `ctx.templateDecls`.
-*/
 //#endregion
 //#region src/closure-codegen/emit/template-decl.ts
 const SVG_TEMPLATE_ROOT_TAGS = new Set([
@@ -621,6 +466,27 @@ function emitWalkExpr(root, walk, walkKinds) {
 	return out;
 }
 //#endregion
+//#region src/closure-codegen/keyed-list/keyed-list-item-reader.ts
+/** Read through the row observable so primitive replacements remain reactive too. */
+function useObservableItem(createItem, importsNeeded) {
+	if (!t.isArrowFunctionExpression(createItem)) throw new Error("Expected a keyed-list row factory");
+	const item = createItem.params[0];
+	const names = /* @__PURE__ */ new Set();
+	t.traverseFast(createItem, (node) => {
+		if (t.isIdentifier(node)) names.add(node.name);
+	});
+	let name = "__geaItemObservable";
+	while (names.has(name)) name += "_";
+	const observable = t.identifier(name);
+	const read = t.callExpression(t.identifier("readItem"), [observable]);
+	const bindings = /* @__PURE__ */ new Map();
+	if (t.isIdentifier(item)) bindings.set(item.name, read);
+	else for (const name of Object.keys(t.getBindingIdentifiers(item))) bindings.set(name, t.callExpression(t.arrowFunctionExpression([t.cloneNode(item, true)], t.identifier(name)), [t.cloneNode(read, true)]));
+	createItem.body = substituteBindings(createItem.body, bindings);
+	createItem.params[0] = observable;
+	importsNeeded.add("readItem");
+}
+//#endregion
 //#region src/closure-codegen/emit/emit-map-branch.ts
 function buildMapBranchFn(mapExpr, ctx) {
 	const arrowExpr = mapExpr.arguments[0];
@@ -644,7 +510,7 @@ function buildMapBranchFn(mapExpr, ctx) {
 		t.identifier("d")
 	], createItemBlock);
 	ctx.importsNeeded.add("createItemObservable");
-	ctx.importsNeeded.add("createItemProxy");
+	useObservableItem(createItemFn, ctx.importsNeeded);
 	ctx.importsNeeded.add("_rescue");
 	ctx.importsNeeded.add("GEA_PROXY_RAW");
 	const listId = "L" + ctx.listCounter++;
@@ -658,7 +524,7 @@ function buildMapBranchFn(mapExpr, ctx) {
 		t.identifier(rqName),
 		t.callExpression(t.identifier("String"), [t.identifier("__k")]),
 		t.identifier(itemParam)
-	]))]), t.ifStatement(t.identifier("__r"), t.blockStatement([t.returnStatement(t.identifier("__r"))])), t.variableDeclaration("const", [t.variableDeclarator(t.identifier("__rd"), t.callExpression(t.memberExpression(t.identifier("d"), t.identifier("child")), []))]), t.variableDeclaration("const", [t.variableDeclarator(t.identifier("__obs"), t.callExpression(t.identifier("createItemObservable"), [t.identifier(itemParam)]))]), t.variableDeclaration("const", [t.variableDeclarator(t.identifier("__li"), t.conditionalExpression(t.logicalExpression("&&", t.binaryExpression("!==", t.identifier(itemParam), t.nullLiteral()), t.binaryExpression("===", t.unaryExpression("typeof", t.identifier(itemParam)), t.stringLiteral("object"))), t.callExpression(t.identifier("createItemProxy"), [t.identifier("__obs")]), t.identifier(itemParam)))]), t.variableDeclaration("const", [t.variableDeclarator(t.identifier("__el"), t.callExpression(t.identifier(ciName), [
+	]))]), t.ifStatement(t.identifier("__r"), t.blockStatement([t.returnStatement(t.identifier("__r"))])), t.variableDeclaration("const", [t.variableDeclarator(t.identifier("__rd"), t.callExpression(t.memberExpression(t.identifier("d"), t.identifier("child")), []))]), t.variableDeclaration("const", [t.variableDeclarator(t.identifier("__obs"), t.callExpression(t.identifier("createItemObservable"), [t.identifier(itemParam)]))]), t.variableDeclaration("const", [t.variableDeclarator(t.identifier("__li"), t.identifier("__obs"))]), t.variableDeclaration("const", [t.variableDeclarator(t.identifier("__el"), t.callExpression(t.identifier(ciName), [
 		t.identifier("__li"),
 		t.identifier(idxParam),
 		t.identifier("__rd")
@@ -2125,7 +1991,7 @@ function buildCreateEntryArrow(options, itemId, idxId) {
 	}
 	const obsId = t.identifier("__obs");
 	const liveItemId = t.identifier("__li");
-	if (needsItemProxy) createEntryStmts.push(t.variableDeclaration("const", [t.variableDeclarator(obsId, t.callExpression(t.identifier("createItemObservable"), [itemId]))]), t.variableDeclaration("const", [t.variableDeclarator(liveItemId, t.conditionalExpression(t.logicalExpression("&&", t.binaryExpression("!==", itemId, t.nullLiteral()), t.binaryExpression("===", t.unaryExpression("typeof", itemId), t.stringLiteral("object"))), t.callExpression(t.identifier("createItemProxy"), [obsId]), itemId))]));
+	if (needsItemProxy) createEntryStmts.push(t.variableDeclaration("const", [t.variableDeclarator(obsId, t.callExpression(t.identifier("createItemObservable"), [itemId]))]), t.variableDeclaration("const", [t.variableDeclarator(liveItemId, obsId)]));
 	else createEntryStmts.push(t.variableDeclaration("const", [t.variableDeclarator(obsId, t.nullLiteral())]), t.variableDeclaration("const", [t.variableDeclarator(liveItemId, itemId)]));
 	const elementId = t.identifier("__el");
 	createEntryStmts.push(t.variableDeclaration("const", [t.variableDeclarator(elementId, t.callExpression(t.identifier(ciName), [
@@ -2150,7 +2016,7 @@ function buildSimpleCreateEntryArrow(options, itemId, idxId) {
 	const liveItemId = t.identifier("__li");
 	const createEntryStmts = [t.variableDeclaration("const", [t.variableDeclarator(kId, keyExprWith(options, itemId, idxId))])];
 	if (needsRowDisposer) createEntryStmts.push(t.variableDeclaration("const", [t.variableDeclarator(rowDId, t.callExpression(t.memberExpression(t.identifier("d"), t.identifier("child")), []))]));
-	if (needsItemProxy) createEntryStmts.push(t.variableDeclaration("const", [t.variableDeclarator(obsId, t.callExpression(t.identifier("createItemObservable"), [itemId]))]), t.variableDeclaration("const", [t.variableDeclarator(liveItemId, t.conditionalExpression(t.logicalExpression("&&", t.binaryExpression("!==", itemId, t.nullLiteral()), t.binaryExpression("===", t.unaryExpression("typeof", itemId), t.stringLiteral("object"))), t.callExpression(t.identifier("createItemProxy"), [obsId]), itemId))]));
+	if (needsItemProxy) createEntryStmts.push(t.variableDeclaration("const", [t.variableDeclarator(obsId, t.callExpression(t.identifier("createItemObservable"), [itemId]))]), t.variableDeclaration("const", [t.variableDeclarator(liveItemId, obsId)]));
 	const createArgs = [needsItemProxy ? liveItemId : itemId, idxId];
 	if (needsRowDisposer) createArgs.push(rowDId);
 	createEntryStmts.push(t.variableDeclaration("const", [t.variableDeclarator(elementId, t.callExpression(t.identifier(ciName), createArgs))]));
@@ -3163,7 +3029,7 @@ function emitKeyedListSlot(slot, stmts, ctx) {
 	const needsRowDisposer = !(patchRowExpr && t.isIdentifier(itemParam) && !createItemBodyReferencesRowDisposer(createItem));
 	if (needsItemProxy) {
 		ctx.importsNeeded.add("createItemObservable");
-		ctx.importsNeeded.add("createItemProxy");
+		useObservableItem(createItem, ctx.importsNeeded);
 	}
 	const ciName = "__ki_" + listId;
 	const prName = "__kp_" + listId;
@@ -5446,6 +5312,185 @@ function rewriteFnComponent(fnDecl, parentCtx) {
 	else fnDecl.params[1] = t.identifier("d");
 	fnDecl.body.body = newBody;
 }
+//#endregion
+//#region src/closure-codegen/transform/transform-component-props.ts
+/**
+* Best-effort props-shape inference for compiled component classes.
+*
+* PROBLEM: the codegen rewrites `class HomeView extends Component { ... }`
+* into `class HomeView extends CompiledComponent { ... }` with no type
+* argument. `CompiledComponent<P extends Record<string, any> = Record<string,
+* any>>` then defaults `P` to `Record<string, any>`, so every
+* `this.props.x` read inside the class infers as `any` — even though the
+* original JSX call site (`<HomeView app={this} />`) fully determines the
+* real shape.
+*
+* FIX: scan the module for JSX usages of each locally-declared component and
+* synthesize a `{ attr: Type; ... }` literal from what's actually passed, so
+* callers can thread it onto the rewritten `extends CompiledXxx<...>` clause.
+*
+* This has no type checker to lean on — only the attribute value's own AST
+* shape. Only a few forms are classified:
+*   - `this`                      → the name of the enclosing class
+*   - string / template (static) → `string`
+*   - number / boolean / null literal → their primitive type
+* Anything else (a spread attribute, JSX children, an arbitrary expression)
+* makes that JSX usage "unresolvable", and the whole component is skipped —
+* emitting a narrower-than-reality type would be worse than emitting none,
+* since geatsc has no boxing to fall back on.
+*/
+/**
+* Names among `componentNames` that appear as a JSX opening-element tag
+* anywhere in this module — regardless of whether the usage is resolvable
+* into a props shape (unlike `inferComponentPropsTypes`, which drops
+* unresolvable or props-less usages entirely).
+*
+* Used to distinguish "used here, but with a shape we couldn't infer" from
+* "never used as JSX in this file at all" — only the latter is safe grounds
+* for treating a class as provably propless. See `applyPropsTypeArgument`
+* in transform.ts for how this combines with `classPropsReadsAreCovered`.
+*/
+function collectComponentsUsedAsJsx(ast, componentNames) {
+	const used = /* @__PURE__ */ new Set();
+	if (componentNames.size === 0) return used;
+	traverse(ast, {
+		noScope: true,
+		JSXElement(path) {
+			const name = path.node.openingElement.name;
+			if (t.isJSXIdentifier(name) && componentNames.has(name.name)) used.add(name.name);
+		}
+	});
+	return used;
+}
+function inferComponentPropsTypes(ast, componentNames) {
+	if (componentNames.size === 0) return /* @__PURE__ */ new Map();
+	const usages = /* @__PURE__ */ new Map();
+	const getUsage = (name) => {
+		let usage = usages.get(name);
+		if (!usage) {
+			usage = {
+				attrs: /* @__PURE__ */ new Map(),
+				siteCount: 0,
+				unresolvable: false
+			};
+			usages.set(name, usage);
+		}
+		return usage;
+	};
+	traverse(ast, {
+		noScope: true,
+		JSXElement(path) {
+			const opening = path.node.openingElement;
+			const name = opening.name;
+			if (!t.isJSXIdentifier(name) || !componentNames.has(name.name)) return;
+			const usage = getUsage(name.name);
+			usage.siteCount++;
+			if ((path.node.children ?? []).filter((child) => !(t.isJSXText(child) && /^\s*$/.test(child.value))).length > 0) usage.unresolvable = true;
+			const enclosingClassName = findEnclosingClassName(path);
+			for (const attr of opening.attributes) {
+				if (!t.isJSXAttribute(attr) || !t.isJSXIdentifier(attr.name)) {
+					usage.unresolvable = true;
+					continue;
+				}
+				const attrName = attr.name.name;
+				const typeStr = classifyAttrValue(attr.value, enclosingClassName);
+				if (typeStr == null) {
+					usage.unresolvable = true;
+					continue;
+				}
+				let observation = usage.attrs.get(attrName);
+				if (!observation) {
+					observation = {
+						types: /* @__PURE__ */ new Set(),
+						seenCount: 0
+					};
+					usage.attrs.set(attrName, observation);
+				}
+				observation.types.add(typeStr);
+				observation.seenCount++;
+			}
+		}
+	});
+	const result = /* @__PURE__ */ new Map();
+	for (const [name, usage] of usages) {
+		if (usage.unresolvable || usage.siteCount === 0 || usage.attrs.size === 0) continue;
+		const members = [...usage.attrs.entries()].map(([attrName, observation]) => {
+			const required = observation.seenCount === usage.siteCount;
+			const member = t.tsPropertySignature(t.identifier(attrName), t.tsTypeAnnotation(unionOfTypeStrings(observation.types)));
+			member.optional = !required;
+			return member;
+		});
+		result.set(name, t.tsTypeLiteral(members));
+	}
+	return result;
+}
+/**
+* Guard against emitting a props type narrower than what the class body
+* actually reads. `classDecl` must already reflect the fully-lowered body
+* (template method compiled in place) — this scans every `this.props.<key>`
+* read in the class and requires each key to be present in `propsType`.
+* Only guards against the codegen NARROWING props out from under real reads;
+* it does not otherwise validate the inferred shape.
+*/
+function classPropsReadsAreCovered(classDecl, propsType) {
+	const allowed = /* @__PURE__ */ new Set();
+	for (const member of propsType.members) if (t.isTSPropertySignature(member) && t.isIdentifier(member.key)) allowed.add(member.key.name);
+	let covered = true;
+	const isPropsMember = (node) => (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) && !node.computed && t.isIdentifier(node.property, { name: "props" }) && t.isThisExpression(node.object);
+	const visit = (node) => {
+		if (!covered || !node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const child of node) visit(child);
+			return;
+		}
+		if ((t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) && !node.computed && t.isIdentifier(node.property) && isPropsMember(node.object)) {
+			if (!allowed.has(node.property.name)) covered = false;
+			return;
+		}
+		for (const key of Object.keys(node)) {
+			if (key === "loc" || key === "start" || key === "end" || key === "type") continue;
+			visit(node[key]);
+		}
+	};
+	visit(classDecl.body.body);
+	return covered;
+}
+function findEnclosingClassName(path) {
+	let current = path.parentPath;
+	while (current) {
+		if (current.isFunctionExpression() || current.isFunctionDeclaration()) return null;
+		if (current.isClassDeclaration()) return current.node.id ? current.node.id.name : null;
+		current = current.parentPath;
+	}
+	return null;
+}
+function classifyAttrValue(value, enclosingClassName) {
+	if (value == null) return "boolean";
+	if (t.isStringLiteral(value)) return "string";
+	const expr = t.isJSXExpressionContainer(value) ? value.expression : null;
+	if (!expr || t.isJSXEmptyExpression(expr)) return null;
+	if (t.isThisExpression(expr)) return enclosingClassName;
+	if (t.isStringLiteral(expr)) return "string";
+	if (t.isNumericLiteral(expr)) return "number";
+	if (t.isBooleanLiteral(expr)) return "boolean";
+	if (t.isNullLiteral(expr)) return "null";
+	if (t.isTemplateLiteral(expr) && expr.expressions.length === 0) return "string";
+	return null;
+}
+function unionOfTypeStrings(types) {
+	const nodes = [...types].sort().map(typeStringToNode);
+	if (nodes.length === 1) return nodes[0];
+	return t.tsUnionType(nodes);
+}
+function typeStringToNode(typeStr) {
+	switch (typeStr) {
+		case "string": return t.tsStringKeyword();
+		case "number": return t.tsNumberKeyword();
+		case "boolean": return t.tsBooleanKeyword();
+		case "null": return t.tsNullKeyword();
+		default: return t.tsTypeReference(t.identifier(typeStr));
+	}
+}
 const RESOLVED_RECONCILE_ID = "\0virtual:gea-reconcile";
 const HMR_RUNTIME_ID = "virtual:gea-hmr";
 const RESOLVED_HMR_RUNTIME_ID = "\0" + HMR_RUNTIME_ID;
@@ -5829,9 +5874,12 @@ function transformFile(source, _filename, options = {}) {
 	ctx.directFnComponentParams = collectDirectFnComponentParams(ast, ctx.directFnComponents);
 	ctx.directFnStringProps = collectDirectFnStringProps(ast, ctx.directFnComponents);
 	ctx.directFnNoDisposer = /* @__PURE__ */ new Set();
-	ctx.directClassComponents = collectLocalClassComponents(ast);
+	const localComponentNames = collectLocalClassComponents(ast);
+	ctx.directClassComponents = new Set(localComponentNames);
 	for (const name of options.directClassComponents ?? []) ctx.directClassComponents.add(name);
 	ctx.directFactoryComponents = new Set(options.directFactoryComponents);
+	const componentPropsShapes = inferComponentPropsTypes(ast, localComponentNames);
+	const componentsUsedAsJsx = collectComponentsUsedAsJsx(ast, localComponentNames);
 	const rewritten = [];
 	const reactiveComponentNames = /* @__PURE__ */ new Set();
 	let firstClassIdx = -1;
@@ -5934,18 +5982,22 @@ function transformFile(source, _filename, options = {}) {
 				ctx.importsNeeded.add("CompiledComponent");
 				classDecl.superClass = t.identifier("CompiledComponent");
 				usesCompiledRuntimeBase = true;
+				applyPropsTypeArgument(classDecl, className, componentPropsShapes, componentsUsedAsJsx);
 			} else if (useTinyReactiveComponent) {
 				ctx.importsNeeded.add("CompiledTinyReactiveComponent");
 				classDecl.superClass = t.identifier("CompiledTinyReactiveComponent");
 				usesCompiledRuntimeBase = true;
+				applyPropsTypeArgument(classDecl, className, componentPropsShapes, componentsUsedAsJsx);
 			} else if (useLeanReactiveComponent) {
 				ctx.importsNeeded.add("CompiledLeanReactiveComponent");
 				classDecl.superClass = t.identifier("CompiledLeanReactiveComponent");
 				usesCompiledRuntimeBase = true;
+				applyPropsTypeArgument(classDecl, className, componentPropsShapes, componentsUsedAsJsx);
 			} else if (t.isIdentifier(classDecl.superClass, { name: "Component" })) {
 				ctx.importsNeeded.add("CompiledReactiveComponent");
 				classDecl.superClass = t.identifier("CompiledReactiveComponent");
 				usesCompiledRuntimeBase = true;
+				applyPropsTypeArgument(classDecl, className, componentPropsShapes, componentsUsedAsJsx);
 			}
 			if (usesCompiledRuntimeBase && hasAfterRenderAsyncHook && !hasOwnInstanceMethod(classDecl, "render")) {
 				ctx.importsNeeded.add("scheduleAfterRenderAsync");
@@ -6064,6 +6116,70 @@ function findClassDeclarationByName(ast, name) {
 	}
 	return null;
 }
+/**
+* Thread an inferred props shape onto the rewritten `extends CompiledXxx`
+* clause as an explicit type argument, e.g. `CompiledComponent<{ app: App }>`.
+*
+* Two guards keep this from ever emitting a WRONG type (never just an
+* incomplete one):
+*   - If the hand-written source already annotated `extends Component<...>`,
+*     that `superTypeParameters` node survives the `superClass` identifier
+*     swap above untouched — do not override the author's own type.
+*   - If the class body reads a `this.props.<key>` that the inferred shape
+*     doesn't cover (e.g. a caller in another file passes it, invisible to
+*     this per-file scan), leave the class with no type argument so it keeps
+*     the permissive `Record<string, any>` default rather than breaking.
+*
+* A class with NO JSX usage site in this file at all (a root component,
+* mounted by the runtime rather than written as `<App/>` anywhere) gets no
+* entry in `componentPropsShapes` — inference only ever runs over observed
+* call sites, so an unobserved component produces no shape, resolvable or
+* not. Falling back to the permissive `Record<string, any>` default in that
+* case isn't merely imprecise, it's backwards: silence at every call site is
+* exactly the evidence that the class takes no props, so the honest emission
+* is an explicit empty type — `{}` — not the default's promise that it might
+* accept arbitrary ones.
+*
+* Emitting that empty type is gated the same way as the shape-inference path
+* above, by the SAME two-guard standard, instantiated for the "no props"
+* claim instead of an inferred one:
+*   - `!componentsUsedAsJsx.has(className)` — the per-file JSX-usage guard.
+*     This is a per-file scan, so it cannot see a caller in ANOTHER file
+*     that writes `<App foo={x}/>`. That is sound here for a reason the
+*     general shape-inference path above does not get to rely on: the guard
+*     below additionally requires the class to read NO `this.props.<key>` at
+*     all, in its own body. A component that genuinely uses props always
+*     reads at least one, so a cross-file caller passing real data to a
+*     class that reads none of it would itself be dead-argument surface on
+*     the CALLER, not a case this class's compiled shape needs to accept.
+*     Nothing here can silently misbehave: the only externally-visible
+*     effect of a stricter-than-{} … Record<string, any> narrowing is that
+*     TypeScript itself would flag an excess/unknown prop at that other JSX
+*     call site — a loud compile error, not silent wrong behavior, and
+*     exactly the category of bug an empty props type exists to catch.
+*   - `classPropsReadsAreCovered(classDecl, <empty type>)` — reuses the
+*     existing reads-coverage guard against a zero-member shape, i.e. "this
+*     class's body contains no `this.props.<key>` read whatsoever." This is
+*     strictly stronger than the non-empty-shape case (which only requires
+*     coverage of the OBSERVED keys) — here NO key may be read, observed or
+*     not — so it still catches the shape-inference guard's original worry
+*     (a real prop consumed only via a cross-file call site) as a special
+*     case: if the body read that prop, this guard fails and the permissive
+*     default is kept, exactly as before.
+*/
+function applyPropsTypeArgument(classDecl, className, componentPropsShapes, componentsUsedAsJsx) {
+	if (classDecl.superTypeParameters) return;
+	const propsType = componentPropsShapes.get(className);
+	if (propsType) {
+		if (!classPropsReadsAreCovered(classDecl, propsType)) return;
+		classDecl.superTypeParameters = t.tsTypeParameterInstantiation([propsType]);
+		return;
+	}
+	if (componentsUsedAsJsx.has(className)) return;
+	const emptyPropsType = t.tsTypeLiteral([]);
+	if (!classPropsReadsAreCovered(classDecl, emptyPropsType)) return;
+	classDecl.superTypeParameters = t.tsTypeParameterInstantiation([emptyPropsType]);
+}
 function collectLocalClassComponents(ast) {
 	const names = /* @__PURE__ */ new Set();
 	for (const node of ast.program.body) {
@@ -6384,10 +6500,12 @@ function injectHMR(ast, componentClassNames, defaultExportClassName, componentIm
 	hmrStmts.push(js`const __moduleExports = ${t.objectExpression(exportProperties)};`);
 	hmrStmts.push(js`registerHotModule(${jsExpr`${importMeta()}.url`}, __moduleExports);`);
 	const acceptBody = [t.variableDeclaration("const", [t.variableDeclarator(t.identifier("__updatedModule"), t.logicalExpression("||", t.identifier("newModule"), t.identifier("__moduleExports")))]), t.expressionStatement(t.callExpression(t.identifier("registerHotModule"), [t.memberExpression(importMeta(), t.identifier("url")), t.identifier("__updatedModule")]))];
+	acceptBody.push(js`let __patched = false;`);
 	for (const cn of componentClassNames) {
 		const key = cn === defaultExportClassName ? "default" : cn;
-		acceptBody.push(t.expressionStatement(t.callExpression(t.identifier("handleComponentUpdate"), [t.memberExpression(importMeta(), t.identifier("url")), t.objectExpression([t.objectProperty(t.identifier("default"), t.memberExpression(t.identifier("__updatedModule"), t.identifier(key)))])])));
+		acceptBody.push(t.expressionStatement(t.assignmentExpression("=", t.identifier("__patched"), t.logicalExpression("||", t.callExpression(t.identifier("handleComponentUpdate"), [t.memberExpression(importMeta(), t.identifier("url")), t.objectExpression([t.objectProperty(t.identifier("default"), t.memberExpression(t.identifier("__updatedModule"), t.identifier(key)))])]), t.identifier("__patched")))));
 	}
+	acceptBody.push(t.ifStatement(t.unaryExpression("!", t.identifier("__patched")), t.expressionStatement(t.callExpression(t.memberExpression(hot(), t.identifier("invalidate")), []))));
 	hmrStmts.push(t.expressionStatement(t.callExpression(t.memberExpression(hot(), t.identifier("accept")), [t.arrowFunctionExpression([t.identifier("newModule")], t.blockStatement(acceptBody))])));
 	hmrStmts.push(...createAccepts(componentImports, proxyDep, shouldSkipDepAccept));
 	for (const cn of componentClassNames) {
@@ -8124,6 +8242,7 @@ function geaPlugin(options = {}) {
 	const irComponents = /* @__PURE__ */ new Map();
 	const irStores = /* @__PURE__ */ new Map();
 	const hostCapabilities = /* @__PURE__ */ new Set();
+	const staticModuleShapes = /* @__PURE__ */ new Map();
 	const storeRegistry = /* @__PURE__ */ new Map();
 	const resolveImportPath = (importer, source) => {
 		const base = resolve(dirname(importer), source);
@@ -8281,7 +8400,10 @@ function geaPlugin(options = {}) {
 			if (!cleanId.match(/\.(js|jsx|ts|tsx)$/) || cleanId.includes("node_modules")) return null;
 			let transformedCode = code;
 			let changed = false;
-			if (irOptions?.enabled) recordHostCapabilities(code);
+			if (irOptions?.enabled) {
+				recordHostCapabilities(code);
+				staticModuleShapes.set(cleanId, collectStaticModuleShape(code));
+			}
 			if (code.includes("extends Store") || code.includes("new Store(")) {
 				storeModules.add(cleanId);
 				const storeClassName = extractStoreClassName(code);
@@ -8367,7 +8489,7 @@ function geaPlugin(options = {}) {
 				map: null
 			};
 		},
-		generateBundle(_options, bundle) {
+		async generateBundle(_options, bundle) {
 			if (!irOptions?.enabled) return;
 			const renderedIds = renderedModuleIds(bundle);
 			const modules = Array.from(irModules.values()).filter((module) => {
@@ -8389,12 +8511,23 @@ function geaPlugin(options = {}) {
 					if (candidateModule && !modules.includes(candidateModule)) modules.push(candidateModule);
 				}
 			}
+			const liveComponents = Array.from(irComponents.values()).filter((component) => componentIds.has(component.id));
+			const logicalRoutes = await collectLogicalModuleRoutes({
+				entries: entryFacadeModuleIds(bundle),
+				root: resolvedConfig?.root,
+				moduleShapes: staticModuleShapes,
+				resolveModule: async (specifier, importer) => {
+					const resolved = await this.resolve(specifier, importer, { skipSelf: true });
+					return resolved && !resolved.external ? cleanRollupModuleId(resolved.id) : null;
+				}
+			});
+			const components = liveComponents.map((component) => attachRootRendererAuthority(component, logicalRoutes, staticModuleShapes));
 			const irBundle = {
 				schema: "gea-ir",
 				version: 1,
 				entry: geaIrEntryFromBundle(bundle) ?? geaIrConfiguredEntry(resolvedConfig),
 				modules,
-				components: Array.from(irComponents.values()).filter((component) => componentIds.has(component.id)),
+				components,
 				stores: Array.from(irStores.values()).filter((store) => storeIds.has(store.id)),
 				hostCapabilities: Array.from(hostCapabilities).sort()
 			};
@@ -8472,6 +8605,105 @@ function geaPlugin(options = {}) {
 		if (/\bdocument\s*\./.test(source)) hostCapabilities.add("dom");
 	}
 }
+function collectStaticModuleShape(source) {
+	const specifiers = /* @__PURE__ */ new Set();
+	const exportsByLocalName = /* @__PURE__ */ new Map();
+	const addExport = (localName, exportName) => {
+		const names = exportsByLocalName.get(localName) ?? /* @__PURE__ */ new Set();
+		names.add(exportName);
+		exportsByLocalName.set(localName, names);
+	};
+	try {
+		const ast = parse(source, {
+			sourceType: "module",
+			plugins: [
+				"typescript",
+				"jsx",
+				"classProperties",
+				"classPrivateProperties",
+				"classPrivateMethods"
+			]
+		});
+		for (const statement of ast.program.body) {
+			if ((statement.type === "ImportDeclaration" || statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") && statement.source?.value) specifiers.add(statement.source.value);
+			if (statement.type === "ExportNamedDeclaration") {
+				const declaration = statement.declaration;
+				if ((declaration?.type === "ClassDeclaration" || declaration?.type === "FunctionDeclaration") && declaration.id) addExport(declaration.id.name, declaration.id.name);
+				else if (declaration?.type === "VariableDeclaration") {
+					for (const declarator of declaration.declarations) if (declarator.id.type === "Identifier") addExport(declarator.id.name, declarator.id.name);
+				}
+				if (!statement.source) for (const specifier of statement.specifiers) {
+					if (specifier.type !== "ExportSpecifier") continue;
+					addExport(specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value, specifier.exported.type === "Identifier" ? specifier.exported.name : specifier.exported.value);
+				}
+			} else if (statement.type === "ExportDefaultDeclaration") {
+				const declaration = statement.declaration;
+				if ((declaration.type === "ClassDeclaration" || declaration.type === "FunctionDeclaration") && declaration.id) addExport(declaration.id.name, "default");
+				else if (declaration.type === "Identifier") addExport(declaration.name, "default");
+			}
+		}
+	} catch {}
+	return {
+		specifiers: [...specifiers].sort(),
+		exportsByLocalName: new Map([...exportsByLocalName].map(([localName, exportNames]) => [localName, new Set([...exportNames].sort())]))
+	};
+}
+/** Logical source coordinates are relative to the project, never to its checkout. */
+async function collectLogicalModuleRoutes(input) {
+	let root = input.root ?? (input.entries[0] ? dirname(input.entries[0]) : "/");
+	if (!input.root) while (input.entries.some((entry) => relative(root, entry).startsWith("../"))) root = dirname(root);
+	const routes = /* @__PURE__ */ new Map();
+	const owners = /* @__PURE__ */ new Map();
+	const pending = [];
+	const add = (moduleId, fallback) => {
+		moduleId = cleanRollupModuleId(moduleId);
+		if (routes.has(moduleId)) return;
+		const local = relative(root, moduleId).replace(/\\/g, "/");
+		const route = !local.startsWith("../") && !moduleId.startsWith("\0") ? `/${local}` : fallback;
+		if (!route) return;
+		const owner = owners.get(route);
+		if (owner && owner !== moduleId) throw new Error(`Ambiguous Gea renderer module coordinate: ${route}`);
+		owners.set(route, moduleId);
+		routes.set(moduleId, new Set([route]));
+		pending.push(moduleId);
+	};
+	for (const entry of input.entries) add(entry, `/${relative(root, entry).replace(/\\/g, "/")}`);
+	while (pending.length > 0) {
+		const moduleId = pending.shift();
+		const route = [...routes.get(moduleId)][0];
+		for (const specifier of input.moduleShapes.get(moduleId)?.specifiers ?? []) {
+			const target = await input.resolveModule(specifier, moduleId);
+			if (!target) continue;
+			add(target, specifier.startsWith("./") || specifier.startsWith("../") ? posix.join(posix.dirname(route), specifier) : specifier.startsWith("/") ? null : `/@modules/${specifier}`);
+		}
+	}
+	return routes;
+}
+function attachRootRendererAuthority(component, logicalRoutes, moduleShapes) {
+	const moduleId = cleanRollupModuleId(component.module);
+	const routes = logicalRoutes.get(moduleId);
+	const exportNames = moduleShapes.get(moduleId)?.exportsByLocalName.get(component.exportName);
+	if (!routes?.size || !exportNames?.size) return component;
+	const candidates = [...routes].flatMap((moduleSpecifier) => [...exportNames].map((exportName) => ({
+		moduleSpecifier,
+		exportName
+	})));
+	candidates.sort((left, right) => {
+		return (left.exportName === component.exportName ? 0 : 1) - (right.exportName === component.exportName ? 0 : 1) || left.moduleSpecifier.length - right.moduleSpecifier.length || `${left.moduleSpecifier}#${left.exportName}`.localeCompare(`${right.moduleSpecifier}#${right.exportName}`);
+	});
+	const coordinate = candidates[0];
+	const digest = createHash("sha256").update(`${coordinate.moduleSpecifier}\u0000${coordinate.exportName}`).digest("hex");
+	return {
+		...component,
+		rootRendererAuthority: {
+			component: coordinate,
+			rendererResourceId: `gea-renderer:v1:${digest}`
+		}
+	};
+}
+function entryFacadeModuleIds(bundle) {
+	return Object.values(bundle).filter((item) => item.type === "chunk" && item.isEntry && item.facadeModuleId).map((item) => cleanRollupModuleId(item.facadeModuleId)).sort();
+}
 function renderedModuleIds(bundle) {
 	const ids = /* @__PURE__ */ new Set();
 	for (const item of Object.values(bundle)) {
@@ -8524,7 +8756,29 @@ function compilerRuntimePathFromCoreEntry(entry) {
 	if (clean.endsWith("/dist/index.mjs")) return clean.slice(0, -15) + "/dist/compiler-runtime.mjs";
 	return null;
 }
+function compilerRuntimeExportLines(runtimePath) {
+	if (!runtimePath.endsWith(".ts")) return null;
+	let source;
+	try {
+		source = readFileSync(runtimePath, "utf8");
+	} catch {
+		return null;
+	}
+	const dir = dirname(runtimePath);
+	const lines = [];
+	const EXPORT_FROM_RE = /export\s*\{([^}]*)\}\s*from\s*['"](\.[^'"]+)['"]/g;
+	let match;
+	while (match = EXPORT_FROM_RE.exec(source)) {
+		const names = match[1];
+		const relativeSpecifier = match[2];
+		const absoluteSpecifier = normalizeImportPath(resolve(dir, relativeSpecifier));
+		lines.push(`export {${names}} from ${JSON.stringify(absoluteSpecifier)}`);
+	}
+	return lines.length > 0 ? lines : null;
+}
 function compilerRuntimeSource(runtimePath) {
+	const perSubmoduleLines = compilerRuntimeExportLines(runtimePath);
+	if (perSubmoduleLines) return `${perSubmoduleLines.join("\n")}\n`;
 	const path = normalizeImportPath(runtimePath);
 	return `export {
   NOOP_DISPOSER,
@@ -8567,6 +8821,7 @@ function compilerRuntimeSource(runtimePath) {
   GEA_DIRTY_PROPS,
   createItemObservable,
   createItemProxy,
+  readItem,
   _rescue,
   GEA_CREATE_TEMPLATE,
   GEA_PARENT_COMPONENT,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geajs/vite-plugin",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "Vite plugin for Gea framework - JSX/TSX transform, reactivity, HMR",
   "type": "module",
   "main": "./dist/index.mjs",