@fluixi/compiler 1.0.0-alpha.100

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ibrahima Touré
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,131 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/fluixi/assets/main/logos/128x128.png" alt="Fluixi" width="120" height="120" />
+</p>
+
+# @fluixi/compiler
+
+**The Fluixi compiler — parses, lowers and emits. Not a Babel plugin.**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-22c55e.svg)](./LICENSE)
+![TypeScript](https://img.shields.io/badge/TypeScript-strict-3178c6?logo=typescript&logoColor=white)
+[![npm](https://img.shields.io/npm/v/@fluixi/compiler?logo=npm)](https://www.npmjs.com/package/@fluixi/compiler)
+
+---
+
+## ✨ Overview
+
+`@fluixi/compiler` turns Fluixi source into fine-grained reactive output. Both authoring
+syntaxes — JSX and `` html`...` `` templates — lower to the **same host-agnostic IR**, and
+the **imperative backend** compiles that straight into [`@fluixi/dom`](../dom) runtime
+calls (`createNativeElement`/`spread`/`insert`/`createComponent`/…). No VDOM, and no
+`jsx()` dispatch at runtime.
+
+It owns the transform rather than running inside someone else's: parse once, splice the
+emitted code over the spans it replaces. Nothing is reprinted, so a hole keeps the text the
+author wrote and every edit carries a source map; types are left in place for the bundler
+to strip.
+
+`@babel/parser` is the only package it takes from that namespace, used as a parser — the
+same position Vue's compiler is in. `@babel/core` and the plugin machinery are optional
+peers, needed only by `babel: true`.
+
+The `@fluixi/jsx` automatic runtime is still what esbuild and TypeScript's
+`jsxImportSource` point at; this compiler simply never emits a call into it.
+
+It also provides the **`"use server"`** transform (server functions): the client build
+gets an RPC stub, the server build keeps and registers the body.
+
+Most apps don't use this package directly — [`@fluixi/vite-plugin`](../vite-plugin) (and
+[`@fluixi/start`](../start)) wrap it.
+
+## What it does to your code
+
+Beyond turning markup into DOM calls:
+
+**Props you destructured stay reactive.** `function Card({ title })` compiles to
+`props.title` at each use, so the binding keeps updating, and `...rest` becomes the
+`splitProps` call you would have written. Anything it can't prove safe — a reassigned
+binding, a computed key, a default it would have to re-run per read — is left exactly as
+written and reported. On by default; set `propsDestructure: false` for a package that ships
+its **source** for consumers to compile, since the rewrite belongs to whoever compiles.
+
+**`$` intrinsics resolve without an import.** `$signal`, `$memo`, `$effect`, `$store`,
+`$resource`, `$selector`, `$deferred`, `$untrack`, `$untrackStore` compile to the runtime
+calls they stand for, and the import is added for what a module actually used. A primitive
+is recognised by the binding it came from, never by name: `import { signal as state }` is
+recognised, a local `function signal()` is not. A module that binds a `$` name keeps its
+own meaning and gets a diagnostic.
+
+**Unimported tags resolve through rules.** `resolve` says where a capitalised tag comes
+from — an entry per component, or one pattern for a family:
+
+```ts
+createVitePlugin({ resolve: [{ match: /^([A-Z]\w+)$/, module: '/src/components/$1.tsx' }] })
+```
+
+**`load:` splits a component into its own chunk.** `load:visible`, `load:idle`,
+`load:interaction`, `load:media` decide when its module is fetched. It works on a component
+a rule supplies and on one you imported yourself — in the second case the static import is
+removed, which only happens when the name is used nowhere but as a tag.
+
+**It says when it couldn't do these things.** A tag nothing supplies and a `load:` that
+can't apply both build cleanly and fail at runtime, so they're reported at build time with
+the reason. The bundler adapters print them; `TransformResult` carries them as
+`propsDiagnostics`, `intrinsicDiagnostics`, `loadDiagnostics` and `unresolvedDiagnostics`
+if you're driving the transform yourself.
+
+## 📦 Installation
+
+```sh
+pnpm add -D @fluixi/compiler
+```
+
+## 🚀 Usage
+
+Via the Vite integration (the common path):
+
+```ts
+import { defineConfig } from 'vite';
+import { createVitePlugin, serverFunctionsVitePlugin } from '@fluixi/compiler/integrations';
+
+export default defineConfig({
+  plugins: [
+    serverFunctionsVitePlugin(),          // "use server" transform
+    createVitePlugin(),
+  ],
+});
+```
+
+Or compile a module directly:
+
+```ts
+import { transformTemplates } from '@fluixi/compiler/transform';
+
+const { code, map } = transformTemplates(source, 'App.tsx', {})!;
+```
+
+`transformTemplates` returns `null` when there is nothing to do — no JSX, no templates, no
+`$` intrinsics and nothing to report — so a bundler can leave the file untouched.
+
+### Compiling through Babel
+
+`fluixi({ babel: true })` routes through the Babel front-end instead. It exists for a
+project whose own Babel plugins have to see the compiled output; it needs `@babel/core`
+and friends installed, and says so rather than degrading. Everything else — the IR, the
+passes, the backend — is the same code either way.
+
+## 🔌 Subpaths
+
+| Import | What | Babel |
+| --- | --- | --- |
+| `@fluixi/compiler` | IR, codegen backends, resolve/optimize passes, options | none |
+| `@fluixi/compiler/builtins` | the control-flow / router component names | none |
+| `@fluixi/compiler/transform` | `transformTemplates`, `transformServerFns` | parser only |
+| `@fluixi/compiler/integrations` | vite, webpack, rollup and esbuild adapters | parser only |
+| `@fluixi/compiler/babel` | the Babel plugin front-end | `@babel/core` |
+
+`no-babel-in-core.spec.ts` fails the build if that column stops being true.
+
+## 📄 License
+
+[MIT](./LICENSE) © [Fluixi](https://fluixi.dev)

package/dist/analyze/expr-shape.cjs

@@ -0,0 +1,62 @@
+"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/analyze/expr-shape.ts
+var expr_shape_exports = {};
+__export(expr_shape_exports, {
+  shapeOf: () => shapeOf
+});
+module.exports = __toCommonJS(expr_shape_exports);
+var CALL = /* @__PURE__ */ new Set(["CallExpression", "OptionalCallExpression"]);
+var MEMBER = /* @__PURE__ */ new Set(["MemberExpression", "OptionalMemberExpression"]);
+function shapeOf(node) {
+  if (!node) return { kind: "opaque" };
+  if (CALL.has(node.type)) return { kind: "call" };
+  if (MEMBER.has(node.type)) {
+    const property = node.property;
+    const computed = node.computed === true;
+    return {
+      kind: "member",
+      property: !computed && property?.type === "Identifier" ? property.name : null
+    };
+  }
+  if (node.type === "ConditionalExpression") {
+    return { kind: "compound", parts: [node.test, node.consequent, node.alternate].map(part) };
+  }
+  if (node.type === "LogicalExpression" || node.type === "BinaryExpression") {
+    return { kind: "compound", parts: [node.left, node.right].map(part) };
+  }
+  if (node.type === "TemplateLiteral") {
+    return { kind: "compound", parts: node.expressions.map(part) };
+  }
+  if (node.type === "ObjectExpression") {
+    const props = node.properties.filter(
+      (p) => (p.type === "ObjectProperty" || p.type === "Property") && p.computed !== true
+    );
+    return { kind: "compound", parts: props.map((p) => part(p.value)) };
+  }
+  if (node.type === "ArrayExpression") {
+    const items = node.elements.filter(
+      (e) => e != null && e.type !== "SpreadElement"
+    );
+    return { kind: "compound", parts: items.map(part) };
+  }
+  return { kind: "opaque" };
+}
+var part = (n) => shapeOf(n);

package/dist/analyze/expr-shape.d.cts

@@ -0,0 +1,14 @@
+/**
+ * Map a parsed expression node to an `ExprShape`.
+ *
+ * Works off `node.type` strings, so it takes any ESTree-shaped AST, @babel/parser,
+ * acorn, or whatever replaces them: and accepts the few names Babel spells
+ * differently (`ObjectProperty`, `Optional*Expression`).
+ */
+import type { ExprShape } from './reactive-expr.cjs';
+interface Node {
+    type: string;
+    [key: string]: unknown;
+}
+export declare function shapeOf(node: Node | null | undefined): ExprShape;
+export {};

package/dist/analyze/expr-shape.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Map a parsed expression node to an `ExprShape`.
+ *
+ * Works off `node.type` strings, so it takes any ESTree-shaped AST, @babel/parser,
+ * acorn, or whatever replaces them: and accepts the few names Babel spells
+ * differently (`ObjectProperty`, `Optional*Expression`).
+ */
+import type { ExprShape } from './reactive-expr.js';
+interface Node {
+    type: string;
+    [key: string]: unknown;
+}
+export declare function shapeOf(node: Node | null | undefined): ExprShape;
+export {};
+//# sourceMappingURL=expr-shape.d.ts.map

package/dist/analyze/expr-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expr-shape.d.ts","sourceRoot":"","sources":["../../src/analyze/expr-shape.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,UAAU,IAAI;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAKD,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,SAAS,CAuChE"}

package/dist/analyze/expr-shape.js

@@ -0,0 +1,37 @@
+const CALL = new Set(['CallExpression', 'OptionalCallExpression']);
+const MEMBER = new Set(['MemberExpression', 'OptionalMemberExpression']);
+export function shapeOf(node) {
+    if (!node)
+        return { kind: 'opaque' };
+    if (CALL.has(node.type))
+        return { kind: 'call' };
+    if (MEMBER.has(node.type)) {
+        const property = node.property;
+        const computed = node.computed === true;
+        return {
+            kind: 'member',
+            property: !computed && property?.type === 'Identifier' ? property.name : null,
+        };
+    }
+    if (node.type === 'ConditionalExpression') {
+        return { kind: 'compound', parts: [node.test, node.consequent, node.alternate].map(part) };
+    }
+    if (node.type === 'LogicalExpression' || node.type === 'BinaryExpression') {
+        return { kind: 'compound', parts: [node.left, node.right].map(part) };
+    }
+    if (node.type === 'TemplateLiteral') {
+        return { kind: 'compound', parts: node.expressions.map(part) };
+    }
+    // A computed key or a spread contributes nothing, we cannot see what it
+    // introduces, so we must not claim it is inert.
+    if (node.type === 'ObjectExpression') {
+        const props = node.properties.filter((p) => (p.type === 'ObjectProperty' || p.type === 'Property') && p.computed !== true);
+        return { kind: 'compound', parts: props.map((p) => part(p.value)) };
+    }
+    if (node.type === 'ArrayExpression') {
+        const items = node.elements.filter((e) => e != null && e.type !== 'SpreadElement');
+        return { kind: 'compound', parts: items.map(part) };
+    }
+    return { kind: 'opaque' };
+}
+const part = (n) => shapeOf(n);

package/dist/analyze/expr-shape.mjs

@@ -0,0 +1,41 @@
+// src/analyze/expr-shape.ts
+var CALL = /* @__PURE__ */ new Set(["CallExpression", "OptionalCallExpression"]);
+var MEMBER = /* @__PURE__ */ new Set(["MemberExpression", "OptionalMemberExpression"]);
+function shapeOf(node) {
+  if (!node) return { kind: "opaque" };
+  if (CALL.has(node.type)) return { kind: "call" };
+  if (MEMBER.has(node.type)) {
+    const property = node.property;
+    const computed = node.computed === true;
+    return {
+      kind: "member",
+      property: !computed && property?.type === "Identifier" ? property.name : null
+    };
+  }
+  if (node.type === "ConditionalExpression") {
+    return { kind: "compound", parts: [node.test, node.consequent, node.alternate].map(part) };
+  }
+  if (node.type === "LogicalExpression" || node.type === "BinaryExpression") {
+    return { kind: "compound", parts: [node.left, node.right].map(part) };
+  }
+  if (node.type === "TemplateLiteral") {
+    return { kind: "compound", parts: node.expressions.map(part) };
+  }
+  if (node.type === "ObjectExpression") {
+    const props = node.properties.filter(
+      (p) => (p.type === "ObjectProperty" || p.type === "Property") && p.computed !== true
+    );
+    return { kind: "compound", parts: props.map((p) => part(p.value)) };
+  }
+  if (node.type === "ArrayExpression") {
+    const items = node.elements.filter(
+      (e) => e != null && e.type !== "SpreadElement"
+    );
+    return { kind: "compound", parts: items.map(part) };
+  }
+  return { kind: "opaque" };
+}
+var part = (n) => shapeOf(n);
+export {
+  shapeOf
+};

package/dist/analyze/intrinsics.cjs

@@ -0,0 +1,112 @@
+"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/analyze/intrinsics.ts
+var intrinsics_exports = {};
+__export(intrinsics_exports, {
+  INTRINSICS: () => INTRINSICS,
+  PRIMITIVE_MODULES: () => PRIMITIVE_MODULES,
+  REACTIVE_MODULE: () => REACTIVE_MODULE,
+  RUNTIME_PRIMITIVES: () => RUNTIME_PRIMITIVES,
+  TAG_INTRINSICS: () => TAG_INTRINSICS,
+  isIntrinsicName: () => isIntrinsicName,
+  isPrimitiveModule: () => isPrimitiveModule,
+  mayHaveIntrinsic: () => mayHaveIntrinsic,
+  tagIntrinsics: () => tagIntrinsics
+});
+module.exports = __toCommonJS(intrinsics_exports);
+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" },
+  $cachedResource: { export: "cachedResource", module: "@fluixi/reactive/cached-resource", 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" },
+  // Scopes, scheduling and lifecycle: no value to classify, but the same authoring promise,
+  // no import to write. `$cleanup` registers a callback on the current owner (`onCleanup`).
+  $batch: { export: "batch", module: REACTIVE_MODULE, returns: "plain" },
+  $cleanup: { export: "onCleanup", module: REACTIVE_MODULE, returns: "plain" },
+  $root: { export: "root", module: REACTIVE_MODULE, returns: "plain" },
+  $context: { export: "context", module: REACTIVE_MODULE, returns: "plain" },
+  $renderEffect: { export: "renderEffect", module: REACTIVE_MODULE, returns: "effect" },
+  $computed: { export: "computed", module: REACTIVE_MODULE, returns: "effect" },
+  // Storage for where the code runs, and a signal kept in it. `$persisted` is a signal
+  // handle as far as reads go: the same accessor with `set` on it.
+  $storage: { export: "useStorage", module: "@fluixi/core/storage", returns: "plain" },
+  $asyncStorage: { export: "useAsyncStorage", module: "@fluixi/core/storage", returns: "plain" },
+  $persisted: { export: "persisted", module: "@fluixi/core/storage", returns: "signal-handle" },
+  // An environment variable, public or server-only; the browser build refuses a secret.
+  $env: { export: "env", module: "@fluixi/start/env", returns: "plain" }
+};
+var RUNTIME_PRIMITIVES = {
+  signal: "signal-handle",
+  memo: "memo-handle",
+  effect: "effect",
+  store: "store-handle",
+  createSignal: ["signal-accessor", "signal-setter"],
+  createMemo: "memo-accessor",
+  createEffect: "effect",
+  createRenderEffect: "effect",
+  renderEffect: "effect",
+  computed: "effect",
+  createStore: "reactive-object",
+  resource: "resource-handle",
+  cachedResource: "resource-handle",
+  createResource: "reactive-object",
+  createSelector: "memo-accessor",
+  createDeferred: "memo-accessor"
+};
+var PRIMITIVE_MODULES = [
+  "@fluixi/reactive",
+  "@fluixi/reactive/signal",
+  "@fluixi/reactive/store",
+  "@fluixi/reactive/cached-resource",
+  "@fluixi/core"
+];
+var TAG_INTRINSICS = {
+  $html: { export: "html", module: "@fluixi/core" },
+  $svg: { export: "svg", module: "@fluixi/core" },
+  $css: { export: "css", module: "@fluixi/core" }
+};
+function tagIntrinsics(bound) {
+  const tags = /* @__PURE__ */ new Map();
+  for (const [name, tag] of Object.entries(TAG_INTRINSICS)) if (!bound.has(name)) tags.set(name, tag.export);
+  return tags;
+}
+var INTRINSIC_CALL = new RegExp(`\\$(?:${Object.keys(INTRINSICS).map((n) => n.slice(1)).join("|")})\\s*\\(`);
+function mayHaveIntrinsic(code) {
+  return INTRINSIC_CALL.test(code);
+}
+function isIntrinsicName(name) {
+  return Object.prototype.hasOwnProperty.call(INTRINSICS, name);
+}
+function isPrimitiveModule(source) {
+  return PRIMITIVE_MODULES.includes(source);
+}

package/dist/analyze/intrinsics.d.cts

@@ -0,0 +1,80 @@
+/**
+ * The reactive primitives the compiler knows by name, in one place.
+ *
+ * Two ways to write the same thing. The runtime call, which needs an import and works
+ * without us:
+ *
+ *   import { createSignal } from '@fluixi/reactive/signal';
+ *   const count = createSignal(0);
+ *
+ * And the intrinsic, which the compiler resolves and imports for you:
+ *
+ *   const count = $signal(0);
+ *
+ * They are not two reactive systems. `$signal` compiles to the same `createSignal` call,
+ * so there's one graph, one lifecycle, one SSR story. The `$` form is authoring sugar
+ * the compiler understands; the runtime form stays public, because a library that never
+ * runs this compiler still has to be able to write reactive code.
+ *
+ * Everything the compiler needs to know about a primitive lives in this table rather
+ * than spread across passes, so adding one is an entry, not a new code path.
+ */
+/** What a binding holds, once we know where it came from. */
+export type ReactiveKind = 'plain'
+/** `signal(0)`: one object, read with `.get()` and written with `.set()`. */
+ | 'signal-handle'
+/** `memo(fn)`: read-only, so `.get()` only. */
+ | 'memo-handle'
+/** `store(obj)`: read properties directly, `.set()` writes. */
+ | 'store-handle'
+/** `resource(fn)`: `.get()` reads, with `.loading`/`.latest`/`.refetch()` on it. */
+ | 'resource-handle'
+/** The accessor half of the tuple form, `const [count] = createSignal(0)`. */
+ | 'signal-accessor' | 'signal-setter' | 'memo-accessor' | 'effect' | 'reactive-object';
+export interface Intrinsic {
+    /** Runtime export this compiles to. */
+    export: string;
+    /** Module it comes from. */
+    module: string;
+    /**
+     * What the call yields. A tuple means the call is destructured into that many
+     * bindings: `createSignal` gives an accessor and a setter, in that order.
+     */
+    returns: ReactiveKind | readonly ReactiveKind[];
+}
+/** Module the reactive primitives are imported from when the compiler adds the import. */
+export declare const REACTIVE_MODULE = "@fluixi/reactive/signal";
+/**
+ * `$name` → the runtime it stands for.
+ *
+ * The `$` prefix is reserved. A local binding of the same name wins, it has to, or the
+ * compiler would rewrite code that means something else, and that's reported rather
+ * than done quietly.
+ */
+export declare const INTRINSICS: Readonly<Record<string, Intrinsic>>;
+/**
+ * The runtime names, for the other direction: source that imports `createSignal` gets
+ * classified the same way as source that writes `$signal`, so later passes see one
+ * vocabulary whichever form the author used.
+ */
+export declare const RUNTIME_PRIMITIVES: Readonly<Record<string, Intrinsic['returns']>>;
+/** Modules whose exports count as reactive primitives. */
+export declare const PRIMITIVE_MODULES: readonly string[];
+/**
+ * Cheap text check for the file-skipping fast path: a module with no `$` call never
+ * needs parsing. Non-global, so it has no lastIndex to carry between calls.
+ */
+/**
+ * Template tags an app writes without importing them. Each compiles exactly like the marker
+ * it names; a module that binds the name itself keeps its own meaning.
+ */
+export declare const TAG_INTRINSICS: Readonly<Record<string, {
+    export: 'html' | 'svg' | 'css';
+    module: string;
+}>>;
+/** The `$` tags this module can use: all of them, less the ones it binds. */
+export declare function tagIntrinsics(bound: Set<string>): Map<string, 'html' | 'svg' | 'css'>;
+export declare function mayHaveIntrinsic(code: string): boolean;
+export declare function isIntrinsicName(name: string): boolean;
+/** Whether a module path exports the reactive primitives. */
+export declare function isPrimitiveModule(source: string): boolean;

package/dist/analyze/intrinsics.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The reactive primitives the compiler knows by name, in one place.
+ *
+ * Two ways to write the same thing. The runtime call, which needs an import and works
+ * without us:
+ *
+ *   import { createSignal } from '@fluixi/reactive/signal';
+ *   const count = createSignal(0);
+ *
+ * And the intrinsic, which the compiler resolves and imports for you:
+ *
+ *   const count = $signal(0);
+ *
+ * They are not two reactive systems. `$signal` compiles to the same `createSignal` call,
+ * so there's one graph, one lifecycle, one SSR story. The `$` form is authoring sugar
+ * the compiler understands; the runtime form stays public, because a library that never
+ * runs this compiler still has to be able to write reactive code.
+ *
+ * Everything the compiler needs to know about a primitive lives in this table rather
+ * than spread across passes, so adding one is an entry, not a new code path.
+ */
+/** What a binding holds, once we know where it came from. */
+export type ReactiveKind = 'plain'
+/** `signal(0)`: one object, read with `.get()` and written with `.set()`. */
+ | 'signal-handle'
+/** `memo(fn)`: read-only, so `.get()` only. */
+ | 'memo-handle'
+/** `store(obj)`: read properties directly, `.set()` writes. */
+ | 'store-handle'
+/** `resource(fn)`: `.get()` reads, with `.loading`/`.latest`/`.refetch()` on it. */
+ | 'resource-handle'
+/** The accessor half of the tuple form, `const [count] = createSignal(0)`. */
+ | 'signal-accessor' | 'signal-setter' | 'memo-accessor' | 'effect' | 'reactive-object';
+export interface Intrinsic {
+    /** Runtime export this compiles to. */
+    export: string;
+    /** Module it comes from. */
+    module: string;
+    /**
+     * What the call yields. A tuple means the call is destructured into that many
+     * bindings: `createSignal` gives an accessor and a setter, in that order.
+     */
+    returns: ReactiveKind | readonly ReactiveKind[];
+}
+/** Module the reactive primitives are imported from when the compiler adds the import. */
+export declare const REACTIVE_MODULE = "@fluixi/reactive/signal";
+/**
+ * `$name` → the runtime it stands for.
+ *
+ * The `$` prefix is reserved. A local binding of the same name wins, it has to, or the
+ * compiler would rewrite code that means something else, and that's reported rather
+ * than done quietly.
+ */
+export declare const INTRINSICS: Readonly<Record<string, Intrinsic>>;
+/**
+ * The runtime names, for the other direction: source that imports `createSignal` gets
+ * classified the same way as source that writes `$signal`, so later passes see one
+ * vocabulary whichever form the author used.
+ */
+export declare const RUNTIME_PRIMITIVES: Readonly<Record<string, Intrinsic['returns']>>;
+/** Modules whose exports count as reactive primitives. */
+export declare const PRIMITIVE_MODULES: readonly string[];
+/**
+ * Cheap text check for the file-skipping fast path: a module with no `$` call never
+ * needs parsing. Non-global, so it has no lastIndex to carry between calls.
+ */
+/**
+ * Template tags an app writes without importing them. Each compiles exactly like the marker
+ * it names; a module that binds the name itself keeps its own meaning.
+ */
+export declare const TAG_INTRINSICS: Readonly<Record<string, {
+    export: 'html' | 'svg' | 'css';
+    module: string;
+}>>;
+/** The `$` tags this module can use: all of them, less the ones it binds. */
+export declare function tagIntrinsics(bound: Set<string>): Map<string, 'html' | 'svg' | 'css'>;
+export declare function mayHaveIntrinsic(code: string): boolean;
+export declare function isIntrinsicName(name: string): boolean;
+/** Whether a module path exports the reactive primitives. */
+export declare function isPrimitiveModule(source: string): boolean;
+//# sourceMappingURL=intrinsics.d.ts.map

package/dist/analyze/intrinsics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intrinsics.d.ts","sourceRoot":"","sources":["../../src/analyze/intrinsics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,6DAA6D;AAC7D,MAAM,MAAM,YAAY,GACpB,OAAO;AACT,6EAA6E;GAC3E,eAAe;AACjB,+CAA+C;GAC7C,aAAa;AACf,+DAA+D;GAC7D,cAAc;AAChB,oFAAoF;GAClF,iBAAiB;AACnB,8EAA8E;GAC5E,iBAAiB,GACjB,eAAe,GACf,eAAe,GACf,QAAQ,GACR,iBAAiB,CAAC;AAEtB,MAAM,WAAW,SAAS;IACxB,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,OAAO,EAAE,YAAY,GAAG,SAAS,YAAY,EAAE,CAAC;CACjD;AAED,0FAA0F;AAC1F,eAAO,MAAM,eAAe,4BAA4B,CAAC;AAEzD;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAsC1D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC,CAiB7E,CAAC;AAEF,0DAA0D;AAC1D,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAM9C,CAAC;AAEF;;;GAGG;AACH;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAIvG,CAAC;AAEF,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC,CAIrF;AAID,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,6DAA6D;AAC7D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEzD"}