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

package/dist/resolve/builtins.cjs

@@ -1 +1,73 @@
-"use strict";var l=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var m=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var M=(o,t)=>{for(var e in t)l(o,e,{get:t[e],enumerable:!0})},O=(o,t,e,s)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of m(t))!d.call(o,n)&&n!==e&&l(o,n,{get:()=>t[n],enumerable:!(s=a(t,n))||s.enumerable});return o};var f=o=>O(l({},"__esModule",{value:!0}),o);var E={};M(E,{BUILTIN_COMPONENTS:()=>R,CORE_CONTROL_FLOW:()=>u,DOM_CONTROL_FLOW:()=>i,RESERVED_COMPONENTS:()=>x,ROUTER_COMPONENTS:()=>c,builtinComponentMap:()=>p,builtinComponents:()=>C,routerComponents:()=>g});module.exports=f(E);var i=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],u=["Suspense","SuspenseList","Await"],c=["Router","Outlet","Redirect","Link"],R=[...i,...u,...c],x=new Set([...i,...u]);function p(o={}){let{controlFlowModule:t="@fluixi/dom",coreModule:e="@fluixi/core",routerModule:s="@fluixi/core/router"}=o,n={};for(let r of i)n[r]=t;for(let r of u)n[r]=e;for(let r of c)n[r]=s;return n}function C(o={}){return{components:p(o)}}function g(o){let t=o??"@fluixi/core/router";return{components:Object.fromEntries(c.map(e=>[e,t]))}}
+/*! @fluixi/compiler v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"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/builtins.ts
+var builtins_exports = {};
+__export(builtins_exports, {
+  BUILTIN_COMPONENTS: () => BUILTIN_COMPONENTS,
+  CORE_CONTROL_FLOW: () => CORE_CONTROL_FLOW,
+  DOM_CONTROL_FLOW: () => DOM_CONTROL_FLOW,
+  RESERVED_COMPONENTS: () => RESERVED_COMPONENTS,
+  ROUTER_COMPONENTS: () => ROUTER_COMPONENTS,
+  builtinComponentMap: () => builtinComponentMap,
+  builtinComponents: () => builtinComponents,
+  routerComponents: () => routerComponents
+});
+module.exports = __toCommonJS(builtins_exports);
+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;
+}
+function builtinComponents(modules = {}) {
+  return { components: builtinComponentMap(modules) };
+}
+function routerComponents(routerModule) {
+  const module2 = routerModule ?? "@fluixi/core/router";
+  return { components: Object.fromEntries(ROUTER_COMPONENTS.map((n) => [n, module2])) };
+}

package/dist/resolve/builtins.d.cts

@@ -0,0 +1,68 @@
+/**
+ * The components the compiler supplies without an import, as data.
+ *
+ * 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
+ * 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
+ * with a test that fails when the two drift.
+ *
+ * So the names live here, shaped as {@link ComponentMapRule} so they compose with
+ * user-configured `resolve` rules, and the compiler keeps its own sets for the parts
+ * that are genuinely about codegen.
+ *
+ * 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
+ * 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.
+ */
+import type { ComponentMapRule } from './component-resolver.cjs';
+/** Where the built-in groups come from when the host does not override the module. */
+export interface BuiltinModules {
+    /** Control flow that lives in the DOM package. Default `@fluixi/dom`. */
+    controlFlowModule?: string;
+    /** Control flow that only exists in core. Default `@fluixi/core`. */
+    coreModule?: string;
+    /** Router components. Default `@fluixi/core/router`. */
+    routerModule?: string;
+}
+/** 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. */
+export declare const CORE_CONTROL_FLOW: readonly ["Suspense", "SuspenseList", "Await"];
+/**
+ * Router components.
+ *
+ * `Routes` is not a component (routing is `<Router routes={…}>`) and `lazy` is a call
+ * rather than a tag, so neither can be supplied this way.
+ */
+export declare const ROUTER_COMPONENTS: readonly ["Router", "Outlet", "Redirect", "Link"];
+/** Every name the compiler supplies without an import. */
+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
+ * 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.
+ */
+export declare const RESERVED_COMPONENTS: ReadonlySet<string>;
+/** Name → module for every built-in, honouring host module overrides. */
+export declare function builtinComponentMap(modules?: BuiltinModules): Record<string, string>;
+/**
+ * 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
+ * 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. */
+export declare function routerComponents(routerModule?: string): ComponentMapRule;

package/dist/resolve/builtins.mjs

