npm - @netrojs/vono - Versions diffs - 0.0.1 - Mend

@netrojs/vono 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/dist/server.d.ts ADDED Viewed

@@ -0,0 +1,212 @@
+import { Hono, MiddlewareHandler, Context } from 'hono';
+import { Component } from 'vue';
+import { Plugin } from 'vite';
+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-vono-spa";
+/** window key for SSR-injected per-page loader data. */
+declare const STATE_KEY = "__VONO_STATE__";
+/** window key for SSR-injected URL params. */
+declare const PARAMS_KEY = "__VONO_PARAMS__";
+/** window key for SSR-injected SEO meta. */
+declare const SEO_KEY = "__VONO_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;
+/**
+ * Extract the loader data type from a `PageDef` returned by `definePage()`.
+ *
+ * This enables you to define the data type exactly once — inferred from the
+ * loader — and import it into page components for `usePageData<T>()`.
+ *
+ * @example
+ * // app/routes.ts
+ * export const homePage = definePage({
+ *   path: '/',
+ *   loader: async () => ({ title: 'Hello', count: 42 }),
+ *   component: () => import('./pages/home.vue'),
+ * })
+ * export type HomeData = InferPageData<typeof homePage>
+ * // HomeData = { title: string; count: number }
+ *
+ * // app/pages/home.vue
+ * import type { HomeData } from '../routes'
+ * const data = usePageData<HomeData>()
+ */
+type InferPageData<T> = T extends PageDef<infer D> ? D : never;
+/**
+ * Returns true when `c` is an async factory function (i.e. `() => import(...)`)
+ * rather than a resolved Vue component object.
+ *
+ * Used by both server.ts (to resolve the import before SSR) and client.ts
+ * (to wrap with defineAsyncComponent for lazy hydration).
+ */
+declare function isAsyncLoader(c: unknown): c is AsyncLoader;
+/**
+ * Define a page route with full type inference.
+ *
+ * TypeScript infers `TData` automatically from the `loader` return type, so
+ * you rarely need to supply the generic manually.  Export the page constant and
+ * use `InferPageData<typeof myPage>` in your component for a single source of
+ * truth.
+ *
+ * @example
+ * export const postPage = definePage({
+ *   path:      '/post/[slug]',
+ *   loader:    async (c) => fetchPost(c.req.param('slug')),
+ *   component: () => import('./pages/post.vue'),
+ * })
+ * export type PostData = InferPageData<typeof postPage>
+ */
+declare function definePage<TData extends object = Record<string, never>>(def: Omit<PageDef<TData>, '__type'>): PageDef<TData>;
+declare function defineGroup(def: Omit<GroupDef, '__type'>): GroupDef;
+/** Wrap a Vue layout component (must render <slot />) as a Vono layout. */
+declare function defineLayout(component: Component): LayoutDef;
+declare function defineApiRoute(path: string, register: ApiRouteDef['register']): ApiRouteDef;
+declare function compilePath(path: string): CompiledPath;
+declare function matchPath(cp: CompiledPath, pathname: string): Record<string, string> | null;
+/**
+ * Convert Vono `[param]` syntax to Vue Router `:param` syntax.
+ *
+ * `/posts/[slug]`    → `/posts/:slug`
+ * `/files/[...path]` → `/files/:path(.*)*`
+ */
+declare function toVueRouterPath(vonoPath: string): string;
+declare function resolveRoutes(routes: Route[], options?: {
+    prefix?: string;
+    middleware?: HonoMiddleware[];
+    layout?: LayoutDef | false;
+}): {
+    pages: ResolvedRoute[];
+    apis: ApiRouteDef[];
+};
+interface AssetConfig {
+    scripts?: string[];
+    styles?: string[];
+    /** Directory containing the Vite-built assets and .vite/manifest.json. */
+    manifestDir?: string;
+    manifestEntry?: string;
+}
+interface VonoOptions extends AppConfig {
+    assets?: AssetConfig;
+}
+interface VonoApp {
+    /** The Hono instance — attach extra routes, error handlers, middleware. */
+    app: Hono;
+    /** WinterCG-compatible fetch handler for edge runtimes. */
+    handler: typeof Hono.prototype.fetch;
+}
+declare function createVono(config: VonoOptions): VonoApp;
+type Runtime = 'node' | 'bun' | 'deno' | 'edge';
+declare function detectRuntime(): Runtime;
+interface ServeOptions {
+    app: VonoApp;
+    port?: number;
+    hostname?: string;
+    runtime?: Runtime;
+    /** Root directory that contains the built assets and public files. */
+    staticDir?: string;
+}
+declare function serve(opts: ServeOptions): Promise<void>;
+interface VonoPluginOptions {
+    /** Server entry file.             @default 'server.ts' */
+    serverEntry?: string;
+    /** Client entry file.             @default 'client.ts' */
+    clientEntry?: string;
+    /** Server bundle output dir.      @default 'dist/server' */
+    serverOutDir?: string;
+    /** Client assets output dir.      @default 'dist/assets' */
+    clientOutDir?: string;
+    /** Extra packages external to the server bundle. */
+    serverExternal?: string[];
+    /** Options forwarded to @vitejs/plugin-vue in the client build. */
+    vueOptions?: Record<string, unknown>;
+}
+declare function vonoVitePlugin(opts?: VonoPluginOptions): Plugin;
+export { type ApiRouteDef, type AppConfig, type AssetConfig, type AsyncLoader, type ClientMiddleware, type CompiledPath, DATA_KEY, type GroupDef, type HonoMiddleware, type InferPageData, type LayoutDef, type LoaderCtx, PARAMS_KEY, type PageDef, type ResolvedRoute, type Route, type Runtime, type SEOMeta, SEO_KEY, SPA_HEADER, STATE_KEY, type ServeOptions, type VonoApp, type VonoOptions, type VonoPluginOptions, compilePath, createVono, defineApiRoute, defineGroup, defineLayout, definePage, detectRuntime, isAsyncLoader, matchPath, resolveRoutes, serve, toVueRouterPath, vonoVitePlugin };

