@fluixi/compiler 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/lower/text.cjs

@@ -1 +1,42 @@
-"use strict";var f=Object.defineProperty;var o=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var s=(l,e)=>{for(var n in e)f(l,n,{get:e[n],enumerable:!0})},a=(l,e,n,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of c(e))!p.call(l,t)&&t!==n&&f(l,t,{get:()=>e[t],enumerable:!(r=o(e,t))||r.enumerable});return l};var g=l=>a(f({},"__esModule",{value:!0}),l);var h={};s(h,{cleanTemplateText:()=>u});module.exports=g(h);function u(l){let e=l.split(/\r\n|\n|\r/),n=0;for(let t=0;t<e.length;t++)/[^ \t]/.test(e[t])&&(n=t);let r="";for(let t=0;t<e.length;t++){let i=e[t].replace(/\t/g," ");t!==0&&(i=i.replace(/^ +/,"")),t!==e.length-1&&(i=i.replace(/ +$/,"")),i&&(t!==n&&(i+=" "),r+=i)}return r}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lower/text.ts
+var text_exports = {};
+__export(text_exports, {
+  cleanTemplateText: () => cleanTemplateText
+});
+module.exports = __toCommonJS(text_exports);
+function cleanTemplateText(value) {
+  const lines = value.split(/\r\n|\n|\r/);
+  let lastNonEmpty = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (/[^ \t]/.test(lines[i])) lastNonEmpty = i;
+  }
+  let out = "";
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i].replace(/\t/g, " ");
+    if (i !== 0) line = line.replace(/^ +/, "");
+    if (i !== lines.length - 1) line = line.replace(/ +$/, "");
+    if (!line) continue;
+    if (i !== lastNonEmpty) line += " ";
+    out += line;
+  }
+  return out;
+}

package/dist/lower/text.d.cts

@@ -0,0 +1,10 @@
+/**
+ * Whitespace handling for template text runs.
+ *
+ * JSX and `` html`...` `` collapse a text run the same way — the rule came from
+ * JSX and the template syntax adopted it so an author moving between the two
+ * gets the same output. It is pure string work with no parser in it, so it lives
+ * here rather than in a front-end, where both can reach it and neither owns it.
+ */
+/** Canonical JSX text cleaning — kept identical to plugin.ts cleanTemplateText. */
+export declare function cleanTemplateText(value: string): string;

package/dist/lower/text.mjs

@@ -1 +1,21 @@
-function f(r){let l=r.split(/\r\n|\n|\r/),n=0;for(let t=0;t<l.length;t++)/[^ \t]/.test(l[t])&&(n=t);let i="";for(let t=0;t<l.length;t++){let e=l[t].replace(/\t/g," ");t!==0&&(e=e.replace(/^ +/,"")),t!==l.length-1&&(e=e.replace(/ +$/,"")),e&&(t!==n&&(e+=" "),i+=e)}return i}export{f as cleanTemplateText};
+// src/lower/text.ts
+function cleanTemplateText(value) {
+  const lines = value.split(/\r\n|\n|\r/);
+  let lastNonEmpty = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (/[^ \t]/.test(lines[i])) lastNonEmpty = i;
+  }
+  let out = "";
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i].replace(/\t/g, " ");
+    if (i !== 0) line = line.replace(/^ +/, "");
+    if (i !== lines.length - 1) line = line.replace(/ +$/, "");
+    if (!line) continue;
+    if (i !== lastNonEmpty) line += " ";
+    out += line;
+  }
+  return out;
+}
+export {
+  cleanTemplateText
+};

package/dist/optimize/analyze-static.cjs

