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

package/dist/options.d.cts

@@ -0,0 +1,39 @@
+import type { ComponentResolverRule } from './resolve/component-resolver.cjs';
+/**
+ * Public compiler options. This schema is the stable public API, it stays put
+ * as backends change. Switching DOM strategy is `backend`, not a rewrite.
+ */
+export interface CompilerOptions {
+    /**
+     * Clone static subtrees from a `<template>` instead of building them element by
+     * element. Roughly 2x faster to instantiate, but **client-only**: `createTemplate`
+     * produces real DOM nodes, which the SSR renderer's ServerElement tree rejects, and a
+     * clone creates a fresh node where hydration must adopt the existing one. Opt in for
+     * a client-rendered app; leave off wherever SSR or hydration is involved.
+     */
+    templateClone?: boolean;
+    /**
+     * Also clone subtrees whose *structure* is static but which contain dynamic holes ,
+     * the common shape. Roughly halves the emitted code for such a subtree and replaces
+     * per-element construction with one clone.
+     *
+     * Works under SSR and hydration: each hole is bracketed by `<!--fx-->` markers, so its
+     * content is exactly the nodes between them and the server's markup has the same shape
+     * as the client's template. Hydration adopts those nodes rather than rebuilding them.
+     */
+    partialTemplates?: boolean;
+    /** which codegen backend to use */
+    backend?: 'imperative' | 'template-clone';
+    /** runtime module emitted symbols are imported from */
+    moduleName?: string;
+    delegateEvents?: boolean;
+    hydratable?: boolean;
+    sourceMaps?: boolean;
+    dev?: boolean;
+    /**
+     * Rules that resolve an unbound capitalised tag to a module, so a component can be
+     * used in a template without an import. See `createComponentResolver`.
+     */
+    resolve?: readonly ComponentResolverRule[];
+}
+export declare const defaultOptions: CompilerOptions;

package/dist/options.d.ts

@@ -1,6 +1,6 @@
 import type { ComponentResolverRule } from './resolve/component-resolver.js';
 /**
- * Public compiler options. This schema is the stable public API — it stays put
+ * Public compiler options. This schema is the stable public API, it stays put
  * as backends change. Switching DOM strategy is `backend`, not a rewrite.
  */
 export interface CompilerOptions {
@@ -13,7 +13,7 @@ export interface CompilerOptions {
      */
     templateClone?: boolean;
     /**
-     * Also clone subtrees whose *structure* is static but which contain dynamic holes —
+     * Also clone subtrees whose *structure* is static but which contain dynamic holes ,
      * the common shape. Roughly halves the emitted code for such a subtree and replaces
      * per-element construction with one clone.
      *

package/dist/options.mjs

@@ -1 +1,12 @@
-var e={backend:"imperative",moduleName:"@fluixi/dom",delegateEvents:!0,hydratable:!1,sourceMaps:!0,dev:!1};export{e as defaultOptions};
+// src/options.ts
+var defaultOptions = {
+  backend: "imperative",
+  moduleName: "@fluixi/dom",
+  delegateEvents: true,
+  hydratable: false,
+  sourceMaps: true,
+  dev: false
+};
+export {
+  defaultOptions
+};

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.85 | (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.d.ts

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

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

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

package/dist/resolve/builtins.js

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

package/dist/resolve/builtins.mjs

@@ -1 +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.85 | (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?`//
-// Import these explicitly — lib.dom already declares the name, so an ambient
+"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}}