@fluixi/start 0.1.0-alpha.72 → 0.1.0-alpha.74

package/dist/interceptors.cjs

@@ -0,0 +1,71 @@
+"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/interceptors.ts
+var interceptors_exports = {};
+__export(interceptors_exports, {
+  addInterceptor: () => addInterceptor,
+  clearInterceptors: () => clearInterceptors,
+  fetchWithInterceptors: () => fetchWithInterceptors
+});
+module.exports = __toCommonJS(interceptors_exports);
+
+// src/server-fn.ts
+var _fetch = (...a) => fetch(...a);
+function setServerFnFetch(f) {
+  _fetch = f;
+}
+
+// src/interceptors.ts
+var interceptors = [];
+function addInterceptor(interceptor) {
+  if (interceptors.length === 0) setServerFnFetch(fetchWithInterceptors);
+  interceptors.push(interceptor);
+  return () => {
+    const i = interceptors.indexOf(interceptor);
+    if (i >= 0) interceptors.splice(i, 1);
+  };
+}
+function clearInterceptors() {
+  interceptors.length = 0;
+  setServerFnFetch(((...a) => fetch(...a)));
+}
+async function fetchWithInterceptors(input, init) {
+  let request = input instanceof Request && !init ? input : new Request(input, init);
+  for (const i of interceptors) if (i.request) request = await i.request(request);
+  let response;
+  try {
+    response = await fetch(request);
+  } catch (error) {
+    for (const i of interceptors) {
+      if (!i.error) continue;
+      const recovered = await i.error(error, request);
+      if (recovered) return recovered;
+    }
+    throw error;
+  }
+  for (const i of interceptors) if (i.response) response = await i.response(response, request);
+  return response;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addInterceptor,
+  clearInterceptors,
+  fetchWithInterceptors
+});

package/dist/interceptors.mjs

@@ -0,0 +1,42 @@
+// src/server-fn.ts
+var _fetch = (...a) => fetch(...a);
+function setServerFnFetch(f) {
+  _fetch = f;
+}
+
+// src/interceptors.ts
+var interceptors = [];
+function addInterceptor(interceptor) {
+  if (interceptors.length === 0) setServerFnFetch(fetchWithInterceptors);
+  interceptors.push(interceptor);
+  return () => {
+    const i = interceptors.indexOf(interceptor);
+    if (i >= 0) interceptors.splice(i, 1);
+  };
+}
+function clearInterceptors() {
+  interceptors.length = 0;
+  setServerFnFetch(((...a) => fetch(...a)));
+}
+async function fetchWithInterceptors(input, init) {
+  let request = input instanceof Request && !init ? input : new Request(input, init);
+  for (const i of interceptors) if (i.request) request = await i.request(request);
+  let response;
+  try {
+    response = await fetch(request);
+  } catch (error) {
+    for (const i of interceptors) {
+      if (!i.error) continue;
+      const recovered = await i.error(error, request);
+      if (recovered) return recovered;
+    }
+    throw error;
+  }
+  for (const i of interceptors) if (i.response) response = await i.response(response, request);
+  return response;
+}
+export {
+  addInterceptor,
+  clearInterceptors,
+  fetchWithInterceptors
+};

package/dist/internal.cjs

