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

package/dist/{chunk-EZR7NZOY.mjs → chunk-6DB5FXS4.mjs}

@@ -1,4 +1,4 @@
-/*! @fluixi/compiler v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+/*! @fluixi/compiler v1.0.0-alpha.85 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
 import {
   INTRINSICS,
   RESERVED_COMPONENTS,
@@ -7,7 +7,7 @@ import {
   builtinComponentMap,
   isIntrinsicName,
   isPrimitiveModule
-} from "./chunk-MJV3UXIL.mjs";
+} from "./chunk-4PLHS2FP.mjs";
 
 // src/analyze/expr-shape.ts
 var CALL = /* @__PURE__ */ new Set(["CallExpression", "OptionalCallExpression"]);
@@ -1654,7 +1654,7 @@ var Lowerer = class {
       }
     ];
   }
-  /** A plain attribute (incl. lit `?bool`, mixed values) — old `mkProp` behavior. */
+  /** A plain attribute (incl. lit `?bool`, mixed values), old `mkProp` behavior. */
   plainAttr(a) {
     const v = a.value;
     let name = a.name;

package/dist/{chunk-FSSWUXUR.mjs → chunk-F74GFKSL.mjs}

@@ -1,4 +1,4 @@
-/*! @fluixi/compiler v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+/*! @fluixi/compiler v1.0.0-alpha.85 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
 
 // src/transform/server-fn-id.ts
 function hash(s) {

package/dist/{chunk-3YKZ4GNH.mjs → chunk-G6QC2WRJ.mjs}

@@ -1,4 +1,4 @@
-/*! @fluixi/compiler v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+/*! @fluixi/compiler v1.0.0-alpha.85 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {

package/dist/{chunk-R2VHAZAX.mjs → chunk-RUDJDZAA.mjs}

@@ -1,4 +1,4 @@
-/*! @fluixi/compiler v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+/*! @fluixi/compiler v1.0.0-alpha.85 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
 
 // ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
 var comma = ",".charCodeAt(0);

package/dist/codegen/backends/imperative.cjs

@@ -238,7 +238,7 @@ var INTRINSICS = {
   $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
   $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
   // No short runtime form for these yet, so the intrinsic stands for the `create*`
-  // name. Still worth having — no import to write — and when a shorter form is
+  // name. Still worth having: no import to write, and when a shorter form is
   // designed, the change is this line rather than a compiler pass.
   $selector: { export: "createSelector", module: REACTIVE_MODULE, returns: "memo-accessor" },
   $deferred: { export: "createDeferred", module: REACTIVE_MODULE, returns: "memo-accessor" },

package/dist/codegen/backends/imperative.d.cts

@@ -2,7 +2,7 @@ import type { CodegenBackend, StaticTemplate } from '../backend.cjs';
 /**
  * Substitute template declarations into the code as inline `createTemplate` calls.
  *
- * For hosts that cannot hoist — nested JSX lowered inside an expression, where there is
+ * For hosts that cannot hoist: nested JSX lowered inside an expression, where there is
  * no module scope to reach. `createTemplate` caches by HTML string, so this costs a Map
  * lookup per instantiation rather than a re-parse, and is still far cheaper than
  * building the subtree element by element.

package/dist/codegen/backends/imperative.d.ts

@@ -2,7 +2,7 @@ import type { CodegenBackend, StaticTemplate } from '../backend.js';
 /**
  * Substitute template declarations into the code as inline `createTemplate` calls.
  *
- * For hosts that cannot hoist — nested JSX lowered inside an expression, where there is
+ * For hosts that cannot hoist: nested JSX lowered inside an expression, where there is
  * no module scope to reach. `createTemplate` caches by HTML string, so this costs a Map
  * lookup per instantiation rather than a re-parse, and is still far cheaper than
  * building the subtree element by element.

package/dist/codegen/backends/imperative.js

@@ -4,7 +4,7 @@ import { RUNTIME_CONTRACT_V1 } from '../contract.js';
 import { markHole, markProps, SOURCE_MARKER } from '../../transform/source-locations.js';
 import { paren } from '../../analyze/paren.js';
 /**
- * Imperative fine-grained backend — emits createNativeElement/insert/spread/
+ * Imperative fine-grained backend: emits createNativeElement/insert/spread/
  * createComponent (RUNTIME_CONTRACT_V1), the runtime proven by the @fluixi/dom
  * contract tests.
  *
@@ -53,7 +53,7 @@ function propValue(p) {
 /**
  * Component props are passed as VALUES, not thunks (unlike native-element attrs).
  * The whole `createComponent(...)` call sits inside a `createMemo`, so reading a
- * signal in a prop re-evaluates when the memo re-runs — no per-prop thunk needed.
+ * signal in a prop re-evaluates when the memo re-runs, no per-prop thunk needed.
  * This matches the inline codegen; wrapping a prop like
  * `history={createMemoryHistory()}` in `() => …` would hand the component a
  * function instead of the value (e.g. `history.get is not a function`).
@@ -81,7 +81,7 @@ function emitProps(props, childrenExpr, used) {
 /**
  * The memo a component lowers to is an accessor, so it takes the same hole mark as any
  * other reactive binding. Without it, the insert that places the subtree reports whatever
- * the runtime stack says — a position in the compiled file.
+ * the runtime stack says: a position in the compiled file.
  */
 function markBind(code, at) {
     return at ? markHole(code, at.line, at.column) : code;
@@ -122,20 +122,20 @@ function emitComponent(name, props, children, used, templates, at) {
             propAt[p.name] = [p.at.line, p.at.column];
     if (Object.keys(propAt).length)
         obj = markProps(obj, propAt);
-    // The memo never recomputes — every prop is a getter, so this callback reads nothing
+    // The memo never recomputes: every prop is a getter, so this callback reads nothing
     // reactive. It is here for what it makes `insert` do, and it cannot be elided.
     //
     // A component whose return value is *itself* bare control flow (`return <Show …/>`)
     // produces a memo, which `createComponent` deliberately does not stamp as a component.
     // Without this wrapper `insert` stops re-reading it, and the subtree goes stale when a
-    // sibling updates the context it depends on — see `show-context-insert.spec.ts`.
+    // sibling updates the context it depends on: see `show-context-insert.spec.ts`.
     //
     // Static props are not a sufficient condition for dropping it either: safety depends on
     // what the callee *returns*, which lives in another module and is not visible here.
     //
     // Nor can it be a plain `() => createComponent(...)` thunk. The memo also provides
     // *identity*: it runs once and caches. A thunk is re-invoked by insert's render effect
-    // on every run, rebuilding the component with a fresh owner — which loses context,
+    // on every run, rebuilding the component with a fresh owner, which loses context,
     // duplicates the tree on hydration and piles up Portals. Measured: dropping the wrapper
     // fails 3 tests, replacing it with a thunk fails 14.
     //
@@ -179,7 +179,7 @@ function emitNode(node, used, templates) {
             return emitChildren(node.children, used, templates);
         case 'component':
             // No reactive prop means no `bindAt`, which is most tags. The insert that places the
-            // subtree still has to report somewhere, and the tag itself is where it was written —
+            // subtree still has to report somewhere, and the tag itself is where it was written , 
             // without this it reports whatever the runtime stack says, a line in the compiled file.
             return markBind(emitComponent(node.name, node.props, node.children, used, templates, node.at), node.bindAt ?? node.at);
         case 'control': {
@@ -192,7 +192,7 @@ function emitNode(node, used, templates) {
             // one cloneNode instead of an createNativeElement + spread per element.
             // SVG is excluded: the runtime wraps SVG template HTML in an <svg> host and
             // `cloneTemplate(t, true)` returns that wrapper, not the serialized element, so
-            // cloning would hand back the wrong node. Correctness first — SVG keeps the
+            // cloning would hand back the wrong node. Correctness first, SVG keeps the
             // imperative path until the runtime grows an unwrapping clone.
             if (templates && node.static && !node.svg && isSerializable(node)) {
                 used.add('templateNode');
@@ -205,7 +205,7 @@ function emitNode(node, used, templates) {
                     ? `templateNode(${id}, ${JSON.stringify(node.tag)}, false, false, ${JSON.stringify(at)})`
                     : `templateNode(${id}, ${JSON.stringify(node.tag)})`;
             }
-            // Structure static, contents dynamic — the common shape. One template for the
+            // Structure static, contents dynamic: the common shape. One template for the
             // structure, then each hole filled through a reference into the clone. Every
             // reference is read before any insertion, since inserting shifts later positions.
             if (templates && partial) {
@@ -227,7 +227,7 @@ function emitNode(node, used, templates) {
                     for (const step of plan.steps)
                         lines.push(`const ${step.ref} = ${step.expr};`);
                     for (const hole of plan.holes) {
-                        // The fourth argument is what the hole already holds — nothing on a fresh
+                        // The fourth argument is what the hole already holds, nothing on a fresh
                         // clone, the server's content when hydrating. `insert` reconciles against it,
                         // so hydration reuses those nodes rather than building new ones.
                         // `holeScope` places the hydration cursor at what the server rendered for
@@ -255,7 +255,7 @@ function emitNode(node, used, templates) {
             if (node.props.length > 0) {
                 // Literal attributes are written straight on. `spread` is a generic helper that
                 // walks every prop checking for reactivity, events, refs, class/style objects and
-                // namespaces — none of which a compile-time constant needs. Same predicate the
+                // namespaces: none of which a compile-time constant needs. Same predicate the
                 // template serializer uses, so the two agree on what a plain attribute is.
                 if (!node.svg && node.props.every(isPlainLiteralAttr)) {
                     for (const p of node.props)
@@ -287,7 +287,7 @@ function emitNode(node, used, templates) {
 /**
  * Substitute template declarations into the code as inline `createTemplate` calls.
  *
- * For hosts that cannot hoist — nested JSX lowered inside an expression, where there is
+ * For hosts that cannot hoist: nested JSX lowered inside an expression, where there is
  * no module scope to reach. `createTemplate` caches by HTML string, so this costs a Map
  * lookup per instantiation rather than a re-parse, and is still far cheaper than
  * building the subtree element by element.

package/dist/codegen/backends/imperative.mjs

@@ -211,7 +211,7 @@ var INTRINSICS = {
   $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
   $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
   // No short runtime form for these yet, so the intrinsic stands for the `create*`
-  // name. Still worth having — no import to write — and when a shorter form is
+  // name. Still worth having: no import to write, and when a shorter form is
   // designed, the change is this line rather than a compiler pass.
   $selector: { export: "createSelector", module: REACTIVE_MODULE, returns: "memo-accessor" },
   $deferred: { export: "createDeferred", module: REACTIVE_MODULE, returns: "memo-accessor" },

package/dist/codegen/contract.d.cts

@@ -11,13 +11,13 @@ export interface RuntimeContract {
     symbols: readonly string[];
 }
 /**
- * v1 — the imperative fine-grained runtime, locked by the @fluixi/dom contract
+ * v1: the imperative fine-grained runtime, locked by the @fluixi/dom contract
  * tests (createNativeElement/insert/spread/delegateEvents/createComponent + the
  * control-flow components).
  */
 export declare const RUNTIME_CONTRACT_V1: RuntimeContract;
 /**
- * v2 — adds the Solid-style (but ours) template-clone primitives. A future
+ * v2: adds the Solid-style (but ours) template-clone primitives. A future
  * template-clone backend targets this contract; the runtime gains template()/
  * cloneTemplate()/walk() at the same time.
  */

package/dist/codegen/contract.d.ts

@@ -11,13 +11,13 @@ export interface RuntimeContract {
     symbols: readonly string[];
 }
 /**
- * v1 — the imperative fine-grained runtime, locked by the @fluixi/dom contract
+ * v1: the imperative fine-grained runtime, locked by the @fluixi/dom contract
  * tests (createNativeElement/insert/spread/delegateEvents/createComponent + the
  * control-flow components).
  */
 export declare const RUNTIME_CONTRACT_V1: RuntimeContract;
 /**
- * v2 — adds the Solid-style (but ours) template-clone primitives. A future
+ * v2: adds the Solid-style (but ours) template-clone primitives. A future
  * template-clone backend targets this contract; the runtime gains template()/
  * cloneTemplate()/walk() at the same time.
  */

package/dist/codegen/contract.js

@@ -1,5 +1,5 @@
 /**
- * v1 — the imperative fine-grained runtime, locked by the @fluixi/dom contract
+ * v1: the imperative fine-grained runtime, locked by the @fluixi/dom contract
  * tests (createNativeElement/insert/spread/delegateEvents/createComponent + the
  * control-flow components).
  */
@@ -19,7 +19,7 @@ export const RUNTIME_CONTRACT_V1 = {
     ],
 };
 /**
- * v2 — adds the Solid-style (but ours) template-clone primitives. A future
+ * v2: adds the Solid-style (but ours) template-clone primitives. A future
  * template-clone backend targets this contract; the runtime gains template()/
  * cloneTemplate()/walk() at the same time.
  */

package/dist/codegen/partial-template.d.cts

@@ -1,13 +1,13 @@
 /**
  * Cloning a subtree whose *structure* is static but which contains dynamic holes.
  *
- * The fully-static case is easy: serialize, clone, done. The common case is not static —
- * a card wrapper with one reactive value inside — and a single hole used to send the
+ * The fully-static case is easy: serialize, clone, done. The common case is not static ,
+ * a card wrapper with one reactive value inside: and a single hole used to send the
  * whole subtree back to being built an element at a time. This plans the middle ground:
  * the structure becomes one template, and each hole is filled through a reference into
  * the cloned tree.
  *
- * Three things make it correct in all three environments — fresh client render, server
+ * Three things make it correct in all three environments, fresh client render, server
  * render, and hydration:
  *
  *  - **Each hole is bracketed by a marker pair.** A hole's content is then, by
@@ -26,7 +26,7 @@ import type { IRElement, IRNode } from '../ir/nodes.cjs';
  * The comments bracketing a hole.
  *
  * Named rather than anonymous so they are recognisable in devtools and in a page's
- * source — an unexplained `<!---->` is a support question.
+ * source: an unexplained `<!---->` is a support question.
  */
 export declare const HOLE_START = "<!--fx-->";
 export declare const HOLE_END = "<!--fx/-->";

package/dist/codegen/partial-template.d.ts

@@ -1,13 +1,13 @@
 /**
  * Cloning a subtree whose *structure* is static but which contains dynamic holes.
  *
- * The fully-static case is easy: serialize, clone, done. The common case is not static —
- * a card wrapper with one reactive value inside — and a single hole used to send the
+ * The fully-static case is easy: serialize, clone, done. The common case is not static ,
+ * a card wrapper with one reactive value inside: and a single hole used to send the
  * whole subtree back to being built an element at a time. This plans the middle ground:
  * the structure becomes one template, and each hole is filled through a reference into
  * the cloned tree.
  *
- * Three things make it correct in all three environments — fresh client render, server
+ * Three things make it correct in all three environments, fresh client render, server
  * render, and hydration:
  *
  *  - **Each hole is bracketed by a marker pair.** A hole's content is then, by
@@ -26,7 +26,7 @@ import type { IRElement, IRNode } from '../ir/nodes.js';
  * The comments bracketing a hole.
  *
  * Named rather than anonymous so they are recognisable in devtools and in a page's
- * source — an unexplained `<!---->` is a support question.
+ * source: an unexplained `<!---->` is a support question.
  */
 export declare const HOLE_START = "<!--fx-->";
 export declare const HOLE_END = "<!--fx/-->";

package/dist/codegen/serialize-static.d.cts

@@ -2,7 +2,7 @@
  * Serialize a static IR subtree to the HTML a `<template>` can be built from.
  *
  * Only called for nodes `analyzeStatic` marked static, so every prop is a literal and
- * every child is text or another static element — there is nothing here that could need
+ * every child is text or another static element: there is nothing here that could need
  * an expression. That invariant is what makes this safe: the serializer never has to
  * guess, and anything it cannot represent is a bug in the analysis, not a fallback.
  */
@@ -12,7 +12,7 @@ export declare function isRawTextElement(tag: string): boolean;
 /** The HTML spelling of an IR prop name. */
 export declare function htmlAttrName(name: string): string;
 /**
- * True for a prop that is a plain HTML attribute with a compile-time constant value —
+ * True for a prop that is a plain HTML attribute with a compile-time constant value ,
  * safe to write straight onto the element, with no runtime interpretation.
  */
 export declare function isPlainLiteralAttr(prop: IRProp): boolean;
@@ -24,7 +24,7 @@ export declare function serializeStatic(node: IRElement): string;
  * Where each element of a template was written, in the order a clone walks them.
  *
  * A template is emitted as one string, so a source map traces everything in it back to the
- * line the root opens at — every element in a component reports the same place. The order
+ * line the root opens at: every element in a component reports the same place. The order
  * is pre-order over the elements the template contains, which is what
  * `[root, ...root.querySelectorAll('*')]` gives back on the clone, since holes are filled
  * only after it is built.

package/dist/codegen/serialize-static.d.ts

@@ -2,7 +2,7 @@
  * Serialize a static IR subtree to the HTML a `<template>` can be built from.
  *
  * Only called for nodes `analyzeStatic` marked static, so every prop is a literal and
- * every child is text or another static element — there is nothing here that could need
+ * every child is text or another static element: there is nothing here that could need
  * an expression. That invariant is what makes this safe: the serializer never has to
  * guess, and anything it cannot represent is a bug in the analysis, not a fallback.
  */
@@ -12,7 +12,7 @@ export declare function isRawTextElement(tag: string): boolean;
 /** The HTML spelling of an IR prop name. */
 export declare function htmlAttrName(name: string): string;
 /**
- * True for a prop that is a plain HTML attribute with a compile-time constant value —
+ * True for a prop that is a plain HTML attribute with a compile-time constant value ,
  * safe to write straight onto the element, with no runtime interpretation.
  */
 export declare function isPlainLiteralAttr(prop: IRProp): boolean;
@@ -24,7 +24,7 @@ export declare function serializeStatic(node: IRElement): string;
  * Where each element of a template was written, in the order a clone walks them.
  *
  * A template is emitted as one string, so a source map traces everything in it back to the
- * line the root opens at — every element in a component reports the same place. The order
+ * line the root opens at: every element in a component reports the same place. The order
  * is pre-order over the elements the template contains, which is what
  * `[root, ...root.querySelectorAll('*')]` gives back on the clone, since holes are filled
  * only after it is built.

package/dist/codegen/serialize-static.js

@@ -49,8 +49,8 @@ const PROPERTY_ONLY = new Set([
  * Elements whose content the HTML parser does not decode entities inside.
  *
  * Escaping `>` in a `<style>` body would leave a literal `&gt;` in the CSS rather than
- * the character. There is nothing to gain from templating these — their content is the
- * interesting part, not their structure — so they stay on the imperative path.
+ * the character. There is nothing to gain from templating these, their content is the
+ * interesting part, not their structure: so they stay on the imperative path.
  */
 const RAW_TEXT_ELEMENTS = new Set(['script', 'style', 'textarea', 'title']);
 /** True when this element's content must not be entity-escaped. */
@@ -62,7 +62,7 @@ export function htmlAttrName(name) {
     return HTML_NAME[name] ?? name;
 }
 /**
- * True for a prop that is a plain HTML attribute with a compile-time constant value —
+ * True for a prop that is a plain HTML attribute with a compile-time constant value ,
  * safe to write straight onto the element, with no runtime interpretation.
  */
 export function isPlainLiteralAttr(prop) {
@@ -84,7 +84,7 @@ export function isSerializable(node) {
     for (const prop of node.props) {
         // Namespaced names (`prop:value`, `attr:x`, `bool:disabled`, `on:click`) are
         // instructions to the runtime, not HTML, and property-only names are assigned
-        // rather than set — both stay on the imperative path.
+        // rather than set: both stay on the imperative path.
         if (!isPlainLiteralAttr(prop))
             return false;
     }
@@ -125,7 +125,7 @@ function serializeProp(prop) {
 }
 /**
  * Escaping is deliberately aggressive. This string is assigned to `innerHTML`, so a
- * literal that happens to contain markup would otherwise become elements — a value like
+ * literal that happens to contain markup would otherwise become elements, a value like
  * `class="a<b"` must stay one attribute.
  */
 function escapeAttr(value) {
@@ -142,7 +142,7 @@ function escapeText(value) {
  * Where each element of a template was written, in the order a clone walks them.
  *
  * A template is emitted as one string, so a source map traces everything in it back to the
- * line the root opens at — every element in a component reports the same place. The order
+ * line the root opens at: every element in a component reports the same place. The order
  * is pre-order over the elements the template contains, which is what
  * `[root, ...root.querySelectorAll('*')]` gives back on the clone, since holes are filled
  * only after it is built.

package/dist/frontend/babel/build-ir-lit.cjs

@@ -303,7 +303,7 @@ var INTRINSICS = {
   $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
   $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
   // No short runtime form for these yet, so the intrinsic stands for the `create*`
-  // name. Still worth having — no import to write — and when a shorter form is
+  // name. Still worth having: no import to write, and when a shorter form is
   // designed, the change is this line rather than a compiler pass.
   $selector: { export: "createSelector", module: REACTIVE_MODULE, returns: "memo-accessor" },
   $deferred: { export: "createDeferred", module: REACTIVE_MODULE, returns: "memo-accessor" },
@@ -1033,7 +1033,7 @@ var Lowerer = class {
       }
     ];
   }
-  /** A plain attribute (incl. lit `?bool`, mixed values) — old `mkProp` behavior. */
+  /** A plain attribute (incl. lit `?bool`, mixed values), old `mkProp` behavior. */
   plainAttr(a) {
     const v = a.value;
     let name = a.name;
@@ -1454,7 +1454,7 @@ function buildIR(node, used = /* @__PURE__ */ new Set(), onNested) {
   const ir = buildJsxIR(node, {
     code: (n) => (
       // A member-expression tag (`<ns.Foo/>`) is not an Expression, so it cannot go
-      // through the nested-JSX compile — it only ever needs printing.
+      // through the nested-JSX compile: it only ever needs printing.
       n.type === "JSXMemberExpression" ? gen(n) : genExpr(n, used, onNested)
     ),
     used

package/dist/frontend/babel/build-ir-lit.d.cts

@@ -6,8 +6,8 @@
  * concerns into one place with no source spans, no diagnostics, and no reuse
  * outside the compiler. It has been split:
  *
- *   `@fluixi/template-parser`  — Babel-free tokenizer + parser → Template AST
- *   `./lower-template`         — Babel-aware lowering: Template AST → IR
+ *   `@fluixi/template-parser` : Babel-free tokenizer + parser → Template AST
+ *   `./lower-template`        : Babel-aware lowering: Template AST → IR
  *
  * `buildIRFromLit` keeps its exact signature so every caller (build-ir's nested
  * composition, plugin's `emitLitViaIR`) is unchanged; the shared Template AST

package/dist/frontend/babel/build-ir-lit.d.ts

@@ -6,8 +6,8 @@
  * concerns into one place with no source spans, no diagnostics, and no reuse
  * outside the compiler. It has been split:
  *
- *   `@fluixi/template-parser`  — Babel-free tokenizer + parser → Template AST
- *   `./lower-template`         — Babel-aware lowering: Template AST → IR
+ *   `@fluixi/template-parser` : Babel-free tokenizer + parser → Template AST
+ *   `./lower-template`        : Babel-aware lowering: Template AST → IR
  *
  * `buildIRFromLit` keeps its exact signature so every caller (build-ir's nested
  * composition, plugin's `emitLitViaIR`) is unchanged; the shared Template AST

package/dist/frontend/babel/build-ir-lit.mjs

@@ -269,7 +269,7 @@ var INTRINSICS = {
   $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
   $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
   // No short runtime form for these yet, so the intrinsic stands for the `create*`
-  // name. Still worth having — no import to write — and when a shorter form is
+  // name. Still worth having: no import to write, and when a shorter form is
   // designed, the change is this line rather than a compiler pass.
   $selector: { export: "createSelector", module: REACTIVE_MODULE, returns: "memo-accessor" },
   $deferred: { export: "createDeferred", module: REACTIVE_MODULE, returns: "memo-accessor" },
@@ -999,7 +999,7 @@ var Lowerer = class {
       }
     ];
   }
-  /** A plain attribute (incl. lit `?bool`, mixed values) — old `mkProp` behavior. */
+  /** A plain attribute (incl. lit `?bool`, mixed values), old `mkProp` behavior. */
   plainAttr(a) {
     const v = a.value;
     let name = a.name;
@@ -1420,7 +1420,7 @@ function buildIR(node, used = /* @__PURE__ */ new Set(), onNested) {
   const ir = buildJsxIR(node, {
     code: (n) => (
       // A member-expression tag (`<ns.Foo/>`) is not an Expression, so it cannot go
-      // through the nested-JSX compile — it only ever needs printing.
+      // through the nested-JSX compile: it only ever needs printing.
       n.type === "JSXMemberExpression" ? gen(n) : genExpr(n, used, onNested)
     ),
     used

package/dist/frontend/babel/build-ir.cjs

@@ -252,7 +252,7 @@ var INTRINSICS = {
   $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
   $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
   // No short runtime form for these yet, so the intrinsic stands for the `create*`
-  // name. Still worth having — no import to write — and when a shorter form is
+  // name. Still worth having: no import to write, and when a shorter form is
   // designed, the change is this line rather than a compiler pass.
   $selector: { export: "createSelector", module: REACTIVE_MODULE, returns: "memo-accessor" },
   $deferred: { export: "createDeferred", module: REACTIVE_MODULE, returns: "memo-accessor" },
@@ -1038,7 +1038,7 @@ var Lowerer = class {
       }
     ];
   }
-  /** A plain attribute (incl. lit `?bool`, mixed values) — old `mkProp` behavior. */
+  /** A plain attribute (incl. lit `?bool`, mixed values), old `mkProp` behavior. */
   plainAttr(a) {
     const v = a.value;
     let name = a.name;
@@ -1515,7 +1515,7 @@ function buildIR(node, used = /* @__PURE__ */ new Set(), onNested) {
   const ir = buildJsxIR(node, {
     code: (n) => (
       // A member-expression tag (`<ns.Foo/>`) is not an Expression, so it cannot go
-      // through the nested-JSX compile — it only ever needs printing.
+      // through the nested-JSX compile: it only ever needs printing.
       n.type === "JSXMemberExpression" ? gen2(n) : genExpr(n, used, onNested)
     ),
     used

package/dist/frontend/babel/build-ir.d.cts

@@ -20,7 +20,7 @@ export declare function genExpr(node: t.Expression, used: Set<string>, onNested?
  * Called with the IR of JSX (or a template) found inside an expression.
  *
  * That IR is compiled and thrown away during the walk, so anything the module
- * needs because of it — a component import, a delegated event — has to be taken
+ * needs because of it: a component import, a delegated event, has to be taken
  * off it here or it is lost. Without this, `{(b) => <Input/>}` emitted a
  * reference to `Input` that nothing imported.
  */
@@ -29,7 +29,7 @@ export declare const SVG_TAGS: Set<string>;
 export declare function isReactiveExpr(node: t.Expression): boolean;
 /**
  * Build IR from a JSX node. The builder is shared (lower/jsx.ts); what this
- * front-end supplies is how an expression becomes source — `genExpr`, which also
+ * front-end supplies is how an expression becomes source, `genExpr`, which also
  * compiles any JSX or `` html`` `` nested inside it.
  */
 export declare function buildIR(node: t.JSXElement | t.JSXFragment, used?: Set<string>, onNested?: NestedHook): IRNode;

package/dist/frontend/babel/build-ir.d.ts

@@ -20,7 +20,7 @@ export declare function genExpr(node: t.Expression, used: Set<string>, onNested?
  * Called with the IR of JSX (or a template) found inside an expression.
  *
  * That IR is compiled and thrown away during the walk, so anything the module
- * needs because of it — a component import, a delegated event — has to be taken
+ * needs because of it: a component import, a delegated event, has to be taken
  * off it here or it is lost. Without this, `{(b) => <Input/>}` emitted a
  * reference to `Input` that nothing imported.
  */
@@ -29,7 +29,7 @@ export declare const SVG_TAGS: Set<string>;
 export declare function isReactiveExpr(node: t.Expression): boolean;
 /**
  * Build IR from a JSX node. The builder is shared (lower/jsx.ts); what this
- * front-end supplies is how an expression becomes source — `genExpr`, which also
+ * front-end supplies is how an expression becomes source, `genExpr`, which also
  * compiles any JSX or `` html`` `` nested inside it.
  */
 export declare function buildIR(node: t.JSXElement | t.JSXFragment, used?: Set<string>, onNested?: NestedHook): IRNode;

package/dist/frontend/babel/build-ir.js

@@ -107,14 +107,14 @@ export function isReactiveExpr(node) {
 }
 /**
  * Build IR from a JSX node. The builder is shared (lower/jsx.ts); what this
- * front-end supplies is how an expression becomes source — `genExpr`, which also
+ * front-end supplies is how an expression becomes source, `genExpr`, which also
  * compiles any JSX or `` html`` `` nested inside it.
  */
 export function buildIR(node, used = new Set(), onNested) {
     const ir = buildJsxIR(node, {
         code: (n) => 
         // A member-expression tag (`<ns.Foo/>`) is not an Expression, so it cannot go
-        // through the nested-JSX compile — it only ever needs printing.
+        // through the nested-JSX compile: it only ever needs printing.
         n.type === 'JSXMemberExpression'
             ? gen(n)
             : genExpr(n, used, onNested),

package/dist/frontend/babel/build-ir.mjs

@@ -215,7 +215,7 @@ var INTRINSICS = {
   $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
   $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
   // No short runtime form for these yet, so the intrinsic stands for the `create*`
-  // name. Still worth having — no import to write — and when a shorter form is
+  // name. Still worth having: no import to write, and when a shorter form is
   // designed, the change is this line rather than a compiler pass.
   $selector: { export: "createSelector", module: REACTIVE_MODULE, returns: "memo-accessor" },
   $deferred: { export: "createDeferred", module: REACTIVE_MODULE, returns: "memo-accessor" },
@@ -1003,7 +1003,7 @@ var Lowerer = class {
       }
     ];
   }
-  /** A plain attribute (incl. lit `?bool`, mixed values) — old `mkProp` behavior. */
+  /** A plain attribute (incl. lit `?bool`, mixed values), old `mkProp` behavior. */
   plainAttr(a) {
     const v = a.value;
     let name = a.name;
@@ -1480,7 +1480,7 @@ function buildIR(node, used = /* @__PURE__ */ new Set(), onNested) {
   const ir = buildJsxIR(node, {
     code: (n) => (
       // A member-expression tag (`<ns.Foo/>`) is not an Expression, so it cannot go
-      // through the nested-JSX compile — it only ever needs printing.
+      // through the nested-JSX compile: it only ever needs printing.
       n.type === "JSXMemberExpression" ? gen2(n) : genExpr(n, used, onNested)
     ),
     used