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

package/dist/resolve/component-resolver.mjs

@@ -1 +1,59 @@
-var f=r=>"components"in r;function m(r,e){return r.replace(/\$(\d+)/g,(l,i)=>e[Number(i)]??l)}function d(r,e){return typeof e=="string"?{module:e,export:r}:e}function R(r=[]){let e=new Map,l=[],i=[];for(let o of r){if(!f(o)){i.push(o);continue}for(let[n,s]of Object.entries(o.components)){let t=d(n,s),c=e.get(n);if(c&&c.module!==t.module){let u=l.find(a=>a.name===n);u?u.modules.push(t.module):l.push({name:n,modules:[c.module,t.module]});continue}e.set(n,t)}}let p=new Map;return{resolve:o=>{if(p.has(o))return p.get(o);let n=e.get(o);if(!n)for(let s of i){let t=o.match(new RegExp(s.match.source,s.match.flags.replace("g","")));if(t){n={module:m(s.module,t),export:s.export?m(s.export,t):o};break}}return p.set(o,n),n},names:()=>[...e.keys()],conflicts:()=>l}}export{R as createComponentResolver};
+// src/resolve/component-resolver.ts
+var isMapRule = (rule) => "components" in rule;
+function substitute(template, match) {
+  return template.replace(/\$(\d+)/g, (whole, index) => {
+    const group = match[Number(index)];
+    return group ?? whole;
+  });
+}
+function normalise(name, entry) {
+  return typeof entry === "string" ? { module: entry, export: name } : entry;
+}
+function createComponentResolver(rules = []) {
+  const exact = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  const patterns = [];
+  for (const rule of rules) {
+    if (!isMapRule(rule)) {
+      patterns.push(rule);
+      continue;
+    }
+    for (const [name, entry] of Object.entries(rule.components)) {
+      const resolved = normalise(name, entry);
+      const existing = exact.get(name);
+      if (existing && existing.module !== resolved.module) {
+        const conflict = conflicts.find((c) => c.name === name);
+        if (conflict) conflict.modules.push(resolved.module);
+        else conflicts.push({ name, modules: [existing.module, resolved.module] });
+        continue;
+      }
+      exact.set(name, resolved);
+    }
+  }
+  const cache = /* @__PURE__ */ new Map();
+  const resolve = (name) => {
+    if (cache.has(name)) return cache.get(name);
+    let result = exact.get(name);
+    if (!result) {
+      for (const rule of patterns) {
+        const match = name.match(new RegExp(rule.match.source, rule.match.flags.replace("g", "")));
+        if (!match) continue;
+        result = {
+          module: substitute(rule.module, match),
+          export: rule.export ? substitute(rule.export, match) : name
+        };
+        break;
+      }
+    }
+    cache.set(name, result);
+    return result;
+  };
+  return {
+    resolve,
+    names: () => [...exact.keys()],
+    conflicts: () => conflicts
+  };
+}
+export {
+  createComponentResolver
+};

package/dist/resolve/load-directive.cjs