@@ -0,0 +1,388 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api.ts
+var api_exports = {};
+__export(api_exports, {
+  API_VIRTUAL_MODULE: () => API_VIRTUAL_MODULE,
+  apiRoutesVitePlugin: () => apiRoutesVitePlugin,
+  derivePattern: () => derivePattern,
+  handleApi: () => handleApi,
+  isApiPath: () => isApiPath,
+  matchApiRoutes: () => matchApiRoutes
+});
+function derivePattern(rel, prefix = "/api") {
+  const segs = rel.split("/").filter(Boolean);
+  if (segs[segs.length - 1] === "index") segs.pop();
+  const keys = [];
+  let rank = 0;
+  const parts = segs.map((seg) => {
+    const catchAll = seg.match(/^\[\.\.\.(.+)\]$/);
+    if (catchAll) {
+      keys.push(catchAll[1]);
+      return "(.+)";
+    }
+    const param = seg.match(/^\[(.+)\]$/);
+    if (param) {
+      keys.push(param[1]);
+      rank += 1;
+      return "([^/]+)";
+    }
+    rank += 10;
+    return seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  });
+  return { source: `^${prefix}${parts.length ? "/" + parts.join("/") : ""}/?$`, keys, rank };
+}
+function isApiPath(pathname, prefix = "/api") {
+  return pathname === prefix || pathname.startsWith(prefix + "/");
+}
+function matchApiRoutes(routes, pathname) {
+  for (const r of [...routes].sort((a, b) => b.rank - a.rank)) {
+    const m = new RegExp(r.source).exec(pathname);
+    if (!m) continue;
+    const params = {};
+    r.keys.forEach((k, i) => params[k] = decodeURIComponent(m[i + 1] ?? ""));
+    return { mod: r.mod, params };
+  }
+  return null;
+}
+async function handleApi(routes, request, prefix = "/api") {
+  const pathname = new URL(request.url).pathname;
+  const match = matchApiRoutes(routes, pathname);
+  if (!match) return new Response("Not Found", { status: 404 });
+  const fn = match.mod[request.method];
+  if (typeof fn !== "function") {
+    const allow = METHODS.filter((m) => typeof match.mod[m] === "function").join(", ");
+    return new Response("Method Not Allowed", { status: 405, headers: allow ? { allow } : void 0 });
+  }
+  const out = await fn(request, { params: match.params });
+  if (out instanceof Response) return out;
+  return new Response(JSON.stringify(out ?? null), { headers: { "content-type": "application/json; charset=utf-8" } });
+}
+function scanFiles(dir, base = dir) {
+  let out = [];
+  let entries = [];
+  try {
+    entries = (0, import_node_fs.readdirSync)(dir);
+  } catch {
+    return out;
+  }
+  for (const name of entries) {
+    const full = (0, import_node_path.join)(dir, name);
+    if ((0, import_node_fs.statSync)(full).isDirectory()) out = out.concat(scanFiles(full, base));
+    else if (/\.(ts|tsx|js|mjs)$/.test(name) && !/\.(spec|test)\./.test(name)) out.push(full);
+  }
+  return out;
+}
+function apiRoutesVitePlugin(opts) {
+  let root = process.cwd();
+  const prefix = opts.prefix ?? "/api";
+  const id = "\0" + API_VMOD;
+  return {
+    name: "fluixi-api",
+    // Must beat node resolution: '@fluixi/start/api-routes' is a real file in this package,
+    // so without `pre` Vite resolves the typed stub and the generated table never loads —
+    // the app builds and every API route 404s.
+    enforce: "pre",
+    configResolved(config) {
+      root = config.root || root;
+    },
+    resolveId(source) {
+      return source === API_VMOD || source === "@fluixi/start/api-routes" ? id : null;
+    },
+    load(source) {
+      if (source !== id) return null;
+      const dir = (0, import_node_path.resolve)(root, opts.dir);
+      const files = scanFiles(dir);
+      const imports = [];
+      const entries = [];
+      files.forEach((file, i) => {
+        const rel = (0, import_node_path.relative)(dir, file).replace(/\.(ts|tsx|js|mjs)$/, "").split(/[\\/]/).join("/");
+        const { source: src, keys, rank } = derivePattern(rel, prefix);
+        imports.push(`import * as _${i} from ${JSON.stringify(file)};`);
+        entries.push(`{ source: ${JSON.stringify(src)}, keys: ${JSON.stringify(keys)}, rank: ${rank}, mod: _${i} }`);
+      });
+      return `import { isApiPath, handleApi } from '@fluixi/start/api';
+${imports.join("\n")}
+const routes = [${entries.join(",")}];
+export const isApiRequest = (request) => isApiPath(new URL(request.url).pathname, ${JSON.stringify(prefix)});
+export const handleApiRequest = (request) => handleApi(routes, request, ${JSON.stringify(prefix)});
+`;
+    }
+  };
+}
+var import_node_fs, import_node_path, API_VMOD, METHODS, API_VIRTUAL_MODULE;
+var init_api = __esm({
+  "src/api.ts"() {
+    "use strict";
+    import_node_fs = require("node:fs");
+    import_node_path = require("node:path");
+    API_VMOD = "virtual:fluixi-api";
+    METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
+    API_VIRTUAL_MODULE = API_VMOD;
+  }
+});
+
+// src/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  I18N_VMOD: () => I18N_VMOD,
+  SERVER_FNS_VMOD: () => SERVER_FNS_VMOD,
+  fluixiPlugins: () => fluixiPlugins,
+  guardHandler: () => guardHandler,
+  i18nVitePlugin: () => i18nVitePlugin,
+  injectApp: () => injectApp,
+  injectAppAndHead: () => injectAppAndHead,
+  installCrashGuards: () => installCrashGuards,
+  loadServerEnv: () => loadServerEnv,
+  splitTemplate: () => splitTemplate,
+  startTypesPlugin: () => startTypesPlugin
+});
+module.exports = __toCommonJS(internal_exports);
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+
+// src/document.ts
+var import_head = require("@fluixi/head");
+function injectApp(template, appHtml, mountId = "root") {
+  const mount = new RegExp(`<div id=["']${mountId}["']\\s*>\\s*</div>`);
+  if (mount.test(template)) {
+    return template.replace(mount, `<div id="${mountId}">${appHtml}</div>`);
+  }
+  if (template.includes("<!--ssr-outlet-->")) {
+    return template.replace("<!--ssr-outlet-->", appHtml);
+  }
+  return template.replace("</body>", `<div id="${mountId}">${appHtml}</div></body>`);
+}
+function splitTemplate(template, mountId = "root") {
+  const mount = new RegExp(`<div id=["']${mountId}["']\\s*>\\s*</div>`);
+  const m = template.match(mount);
+  if (m && m.index !== void 0) {
+    return {
+      head: template.slice(0, m.index) + `<div id="${mountId}">`,
+      tail: `</div>` + template.slice(m.index + m[0].length)
+    };
+  }
+  const outlet = template.indexOf("<!--ssr-outlet-->");
+  if (outlet !== -1) {
+    return {
+      head: template.slice(0, outlet),
+      tail: template.slice(outlet + "<!--ssr-outlet-->".length)
+    };
+  }
+  const body = template.indexOf("</body>");
+  if (body !== -1) {
+    return {
+      head: template.slice(0, body) + `<div id="${mountId}">`,
+      tail: `</div>` + template.slice(body)
+    };
+  }
+  return { head: template, tail: "" };
+}
+function setHtmlAttr(html, name, value) {
+  const existing = new RegExp(`(<html\\b[^>]*?)\\s${name}="[^"]*"`, "i");
+  if (existing.test(html)) return html.replace(existing, `$1 ${name}="${value}"`);
+  return html.replace(/<html\b/i, `<html ${name}="${value}"`);
+}
+function injectAppAndHead(template, rendered, mountId = "root") {
+  const { head, body } = (0, import_head.extractHeadMarker)(rendered);
+  let html = injectApp(template, body, mountId);
+  if (head) {
+    if (head.headHtml) {
+      if (/<title[\s>]/i.test(head.headHtml)) html = html.replace(/<title>[\s\S]*?<\/title>/i, "");
+      html = html.replace("</head>", `${head.headHtml}</head>`);
+    }
+    for (const [k, v] of Object.entries(head.htmlAttrs)) html = setHtmlAttr(html, k, v);
+  }
+  return html;
+}
+function guardHandler(handler, onError) {
+  return async (request) => {
+    try {
+      return await handler(request);
+    } catch (e) {
+      onError?.(e);
+      return new Response(String(e?.stack || e), {
+        status: 500,
+        headers: { "content-type": "text/plain; charset=utf-8" }
+      });
+    }
+  };
+}
+
+// src/internal.ts
+var SERVER_FNS_VMOD = "virtual:fluixi-server-fns";
+var I18N_VMOD = "virtual:fluixi-i18n";
+function i18nVitePlugin(opts) {
+  let root = process.cwd();
+  const id = "\0" + I18N_VMOD;
+  return {
+    name: "fluixi-i18n",
+    configResolved(config) {
+      root = config.root || root;
+    },
+    resolveId(source) {
+      return source === I18N_VMOD ? id : null;
+    },
+    load(source) {
+      if (source !== id) return null;
+      const dir = (0, import_node_path2.resolve)(root, opts.dir);
+      let files = [];
+      try {
+        files = (0, import_node_fs2.readdirSync)(dir).filter((f) => f.endsWith(".json"));
+      } catch {
+      }
+      const discovered = files.map((f) => f.replace(/\.json$/, "")).sort();
+      const locales = opts.locales?.length ? opts.locales : discovered;
+      const defaultLocale = opts.defaultLocale ?? locales[0] ?? "en";
+      const imports = locales.map((l, i) => `import _${i} from ${JSON.stringify((0, import_node_path2.resolve)(dir, l + ".json"))};`).join("\n");
+      const messages = `export const messages = {${locales.map((l, i) => `${JSON.stringify(l)}:_${i}`).join(",")}};`;
+      return `${imports}
+export const locales = ${JSON.stringify(locales)};
+export const defaultLocale = ${JSON.stringify(defaultLocale)};
+${messages}
+`;
+    }
+  };
+}
+async function loadServerEnv(root, mode) {
+  const { loadEnv } = await import("vite");
+  const env = loadEnv(mode, root, "");
+  for (const [k, v] of Object.entries(env)) {
+    if (process.env[k] === void 0) process.env[k] = v;
+  }
+}
+function i18nTypeBlock(root, i18n) {
+  const dir = (0, import_node_path2.resolve)(root, i18n.dir);
+  let discovered = [];
+  try {
+    discovered = (0, import_node_fs2.readdirSync)(dir).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, "")).sort();
+  } catch {
+  }
+  const locales = i18n.locales?.length ? i18n.locales : discovered;
+  const defaultLocale = i18n.defaultLocale ?? locales[0] ?? "en";
+  const typed = locales.length > 0 && locales.every((l) => discovered.includes(l));
+  if (!typed) {
+    return [
+      `declare module 'virtual:fluixi-i18n' {`,
+      `  export const messages: Record<string, Record<string, unknown>>;`,
+      `  export const locales: string[];`,
+      `  export const defaultLocale: string;`,
+      `}`
+    ];
+  }
+  const srcDir = (0, import_node_path2.resolve)(root, "src");
+  const toSpec = (l) => {
+    const rel = (0, import_node_path2.relative)(srcDir, (0, import_node_path2.resolve)(dir, l + ".json")).split(/[\\/]/).join("/");
+    return rel.startsWith(".") ? rel : "./" + rel;
+  };
+  const entries = locales.map((l) => `    ${JSON.stringify(l)}: (typeof import(${JSON.stringify(toSpec(l))}))['default'];`);
+  const tuple = locales.map((l) => JSON.stringify(l)).join(", ");
+  return [
+    `declare module 'virtual:fluixi-i18n' {`,
+    `  export const messages: {`,
+    ...entries,
+    `  };`,
+    `  export const locales: readonly [${tuple}];`,
+    `  export const defaultLocale: ${JSON.stringify(defaultLocale)};`,
+    `}`
+  ];
+}
+function startTypesPlugin(cfg) {
+  let root = process.cwd();
+  return {
+    name: "fluixi-start-types",
+    configResolved(config) {
+      root = config.root || root;
+    },
+    buildStart() {
+      const blocks = [];
+      if (cfg.i18n) blocks.push(...i18nTypeBlock(root, cfg.i18n));
+      if (blocks.length === 0) return;
+      const content = `// Auto-generated by @fluixi/start — do not edit.
+${blocks.join("\n")}
+`;
+      const file = (0, import_node_path2.resolve)(root, "src/fluixi-start-env.d.ts");
+      try {
+        if (!(0, import_node_fs2.existsSync)(file) || (0, import_node_fs2.readFileSync)(file, "utf8") !== content) (0, import_node_fs2.writeFileSync)(file, content);
+      } catch {
+      }
+    }
+  };
+}
+async function fluixiPlugins(cfg) {
+  const { fluixi, fluixiRoutesPlugin } = await import("@fluixi/core/plugins");
+  const { serverFunctionsVitePlugin } = await import("@fluixi/compiler/integrations");
+  const plugins = [
+    serverFunctionsVitePlugin(),
+    fluixiRoutesPlugin({ routesDir: cfg.routesDir, polyfills: false }),
+    // The app's component-resolution rules reach the compiler here; without this an SSR
+    // app has no way to say where an unimported tag comes from.
+    //
+    // `fluixi()` and not `createVitePlugin()`: the latter is the bare compiler integration,
+    // and the reactive graph — agent, source marks, /__fluixi/graph — is composed on top of
+    // it by the former. A start app got no graph at all until this changed.
+    fluixi({ resolve: cfg.resolve })
+  ];
+  if (cfg.i18n) plugins.push(i18nVitePlugin(cfg.i18n));
+  const { apiRoutesVitePlugin: apiRoutesVitePlugin2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+  plugins.push(apiRoutesVitePlugin2({ dir: cfg.apiDir }));
+  plugins.push(startTypesPlugin(cfg));
+  return plugins;
+}
+var _guardsInstalled = false;
+function installCrashGuards() {
+  if (_guardsInstalled) return;
+  _guardsInstalled = true;
+  process.on(
+    "unhandledRejection",
+    (reason) => console.warn("[fluixi] unhandled rejection (backend likely down) —", reason?.message || reason)
+  );
+  process.on(
+    "uncaughtException",
+    (err) => console.warn("[fluixi] uncaught exception —", err?.message || err)
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  I18N_VMOD,
+  SERVER_FNS_VMOD,
+  fluixiPlugins,
+  guardHandler,
+  i18nVitePlugin,
+  injectApp,
+  injectAppAndHead,
+  installCrashGuards,
+  loadServerEnv,
+  splitTemplate,
+  startTypesPlugin
+});

package/dist/internal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGlD,6FAA6F;AAC7F,eAAO,MAAM,eAAe,8BAA8B,CAAC;AAE3D,wGAAwG;AACxG,eAAO,MAAM,SAAS,wBAAwB,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,GAAG,CAoCrG;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM7E;AA6DD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,GAAG,CA0BzD;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAsBvE;AAED,OAAO,EACL,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,YAAY,GACb,MAAM,eAAe,CAAC;AAIvB;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CASzC"}
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGlD,6FAA6F;AAC7F,eAAO,MAAM,eAAe,8BAA8B,CAAC;AAE3D,wGAAwG;AACxG,eAAO,MAAM,SAAS,wBAAwB,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,GAAG,CAoCrG;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM7E;AA6DD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,GAAG,CA0BzD;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CA0BvE;AAED,OAAO,EACL,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,YAAY,GACb,MAAM,eAAe,CAAC;AAIvB;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CASzC"}

package/dist/internal.js

@@ -173,7 +173,7 @@ export function startTypesPlugin(cfg) {
  * bits only (optimizeDeps, ssr.noExternal via config, etc.).
  */
 export async function fluixiPlugins(cfg) {
-    const { createVitePlugin, fluixiRoutesPlugin } = await import('@fluixi/core/plugins');
+    const { fluixi, fluixiRoutesPlugin } = await import('@fluixi/core/plugins');
     const { serverFunctionsVitePlugin } = await import('@fluixi/compiler/integrations');
     // polyfills:false — the meta-framework is SSR-first; the browser node-polyfill shims
     // break server rendering. Apps that need Buffer/process in the browser opt in later.
@@ -184,7 +184,11 @@ export async function fluixiPlugins(cfg) {
         fluixiRoutesPlugin({ routesDir: cfg.routesDir, polyfills: false }),
         // The app's component-resolution rules reach the compiler here; without this an SSR
         // app has no way to say where an unimported tag comes from.
-        createVitePlugin({ resolve: cfg.resolve }),
+        //
+        // `fluixi()` and not `createVitePlugin()`: the latter is the bare compiler integration,
+        // and the reactive graph — agent, source marks, /__fluixi/graph — is composed on top of
+        // it by the former. A start app got no graph at all until this changed.
+        fluixi({ resolve: cfg.resolve }),
     ];
     // Auto-discover translations (src/i18n/<locale>.json → virtual:fluixi-i18n) unless disabled.
     if (cfg.i18n)