@@ -1 +1,112 @@
-"use strict";var a=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var d=(r,e)=>{for(var s in e)a(r,s,{get:e[s],enumerable:!0})},u=(r,e,s,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of f(e))!p.call(r,t)&&t!==s&&a(r,t,{get:()=>e[t],enumerable:!(n=l(e,t))||n.enumerable});return r};var R=r=>u(a({},"__esModule",{value:!0}),r);var y={};d(y,{analyzeStatic:()=>m,staticRoots:()=>x});module.exports=R(y);function h(r){switch(r.kind){case"event":return"event";case"ref":return"ref";case"spread":return"spread";case"class":case"style":return"class-or-style-directive";case"attr":case"prop":return r.reactive?"reactive-prop":r.expr!==void 0?"expression-prop":void 0;default:return"expression-prop"}}function m(r){let e=[],s=new Map,n=t=>{switch(t.kind){case"text":return!0;case"expr":return!1;case"component":case"control":for(let i of t.children)n(i);return!1;case"fragment":for(let i of t.children)n(i);return!1;case"element":{let i=!0;for(let o of t.children)n(o)||(i=!1);let c;for(let o of t.props)if(c=h(o),c)break;return!c&&!i&&(c=I(t)),t.static=!c,c?s.set(t,c):e.push(t),t.static}default:return!1}};for(let t of Array.isArray(r)?r:[r])n(t);return{staticElements:e,reasons:s}}function I(r){for(let e of r.children){if(e.kind==="expr")return"expression-child";if(e.kind==="component")return"component-child";if(e.kind==="control")return"control-child";if(e.kind==="element"&&!e.static||e.kind==="fragment")return"expression-child"}return"expression-child"}function x(r){let e=[],s=n=>{if(n.kind==="element"&&n.static){e.push(n);return}let t=n.children;if(t)for(let i of t)s(i)};for(let n of Array.isArray(r)?r:[r])s(n);return e}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/optimize/analyze-static.ts
+var analyze_static_exports = {};
+__export(analyze_static_exports, {
+  analyzeStatic: () => analyzeStatic,
+  staticRoots: () => staticRoots
+});
+module.exports = __toCommonJS(analyze_static_exports);
+function propReason(prop) {
+  switch (prop.kind) {
+    case "event":
+      return "event";
+    case "ref":
+      return "ref";
+    case "spread":
+      return "spread";
+    case "class":
+    case "style":
+      return "class-or-style-directive";
+    case "attr":
+    case "prop":
+      if (prop.reactive) return "reactive-prop";
+      if (prop.expr !== void 0) return "expression-prop";
+      return void 0;
+    /* c8 ignore next 2 */
+    default:
+      return "expression-prop";
+  }
+}
+function analyzeStatic(root) {
+  const staticElements = [];
+  const reasons = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    switch (node.kind) {
+      case "text":
+        return true;
+      case "expr":
+        return false;
+      case "component":
+      case "control":
+        for (const child of node.children) visit(child);
+        return false;
+      case "fragment":
+        for (const child of node.children) visit(child);
+        return false;
+      case "element": {
+        let childrenStatic = true;
+        for (const child of node.children) {
+          if (!visit(child)) childrenStatic = false;
+        }
+        let reason;
+        for (const prop of node.props) {
+          reason = propReason(prop);
+          if (reason) break;
+        }
+        if (!reason && !childrenStatic) {
+          reason = childReason(node);
+        }
+        node.static = !reason;
+        if (reason) reasons.set(node, reason);
+        else staticElements.push(node);
+        return node.static;
+      }
+      /* c8 ignore next 2 */
+      default:
+        return false;
+    }
+  };
+  for (const node of Array.isArray(root) ? root : [root]) visit(node);
+  return { staticElements, reasons };
+}
+function childReason(node) {
+  for (const child of node.children) {
+    if (child.kind === "expr") return "expression-child";
+    if (child.kind === "component") return "component-child";
+    if (child.kind === "control") return "control-child";
+    if (child.kind === "element" && !child.static) return "expression-child";
+    if (child.kind === "fragment") return "expression-child";
+  }
+  return "expression-child";
+}
+function staticRoots(root) {
+  const roots = [];
+  const visit = (node) => {
+    if (node.kind === "element" && node.static) {
+      roots.push(node);
+      return;
+    }
+    const children = node.children;
+    if (children) for (const child of children) visit(child);
+  };
+  for (const node of Array.isArray(root) ? root : [root]) visit(node);
+  return roots;
+}

package/dist/optimize/analyze-static.d.cts

