@fluixi/compiler 1.0.0-alpha.100

package/dist/resolve/write-globals.js

@@ -0,0 +1,169 @@
+/**
+ * Write the generated component declarations into a project.
+ *
+ * Split from the generator so the generator stays pure and testable; this half owns the
+ * three things that only matter once a real file is involved:
+ *
+ *  - **Never clobber someone's file.** A path like `src/fluixi.d.ts` is plausible enough
+ *    that a project may already have one. Anything without our header is left alone and
+ *    reported, because silently overwriting hand-written declarations is unrecoverable.
+ *  - **Do not rewrite unchanged content.** The dev server watches this directory; an
+ *    identical write still bumps mtime and can cost a reload every restart.
+ *  - **Only declare what the project can resolve.** Dependencies come from its manifest,
+ *    so a component from an uninstalled package is skipped rather than degraded to `any`.
+ */
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, dirname, relative, sep, resolve as resolvePath } from 'node:path';
+import { componentGlobals } from './component-globals.js';
+/** The marker every generated file carries, used to tell ours from a hand-written one. */
+const GENERATED_MARKER = 'GENERATED by @fluixi/compiler';
+export const DEFAULT_GLOBALS_PATH = 'fluixi.d.ts';
+/**
+ * Whether `target` looks covered by the project's `include`, as best we can tell.
+ *
+ * `undefined` when there is nothing to judge from, no tsconfig, unreadable, or an
+ * `extends` we would have to resolve to answer honestly. Best-effort by design: this
+ * drives a warning, never a failure, so a wrong guess must not be able to break a build.
+ */
+function coveredByInclude(root, target) {
+    let config;
+    try {
+        const raw = readFileSync(resolvePath(root, 'tsconfig.json'), 'utf8');
+        // Comments are legal in tsconfig and would break JSON.parse.
+        config = JSON.parse(raw.replace(/^\s*\/\/.*$/gm, ''));
+    }
+    catch {
+        return undefined;
+    }
+    if (config.extends !== undefined)
+        return undefined;
+    // No `include` means the whole directory tree, which covers anything we write.
+    if (!Array.isArray(config.include))
+        return true;
+    const relative = relativePosix(root, target);
+    return config.include.some((entry) => {
+        if (typeof entry !== 'string')
+            return false;
+        const pattern = entry
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*\*\//g, '(?:.*/)?')
+            .replace(/\*/g, '[^/]*');
+        // A bare directory entry (`src`) covers everything beneath it.
+        return new RegExp(`^${pattern}(?:/.*)?$`).test(relative);
+    });
+}
+/** `from` -> `to` as a posix-style relative path. */
+function relativePosix(from, to) {
+    return relative(from, to).split(sep).join('/');
+}
+/**
+ * Make a specifier resolvable from the generated file.
+ *
+ * A bundler-root-absolute `/src/components/Card.tsx` is what Vite wants and what
+ * TypeScript cannot resolve at all, so it becomes a path relative to the generated file.
+ * The extension goes to `.js` because that is what TypeScript expects to be written for
+ * a `.ts`/`.tsx` source under every module resolution mode that accepts an extension.
+ */
+function forTypeScript(module, outDir, root) {
+    if (!module.startsWith('/'))
+        return module;
+    const absolute = resolvePath(root, module.slice(1));
+    let rel = relative(outDir, absolute).split(sep).join('/');
+    if (!rel.startsWith('.'))
+        rel = `./${rel}`;
+    return rel.replace(/\.(tsx|ts|jsx|mts|cts)$/, '.js');
+}
+/** The project's declared dependencies, or undefined when there is no readable manifest. */
+function projectDependencies(root) {
+    try {
+        const manifest = JSON.parse(readFileSync(resolvePath(root, 'package.json'), 'utf8'));
+        return [
+            ...Object.keys(manifest.dependencies ?? {}),
+            ...Object.keys(manifest.devDependencies ?? {}),
+            ...Object.keys(manifest.peerDependencies ?? {}),
+        ];
+    }
+    catch {
+        // No manifest to read: declare everything and let TypeScript report what is missing.
+        return undefined;
+    }
+}
+/**
+ * Names from the files a pattern rule points at: `/src/components/$1.tsx` lists
+ * `src/components` and offers each `X` for `X.tsx`. Only a project path with the group in
+ * the file name; the resolver still decides whether a name matches.
+ */
+export function patternCandidates(rules, root) {
+    const out = [];
+    for (const rule of rules) {
+        if (!('match' in rule) || !rule.module.startsWith('/'))
+            continue;
+        const dir = dirname(rule.module);
+        const file = basename(rule.module);
+        const group = file.match(/\$\d+/);
+        if (dir.includes('$') || !group || file.indexOf('$', group.index + 1) !== -1)
+            continue;
+        const before = file.slice(0, group.index);
+        const after = file.slice(group.index + group[0].length);
+        let entries;
+        try {
+            entries = readdirSync(resolvePath(root, dir.slice(1)));
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.length > before.length + after.length && entry.startsWith(before) && entry.endsWith(after)) {
+                out.push(entry.slice(before.length, entry.length - after.length));
+            }
+        }
+    }
+    return out;
+}
+/** Generate and write the declarations for `root`, returning what was done. */
+export function writeComponentGlobals(options, root) {
+    if (options.globals === false)
+        return { status: 'skipped', reason: 'disabled' };
+    const rules = options.resolve ?? [];
+    const target = resolvePath(root, options.globals ?? DEFAULT_GLOBALS_PATH);
+    let existing;
+    try {
+        existing = readFileSync(target, 'utf8');
+    }
+    catch {
+        existing = undefined;
+    }
+    if (existing !== undefined && !existing.includes(GENERATED_MARKER)) {
+        return { status: 'skipped', reason: 'foreign-file', path: target };
+    }
+    const { source, declared } = componentGlobals(rules, {
+        available: projectDependencies(root),
+        candidates: patternCandidates(rules, root),
+        specifier: (module) => forTypeScript(module, dirname(target), root),
+    });
+    if (existing === source) {
+        return {
+            status: 'unchanged',
+            path: target,
+            declared: declared.length,
+            warning: warnIfUnreachable(root, target),
+        };
+    }
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, source);
+    return {
+        status: 'written',
+        path: target,
+        declared: declared.length,
+        warning: warnIfUnreachable(root, target),
+    };
+}
+/** The message to show when the generated file is outside the project's `include`. */
+function warnIfUnreachable(root, target) {
+    if (coveredByInclude(root, target) !== false)
+        return undefined;
+    const relative = relativePosix(root, target);
+    return (`[fluixi] ${relative} is not covered by "include" in tsconfig.json, so TypeScript ` +
+        `will ignore it and every resolved component stays "Cannot find name". Add ` +
+        `"${relative}" to "include".`);
+}