@@ -1 +1,53 @@
-var s=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],i=["Suspense","SuspenseList","Await"],u=["Router","Outlet","Redirect","Link"],p=[...s,...i,...u],a=new Set([...s,...i]);function l(o={}){let{controlFlowModule:e="@fluixi/dom",coreModule:r="@fluixi/core",routerModule:c="@fluixi/core/router"}=o,n={};for(let t of s)n[t]=e;for(let t of i)n[t]=r;for(let t of u)n[t]=c;return n}function m(o={}){return{components:l(o)}}function d(o){let e=o??"@fluixi/core/router";return{components:Object.fromEntries(u.map(r=>[r,e]))}}export{p as BUILTIN_COMPONENTS,i as CORE_CONTROL_FLOW,s as DOM_CONTROL_FLOW,a as RESERVED_COMPONENTS,u as ROUTER_COMPONENTS,l as builtinComponentMap,m as builtinComponents,d as routerComponents};
+/*! @fluixi/compiler v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// 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;
+}
+function builtinComponents(modules = {}) {
+  return { components: builtinComponentMap(modules) };
+}
+function routerComponents(routerModule) {
+  const module = routerModule ?? "@fluixi/core/router";
+  return { components: Object.fromEntries(ROUTER_COMPONENTS.map((n) => [n, module])) };
+}
+export {
+  BUILTIN_COMPONENTS,
+  CORE_CONTROL_FLOW,
+  DOM_CONTROL_FLOW,
+  RESERVED_COMPONENTS,
+  ROUTER_COMPONENTS,
+  builtinComponentMap,
+  builtinComponents,
+  routerComponents
+};

package/dist/resolve/component-globals.cjs

@@ -1,22 +1,242 @@
-"use strict";var C=Object.defineProperty;var _=Object.getOwnPropertyDescriptor;var D=Object.getOwnPropertyNames;var P=Object.prototype.hasOwnProperty;var k=(e,t)=>{for(var r in t)C(e,r,{get:t[r],enumerable:!0})},A=(e,t,r,c)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of D(t))!P.call(e,n)&&n!==r&&C(e,n,{get:()=>t[n],enumerable:!(c=_(t,n))||c.enumerable});return e};var B=e=>A(C({},"__esModule",{value:!0}),e);var H={};k(H,{componentGlobals:()=>V});module.exports=B(H);var G=e=>"components"in e;function S(e,t){return e.replace(/\$(\d+)/g,(r,c)=>t[Number(c)]??r)}function W(e,t){return typeof t=="string"?{module:t,export:e}:t}function $(e=[]){let t=new Map,r=[],c=[];for(let s of e){if(!G(s)){c.push(s);continue}for(let[i,a]of Object.entries(s.components)){let u=W(i,a),m=t.get(i);if(m&&m.module!==u.module){let d=r.find(R=>R.name===i);d?d.modules.push(u.module):r.push({name:i,modules:[m.module,u.module]});continue}t.set(i,u)}}let n=new Map;return{resolve:s=>{if(n.has(s))return n.get(s);let i=t.get(s);if(!i)for(let a of c){let u=s.match(new RegExp(a.match.source,a.match.flags.replace("g","")));if(u){i={module:S(a.module,u),export:a.export?S(a.export,u):s};break}}return n.set(s,i),i},names:()=>[...t.keys()],conflicts:()=>r}}var b=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],M=["Suspense","SuspenseList","Await"],E=["Router","Outlet","Redirect","Link"],J=[...b,...M,...E],Q=new Set([...b,...M]);function I(e={}){let{controlFlowModule:t="@fluixi/dom",coreModule:r="@fluixi/core",routerModule:c="@fluixi/core/router"}=e,n={};for(let p of b)n[p]=t;for(let p of M)n[p]=r;for(let p of E)n[p]=c;return n}var f="@fluixi/reactive/signal",h={$signal:{export:"signal",module:f,returns:"signal-handle"},$memo:{export:"memo",module:f,returns:"memo-handle"},$effect:{export:"effect",module:f,returns:"effect"},$store:{export:"store",module:"@fluixi/reactive/store",returns:"store-handle"},$resource:{export:"resource",module:f,returns:"resource-handle"},$selector:{export:"createSelector",module:f,returns:"memo-accessor"},$deferred:{export:"createDeferred",module:f,returns:"memo-accessor"},$untrack:{export:"untrack",module:f,returns:"plain"},$untrackStore:{export:"untrackStore",module:"@fluixi/reactive/store",returns:"plain"}};var Y=new RegExp(`\\$(?:${Object.keys(h).map(e=>e.slice(1)).join("|")})\\s*\\(`);var F=new Set(["Text","Image","Option","Audio","Comment","Range","Selection","Notification","Event","Document","Element","Node","Screen","Window","Location","History","Storage","Response","Request","Headers"]);function U(e){if(e.startsWith(".")||e.startsWith("/")||/^[~@]\//.test(e))return;let t=e.split("/");return e.startsWith("@")?t.slice(0,2).join("/"):t[0]}function y(e){return`_${e.replace(/[^A-Za-z0-9]/g,"_")}`}function V(e,t={}){let{available:r,builtins:c=!0,intrinsics:n=!0,generator:p="@fluixi/compiler",specifier:s=o=>o}=t,i=[...e];c&&i.push({components:I()});let a=$(i),u=r?new Set(r):void 0,m=[],d=[],R=[],v=new Map;for(let o of[...a.names()].sort()){let l=a.resolve(o);if(!l)continue;let g=U(l.module);F.has(o)?d.push(o):u&&g&&!u.has(g)?R.push(o):(m.push(o),v.set(o,l))}let w=n?[...new Set(Object.values(h).map(o=>o.module))]:[],O=[...new Set([...m.map(o=>v.get(o).module),...w])].sort().map(o=>`import * as ${y(o)} from '${s(o)}';`),N=m.map(o=>{let l=v.get(o),g=y(l.module);return l.export==="default"?`  const ${o}: typeof ${g}.default;`:`  export import ${o} = ${g}.${l.export};`}),T=d.length>0?`//
+"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/component-globals.ts
+var component_globals_exports = {};
+__export(component_globals_exports, {
+  componentGlobals: () => componentGlobals
+});
+module.exports = __toCommonJS(component_globals_exports);
+
+// 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
+  };
+}
+
+// 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/analyze/intrinsics.ts
+var REACTIVE_MODULE = "@fluixi/reactive/signal";
+var INTRINSICS = {
+  $signal: { export: "signal", module: REACTIVE_MODULE, returns: "signal-handle" },
+  $memo: { export: "memo", module: REACTIVE_MODULE, returns: "memo-handle" },
+  $effect: { export: "effect", module: REACTIVE_MODULE, returns: "effect" },
+  $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
+  // 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" },
+  // Not value constructors, but the compiler has to know them: they change what a read
+  // does. `untrack` suppresses dependency collection, which is exactly the kind of thing
+  // dependency analysis must not guess at.
+  $untrack: { export: "untrack", module: REACTIVE_MODULE, returns: "plain" },
+  $untrackStore: { export: "untrackStore", module: "@fluixi/reactive/store", returns: "plain" }
+};
+var INTRINSIC_CALL = new RegExp(`\\$(?:${Object.keys(INTRINSICS).map((n) => n.slice(1)).join("|")})\\s*\\(`);
+
+// src/resolve/component-globals.ts
+var DOM_GLOBALS = /* @__PURE__ */ new Set([
+  "Text",
+  "Image",
+  "Option",
+  "Audio",
+  "Comment",
+  "Range",
+  "Selection",
+  "Notification",
+  "Event",
+  "Document",
+  "Element",
+  "Node",
+  "Screen",
+  "Window",
+  "Location",
+  "History",
+  "Storage",
+  "Response",
+  "Request",
+  "Headers"
+]);
+function packageOf(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/")) return void 0;
+  if (/^[~@]\//.test(specifier)) return void 0;
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function namespaceAlias(module2) {
+  return `_${module2.replace(/[^A-Za-z0-9]/g, "_")}`;
+}
+function componentGlobals(rules, options = {}) {
+  const {
+    available: availableList,
+    builtins = true,
+    intrinsics = true,
+    generator = "@fluixi/compiler",
+    specifier = (module2) => module2
+  } = options;
+  const all = [...rules];
+  if (builtins) {
+    all.push({ components: builtinComponentMap() });
+  }
+  const resolver = createComponentResolver(all);
+  const available = availableList ? new Set(availableList) : void 0;
+  const declared = [];
+  const shadowedByDom = [];
+  const unavailable = [];
+  const resolved = /* @__PURE__ */ new Map();
+  for (const name of [...resolver.names()].sort()) {
+    const target = resolver.resolve(name);
+    if (!target) continue;
+    const pkg = packageOf(target.module);
+    if (DOM_GLOBALS.has(name)) shadowedByDom.push(name);
+    else if (available && pkg && !available.has(pkg)) unavailable.push(name);
+    else {
+      declared.push(name);
+      resolved.set(name, target);
+    }
+  }
+  const intrinsicModules = intrinsics ? [...new Set(Object.values(INTRINSICS).map((i) => i.module))] : [];
+  const modules = [
+    .../* @__PURE__ */ new Set([...declared.map((name) => resolved.get(name).module), ...intrinsicModules])
+  ].sort();
+  const imports = modules.map(
+    (m) => `import * as ${namespaceAlias(m)} from '${specifier(m)}';`
+  );
+  const lines = declared.map((name) => {
+    const target = resolved.get(name);
+    const ns = namespaceAlias(target.module);
+    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
 // declaration cannot win:
-`+d.map(o=>{let l=a.resolve(o)?.module;return`//   import { ${o} } from '${l?s(l):""}';
-`}).join(""):"",L=n?Object.entries(h).map(([o,l])=>`  const ${o}: typeof ${y(l.module)}.${l.export};`):[],x=e.filter(o=>"match"in o).length,j=x>0?`//
-// ${x} pattern rule${x===1?"":"s"} cannot be declared:
+` + shadowedByDom.map((n) => {
+    const module2 = resolver.resolve(n)?.module;
+    return `//   import { ${n} } from '${module2 ? specifier(module2) : ""}';
+`;
+  }).join("") : "";
+  const intrinsicLines = intrinsics ? Object.entries(INTRINSICS).map(
+    ([name, intrinsic]) => `  const ${name}: typeof ${namespaceAlias(intrinsic.module)}.${intrinsic.export};`
+  ) : [];
+  const patternRules = rules.filter((rule) => "match" in rule).length;
+  const patternNote = patternRules > 0 ? `//
+// ${patternRules} pattern rule${patternRules === 1 ? "" : "s"} cannot be declared:
 // 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.
-`:"";return{source:`// GENERATED by ${p} — 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.
-`+T+j+(O.length>0?`
-${O.join(`
-`)}
-`:`
-`)+`
+` + note + patternNote + (imports.length > 0 ? `
+${imports.join("\n")}
+` : "\n") + `
 declare global {
-${[...N,...L].join(`
-`)}
+${[...lines, ...intrinsicLines].join("\n")}
+}
+`;
+  return { source, declared, shadowedByDom, unavailable, patternRules };
 }
-`,declared:m,shadowedByDom:d,unavailable:R,patternRules:x}}

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

@@ -0,0 +1,80 @@
+/**
+ * Ambient declarations for the components `resolve` supplies without an import.
+ *
+ * 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.
+ *
+ * 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
+ * that predates it does not.
+ *
+ * Pure, like the resolver: rules in, source out, no filesystem. Writing the file is the
+ * caller's job (the Vite plugin does it on config resolve; a CLI can do it in CI).
+ */
+import { type ComponentResolverRule } from './component-resolver.cjs';
+export interface ComponentGlobalsOptions {
+    /**
+     * 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
+     * silent: the component degrades to `any` and every prop typo type-checks, which is
+     * 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.
+     */
+    available?: Iterable<string>;
+    /**
+     * Declare the framework builtins (`Show`, `For`, `Portal`, `Router`, …) too.
+     *
+     * On by default because the compiler resolves them whether or not a rule mentions
+     * them, so declaring them is what matches reality. A real import shadows the ambient
+     * declaration, so this stays safe for code that imports them explicitly.
+     */
+    builtins?: boolean;
+    /**
+     * Declare the `$` reactive intrinsics (`$signal`, `$memo`, …).
+     *
+     * On by default, matching the compiler: it rewrites those calls whether or not
+     * anything declares them, and without the declaration the editor reports
+     * "Cannot find name '$signal'" for code that builds correctly.
+     */
+    intrinsics?: boolean;
+    /** Attribution written into the header. */
+    generator?: string;
+    /**
+     * Rewrite a module specifier for the file being generated.
+     *
+     * A bundler and TypeScript do not agree on every specifier: Vite resolves a
+     * root-absolute `/src/x.tsx` that TypeScript cannot see at all. The caller knows where
+     * the file will land and so is the only one able to fix that up; the generator stays
+     * pure and just asks.
+     */
+    specifier?: (module: string) => string;
+}
+export interface ComponentGlobalsResult {
+    /** The `.d.ts` source to write. */
+    source: string;
+    /** Components declared. */
+    declared: string[];
+    /** Left out because `lib.dom` already claims the name. */
+    shadowedByDom: string[];
+    /** Left out because the project does not depend on their package. */
+    unavailable: string[];
+    /**
+     * Pattern rules, which have no finite name list and so cannot be declared.
+     *
+     * `Icon(.+) -> @/icons/$1` matches unboundedly many names; the resolver answers them on
+     * demand but cannot enumerate them. Those tags stay manual, and the caller is told how
+     * many rules are in that position rather than left to wonder why nothing appeared.
+     */
+    patternRules: number;
+}
+/** Build the ambient `.d.ts` for the components a project's `resolve` config supplies. */
+export declare function componentGlobals(rules: readonly ComponentResolverRule[], options?: ComponentGlobalsOptions): ComponentGlobalsResult;