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

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

@@ -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.js';
 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>;
     /**

package/dist/resolve/component-globals.js

@@ -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
@@ -23,7 +23,7 @@ import { INTRINSICS } from '../analyze/intrinsics.js';
  * Names `lib.dom` already declares as globals.
  *
  * An ambient `const Text` cannot beat `lib.dom`'s `var Text`, so for these the editor
- * would disagree with the compiler — resolution still works at runtime, but the type
+ * would disagree with the compiler: resolution still works at runtime, but the type
  * shown would be the DOM node's. They are left out and reported instead, since importing
  * them explicitly makes both agree.
  */
@@ -68,7 +68,7 @@ export function componentGlobals(rules, options = {}) {
     const { available: availableList, builtins = true, intrinsics = true, generator = '@fluixi/compiler', specifier = (module) => module, } = options;
     const all = [...rules];
     if (builtins) {
-        // Appended, so an explicit rule for the same name still wins — the resolver is
+        // Appended, so an explicit rule for the same name still wins, the resolver is
         // first-match, and a project retargeting `Router` should keep its own answer.
         all.push({ components: builtinComponentMap() });
     }
@@ -107,8 +107,8 @@ export function componentGlobals(rules, options = {}) {
     // (`Button(props: ButtonProps): ComponentChild`) and go-to-definition lands on the
     // source. Both forms keep the JSDoc; the alias also keeps the shape.
     //
-    // A default export cannot use it — `import X = ns.default` is a syntax error, since
-    // `default` is a reserved word in that position — so those fall back to the `const`
+    // A default export cannot use it: `import X = ns.default` is a syntax error, since
+    // `default` is a reserved word in that position, so those fall back to the `const`
     // form, which types and documents correctly but renders as an anonymous arrow.
     const lines = declared.map((name) => {
         const target = resolved.get(name);
@@ -118,7 +118,7 @@ export function componentGlobals(rules, options = {}) {
             : `  export import ${name} = ${ns}.${target.export};`;
     });
     const note = shadowedByDom.length > 0
-        ? `//\n// Import these explicitly — lib.dom already declares the name, so an ambient\n` +
+        ? `//\n// Import these explicitly: lib.dom already declares the name, so an ambient\n` +
             `// declaration cannot win:\n` +
             shadowedByDom
                 .map((n) => {
@@ -129,7 +129,7 @@ export function componentGlobals(rules, options = {}) {
         : '';
     // `typeof ns.signal` rather than an alias: the intrinsic is a global that stands for
     // the runtime call, so it takes the runtime's signature without claiming to be that
-    // symbol — go-to-definition on `$signal` should land on what it compiles to.
+    // symbol: go-to-definition on `$signal` should land on what it compiles to.
     const intrinsicLines = intrinsics
         ? Object.entries(INTRINSICS).map(([name, intrinsic]) => `  const ${name}: typeof ${namespaceAlias(intrinsic.module)}.${intrinsic.export};`)
         : [];
@@ -139,7 +139,7 @@ export function componentGlobals(rules, options = {}) {
             `// a pattern matches unboundedly many names, so there is no list to emit. Those\n` +
             `// tags still resolve at build time; declare them by hand if the editor needs them.\n`
         : '';
-    const source = `// GENERATED by ${generator} — do not edit.\n` +
+    const source = `// GENERATED by ${generator}, do not edit.\n` +
         `//\n` +
         `// The components \`resolve\` supplies without an import. This describes what the\n` +
         `// compiler already does; it does not enable it.\n` +

package/dist/resolve/component-globals.mjs

@@ -99,7 +99,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" },
@@ -185,7 +185,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 module = resolver.resolve(n)?.module;
@@ -201,7 +201,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-resolver.d.cts

@@ -4,7 +4,7 @@
  * An unbound capitalised tag in a template is a name the compiler can resolve to a
  * module, instead of an import the author has to write. The framework already does
  * this for `Suspense`/`Portal`/`Router`, but through a hardcoded name set inside the
- * Babel plugin — which cannot be extended by a UI library or an app, and cannot be
+ * Babel plugin: which cannot be extended by a UI library or an app, and cannot be
  * configured per project.
  *
  * This is the configurable version of the same idea. It is deliberately a pure
@@ -44,7 +44,7 @@ export interface ComponentPatternRule {
     export?: string;
 }
 export type ComponentResolverRule = ComponentMapRule | ComponentPatternRule;
-/** Two rules claiming the same name — reported rather than silently first-wins. */
+/** Two rules claiming the same name: reported rather than silently first-wins. */
 export interface ResolverConflict {
     name: string;
     modules: string[];
@@ -60,7 +60,7 @@ export interface ComponentResolver {
 /**
  * Build a resolver from rules, in order.
  *
- * Map rules are flattened up front so lookup is a plain object read — resolution runs
+ * Map rules are flattened up front so lookup is a plain object read, resolution runs
  * once per component reference per compile, so it sits on the hot path of every build.
  * Pattern rules are tried afterwards, in declaration order, and only when no map rule
  * matched: an explicit entry should always beat a pattern.

package/dist/resolve/component-resolver.d.ts

@@ -4,7 +4,7 @@
  * An unbound capitalised tag in a template is a name the compiler can resolve to a
  * module, instead of an import the author has to write. The framework already does
  * this for `Suspense`/`Portal`/`Router`, but through a hardcoded name set inside the
- * Babel plugin — which cannot be extended by a UI library or an app, and cannot be
+ * Babel plugin: which cannot be extended by a UI library or an app, and cannot be
  * configured per project.
  *
  * This is the configurable version of the same idea. It is deliberately a pure
@@ -44,7 +44,7 @@ export interface ComponentPatternRule {
     export?: string;
 }
 export type ComponentResolverRule = ComponentMapRule | ComponentPatternRule;
-/** Two rules claiming the same name — reported rather than silently first-wins. */
+/** Two rules claiming the same name: reported rather than silently first-wins. */
 export interface ResolverConflict {
     name: string;
     modules: string[];
@@ -60,7 +60,7 @@ export interface ComponentResolver {
 /**
  * Build a resolver from rules, in order.
  *
- * Map rules are flattened up front so lookup is a plain object read — resolution runs
+ * Map rules are flattened up front so lookup is a plain object read, resolution runs
  * once per component reference per compile, so it sits on the hot path of every build.
  * Pattern rules are tried afterwards, in declaration order, and only when no map rule
  * matched: an explicit entry should always beat a pattern.

package/dist/resolve/component-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component-resolver.d.ts","sourceRoot":"","sources":["../../src/resolve/component-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,6CAA6C;AAC7C,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,CAAC,CAAC;CACxD;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,qBAAqB,GAAG,gBAAgB,GAAG,oBAAoB,CAAC;AAE5E,mFAAmF;AACnF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,gDAAgD;IAChD,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,iBAAiB,GAAG,SAAS,CAAC;IACzD,iEAAiE;IACjE,KAAK,EAAE,MAAM,MAAM,EAAE,CAAC;IACtB,kEAAkE;IAClE,SAAS,EAAE,MAAM,gBAAgB,EAAE,CAAC;CACrC;AAiBD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,GAAE,SAAS,qBAAqB,EAAO,GAC3C,iBAAiB,CAwDnB"}
+{"version":3,"file":"component-resolver.d.ts","sourceRoot":"","sources":["../../src/resolve/component-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,6CAA6C;AAC7C,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,CAAC,CAAC;CACxD;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,qBAAqB,GAAG,gBAAgB,GAAG,oBAAoB,CAAC;AAE5E,kFAAkF;AAClF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,gDAAgD;IAChD,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,iBAAiB,GAAG,SAAS,CAAC;IACzD,iEAAiE;IACjE,KAAK,EAAE,MAAM,MAAM,EAAE,CAAC;IACtB,kEAAkE;IAClE,SAAS,EAAE,MAAM,gBAAgB,EAAE,CAAC;CACrC;AAiBD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,GAAE,SAAS,qBAAqB,EAAO,GAC3C,iBAAiB,CAwDnB"}

package/dist/resolve/component-resolver.js

@@ -4,7 +4,7 @@
  * An unbound capitalised tag in a template is a name the compiler can resolve to a
  * module, instead of an import the author has to write. The framework already does
  * this for `Suspense`/`Portal`/`Router`, but through a hardcoded name set inside the
- * Babel plugin — which cannot be extended by a UI library or an app, and cannot be
+ * Babel plugin: which cannot be extended by a UI library or an app, and cannot be
  * configured per project.
  *
  * This is the configurable version of the same idea. It is deliberately a pure
@@ -33,7 +33,7 @@ function normalise(name, entry) {
 /**
  * Build a resolver from rules, in order.
  *
- * Map rules are flattened up front so lookup is a plain object read — resolution runs
+ * Map rules are flattened up front so lookup is a plain object read, resolution runs
  * once per component reference per compile, so it sits on the hot path of every build.
  * Pattern rules are tried afterwards, in declaration order, and only when no map rule
  * matched: an explicit entry should always beat a pattern.
@@ -54,7 +54,7 @@ export function createComponentResolver(rules = []) {
                 // Ambiguity is the failure mode that actually happens once a map holds
                 // ~80 common words (Card, Table, Text, Link). Silently taking the first
                 // rule would compile a working import of the wrong component, which is
-                // far worse to debug than a build error — so it is recorded and reported.
+                // far worse to debug than a build error: so it is recorded and reported.
                 const conflict = conflicts.find((c) => c.name === name);
                 if (conflict)
                     conflict.modules.push(resolved.module);

package/dist/resolve/load-directive.d.cts

@@ -1,17 +1,17 @@
 /**
- * The `load:` directive — when a component's code is fetched.
+ * The `load:` directive: when a component's code is fetched.
  *
  * Resolution decides *where* a component comes from; this decides *when*. They are
  * separate because they vary independently: the location of `<RevenueChart>` is the
  * same everywhere and belongs in config, while whether this particular usage should
- * wait for the viewport is a property of the usage. Fusing them — `<Chart lazy="./Chart">`
- * — was rejected for exactly that reason.
+ * wait for the viewport is a property of the usage. Fusing them, `<Chart lazy="./Chart">`
+ *: was rejected for exactly that reason.
  *
  * `load:` joins the existing `use:`/`prop:`/`attr:`/`bool:` namespace, so it cannot
  * collide with a real prop and the parser already has a directive taxonomy to hang it on.
  *
  * One parser for both frontends. `load:visible` is already a valid `JSXNamespacedName`,
- * so JSX needs no parser change, and the html`` path produces a `LoadDirective` node —
+ * so JSX needs no parser change, and the html`` path produces a `LoadDirective` node ,
  * but both funnel through {@link parseLoadDirective}, so the two syntaxes cannot drift.
  */
 /** When a component's module is fetched. */
@@ -42,7 +42,7 @@ export declare function isLoadDirective(name: string): boolean;
 /**
  * Parse `load:<strategy>` plus its optional value into a strategy.
  *
- * `value` is the attribute's literal text — `load:visible="200px"` — or null for a bare
+ * `value` is the attribute's literal text: `load:visible="200px"`, or null for a bare
  * directive. A `${…}` hole is rejected: the strategy has to be known at compile time
  * because it decides how the module is emitted, and a runtime value cannot.
  */

package/dist/resolve/load-directive.d.ts

@@ -1,17 +1,17 @@
 /**
- * The `load:` directive — when a component's code is fetched.
+ * The `load:` directive: when a component's code is fetched.
  *
  * Resolution decides *where* a component comes from; this decides *when*. They are
  * separate because they vary independently: the location of `<RevenueChart>` is the
  * same everywhere and belongs in config, while whether this particular usage should
- * wait for the viewport is a property of the usage. Fusing them — `<Chart lazy="./Chart">`
- * — was rejected for exactly that reason.
+ * wait for the viewport is a property of the usage. Fusing them, `<Chart lazy="./Chart">`
+ *: was rejected for exactly that reason.
  *
  * `load:` joins the existing `use:`/`prop:`/`attr:`/`bool:` namespace, so it cannot
  * collide with a real prop and the parser already has a directive taxonomy to hang it on.
  *
  * One parser for both frontends. `load:visible` is already a valid `JSXNamespacedName`,
- * so JSX needs no parser change, and the html`` path produces a `LoadDirective` node —
+ * so JSX needs no parser change, and the html`` path produces a `LoadDirective` node ,
  * but both funnel through {@link parseLoadDirective}, so the two syntaxes cannot drift.
  */
 /** When a component's module is fetched. */
@@ -42,7 +42,7 @@ export declare function isLoadDirective(name: string): boolean;
 /**
  * Parse `load:<strategy>` plus its optional value into a strategy.
  *
- * `value` is the attribute's literal text — `load:visible="200px"` — or null for a bare
+ * `value` is the attribute's literal text: `load:visible="200px"`, or null for a bare
  * directive. A `${…}` hole is rejected: the strategy has to be known at compile time
  * because it decides how the module is emitted, and a runtime value cannot.
  */

package/dist/resolve/load-directive.js

@@ -1,17 +1,17 @@
 /**
- * The `load:` directive — when a component's code is fetched.
+ * The `load:` directive: when a component's code is fetched.
  *
  * Resolution decides *where* a component comes from; this decides *when*. They are
  * separate because they vary independently: the location of `<RevenueChart>` is the
  * same everywhere and belongs in config, while whether this particular usage should
- * wait for the viewport is a property of the usage. Fusing them — `<Chart lazy="./Chart">`
- * — was rejected for exactly that reason.
+ * wait for the viewport is a property of the usage. Fusing them, `<Chart lazy="./Chart">`
+ *: was rejected for exactly that reason.
  *
  * `load:` joins the existing `use:`/`prop:`/`attr:`/`bool:` namespace, so it cannot
  * collide with a real prop and the parser already has a directive taxonomy to hang it on.
  *
  * One parser for both frontends. `load:visible` is already a valid `JSXNamespacedName`,
- * so JSX needs no parser change, and the html`` path produces a `LoadDirective` node —
+ * so JSX needs no parser change, and the html`` path produces a `LoadDirective` node ,
  * but both funnel through {@link parseLoadDirective}, so the two syntaxes cannot drift.
  */
 /** Everything is eager unless a directive says otherwise. */
@@ -28,7 +28,7 @@ export function isLoadDirective(name) {
 /**
  * Parse `load:<strategy>` plus its optional value into a strategy.
  *
- * `value` is the attribute's literal text — `load:visible="200px"` — or null for a bare
+ * `value` is the attribute's literal text: `load:visible="200px"`, or null for a bare
  * directive. A `${…}` hole is rejected: the strategy has to be known at compile time
  * because it decides how the module is emitted, and a runtime value cannot.
  */
@@ -46,7 +46,7 @@ export function parseLoadDirective(name, value) {
             return { kind: 'never' };
         case 'visible':
             // `load:visible="200px"` starts the fetch before the element reaches the
-            // viewport, which is usually what you want — arriving exactly on intersection
+            // viewport, which is usually what you want, arriving exactly on intersection
             // means the user waits for the network.
             return value ? { kind: 'visible', rootMargin: value } : { kind: 'visible' };
         case 'interaction':

package/dist/resolve/resolve-ir.d.cts

@@ -2,13 +2,13 @@
  * The resolve pass: annotate component references in the IR with where they come from.
  *
  * Runs between the frontends and the optimizer, so every later pass reads provenance off
- * the node instead of re-deriving it. Nothing here emits code — the pass only records a
+ * the node instead of re-deriving it. Nothing here emits code, the pass only records a
  * decision, which is what lets the same answer drive import injection, chunk grouping,
  * hint planning and diagnostics without any of them agreeing by coincidence.
  *
  * Two suppliers, in precedence order:
  *
- *  1. **Control flow** (`Show`, `For`, `Switch`, …) — the name selects a lowering, so a
+ *  1. **Control flow** (`Show`, `For`, `Switch`, …), the name selects a lowering, so a
  *     rule cannot re-point it. Recorded as `builtin` so a later pass can tell the
  *     difference between "configured here" and "fixed by the compiler".
  *  2. **Configured rules**, then the **router built-ins**. Router components are only an
@@ -24,13 +24,13 @@ import { type IRLoadStrategy } from './load-directive.cjs';
 export interface ResolveOptions {
     /** Rules configured for the project. Omit when the project configures none. */
     resolver?: ComponentResolver;
-    /** True when the name already has a binding in the file — an import the author wrote. */
+    /** True when the name already has a binding in the file, an import the author wrote. */
     isBound?: (name: string) => boolean;
     /** Module overrides, so `routerModule` and friends are honoured. */
     modules?: Parameters<typeof builtinComponentMap>[0];
     /**
      * The `load:` strategy for a reference, when the frontend found one on the tag.
-     * Keyed by node so two usages of the same component can load differently — the
+     * Keyed by node so two usages of the same component can load differently, the
      * whole reason timing lives at the usage site and location does not.
      */
     strategyFor?: (node: IRComponent) => IRLoadStrategy | undefined;
@@ -41,8 +41,8 @@ export interface ResolveReport {
     /**
      * Capitalised tags nothing supplies and nothing binds.
      *
-     * These compile to a reference to an identifier that does not exist — the build
-     * succeeds and the page throws at runtime — so they are the pass's most useful
+     * These compile to a reference to an identifier that does not exist, the build
+     * succeeds and the page throws at runtime: so they are the pass's most useful
      * output for diagnostics.
      */
     unresolved: string[];

package/dist/resolve/resolve-ir.d.ts

@@ -2,13 +2,13 @@
  * The resolve pass: annotate component references in the IR with where they come from.
  *
  * Runs between the frontends and the optimizer, so every later pass reads provenance off
- * the node instead of re-deriving it. Nothing here emits code — the pass only records a
+ * the node instead of re-deriving it. Nothing here emits code, the pass only records a
  * decision, which is what lets the same answer drive import injection, chunk grouping,
  * hint planning and diagnostics without any of them agreeing by coincidence.
  *
  * Two suppliers, in precedence order:
  *
- *  1. **Control flow** (`Show`, `For`, `Switch`, …) — the name selects a lowering, so a
+ *  1. **Control flow** (`Show`, `For`, `Switch`, …), the name selects a lowering, so a
  *     rule cannot re-point it. Recorded as `builtin` so a later pass can tell the
  *     difference between "configured here" and "fixed by the compiler".
  *  2. **Configured rules**, then the **router built-ins**. Router components are only an
@@ -24,13 +24,13 @@ import { type IRLoadStrategy } from './load-directive.js';
 export interface ResolveOptions {
     /** Rules configured for the project. Omit when the project configures none. */
     resolver?: ComponentResolver;
-    /** True when the name already has a binding in the file — an import the author wrote. */
+    /** True when the name already has a binding in the file, an import the author wrote. */
     isBound?: (name: string) => boolean;
     /** Module overrides, so `routerModule` and friends are honoured. */
     modules?: Parameters<typeof builtinComponentMap>[0];
     /**
      * The `load:` strategy for a reference, when the frontend found one on the tag.
-     * Keyed by node so two usages of the same component can load differently — the
+     * Keyed by node so two usages of the same component can load differently, the
      * whole reason timing lives at the usage site and location does not.
      */
     strategyFor?: (node: IRComponent) => IRLoadStrategy | undefined;
@@ -41,8 +41,8 @@ export interface ResolveReport {
     /**
      * Capitalised tags nothing supplies and nothing binds.
      *
-     * These compile to a reference to an identifier that does not exist — the build
-     * succeeds and the page throws at runtime — so they are the pass's most useful
+     * These compile to a reference to an identifier that does not exist, the build
+     * succeeds and the page throws at runtime: so they are the pass's most useful
      * output for diagnostics.
      */
     unresolved: string[];

package/dist/resolve/resolve-ir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-ir.d.ts","sourceRoot":"","sources":["../../src/resolve/resolve-ir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAA0C,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAC5F,OAAO,EAAS,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEjE,MAAM,WAAW,cAAc;IAC7B,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,yFAAyF;IACzF,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IACpC,oEAAoE;IACpE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;IACpD;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,cAAc,GAAG,SAAS,CAAC;CACjE;AAED,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IACzC;;;;;;OAMG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,gFAAgF;AAChF,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EACvB,OAAO,GAAE,cAAmB,GAC3B,aAAa,CA8Cf;AAED,kEAAkE;AAClE,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAOjF"}
+{"version":3,"file":"resolve-ir.d.ts","sourceRoot":"","sources":["../../src/resolve/resolve-ir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAA0C,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAC5F,OAAO,EAAS,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEjE,MAAM,WAAW,cAAc;IAC7B,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,wFAAwF;IACxF,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IACpC,oEAAoE;IACpE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;IACpD;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,cAAc,GAAG,SAAS,CAAC;CACjE;AAED,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IACzC;;;;;;OAMG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,gFAAgF;AAChF,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EACvB,OAAO,GAAE,cAAmB,GAC3B,aAAa,CA8Cf;AAED,kEAAkE;AAClE,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAOjF"}

package/dist/resolve/resolve-ir.js

@@ -9,7 +9,7 @@ export function resolveComponentSources(root, options = {}) {
     const annotate = (node) => {
         const { name } = node;
         // A dotted path (`Ctx.Provider`) or a dynamic tag needs its root binding, which is
-        // an ordinary expression the author wrote — nothing to supply.
+        // an ordinary expression the author wrote: nothing to supply.
         if (!name || name.includes('.'))
             return;
         if (isBound?.(name))

package/dist/resolve/write-globals.cjs

@@ -128,7 +128,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" },
@@ -214,7 +214,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;
@@ -230,7 +230,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/write-globals.js

@@ -21,7 +21,7 @@ export const DEFAULT_GLOBALS_PATH = 'fluixi.d.ts';
 /**
  * Whether `target` looks covered by the project's `include`, as best we can tell.
  *
- * `undefined` when there is nothing to judge from — no tsconfig, unreadable, or an
+ * `undefined` when there is nothing to judge from, no tsconfig, unreadable, or an
  * `extends` we would have to resolve to answer honestly. Best-effort by design: this
  * drives a warning, never a failure, so a wrong guess must not be able to break a build.
  */
@@ -84,7 +84,7 @@ function projectDependencies(root) {
         ];
     }
     catch {
-        // No manifest to read — declare everything and let TypeScript report what is missing.
+        // No manifest to read: declare everything and let TypeScript report what is missing.
         return undefined;
     }
 }

package/dist/resolve/write-globals.mjs

@@ -103,7 +103,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" },
@@ -189,7 +189,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 module = resolver.resolve(n)?.module;
@@ -205,7 +205,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/{server-fns-4ZXN6DYU.mjs → server-fns-ZYWQTSZU.mjs}

@@ -1,11 +1,11 @@
-/*! @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 {
   MagicString
-} from "./chunk-R2VHAZAX.mjs";
+} from "./chunk-RUDJDZAA.mjs";
 import {
   serverFnId
-} from "./chunk-FSSWUXUR.mjs";
-import "./chunk-3YKZ4GNH.mjs";
+} from "./chunk-F74GFKSL.mjs";
+import "./chunk-G6QC2WRJ.mjs";
 
 // src/transform/server-fns.ts
 import { parse } from "@babel/parser";

package/dist/{server-functions-V6D6DRIA.mjs → server-functions-PCERFA7A.mjs}

@@ -1,8 +1,8 @@
-/*! @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 {
   serverFnId
-} from "./chunk-FSSWUXUR.mjs";
-import "./chunk-3YKZ4GNH.mjs";
+} from "./chunk-F74GFKSL.mjs";
+import "./chunk-G6QC2WRJ.mjs";
 
 // src/frontend/babel/server-functions.ts
 import { transformSync } from "@babel/core";

package/dist/transform/bindings.d.cts

@@ -6,7 +6,7 @@
  * function shadows our import there but cannot collide with it, which is the same
  * answer `path.scope.hasBinding` gives on the Program path.
  *
- * Missing a binding emits a duplicate declaration — a syntax error. Reporting one
+ * Missing a binding emits a duplicate declaration, a syntax error. Reporting one
  * that isn't there drops an import the code needs. Both are loud, neither is
  * subtle, and the corpus in bindings.spec.ts covers the patterns that bind.
  */

package/dist/transform/bindings.d.ts

@@ -6,7 +6,7 @@
  * function shadows our import there but cannot collide with it, which is the same
  * answer `path.scope.hasBinding` gives on the Program path.
  *
- * Missing a binding emits a duplicate declaration — a syntax error. Reporting one
+ * Missing a binding emits a duplicate declaration, a syntax error. Reporting one
  * that isn't there drops an import the code needs. Both are loud, neither is
  * subtle, and the corpus in bindings.spec.ts covers the patterns that bind.
  */

package/dist/transform/bindings.js

@@ -6,7 +6,7 @@
  * function shadows our import there but cannot collide with it, which is the same
  * answer `path.scope.hasBinding` gives on the Program path.
  *
- * Missing a binding emits a duplicate declaration — a syntax error. Reporting one
+ * Missing a binding emits a duplicate declaration, a syntax error. Reporting one
  * that isn't there drops an import the code needs. Both are loud, neither is
  * subtle, and the corpus in bindings.spec.ts covers the patterns that bind.
  */

package/dist/transform/index.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.85 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -490,7 +490,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" },
@@ -1582,7 +1582,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/transform/index.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/templates.ts
 import { parse as parse2 } from "@babel/parser";
@@ -1522,7 +1522,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" },
@@ -2616,7 +2616,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;