@@ -0,0 +1,39 @@
+/**
+ * Static analysis: mark the element subtrees that never change after creation.
+ *
+ * A static subtree can be built once as an HTML string and cloned per instance, instead
+ * of constructed an element at a time. That is the difference between one `cloneNode`
+ * and N `createElement` + N `spread` calls — measured at 2.1x faster for a three-element
+ * row and 2.4x for a nine-element card, with the gap widening as components grow.
+ *
+ * `IRElement.static` has existed since the IR was written, documented as
+ * "subtree has no dynamic parts → hoistable (template-clone)", but was hardcoded `false`
+ * with no producer. This is the producer.
+ *
+ * The analysis is deliberately conservative: marking something static that is not is a
+ * correctness bug (a shared DOM node across renders), while missing one is only a lost
+ * optimisation. Anything not positively known to be inert makes its whole ancestry
+ * dynamic.
+ */
+import type { IRNode, IRElement } from '../ir/nodes.cjs';
+/** Why a subtree could not be treated as static. Useful for diagnostics and tests. */
+export type DynamicReason = 'reactive-prop' | 'expression-prop' | 'event' | 'ref' | 'spread' | 'class-or-style-directive' | 'expression-child' | 'component-child' | 'control-child';
+export interface StaticReport {
+    /** Elements marked static, in visit order. */
+    staticElements: IRElement[];
+    /** Why each non-static element was rejected, keyed by the element node. */
+    reasons: Map<IRElement, DynamicReason>;
+}
+/**
+ * Mark every static element in the tree, returning what was decided.
+ *
+ * Mutates `IRElement.static` in place, since that field is the contract codegen reads.
+ */
+export declare function analyzeStatic(root: IRNode | IRNode[]): StaticReport;
+/**
+ * The outermost static elements — the roots worth turning into templates.
+ *
+ * Cloning a static child of a static parent is wasted: the parent's template already
+ * contains it.
+ */
+export declare function staticRoots(root: IRNode | IRNode[]): IRElement[];

package/dist/optimize/analyze-static.mjs

@@ -1 +1,91 @@
-function a(r){switch(r.kind){case"event":return"event";case"ref":return"ref";case"spread":return"spread";case"class":case"style":return"class-or-style-directive";case"attr":case"prop":return r.reactive?"reactive-prop":r.expr!==void 0?"expression-prop":void 0;default:return"expression-prop"}}function f(r){let t=[],c=new Map,n=e=>{switch(e.kind){case"text":return!0;case"expr":return!1;case"component":case"control":for(let s of e.children)n(s);return!1;case"fragment":for(let s of e.children)n(s);return!1;case"element":{let s=!0;for(let o of e.children)n(o)||(s=!1);let i;for(let o of e.props)if(i=a(o),i)break;return!i&&!s&&(i=l(e)),e.static=!i,i?c.set(e,i):t.push(e),e.static}default:return!1}};for(let e of Array.isArray(r)?r:[r])n(e);return{staticElements:t,reasons:c}}function l(r){for(let t of r.children){if(t.kind==="expr")return"expression-child";if(t.kind==="component")return"component-child";if(t.kind==="control")return"control-child";if(t.kind==="element"&&!t.static||t.kind==="fragment")return"expression-child"}return"expression-child"}function p(r){let t=[],c=n=>{if(n.kind==="element"&&n.static){t.push(n);return}let e=n.children;if(e)for(let s of e)c(s)};for(let n of Array.isArray(r)?r:[r])c(n);return t}export{f as analyzeStatic,p as staticRoots};
+// src/optimize/analyze-static.ts
+function propReason(prop) {
+  switch (prop.kind) {
+    case "event":
+      return "event";
+    case "ref":
+      return "ref";
+    case "spread":
+      return "spread";
+    case "class":
+    case "style":
+      return "class-or-style-directive";
+    case "attr":
+    case "prop":
+      if (prop.reactive) return "reactive-prop";
+      if (prop.expr !== void 0) return "expression-prop";
+      return void 0;
+    /* c8 ignore next 2 */
+    default:
+      return "expression-prop";
+  }
+}
+function analyzeStatic(root) {
+  const staticElements = [];
+  const reasons = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    switch (node.kind) {
+      case "text":
+        return true;
+      case "expr":
+        return false;
+      case "component":
+      case "control":
+        for (const child of node.children) visit(child);
+        return false;
+      case "fragment":
+        for (const child of node.children) visit(child);
+        return false;
+      case "element": {
+        let childrenStatic = true;
+        for (const child of node.children) {
+          if (!visit(child)) childrenStatic = false;
+        }
+        let reason;
+        for (const prop of node.props) {
+          reason = propReason(prop);
+          if (reason) break;
+        }
+        if (!reason && !childrenStatic) {
+          reason = childReason(node);
+        }
+        node.static = !reason;
+        if (reason) reasons.set(node, reason);
+        else staticElements.push(node);
+        return node.static;
+      }
+      /* c8 ignore next 2 */
+      default:
+        return false;
+    }
+  };
+  for (const node of Array.isArray(root) ? root : [root]) visit(node);
+  return { staticElements, reasons };
+}
+function childReason(node) {
+  for (const child of node.children) {
+    if (child.kind === "expr") return "expression-child";
+    if (child.kind === "component") return "component-child";
+    if (child.kind === "control") return "control-child";
+    if (child.kind === "element" && !child.static) return "expression-child";
+    if (child.kind === "fragment") return "expression-child";
+  }
+  return "expression-child";
+}
+function staticRoots(root) {
+  const roots = [];
+  const visit = (node) => {
+    if (node.kind === "element" && node.static) {
+      roots.push(node);
+      return;
+    }
+    const children = node.children;
+    if (children) for (const child of children) visit(child);
+  };
+  for (const node of Array.isArray(root) ? root : [root]) visit(node);
+  return roots;
+}
+export {
+  analyzeStatic,
+  staticRoots
+};

