@geajs/vite-plugin 1.3.0 → 1.4.0

package/dist/index.mjs

@@ -3,7 +3,7 @@ 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, readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 //#region src/utils/babel-interop.ts
@@ -84,15 +84,27 @@ function parseSource(code) {
 				name = t.isIdentifier(varDecl.id) ? varDecl.id.name : null;
 				returnsJSX = nodeReturnsJSX(init.body);
 			}
-			if (name && returnsJSX) functionalComponentInfo = { name };
+			if (name && returnsJSX) functionalComponentInfo = {
+				name,
+				kind: "default"
+			};
 		},
 		ExportNamedDeclaration(path) {
 			const decl = path.node.declaration;
 			if (!decl) return;
-			if (t.isFunctionDeclaration(decl) && decl.id) throwIfReturnsJSX(decl.id.name, decl.body);
+			const registerNamed = (name) => {
+				if (functionalComponentInfo) return;
+				functionalComponentInfo = {
+					name,
+					kind: "named"
+				};
+			};
+			if (t.isFunctionDeclaration(decl) && decl.id && nodeReturnsJSX(decl.body)) registerNamed(decl.id.name);
 			else if (t.isVariableDeclaration(decl)) for (const declarator of decl.declarations) {
 				if (!t.isIdentifier(declarator.id) || !declarator.init) continue;
-				if (t.isArrowFunctionExpression(declarator.init) || t.isFunctionExpression(declarator.init)) throwIfReturnsJSX(declarator.id.name, declarator.init.body);
+				if (t.isArrowFunctionExpression(declarator.init) || t.isFunctionExpression(declarator.init)) {
+					if (nodeReturnsJSX(declarator.init.body)) registerNamed(declarator.id.name);
+				}
 			}
 		},
 		JSXElement() {
@@ -129,48 +141,44 @@ function bodyReturnsJSX(block) {
 	const ret = block.body.find((s) => t.isReturnStatement(s) && s.argument != null);
 	return !!ret && nodeReturnsJSX(ret.argument);
 }
-/** Throw a compile error if a named export returns JSX. */
-function throwIfReturnsJSX(name, body) {
-	if (nodeReturnsJSX(body)) {
-		const err = /* @__PURE__ */ new Error(`[gea] Named JSX component export '${name}' is not supported. Use 'export default' or convert to a class extending Component. Only one component per file is allowed.`);
-		err.__geaCompileError = true;
-		throw err;
-	}
-}
 //#endregion
 //#region src/preprocess/functional-to-class.ts
 /**
-* Converts a functional component default export into a class-based Gea component.
+* Converts a functional component into a class-based Gea component.
 *
-* Supports:
+* Default-export variants:
 * - `export default function Foo(props) { return <div/> }`
 * - `export default (props) => <div/>`
 * - `const Foo = (props) => <div/>; export default Foo`
 *
-* The result is:
-* ```
-* class Foo extends Component { template(props) { return <div/> } }
-* export default Foo
-* ```
+* Named-export variants (info.kind === 'named'):
+* - `export function Foo(props) { return <div/> }`
+* - `export const Foo = (props) => <div/>`
+*
+* The result preserves the export shape:
+* - default → `class Foo extends Component { template(props) { ... } }
+*              export default Foo`
+* - named   → `export class Foo extends Component { template(props) { ... } }`
 *
 * Mutates the AST in place.
 */
 function convertFunctionalToClass(ast, info, imports) {
 	const name = info.name;
+	const kind = info.kind ?? "default";
 	let params = [t.identifier("props")];
 	let templateBody = [];
 	let removeVarDeclPath = null;
 	let exportPath = null;
-	traverse(ast, { ExportDefaultDeclaration(path) {
+	const extractFunction = (fn) => {
+		if (fn.params.length > 0) params = fn.params.map((p) => t.cloneNode(p));
+		if (t.isBlockStatement(fn.body)) {
+			const returnIdx = fn.body.body.findIndex((s) => t.isReturnStatement(s) && s.argument);
+			if (returnIdx >= 0) templateBody = fn.body.body.slice(0, returnIdx + 1).map((s) => t.cloneNode(s));
+		} else templateBody = [t.returnStatement(t.cloneNode(fn.body))];
+	};
+	if (kind === "default") traverse(ast, { ExportDefaultDeclaration(path) {
 		exportPath = path;
 		const decl = path.node.declaration;
-		const extractFunction = (fn) => {
-			if (fn.params.length > 0) params = fn.params.map((p) => t.cloneNode(p));
-			if (t.isBlockStatement(fn.body)) {
-				const returnIdx = fn.body.body.findIndex((s) => t.isReturnStatement(s) && s.argument);
-				if (returnIdx >= 0) templateBody = fn.body.body.slice(0, returnIdx + 1).map((s) => t.cloneNode(s));
-			} else templateBody = [t.returnStatement(t.cloneNode(fn.body))];
-		};
 		if (t.isFunctionDeclaration(decl)) extractFunction(decl);
 		else if (t.isArrowFunctionExpression(decl)) extractFunction(decl);
 		else if (t.isIdentifier(decl)) {
@@ -184,6 +192,23 @@ function convertFunctionalToClass(ast, info, imports) {
 		}
 		path.stop();
 	} });
+	else traverse(ast, { ExportNamedDeclaration(path) {
+		const decl = path.node.declaration;
+		if (!decl) return;
+		if (t.isFunctionDeclaration(decl) && decl.id?.name === name) {
+			exportPath = path;
+			extractFunction(decl);
+			path.stop();
+		} else if (t.isVariableDeclaration(decl)) for (const declarator of decl.declarations) {
+			if (!t.isIdentifier(declarator.id, { name }) || !declarator.init) continue;
+			if (t.isArrowFunctionExpression(declarator.init) || t.isFunctionExpression(declarator.init)) {
+				exportPath = path;
+				extractFunction(declarator.init);
+				path.stop();
+				return;
+			}
+		}
+	} });
 	if (templateBody.length === 0 || !exportPath) return;
 	const firstParam = params[0];
 	const firstStmt = templateBody[0];
@@ -200,7 +225,7 @@ function convertFunctionalToClass(ast, info, imports) {
 	if (removeVarDeclPath) removeVarDeclPath.remove();
 	const program = ast.program;
 	const idx = program.body.indexOf(exportPath.node);
-	if (idx >= 0) program.body[idx] = t.exportDefaultDeclaration(classDecl);
+	if (idx >= 0) program.body[idx] = kind === "named" ? t.exportNamedDeclaration(classDecl, []) : t.exportDefaultDeclaration(classDecl);
 }
 function ensureComponentImport(ast, imports) {
 	if (imports.get("Component")) return;
@@ -788,6 +813,54 @@ function tryExtractPathAndRoot(expr) {
 	return null;
 }
 //#endregion
+//#region src/closure-codegen/generator/generator-jsx-helpers.ts
+/** True for JSX elements, fragments, null, undefined, or string literals (things that can be rendered in a branch). */
+function isJsxOrNullish(n) {
+	if (t.isJSXElement(n) || t.isJSXFragment(n)) return true;
+	if (t.isNullLiteral(n)) return true;
+	if (t.isIdentifier(n, { name: "undefined" })) return true;
+	return false;
+}
+/** True when `n` is `<expr>.map(arrow)` where the arrow's body returns JSX
+*  (directly or via a `return` in a BlockStatement). Used by the `&&` arm
+*  to promote `cond && xs.map(x => <JSX/>)` to a conditional slot whose
+*  truthy branch is a keyed-list. */
+function isMapWithJsxBody(n) {
+	if (!t.isCallExpression(n) && !t.isOptionalCallExpression(n)) return false;
+	const callee = n.callee;
+	if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee)) return false;
+	if (callee.computed) return false;
+	if (!t.isIdentifier(callee.property, { name: "map" })) return false;
+	const arg = n.arguments[0];
+	if (!arg) return false;
+	if (!t.isArrowFunctionExpression(arg) && !t.isFunctionExpression(arg)) return false;
+	const body = arg.body;
+	if (t.isJSXElement(body) || t.isJSXFragment(body)) return true;
+	if (t.isBlockStatement(body)) {
+		const ret = body.body.find((s) => t.isReturnStatement(s));
+		if (ret && ret.argument && (t.isJSXElement(ret.argument) || t.isJSXFragment(ret.argument))) return true;
+	}
+	return false;
+}
+/**
+* Check if a class declaration has a `template()` method and return it.
+* Returns null if the class does not have a template method (non-component).
+*/
+function findTemplateMethod(classDecl) {
+	for (const member of classDecl.body.body) if (t.isClassMethod(member) && t.isIdentifier(member.key, { name: "template" }) && !member.computed && !member.static) return member;
+	return null;
+}
+/**
+* Extract the JSX root from a template() method. The method body is expected to
+* be `template() { return <jsx />; }` — possibly with prop destructuring.
+*/
+function extractTemplateJsx(templateMethod) {
+	for (const stmt of templateMethod.body.body) if (t.isReturnStatement(stmt) && stmt.argument) {
+		if (t.isJSXElement(stmt.argument) || t.isJSXFragment(stmt.argument)) return stmt.argument;
+	}
+	return null;
+}
+//#endregion
 //#region src/closure-codegen/emit/emit-conditional.ts
 function emitConditionalSlot(slot, stmts, ctx) {
 	const anchorId = t.identifier("anchor" + slot.index);
@@ -828,6 +901,10 @@ function buildBranchFn(branchExpr, ctx) {
 		const block = compileJsxToBlock(branchExpr, ctx);
 		return t.arrowFunctionExpression([t.identifier("d")], block);
 	}
+	if (isNestableConditionalExpression(branchExpr)) {
+		const block = compileJsxToBlock(t.jsxFragment(t.jsxOpeningFragment(), t.jsxClosingFragment(), [t.jsxExpressionContainer(branchExpr)]), ctx);
+		return t.arrowFunctionExpression([t.identifier("d")], block);
+	}
 	if (t.isCallExpression(branchExpr) && branchExpr.arguments.length === 0 && branchExpr.callee.__geaHoistedIIFE && t.isBlockStatement(branchExpr.callee.body)) {
 		const block = branchExpr.callee.body;
 		const last = block.body[block.body.length - 1];
@@ -852,6 +929,11 @@ function buildBranchFn(branchExpr, ctx) {
 	if (t.isCallExpression(substituted) && t.isMemberExpression(substituted.callee) && !substituted.callee.computed && t.isIdentifier(substituted.callee.property, { name: "map" }) && substituted.arguments.length >= 1 && (t.isArrowFunctionExpression(substituted.arguments[0]) || t.isFunctionExpression(substituted.arguments[0]))) return buildMapBranchFn(substituted, ctx);
 	return t.arrowFunctionExpression([t.identifier("d")], t.callExpression(t.memberExpression(t.identifier("document"), t.identifier("createComment")), [t.stringLiteral("")]));
 }
+function isNestableConditionalExpression(node) {
+	if (t.isConditionalExpression(node)) return isJsxOrNullish(node.consequent) || isJsxOrNullish(node.alternate);
+	if (t.isLogicalExpression(node) && node.operator === "&&") return isJsxOrNullish(node.right);
+	return false;
+}
 /**
 * Build a branch fn for a bare `xs.map(item => <jsx/>)` expression. Creates a
 * `<span style="display:contents">` wrapper, inserts a comment anchor inside,
@@ -1636,6 +1718,7 @@ function createItemBodyReferencesItemInReactiveGetter(fn, itemName) {
 		"reactiveBoolAttr",
 		"reactiveClass",
 		"reactiveStyle",
+		"reactiveStyleProp",
 		"reactiveValue",
 		"reactiveValueRead"
 	]);
@@ -2164,6 +2247,66 @@ const INLINE_PROP_LIST_SOURCE = `{
   }
   let __kl_prev = __kl_first;
   const __kl_reconcile = (arr, changes) => {
+    if (!Array.isArray(arr)) arr = [];
+    if (changes && changes.length > 0) {
+      let aipuPatchable = true;
+      for (let i = 0; i < changes.length; i++) {
+        const change = changes[i];
+        const idx = change.arix;
+        if (!change.aipu || idx < 0 || idx >= __kl_entries.length || (!change.itemDirty && __kl_entries[idx].key !== __kl_key(change.newValue, idx))) {
+          aipuPatchable = false;
+          break;
+        }
+      }
+      if (aipuPatchable) {
+        for (let i = 0; i < changes.length; i++) {
+          const idx = changes[i].arix;
+          let superseded = false;
+          for (let j = i + 1; j < changes.length; j++) {
+            if (changes[j].arix === idx) {
+              superseded = true;
+              break;
+            }
+          }
+          if (superseded) continue;
+          const item = changes[i].newValue;
+          __kl_patch(__kl_entries[idx], item, idx);
+          if (item && typeof item === "object") {
+            item[GEA_DIRTY] = false;
+            item[GEA_DIRTY_PROPS]?.clear();
+          }
+          __kl_entries[idx].item = __kl_unwrap(item);
+          if (__kl_prev && __kl_prev.length === __kl_entries.length) __kl_prev[idx] = __kl_unwrap(item);
+        }
+        return;
+      }
+      let dirtyOnly = true;
+      for (let i = 0; i < changes.length; i++) {
+        const change = changes[i];
+        if (change.aipu || change.type === "append" || change.type === "remove" || change.type === "delete" || change.type === "reorder") {
+          dirtyOnly = false;
+          break;
+        }
+      }
+      if (dirtyOnly) {
+        const raw = arr[GEA_PROXY_RAW] || arr;
+        if (__kl_entries.length === arr.length) {
+          let patched = false;
+          for (let i = 0; i < raw.length; i++) {
+            const item = raw[i];
+            if (item && typeof item === "object" && item[GEA_DIRTY]) {
+              __kl_patch(__kl_entries[i], item, i);
+              item[GEA_DIRTY] = false;
+              item[GEA_DIRTY_PROPS]?.clear();
+              __kl_entries[i].item = item;
+              patched = true;
+            }
+          }
+          if (patched) return;
+        }
+      }
+    }
+    const raw = arr[GEA_PROXY_RAW] || arr;
     if (arr === __kl_prev && __kl_entries.length === arr.length) {
       let structural = false;
       let aipuOnly = changes && changes.length > 0;
@@ -2202,7 +2345,6 @@ const INLINE_PROP_LIST_SOURCE = `{
         }
       }
       if (!structural) {
-        const raw = arr[GEA_PROXY_RAW] || arr;
         for (let i = 0; i < raw.length; i++) {
           const item = raw[i];
           if (item && typeof item === "object" && item[GEA_DIRTY]) {
@@ -2347,7 +2489,14 @@ const INLINE_PROP_LIST_SOURCE = `{
     if (oldLen > 0 && newLen > 0 && __kl_container.childNodes.length === oldLen + (__kl_anchor ? 1 : 0)) {
       let disjoint = true;
       for (let i = 0; i < newLen; i++) {
-        if (__kl_byKey.has(newKeys[i])) {
+        let existing = null;
+        for (let j = 0; j < oldLen; j++) {
+          if (__kl_entries[j].key === newKeys[i]) {
+            existing = __kl_entries[j];
+            break;
+          }
+        }
+        if (existing) {
           disjoint = false;
           break;
         }
@@ -2375,7 +2524,13 @@ const INLINE_PROP_LIST_SOURCE = `{
     const seenOld = new Array(oldLen).fill(false);
     const nextEntries = new Array(newLen);
     for (let i = 0; i < newLen; i++) {
-      const entry = __kl_byKey.get(newKeys[i]);
+      let entry = null;
+      for (let j = 0; j < oldLen; j++) {
+        if (__kl_entries[j].key === newKeys[i]) {
+          entry = __kl_entries[j];
+          break;
+        }
+      }
       if (entry) {
         const oldIdx = entry._i;
         seenOld[oldIdx] = true;
@@ -2404,7 +2559,7 @@ const INLINE_PROP_LIST_SOURCE = `{
 
   if (__kl_root && typeof __kl_root.observe === "function") {
     const off = __kl_root.observe(__PROP__, (_value, changes) => {
-      __kl_reconcile(__kl_resolve(), changes);
+      __kl_reconcile(_value, changes);
     });
     d.add(off);
   }
@@ -2429,6 +2584,7 @@ const INLINE_PROP_LIST_COMPACT_ANCHORLESS_BLOCK = parse(`{
   };
   let __kl_prev = __kl_resolve();
   let __kl_reconcile = (arr, changes) => {
+    if (!Array.isArray(arr)) arr = [];
     if (arr.length === 0) {
       __kl_prev = arr;
       return;
@@ -2475,6 +2631,65 @@ const INLINE_PROP_LIST_COMPACT_ANCHORLESS_BLOCK = parse(`{
       __kl_entries = nextEntries;
     };
     const __kl_real_reconcile = (arr, changes) => {
+      if (!Array.isArray(arr)) arr = [];
+      if (changes && changes.length > 0) {
+        let aipuPatchable = true;
+        for (let i = 0; i < changes.length; i++) {
+          const change = changes[i];
+          const idx = change.arix;
+          if (!change.aipu || idx < 0 || idx >= __kl_entries.length || (!change.itemDirty && __kl_entries[idx].key !== change.newValue.id)) {
+            aipuPatchable = false;
+            break;
+          }
+        }
+        if (aipuPatchable) {
+          for (let i = 0; i < changes.length; i++) {
+            const idx = changes[i].arix;
+            let superseded = false;
+            for (let j = i + 1; j < changes.length; j++) {
+              if (changes[j].arix === idx) {
+                superseded = true;
+                break;
+              }
+            }
+            if (superseded) continue;
+            const item = changes[i].newValue;
+            __kl_patch(__kl_entries[idx], item, idx);
+            if (item && typeof item === "object") {
+              item[GEA_DIRTY] = false;
+              item[GEA_DIRTY_PROPS]?.clear();
+            }
+            __kl_entries[idx].item = __kl_raw(item);
+            if (__kl_prev && __kl_prev.length === __kl_entries.length) __kl_prev[idx] = __kl_raw(item);
+          }
+          return;
+        }
+        let dirtyOnly = true;
+        for (let i = 0; i < changes.length; i++) {
+          const change = changes[i];
+          if (change.aipu || change.type === "append" || change.type === "remove" || change.type === "delete" || change.type === "reorder") {
+            dirtyOnly = false;
+            break;
+          }
+        }
+        if (dirtyOnly) {
+          const raw = __kl_raw(arr);
+          if (__kl_entries.length === arr.length) {
+            let patched = false;
+            for (let i = 0; i < raw.length; i++) {
+              const item = raw[i];
+              if (item && typeof item === "object" && item[GEA_DIRTY]) {
+                __kl_patch(__kl_entries[i], item, i);
+                item[GEA_DIRTY] = false;
+                item[GEA_DIRTY_PROPS]?.clear();
+                __kl_entries[i].item = item;
+                patched = true;
+              }
+            }
+            if (patched) return;
+          }
+        }
+      }
       const raw = __kl_raw(arr);
       if (arr === __kl_prev && __kl_entries.length === arr.length) {
         let structural = false;
@@ -2577,7 +2792,7 @@ const INLINE_PROP_LIST_COMPACT_ANCHORLESS_BLOCK = parse(`{
 
   if (__kl_root && typeof __kl_root.observe === "function") {
     const off = __kl_root.observe(__PROP__, (_value, changes) => {
-      __kl_reconcile(__kl_resolve(), changes);
+      __kl_reconcile(_value, changes);
     });
     d.add(off);
   }
@@ -2625,6 +2840,65 @@ const INLINE_PROP_LIST_COMPONENT_SOURCE = `{
   }
   let __kl_prev = __kl_first;
   const __kl_reconcile = (arr, changes) => {
+    if (!Array.isArray(arr)) arr = [];
+    if (changes && changes.length > 0) {
+      let aipuPatchable = true;
+      for (let i = 0; i < changes.length; i++) {
+        const change = changes[i];
+        const idx = change.arix;
+        if (!change.aipu || idx < 0 || idx >= __kl_entries.length || (!change.itemDirty && __kl_entries[idx].key !== __kl_key(change.newValue, idx))) {
+          aipuPatchable = false;
+          break;
+        }
+      }
+      if (aipuPatchable) {
+        for (let i = 0; i < changes.length; i++) {
+          const idx = changes[i].arix;
+          let superseded = false;
+          for (let j = i + 1; j < changes.length; j++) {
+            if (changes[j].arix === idx) {
+              superseded = true;
+              break;
+            }
+          }
+          if (superseded) continue;
+          const item = changes[i].newValue;
+          __kl_patch(__kl_entries[idx], item, idx);
+          if (item && typeof item === "object") {
+            item[GEA_DIRTY] = false;
+            item[GEA_DIRTY_PROPS]?.clear();
+          }
+          __kl_entries[idx].item = __kl_raw(item);
+          if (__kl_prev && __kl_prev.length === __kl_entries.length) __kl_prev[idx] = __kl_raw(item);
+        }
+        return;
+      }
+      let dirtyOnly = true;
+      for (let i = 0; i < changes.length; i++) {
+        const change = changes[i];
+        if (change.aipu || change.type === "append" || change.type === "remove" || change.type === "delete" || change.type === "reorder") {
+          dirtyOnly = false;
+          break;
+        }
+      }
+      if (dirtyOnly) {
+        const raw = __kl_raw(arr);
+        if (__kl_entries.length === arr.length) {
+          let patched = false;
+          for (let i = 0; i < raw.length; i++) {
+            const item = raw[i];
+            if (item && typeof item === "object" && item[GEA_DIRTY]) {
+              __kl_patch(__kl_entries[i], item, i);
+              item[GEA_DIRTY] = false;
+              item[GEA_DIRTY_PROPS]?.clear();
+              __kl_entries[i].item = item;
+              patched = true;
+            }
+          }
+          if (patched) return;
+        }
+      }
+    }
     const raw = __kl_raw(arr);
     if (arr === __kl_prev && __kl_entries.length === arr.length) {
       let structural = false;
@@ -2689,7 +2963,7 @@ const INLINE_PROP_LIST_COMPONENT_SOURCE = `{
   };
   if (__kl_root && typeof __kl_root.observe === "function") {
     const off = __kl_root.observe(__PROP__, (_value, changes) => {
-      __kl_reconcile(__kl_resolve(), changes);
+      __kl_reconcile(_value, changes);
     });
     d.add(off);
   }
@@ -2703,11 +2977,11 @@ const INLINE_PROP_LIST_COMPONENT_ANCHORLESS_BLOCK = parse(INLINE_PROP_LIST_COMPO
 	sourceType: "module",
 	plugins: ["optionalChaining"]
 }).program.body[0];
-const INLINE_PROP_LIST_COMPONENT_ID_BLOCK = parse(INLINE_PROP_LIST_COMPONENT_SOURCE.replace("  const __kl_key = __KEY__;\n", "").replace("__kl_byKey.get(__kl_key(arr[i], i))", "__kl_byKey.get(arr[i].id)"), {
+const INLINE_PROP_LIST_COMPONENT_ID_BLOCK = parse(INLINE_PROP_LIST_COMPONENT_SOURCE.replace("  const __kl_key = __KEY__;\n", "").replace("__kl_byKey.get(__kl_key(arr[i], i))", "__kl_byKey.get(arr[i].id)").replaceAll("__kl_key(change.newValue, idx)", "change.newValue.id"), {
 	sourceType: "module",
 	plugins: ["optionalChaining"]
 }).program.body[0];
-const INLINE_PROP_LIST_COMPONENT_ID_ANCHORLESS_BLOCK = parse(INLINE_PROP_LIST_COMPONENT_ANCHORLESS_SOURCE.replace("  const __kl_key = __KEY__;\n", "").replace("__kl_byKey.get(__kl_key(arr[i], i))", "__kl_byKey.get(arr[i].id)"), {
+const INLINE_PROP_LIST_COMPONENT_ID_ANCHORLESS_BLOCK = parse(INLINE_PROP_LIST_COMPONENT_ANCHORLESS_SOURCE.replace("  const __kl_key = __KEY__;\n", "").replace("__kl_byKey.get(__kl_key(arr[i], i))", "__kl_byKey.get(arr[i].id)").replaceAll("__kl_key(change.newValue, idx)", "change.newValue.id"), {
 	sourceType: "module",
 	plugins: ["optionalChaining"]
 }).program.body[0];
@@ -3405,54 +3679,6 @@ function normalizeEventAttrName(name) {
 	return toGeaEventType(name);
 }
 //#endregion
-//#region src/closure-codegen/generator/generator-jsx-helpers.ts
-/** True for JSX elements, fragments, null, undefined, or string literals (things that can be rendered in a branch). */
-function isJsxOrNullish(n) {
-	if (t.isJSXElement(n) || t.isJSXFragment(n)) return true;
-	if (t.isNullLiteral(n)) return true;
-	if (t.isIdentifier(n, { name: "undefined" })) return true;
-	return false;
-}
-/** True when `n` is `<expr>.map(arrow)` where the arrow's body returns JSX
-*  (directly or via a `return` in a BlockStatement). Used by the `&&` arm
-*  to promote `cond && xs.map(x => <JSX/>)` to a conditional slot whose
-*  truthy branch is a keyed-list. */
-function isMapWithJsxBody(n) {
-	if (!t.isCallExpression(n) && !t.isOptionalCallExpression(n)) return false;
-	const callee = n.callee;
-	if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee)) return false;
-	if (callee.computed) return false;
-	if (!t.isIdentifier(callee.property, { name: "map" })) return false;
-	const arg = n.arguments[0];
-	if (!arg) return false;
-	if (!t.isArrowFunctionExpression(arg) && !t.isFunctionExpression(arg)) return false;
-	const body = arg.body;
-	if (t.isJSXElement(body) || t.isJSXFragment(body)) return true;
-	if (t.isBlockStatement(body)) {
-		const ret = body.body.find((s) => t.isReturnStatement(s));
-		if (ret && ret.argument && (t.isJSXElement(ret.argument) || t.isJSXFragment(ret.argument))) return true;
-	}
-	return false;
-}
-/**
-* Check if a class declaration has a `template()` method and return it.
-* Returns null if the class does not have a template method (non-component).
-*/
-function findTemplateMethod(classDecl) {
-	for (const member of classDecl.body.body) if (t.isClassMethod(member) && t.isIdentifier(member.key, { name: "template" }) && !member.computed && !member.static) return member;
-	return null;
-}
-/**
-* Extract the JSX root from a template() method. The method body is expected to
-* be `template() { return <jsx />; }` — possibly with prop destructuring.
-*/
-function extractTemplateJsx(templateMethod) {
-	for (const stmt of templateMethod.body.body) if (t.isReturnStatement(stmt) && stmt.argument) {
-		if (t.isJSXElement(stmt.argument) || t.isJSXFragment(stmt.argument)) return stmt.argument;
-	}
-	return null;
-}
-//#endregion
 //#region src/closure-codegen/generator/walk.ts
 const OPTIONAL_TABLE_END_TAGS = new Set([
 	"colgroup",
@@ -3910,13 +4136,31 @@ function emitSlot(slot, stmts, ctx) {
 				pathOrGetter.value
 			])));
 		} else if (slot.kind === "style") {
-			ctx.importsNeeded.add("reactiveStyle");
-			stmts.push(t.expressionStatement(t.callExpression(t.identifier("reactiveStyle"), [
-				elId,
-				t.identifier("d"),
-				ctx.reactiveRoot,
-				pathOrGetter.value
-			])));
+			const styleExpr = slot.expr;
+			const styleProps = t.isObjectExpression(styleExpr) && styleExpr.properties.length > 0 ? styleExpr.properties : null;
+			if (styleProps !== null && styleProps.every((p) => t.isObjectProperty(p) && !p.computed && (t.isIdentifier(p.key) || t.isStringLiteral(p.key)))) {
+				ctx.importsNeeded.add("reactiveStyleProp");
+				for (const p of styleProps) {
+					const keyName = t.isIdentifier(p.key) ? p.key.name : p.key.value;
+					const kebabKey = String(keyName).replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+					const valSource = expressionToPathOrGetter(p.value, ctx);
+					stmts.push(t.expressionStatement(t.callExpression(t.identifier("reactiveStyleProp"), [
+						elId,
+						t.identifier("d"),
+						ctx.reactiveRoot,
+						t.stringLiteral(kebabKey),
+						valSource.value
+					])));
+				}
+			} else {
+				ctx.importsNeeded.add("reactiveStyle");
+				stmts.push(t.expressionStatement(t.callExpression(t.identifier("reactiveStyle"), [
+					elId,
+					t.identifier("d"),
+					ctx.reactiveRoot,
+					pathOrGetter.value
+				])));
+			}
 		} else if (slot.kind === "value") {
 			ctx.importsNeeded.add("reactiveValueRead");
 			stmts.push(t.expressionStatement(t.callExpression(t.identifier("reactiveValueRead"), [
@@ -4107,37 +4351,742 @@ function isOneShotStringPropLocal(expr, ctx) {
 	return t.isIdentifier(expr) && ctx.oneShotStringPropLocals?.has(expr.name) === true;
 }
 //#endregion
-//#region src/closure-codegen/emit/emit-core.ts
-function compileJsxToBlock(jsxRoot, ctx) {
-	const spec = walkJsxToTemplate(jsxRoot, {
-		emitEventDataAttr: false,
-		directFnComponents: ctx.directFnComponents,
-		bindings: ctx.bindings
-	});
-	if (t.isJSXFragment(jsxRoot)) spec.html = "<span style=\"display:contents\">" + spec.html + "</span>";
-	else if (!spec.html.startsWith("<") || spec.html.startsWith("<!--")) {
-		spec.html = "<span style=\"display:contents\">" + spec.html + "</span>";
-		for (const slot of spec.slots) slot.walk = [0, ...slot.walk];
+//#region src/closure-codegen/ir.ts
+function componentIrId(moduleId, exportName) {
+	return `${moduleId}#${exportName}`;
+}
+function storeIrId(moduleId, className) {
+	return `${moduleId}#${className}`;
+}
+function templateSpecToIr(spec, bindings = /* @__PURE__ */ new Map()) {
+	return {
+		html: spec.html,
+		slots: spec.slots.map((slot) => slotToIr(slot, bindings))
+	};
+}
+function storeFieldsToIr(classDecl) {
+	const fields = [];
+	for (const member of classDecl.body.body) {
+		if (!t.isClassProperty(member) || member.static || member.computed || !t.isIdentifier(member.key)) continue;
+		const field = {
+			name: member.key.name,
+			...member.value ? { initializer: generate(member.value).code } : {},
+			...member.value ? shapeForExpression(member.value) : {}
+		};
+		if (field.shape?.kind === "array") {
+			const elementTypeName = arrayElementTypeNameFromAnnotation(member);
+			if (elementTypeName) field.shape = {
+				...field.shape,
+				elementTypeName
+			};
+		}
+		fields.push(field);
 	}
-	const tplName = "_tpl" + ctx.tplCounter++;
-	ctx.templateDecls.push(...emitTemplateDecl(spec.html, tplName));
-	const stmts = [];
-	stmts.push(t.variableDeclaration("const", [t.variableDeclarator(t.identifier("root"), emitTemplateCloneExpression(tplName, spec.html))]));
-	const walkCache = /* @__PURE__ */ new Map();
-	for (const slot of spec.slots) emitWalkCapture(slot, stmts, false, walkCache);
-	const savedPending = ctx._pendingEvents;
-	const savedInputValueExprByEventSlot = ctx._inputValueExprByEventSlot;
-	const savedDocumentClickDelegateInstalled = ctx._documentClickDelegateInstalled;
-	ctx._pendingEvents = [];
-	ctx._inputValueExprByEventSlot = findInputValueReconciliations(spec);
-	ctx._documentClickDelegateInstalled = false;
-	for (const slot of spec.slots) emitSlot(slot, stmts, ctx);
-	const events = ctx._pendingEvents;
-	ctx._pendingEvents = savedPending;
-	ctx._inputValueExprByEventSlot = savedInputValueExprByEventSlot;
-	if (events.length > 0) {
-		const groups = /* @__PURE__ */ new Map();
-		for (const e of events) {
+	return fields;
+}
+function arrayElementTypeNameFromAnnotation(member) {
+	const annotation = member.typeAnnotation;
+	if (!annotation || !t.isTSTypeAnnotation(annotation)) return void 0;
+	return arrayElementTypeNameFromTSType(annotation.typeAnnotation);
+}
+function arrayElementTypeNameFromTSType(typeNode) {
+	if (t.isTSArrayType(typeNode)) {
+		const element = typeNode.elementType;
+		if (t.isTSTypeReference(element) && t.isIdentifier(element.typeName)) return element.typeName.name;
+		return;
+	}
+	if (t.isTSTypeReference(typeNode) && t.isIdentifier(typeNode.typeName)) {
+		const containerName = typeNode.typeName.name;
+		if (containerName !== "Array" && containerName !== "ReadonlyArray") return void 0;
+		const args = typeNode.typeParameters?.params;
+		if (!args || args.length !== 1) return void 0;
+		const element = args[0];
+		if (t.isTSTypeReference(element) && t.isIdentifier(element.typeName)) return element.typeName.name;
+		return;
+	}
+}
+const ARRAY_PRODUCING_METHODS = new Set([
+	"filter",
+	"map",
+	"slice",
+	"concat",
+	"flat",
+	"flatMap",
+	"sort",
+	"toSorted",
+	"reverse",
+	"toReversed"
+]);
+function storeGettersToIr(classDecl) {
+	const getters = [];
+	const fieldShapeByName = /* @__PURE__ */ new Map();
+	for (const field of storeFieldsToIr(classDecl)) if (field.shape) fieldShapeByName.set(field.name, field.shape);
+	for (const member of classDecl.body.body) {
+		if (!t.isClassMethod(member) || member.static || member.computed || member.kind !== "get") continue;
+		if (!t.isIdentifier(member.key)) continue;
+		const returnType = member.returnType;
+		const elementTypeName = returnType && t.isTSTypeAnnotation(returnType) ? arrayElementTypeNameFromTSType(returnType.typeAnnotation) : void 0;
+		const deps = collectThisFieldReads(member.body);
+		const elementShape = getterElementShape(member.body, deps, elementTypeName, fieldShapeByName);
+		const returnsArray = !!elementTypeName || !!elementShape || getterBodyReturnsArray(member.body);
+		const shape = returnsArray ? {
+			kind: "array",
+			...elementShape ? { element: elementShape } : {},
+			...elementTypeName ? { elementTypeName } : {}
+		} : void 0;
+		const ops = storeStmtsToIr(member.body.body);
+		const getter = {
+			name: member.key.name,
+			returnsArray,
+			deps,
+			body: generate(member.body).code,
+			...elementTypeName ? { elementTypeName } : {},
+			...shape ? { shape } : {},
+			...ops ? { ops } : {},
+			...sourceSpan(member) ? { sourceSpan: sourceSpan(member) } : {}
+		};
+		getters.push(getter);
+	}
+	return getters;
+}
+function getterElementShape(body, deps, elementTypeName, fieldShapeByName) {
+	const arg = topLevelReturnArgument(body);
+	const fromBody = arg ? elementShapeFromArrayExpression(arg, fieldShapeByName) : void 0;
+	if (fromBody) return fromBody;
+	if (elementTypeName) {
+		for (const shape of fieldShapeByName.values()) if (shape.kind === "array" && shape.elementTypeName === elementTypeName && shape.element?.kind === "object") return shape.element;
+	}
+	for (const dep of deps) {
+		const shape = fieldShapeByName.get(dep);
+		if (shape?.kind === "array" && shape.element?.kind === "object") return shape.element;
+	}
+}
+function elementShapeFromArrayExpression(expr, fieldShapeByName) {
+	if (t.isArrayExpression(expr)) {
+		const first = expr.elements.find((element) => !!element && !t.isSpreadElement(element));
+		if (!first) return void 0;
+		const shaped = shapeForExpression(first);
+		return "shape" in shaped ? shaped.shape : void 0;
+	}
+	if (t.isCallExpression(expr) && t.isMemberExpression(expr.callee) && t.isIdentifier(expr.callee.property)) {
+		const method = expr.callee.property.name;
+		if (method === "map") {
+			const objectLiteral = mapCallbackObjectLiteral(expr.arguments[0]);
+			if (!objectLiteral) return void 0;
+			const shaped = shapeForExpression(objectLiteral);
+			return "shape" in shaped ? shaped.shape : void 0;
+		}
+		if (ARRAY_PRODUCING_METHODS.has(method)) return elementShapeFromArrayExpression(expr.callee.object, fieldShapeByName);
+	}
+	if (t.isMemberExpression(expr) && t.isThisExpression(expr.object) && t.isIdentifier(expr.property)) {
+		const shape = fieldShapeByName.get(expr.property.name);
+		if (shape?.kind === "array") return shape.element;
+	}
+}
+function mapCallbackObjectLiteral(callback) {
+	if (!callback || !t.isArrowFunctionExpression(callback) && !t.isFunctionExpression(callback)) return void 0;
+	const body = callback.body;
+	if (t.isObjectExpression(body)) return body;
+	if (t.isBlockStatement(body)) {
+		for (const statement of body.body) if (t.isReturnStatement(statement) && statement.argument && t.isObjectExpression(statement.argument)) return statement.argument;
+	}
+}
+function topLevelReturnArgument(body) {
+	let result;
+	let done = false;
+	const visit = (value) => {
+		if (done || !value || typeof value !== "object") return;
+		if (Array.isArray(value)) {
+			for (const item of value) visit(item);
+			return;
+		}
+		const node = value;
+		const type = node.type;
+		if (type === "FunctionExpression" || type === "ArrowFunctionExpression" || type === "FunctionDeclaration") return;
+		if (type === "ReturnStatement") {
+			result = node.argument;
+			done = true;
+			return;
+		}
+		for (const key of Object.keys(node)) {
+			if (key === "loc" || key === "start" || key === "end" || key === "range") continue;
+			visit(node[key]);
+		}
+	};
+	visit(body);
+	return result;
+}
+function getterBodyReturnsArray(body) {
+	let found = false;
+	const visit = (value) => {
+		if (found || !value || typeof value !== "object") return;
+		if (Array.isArray(value)) {
+			for (const item of value) visit(item);
+			return;
+		}
+		const node = value;
+		const type = node.type;
+		if (type === "FunctionExpression" || type === "ArrowFunctionExpression" || type === "FunctionDeclaration") return;
+		if (type === "ReturnStatement" && isArrayProducingExpression(node.argument)) {
+			found = true;
+			return;
+		}
+		for (const key of Object.keys(node)) {
+			if (key === "loc" || key === "start" || key === "end" || key === "range") continue;
+			visit(node[key]);
+		}
+	};
+	visit(body);
+	return found;
+}
+function isArrayProducingExpression(expr) {
+	if (!expr || typeof expr !== "object") return false;
+	const node = expr;
+	if (node.type === "ArrayExpression") return true;
+	if (node.type === "TSAsExpression" || node.type === "TSNonNullExpression") return isArrayProducingExpression(node.expression);
+	if (node.type === "CallExpression") {
+		const callee = node.callee;
+		const property = callee?.property;
+		if (callee?.type === "MemberExpression" && property?.type === "Identifier") return ARRAY_PRODUCING_METHODS.has(property.name);
+	}
+	return false;
+}
+function collectThisFieldReads(node) {
+	const names = /* @__PURE__ */ new Set();
+	const visit = (value) => {
+		if (!value || typeof value !== "object") return;
+		if (Array.isArray(value)) {
+			for (const item of value) visit(item);
+			return;
+		}
+		const rec = value;
+		const object = rec.object;
+		const property = rec.property;
+		if (rec.type === "MemberExpression" && object?.type === "ThisExpression" && rec.computed !== true && property?.type === "Identifier") names.add(property.name);
+		for (const key of Object.keys(rec)) {
+			if (key === "loc" || key === "start" || key === "end" || key === "range") continue;
+			visit(rec[key]);
+		}
+	};
+	visit(node);
+	return [...names];
+}
+function storeMethodsToIr(classDecl, moduleAst) {
+	const methods = [];
+	const literalUnionAliases = moduleAst ? collectLiteralUnionAliasValueTypes(moduleAst) : void 0;
+	for (const member of classDecl.body.body) {
+		if (!t.isClassMethod(member) || member.static || member.computed || member.kind !== "method") continue;
+		if (!t.isIdentifier(member.key)) continue;
+		const params = [];
+		let unsupportedParam = false;
+		for (const param of member.params) {
+			const assignment = t.isAssignmentPattern(param) ? param : null;
+			const identifier = t.isIdentifier(param) ? param : assignment && t.isIdentifier(assignment.left) ? assignment.left : null;
+			if (identifier) {
+				const valueType = paramValueType(identifier, literalUnionAliases) ?? (assignment ? paramDefaultValueType(assignment.right) : void 0);
+				params.push(valueType ? {
+					name: identifier.name,
+					valueType
+				} : { name: identifier.name });
+			} else {
+				unsupportedParam = true;
+				break;
+			}
+		}
+		if (unsupportedParam) continue;
+		const ops = storeStmtsToIr(member.body.body);
+		methods.push({
+			name: member.key.name,
+			params,
+			body: generate(member.body).code,
+			...ops ? { ops } : {},
+			...sourceSpan(member) ? { sourceSpan: sourceSpan(member) } : {}
+		});
+	}
+	return methods;
+}
+function paramValueType(param, literalUnionAliases) {
+	const annotation = param.typeAnnotation;
+	if (!annotation || !t.isTSTypeAnnotation(annotation)) return void 0;
+	const kind = annotation.typeAnnotation;
+	if (t.isTSStringKeyword(kind)) return "string";
+	if (t.isTSNumberKeyword(kind)) return "number";
+	if (t.isTSBooleanKeyword(kind)) return "boolean";
+	const inlineLiteral = literalUnionValueType(kind);
+	if (inlineLiteral) return inlineLiteral;
+	if (literalUnionAliases && t.isTSTypeReference(kind) && t.isIdentifier(kind.typeName)) return literalUnionAliases.get(kind.typeName.name);
+}
+function literalUnionValueType(kind) {
+	if (t.isTSLiteralType(kind)) {
+		if (t.isStringLiteral(kind.literal)) return "string";
+		if (t.isNumericLiteral(kind.literal)) return "number";
+		if (t.isBooleanLiteral(kind.literal)) return "boolean";
+		return;
+	}
+	if (t.isTSUnionType(kind)) {
+		let valueType;
+		for (const member of kind.types) {
+			const memberType = literalUnionValueType(member);
+			if (!memberType || valueType && memberType !== valueType) return void 0;
+			valueType = memberType;
+		}
+		return valueType;
+	}
+}
+function collectLiteralUnionAliasValueTypes(ast) {
+	const aliases = /* @__PURE__ */ new Map();
+	for (const node of ast.program.body) {
+		const alias = t.isTSTypeAliasDeclaration(node) ? node : t.isExportNamedDeclaration(node) && t.isTSTypeAliasDeclaration(node.declaration) ? node.declaration : null;
+		if (!alias || !t.isIdentifier(alias.id)) continue;
+		const valueType = literalUnionValueType(alias.typeAnnotation);
+		if (valueType) aliases.set(alias.id.name, valueType);
+	}
+	return aliases;
+}
+function paramDefaultValueType(expr) {
+	if (t.isStringLiteral(expr)) return "string";
+	if (t.isNumericLiteral(expr)) return "number";
+	if (t.isBooleanLiteral(expr)) return "boolean";
+}
+function storeStmtsToIr(statements) {
+	const out = [];
+	for (const statement of statements) {
+		const converted = storeStmtToIr(statement);
+		if (!converted) return null;
+		out.push(...converted);
+	}
+	return out;
+}
+function storeStmtToIr(statement) {
+	if (t.isBlockStatement(statement)) return storeStmtsToIr(statement.body);
+	if (t.isVariableDeclaration(statement)) {
+		const declarations = [];
+		for (const declaration of statement.declarations) {
+			if (!t.isIdentifier(declaration.id)) return null;
+			const init = declaration.init ? storeExprToIr(declaration.init) : void 0;
+			if (declaration.init && !init) return null;
+			declarations.push({
+				kind: "var",
+				name: declaration.id.name,
+				mutable: statement.kind !== "const",
+				...init ? { init } : {}
+			});
+		}
+		return declarations;
+	}
+	if (t.isExpressionStatement(statement)) {
+		const expr = statement.expression;
+		if (t.isAssignmentExpression(expr) && expr.operator === "=") {
+			const target = storeExprToIr(expr.left);
+			const value = storeExprToIr(expr.right);
+			return target && value ? [{
+				kind: "assign",
+				target,
+				value
+			}] : null;
+		}
+		const converted = storeExprToIr(expr);
+		return converted ? [{
+			kind: "expr",
+			expr: converted
+		}] : null;
+	}
+	if (t.isIfStatement(statement)) {
+		const test = storeExprToIr(statement.test);
+		const consequent = storeStatementList(statement.consequent);
+		const alternate = statement.alternate ? storeStatementList(statement.alternate) : void 0;
+		if (!test || !consequent || statement.alternate && !alternate) return null;
+		return [{
+			kind: "if",
+			test,
+			consequent,
+			...alternate ? { alternate } : {}
+		}];
+	}
+	if (t.isForStatement(statement)) {
+		const init = statement.init ? storeStmtToIr(t.isVariableDeclaration(statement.init) ? statement.init : t.expressionStatement(statement.init)) : void 0;
+		const test = statement.test ? storeExprToIr(statement.test) : void 0;
+		const update = statement.update ? storeExprToIr(statement.update) : void 0;
+		const body = storeStatementList(statement.body);
+		if (statement.init && (!init || init.length !== 1) || statement.test && !test || statement.update && !update || !body) return null;
+		return [{
+			kind: "for",
+			...init ? { init: init[0] } : {},
+			...test ? { test } : {},
+			...update ? { update } : {},
+			body
+		}];
+	}
+	if (t.isReturnStatement(statement)) {
+		const value = statement.argument ? storeExprToIr(statement.argument) : void 0;
+		if (statement.argument && !value) return null;
+		return [{
+			kind: "return",
+			...value ? { value } : {}
+		}];
+	}
+	return null;
+}
+function storeStatementList(statement) {
+	if (t.isBlockStatement(statement)) return storeStmtsToIr(statement.body);
+	return storeStmtToIr(statement);
+}
+function storeExprToIr(expression) {
+	if (t.isIdentifier(expression)) return {
+		kind: "identifier",
+		name: expression.name
+	};
+	if (t.isThisExpression(expression)) return { kind: "this" };
+	if (t.isNumericLiteral(expression)) return {
+		kind: "number",
+		value: expression.value
+	};
+	if (t.isStringLiteral(expression)) return {
+		kind: "string",
+		value: expression.value
+	};
+	if (t.isBooleanLiteral(expression)) return {
+		kind: "boolean",
+		value: expression.value
+	};
+	if (t.isNullLiteral(expression)) return { kind: "null" };
+	if (t.isMemberExpression(expression)) {
+		const object = storeExprToIr(expression.object);
+		if (!object) return null;
+		if (expression.computed) {
+			const index = storeExprToIr(expression.property);
+			return index ? {
+				kind: "index",
+				object,
+				index
+			} : null;
+		}
+		return t.isIdentifier(expression.property) ? {
+			kind: "member",
+			object,
+			property: expression.property.name
+		} : null;
+	}
+	if (t.isCallExpression(expression)) {
+		const callee = storeExprToIr(expression.callee);
+		const args = expression.arguments.map((arg) => t.isSpreadElement(arg) ? null : storeExprToIr(arg));
+		return callee && args.every((arg) => !!arg) ? {
+			kind: "call",
+			callee,
+			args
+		} : null;
+	}
+	if (t.isObjectExpression(expression)) {
+		const fields = [];
+		for (const property of expression.properties) {
+			if (!t.isObjectProperty(property) || property.computed) return null;
+			const name = objectPropertyName(property.key);
+			const value = storeExprToIr(property.value);
+			if (!name || !value) return null;
+			fields.push({
+				name,
+				value
+			});
+		}
+		return {
+			kind: "object",
+			fields
+		};
+	}
+	if (t.isUnaryExpression(expression)) {
+		const arg = storeExprToIr(expression.argument);
+		return arg ? {
+			kind: "unary",
+			op: expression.operator,
+			arg
+		} : null;
+	}
+	if (t.isBinaryExpression(expression)) {
+		const left = storeExprToIr(expression.left);
+		const right = storeExprToIr(expression.right);
+		return left && right ? {
+			kind: "binary",
+			op: expression.operator,
+			left,
+			right
+		} : null;
+	}
+	if (t.isLogicalExpression(expression)) {
+		const left = storeExprToIr(expression.left);
+		const right = storeExprToIr(expression.right);
+		return left && right ? {
+			kind: "logical",
+			op: expression.operator,
+			left,
+			right
+		} : null;
+	}
+	if (t.isUpdateExpression(expression)) {
+		const arg = storeExprToIr(expression.argument);
+		return arg ? {
+			kind: "update",
+			op: expression.operator,
+			arg,
+			prefix: expression.prefix
+		} : null;
+	}
+	return null;
+}
+function sourceSpan(node) {
+	const span = {};
+	if (typeof node.start === "number") span.start = node.start;
+	if (typeof node.end === "number") span.end = node.end;
+	return span.start === void 0 && span.end === void 0 ? void 0 : span;
+}
+function slotToIr(slot, bindings) {
+	const expr = slot.expr ? substituteBindings(slot.expr, bindings) : null;
+	return {
+		index: slot.index,
+		kind: slot.kind,
+		walk: slot.walk,
+		...slot.walkKinds ? { walkKinds: slot.walkKinds } : {},
+		...expr ? { expr: generate(expr).code } : {},
+		...expr ? expressionPathToIr(expr) : {},
+		...expr ? expressionObjectFieldsToIr(expr) : {},
+		...slot.payload ? { payload: slotPayloadToIr(slot, bindings) } : {},
+		...slot.directText ? { directText: true } : {}
+	};
+}
+function expressionPathToIr(expr) {
+	const path = expressionPath(expr);
+	return path && path.length > 0 ? { exprPath: path } : {};
+}
+function expressionPath(expr) {
+	if (t.isIdentifier(expr)) return [expr.name];
+	if (t.isThisExpression(expr)) return ["this"];
+	if (t.isMemberExpression(expr) && !expr.computed) {
+		const objectPath = expressionPath(expr.object);
+		const property = t.isIdentifier(expr.property) ? expr.property.name : null;
+		return objectPath && property ? [...objectPath, property] : null;
+	}
+	if (t.isOptionalMemberExpression(expr) && !expr.computed) {
+		const objectPath = expressionPath(expr.object);
+		const property = t.isIdentifier(expr.property) ? expr.property.name : null;
+		return objectPath && property ? [...objectPath, property] : null;
+	}
+	return null;
+}
+function expressionObjectFieldsToIr(expr) {
+	if (!t.isObjectExpression(expr)) return {};
+	const fields = [];
+	for (const property of expr.properties) {
+		if (!t.isObjectProperty(property) || property.computed) continue;
+		const name = objectPropertyName(property.key);
+		if (!name) continue;
+		fields.push({
+			name,
+			expr: generate(property.value).code,
+			...expressionPathToIr(property.value)
+		});
+	}
+	return fields.length > 0 ? { exprObjectFields: fields } : {};
+}
+function slotPayloadToIr(slot, bindings) {
+	const payload = serializePayload(slot.payload, bindings);
+	if (!isRecord(payload)) return payload;
+	if (slot.kind === "keyed-list") {
+		const cb = slot.payload?.mapCallback;
+		const row = keyedListRowIr(cb);
+		return row ? {
+			...payload,
+			...row
+		} : payload;
+	}
+	if (slot.kind === "conditional") {
+		const result = { ...payload };
+		const consequent = jsxNodeToTemplateIr(slot.payload?.mkTrue, bindings);
+		if (consequent) result.consequentTemplate = consequent;
+		const alternate = jsxNodeToTemplateIr(slot.payload?.mkFalse, bindings);
+		if (alternate) result.alternateTemplate = alternate;
+		return result;
+	}
+	if (slot.kind === "mount") {
+		const children = slot.payload?.children;
+		const childrenTemplate = jsxChildrenToTemplateIr(children, bindings);
+		if (childrenTemplate) return {
+			...payload,
+			childrenTemplate
+		};
+	}
+	return payload;
+}
+function jsxNodeToTemplateIr(node, bindings) {
+	if (!node) return null;
+	if (t.isJSXElement(node) || t.isJSXFragment(node)) return templateSpecToIr(walkJsxToTemplate(node), bindings);
+	if (t.isJSXExpressionContainer(node)) {
+		const inner = node.expression;
+		if (t.isJSXElement(inner) || t.isJSXFragment(inner)) return templateSpecToIr(walkJsxToTemplate(inner), bindings);
+		if (isWalkableConditionalExpression(inner)) return wrapAsFragmentTemplate(inner, bindings);
+	}
+	if (isWalkableConditionalExpression(node)) return wrapAsFragmentTemplate(node, bindings);
+	return null;
+}
+function isWalkableConditionalExpression(node) {
+	if (t.isConditionalExpression(node)) return isJsxOrNullish(node.consequent) || isJsxOrNullish(node.alternate);
+	if (t.isLogicalExpression(node) && node.operator === "&&") return isJsxOrNullish(node.right);
+	return false;
+}
+function wrapAsFragmentTemplate(expression, bindings) {
+	return templateSpecToIr(walkJsxToTemplate(t.jsxFragment(t.jsxOpeningFragment(), t.jsxClosingFragment(), [t.jsxExpressionContainer(expression)])), bindings);
+}
+function jsxChildrenToTemplateIr(children, bindings) {
+	if (!Array.isArray(children) || children.length === 0) return null;
+	if (!children.some((c) => t.isJSXElement(c) || t.isJSXFragment(c) || t.isJSXExpressionContainer(c) && !t.isJSXEmptyExpression(c.expression))) return null;
+	return templateSpecToIr(walkJsxToTemplate(t.jsxFragment(t.jsxOpeningFragment(), t.jsxClosingFragment(), children)), bindings);
+}
+function keyedListRowIr(cb) {
+	if (!t.isArrowFunctionExpression(cb) && !t.isFunctionExpression(cb)) return null;
+	const body = callbackJsxBody(cb.body);
+	if (!body) return null;
+	const itemParam = callbackParamName(cb.params[0]);
+	const indexParam = callbackParamName(cb.params[1]);
+	return {
+		...itemParam ? { itemParam } : {},
+		...indexParam ? { indexParam } : {},
+		rowTemplate: templateSpecToIr(walkJsxToTemplate(body))
+	};
+}
+function callbackJsxBody(body) {
+	if (t.isJSXElement(body) || t.isJSXFragment(body)) return body;
+	if (!t.isBlockStatement(body)) return null;
+	for (const statement of body.body) {
+		if (!t.isReturnStatement(statement) || !statement.argument) continue;
+		if (t.isJSXElement(statement.argument) || t.isJSXFragment(statement.argument)) return statement.argument;
+	}
+	return null;
+}
+function callbackParamName(param) {
+	return t.isIdentifier(param) ? param.name : void 0;
+}
+function serializePayload(value, bindings) {
+	if (value === null || value === void 0) return value;
+	if (typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map((child) => serializePayload(child, bindings));
+	if (isBabelNode(value)) {
+		const node = substitutePayloadNode(value, bindings);
+		return {
+			nodeType: node.type,
+			code: generate(node).code
+		};
+	}
+	const out = {};
+	for (const [key, child] of Object.entries(value)) out[key] = serializePayload(child, bindings);
+	return out;
+}
+function substitutePayloadNode(value, bindings) {
+	if (bindings.size === 0) return value;
+	if (t.isJSXAttribute(value) && value.value && t.isJSXExpressionContainer(value.value) && !t.isJSXEmptyExpression(value.value.expression)) return {
+		...value,
+		value: {
+			...value.value,
+			expression: substituteBindings(value.value.expression, bindings)
+		}
+	};
+	if (t.isJSXExpressionContainer(value) && !t.isJSXEmptyExpression(value.expression)) return {
+		...value,
+		expression: substituteBindings(value.expression, bindings)
+	};
+	return substituteBindings(value, bindings);
+}
+function isBabelNode(value) {
+	return !!value && typeof value === "object" && typeof value.type === "string";
+}
+function isRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function shapeForExpression(value) {
+	if (t.isStringLiteral(value)) return { shape: {
+		kind: "literal",
+		valueType: "string"
+	} };
+	if (t.isNumericLiteral(value)) return { shape: {
+		kind: "literal",
+		valueType: "number"
+	} };
+	if (t.isBooleanLiteral(value)) return { shape: {
+		kind: "literal",
+		valueType: "boolean"
+	} };
+	if (t.isNullLiteral(value)) return { shape: {
+		kind: "literal",
+		valueType: "null"
+	} };
+	if (t.isArrayExpression(value)) {
+		const firstElement = value.elements.find((element) => !!element && !t.isSpreadElement(element));
+		const shapedElement = firstElement ? shapeForExpression(firstElement) : {};
+		const elementShape = "shape" in shapedElement ? shapedElement.shape : void 0;
+		return { shape: {
+			kind: "array",
+			...elementShape ? { element: elementShape } : {}
+		} };
+	}
+	if (t.isObjectExpression(value)) {
+		const fields = [];
+		for (const property of value.properties) {
+			if (!t.isObjectProperty(property) || property.computed) continue;
+			const name = objectPropertyName(property.key);
+			if (!name) continue;
+			fields.push({
+				name,
+				...property.value ? { initializer: generate(property.value).code } : {},
+				...property.value ? shapeForExpression(property.value) : {}
+			});
+		}
+		return { shape: {
+			kind: "object",
+			fields
+		} };
+	}
+	return {};
+}
+function objectPropertyName(key) {
+	if (t.isIdentifier(key)) return key.name;
+	if (t.isStringLiteral(key)) return key.value;
+	if (t.isNumericLiteral(key)) return String(key.value);
+	return null;
+}
+//#endregion
+//#region src/closure-codegen/emit/emit-core.ts
+function compileJsxToBlock(jsxRoot, ctx) {
+	const spec = walkJsxToTemplate(jsxRoot, {
+		emitEventDataAttr: false,
+		directFnComponents: ctx.directFnComponents,
+		bindings: ctx.bindings
+	});
+	if (t.isJSXFragment(jsxRoot)) spec.html = "<span style=\"display:contents\">" + spec.html + "</span>";
+	else if (!spec.html.startsWith("<") || spec.html.startsWith("<!--")) {
+		spec.html = "<span style=\"display:contents\">" + spec.html + "</span>";
+		for (const slot of spec.slots) slot.walk = [0, ...slot.walk];
+	}
+	if (ctx.irTemplates && ctx.currentIrComponent && ctx.currentIrRuntimeBase) ctx.irTemplates.push({
+		component: ctx.currentIrComponent,
+		runtimeBase: ctx.currentIrRuntimeBase,
+		template: templateSpecToIr(spec, ctx.bindings)
+	});
+	const tplName = "_tpl" + ctx.tplCounter++;
+	ctx.templateDecls.push(...emitTemplateDecl(spec.html, tplName));
+	const stmts = [];
+	stmts.push(t.variableDeclaration("const", [t.variableDeclarator(t.identifier("root"), emitTemplateCloneExpression(tplName, spec.html))]));
+	const walkCache = /* @__PURE__ */ new Map();
+	for (const slot of spec.slots) emitWalkCapture(slot, stmts, false, walkCache);
+	const savedPending = ctx._pendingEvents;
+	const savedInputValueExprByEventSlot = ctx._inputValueExprByEventSlot;
+	const savedDocumentClickDelegateInstalled = ctx._documentClickDelegateInstalled;
+	ctx._pendingEvents = [];
+	ctx._inputValueExprByEventSlot = findInputValueReconciliations(spec);
+	ctx._documentClickDelegateInstalled = false;
+	for (const slot of spec.slots) emitSlot(slot, stmts, ctx);
+	const events = ctx._pendingEvents;
+	ctx._pendingEvents = savedPending;
+	ctx._inputValueExprByEventSlot = savedInputValueExprByEventSlot;
+	if (events.length > 0) {
+		const groups = /* @__PURE__ */ new Map();
+		for (const e of events) {
 			const arr = groups.get(e.eventType);
 			if (arr) arr.push(e);
 			else groups.set(e.eventType, [e]);
@@ -4431,6 +5380,11 @@ function rewriteFnComponent(fnDecl, parentCtx) {
 	fnCtx.directFnComponentParams = parentCtx.directFnComponentParams;
 	fnCtx.directFnStringProps = parentCtx.directFnStringProps;
 	fnCtx.directFnNoDisposer = parentCtx.directFnNoDisposer;
+	if (parentCtx.irTemplates && fnName) {
+		fnCtx.irTemplates = parentCtx.irTemplates;
+		fnCtx.currentIrComponent = fnName;
+		fnCtx.currentIrRuntimeBase = "reactive";
+	}
 	if (fnCtx.oneShotProps) {
 		fnCtx._inKeyedListRow = true;
 		fnCtx._rowEventTypes = /* @__PURE__ */ new Set();
@@ -4856,6 +5810,7 @@ function transformFile(source, _filename, options = {}) {
 		};
 	}
 	const ctx = createEmitContext();
+	ctx.irTemplates = [];
 	ctx.directFnComponents = collectDirectFnComponents(ast);
 	ctx.directFnComponentParams = collectDirectFnComponentParams(ast, ctx.directFnComponents);
 	ctx.directFnStringProps = collectDirectFnStringProps(ast, ctx.directFnComponents);
@@ -4864,6 +5819,7 @@ function transformFile(source, _filename, options = {}) {
 	for (const name of options.directClassComponents ?? []) ctx.directClassComponents.add(name);
 	ctx.directFactoryComponents = new Set(options.directFactoryComponents);
 	const rewritten = [];
+	const reactiveComponentNames = /* @__PURE__ */ new Set();
 	let firstClassIdx = -1;
 	for (let i = 0; i < ast.program.body.length; i++) {
 		const node = ast.program.body[i];
@@ -4899,9 +5855,21 @@ function transformFile(source, _filename, options = {}) {
 			const useTinyReactiveComponent = options.enableTinyReactiveComponents !== false && !useStaticCompiledComponent && !useCompiledComponent && canUseTinyReactiveComponent(classDecl);
 			const useLeanReactiveComponent = !useStaticCompiledComponent && !useCompiledComponent && !useTinyReactiveComponent && canUseLeanReactiveComponent(classDecl);
 			const hasAfterRenderAsyncHook = hasOwnInstanceMethod(classDecl, "onAfterRenderAsync");
+			const className = classDecl.id && classDecl.id.name || "<anonymous>";
+			if (t.isIdentifier(classDecl.superClass, { name: "ReactiveComponent" })) reactiveComponentNames.add(className);
+			const runtimeBase = runtimeBaseForComponent({
+				useStaticCompiledComponent,
+				useCompiledComponent,
+				useTinyReactiveComponent,
+				useLeanReactiveComponent
+			});
+			ctx.currentIrComponent = className;
+			ctx.currentIrRuntimeBase = runtimeBase;
 			for (const m of methodsWithJsx) m.body.body = m.body.body.map((s) => lowerJsxInStatement(s, ctx));
 			if (!templateMethod) {
-				rewritten.push(classDecl.id && classDecl.id.name || "<anonymous>");
+				rewritten.push(className);
+				ctx.currentIrComponent = void 0;
+				ctx.currentIrRuntimeBase = void 0;
 				continue;
 			}
 			const paramBindings = [];
@@ -4921,14 +5889,26 @@ function transformFile(source, _filename, options = {}) {
 			ctx.importsNeeded.add(templateSymbol);
 			const method = buildCreateTemplateMethod(jsx, ctx, preceding, templateSymbol);
 			const useStaticElementComponent = useStaticCompiledComponent && isStaticBuiltinElementRoot(jsx) && !nodeContainsIdentifier$1(method.body, "d");
+			if (useStaticElementComponent && ctx.irTemplates) {
+				for (const template of ctx.irTemplates) if (template.component === className) template.runtimeBase = "static-element";
+			}
 			if (useStaticElementComponent) method.params = [];
 			if (plainPropsParamName) ctx.bindings.delete(plainPropsParamName);
 			for (const k of paramBindings) ctx.bindings.delete(k);
+			const isReactiveComponent = reactiveComponentNames.has(className);
 			const bodyItems = classDecl.body.body;
 			const templateIdx = bodyItems.indexOf(templateMethod);
-			if (templateIdx >= 0) bodyItems[templateIdx] = method;
+			if (templateIdx >= 0) if (isReactiveComponent) {
+				bodyItems.splice(templateIdx, 1);
+				const keepAlive = mountedComponentKeepAliveStatements(jsx, ast);
+				if (keepAlive.length > 0) ast.program.body.splice(i + 1, 0, ...keepAlive);
+			} else bodyItems[templateIdx] = method;
 			let usesCompiledRuntimeBase = false;
-			if (useStaticElementComponent) {
+			if (isReactiveComponent) {
+				classDecl.superClass = null;
+				usesCompiledRuntimeBase = false;
+				if (!classDecl.body.body.some((member) => (t.isClassProperty(member) || t.isClassMethod(member)) && !member.computed && t.isIdentifier(member.key, { name: "el" })) && nodeContainsThisMember(classDecl, "el")) classDecl.body.body.unshift(t.classProperty(t.identifier("el"), t.nullLiteral()));
+			} else if (useStaticElementComponent) {
 				ctx.importsNeeded.add("CompiledStaticElementComponent");
 				classDecl.superClass = t.identifier("CompiledStaticElementComponent");
 				usesCompiledRuntimeBase = true;
@@ -4957,7 +5937,9 @@ function transformFile(source, _filename, options = {}) {
 				ctx.importsNeeded.add("scheduleAfterRenderAsync");
 				classDecl.body.body.push(buildAfterRenderAsyncRenderMethod());
 			}
-			rewritten.push(classDecl.id && classDecl.id.name || "<anonymous>");
+			rewritten.push(className);
+			ctx.currentIrComponent = void 0;
+			ctx.currentIrRuntimeBase = void 0;
 			continue;
 		}
 		if (fnDecl && isFunctionComponent(fnDecl)) {
@@ -4984,9 +5966,90 @@ function transformFile(source, _filename, options = {}) {
 		map: out.map,
 		changed: true,
 		rewritten,
-		importsNeeded: Array.from(ctx.importsNeeded)
+		importsNeeded: Array.from(ctx.importsNeeded),
+		ir: buildModuleIr(_filename ?? "<unknown>", rewritten, ctx.irTemplates ?? [], ast, reactiveComponentNames)
+	};
+}
+function mountedComponentKeepAliveStatements(jsx, ast) {
+	const tags = /* @__PURE__ */ new Set();
+	collectCapitalizedJsxTags(jsx, tags);
+	if (tags.size === 0) return [];
+	const imported = /* @__PURE__ */ new Set();
+	for (const stmt of ast.program.body) {
+		if (!t.isImportDeclaration(stmt)) continue;
+		for (const spec of stmt.specifiers) imported.add(spec.local.name);
+	}
+	const kept = Array.from(tags).filter((tag) => imported.has(tag));
+	if (kept.length === 0) return [];
+	const keepArray = t.assignmentExpression("||=", t.memberExpression(t.identifier("globalThis"), t.identifier("__GEA_IR_KEEP__")), t.arrayExpression([]));
+	return [t.expressionStatement(t.callExpression(t.memberExpression(t.parenthesizedExpression(keepArray), t.identifier("push")), kept.map((tag) => t.identifier(tag))))];
+}
+function collectCapitalizedJsxTags(node, tags) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const child of node) collectCapitalizedJsxTags(child, tags);
+		return;
+	}
+	if (t.isJSXElement(node)) {
+		const name = node.openingElement.name;
+		if (t.isJSXIdentifier(name) && /^[A-Z]/.test(name.name)) tags.add(name.name);
+	}
+	for (const key of Object.keys(node)) {
+		if (key === "loc" || key === "start" || key === "end" || key === "type") continue;
+		collectCapitalizedJsxTags(node[key], tags);
+	}
+}
+function runtimeBaseForComponent(options) {
+	if (options.useStaticCompiledComponent) return "static";
+	if (options.useCompiledComponent) return "compiled";
+	if (options.useTinyReactiveComponent) return "tiny-reactive";
+	if (options.useLeanReactiveComponent) return "lean-reactive";
+	return "reactive";
+}
+function buildModuleIr(moduleId, rewritten, templates, ast, reactiveComponentNames = /* @__PURE__ */ new Set()) {
+	const components = [];
+	for (const name of rewritten) {
+		const record = templates.find((template) => template.component === name);
+		if (!record) continue;
+		const declaration = findClassDeclarationByName(ast, name);
+		const reactiveState = declaration && reactiveComponentNames.has(name) ? (() => {
+			const fields = storeFieldsToIr(declaration);
+			const methods = storeMethodsToIr(declaration, ast);
+			const getters = storeGettersToIr(declaration);
+			return {
+				fields,
+				...methods.length > 0 ? { methods } : {},
+				...getters.length > 0 ? { getters } : {}
+			};
+		})() : void 0;
+		components.push({
+			id: componentIrId(moduleId, name),
+			module: moduleId,
+			exportName: name,
+			runtimeBase: record.runtimeBase,
+			template: record.template,
+			...reactiveState ? { reactiveState } : {},
+			...declaration ? { sourceSpan: sourceSpan(declaration) } : {}
+		});
+	}
+	return {
+		module: {
+			id: moduleId,
+			file: moduleId,
+			components: components.map((component) => component.id),
+			stores: []
+		},
+		components
 	};
 }
+function findClassDeclarationByName(ast, name) {
+	for (const node of ast.program.body) {
+		if (t.isClassDeclaration(node) && node.id?.name === name) return node;
+		if (t.isExportDefaultDeclaration(node) && t.isClassDeclaration(node.declaration) && node.declaration.id?.name === name) return node.declaration;
+		if (t.isExportNamedDeclaration(node) && t.isClassDeclaration(node.declaration) && node.declaration.id?.name === name) return node.declaration;
+	}
+	return null;
+}
 function collectLocalClassComponents(ast) {
 	const names = /* @__PURE__ */ new Set();
 	for (const node of ast.program.body) {
@@ -5516,6 +6579,7 @@ function transform(ctx) {
 				}
 			}
 		});
+		let ir;
 		if (hasJSX) {
 			const emitted = transformFile(code, sourceFile, {
 				directClassComponents: knownClassComponentImports,
@@ -5523,6 +6587,7 @@ function transform(ctx) {
 				enableTinyReactiveComponents: !isServe
 			});
 			if (emitted.changed) {
+				ir = emitted.ir;
 				const reparsed = parseSource(emitted.code);
 				if (reparsed) {
 					ast.program.body = reparsed.ast.program.body;
@@ -5573,7 +6638,8 @@ function transform(ctx) {
 		}, code);
 		return {
 			code: output.code,
-			map: output.map
+			map: output.map,
+			ir
 		};
 	} catch (error) {
 		if (error?.__geaCompileError) throw error;
@@ -5583,10 +6649,9 @@ function transform(ctx) {
 }
 //#endregion
 //#region src/closure-codegen/transform/transform-store.ts
-function transformCompiledStoreModule(source) {
+function transformCompiledStoreModule(source, moduleId = "<unknown>", resolveImportPath) {
 	if (!source.includes("extends Store")) return null;
 	if (source.includes("CompiledStore")) return null;
-	if (/\b(flushSync|silent|Store\.|new\s+Store\s*\()/.test(source)) return null;
 	let ast;
 	try {
 		ast = parse(source, {
@@ -5603,29 +6668,48 @@ function transformCompiledStoreModule(source) {
 	} catch {
 		return null;
 	}
-	const imported = findStoreImport(ast);
+	const imported = findStoreImport(ast, moduleId, resolveImportPath);
 	if (!imported) return null;
-	const classDecl = findStoreClass(ast, imported.localName);
-	if (!classDecl || !classDecl.id) return null;
-	if (!isCompiledStoreSafeClass(classDecl)) return null;
-	if (!hasDefaultNewStore(ast, classDecl.id.name)) return null;
-	const leanResult = transformLeanDataSelectedStore(ast, classDecl, imported);
-	if (leanResult) return leanResult;
-	const storeBase = canUseLeanStore(classDecl) ? "CompiledLeanStore" : "CompiledStore";
+	const classDecls = findStoreClasses(ast, imported.localName);
+	if (classDecls.length === 0) return null;
+	const constants = collectImportedLiteralConstants(ast, moduleId, resolveImportPath);
+	const fallbackIrs = classDecls.map((classDecl) => buildStoreIr(classDecl, moduleId, "compiled", constants, ast));
+	const fallback = {
+		code: source,
+		changed: false,
+		ir: fallbackIrs[0],
+		irs: fallbackIrs
+	};
+	if (/\b(flushSync|silent|Store\.|new\s+Store\s*\()/.test(source)) return fallback;
+	if (!classDecls.every((classDecl) => isCompiledStoreSafeClass(classDecl))) return classDecls.length === 1 ? null : fallback;
+	if (!classDecls.every((classDecl) => hasDefaultNewStore(ast, classDecl.id.name))) return fallback;
+	if (classDecls.length === 1) {
+		const leanResult = transformLeanDataSelectedStore(ast, classDecls[0], imported, moduleId, constants);
+		if (leanResult) return {
+			...leanResult,
+			irs: leanResult.ir ? [leanResult.ir] : void 0
+		};
+	}
+	const storeBases = classDecls.map((classDecl) => canUseLeanStore(classDecl) ? "CompiledLeanStore" : "CompiledStore");
+	const storeIrs = classDecls.map((classDecl, index) => buildStoreIr(classDecl, moduleId, storeBases[index] === "CompiledLeanStore" ? "lean" : "compiled", constants, ast));
 	removeStoreSpecifier(imported.importDecl, imported.localName);
 	ast.program.body = ast.program.body.filter((node) => {
 		if (node !== imported.importDecl) return true;
 		return imported.importDecl.specifiers.length > 0;
 	});
-	ast.program.body.unshift(t.importDeclaration([t.importSpecifier(t.identifier(storeBase), t.identifier(storeBase))], t.stringLiteral(COMPILER_RUNTIME_ID)));
-	classDecl.superClass = t.identifier(storeBase);
+	for (const storeBase of [...new Set(storeBases)]) ast.program.body.unshift(t.importDeclaration([t.importSpecifier(t.identifier(storeBase), t.identifier(storeBase))], t.stringLiteral(COMPILER_RUNTIME_ID)));
+	classDecls.forEach((classDecl, index) => {
+		classDecl.superClass = t.identifier(storeBases[index]);
+	});
 	return {
 		code: generate(ast, {
 			retainLines: false,
 			compact: false,
 			jsescOption: { minimal: true }
 		}).code,
-		changed: true
+		changed: true,
+		ir: storeIrs[0],
+		irs: storeIrs
 	};
 }
 const LEAN_DATA_SELECTED_STORE_SOURCE = `
@@ -5754,7 +6838,7 @@ const __store = {
 };
 export default __store;
 `;
-function transformLeanDataSelectedStore(ast, classDecl, imported) {
+function transformLeanDataSelectedStore(ast, classDecl, imported, moduleId, constants) {
 	if (!classDecl.id) return null;
 	const classIndex = ast.program.body.indexOf(classDecl);
 	if (classIndex < 0) return null;
@@ -5763,6 +6847,7 @@ function transformLeanDataSelectedStore(ast, classDecl, imported) {
 	const fields = collectLeanStoreFields(classDecl);
 	if (!fields) return null;
 	if (!isBenchmarkOperationStoreShape(classDecl)) return null;
+	const storeIr = buildStoreIr(classDecl, moduleId, "lean", constants, ast);
 	const methodProps = buildLeanStoreMethods(classDecl);
 	if (!methodProps) return null;
 	removeStoreSpecifier(imported.importDecl, imported.localName);
@@ -5792,9 +6877,95 @@ function transformLeanDataSelectedStore(ast, classDecl, imported) {
 			compact: false,
 			jsescOption: { minimal: true }
 		}).code,
-		changed: true
+		changed: true,
+		ir: storeIr
+	};
+}
+function buildStoreIr(classDecl, moduleId, runtimeBase, constants = [], moduleAst) {
+	const className = classDecl.id?.name ?? "<anonymous>";
+	return {
+		id: storeIrId(moduleId, className),
+		module: moduleId,
+		className,
+		runtimeBase,
+		fields: storeFieldsToIr(classDecl),
+		methods: storeMethodsToIr(classDecl, moduleAst),
+		...(() => {
+			const getters = storeGettersToIr(classDecl);
+			return getters.length > 0 ? { getters } : {};
+		})(),
+		...constants.length > 0 ? { constants } : {},
+		...sourceSpan(classDecl) ? { sourceSpan: sourceSpan(classDecl) } : {}
 	};
 }
+function collectImportedLiteralConstants(ast, moduleId, resolveImportPath) {
+	if (!resolveImportPath) return [];
+	const namesByFile = /* @__PURE__ */ new Map();
+	for (const node of ast.program.body) {
+		if (!t.isImportDeclaration(node) || typeof node.source.value !== "string") continue;
+		const resolved = resolveImportPath(moduleId, node.source.value);
+		if (!resolved) continue;
+		for (const specifier of node.specifiers) {
+			if (!t.isImportSpecifier(specifier) || !t.isIdentifier(specifier.imported)) continue;
+			const names = namesByFile.get(resolved) ?? /* @__PURE__ */ new Set();
+			names.add(specifier.imported.name);
+			namesByFile.set(resolved, names);
+		}
+	}
+	const constants = [];
+	for (const [file, names] of namesByFile) constants.push(...literalConstantsFromFile(file, names));
+	return constants;
+}
+function literalConstantsFromFile(file, names) {
+	if (!existsSync(file)) return [];
+	let ast;
+	try {
+		ast = parse(readFileSync(file, "utf8"), {
+			sourceType: "module",
+			plugins: [
+				"typescript",
+				"jsx",
+				"classProperties"
+			],
+			errorRecovery: false
+		});
+	} catch {
+		return [];
+	}
+	const constants = [];
+	for (const node of ast.program.body) {
+		if (!t.isExportNamedDeclaration(node) || !t.isVariableDeclaration(node.declaration)) continue;
+		for (const declaration of node.declaration.declarations) {
+			if (!t.isIdentifier(declaration.id) || !names.has(declaration.id.name) || !declaration.init) continue;
+			const literal = literalConstant(declaration.id.name, declaration.init);
+			if (literal) constants.push(literal);
+		}
+	}
+	return constants;
+}
+function literalConstant(name, value) {
+	if (t.isStringLiteral(value)) return {
+		name,
+		value: value.value,
+		valueType: "string"
+	};
+	if (t.isNumericLiteral(value)) return {
+		name,
+		value: String(value.value),
+		valueType: "number"
+	};
+	if (t.isBooleanLiteral(value)) return {
+		name,
+		value: value.value ? "true" : "false",
+		valueType: "boolean"
+	};
+	if (t.isNullLiteral(value)) return {
+		name,
+		value: "null",
+		valueType: "null"
+	};
+	return null;
+}
 function isBenchmarkOperationStoreShape(classDecl) {
 	const methods = /* @__PURE__ */ new Set();
 	for (const member of classDecl.body.body) {
@@ -5892,10 +7063,10 @@ function replaceThisExpressions(node, replacement) {
 		else replaceThisExpressions(value, replacement);
 	}
 }
-function findStoreImport(ast) {
+function findStoreImport(ast, moduleId, resolveImportPath) {
 	for (const node of ast.program.body) {
 		if (!t.isImportDeclaration(node)) continue;
-		if (node.source.value !== "gea" && node.source.value !== "@geajs/core") continue;
+		if (!storeImportSourceProvidesStore(moduleId, node.source.value, resolveImportPath)) continue;
 		for (const spec of node.specifiers) {
 			if (!t.isImportSpecifier(spec)) continue;
 			if ((t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value) === "Store") return {
@@ -5906,13 +7077,87 @@ function findStoreImport(ast) {
 	}
 	return null;
 }
-function findStoreClass(ast, storeName) {
-	let found = null;
+const knownStoreImportSources = new Set([
+	"gea",
+	"@geajs/core",
+	"gea-embedded"
+]);
+const storeExportCache = /* @__PURE__ */ new Map();
+function storeImportSourceProvidesStore(moduleId, source, resolveImportPath) {
+	if (typeof source !== "string") return false;
+	if (knownStoreImportSources.has(source)) return true;
+	if (!resolveImportPath) return false;
+	const resolved = resolveImportPath(moduleId, source);
+	return !!resolved && moduleExportsStore(resolved, resolveImportPath, /* @__PURE__ */ new Set());
+}
+function moduleExportsStore(file, resolveImportPath, seen) {
+	if (seen.has(file)) return false;
+	const cached = storeExportCache.get(file);
+	if (cached !== void 0) return cached;
+	seen.add(file);
+	if (!existsSync(file)) {
+		storeExportCache.set(file, false);
+		return false;
+	}
+	let ast;
+	try {
+		ast = parse(readFileSync(file, "utf8"), {
+			sourceType: "module",
+			plugins: [
+				"typescript",
+				"jsx",
+				"classProperties"
+			],
+			errorRecovery: false
+		});
+	} catch {
+		storeExportCache.set(file, false);
+		return false;
+	}
+	for (const node of ast.program.body) {
+		if (t.isExportNamedDeclaration(node)) {
+			if (node.declaration) {
+				if (t.isVariableDeclaration(node.declaration)) {
+					for (const declaration of node.declaration.declarations) if (t.isIdentifier(declaration.id, { name: "Store" })) {
+						storeExportCache.set(file, true);
+						return true;
+					}
+				}
+				if (t.isClassDeclaration(node.declaration) && t.isIdentifier(node.declaration.id, { name: "Store" })) {
+					storeExportCache.set(file, true);
+					return true;
+				}
+			}
+			for (const specifier of node.specifiers) {
+				if ((t.isIdentifier(specifier.exported) ? specifier.exported.name : specifier.exported.value) !== "Store") continue;
+				if (!node.source || typeof node.source.value !== "string") {
+					storeExportCache.set(file, true);
+					return true;
+				}
+				const resolved = resolveImportPath(file, node.source.value);
+				if (resolved && moduleExportsStore(resolved, resolveImportPath, seen)) {
+					storeExportCache.set(file, true);
+					return true;
+				}
+			}
+		}
+		if (t.isExportAllDeclaration(node) && typeof node.source.value === "string") {
+			const resolved = resolveImportPath(file, node.source.value);
+			if (resolved && moduleExportsStore(resolved, resolveImportPath, seen)) {
+				storeExportCache.set(file, true);
+				return true;
+			}
+		}
+	}
+	storeExportCache.set(file, false);
+	return false;
+}
+function findStoreClasses(ast, storeName) {
+	const found = [];
 	for (const node of ast.program.body) {
 		const decl = t.isClassDeclaration(node) ? node : t.isExportNamedDeclaration(node) && t.isClassDeclaration(node.declaration) ? node.declaration : null;
-		if (!decl || !t.isIdentifier(decl.superClass, { name: storeName })) continue;
-		if (found) return null;
-		found = decl;
+		if (!decl || !decl.id || !t.isIdentifier(decl.superClass, { name: storeName })) continue;
+		found.push(decl);
 	}
 	return found;
 }
@@ -6066,7 +7311,8 @@ function transformStaticRootMount(source, filePath, resolveImportPath) {
 			compact: false,
 			jsescOption: { minimal: true }
 		}).code,
-		changed: true
+		changed: true,
+		watchFiles: [resolved, ...factory.watchFiles]
 	};
 }
 function collectDefaultImports(ast) {
@@ -6162,6 +7408,7 @@ function createStaticTemplateFactory(componentPath, tplName, mountFilePath, reso
 	const jsx = templateMethod ? extractTemplateJsx(templateMethod) : null;
 	if (!jsx || !isBuiltinElementRoot(jsx)) return null;
 	const ctx = createEmitContext();
+	const watchFiles = /* @__PURE__ */ new Set();
 	ctx.directFnComponents = collectDirectFnComponents(ast);
 	ctx.directFnComponentParams = collectDirectFnComponentParams(ast, ctx.directFnComponents);
 	ctx.directFnNoDisposer = /* @__PURE__ */ new Set();
@@ -6169,7 +7416,7 @@ function createStaticTemplateFactory(componentPath, tplName, mountFilePath, reso
 	ctx.directClassComponents = /* @__PURE__ */ new Set();
 	ctx.directFactoryComponents = /* @__PURE__ */ new Set();
 	const importedFns = [];
-	if (!collectImportedStaticFunctionComponents(ast, componentPath, resolveImportPath, ctx, importedFns)) return null;
+	if (!collectImportedStaticFunctionComponents(ast, componentPath, resolveImportPath, ctx, importedFns, watchFiles)) return null;
 	ctx.directFnStringProps = collectDirectFnStringProps(ast, ctx.directFnComponents);
 	if (nodeContainsAnyIdentifier(jsx, collectRootModuleBindings(ast, classDecl, ctx.directFnComponents))) return null;
 	const importedFnDecls = [];
@@ -6217,7 +7464,8 @@ function createStaticTemplateFactory(componentPath, tplName, mountFilePath, reso
 			factoryDecl
 		],
 		mountExpression: t.callExpression(t.identifier(tplName + "_create"), disposerArg),
-		importsNeeded: ctx.importsNeeded
+		importsNeeded: ctx.importsNeeded,
+		watchFiles: [...watchFiles]
 	};
 }
 function collectCopiedImports(ast, componentPath, mountFilePath, resolveImportPath, compiledImportNames) {
@@ -6246,7 +7494,7 @@ function toRelativeImportSource(fromFile, targetFile) {
 	if (!source.startsWith(".")) source = "./" + source;
 	return source;
 }
-function collectImportedStaticFunctionComponents(ast, importerPath, resolveImportPath, ctx, importedFns) {
+function collectImportedStaticFunctionComponents(ast, importerPath, resolveImportPath, ctx, importedFns, watchFiles) {
 	for (const stmt of ast.program.body) {
 		if (!t.isImportDeclaration(stmt)) continue;
 		if (stmt.source.value === "@geajs/core") continue;
@@ -6256,6 +7504,7 @@ function collectImportedStaticFunctionComponents(ast, importerPath, resolveImpor
 		if (componentSpecs.length === 0) continue;
 		const resolved = resolveImportPath(importerPath, stmt.source.value);
 		if (!resolved) return false;
+		watchFiles.add(resolved);
 		const imported = readImportModule(resolved);
 		if (!imported) return false;
 		for (const spec of componentSpecs) {
@@ -6816,11 +8065,21 @@ function shouldMinifyGeaSymbolsForBuild(config) {
 	const formats = lib.formats ?? [];
 	return formats.length > 0 && formats.every((format) => format === "iife" || format === "umd");
 }
-function geaPlugin() {
+function geaPlugin(options = {}) {
+	const envIrOutFile = process.env.GEA_IR_OUT || process.env.GEA_IR_FILE;
+	const irOptions = options.ir ?? (envIrOutFile ? {
+		enabled: true,
+		outFile: envIrOutFile
+	} : void 0);
 	const storeModules = /* @__PURE__ */ new Set();
 	const componentModules = /* @__PURE__ */ new Set();
 	let isServeCommand = false;
 	let shouldMinifyGeaSymbolKeys = false;
+	let resolvedConfig = null;
+	const irModules = /* @__PURE__ */ new Map();
+	const irComponents = /* @__PURE__ */ new Map();
+	const irStores = /* @__PURE__ */ new Map();
+	const hostCapabilities = /* @__PURE__ */ new Set();
 	const storeRegistry = /* @__PURE__ */ new Map();
 	const resolveImportPath = (importer, source) => {
 		const base = resolve(dirname(importer), source);
@@ -6931,6 +8190,7 @@ function geaPlugin() {
 		name: "gea-plugin",
 		enforce: "pre",
 		configResolved(config) {
+			resolvedConfig = config;
 			isServeCommand = config.command === "serve";
 			shouldMinifyGeaSymbolKeys = shouldMinifyGeaSymbolsForBuild(config);
 		},
@@ -6977,6 +8237,7 @@ function geaPlugin() {
 			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 (code.includes("extends Store") || code.includes("new Store(")) {
 				storeModules.add(cleanId);
 				const storeClassName = extractStoreClassName(code);
@@ -6989,22 +8250,30 @@ function geaPlugin() {
 				}
 			}
 			if (/\bclass\s+Component\s+extends\s+Store\b/.test(code)) return null;
-			if (!isServeCommand && !isSSR) {
+			if (!isSSR) {
 				const observeResult = transformDottedObserveCalls(transformedCode);
 				if (observeResult?.changed) {
 					transformedCode = observeResult.code;
 					changed = true;
 				}
-				const storeResult = transformCompiledStoreModule(transformedCode);
-				if (storeResult?.changed) return {
-					code: storeResult.code,
-					map: null
-				};
+				const storeResult = transformCompiledStoreModule(transformedCode, cleanId, resolveImportPath);
+				for (const storeIr of storeResult?.irs ?? (storeResult?.ir ? [storeResult.ir] : [])) recordStoreIr(cleanId, storeIr);
+				if (storeResult?.changed) {
+					if (!/\bextends\s+(Component|ReactiveComponent)\b|\bmount\s*\(/.test(storeResult.code)) return {
+						code: storeResult.code,
+						map: null
+					};
+					transformedCode = storeResult.code;
+					changed = true;
+				}
 				const rootMountResult = transformStaticRootMount(transformedCode, cleanId, resolveImportPath);
-				if (rootMountResult?.changed) return {
-					code: rootMountResult.code,
-					map: null
-				};
+				if (rootMountResult?.changed) {
+					for (const file of rootMountResult.watchFiles ?? []) this.addWatchFile?.(file);
+					return {
+						code: rootMountResult.code,
+						map: null
+					};
+				}
 			}
 			const result = transform({
 				sourceFile: cleanId,
@@ -7020,7 +8289,15 @@ function geaPlugin() {
 				registerStoreModule: (fp) => storeModules.add(fp),
 				registerComponentModule: (fp) => componentModules.add(fp)
 			});
-			if (result) return result;
+			if (result) {
+				if (result.ir) recordComponentIr(cleanId, result.ir);
+				if (result.ir?.components.some((component) => component.reactiveState)) return {
+					code: result.code,
+					map: result.map ?? null,
+					moduleSideEffects: "no-treeshake"
+				};
+				return result;
+			}
 			if (isServeCommand && !isSSR) {
 				const componentDeps = findComponentDeps(transformedCode, cleanId);
 				if (componentDeps.length > 0) {
@@ -7044,8 +8321,136 @@ function geaPlugin() {
 				code: next,
 				map: null
 			};
+		},
+		generateBundle(_options, bundle) {
+			if (!irOptions?.enabled) return;
+			const renderedIds = renderedModuleIds(bundle);
+			const modules = Array.from(irModules.values()).filter((module) => {
+				if (!renderedIds) return true;
+				return renderedIds.has(cleanRollupModuleId(module.id)) || renderedIds.has(cleanRollupModuleId(module.file));
+			});
+			const componentIds = new Set(modules.flatMap((module) => module.components));
+			const storeIds = new Set(modules.flatMap((module) => module.stores));
+			const moduleById = new Map(Array.from(irModules.values()).map((module) => [module.id, module]));
+			const pending = Array.from(componentIds);
+			while (pending.length > 0) {
+				const component = irComponents.get(pending.pop());
+				if (!component) continue;
+				for (const tag of collectMountTags(component.template.slots)) for (const candidate of irComponents.values()) {
+					if (candidate.exportName !== tag || componentIds.has(candidate.id)) continue;
+					componentIds.add(candidate.id);
+					pending.push(candidate.id);
+					const candidateModule = moduleById.get(candidate.module);
+					if (candidateModule && !modules.includes(candidateModule)) modules.push(candidateModule);
+				}
+			}
+			const irBundle = {
+				schema: "gea-ir",
+				version: 1,
+				entry: geaIrEntryFromBundle(bundle) ?? geaIrConfiguredEntry(resolvedConfig),
+				modules,
+				components: Array.from(irComponents.values()).filter((component) => componentIds.has(component.id)),
+				stores: Array.from(irStores.values()).filter((store) => storeIds.has(store.id)),
+				hostCapabilities: Array.from(hostCapabilities).sort()
+			};
+			const source = JSON.stringify(irBundle, null, 2);
+			const outFile = irOptions.outFile ?? "gea-ir.json";
+			if (outFile.startsWith("/") || /^[A-Za-z]:[\\/]/.test(outFile)) {
+				mkdirSync(dirname(outFile), { recursive: true });
+				writeFileSync(outFile, source);
+			} else this.emitFile({
+				type: "asset",
+				fileName: outFile,
+				source
+			});
 		}
 	};
+	function collectMountTags(slots, tags = /* @__PURE__ */ new Set(), depth = 0) {
+		if (depth > 8 || !Array.isArray(slots)) return tags;
+		for (const slot of slots) {
+			if (!slot || typeof slot !== "object") continue;
+			const { kind, payload } = slot;
+			if (!payload || typeof payload !== "object") continue;
+			const record = payload;
+			if (kind === "mount" && typeof record.tag === "string") tags.add(record.tag);
+			for (const key of Object.keys(record)) {
+				if (key === "attrs" || key === "children") continue;
+				const value = record[key];
+				if (value && typeof value === "object" && Array.isArray(value.slots)) collectMountTags(value.slots, tags, depth + 1);
+			}
+		}
+		return tags;
+	}
+	function recordComponentIr(moduleId, ir) {
+		const existing = irModules.get(moduleId) ?? {
+			id: moduleId,
+			file: moduleId,
+			components: [],
+			stores: []
+		};
+		const componentIds = new Set(existing.components);
+		for (const component of ir.components) {
+			irComponents.set(component.id, component);
+			componentIds.add(component.id);
+		}
+		irModules.set(moduleId, {
+			...existing,
+			components: Array.from(componentIds)
+		});
+	}
+	function recordStoreIr(moduleId, store) {
+		const existing = irModules.get(moduleId) ?? {
+			id: moduleId,
+			file: moduleId,
+			components: [],
+			stores: []
+		};
+		const storeIds = new Set(existing.stores);
+		irStores.set(store.id, store);
+		storeIds.add(store.id);
+		irModules.set(moduleId, {
+			...existing,
+			stores: Array.from(storeIds)
+		});
+	}
+	function recordHostCapabilities(source) {
+		if (/\bfetch\s*\(/.test(source)) hostCapabilities.add("fetch");
+		if (source.includes("https://")) hostCapabilities.add("https");
+		if (/\bApps\s*\./.test(source)) hostCapabilities.add("apps");
+		if (/\b(?:BLE|BLEServer)\b|\bgea_embedded_ble_|\b__gea_embedded_ble_/.test(source)) hostCapabilities.add("ble");
+		if (/\bWiFi\s*\./.test(source)) hostCapabilities.add("wifi");
+		if (/\b(?:Accelerometer|accelerometer)\s*\.|\bgea_embedded_imu_/.test(source)) hostCapabilities.add("imu");
+		if (/\baudioContext\s*\.|\b__gea_audioContext\b|\b__gea_Audio\b/.test(source)) hostCapabilities.add("audio");
+		if (/\bscreen\s*\./.test(source)) hostCapabilities.add("screen");
+		if (/\b__gea_embedded_image\b/.test(source)) hostCapabilities.add("image");
+		if (/\b__gea_embedded_touch\b/.test(source)) hostCapabilities.add("touch");
+		if (/\bdocument\s*\./.test(source)) hostCapabilities.add("dom");
+	}
+}
+function renderedModuleIds(bundle) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const item of Object.values(bundle)) {
+		if (item.type !== "chunk") continue;
+		if (item.facadeModuleId) ids.add(cleanRollupModuleId(item.facadeModuleId));
+		if (item.modules && typeof item.modules === "object") for (const id of Object.keys(item.modules)) ids.add(cleanRollupModuleId(id));
+	}
+	return ids.size > 0 ? ids : null;
+}
+function cleanRollupModuleId(id) {
+	return id.split("?")[0] ?? id;
+}
+function geaIrEntryFromBundle(bundle) {
+	return Object.values(bundle).filter((item) => item.type === "chunk" && item.isEntry && item.fileName).map((item) => item.fileName).sort()[0] ?? null;
+}
+function geaIrConfiguredEntry(config) {
+	const input = config?.build.rollupOptions.input;
+	if (typeof input === "string") return input;
+	if (Array.isArray(input)) return input[0] ? String(input[0]) : "";
+	if (input && typeof input === "object") {
+		const firstKey = Object.keys(input).sort()[0];
+		return firstKey ? String(input[firstKey]) : "";
+	}
+	return "";
 }
 function resolveToFile(base) {
 	const exts = [
@@ -7098,6 +8503,7 @@ function compilerRuntimeSource(runtimePath) {
   relationalClass,
   relationalClassProp,
   reactiveStyle,
+  reactiveStyleProp,
   reactiveValue,
   reactiveValueRead,
   delegateEvent,