@netrojs/fnetro 0.2.21 → 0.3.0

package/dist/server.js

@@ -1,22 +1,61 @@
 // server.ts
 import { Hono } from "hono";
-import { createComponent } from "solid-js";
-import { renderToStringAsync, generateHydrationScript } from "solid-js/web";
-import { Router } from "@solidjs/router";
+import { createSSRApp, defineComponent, h } from "vue";
+import { createRouter, createMemoryHistory, RouterView } from "vue-router";
+import { renderToString, renderToWebStream } from "@vue/server-renderer";
+
+// types.ts
+var SPA_HEADER = "x-fnetro-spa";
+var STATE_KEY = "__FNETRO_STATE__";
+var PARAMS_KEY = "__FNETRO_PARAMS__";
+var SEO_KEY = "__FNETRO_SEO__";
+var DATA_KEY = /* @__PURE__ */ Symbol.for("fnetro:data");
 
 // core.ts
+var VUE_BRANDS = ["__name", "__file", "__vccOpts", "setup", "render", "data", "components"];
+function isAsyncLoader(c) {
+  if (typeof c !== "function") return false;
+  const f = c;
+  for (const brand of VUE_BRANDS) {
+    if (brand in f) return false;
+  }
+  return true;
+}
 function definePage(def) {
   return { __type: "page", ...def };
 }
 function defineGroup(def) {
   return { __type: "group", ...def };
 }
-function defineLayout(Component) {
-  return { __type: "layout", Component };
+function defineLayout(component) {
+  return { __type: "layout", component };
 }
 function defineApiRoute(path, register) {
   return { __type: "api", path, register };
 }
+function compilePath(path) {
+  const keys = [];
+  const src = path.replace(/\[\.\.\.([^\]]+)\]/g, (_, k) => {
+    keys.push(k);
+    return "(.*)";
+  }).replace(/\[([^\]]+)\]/g, (_, k) => {
+    keys.push(k);
+    return "([^/]+)";
+  }).replace(/\*/g, "(.*)");
+  return { re: new RegExp(`^${src}$`), keys };
+}
+function matchPath(cp, pathname) {
+  const m = pathname.match(cp.re);
+  if (!m) return null;
+  const params = {};
+  cp.keys.forEach((k, i) => {
+    params[k] = decodeURIComponent(m[i + 1] ?? "");
+  });
+  return params;
+}
+function toVueRouterPath(fnetroPath) {
+  return fnetroPath.replace(/\[\.\.\.([^\]]+)\]/g, ":$1(.*)*").replace(/\[([^\]]+)\]/g, ":$1");
+}
 function resolveRoutes(routes, options = {}) {
   const pages = [];
   const apis = [];
@@ -27,7 +66,11 @@ function resolveRoutes(routes, options = {}) {
       const prefix = (options.prefix ?? "") + route.prefix;
       const mw = [...options.middleware ?? [], ...route.middleware ?? []];
       const layout = route.layout !== void 0 ? route.layout : options.layout;
-      const sub = resolveRoutes(route.routes, { prefix, middleware: mw, layout });
+      const sub = resolveRoutes(route.routes, {
+        prefix,
+        middleware: mw,
+        ...layout !== void 0 && { layout }
+      });
       pages.push(...sub.pages);
       apis.push(...sub.apis);
     } else {
@@ -41,32 +84,9 @@ function resolveRoutes(routes, options = {}) {
   }
   return { pages, apis };
 }
-function compilePath(path) {
-  const keys = [];
-  const src = path.replace(/\[\.\.\.([^\]]+)\]/g, (_, k) => {
-    keys.push(k);
-    return "(.*)";
-  }).replace(/\[([^\]]+)\]/g, (_, k) => {
-    keys.push(k);
-    return "([^/]+)";
-  }).replace(/\*/g, "(.*)");
-  return { re: new RegExp(`^${src}$`), keys };
-}
-function matchPath(compiled, pathname) {
-  const m = pathname.match(compiled.re);
-  if (!m) return null;
-  const params = {};
-  compiled.keys.forEach((k, i) => {
-    params[k] = decodeURIComponent(m[i + 1] ?? "");
-  });
-  return params;
-}
-var SPA_HEADER = "x-fnetro-spa";
-var STATE_KEY = "__FNETRO_STATE__";
-var PARAMS_KEY = "__FNETRO_PARAMS__";
-var SEO_KEY = "__FNETRO_SEO__";
 
 // server.ts