@@ -1 +1,93 @@
-"use strict";var o=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var k=(e,n)=>{for(var t in n)o(e,t,{get:n[t],enumerable:!0})},p=(e,n,t,a)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of g(n))!u.call(e,r)&&r!==t&&o(e,r,{get:()=>n[r],enumerable:!(a=l(n,r))||a.enumerable});return e};var w=e=>p(o({},"__esModule",{value:!0}),e);var y={};k(y,{DEFAULT_INTERACTION_EVENTS:()=>c,EAGER:()=>d,LoadDirectiveError:()=>i,isDeferred:()=>m,isLoadDirective:()=>v,parseLoadDirective:()=>f,strategyKey:()=>x});module.exports=w(y);var d={kind:"eager"},c=["pointerdown","focusin","keydown"],s=new Set(["eager","idle","visible","interaction","media","never"]),i=class extends Error{};function v(e){return e.startsWith("load:")}function f(e,n){let t=e.slice(5);if(!s.has(t))throw new i(`Unknown load strategy 'load:${t}'. Expected one of ${[...s].join(", ")}.`);switch(t){case"eager":return d;case"idle":return{kind:"idle"};case"never":return{kind:"never"};case"visible":return n?{kind:"visible",rootMargin:n}:{kind:"visible"};case"interaction":return{kind:"interaction",events:n?h(n):[...c]};case"media":if(!n)throw new i(`'load:media' needs a query, e.g. load:media="(min-width: 1024px)".`);return{kind:"media",query:n};default:throw new i(`Unhandled load strategy '${t}'.`)}}function h(e){let n=e.split(/[\s,]+/).map(t=>t.trim()).filter(Boolean);if(n.length===0)throw new i("'load:interaction' was given no event names.");return n}function m(e){return e.kind!=="eager"&&e.kind!=="never"}function x(e){switch(e.kind){case"visible":return`visible:${e.rootMargin??""}`;case"interaction":return`interaction:${[...e.events].sort().join(",")}`;case"media":return`media:${e.query}`;default:return e.kind}}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/resolve/load-directive.ts
+var load_directive_exports = {};
+__export(load_directive_exports, {
+  DEFAULT_INTERACTION_EVENTS: () => DEFAULT_INTERACTION_EVENTS,
+  EAGER: () => EAGER,
+  LoadDirectiveError: () => LoadDirectiveError,
+  isDeferred: () => isDeferred,
+  isLoadDirective: () => isLoadDirective,
+  parseLoadDirective: () => parseLoadDirective,
+  strategyKey: () => strategyKey
+});
+module.exports = __toCommonJS(load_directive_exports);
+var EAGER = { kind: "eager" };
+var DEFAULT_INTERACTION_EVENTS = ["pointerdown", "focusin", "keydown"];
+var STRATEGIES = /* @__PURE__ */ new Set(["eager", "idle", "visible", "interaction", "media", "never"]);
+var LoadDirectiveError = class extends Error {
+};
+function isLoadDirective(name) {
+  return name.startsWith("load:");
+}
+function parseLoadDirective(name, value) {
+  const strategy = name.slice("load:".length);
+  if (!STRATEGIES.has(strategy)) {
+    throw new LoadDirectiveError(
+      `Unknown load strategy 'load:${strategy}'. Expected one of ${[...STRATEGIES].join(", ")}.`
+    );
+  }
+  switch (strategy) {
+    case "eager":
+      return EAGER;
+    case "idle":
+      return { kind: "idle" };
+    case "never":
+      return { kind: "never" };
+    case "visible":
+      return value ? { kind: "visible", rootMargin: value } : { kind: "visible" };
+    case "interaction":
+      return {
+        kind: "interaction",
+        events: value ? splitEvents(value) : [...DEFAULT_INTERACTION_EVENTS]
+      };
+    case "media":
+      if (!value) {
+        throw new LoadDirectiveError(
+          `'load:media' needs a query, e.g. load:media="(min-width: 1024px)".`
+        );
+      }
+      return { kind: "media", query: value };
+    default:
+      throw new LoadDirectiveError(`Unhandled load strategy '${strategy}'.`);
+  }
+}
+function splitEvents(value) {
+  const events = value.split(/[\s,]+/).map((e) => e.trim()).filter(Boolean);
+  if (events.length === 0) {
+    throw new LoadDirectiveError(`'load:interaction' was given no event names.`);
+  }
+  return events;
+}
+function isDeferred(strategy) {
+  return strategy.kind !== "eager" && strategy.kind !== "never";
+}
+function strategyKey(strategy) {
+  switch (strategy.kind) {
+    case "visible":
+      return `visible:${strategy.rootMargin ?? ""}`;
+    case "interaction":
+      return `interaction:${[...strategy.events].sort().join(",")}`;
+    case "media":
+      return `media:${strategy.query}`;
+    default:
+      return strategy.kind;
+  }
+}

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

