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

package/dist/lower/jsx.d.cts

@@ -2,7 +2,7 @@
  * Build IR from a JSX tree.
  *
  * Reads `node.type` rather than a parser's helpers, and asks the caller for the
- * source of an expression through `code()` — a front-end that can slice the
+ * source of an expression through `code()`: a front-end that can slice the
  * original text returns that, one that reprints returns the printed form. Either
  * way the IR is the same, which is what keeps one builder for both.
  */

package/dist/lower/jsx.d.ts

@@ -2,7 +2,7 @@
  * Build IR from a JSX tree.
  *
  * Reads `node.type` rather than a parser's helpers, and asks the caller for the
- * source of an expression through `code()` — a front-end that can slice the
+ * source of an expression through `code()`: a front-end that can slice the
  * original text returns that, one that reprints returns the printed form. Either
  * way the IR is the same, which is what keeps one builder for both.
  */

package/dist/lower/jsx.js

@@ -14,7 +14,7 @@ const DELEGATED = new Set([
     'keydown', 'keyup', 'keypress', 'mousedown', 'mouseup',
 ]);
 const isReactive = (node) => isReactiveShape(shapeOf(node));
-/** Only when the host asked for source locations — the flag that records usage sites too. */
+/** Only when the host asked for source locations, the flag that records usage sites too. */
 const posOf = (node, ctx) => {
     if (!ctx.sourceFile)
         return undefined;
@@ -87,7 +87,7 @@ function buildAttr(attr, ctx) {
         base.expr = ctx.code(expr);
         base.reactive = isHandler ? false : isReactive(expr);
         // Every prop, not only the ones that move: a panel names the line for each of them.
-        // Nothing treats this as a binding position — that asks for `reactive` as well.
+        // Nothing treats this as a binding position: that asks for `reactive` as well.
         base.at = posOf(expr, ctx);
         if (expr.type === 'JSXElement' || expr.type === 'JSXFragment')
             base.jsxElement = true;
@@ -118,7 +118,7 @@ function buildProps(attrs, ctx) {
         }
         if (a.type !== 'JSXAttribute')
             continue;
-        // load: is a directive, not a prop — the resolve pass reads it off the node.
+        // load: is a directive, not a prop: the resolve pass reads it off the node.
         if (isLoadDirective(attrName(a.name)))
             continue;
         const ns = a.name.type === 'JSXNamespacedName' ? a.name.namespace.name : null;
@@ -148,7 +148,7 @@ function buildChildren(children, ctx) {
     const out = [];
     for (const child of children) {
         if (child.type === 'JSXText') {
-            // Drop whitespace-only text spanning a newline so a lone child stays lone —
+            // Drop whitespace-only text spanning a newline so a lone child stays lone , 
             // an array insert will not reactively bind a memo/component inside it.
             const text = cleanTemplateText(child.value);
             if (text)

package/dist/lower/template.cjs

@@ -284,7 +284,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" },
@@ -1014,7 +1014,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/lower/template.d.cts

@@ -10,7 +10,7 @@ import { type Piece } from '@fluixi/template-parser';
 import type { HolePosition, IRNode } from '../ir/nodes.cjs';
 /**
  * One `${…}` slot, as the front-end describes it. Conclusions about the
- * expression only — never a syntax tree, or the parser dependency creeps back.
+ * expression only: never a syntax tree, or the parser dependency creeps back.
  */
 export interface TemplateHole {
     /** The expression source, verbatim. Anything nested inside it is already compiled. */
@@ -18,7 +18,7 @@ export interface TemplateHole {
     /** Whether it must be wired reactively (see analyze/reactive-expr.ts). */
     reactive: boolean;
     /**
-     * Set when the hole is a single-expression arrow — `${item => …}`. `each` turns
+     * Set when the hole is a single-expression arrow, `${item => …}`. `each` turns
      * that into `For`'s render function, so it needs the parameters and the body
      * separately rather than the arrow as written.
      */
@@ -27,7 +27,7 @@ export interface TemplateHole {
         body: string;
         bodyReactive: boolean;
     };
-    /** Whether the hole is an object literal — `class=${{…}}` lowers to classList. */
+    /** Whether the hole is an object literal: `class=${{…}}` lowers to classList. */
     object?: boolean;
     /**
      * Where the `${…}` was written. Only kept when the host asked for source locations.

package/dist/lower/template.d.ts

@@ -10,7 +10,7 @@ import { type Piece } from '@fluixi/template-parser';
 import type { HolePosition, IRNode } from '../ir/nodes.js';
 /**
  * One `${…}` slot, as the front-end describes it. Conclusions about the
- * expression only — never a syntax tree, or the parser dependency creeps back.
+ * expression only: never a syntax tree, or the parser dependency creeps back.
  */
 export interface TemplateHole {
     /** The expression source, verbatim. Anything nested inside it is already compiled. */
@@ -18,7 +18,7 @@ export interface TemplateHole {
     /** Whether it must be wired reactively (see analyze/reactive-expr.ts). */
     reactive: boolean;
     /**
-     * Set when the hole is a single-expression arrow — `${item => …}`. `each` turns
+     * Set when the hole is a single-expression arrow, `${item => …}`. `each` turns
      * that into `For`'s render function, so it needs the parameters and the body
      * separately rather than the arrow as written.
      */
@@ -27,7 +27,7 @@ export interface TemplateHole {
         body: string;
         bodyReactive: boolean;
     };
-    /** Whether the hole is an object literal — `class=${{…}}` lowers to classList. */
+    /** Whether the hole is an object literal: `class=${{…}}` lowers to classList. */
     object?: boolean;
     /**
      * Where the `${…}` was written. Only kept when the host asked for source locations.

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

@@ -1 +1 @@
-{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/lower/template.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAML,KAAK,KAAK,EAGX,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAsB,MAAM,gBAAgB,CAAC;AAM/E;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,sFAAsF;IACtF,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,KAAK,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAClE,kFAAkF;IAClF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;OAMG;IACH,EAAE,CAAC,EAAE,YAAY,CAAC;CACnB;AAmhBD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,KAAK,EAAE,EACf,KAAK,EAAE,YAAY,EAAE,EACrB,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,EACjB,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAAO,GACnH,MAAM,CAGR"}
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/lower/template.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAML,KAAK,KAAK,EAGX,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAsB,MAAM,gBAAgB,CAAC;AAM/E;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,sFAAsF;IACtF,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,KAAK,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAClE,iFAAiF;IACjF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;OAMG;IACH,EAAE,CAAC,EAAE,YAAY,CAAC;CACnB;AAmhBD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,KAAK,EAAE,EACf,KAAK,EAAE,YAAY,EAAE,EACrB,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,EACjB,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAAO,GACnH,MAAM,CAGR"}

package/dist/lower/template.js

@@ -149,13 +149,13 @@ class Lowerer {
         };
     }
     lowerComponent(el) {
-        // `<${Comp} />`: the tag is an interpolated expression — use the hole's code
+        // `<${Comp} />`: the tag is an interpolated expression, use the hole's code
         // as the component identity, so `createComponent(<expr>, …)` is emitted.
         const name = el.tagHole != null ? this.hole(el.tagHole).code : el.tag;
         const props = this.lowerAttributes(el.attributes);
         // Named slots: a child with `slot="header"` becomes `props.header` (a lazy
         // getter, like `children`); the rest stay the default `children`. This is the
-        // Solid convention — the component reads `props.header` / `props.children`.
+        // Solid convention: the component reads `props.header` / `props.children`.
         const { slots, rest } = this.partitionSlots(el.children);
         for (const [slotName, nodes] of slots) {
             const ir = nodes.length === 1 ? nodes[0] : { kind: 'fragment', children: nodes };
@@ -166,7 +166,7 @@ class Lowerer {
                 jsxElement: true,
             };
             // A slot replaces a same-named attribute rather than joining it. `<Card header>`
-            // alongside `<span slot="header">` otherwise emits the key twice — valid JS where
+            // alongside `<span slot="header">` otherwise emits the key twice, valid JS where
             // the last wins, but the first is dead code and esbuild warns on it. Content is
             // the more specific intent, so the slot is what survives.
             const clash = props.findIndex((p) => p.name === slotName);
@@ -183,7 +183,7 @@ class Lowerer {
             : undefined;
         // The parser's positions are relative to the template string, not the file, so the
         // tag itself has none to give. The first hole is the closest thing that does, and for
-        // the control-flow components — `<Show when=${…}>`, `<For each=${…}>` — it is the
+        // the control-flow components: `<Show when=${…}>`, `<For each=${…}>`, it is the
         // expression driving the subtree anyway.
         // A reactive one: a literal carries a position too now, and it drives nothing.
         const bindAt = props.find((p) => p.at && p.reactive)?.at;
@@ -369,7 +369,7 @@ class Lowerer {
         // Merge all class:/style: directives into one classList/style prop so they
         // don't collide as duplicate keys in the emitted props object.
         // One prop covers every directive of its kind, so it carries the first hole's
-        // position — a real source line beats the stack fallback, which lands in the
+        // position: a real source line beats the stack fallback, which lands in the
         // compiled file.
         if (classEntries.length > 0) {
             props.push({
@@ -471,11 +471,11 @@ class Lowerer {
             },
         ];
     }
-    /** 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;
         // `class=${{...}}` (object literal) -> classList (Solid convention), so it
-        // doesn't collide with a static `class="box"` (which stays className) — both
+        // doesn't collide with a static `class="box"` (which stays className), both
         // apply. `class` -> className; `style=${{...}}` stays `style` (runtime merges).
         // `html=${x}` is the raw-HTML escape hatch -> innerHTML.
         let name = a.name;

package/dist/lower/template.mjs

@@ -262,7 +262,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" },
@@ -992,7 +992,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/lower/text.d.cts

@@ -1,10 +1,10 @@
 /**
  * Whitespace handling for template text runs.
  *
- * JSX and `` html`...` `` collapse a text run the same way — the rule came from
+ * 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. */
+/** Canonical JSX text cleaning: kept identical to plugin.ts cleanTemplateText. */
 export declare function cleanTemplateText(value: string): string;

package/dist/lower/text.d.ts

@@ -1,11 +1,11 @@
 /**
  * Whitespace handling for template text runs.
  *
- * JSX and `` html`...` `` collapse a text run the same way — the rule came from
+ * 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. */
+/** 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

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/lower/text.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,mFAAmF;AACnF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAgBvD"}
+{"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

@@ -1,12 +1,12 @@
 /**
  * Whitespace handling for template text runs.
  *
- * JSX and `` html`...` `` collapse a text run the same way — the rule came from
+ * 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. */
+/** 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;

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

@@ -3,7 +3,7 @@
  *
  * 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
+ * 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
@@ -31,7 +31,7 @@ export interface StaticReport {
  */
 export declare function analyzeStatic(root: IRNode | IRNode[]): StaticReport;
 /**
- * The outermost static elements — the roots worth turning into templates.
+ * 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.

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

@@ -3,7 +3,7 @@
  *
  * 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
+ * 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
@@ -31,7 +31,7 @@ export interface StaticReport {
  */
 export declare function analyzeStatic(root: IRNode | IRNode[]): StaticReport;
 /**
- * The outermost static elements — the roots worth turning into templates.
+ * 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.

package/dist/optimize/analyze-static.js

@@ -2,7 +2,7 @@
  * 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.
+ * when `reactive` is false: a non-reactive expression still has to run per instance.
  */
 function propReason(prop) {
     switch (prop.kind) {
@@ -108,7 +108,7 @@ function childReason(node) {
     return 'expression-child';
 }
 /**
- * The outermost static elements — the roots worth turning into templates.
+ * 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.

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

@@ -1,11 +1,11 @@
 /**
- * Strategy collapsing — demote a deferred reference whose module is already present.
+ * 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.
+ * 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/dist/optimize/collapse-strategies.d.ts

@@ -1,11 +1,11 @@
 /**
- * Strategy collapsing — demote a deferred reference whose module is already present.
+ * 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.
+ * 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/dist/options.d.cts

@@ -1,6 +1,6 @@
 import type { ComponentResolverRule } from './resolve/component-resolver.cjs';
 /**
- * Public compiler options. This schema is the stable public API — it stays put
+ * 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 {
@@ -13,7 +13,7 @@ export interface CompilerOptions {
      */
     templateClone?: boolean;
     /**
-     * Also clone subtrees whose *structure* is static but which contain dynamic holes —
+     * 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.
      *

package/dist/options.d.ts

@@ -1,6 +1,6 @@
 import type { ComponentResolverRule } from './resolve/component-resolver.js';
 /**
- * Public compiler options. This schema is the stable public API — it stays put
+ * 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 {
@@ -13,7 +13,7 @@ export interface CompilerOptions {
      */
     templateClone?: boolean;
     /**
-     * Also clone subtrees whose *structure* is static but which contain dynamic holes —
+     * 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.
      *

package/dist/resolve/builtins.cjs

@@ -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.86 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;

package/dist/resolve/builtins.d.cts

@@ -3,7 +3,7 @@
  *
  * Two different things have always been bundled into one hardcoded `Set` per group:
  * *which module a name comes from*, and *whether the name has special lowering*. Only
- * the first is interesting outside the compiler, and every tool needs it — the TS
+ * the first is interesting outside the compiler, and every tool needs it, the TS
  * plugin, to resolve `<Show>` for hover and go-to-definition; the language server, to
  * complete and validate tags inside `` html`…` ``; a codemod, to materialise imports.
  * Having no published source, `@fluixi/ts-plugin` duplicated the list and pinned it
@@ -15,13 +15,13 @@
  *
  * The split matters: control-flow names cannot become ordinary rules. `Show`, `For`,
  * `Index` and `Match` read a reactive *value* prop inside their own tracking scope, so
- * the compiler emits that prop as a getter — without it `each={items()}` snapshots once
+ * the compiler emits that prop as a getter: without it `each={items()}` snapshots once
  * and never updates. They are also exempted from `createMemo` wrapping and may be
  * replaced outright by `optimizeControlFlowComponent`. A rule only injects an import,
  * so converting them would keep the import and silently drop the reactivity.
  *
- * Router components have no such behaviour — every reference to them in the plugin is
- * import plumbing — so they are a plain rule.
+ * Router components have no such behaviour: every reference to them in the plugin is
+ * import plumbing: so they are a plain rule.
  */
 import type { ComponentMapRule } from './component-resolver.cjs';
 /** Where the built-in groups come from when the host does not override the module. */
@@ -35,7 +35,7 @@ export interface BuiltinModules {
 }
 /** Control flow lowered against the DOM runtime. */
 export declare const DOM_CONTROL_FLOW: readonly ["Show", "For", "Index", "Switch", "Match", "Portal", "Dynamic", "ErrorBoundary"];
-/** Control flow that only `@fluixi/core` exports — importing it from dom resolves to nothing. */
+/** Control flow that only `@fluixi/core` exports, importing it from dom resolves to nothing. */
 export declare const CORE_CONTROL_FLOW: readonly ["Suspense", "SuspenseList", "Await"];
 /**
  * Router components.
@@ -49,7 +49,7 @@ export declare const BUILTIN_COMPONENTS: readonly string[];
 /**
  * Names whose meaning is fixed by the compiler and cannot be reassigned by a rule.
  *
- * A rule naming one of these is a silent no-op — the compiler matches the built-in
+ * A rule naming one of these is a silent no-op: the compiler matches the built-in
  * first and the tag renders control flow instead of the intended component, with no
  * error. Rule authors should check against this set and report rather than emit.
  */
@@ -60,9 +60,9 @@ export declare function builtinComponentMap(modules?: BuiltinModules): Record<st
  * The built-ins as a resolver rule, for tools that want one uniform lookup.
  *
  * Note this is the *naming* half only. Feeding it to the compiler would not make
- * control flow work through resolution — the compiler still recognises those names
+ * control flow work through resolution: the compiler still recognises those names
  * itself, for the codegen reasons above.
  */
 export declare function builtinComponents(modules?: BuiltinModules): ComponentMapRule;
-/** Just the router group as a rule — the one group that is purely an import. */
+/** Just the router group as a rule: the one group that is purely an import. */
 export declare function routerComponents(routerModule?: string): ComponentMapRule;

package/dist/resolve/builtins.d.ts

@@ -3,7 +3,7 @@
  *
  * Two different things have always been bundled into one hardcoded `Set` per group:
  * *which module a name comes from*, and *whether the name has special lowering*. Only
- * the first is interesting outside the compiler, and every tool needs it — the TS
+ * the first is interesting outside the compiler, and every tool needs it, the TS
  * plugin, to resolve `<Show>` for hover and go-to-definition; the language server, to
  * complete and validate tags inside `` html`…` ``; a codemod, to materialise imports.
  * Having no published source, `@fluixi/ts-plugin` duplicated the list and pinned it
@@ -15,13 +15,13 @@
  *
  * The split matters: control-flow names cannot become ordinary rules. `Show`, `For`,
  * `Index` and `Match` read a reactive *value* prop inside their own tracking scope, so
- * the compiler emits that prop as a getter — without it `each={items()}` snapshots once
+ * the compiler emits that prop as a getter: without it `each={items()}` snapshots once
  * and never updates. They are also exempted from `createMemo` wrapping and may be
  * replaced outright by `optimizeControlFlowComponent`. A rule only injects an import,
  * so converting them would keep the import and silently drop the reactivity.
  *
- * Router components have no such behaviour — every reference to them in the plugin is
- * import plumbing — so they are a plain rule.
+ * Router components have no such behaviour: every reference to them in the plugin is
+ * import plumbing: so they are a plain rule.
  */
 import type { ComponentMapRule } from './component-resolver.js';
 /** Where the built-in groups come from when the host does not override the module. */
@@ -35,7 +35,7 @@ export interface BuiltinModules {
 }
 /** Control flow lowered against the DOM runtime. */
 export declare const DOM_CONTROL_FLOW: readonly ["Show", "For", "Index", "Switch", "Match", "Portal", "Dynamic", "ErrorBoundary"];
-/** Control flow that only `@fluixi/core` exports — importing it from dom resolves to nothing. */
+/** Control flow that only `@fluixi/core` exports, importing it from dom resolves to nothing. */
 export declare const CORE_CONTROL_FLOW: readonly ["Suspense", "SuspenseList", "Await"];
 /**
  * Router components.
@@ -49,7 +49,7 @@ export declare const BUILTIN_COMPONENTS: readonly string[];
 /**
  * Names whose meaning is fixed by the compiler and cannot be reassigned by a rule.
  *
- * A rule naming one of these is a silent no-op — the compiler matches the built-in
+ * A rule naming one of these is a silent no-op: the compiler matches the built-in
  * first and the tag renders control flow instead of the intended component, with no
  * error. Rule authors should check against this set and report rather than emit.
  */
@@ -60,10 +60,10 @@ export declare function builtinComponentMap(modules?: BuiltinModules): Record<st
  * The built-ins as a resolver rule, for tools that want one uniform lookup.
  *
  * Note this is the *naming* half only. Feeding it to the compiler would not make
- * control flow work through resolution — the compiler still recognises those names
+ * control flow work through resolution: the compiler still recognises those names
  * itself, for the codegen reasons above.
  */
 export declare function builtinComponents(modules?: BuiltinModules): ComponentMapRule;
-/** Just the router group as a rule — the one group that is purely an import. */
+/** Just the router group as a rule: the one group that is purely an import. */
 export declare function routerComponents(routerModule?: string): ComponentMapRule;
 //# sourceMappingURL=builtins.d.ts.map

package/dist/resolve/builtins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../../src/resolve/builtins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,sFAAsF;AACtF,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,oDAAoD;AACpD,eAAO,MAAM,gBAAgB,4FASnB,CAAC;AAEX,iGAAiG;AACjG,eAAO,MAAM,iBAAiB,gDAAiD,CAAC;AAEhF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,mDAAoD,CAAC;AAEnF,0DAA0D;AAC1D,eAAO,MAAM,kBAAkB,EAAE,SAAS,MAAM,EAI/C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAGlD,CAAC;AAEH,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,cAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYxF;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,cAAmB,GAAG,gBAAgB,CAEhF;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAGxE"}
+{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../../src/resolve/builtins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,sFAAsF;AACtF,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,oDAAoD;AACpD,eAAO,MAAM,gBAAgB,4FASnB,CAAC;AAEX,gGAAgG;AAChG,eAAO,MAAM,iBAAiB,gDAAiD,CAAC;AAEhF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,mDAAoD,CAAC;AAEnF,0DAA0D;AAC1D,eAAO,MAAM,kBAAkB,EAAE,SAAS,MAAM,EAI/C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAGlD,CAAC;AAEH,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,cAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYxF;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,cAAmB,GAAG,gBAAgB,CAEhF;AAED,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAGxE"}

package/dist/resolve/builtins.js

@@ -9,7 +9,7 @@ export const DOM_CONTROL_FLOW = [
     'Dynamic',
     'ErrorBoundary',
 ];
-/** Control flow that only `@fluixi/core` exports — importing it from dom resolves to nothing. */
+/** Control flow that only `@fluixi/core` exports, importing it from dom resolves to nothing. */
 export const CORE_CONTROL_FLOW = ['Suspense', 'SuspenseList', 'Await'];
 /**
  * Router components.
@@ -27,7 +27,7 @@ export const BUILTIN_COMPONENTS = [
 /**
  * Names whose meaning is fixed by the compiler and cannot be reassigned by a rule.
  *
- * A rule naming one of these is a silent no-op — the compiler matches the built-in
+ * A rule naming one of these is a silent no-op: the compiler matches the built-in
  * first and the tag renders control flow instead of the intended component, with no
  * error. Rule authors should check against this set and report rather than emit.
  */
@@ -51,13 +51,13 @@ export function builtinComponentMap(modules = {}) {
  * The built-ins as a resolver rule, for tools that want one uniform lookup.
  *
  * Note this is the *naming* half only. Feeding it to the compiler would not make
- * control flow work through resolution — the compiler still recognises those names
+ * control flow work through resolution: the compiler still recognises those names
  * itself, for the codegen reasons above.
  */
 export function builtinComponents(modules = {}) {
     return { components: builtinComponentMap(modules) };
 }
-/** Just the router group as a rule — the one group that is purely an import. */
+/** Just the router group as a rule: the one group that is purely an import. */
 export function routerComponents(routerModule) {
     const module = routerModule ?? '@fluixi/core/router';
     return { components: Object.fromEntries(ROUTER_COMPONENTS.map((n) => [n, module])) };

package/dist/resolve/builtins.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.86 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
 
 // src/resolve/builtins.ts
 var DOM_CONTROL_FLOW = [

package/dist/resolve/component-globals.cjs

@@ -125,7 +125,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" },
@@ -211,7 +211,7 @@ function componentGlobals(rules, options = {}) {
     return target.export === "default" ? `  const ${name}: typeof ${ns}.default;` : `  export import ${name} = ${ns}.${target.export};`;
   });
   const note = shadowedByDom.length > 0 ? `//
-// Import these explicitly — lib.dom already declares the name, so an ambient
+// Import these explicitly: lib.dom already declares the name, so an ambient
 // declaration cannot win:
 ` + shadowedByDom.map((n) => {
     const module2 = resolver.resolve(n)?.module;
@@ -227,7 +227,7 @@ function componentGlobals(rules, options = {}) {
 // a pattern matches unboundedly many names, so there is no list to emit. Those
 // tags still resolve at build time; declare them by hand if the editor needs them.
 ` : "";
-  const source = `// GENERATED by ${generator} — do not edit.
+  const source = `// GENERATED by ${generator}, do not edit.
 //
 // The components \`resolve\` supplies without an import. This describes what the
 // compiler already does; it does not enable it.

package/dist/resolve/component-globals.d.cts

@@ -1,7 +1,7 @@
 /**
  * Ambient declarations for the components `resolve` supplies without an import.
  *
- * The compiler injects the import, so nothing in the source imports these — which leaves
+ * The compiler injects the import, so nothing in the source imports these, which leaves
  * TypeScript reporting `TS2304: Cannot find name`. The code compiles and runs; the editor
  * is unusable and `tsc` fails. These declarations describe what the compiler already
  * does. They do not enable it.
@@ -9,8 +9,8 @@
  * This lives next to the resolver, and takes rules rather than a flat map, because the
  * resolver is the only thing that knows the whole picture: a UI library's components, the
  * project's own, and the framework builtins all arrive through the same config. A
- * component library cannot generate this on its own — it does not know what else the
- * project resolves — which is why the generator belongs here and the library-specific CLI
+ * component library cannot generate this on its own, it does not know what else the
+ * project resolves: which is why the generator belongs here and the library-specific CLI
  * that predates it does not.
  *
  * Pure, like the resolver: rules in, source out, no filesystem. Writing the file is the
@@ -19,7 +19,7 @@
 import { type ComponentResolverRule } from './component-resolver.cjs';
 export interface ComponentGlobalsOptions {
     /**
-     * Packages the project can actually resolve — normally its declared dependencies.
+     * Packages the project can actually resolve: normally its declared dependencies.
      *
      * Declaring a component from a package the project does not depend on produces an
      * unresolvable `import(...)`, and under the usual `skipLibCheck: true` that failure is
@@ -27,7 +27,7 @@ export interface ComponentGlobalsOptions {
      * worse than the error it replaced. Omit to declare everything, which is only correct
      * when every package is present.
      *
-     * Relative and alias specifiers are never filtered — there is no package to check.
+     * Relative and alias specifiers are never filtered, there is no package to check.
      */
     available?: Iterable<string>;
     /**