@fluixi/compiler 1.0.0-alpha.100

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

@@ -0,0 +1,31 @@
+/**
+ * Strategy collapsing: demote a deferred reference whose module is already present.
+ *
+ * This is not a nice-to-have. Without it the naive feature is a regression: if a module
+ * is referenced eagerly anywhere in the compilation unit, it is in the parent chunk
+ * already, so a `load:visible` boundary elsewhere adds a wrapper, a promise and a
+ * re-render in order to fetch nothing. The bytes are paid twice, once in the chunk,
+ * once in the deferral machinery: and the component renders later than it needs to.
+ *
+ * Collapsing runs per module, not per component name, because a chunk is a module:
+ * `<Button>` eager and `<ButtonGroup load:visible>` from the same package means the
+ * package is already loaded, so deferring the second buys nothing.
+ *
+ * `never` is not collapsed. It means "no client code at all", which is a statement about
+ * what should exist rather than about when to fetch it; an eager sibling does not make a
+ * server-only component suddenly belong in the client bundle. That combination is
+ * contradictory and reported instead.
+ */
+import type { IRNode } from '../ir/nodes.js';
+export interface CollapseReport {
+    /** Modules demoted to eager, with the reference count that was demoted. */
+    collapsed: Map<string, number>;
+    /**
+     * Modules referenced both as `load:never` and in a way that needs client code.
+     * Contradictory rather than optimisable, so it is reported and left alone.
+     */
+    conflicted: string[];
+}
+/** Demote deferred references to modules that are already in the chunk. */
+export declare function collapseStrategies(root: IRNode | IRNode[]): CollapseReport;
+//# sourceMappingURL=collapse-strategies.d.ts.map

package/dist/optimize/collapse-strategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collapse-strategies.d.ts","sourceRoot":"","sources":["../../src/optimize/collapse-strategies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,gBAAgB,CAAC;AAI1D,MAAM,WAAW,cAAc;IAC7B,2EAA2E;IAC3E,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B;;;OAGG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,cAAc,CA2B1E"}

package/dist/optimize/collapse-strategies.js

@@ -0,0 +1,33 @@
+import { isDeferred } from '../resolve/load-directive.js';
+import { walk } from '../resolve/resolve-ir.js';
+/** Demote deferred references to modules that are already in the chunk. */
+export function collapseStrategies(root) {
+    const components = [];
+    walk(root, (node) => {
+        if (node.kind === 'component' && node.source)
+            components.push(node);
+    });
+    const eager = new Set();
+    const never = new Set();
+    for (const node of components) {
+        const { module, loading } = node.source;
+        if (loading.kind === 'eager')
+            eager.add(module);
+        if (loading.kind === 'never')
+            never.add(module);
+    }
+    const collapsed = new Map();
+    for (const node of components) {
+        const source = node.source;
+        if (!isDeferred(source.loading))
+            continue;
+        if (!eager.has(source.module))
+            continue;
+        source.loading = { kind: 'eager' };
+        collapsed.set(source.module, (collapsed.get(source.module) ?? 0) + 1);
+    }
+    return {
+        collapsed,
+        conflicted: [...never].filter((m) => eager.has(m)),
+    };
+}

package/dist/optimize/collapse-strategies.mjs

@@ -0,0 +1,67 @@
+// src/resolve/load-directive.ts
+function isDeferred(strategy) {
+  return strategy.kind !== "eager" && strategy.kind !== "never";
+}
+
+// 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
+]);
+
+// src/resolve/resolve-ir.ts
+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);
+  }
+}
+
+// src/optimize/collapse-strategies.ts
+function collapseStrategies(root) {
+  const components = [];
+  walk(root, (node) => {
+    if (node.kind === "component" && node.source) components.push(node);
+  });
+  const eager = /* @__PURE__ */ new Set();
+  const never = /* @__PURE__ */ new Set();
+  for (const node of components) {
+    const { module, loading } = node.source;
+    if (loading.kind === "eager") eager.add(module);
+    if (loading.kind === "never") never.add(module);
+  }
+  const collapsed = /* @__PURE__ */ new Map();
+  for (const node of components) {
+    const source = node.source;
+    if (!isDeferred(source.loading)) continue;
+    if (!eager.has(source.module)) continue;
+    source.loading = { kind: "eager" };
+    collapsed.set(source.module, (collapsed.get(source.module) ?? 0) + 1);
+  }
+  return {
+    collapsed,
+    conflicted: [...never].filter((m) => eager.has(m))
+  };
+}
+export {
+  collapseStrategies
+};

package/dist/options.cjs

@@ -0,0 +1,33 @@
+"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/options.ts
+var options_exports = {};
+__export(options_exports, {
+  defaultOptions: () => defaultOptions
+});
+module.exports = __toCommonJS(options_exports);
+var defaultOptions = {
+  backend: "imperative",
+  moduleName: "@fluixi/dom",
+  delegateEvents: true,
+  hydratable: false,
+  sourceMaps: true,
+  dev: false
+};

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

@@ -0,0 +1,40 @@
+import type { ComponentResolverRule } from './resolve/component-resolver.js';
+/**
+ * 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;
+//# sourceMappingURL=options.d.ts.map

package/dist/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAE7E;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,mCAAmC;IACnC,OAAO,CAAC,EAAE,YAAY,GAAG,gBAAgB,CAAC;IAC1C,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd;;;OAGG;IACH,OAAO,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC5C;AAED,eAAO,MAAM,cAAc,EAAE,eAO5B,CAAC"}

package/dist/options.js

@@ -0,0 +1,8 @@
+export const defaultOptions = {
+    backend: 'imperative',
+    moduleName: '@fluixi/dom',
+    delegateEvents: true,
+    hydratable: false,
+    sourceMaps: true,
+    dev: false,
+};

package/dist/options.mjs

@@ -0,0 +1,12 @@
+// 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

@@ -0,0 +1,73 @@
+/*! @fluixi/compiler v1.0.0-alpha.100 | (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

@@ -0,0 +1,69 @@
+/**
+ * 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.js';
+/** 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;
+//# sourceMappingURL=builtins.d.ts.map

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

@@ -0,0 +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,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

@@ -0,0 +1,64 @@
+/** Control flow lowered against the DOM runtime. */
+export const DOM_CONTROL_FLOW = [
+    'Show',
+    'For',
+    'Index',
+    'Switch',
+    'Match',
+    'Portal',
+    'Dynamic',
+    'ErrorBoundary',
+];
+/** Control flow that only `@fluixi/core` exports, importing it from dom resolves to nothing. */
+export const CORE_CONTROL_FLOW = ['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 const ROUTER_COMPONENTS = ['Router', 'Outlet', 'Redirect', 'Link'];
+/** Every name the compiler supplies without an import. */
+export const BUILTIN_COMPONENTS = [
+    ...DOM_CONTROL_FLOW,
+    ...CORE_CONTROL_FLOW,
+    ...ROUTER_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
+ * 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 const RESERVED_COMPONENTS = new Set([
+    ...DOM_CONTROL_FLOW,
+    ...CORE_CONTROL_FLOW,
+]);
+/** Name → module for every built-in, honouring host module overrides. */
+export 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;
+}
+/**
+ * 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 function builtinComponents(modules = {}) {
+    return { components: builtinComponentMap(modules) };
+}
+/** 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

@@ -0,0 +1,53 @@
+/*! @fluixi/compiler v1.0.0-alpha.100 | (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
+};