@@ -0,0 +1,53 @@
+/**
+ * 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.
+ *
+ * `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 ,
+ * but both funnel through {@link parseLoadDirective}, so the two syntaxes cannot drift.
+ */
+/** When a component's module is fetched. */
+export type IRLoadStrategy = {
+    kind: 'eager';
+} | {
+    kind: 'idle';
+} | {
+    kind: 'visible';
+    rootMargin?: string;
+} | {
+    kind: 'interaction';
+    events: string[];
+} | {
+    kind: 'media';
+    query: string;
+} | {
+    kind: 'never';
+};
+/** Everything is eager unless a directive says otherwise. */
+export declare const EAGER: IRLoadStrategy;
+/** Events that trigger an `interaction` load when none are named. */
+export declare const DEFAULT_INTERACTION_EVENTS: readonly ["pointerdown", "focusin", "keydown"];
+export declare class LoadDirectiveError extends Error {
+}
+/** True for an attribute name in the `load:` namespace. */
+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
+ * 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.
+ */
+export declare function parseLoadDirective(name: string, value: string | null): IRLoadStrategy;
+/** True when the strategy means "not in the parent chunk". */
+export declare function isDeferred(strategy: IRLoadStrategy): boolean;
+/** A stable key for grouping references that share a strategy. */
+export declare function strategyKey(strategy: IRLoadStrategy): string;

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/load-directive.mjs

@@ -1 +1,72 @@
-var o={kind:"eager"},a=["pointerdown","focusin","keydown"],r=new Set(["eager","idle","visible","interaction","media","never"]),i=class extends Error{};function d(e){return e.startsWith("load:")}function c(e,n){let t=e.slice(5);if(!r.has(t))throw new i(`Unknown load strategy 'load:${t}'. Expected one of ${[...r].join(", ")}.`);switch(t){case"eager":return o;case"idle":return{kind:"idle"};case"never":return{kind:"never"};case"visible":return n?{kind:"visible",rootMargin:n}:{kind:"visible"};case"interaction":return{kind:"interaction",events:n?s(n):[...a]};case"media":if(!n)throw new i(`'load:media' needs a query, e.g. load:media="(min-width: 1024px)".`);return{kind:"media",query:n};default:throw new i(`Unhandled load strategy '${t}'.`)}}function s(e){let n=e.split(/[\s,]+/).map(t=>t.trim()).filter(Boolean);if(n.length===0)throw new i("'load:interaction' was given no event names.");return n}function l(e){return e.kind!=="eager"&&e.kind!=="never"}function g(e){switch(e.kind){case"visible":return`visible:${e.rootMargin??""}`;case"interaction":return`interaction:${[...e.events].sort().join(",")}`;case"media":return`media:${e.query}`;default:return e.kind}}export{a as DEFAULT_INTERACTION_EVENTS,o as EAGER,i as LoadDirectiveError,l as isDeferred,d as isLoadDirective,c as parseLoadDirective,g as strategyKey};
+// src/resolve/load-directive.ts
+var EAGER = { kind: "eager" };
+var DEFAULT_INTERACTION_EVENTS = ["pointerdown", "focusin", "keydown"];
+var STRATEGIES = /* @__PURE__ */ new Set(["eager", "idle", "visible", "interaction", "media", "never"]);
+var LoadDirectiveError = class extends Error {
+};
+function isLoadDirective(name) {
+  return name.startsWith("load:");
+}
+function parseLoadDirective(name, value) {
+  const strategy = name.slice("load:".length);
+  if (!STRATEGIES.has(strategy)) {
+    throw new LoadDirectiveError(
+      `Unknown load strategy 'load:${strategy}'. Expected one of ${[...STRATEGIES].join(", ")}.`
+    );
+  }
+  switch (strategy) {
+    case "eager":
+      return EAGER;
+    case "idle":
+      return { kind: "idle" };
+    case "never":
+      return { kind: "never" };
+    case "visible":
+      return value ? { kind: "visible", rootMargin: value } : { kind: "visible" };
+    case "interaction":
+      return {
+        kind: "interaction",
+        events: value ? splitEvents(value) : [...DEFAULT_INTERACTION_EVENTS]
+      };
+    case "media":
+      if (!value) {
+        throw new LoadDirectiveError(
+          `'load:media' needs a query, e.g. load:media="(min-width: 1024px)".`
+        );
+      }
+      return { kind: "media", query: value };
+    default:
+      throw new LoadDirectiveError(`Unhandled load strategy '${strategy}'.`);
+  }
+}
+function splitEvents(value) {
+  const events = value.split(/[\s,]+/).map((e) => e.trim()).filter(Boolean);
+  if (events.length === 0) {
+    throw new LoadDirectiveError(`'load:interaction' was given no event names.`);
+  }
+  return events;
+}
+function isDeferred(strategy) {
+  return strategy.kind !== "eager" && strategy.kind !== "never";
+}
+function strategyKey(strategy) {
+  switch (strategy.kind) {
+    case "visible":
+      return `visible:${strategy.rootMargin ?? ""}`;
+    case "interaction":
+      return `interaction:${[...strategy.events].sort().join(",")}`;
+    case "media":
+      return `media:${strategy.query}`;
+    default:
+      return strategy.kind;
+  }
+}
+export {
+  DEFAULT_INTERACTION_EVENTS,
+  EAGER,
+  LoadDirectiveError,
+  isDeferred,
+  isLoadDirective,
+  parseLoadDirective,
+  strategyKey
+};