package/dist/optimize/collapse-strategies.cjs

@@ -1 +1,90 @@
-"use strict";var d=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var R=Object.prototype.hasOwnProperty;var v=(e,o)=>{for(var t in o)d(e,t,{get:o[t],enumerable:!0})},x=(e,o,t,i)=>{if(o&&typeof o=="object"||typeof o=="function")for(let n of g(o))!R.call(e,n)&&n!==t&&d(e,n,{get:()=>o[n],enumerable:!(i=f(o,n))||i.enumerable});return e};var S=e=>x(d({},"__esModule",{value:!0}),e);var E={};v(E,{collapseStrategies:()=>I});module.exports=S(E);function l(e){return e.kind!=="eager"&&e.kind!=="never"}var u=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],p=["Suspense","SuspenseList","Await"],m=["Router","Outlet","Redirect","Link"],O=[...u,...p,...m],C=new Set([...u,...p]);function c(e,o){let t=Array.isArray(e)?e:[e];for(let i of t){o(i);let n=i.children;n&&c(n,o)}}function I(e){let o=[];c(e,r=>{r.kind==="component"&&r.source&&o.push(r)});let t=new Set,i=new Set;for(let r of o){let{module:s,loading:a}=r.source;a.kind==="eager"&&t.add(s),a.kind==="never"&&i.add(s)}let n=new Map;for(let r of o){let s=r.source;l(s.loading)&&t.has(s.module)&&(s.loading={kind:"eager"},n.set(s.module,(n.get(s.module)??0)+1))}return{collapsed:n,conflicted:[...i].filter(r=>t.has(r))}}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/optimize/collapse-strategies.ts
+var collapse_strategies_exports = {};
+__export(collapse_strategies_exports, {
+  collapseStrategies: () => collapseStrategies
+});
+module.exports = __toCommonJS(collapse_strategies_exports);
+
+// src/resolve/load-directive.ts
+function isDeferred(strategy) {
+  return strategy.kind !== "eager" && strategy.kind !== "never";
+}
+
+// src/resolve/builtins.ts
+var DOM_CONTROL_FLOW = [
+  "Show",
+  "For",
+  "Index",
+  "Switch",
+  "Match",
+  "Portal",
+  "Dynamic",
+  "ErrorBoundary"
+];
+var CORE_CONTROL_FLOW = ["Suspense", "SuspenseList", "Await"];
+var ROUTER_COMPONENTS = ["Router", "Outlet", "Redirect", "Link"];
+var BUILTIN_COMPONENTS = [
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW,
+  ...ROUTER_COMPONENTS
+];
+var RESERVED_COMPONENTS = /* @__PURE__ */ new Set([
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW
+]);
+
+// src/resolve/resolve-ir.ts
+function walk(root, visit) {
+  const nodes = Array.isArray(root) ? root : [root];
+  for (const node of nodes) {
+    visit(node);
+    const children = node.children;
+    if (children) walk(children, visit);
+  }
+}
+
+// src/optimize/collapse-strategies.ts
+function collapseStrategies(root) {
+  const components = [];
+  walk(root, (node) => {
+    if (node.kind === "component" && node.source) components.push(node);
+  });
+  const eager = /* @__PURE__ */ new Set();
+  const never = /* @__PURE__ */ new Set();
+  for (const node of components) {
+    const { module: module2, loading } = node.source;
+    if (loading.kind === "eager") eager.add(module2);
+    if (loading.kind === "never") never.add(module2);
+  }
+  const collapsed = /* @__PURE__ */ new Map();
+  for (const node of components) {
+    const source = node.source;
+    if (!isDeferred(source.loading)) continue;
+    if (!eager.has(source.module)) continue;
+    source.loading = { kind: "eager" };
+    collapsed.set(source.module, (collapsed.get(source.module) ?? 0) + 1);
+  }
+  return {
+    collapsed,
+    conflicted: [...never].filter((m) => eager.has(m))
+  };
+}