package/dist/resolve/write-globals.mjs

@@ -0,0 +1,362 @@
+// src/resolve/write-globals.ts
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, relative, sep, resolve as resolvePath } from "node:path";
+
+// 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" },
+  $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 TAG_INTRINSICS = {
+  $html: { export: "html", module: "@fluixi/core" },
+  $svg: { export: "svg", module: "@fluixi/core" },
+  $css: { export: "css", module: "@fluixi/core" }
+};
+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(module) {
+  return `_${module.replace(/[^A-Za-z0-9]/g, "_")}`;
+}
+function componentGlobals(rules, options = {}) {
+  const {
+    available: availableList,
+    builtins = true,
+    intrinsics = true,
+    generator = "@fluixi/compiler",
+    specifier = (module) => module,
+    candidates = []
+  } = 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();
+  const names = /* @__PURE__ */ new Set([...resolver.names(), ...[...candidates].filter((n) => /^[A-Za-z_$][\w$]*$/.test(n))]);
+  for (const name of [...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 usableIntrinsics = intrinsics ? Object.entries({ ...INTRINSICS, ...TAG_INTRINSICS }).filter(([, i]) => {
+    const pkg = packageOf(i.module);
+    return !available || !pkg || available.has(pkg);
+  }) : [];
+  const intrinsicModules = [...new Set(usableIntrinsics.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:
+` + shadowedByDom.map((n) => {
+    const module = resolver.resolve(n)?.module;
+    return `//   import { ${n} } from '${module ? specifier(module) : ""}';
+`;
+  }).join("") : "";
+  const intrinsicLines = usableIntrinsics.map(
+    ([name, intrinsic]) => `  const ${name}: typeof ${namespaceAlias(intrinsic.module)}.${intrinsic.export};`
+  );
+  const patternRules = rules.filter((rule) => "match" in rule).length;
+  const patternNote = patternRules === 0 ? "" : options.candidates ? `//
+// ${patternRules} pattern rule${patternRules === 1 ? "" : "s"}: declared for the files the module path
+// points at. A name with no such file still resolves at build time; declare it by hand.
+` : `//
+// ${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.
+`;
+  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.
+` + note + patternNote + (imports.length > 0 ? `
+${imports.join("\n")}
+` : "\n") + `
+declare global {
+${[...lines, ...intrinsicLines].join("\n")}
+}
+`;
+  return { source, declared, shadowedByDom, unavailable, patternRules };
+}
+
+// src/resolve/write-globals.ts
+var GENERATED_MARKER = "GENERATED by @fluixi/compiler";
+var DEFAULT_GLOBALS_PATH = "fluixi.d.ts";
+function coveredByInclude(root, target) {
+  let config;
+  try {
+    const raw = readFileSync(resolvePath(root, "tsconfig.json"), "utf8");
+    config = JSON.parse(raw.replace(/^\s*\/\/.*$/gm, ""));
+  } catch {
+    return void 0;
+  }
+  if (config.extends !== void 0) return void 0;
+  if (!Array.isArray(config.include)) return true;
+  const relative2 = relativePosix(root, target);
+  return config.include.some((entry) => {
+    if (typeof entry !== "string") return false;
+    const pattern = entry.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "(?:.*/)?").replace(/\*/g, "[^/]*");
+    return new RegExp(`^${pattern}(?:/.*)?$`).test(relative2);
+  });
+}
+function relativePosix(from, to) {
+  return relative(from, to).split(sep).join("/");
+}
+function forTypeScript(module, outDir, root) {
+  if (!module.startsWith("/")) return module;
+  const absolute = resolvePath(root, module.slice(1));
+  let rel = relative(outDir, absolute).split(sep).join("/");
+  if (!rel.startsWith(".")) rel = `./${rel}`;
+  return rel.replace(/\.(tsx|ts|jsx|mts|cts)$/, ".js");
+}
+function projectDependencies(root) {
+  try {
+    const manifest = JSON.parse(readFileSync(resolvePath(root, "package.json"), "utf8"));
+    return [
+      ...Object.keys(manifest.dependencies ?? {}),
+      ...Object.keys(manifest.devDependencies ?? {}),
+      ...Object.keys(manifest.peerDependencies ?? {})
+    ];
+  } catch {
+    return void 0;
+  }
+}
+function patternCandidates(rules, root) {
+  const out = [];
+  for (const rule of rules) {
+    if (!("match" in rule) || !rule.module.startsWith("/")) continue;
+    const dir = dirname(rule.module);
+    const file = basename(rule.module);
+    const group = file.match(/\$\d+/);
+    if (dir.includes("$") || !group || file.indexOf("$", group.index + 1) !== -1) continue;
+    const before = file.slice(0, group.index);
+    const after = file.slice(group.index + group[0].length);
+    let entries;
+    try {
+      entries = readdirSync(resolvePath(root, dir.slice(1)));
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.length > before.length + after.length && entry.startsWith(before) && entry.endsWith(after)) {
+        out.push(entry.slice(before.length, entry.length - after.length));
+      }
+    }
+  }
+  return out;
+}
+function writeComponentGlobals(options, root) {
+  if (options.globals === false) return { status: "skipped", reason: "disabled" };
+  const rules = options.resolve ?? [];
+  const target = resolvePath(root, options.globals ?? DEFAULT_GLOBALS_PATH);
+  let existing;
+  try {
+    existing = readFileSync(target, "utf8");
+  } catch {
+    existing = void 0;
+  }
+  if (existing !== void 0 && !existing.includes(GENERATED_MARKER)) {
+    return { status: "skipped", reason: "foreign-file", path: target };
+  }
+  const { source, declared } = componentGlobals(rules, {
+    available: projectDependencies(root),
+    candidates: patternCandidates(rules, root),
+    specifier: (module) => forTypeScript(module, dirname(target), root)
+  });
+  if (existing === source) {
+    return {
+      status: "unchanged",
+      path: target,
+      declared: declared.length,
+      warning: warnIfUnreachable(root, target)
+    };
+  }
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, source);
+  return {
+    status: "written",
+    path: target,
+    declared: declared.length,
+    warning: warnIfUnreachable(root, target)
+  };
+}
+function warnIfUnreachable(root, target) {
+  if (coveredByInclude(root, target) !== false) return void 0;
+  const relative2 = relativePosix(root, target);
+  return `[fluixi] ${relative2} is not covered by "include" in tsconfig.json, so TypeScript will ignore it and every resolved component stays "Cannot find name". Add "${relative2}" to "include".`;
+}
+export {
+  DEFAULT_GLOBALS_PATH,
+  patternCandidates,
+  writeComponentGlobals
+};

package/dist/server-fns-VZLHMQTC.mjs

@@ -0,0 +1,79 @@
+/*! @fluixi/compiler v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+import {
+  MagicString
+} from "./chunk-HXEXPWJ2.mjs";
+import "./chunk-3AICWNF7.mjs";
+import {
+  serverFnId
+} from "./chunk-C3XPDB4Y.mjs";
+import "./chunk-SKAVY75W.mjs";
+
+// src/transform/server-fns.ts
+import { parse } from "@babel/parser";
+var RUNTIME = "@fluixi/start/server-fn";
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "ArrowFunctionExpression"
+]);
+function directive(node) {
+  if (!FUNCTION_TYPES.has(node.type)) return null;
+  const body = node.body;
+  if (!body || body.type !== "BlockStatement") return null;
+  for (const d of body.directives ?? []) {
+    if (d.value?.value === "use server") return d;
+  }
+  return null;
+}
+function findServerFns(node, out) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const child of node) findServerFns(child, out);
+    return;
+  }
+  if (typeof node.type === "string") {
+    const found = directive(node);
+    if (found) {
+      out.push({ fn: node, directive: found });
+      return;
+    }
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+    findServerFns(node[key], out);
+  }
+}
+function transformServerFns(code, options) {
+  if (!code.includes("use server")) return null;
+  const ast = parse(code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript"],
+    errorRecovery: true
+  });
+  const found = [];
+  findServerFns(ast.program, found);
+  if (found.length === 0) return null;
+  const helper = options.ssr ? "$$registerServerFn" : "$$createServerReference";
+  const out = new MagicString(code);
+  found.forEach(({ fn, directive: dir }, index) => {
+    const id = serverFnId(options.filename, options.root, index);
+    const declaration = fn.type === "FunctionDeclaration";
+    if (!options.ssr) {
+      const stub = `${helper}(${JSON.stringify(id)})`;
+      out.overwrite(fn.start, fn.end, declaration ? `const ${fn.id.name} = ${stub};` : stub);
+      return;
+    }
+    out.remove(dir.start, dir.end);
+    out.appendLeft(fn.start, declaration ? `const ${fn.id.name} = ${helper}(${JSON.stringify(id)}, ` : `${helper}(${JSON.stringify(id)}, `);
+    out.appendRight(fn.end, declaration ? ");" : ")");
+  });
+  out.prepend(`import { ${helper} } from ${JSON.stringify(options.runtimeModule ?? RUNTIME)};
+`);
+  return {
+    code: out.toString(),
+    map: out.generateMap({ source: options.filename, includeContent: true, hires: true })
+  };
+}
+export {
+  transformServerFns
+};

package/dist/server-functions-UAZKOLZW.mjs

@@ -0,0 +1,82 @@
+/*! @fluixi/compiler v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+import {
+  serverFnId
+} from "./chunk-C3XPDB4Y.mjs";
+import "./chunk-SKAVY75W.mjs";
+
+// src/frontend/babel/server-functions.ts
+import { transformSync } from "@babel/core";
+var RUNTIME = "@fluixi/start/server-fn";
+function serverFunctionsBabelPlugin({ types: t }) {
+  return {
+    name: "fluixi-server-functions",
+    visitor: {
+      Program: {
+        enter(_path, state) {
+          state.fxIndex = 0;
+          state.fxUsed = null;
+        },
+        exit(path, state) {
+          if (!state.fxUsed) return;
+          path.unshiftContainer(
+            "body",
+            t.importDeclaration(
+              [t.importSpecifier(t.identifier(state.fxUsed), t.identifier(state.fxUsed))],
+              t.stringLiteral(state.opts.runtimeModule || RUNTIME)
+            )
+          );
+        }
+      },
+      "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression": (path, state) => {
+        const body = path.node.body;
+        if (!t.isBlockStatement(body)) return;
+        const dirs = body.directives || [];
+        const di = dirs.findIndex((d) => d.value.value === "use server");
+        if (di < 0) return;
+        body.directives.splice(di, 1);
+        const id = serverFnId(
+          state.opts.filename || state.filename || "unknown",
+          state.opts.root,
+          state.fxIndex++
+        );
+        const ssr = !!state.opts.ssr;
+        const helper = ssr ? "$$registerServerFn" : "$$createServerReference";
+        state.fxUsed = helper;
+        const replacement = ssr ? t.callExpression(t.identifier(helper), [
+          t.stringLiteral(id),
+          path.isFunctionDeclaration() ? t.functionExpression(
+            null,
+            path.node.params,
+            body,
+            path.node.generator,
+            path.node.async
+          ) : path.node
+        ]) : t.callExpression(t.identifier(helper), [t.stringLiteral(id)]);
+        if (path.isFunctionDeclaration()) {
+          path.replaceWith(
+            t.variableDeclaration("const", [t.variableDeclarator(path.node.id, replacement)])
+          );
+        } else {
+          path.replaceWith(replacement);
+        }
+        path.skip();
+      }
+    }
+  };
+}
+function transformServerFunctions(code, opts) {
+  if (!code.includes("use server")) return null;
+  const result = transformSync(code, {
+    filename: opts.filename,
+    configFile: false,
+    babelrc: false,
+    sourceMaps: true,
+    parserOpts: { plugins: ["typescript", "jsx"] },
+    plugins: [[serverFunctionsBabelPlugin, opts]]
+  });
+  if (!result?.code) return null;
+  return { code: result.code, map: result.map };
+}
+export {
+  transformServerFunctions
+};