package/dist/resolve/resolve-ir.cjs

@@ -1 +1,108 @@
-"use strict";var c=Object.defineProperty;var M=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var I=Object.prototype.hasOwnProperty;var w=(n,e)=>{for(var i in e)c(n,i,{get:e[i],enumerable:!0})},N=(n,e,i,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of y(e))!I.call(n,o)&&o!==i&&c(n,o,{get:()=>e[o],enumerable:!(s=M(e,o))||s.enumerable});return n};var k=n=>N(c({},"__esModule",{value:!0}),n);var h={};w(h,{resolveComponentSources:()=>b,walk:()=>f});module.exports=k(h);var l=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],p=["Suspense","SuspenseList","Await"],a=["Router","Outlet","Redirect","Link"],L=[...l,...p,...a],m=new Set([...l,...p]);function S(n={}){let{controlFlowModule:e="@fluixi/dom",coreModule:i="@fluixi/core",routerModule:s="@fluixi/core/router"}=n,o={};for(let d of l)o[d]=e;for(let d of p)o[d]=i;for(let d of a)o[d]=s;return o}var R={kind:"eager"};function b(n,e={}){let{resolver:i,isBound:s,modules:o,strategyFor:d}=e,g=S(o),v=new Map,x=new Set,E=t=>{let{name:r}=t;if(!r||r.includes(".")||s?.(r))return;let u=O(r);if(!u){x.add(r);return}let C=u.origin==="builtin"&&m.has(r)?R:d?.(t)??R;t.source={...u,loading:C},v.set(r,t.source)},O=t=>{if(m.has(t))return{module:g[t],export:t,origin:"builtin"};let r=i?.resolve(t);if(r)return{module:r.module,export:r.export,origin:"rule"};if(a.includes(t))return{module:g[t],export:t,origin:"builtin"}};return f(n,t=>{t.kind==="component"&&E(t)}),{resolved:v,unresolved:[...x]}}function f(n,e){let i=Array.isArray(n)?n:[n];for(let s of i){e(s);let o=s.children;o&&f(o,e)}}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/resolve/resolve-ir.ts
+var resolve_ir_exports = {};
+__export(resolve_ir_exports, {
+  resolveComponentSources: () => resolveComponentSources,
+  walk: () => walk
+});
+module.exports = __toCommonJS(resolve_ir_exports);
+
+// src/resolve/builtins.ts
+var DOM_CONTROL_FLOW = [
+  "Show",
+  "For",
+  "Index",
+  "Switch",
+  "Match",
+  "Portal",
+  "Dynamic",
+  "ErrorBoundary"
+];
+var CORE_CONTROL_FLOW = ["Suspense", "SuspenseList", "Await"];
+var ROUTER_COMPONENTS = ["Router", "Outlet", "Redirect", "Link"];
+var BUILTIN_COMPONENTS = [
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW,
+  ...ROUTER_COMPONENTS
+];
+var RESERVED_COMPONENTS = /* @__PURE__ */ new Set([
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW
+]);
+function builtinComponentMap(modules = {}) {
+  const {
+    controlFlowModule = "@fluixi/dom",
+    coreModule = "@fluixi/core",
+    routerModule = "@fluixi/core/router"
+  } = modules;
+  const map = {};
+  for (const name of DOM_CONTROL_FLOW) map[name] = controlFlowModule;
+  for (const name of CORE_CONTROL_FLOW) map[name] = coreModule;
+  for (const name of ROUTER_COMPONENTS) map[name] = routerModule;
+  return map;
+}
+
+// src/resolve/load-directive.ts
+var EAGER = { kind: "eager" };
+
+// src/resolve/resolve-ir.ts
+function resolveComponentSources(root, options = {}) {
+  const { resolver, isBound, modules, strategyFor } = options;
+  const builtins = builtinComponentMap(modules);
+  const resolved = /* @__PURE__ */ new Map();
+  const unresolved = /* @__PURE__ */ new Set();
+  const annotate = (node) => {
+    const { name } = node;
+    if (!name || name.includes(".")) return;
+    if (isBound?.(name)) return;
+    const source = sourceFor(name);
+    if (!source) {
+      unresolved.add(name);
+      return;
+    }
+    const loading = source.origin === "builtin" && RESERVED_COMPONENTS.has(name) ? EAGER : strategyFor?.(node) ?? EAGER;
+    node.source = { ...source, loading };
+    resolved.set(name, node.source);
+  };
+  const sourceFor = (name) => {
+    if (RESERVED_COMPONENTS.has(name)) {
+      return { module: builtins[name], export: name, origin: "builtin" };
+    }
+    const rule = resolver?.resolve(name);
+    if (rule) return { module: rule.module, export: rule.export, origin: "rule" };
+    if (ROUTER_COMPONENTS.includes(name)) {
+      return { module: builtins[name], export: name, origin: "builtin" };
+    }
+    return void 0;
+  };
+  walk(root, (node) => {
+    if (node.kind === "component") annotate(node);
+  });
+  return { resolved, unresolved: [...unresolved] };
+}
+function walk(root, visit) {
+  const nodes = Array.isArray(root) ? root : [root];
+  for (const node of nodes) {
+    visit(node);
+    const children = node.children;
+    if (children) walk(children, visit);
+  }
+}

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

@@ -0,0 +1,53 @@
+/**
+ * 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
+ * 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
+ *     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
+ *     import, so a project's own `Link` wins; see `builtins.ts`.
+ *
+ * A name bound in the file is not resolved at all: the author's import always wins, and
+ * the caller supplies those bindings via `isBound`.
+ */
+import type { IRNode, IRComponent, IRComponentSource } from '../ir/nodes.cjs';
+import type { ComponentResolver } from './component-resolver.cjs';
+import { builtinComponentMap } from './builtins.cjs';
+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. */
+    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
+     * whole reason timing lives at the usage site and location does not.
+     */
+    strategyFor?: (node: IRComponent) => IRLoadStrategy | undefined;
+}
+export interface ResolveReport {
+    /** Every reference the pass annotated, by name. */
+    resolved: Map<string, IRComponentSource>;
+    /**
+     * 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
+     * output for diagnostics.
+     */
+    unresolved: string[];
+}
+/** Annotate every component reference in `root`, returning what was decided. */
+export declare function resolveComponentSources(root: IRNode | IRNode[], options?: ResolveOptions): ResolveReport;
+/** Depth-first walk over every node that can contain children. */
+export declare function walk(root: IRNode | IRNode[], visit: (node: IRNode) => void): void;

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))