package/dist/optimize/collapse-strategies.d.cts

@@ -0,0 +1,30 @@
+/**
+ * Strategy collapsing — demote a deferred reference whose module is already present.
+ *
+ * This is not a nice-to-have. Without it the naive feature is a regression: if a module
+ * is referenced eagerly anywhere in the compilation unit, it is in the parent chunk
+ * already, so a `load:visible` boundary elsewhere adds a wrapper, a promise and a
+ * re-render in order to fetch nothing. The bytes are paid twice — once in the chunk,
+ * once in the deferral machinery — and the component renders later than it needs to.
+ *
+ * Collapsing runs per module, not per component name, because a chunk is a module:
+ * `<Button>` eager and `<ButtonGroup load:visible>` from the same package means the
+ * package is already loaded, so deferring the second buys nothing.
+ *
+ * `never` is not collapsed. It means "no client code at all", which is a statement about
+ * what should exist rather than about when to fetch it; an eager sibling does not make a
+ * server-only component suddenly belong in the client bundle. That combination is
+ * contradictory and reported instead.
+ */
+import type { IRNode } from '../ir/nodes.cjs';
+export interface CollapseReport {
+    /** Modules demoted to eager, with the reference count that was demoted. */
+    collapsed: Map<string, number>;
+    /**
+     * Modules referenced both as `load:never` and in a way that needs client code.
+     * Contradictory rather than optimisable, so it is reported and left alone.
+     */
+    conflicted: string[];
+}
+/** Demote deferred references to modules that are already in the chunk. */
+export declare function collapseStrategies(root: IRNode | IRNode[]): CollapseReport;

package/dist/optimize/collapse-strategies.mjs

@@ -1 +1,67 @@
-function a(o){return o.kind!=="eager"&&o.kind!=="never"}var l=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],u=["Suspense","SuspenseList","Await"],p=["Router","Outlet","Redirect","Link"],g=[...l,...u,...p],m=new Set([...l,...u]);function d(o,t){let i=Array.isArray(o)?o:[o];for(let s of i){t(s);let r=s.children;r&&d(r,t)}}function w(o){let t=[];d(o,e=>{e.kind==="component"&&e.source&&t.push(e)});let i=new Set,s=new Set;for(let e of t){let{module:n,loading:c}=e.source;c.kind==="eager"&&i.add(n),c.kind==="never"&&s.add(n)}let r=new Map;for(let e of t){let n=e.source;a(n.loading)&&i.has(n.module)&&(n.loading={kind:"eager"},r.set(n.module,(r.get(n.module)??0)+1))}return{collapsed:r,conflicted:[...s].filter(e=>i.has(e))}}export{w as collapseStrategies};
+// src/resolve/load-directive.ts
+function isDeferred(strategy) {
+  return strategy.kind !== "eager" && strategy.kind !== "never";
+}
+
+// src/resolve/builtins.ts
+var DOM_CONTROL_FLOW = [
+  "Show",
+  "For",
+  "Index",
+  "Switch",
+  "Match",
+  "Portal",
+  "Dynamic",
+  "ErrorBoundary"
+];
+var CORE_CONTROL_FLOW = ["Suspense", "SuspenseList", "Await"];
+var ROUTER_COMPONENTS = ["Router", "Outlet", "Redirect", "Link"];
+var BUILTIN_COMPONENTS = [
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW,
+  ...ROUTER_COMPONENTS
+];
+var RESERVED_COMPONENTS = /* @__PURE__ */ new Set([
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW
+]);
+
+// src/resolve/resolve-ir.ts
+function walk(root, visit) {
+  const nodes = Array.isArray(root) ? root : [root];
+  for (const node of nodes) {
+    visit(node);
+    const children = node.children;
+    if (children) walk(children, visit);
+  }
+}
+
+// src/optimize/collapse-strategies.ts
+function collapseStrategies(root) {
+  const components = [];
+  walk(root, (node) => {
+    if (node.kind === "component" && node.source) components.push(node);
+  });
+  const eager = /* @__PURE__ */ new Set();
+  const never = /* @__PURE__ */ new Set();
+  for (const node of components) {
+    const { module, loading } = node.source;
+    if (loading.kind === "eager") eager.add(module);
+    if (loading.kind === "never") never.add(module);
+  }
+  const collapsed = /* @__PURE__ */ new Map();
+  for (const node of components) {
+    const source = node.source;
+    if (!isDeferred(source.loading)) continue;
+    if (!eager.has(source.module)) continue;
+    source.loading = { kind: "eager" };
+    collapsed.set(source.module, (collapsed.get(source.module) ?? 0) + 1);
+  }
+  return {
+    collapsed,
+    conflicted: [...never].filter((m) => eager.has(m))
+  };
+}
+export {
+  collapseStrategies
+};

