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

package/dist/integrations.d.cts

@@ -0,0 +1,215 @@
+/**
+ * @fileoverview Bundler integrations for the Fluixi compiler.
+ * @module @fluixi/compiler/integrations
+ *
+ * vite, webpack, rollup and esbuild adapters. Each is a few lines around
+ * `compileModule`, which rewrites the source in place, JSX and `` html`` `` both
+ * lower to the shared IR and the imperative backend. fluixi re-exports
+ * createVitePlugin from here.
+ *
+ * `babel: true` routes through the babel front-end instead, for a project whose
+ * own babel plugins have to see the output. It is the only thing that needs
+ * @babel/core, and it says so rather than degrading: source that was not compiled
+ * is source whose templates never became DOM calls, and a build that ships it
+ * looks successful until the page is opened.
+ */
+export interface CompilerOptions {
+    /**
+     * 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[];
+    /**
+     * Where to write the ambient declarations for the components `resolve` supplies.
+     *
+     * Relative to the project root; `false` turns generation off. Without this file every
+     * resolved tag is a `Cannot find name` error in the editor and in `tsc`, because the
+     * import only exists after compilation. Committing it is intended, it is what makes a
+     * fresh clone type-check before anyone runs the dev server.
+     *
+     * It must be covered by `include` in tsconfig.json, which for the default means adding
+     * `"fluixi.d.ts"` alongside `"src"`. A file TypeScript does not read looks exactly like
+     * one that was never generated, so a mismatch is reported rather than left to puzzle
+     * over.
+     *
+     * @default 'fluixi.d.ts'
+     */
+    globals?: string | false;
+    /** Clone static subtrees from a `<template>` instead of building them element by element. */
+    templateClone?: boolean;
+    /** Also clone subtrees whose structure is static but which contain dynamic holes. */
+    partialTemplates?: boolean;
+    /**
+     * Whether to generate source maps
+     * @default false
+     */
+    sourceMaps?: boolean;
+    /**
+     * Whether to delegate events
+     * @default true
+     */
+    delegateEvents?: boolean;
+    /**
+     * Whether to generate dev-mode code with additional checks
+     * @default false
+     */
+    development?: boolean;
+    /**
+     * Where the JSX *types* come from, and the `jsxImportSource` handed to esbuild
+     * and TypeScript. The compiler never emits `jsx()` calls itself, this is for
+     * type resolution and for any JSX the Fluixi transform does not consume.
+     * @default '@fluixi/jsx'
+     */
+    importSource?: string;
+    /**
+     * Authoring syntaxes to compile: 'jsx', 'lit' (only `` html`...` `` templates),
+     * or 'both' (default). Both lower to the same IR and the same backend.
+     * @default 'both'
+     */
+    format?: 'jsx' | 'lit' | 'both';
+    /**
+     * Record where each reactive node is created, and serve the running app's graph to a tool
+     * that asks for it. Development only: a build never carries either.
+     *
+     * On by default when the dev server is running and @fluixi/devtools is installed. The
+     * marks are what turn `m5` into `double @ src/app.tsx:6`, and the endpoint is what an
+     * editor or a graph panel reads.
+     *
+     * `{ external: true }` marks dependencies too: node_modules and anything outside the
+     * project. That is for working on the framework itself: the graph then shows which nodes
+     * a library created and which the application did, at the cost of a mark per node in code
+     * you are not editing.
+     */
+    devtools?: boolean | {
+        external?: boolean;
+    };
+    /**
+     * Compile through babel instead of rewriting the source directly.
+     *
+     * The default path parses once and splices the emitted code over the spans it
+     * replaces: nothing is reprinted, edits carry a source map, and types are left
+     * for esbuild to strip. Babel is kept for the cases that need to sit inside its
+     * pipeline: a `babel.config.js` with other plugins that have to see the
+     * output. It needs `@babel/core` and friends installed; they are optional peers.
+     * @default false
+     */
+    babel?: boolean;
+    /**
+     * Tag name marking a lit template for compilation (when `format` includes lit).
+     * @default 'html'
+     */
+    litTag?: string;
+    /**
+     * Rewrite a component's destructured props into property reads, so
+     * `function Card({ title })` keeps updating instead of reading `title` once.
+     * Applies to JSX and html`` alike: it rewrites the function body before either is
+     * compiled. A pattern it can't prove is left as written, so `splitProps` keeps
+     * working wherever it's still needed.
+     *
+     * Turn it off for a package that ships its source to be compiled by the consumer ,
+     * rewriting there would bake property reads into what you publish.
+     *
+     * @default true
+     */
+    propsDestructure?: boolean;
+    /**
+     * Module emitted runtime symbols are imported from in 'imperative' mode.
+     * @default '@fluixi/dom'
+     */
+    signalModule?: string;
+    /**
+     * Module control-flow components are imported from in 'imperative' mode.
+     * @default '@fluixi/dom'
+     */
+    controlFlowModule?: string;
+    /**
+     * Module the router components (Router/Outlet/…) are auto-imported from.
+     * @default '@fluixi/core/router'
+     */
+    routerModule?: string;
+    /**
+     * Where reactive primitives (createMemo) are imported from in 'imperative' mode.
+     * @default '@fluixi/reactive/signal'
+     */
+    reactiveModule?: string;
+}
+/**
+ * Helper for creating a Babel plugin
+ */
+export declare function createBabelPlugin(options?: CompilerOptions): Promise<{
+    name: string;
+    plugin: ((api: object, options: import("./frontend/babel/plugin.cjs").PluginOptions | null | undefined, dirname: string) => import("@babel/core").PluginObj<import("@babel/core").PluginPass>) | null;
+    getOptions(): {
+        reactiveModule?: string | undefined;
+        routerModule?: string | undefined;
+        controlFlowModule?: string | undefined;
+        signalModule?: string | undefined;
+        litTag?: string | undefined;
+        partialTemplates?: boolean | undefined;
+        templateClone?: boolean | undefined;
+        resolve?: readonly ComponentResolverRule[] | undefined;
+        format?: "both" | "jsx" | "lit" | undefined;
+        importSource: string;
+        development: boolean;
+        delegateEvents: boolean;
+    };
+}>;
+/**
+ * Helper for creating a TypeScript transformer
+ */
+export declare function createTypeScriptTransformer(options?: CompilerOptions): (context: any) => (sourceFile: any) => any;
+/**
+ * Create a Vite plugin for JSX transformation
+ */
+export declare function createVitePlugin<T>(options?: CompilerOptions): T;
+/**
+ * Create a Webpack loader for JSX transformation
+ */
+export declare function createWebpackLoader(options?: CompilerOptions): (this: any, source: string) => Promise<void>;
+/**
+ * Create a Rollup plugin for JSX transformation
+ */
+export declare function createRollupPlugin(options?: CompilerOptions): {
+    name: string;
+    transform(code: string, id: string): Promise<import("./transform/templates.cjs").TransformResult | {
+        code: string;
+        map: {
+            version: number;
+            sources: string[];
+            names: string[];
+            sourceRoot?: string | undefined;
+            sourcesContent?: string[] | undefined;
+            mappings: string;
+            file: string;
+        } | null | undefined;
+    } | null>;
+};
+/**
+ * Create an ESBuild plugin for JSX transformation
+ */
+export declare function createESBuildPlugin(options?: CompilerOptions): {
+    name: string;
+    setup(build: any): void;
+};
+export type { ServerFnTransformOptions } from './frontend/babel/server-functions.cjs';
+import type { ComponentResolverRule } from './resolve/component-resolver.cjs';
+/**
+ * Vite plugin for `"use server"`: applies the transform (client→RPC stub, server→register
+ * the body), and provides `virtual:fluixi-server-fns`, side-effect imports of every
+ * module that defines a server function. The server entry imports it so ALL server
+ * functions register at startup (including those in lazy routes, which would otherwise
+ * register only when their chunk loads → an RPC registry miss). The client never imports
+ * it. `enforce:'pre'` so it runs on the raw source before other transforms.
+ */
+export declare function serverFunctionsVitePlugin<T = any>(options?: {
+    babel?: boolean;
+}): T;
+declare const _default: {
+    createBabelPlugin: typeof createBabelPlugin;
+    createTypeScriptTransformer: typeof createTypeScriptTransformer;
+    createVitePlugin: typeof createVitePlugin;
+    createWebpackLoader: typeof createWebpackLoader;
+    createRollupPlugin: typeof createRollupPlugin;
+    createESBuildPlugin: typeof createESBuildPlugin;
+};
+export default _default;

