@fluixi/compiler 1.0.0-alpha.100

package/dist/lower/text.cjs

@@ -0,0 +1,42 @@
+"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.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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;
+//# sourceMappingURL=text.d.ts.map

package/dist/lower/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/lower/text.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,kFAAkF;AAClF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAgBvD"}

package/dist/lower/text.js

@@ -0,0 +1,31 @@
+/**
+ * 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 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.mjs

@@ -0,0 +1,21 @@
+// 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

@@ -0,0 +1,112 @@
+"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.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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.js';
+/** 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[];
+//# sourceMappingURL=analyze-static.d.ts.map

package/dist/optimize/analyze-static.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-static.d.ts","sourceRoot":"","sources":["../../src/optimize/analyze-static.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAU,MAAM,gBAAgB,CAAC;AAEhE,sFAAsF;AACtF,MAAM,MAAM,aAAa,GACrB,eAAe,GACf,iBAAiB,GACjB,OAAO,GACP,KAAK,GACL,QAAQ,GACR,0BAA0B,GAC1B,kBAAkB,GAClB,iBAAiB,GACjB,eAAe,CAAC;AAEpB,MAAM,WAAW,YAAY;IAC3B,8CAA8C;IAC9C,cAAc,EAAE,SAAS,EAAE,CAAC;IAC5B,2EAA2E;IAC3E,OAAO,EAAE,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;CACxC;AA+BD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,YAAY,CA2DnE;AAeD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,EAAE,CAchE"}

package/dist/optimize/analyze-static.js

@@ -0,0 +1,131 @@
+/**
+ * A prop is inert only when it is a plain attribute or property with a literal value.
+ *
+ * `expr` means arbitrary JS, which may read a signal or allocate, so it is dynamic even
+ * when `reactive` is false: a non-reactive expression still has to run per instance.
+ */
+function propReason(prop) {
+    switch (prop.kind) {
+        case 'event':
+            return 'event';
+        case 'ref':
+            return 'ref';
+        case 'spread':
+            return 'spread';
+        case 'class':
+        case 'style':
+            // classList/style objects are built from expressions even when they look literal.
+            return 'class-or-style-directive';
+        case 'attr':
+        case 'prop':
+            if (prop.reactive)
+                return 'reactive-prop';
+            if (prop.expr !== undefined)
+                return 'expression-prop';
+            return undefined;
+        /* c8 ignore next 2 */
+        default:
+            return 'expression-prop';
+    }
+}
+/**
+ * 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 function analyzeStatic(root) {
+    const staticElements = [];
+    const reasons = new Map();
+    /** Returns whether `node` is static, marking elements bottom-up. */
+    const visit = (node) => {
+        switch (node.kind) {
+            case 'text':
+                return true;
+            case 'expr':
+                // A hole is dynamic even when it is not reactive: its value is computed.
+                return false;
+            case 'component':
+            case 'control':
+                // Both produce their own subtree at runtime, so an ancestor cannot be cloned
+                // wholesale. Still walk in, so nested elements are marked for their own sake.
+                for (const child of node.children)
+                    visit(child);
+                return false;
+            case 'fragment':
+                // A fragment is not an element and cannot itself be cloned, but its children
+                // can be considered independently.
+                for (const child of node.children)
+                    visit(child);
+                return false;
+            case 'element': {
+                // Children are visited first and unconditionally, so a static subtree nested
+                // under a dynamic parent is still marked and can be cloned on its own.
+                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 };
+}
+/** The most specific reason a child made its parent dynamic. */
+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';
+    }
+    /* c8 ignore next */
+    return 'expression-child';
+}
+/**
+ * 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 function staticRoots(root) {
+    const roots = [];
+    const visit = (node) => {
+        if (node.kind === 'element' && node.static) {
+            roots.push(node);
+            return; // its subtree is inside this template
+        }
+        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.mjs

@@ -0,0 +1,91 @@
+// 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

@@ -0,0 +1,90 @@
+"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;