package/dist/options.cjs

@@ -1 +1,33 @@
-"use strict";var t=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var s=Object.prototype.hasOwnProperty;var m=(o,e)=>{for(var a in e)t(o,a,{get:e[a],enumerable:!0})},i=(o,e,a,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let l of p(e))!s.call(o,l)&&l!==a&&t(o,l,{get:()=>e[l],enumerable:!(n=r(e,l))||n.enumerable});return o};var d=o=>i(t({},"__esModule",{value:!0}),o);var b={};m(b,{defaultOptions:()=>v});module.exports=d(b);var v={backend:"imperative",moduleName:"@fluixi/dom",delegateEvents:!0,hydratable:!1,sourceMaps:!0,dev:!1};
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/options.ts
+var options_exports = {};
+__export(options_exports, {
+  defaultOptions: () => defaultOptions
+});
+module.exports = __toCommonJS(options_exports);
+var defaultOptions = {
+  backend: "imperative",
+  moduleName: "@fluixi/dom",
+  delegateEvents: true,
+  hydratable: false,
+  sourceMaps: true,
+  dev: false
+};

package/dist/options.d.cts

@@ -0,0 +1,39 @@
+import type { ComponentResolverRule } from './resolve/component-resolver.cjs';
+/**
+ * Public compiler options. This schema is the stable public API — it stays put
+ * as backends change. Switching DOM strategy is `backend`, not a rewrite.
+ */
+export interface CompilerOptions {
+    /**
+     * Clone static subtrees from a `<template>` instead of building them element by
+     * element. Roughly 2x faster to instantiate, but **client-only**: `createTemplate`
+     * produces real DOM nodes, which the SSR renderer's ServerElement tree rejects, and a
+     * clone creates a fresh node where hydration must adopt the existing one. Opt in for
+     * a client-rendered app; leave off wherever SSR or hydration is involved.
+     */
+    templateClone?: boolean;
+    /**
+     * Also clone subtrees whose *structure* is static but which contain dynamic holes —
+     * the common shape. Roughly halves the emitted code for such a subtree and replaces
+     * per-element construction with one clone.
+     *
+     * Works under SSR and hydration: each hole is bracketed by `<!--fx-->` markers, so its
+     * content is exactly the nodes between them and the server's markup has the same shape
+     * as the client's template. Hydration adopts those nodes rather than rebuilding them.
+     */
+    partialTemplates?: boolean;
+    /** which codegen backend to use */
+    backend?: 'imperative' | 'template-clone';
+    /** runtime module emitted symbols are imported from */
+    moduleName?: string;
+    delegateEvents?: boolean;
+    hydratable?: boolean;
+    sourceMaps?: boolean;
+    dev?: boolean;
+    /**
+     * Rules that resolve an unbound capitalised tag to a module, so a component can be
+     * used in a template without an import. See `createComponentResolver`.
+     */
+    resolve?: readonly ComponentResolverRule[];
+}
+export declare const defaultOptions: CompilerOptions;

package/dist/options.mjs

@@ -1 +1,12 @@
-var e={backend:"imperative",moduleName:"@fluixi/dom",delegateEvents:!0,hydratable:!1,sourceMaps:!0,dev:!1};export{e as defaultOptions};
+// src/options.ts
+var defaultOptions = {
+  backend: "imperative",
+  moduleName: "@fluixi/dom",
+  delegateEvents: true,
+  hydratable: false,
+  sourceMaps: true,
+  dev: false
+};
+export {
+  defaultOptions
+};