package/dist/integrations.d.ts

@@ -3,7 +3,7 @@
  * @module @fluixi/compiler/integrations
  *
  * vite, webpack, rollup and esbuild adapters. Each is a few lines around
- * `compileModule`, which rewrites the source in place — JSX and `` html`` `` both
+ * `compileModule`, which rewrites the source in place, JSX and `` html`` `` both
  * lower to the shared IR and the imperative backend. fluixi re-exports
  * createVitePlugin from here.
  *
@@ -24,7 +24,7 @@ export interface CompilerOptions {
      *
      * Relative to the project root; `false` turns generation off. Without this file every
      * resolved tag is a `Cannot find name` error in the editor and in `tsc`, because the
-     * import only exists after compilation. Committing it is intended — it is what makes a
+     * import only exists after compilation. Committing it is intended, it is what makes a
      * fresh clone type-check before anyone runs the dev server.
      *
      * It must be covered by `include` in tsconfig.json, which for the default means adding
@@ -56,7 +56,7 @@ export interface CompilerOptions {
     development?: boolean;
     /**
      * Where the JSX *types* come from, and the `jsxImportSource` handed to esbuild
-     * and TypeScript. The compiler never emits `jsx()` calls itself — this is for
+     * and TypeScript. The compiler never emits `jsx()` calls itself, this is for
      * type resolution and for any JSX the Fluixi transform does not consume.
      * @default '@fluixi/jsx'
      */
@@ -69,13 +69,13 @@ export interface CompilerOptions {
     format?: 'jsx' | 'lit' | 'both';
     /**
      * Record where each reactive node is created, and serve the running app's graph to a tool
-     * that asks for it. Development only — a build never carries either.
+     * that asks for it. Development only: a build never carries either.
      *
      * On by default when the dev server is running and @fluixi/devtools is installed. The
      * marks are what turn `m5` into `double @ src/app.tsx:6`, and the endpoint is what an
      * editor or a graph panel reads.
      *
-     * `{ external: true }` marks dependencies too — node_modules and anything outside the
+     * `{ external: true }` marks dependencies too: node_modules and anything outside the
      * project. That is for working on the framework itself: the graph then shows which nodes
      * a library created and which the application did, at the cost of a mark per node in code
      * you are not editing.
@@ -89,7 +89,7 @@ export interface CompilerOptions {
      * The default path parses once and splices the emitted code over the spans it
      * replaces: nothing is reprinted, edits carry a source map, and types are left
      * for esbuild to strip. Babel is kept for the cases that need to sit inside its
-     * pipeline — a `babel.config.js` with other plugins that have to see the
+     * pipeline: a `babel.config.js` with other plugins that have to see the
      * output. It needs `@babel/core` and friends installed; they are optional peers.
      * @default false
      */
@@ -102,11 +102,11 @@ export interface CompilerOptions {
     /**
      * Rewrite a component's destructured props into property reads, so
      * `function Card({ title })` keeps updating instead of reading `title` once.
-     * Applies to JSX and html`` alike — it rewrites the function body before either is
+     * Applies to JSX and html`` alike: it rewrites the function body before either is
      * compiled. A pattern it can't prove is left as written, so `splitProps` keeps
      * working wherever it's still needed.
      *
-     * Turn it off for a package that ships its source to be compiled by the consumer —
+     * Turn it off for a package that ships its source to be compiled by the consumer ,
      * rewriting there would bake property reads into what you publish.
      *
      * @default true
@@ -195,7 +195,7 @@ export type { ServerFnTransformOptions } from './frontend/babel/server-functions
 import type { ComponentResolverRule } from './resolve/component-resolver.js';
 /**
  * Vite plugin for `"use server"`: applies the transform (client→RPC stub, server→register
- * the body), and provides `virtual:fluixi-server-fns` — side-effect imports of every
+ * the body), and provides `virtual:fluixi-server-fns`, side-effect imports of every
  * module that defines a server function. The server entry imports it so ALL server
  * functions register at startup (including those in lazy routes, which would otherwise
  * register only when their chunk loads → an RPC registry miss). The client never imports

package/dist/integrations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integrations.d.ts","sourceRoot":"","sources":["../src/integrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,OAAO,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC3C;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACzB,6FAA6F;IAC7F,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qFAAqF;IACrF,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAEhC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAE5C;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAMD;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,GAAE,eAAoB;;;;;;;;;;;;;;;;;GAwCpE;AAMD;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,eAAoB,aAIpD,GAAG,MAAM,YAAY,GAAG,SAkB5C;AAqCD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAE,eAAoB,GAAG,CAAC,CAsHpE;AAoID;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,eAAoB,IACxC,MAAM,GAAG,EAAE,QAAQ,MAAM,mBAUjD;AAMD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,eAAoB;;oBAItC,MAAM,MAAM,MAAM;;;;;;;;;;;;EAK3C;AAMD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,eAAoB;;iBAIhD,GAAG;EAwBnB;AAWD,YAAY,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AACrF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AA8B7E;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,CAAC,CAqCvF;;;;;;;;;AAED,wBAOE"}
+{"version":3,"file":"integrations.d.ts","sourceRoot":"","sources":["../src/integrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,OAAO,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC3C;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACzB,6FAA6F;IAC7F,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qFAAqF;IACrF,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAEhC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAE5C;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAMD;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,GAAE,eAAoB;;;;;;;;;;;;;;;;;GAwCpE;AAMD;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,eAAoB,aAIpD,GAAG,MAAM,YAAY,GAAG,SAkB5C;AAqCD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAE,eAAoB,GAAG,CAAC,CAsHpE;AAoID;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,eAAoB,IACxC,MAAM,GAAG,EAAE,QAAQ,MAAM,mBAUjD;AAMD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,eAAoB;;oBAItC,MAAM,MAAM,MAAM;;;;;;;;;;;;EAK3C;AAMD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,eAAoB;;iBAIhD,GAAG;EAwBnB;AAWD,YAAY,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AACrF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAoD7E;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,CAAC,CAqCvF;;;;;;;;;AAED,wBAOE"}

package/dist/integrations.js

@@ -3,7 +3,7 @@
  * @module @fluixi/compiler/integrations
  *
  * vite, webpack, rollup and esbuild adapters. Each is a few lines around
- * `compileModule`, which rewrites the source in place — JSX and `` html`` `` both
+ * `compileModule`, which rewrites the source in place, JSX and `` html`` `` both
  * lower to the shared IR and the imperative backend. fluixi re-exports
  * createVitePlugin from here.
  *
@@ -161,7 +161,7 @@ export function createVitePlugin(options = {}) {
                 if (!babel) {
                     // No silent fallback. This front-end compiles through babel; without it
                     // there is no transform, and emitting the source unchanged would ship a
-                    // build whose JSX and html`` templates were never compiled — a failure
+                    // build whose JSX and html`` templates were never compiled, a failure
                     // that looks exactly like success until the page is opened.
                     throw new Error(`[fluixi] @babel/core is required to compile ${id} but could not be loaded. ` +
                         `Install it alongside @fluixi/compiler.`);
@@ -189,7 +189,7 @@ export function createVitePlugin(options = {}) {
                         ]);
                     }
                 }
-                // Only our custom babel plugin handles JSX — never @babel/preset-react, which
+                // Only our custom babel plugin handles JSX, never @babel/preset-react, which
                 // rewrites spreads with Object.assign and breaks store-proxy reactivity.
                 if (babelPlugin && babelPlugin.plugin) {
                     plugins.push([babelPlugin.plugin, babelPlugin.getOptions()]);
@@ -285,7 +285,7 @@ const reported = new Set();
  * All of these build cleanly and fail at runtime, which is why they are worth printing: an
  * unresolved tag renders nothing, a `load:` it cannot act on ships the chunk eagerly, and a
  * props pattern the rewrite refused reads its value once instead of tracking it. None leaves
- * a trace anywhere else — the last one is a stale value on screen and nothing in the build.
+ * a trace anywhere else: the last one is a stale value on screen and nothing in the build.
  *
  * `console.warn`, deliberately, not a plugin's `this.warn`: that only exists in the
  * rollup/vite context, and this runs for the esbuild and webpack adapters too. A
@@ -407,6 +407,27 @@ import { readdirSync, readFileSync } from 'node:fs';
 import { join as _join } from 'node:path';
 const SERVER_FNS_VMOD = 'virtual:fluixi-server-fns';
 /** Recursively find source files containing the `"use server"` directive under `dir`. */
+/**
+ * Whether a file actually carries a `"use server"` directive.
+ *
+ * Every module this matches is side-effect imported into the server bundle, so a false
+ * positive does more than waste a line: it runs that file on the server. A plain
+ * `includes('use server')` matched the words wherever they appeared, and a client entry
+ * that merely *mentioned* the directive in a comment was imported into the SSR graph and
+ * called `startClient` there, which fails with `document is not defined` from a line
+ * nobody wrote.
+ *
+ * Comments are stripped before the test rather than parsed around, because the answer
+ * only has to be good enough to decide whether the real transform should look at the
+ * file. A directive inside a string literal still matches, which costs an extra import
+ * and nothing else.
+ */
+function hasServerDirective(source) {
+    const withoutComments = source
+        .replace(/\/\*[\s\S]*?\*\//g, ' ')
+        .replace(/(^|[^:])\/\/[^\n]*/g, '$1');
+    return /(^|[\s;{(,])['"]use server['"]/.test(withoutComments);
+}
 function findServerFnModules(dir, out = []) {
     let entries;
     try {
@@ -423,11 +444,11 @@ function findServerFnModules(dir, out = []) {
             findServerFnModules(full, out);
         else if (/\.[jt]sx?$/.test(e.name)) {
             try {
-                if (readFileSync(full, 'utf8').includes('use server'))
+                if (hasServerDirective(readFileSync(full, 'utf8')))
                     out.push(full);
             }
             catch {
-                /* unreadable — skip */
+                /* unreadable: skip */
             }
         }
     }
@@ -435,7 +456,7 @@ function findServerFnModules(dir, out = []) {
 }
 /**
  * Vite plugin for `"use server"`: applies the transform (client→RPC stub, server→register
- * the body), and provides `virtual:fluixi-server-fns` — side-effect imports of every
+ * the body), and provides `virtual:fluixi-server-fns`, side-effect imports of every
  * module that defines a server function. The server entry imports it so ALL server
  * functions register at startup (including those in lazy routes, which would otherwise
  * register only when their chunk loads → an RPC registry miss). The client never imports
@@ -461,7 +482,7 @@ export function serverFunctionsVitePlugin(options = {}) {
             // First wire the request-context bridge (server-only), then side-effect import each
             // server-fn module so its top-level $$registerServerFn(...) runs, then re-export the
             // dispatcher so the host can route /_server through THIS module graph (sharing the
-            // registry the imports populated) — apps don't need to re-export it from entry-server.
+            // registry the imports populated), apps don't need to re-export it from entry-server.
             const setup = `import '@fluixi/start/server-fn-setup';\n`;
             const imports = mods.map((m) => `import ${JSON.stringify(m)};`).join('\n');
             const dispatcher = `\nexport { isServerFnRequest, handleServerFn } from '@fluixi/start/server-fn';\n`;