package/dist/server.js ADDED Viewed

@@ -0,0 +1,451 @@
+// server.ts
+import { Hono } from "hono";
+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-vono-spa";
+var STATE_KEY = "__VONO_STATE__";
+var PARAMS_KEY = "__VONO_PARAMS__";
+var SEO_KEY = "__VONO_SEO__";
+var DATA_KEY = /* @__PURE__ */ Symbol.for("vono: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 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(vonoPath) {
+  return vonoPath.replace(/\[\.\.\.([^\]]+)\]/g, ":$1(.*)*").replace(/\[([^\]]+)\]/g, ":$1");
+}
+function resolveRoutes(routes, options = {}) {
+  const pages = [];
+  const apis = [];
+  for (const route of routes) {
+    if (route.__type === "api") {
+      apis.push({ ...route, path: (options.prefix ?? "") + route.path });
+    } else if (route.__type === "group") {
+      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 !== void 0 && { layout }
+      });
+      pages.push(...sub.pages);
+      apis.push(...sub.apis);
+    } else {
+      pages.push({
+        fullPath: (options.prefix ?? "") + route.path,
+        page: route,
+        layout: route.layout !== void 0 ? route.layout : options.layout,
+        middleware: [...options.middleware ?? [], ...route.middleware ?? []]
+      });
+    }
+  }
+  return { pages, apis };
+}
+// server.ts
+import { build } from "vite";
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function buildHeadMeta(seo, extraHead = "") {
+  const m = (n, v) => v ? `<meta name="${n}" content="${esc(v)}">` : "";
+  const p = (pr, v) => v ? `<meta property="${pr}" content="${esc(v)}">` : "";
+  const lk = (rel, href) => `<link rel="${rel}" href="${esc(href)}">`;
+  const parts = [];
+  if (seo.description) parts.push(m("description", seo.description));
+  if (seo.keywords) parts.push(m("keywords", seo.keywords));
+  if (seo.author) parts.push(m("author", seo.author));
+  if (seo.robots) parts.push(m("robots", seo.robots));
+  if (seo.themeColor) parts.push(m("theme-color", seo.themeColor));
+  if (seo.canonical) parts.push(lk("canonical", seo.canonical));
+  if (seo.ogTitle) parts.push(p("og:title", seo.ogTitle));
+  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.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.twitterCard) parts.push(m("twitter:card", seo.twitterCard));
+  if (seo.twitterSite) parts.push(m("twitter:site", seo.twitterSite));
+  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));
+  const ld = seo.jsonLd;
+  if (ld) {
+    const schemas = Array.isArray(ld) ? ld : [ld];
+    for (const s of schemas) {
+      parts.push(`<script type="application/ld+json">${JSON.stringify(s)}</script>`);
+    }
+  }
+  if (extraHead) parts.push(extraHead);
+  return parts.join("\n");
+}
+function mergeSEO(base, override) {
+  return { ...base ?? {}, ...override ?? {} };
+}
+var _assetsCache = null;
+async function resolveAssets(cfg, defaultEntry) {
+  if (_assetsCache) return _assetsCache;
+  if (cfg.manifestDir) {
+    try {
+      const [{ readFileSync }, { join }] = await Promise.all([
+        import("fs"),
+        import("path")
+      ]);
+      const raw = readFileSync(join(cfg.manifestDir, ".vite", "manifest.json"), "utf-8");
+      const manifest = JSON.parse(raw);
+      const key = cfg.manifestEntry ?? Object.keys(manifest).find((k) => k.endsWith(defaultEntry)) ?? defaultEntry;
+      const entry = manifest[key];
+      if (entry) {
+        _assetsCache = {
+          scripts: [`/assets/${entry.file}`],
+          styles: (entry.css ?? []).map((f) => `/assets/${f}`)
+        };
+        return _assetsCache;
+      }
+    } catch {
+    }
+  }
+  _assetsCache = {
+    scripts: cfg.scripts ?? ["/assets/client.js"],
+    styles: cfg.styles ?? []
+  };
+  return _assetsCache;
+}
+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 ${attrs}>`,
+    "<head>",
+    '<meta charset="UTF-8">',
+    '<meta name="viewport" content="width=device-width,initial-scale=1">',
+    `<title>${esc(title)}</title>`,
+    metaHtml,
+    styleLinks,
+    "</head>",
+    "<body>",
+    '<div id="vono-app">'
+  ].filter(Boolean).join("\n");
+  const tail = [
+    "</div>",
+    "<script>",
+    `window.${STATE_KEY}=${stateJson};`,
+    `window.${PARAMS_KEY}=${paramsJson};`,
+    `window.${SEO_KEY}=${seoJson};`,
+    "</script>",
+    scriptTags,
+    "</body>",
+    "</html>"
+  ].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;
+  const PageComp = await resolveComponent(route.page.component);
+  const routeComp = layout ? defineComponent({
+    name: "VonoRoute",
+    setup: () => () => h(layout.component, null, {
+      default: () => h(PageComp)
+    })
+  }) : PageComp;
+  const app = createSSRApp({ render: () => h(RouterView) });
+  app.provide(DATA_KEY, data);
+  const memHistory = createMemoryHistory();
+  memHistory.replace(url);
+  const router = createRouter({
+    history: memHistory,
+    routes: [{ path: toVueRouterPath(route.fullPath), component: routeComp }]
+  });
+  app.use(router);
+  await router.isReady();
+  return renderToWebStream(app);
+}
+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 createVono(config) {
+  const app = new Hono();
+  for (const mw of config.middleware ?? []) app.use("*", mw);
+  const { pages, apis } = resolveRoutes(config.routes, {
+    ...config.layout !== void 0 && { layout: config.layout },
+    middleware: []
+  });
+  const compiled = pages.map((r) => ({ route: r, cp: compilePath(r.fullPath) }));
+  for (const api of apis) {
+    const sub = new Hono();
+    api.register(sub, config.middleware ?? []);
+    app.route(api.path, sub);
+  }
+  app.all("*", async (c) => {
+    const url = new URL(c.req.url);
+    const pathname = url.pathname;
+    const isSPA = c.req.header(SPA_HEADER) === "1";
+    const isDev = process.env["NODE_ENV"] !== "production";
+    let matched = null;
+    for (const { route: route2, cp } of compiled) {
+      const params2 = matchPath(cp, pathname);
+      if (params2 !== null) {
+        matched = { route: route2, params: params2 };
+        break;
+      }
+    }
+    if (!matched) {
+      if (config.notFound) {
+        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 earlyResponse;
+    let idx = 0;
+    const runNext = async () => {
+      const mw = route.middleware[idx++];
+      if (!mw) return;
+      const res = await mw(c, runNext);
+      if (res instanceof Response && !earlyResponse) earlyResponse = res;
+    };
+    await runNext();
+    if (earlyResponse) return earlyResponse;
+    const rawData = route.page.loader ? await route.page.loader(c) : {};
+    const data = rawData ?? {};
+    if (isSPA) {
+      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, pageSEO2)
+      });
+    }
+    const clientEntry = config.assets?.manifestEntry ?? "client.ts";
+    const assets = isDev ? { scripts: [`/${clientEntry}`], styles: [] } : await resolveAssets(config.assets ?? {}, clientEntry);
+    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 ?? "Vono";
+    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) };
+}
+function detectRuntime() {
+  if (typeof globalThis["Bun"] !== "undefined") return "bun";
+  if (typeof globalThis["Deno"] !== "undefined") return "deno";
+  if (typeof process !== "undefined" && process.versions?.node) return "node";
+  return "edge";
+}
+async function serve(opts) {
+  const runtime = opts.runtime ?? detectRuntime();
+  const port = opts.port ?? Number(process?.env?.["PORT"] ?? 3e3);
+  const hostname = opts.hostname ?? "0.0.0.0";
+  const staticDir = opts.staticDir ?? "./dist";
+  const displayHost = hostname === "0.0.0.0" ? "localhost" : hostname;
+  const logReady = () => console.log(`
+\u{1F525}  Vono [${runtime}] \u2192 http://${displayHost}:${port}
+`);
+  switch (runtime) {
+    case "node": {
+      const [{ serve: nodeServe }, { serveStatic }] = await Promise.all([
+        import("@hono/node-server"),
+        import("@hono/node-server/serve-static")
+      ]);
+      opts.app.app.use("/assets/*", serveStatic({ root: staticDir }));
+      opts.app.app.use("/*", serveStatic({ root: "./public" }));
+      nodeServe({ fetch: opts.app.handler, port, hostname });
+      logReady();
+      break;
+    }
+    case "bun":
+      ;
+      globalThis["Bun"].serve({ fetch: opts.app.handler, port, hostname });
+      logReady();
+      break;
+    case "deno":
+      ;
+      globalThis["Deno"].serve({ port, hostname }, opts.app.handler);
+      logReady();
+      break;
+    default:
+      console.warn("[vono] serve() is a no-op on edge \u2014 export vono.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)$/;
+function vonoVitePlugin(opts = {}) {
+  const {
+    serverEntry = "server.ts",
+    clientEntry = "client.ts",
+    serverOutDir = "dist/server",
+    clientOutDir = "dist/assets",
+    serverExternal = [],
+    vueOptions = {}
+  } = opts;
+  return {
+    name: "vono:build",
+    apply: "build",
+    enforce: "pre",
+    // Server (SSR) bundle configuration.
+    //
+    // target: 'node18' is essential — it tells esbuild to emit ES2022+ syntax
+    // which includes top-level await.  Without it, esbuild defaults to a
+    // browser-compatible target ("chrome87", "es2020", …) that does NOT support
+    // top-level await, causing the build to fail with:
+    //   "Top-level await is not available in the configured target environment"
+    config() {
+      return {
+        build: {
+          ssr: serverEntry,
+          outDir: serverOutDir,
+          // ↓ CRITICAL — enables top-level await in the server bundle
+          target: "node18",
+          rollupOptions: {
+            input: serverEntry,
+            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  Vono: building client bundle\u2026\n");
+      let vuePlugin;
+      try {
+        const mod = await import("@vitejs/plugin-vue");
+        const factory = mod.default ?? mod;
+        vuePlugin = factory(vueOptions);
+      } catch {
+        throw new Error(
+          "[vono] @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,
+        build: {
+          outDir: clientOutDir,
+          // Vite 5+ writes manifest to <outDir>/.vite/manifest.json
+          manifest: true,
+          rollupOptions: {
+            input: clientEntry,
+            output: {
+              format: "es",
+              entryFileNames: "[name]-[hash].js",
+              chunkFileNames: "[name]-[hash].js",
+              assetFileNames: "[name]-[hash][extname]"
+            }
+          }
+        }
+      });
+      console.log("\u2705  Vono: both bundles ready\n");
+    }
+  };
+}
+export {
+  DATA_KEY,
+  PARAMS_KEY,
+  SEO_KEY,
+  SPA_HEADER,
+  STATE_KEY,
+  compilePath,
+  createVono,
+  defineApiRoute,
+  defineGroup,
+  defineLayout,
+  definePage,
+  detectRuntime,
+  isAsyncLoader,
+  matchPath,
+  resolveRoutes,
+  serve,
+  toVueRouterPath,
+  vonoVitePlugin
+};