+import { build } from "vite";
 function esc(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
@@ -85,33 +105,19 @@ function buildHeadMeta(seo, extraHead = "") {
   if (seo.ogDescription) parts.push(p("og:description", seo.ogDescription));
   if (seo.ogImage) parts.push(p("og:image", seo.ogImage));
   if (seo.ogImageAlt) parts.push(p("og:image:alt", seo.ogImageAlt));
-  if (seo.ogImageWidth) parts.push(p("og:image:width", seo.ogImageWidth));
-  if (seo.ogImageHeight) parts.push(p("og:image:height", seo.ogImageHeight));
   if (seo.ogUrl) parts.push(p("og:url", seo.ogUrl));
   if (seo.ogType) parts.push(p("og:type", seo.ogType));
   if (seo.ogSiteName) parts.push(p("og:site_name", seo.ogSiteName));
-  if (seo.ogLocale) parts.push(p("og:locale", seo.ogLocale));
   if (seo.twitterCard) parts.push(m("twitter:card", seo.twitterCard));
   if (seo.twitterSite) parts.push(m("twitter:site", seo.twitterSite));
-  if (seo.twitterCreator) parts.push(m("twitter:creator", seo.twitterCreator));
   if (seo.twitterTitle) parts.push(m("twitter:title", seo.twitterTitle));
   if (seo.twitterDescription) parts.push(m("twitter:description", seo.twitterDescription));
   if (seo.twitterImage) parts.push(m("twitter:image", seo.twitterImage));
-  if (seo.twitterImageAlt) parts.push(m("twitter:image:alt", seo.twitterImageAlt));
-  for (const tag of seo.extra ?? []) {
-    const attrs = [
-      tag.name ? `name="${esc(tag.name)}"` : "",
-      tag.property ? `property="${esc(tag.property)}"` : "",
-      tag.httpEquiv ? `http-equiv="${esc(tag.httpEquiv)}"` : "",
-      `content="${esc(tag.content)}"`
-    ].filter(Boolean).join(" ");
-    parts.push(`<meta ${attrs}>`);
-  }
   const ld = seo.jsonLd;
   if (ld) {
     const schemas = Array.isArray(ld) ? ld : [ld];
-    for (const schema of schemas) {
-      parts.push(`<script type="application/ld+json">${JSON.stringify(schema)}</script>`);
+    for (const s of schemas) {
+      parts.push(`<script type="application/ld+json">${JSON.stringify(s)}</script>`);
     }
   }
   if (extraHead) parts.push(extraHead);
@@ -120,103 +126,118 @@ function buildHeadMeta(seo, extraHead = "") {
 function mergeSEO(base, override) {
   return { ...base ?? {}, ...override ?? {} };
 }
-var _assets = null;
+var _assetsCache = null;
 async function resolveAssets(cfg, defaultEntry) {
-  if (_assets) return _assets;
+  if (_assetsCache) return _assetsCache;
   if (cfg.manifestDir) {
     try {
       const [{ readFileSync }, { join }] = await Promise.all([
         import("fs"),
         import("path")
       ]);
-      const raw = readFileSync(join(cfg.manifestDir, "manifest.json"), "utf-8");
+      const raw = readFileSync(join(cfg.manifestDir, ".vite", "manifest.json"), "utf-8");
       const manifest = JSON.parse(raw);
-      const entryKey = cfg.manifestEntry ?? Object.keys(manifest).find((k) => k.endsWith(defaultEntry)) ?? defaultEntry;
-      const entry = manifest[entryKey];
+      const key = cfg.manifestEntry ?? Object.keys(manifest).find((k) => k.endsWith(defaultEntry)) ?? defaultEntry;
+      const entry = manifest[key];
       if (entry) {
-        _assets = {
+        _assetsCache = {
           scripts: [`/assets/${entry.file}`],
           styles: (entry.css ?? []).map((f) => `/assets/${f}`)
         };
-        return _assets;
+        return _assetsCache;
       }
     } catch {
     }
   }
-  _assets = {
+  _assetsCache = {
     scripts: cfg.scripts ?? ["/assets/client.js"],
     styles: cfg.styles ?? []
   };
-  return _assets;
+  return _assetsCache;
 }
-function buildShell(o) {
-  const htmlAttrStr = Object.entries(o.htmlAttrs ?? { lang: "en" }).map(([k, v]) => `${k}="${esc(v)}"`).join(" ");
-  const styleLinks = o.styles.map((href) => `<link rel="stylesheet" href="${esc(href)}">`).join("\n");
-  const scriptTags = o.scripts.map((src) => `<script type="module" src="${esc(src)}"></script>`).join("\n");
-  return [
+function buildShellParts(title, metaHtml, stateJson, paramsJson, seoJson, scripts, styles, htmlAttrs) {
+  const attrs = Object.entries(htmlAttrs ?? { lang: "en" }).map(([k, v]) => `${k}="${esc(v)}"`).join(" ");
+  const styleLinks = styles.map((href) => `<link rel="stylesheet" href="${esc(href)}">`).join("\n");
+  const scriptTags = scripts.map((src) => `<script type="module" src="${esc(src)}"></script>`).join("\n");
+  const head = [
     "<!DOCTYPE html>",
-    `<html ${htmlAttrStr}>`,
+    `<html ${attrs}>`,
     "<head>",
     '<meta charset="UTF-8">',
     '<meta name="viewport" content="width=device-width,initial-scale=1">',
-    `<title>${esc(o.title)}</title>`,
-    o.metaHtml,
-    generateHydrationScript(),
+    `<title>${esc(title)}</title>`,
+    metaHtml,
     styleLinks,
     "</head>",
     "<body>",
-    `<div id="fnetro-app">${o.bodyHtml}</div>`,
+    '<div id="fnetro-app">'
+  ].filter(Boolean).join("\n");
+  const tail = [
+    "</div>",
     "<script>",
-    `window.${STATE_KEY}=${o.stateJson};`,
-    `window.${PARAMS_KEY}=${o.paramsJson};`,
-    `window.${SEO_KEY}=${o.seoJson};`,
+    `window.${STATE_KEY}=${stateJson};`,
+    `window.${PARAMS_KEY}=${paramsJson};`,
+    `window.${SEO_KEY}=${seoJson};`,
     "</script>",
     scriptTags,
     "</body>",
     "</html>"
-  ].filter(Boolean).join("\n");
+  ].join("\n");
+  return { head, tail };
+}
+async function resolveComponent(comp) {
+  if (isAsyncLoader(comp)) {
+    const mod = await comp();
+    return mod.default ?? mod;
+  }
+  return comp;
 }
 async function renderPage(route, data, url, params, appLayout) {
   const layout = route.layout !== void 0 ? route.layout : appLayout;
-  return renderToStringAsync(() => {
-    const pageEl = createComponent(route.page.Page, { ...data, url, params });
-    const content = layout ? createComponent(layout.Component, {
-      url,
-      params,
-      get children() {
-        return pageEl;
-      }
-    }) : pageEl;
-    return createComponent(Router, {
-      url,
-      get children() {
-        return content;
-      }
-    });
+  const PageComp = await resolveComponent(route.page.component);
+  const routeComp = layout ? defineComponent({
+    name: "FNetroRoute",
+    setup: () => () => h(layout.component, null, {
+      default: () => h(PageComp)
+    })
+  }) : PageComp;
+  const app = createSSRApp({ render: () => h(RouterView) });
+  app.provide(DATA_KEY, data);
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [{ path: toVueRouterPath(route.fullPath), component: routeComp }]
   });
+  app.use(router);
+  await router.push(url);
+  await router.isReady();
+  return renderToWebStream(app);
 }
-async function renderFullPage(route, data, url, params, config, assets) {
-  const pageSEO = typeof route.page.seo === "function" ? route.page.seo(data, params) : route.page.seo;
-  const seo = mergeSEO(config.seo, pageSEO);
-  const title = seo.title ?? "FNetro";
-  const bodyHtml = await renderPage(route, data, url, params, config.layout);
-  return buildShell({
-    title,
-    metaHtml: buildHeadMeta(seo, config.head),
-    bodyHtml,
-    stateJson: JSON.stringify({ [url]: data }),
-    paramsJson: JSON.stringify(params),
-    seoJson: JSON.stringify(seo),
-    scripts: assets.scripts,
-    styles: assets.styles,
-    htmlAttrs: config.htmlAttrs
-  });
+function buildResponseStream(headHtml, bodyStream, tailHtml) {
+  const enc = new TextEncoder();
+  const { readable, writable } = new TransformStream();
+  (async () => {
+    const writer = writable.getWriter();
+    try {
+      await writer.write(enc.encode(headHtml));
+      const reader = bodyStream.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        await writer.write(value);
+      }
+      await writer.write(enc.encode(tailHtml));
+      await writer.close();
+    } catch (err) {
+      await writer.abort(err);
+    }
+  })();
+  return readable;
 }
 function createFNetro(config) {
   const app = new Hono();
   for (const mw of config.middleware ?? []) app.use("*", mw);
   const { pages, apis } = resolveRoutes(config.routes, {
-    layout: config.layout,
+    ...config.layout !== void 0 && { layout: config.layout },
     middleware: []
   });
   const compiled = pages.map((r) => ({ route: r, cp: compilePath(r.fullPath) }));
@@ -240,45 +261,57 @@ function createFNetro(config) {
     }
     if (!matched) {
       if (config.notFound) {
-        const html2 = await renderToStringAsync(
-          () => createComponent(config.notFound, {})
-        );
-        return c.html(
-          `<!DOCTYPE html><html lang="en"><body>${html2}</body></html>`,
-          404
-        );
+        const html = await renderToString(createSSRApp(config.notFound));
+        return c.html(`<!DOCTYPE html><html lang="en"><body>${html}</body></html>`, 404);
       }
       return c.text("Not Found", 404);
     }
     const { route, params } = matched;
     const origParam = c.req.param.bind(c.req);
     c.req["param"] = (key) => key != null ? params[key] ?? origParam(key) : { ...origParam(), ...params };
-    let early;
-    const handlers = [...route.middleware];
+    let earlyResponse;
     let idx = 0;
     const runNext = async () => {
-      const mw = handlers[idx++];
+      const mw = route.middleware[idx++];
       if (!mw) return;
       const res = await mw(c, runNext);
-      if (res instanceof Response && !early) early = res;
+      if (res instanceof Response && !earlyResponse) earlyResponse = res;
     };
     await runNext();
-    if (early) return early;
+    if (earlyResponse) return earlyResponse;
     const rawData = route.page.loader ? await route.page.loader(c) : {};
     const data = rawData ?? {};
     if (isSPA) {
-      const pageSEO = typeof route.page.seo === "function" ? route.page.seo(data, params) : route.page.seo;
+      const pageSEO2 = typeof route.page.seo === "function" ? route.page.seo(data, params) : route.page.seo;
       return c.json({
         state: data,
         params,
         url: pathname,
-        seo: mergeSEO(config.seo, pageSEO)
+        seo: mergeSEO(config.seo, pageSEO2)
       });
     }
     const clientEntry = config.assets?.manifestEntry ?? "client.ts";
     const assets = isDev ? { scripts: [`/${clientEntry}`], styles: [] } : await resolveAssets(config.assets ?? {}, clientEntry);
-    const html = await renderFullPage(route, data, pathname, params, config, assets);
-    return c.html(html);
+    const pageSEO = typeof route.page.seo === "function" ? route.page.seo(data, params) : route.page.seo;
+    const seo = mergeSEO(config.seo, pageSEO);
+    const title = seo.title ?? "FNetro";
+    const { head, tail } = buildShellParts(
+      title,
+      buildHeadMeta(seo, config.head),
+      JSON.stringify({ [pathname]: data }),
+      JSON.stringify(params),
+      JSON.stringify(seo),
+      assets.scripts,
+      assets.styles,
+      config.htmlAttrs
+    );
+    const bodyStream = await renderPage(route, data, pathname, params, config.layout);
+    const stream = buildResponseStream(head, bodyStream, tail);
+    return c.body(stream, 200, {
+      "Content-Type": "text/html; charset=UTF-8",
+      "Transfer-Encoding": "chunked",
+      "X-Content-Type-Options": "nosniff"
+    });
   });
   return { app, handler: app.fetch.bind(app) };
 }
@@ -295,7 +328,7 @@ async function serve(opts) {
   const staticDir = opts.staticDir ?? "./dist";
   const displayHost = hostname === "0.0.0.0" ? "localhost" : hostname;
   const logReady = () => console.log(`
-\u{1F525}  FNetro [${runtime}] ready \u2192 http://${displayHost}:${port}
+\u{1F525}  FNetro [${runtime}] \u2192 http://${displayHost}:${port}
 `);
   switch (runtime) {
     case "node": {
@@ -309,38 +342,21 @@ async function serve(opts) {
       logReady();
       break;
     }
-    case "bun": {
+    case "bun":
       ;
       globalThis["Bun"].serve({ fetch: opts.app.handler, port, hostname });
       logReady();
       break;
-    }
-    case "deno": {
+    case "deno":
       ;
       globalThis["Deno"].serve({ port, hostname }, opts.app.handler);
       logReady();
       break;
-    }
     default:
-      console.warn(
-        "[fnetro] serve() is a no-op on edge runtimes \u2014 export `fnetro.handler` instead."
-      );
+      console.warn("[fnetro] serve() is a no-op on edge \u2014 export fnetro.handler instead.");
   }
 }
 var NODE_BUILTINS = /^node:|^(assert|buffer|child_process|cluster|crypto|dgram|dns|domain|events|fs|http|https|module|net|os|path|perf_hooks|process|punycode|querystring|readline|repl|stream|string_decoder|sys|timers|tls|trace_events|tty|url|util|v8|vm|worker_threads|zlib)$/;
-async function loadSolid() {
-  try {
-    const mod = await import("vite-plugin-solid");
-    return mod.default ?? mod;
-  } catch {
-    throw new Error(
-      "[fnetro] vite-plugin-solid is required.\n  Install it: npm i -D vite-plugin-solid"
-    );
-  }
-}
-function toPlugins(v) {
-  return Array.isArray(v) ? v : [v];
-}
 function fnetroVitePlugin(opts = {}) {
   const {
     serverEntry = "server.ts",
@@ -348,85 +364,46 @@ function fnetroVitePlugin(opts = {}) {
     serverOutDir = "dist/server",
     clientOutDir = "dist/assets",
     serverExternal = [],
-    solidOptions = {}
+    vueOptions = {}
   } = opts;
-  let _solid = null;
-  let _solidPlugins = [];
-  const jsxPlugin = {
-    name: "fnetro:jsx",
-    enforce: "pre",
-    // Sync config hook — must return Omit<UserConfig, 'plugins'> | null
-    // Note: Vite 6+ deprecated `esbuild.jsx`; Vite 8 uses `oxc` instead.
-    config(_cfg, env) {
-      return {
-        oxc: {
-          jsx: "automatic",
-          jsxImportSource: "solid-js"
-        }
-      };
-    },
-    async buildStart() {
-      if (!_solid) {
-        _solid = await loadSolid();
-        _solidPlugins = toPlugins(_solid({ ssr: true, ...solidOptions }));
-      }
-    }
-  };
-  const solidProxy = {
-    name: "fnetro:solid-proxy",
-    enforce: "pre",
-    async transform(code, id, options) {
-      if (!_solidPlugins[0]?.transform) return null;
-      const hook = _solidPlugins[0].transform;
-      const fn = typeof hook === "function" ? hook : hook.handler;
-      if (!fn) return null;
-      return fn.call(this, code, id, options);
-    },
-    async resolveId(id) {
-      if (!_solidPlugins[0]?.resolveId) return null;
-      const hook = _solidPlugins[0].resolveId;
-      const fn = typeof hook === "function" ? hook : hook.handler;
-      if (!fn) return null;
-      return fn.call(this, id, void 0, {});
-    },
-    async load(id) {
-      if (!_solidPlugins[0]?.load) return null;
-      const hook = _solidPlugins[0].load;
-      const fn = typeof hook === "function" ? hook : hook.handler;
-      if (!fn) return null;
-      return fn.call(this, id, {});
-    }
-  };
-  const buildPlugin = {
+  return {
     name: "fnetro:build",
     apply: "build",
     enforce: "pre",
-    // Sync config hook — Omit<UserConfig, 'plugins'> satisfies the ObjectHook constraint
-    config(_cfg, _env) {
+    // Server (SSR) bundle configuration
+    config() {
       return {
         build: {
           ssr: serverEntry,
           outDir: serverOutDir,
           rollupOptions: {
             input: serverEntry,
-            output: {
-              format: "es",
-              entryFileNames: "server.js"
-            },
-            external: (id) => NODE_BUILTINS.test(id) || id === "@hono/node-server" || id === "@hono/node-server/serve-static" || id === "@solidjs/router" || id.startsWith("@solidjs/router/") || serverExternal.includes(id)
+            output: { format: "es", entryFileNames: "server.js" },
+            external: (id) => NODE_BUILTINS.test(id) || id === "vue" || id.startsWith("vue/") || id === "vue-router" || id === "@vue/server-renderer" || id === "@vitejs/plugin-vue" || id === "@hono/node-server" || id === "@hono/node-server/serve-static" || serverExternal.includes(id)
           }
         }
       };
     },
+    // After the server bundle is written, trigger the client SPA build
     async closeBundle() {
       console.log("\n\u26A1  FNetro: building client bundle\u2026\n");
-      const solid = _solid ?? await loadSolid();
-      const { build } = await import("vite");
+      let vuePlugin;
+      try {
+        const mod = await import("@vitejs/plugin-vue");
+        const factory = mod.default ?? mod;
+        vuePlugin = factory(vueOptions);
+      } catch {
+        throw new Error(
+          "[fnetro] @vitejs/plugin-vue is required for the client build.\n  Install: npm i -D @vitejs/plugin-vue"
+        );
+      }
+      const plugins = Array.isArray(vuePlugin) ? vuePlugin : [vuePlugin];
       await build({
         configFile: false,
-        plugins: toPlugins(solid({ ...solidOptions })),
+        plugins,
         build: {
           outDir: clientOutDir,
+          // Vite 5+ writes manifest to <outDir>/.vite/manifest.json
           manifest: true,
           rollupOptions: {
             input: clientEntry,
@@ -442,9 +419,9 @@ function fnetroVitePlugin(opts = {}) {
       console.log("\u2705  FNetro: both bundles ready\n");
     }
   };
-  return [jsxPlugin, solidProxy, buildPlugin];
 }
 export {
+  DATA_KEY,
   PARAMS_KEY,
   SEO_KEY,
   SPA_HEADER,
@@ -457,7 +434,9 @@ export {
   definePage,
   detectRuntime,
   fnetroVitePlugin,
+  isAsyncLoader,
   matchPath,
   resolveRoutes,
-  serve
+  serve,
+  toVueRouterPath
 };

package/dist/types.d.ts

@@ -0,0 +1,99 @@
+import { Component } from 'vue';
+import { Hono, MiddlewareHandler, Context } from 'hono';
+
+type HonoMiddleware = MiddlewareHandler;
+type LoaderCtx = Context;
+interface SEOMeta {
+    title?: string;
+    description?: string;
+    keywords?: string;
+    author?: string;
+    robots?: string;
+    canonical?: string;
+    themeColor?: string;
+    ogTitle?: string;
+    ogDescription?: string;
+    ogImage?: string;
+    ogImageAlt?: string;
+    ogUrl?: string;
+    ogType?: string;
+    ogSiteName?: string;
+    twitterCard?: 'summary' | 'summary_large_image' | 'app' | 'player';
+    twitterSite?: string;
+    twitterTitle?: string;
+    twitterDescription?: string;
+    twitterImage?: string;
+    /** Structured data injected as <script type="application/ld+json">. */
+    jsonLd?: Record<string, unknown> | Record<string, unknown>[];
+}
+type AsyncLoader = () => Promise<{
+    default: Component;
+} | Component>;
+interface PageDef<TData extends object = Record<string, never>> {
+    readonly __type: 'page';
+    path: string;
+    middleware?: HonoMiddleware[];
+    loader?: (c: LoaderCtx) => TData | Promise<TData>;
+    seo?: SEOMeta | ((data: TData, params: Record<string, string>) => SEOMeta);
+    /** Override or disable the app-level layout for this route. */
+    layout?: LayoutDef | false;
+    /**
+     * The Vue component to render for this route.
+     * Use () => import('./Page.vue') for automatic code splitting.
+     */
+    component: Component | AsyncLoader;
+}
+interface GroupDef {
+    readonly __type: 'group';
+    prefix: string;
+    layout?: LayoutDef | false;
+    middleware?: HonoMiddleware[];
+    routes: Route[];
+}
+interface LayoutDef {
+    readonly __type: 'layout';
+    /** Vue layout component — must contain <slot /> for page content. */
+    component: Component;
+}
+interface ApiRouteDef {
+    readonly __type: 'api';
+    path: string;
+    register: (app: Hono, globalMiddleware: HonoMiddleware[]) => void;
+}
+type Route = PageDef<any> | GroupDef | ApiRouteDef;
+interface AppConfig {
+    layout?: LayoutDef;
+    seo?: SEOMeta;
+    middleware?: HonoMiddleware[];
+    routes: Route[];
+    notFound?: Component;
+    htmlAttrs?: Record<string, string>;
+    /** Extra HTML injected into <head> (e.g. font preloads). */
+    head?: string;
+}
+interface ResolvedRoute {
+    fullPath: string;
+    page: PageDef<any>;
+    layout: LayoutDef | false | undefined;
+    middleware: HonoMiddleware[];
+}
+interface CompiledPath {
+    re: RegExp;
+    keys: string[];
+}
+type ClientMiddleware = (url: string, next: () => Promise<void>) => Promise<void>;
+/** Custom request header that identifies an SPA navigation (JSON payload). */
+declare const SPA_HEADER = "x-fnetro-spa";
+/** window key for SSR-injected per-page loader data. */
+declare const STATE_KEY = "__FNETRO_STATE__";
+/** window key for SSR-injected URL params. */
+declare const PARAMS_KEY = "__FNETRO_PARAMS__";
+/** window key for SSR-injected SEO meta. */
+declare const SEO_KEY = "__FNETRO_SEO__";
+/**
+ * Vue provide/inject key for the reactive page-data object.
+ * Symbol.for() ensures the same reference across module instances (SSR safe).
+ */
+declare const DATA_KEY: unique symbol;
+
+export { type ApiRouteDef, type AppConfig, type AsyncLoader, type ClientMiddleware, type CompiledPath, DATA_KEY, type GroupDef, type HonoMiddleware, type LayoutDef, type LoaderCtx, PARAMS_KEY, type PageDef, type ResolvedRoute, type Route, type SEOMeta, SEO_KEY, SPA_HEADER, STATE_KEY };