hono-svelte 0.3.0 → 0.4.0

package/dist/head.js

@@ -0,0 +1,42 @@
+// Per-page <head> tags (CSP-safe: meta/link tags plus an opt-in raw slot).
+// No executable inline scripts are ever emitted here.
+function escapeAttr(value) {
+    return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+export function renderHead(head) {
+    if (!head)
+        return "";
+    if (typeof head === "string")
+        return head;
+    const out = [];
+    if (head.description !== undefined) {
+        out.push(`<meta name="description" content="${escapeAttr(head.description)}" />`);
+    }
+    if (head.canonical !== undefined) {
+        out.push(`<link rel="canonical" href="${escapeAttr(head.canonical)}" />`);
+    }
+    if (head.themeColor !== undefined) {
+        out.push(`<meta name="theme-color" content="${escapeAttr(head.themeColor)}" />`);
+    }
+    for (const m of head.meta ?? []) {
+        const attr = m.name
+            ? `name="${escapeAttr(m.name)}"`
+            : m.property
+                ? `property="${escapeAttr(m.property)}"`
+                : m.httpEquiv
+                    ? `http-equiv="${escapeAttr(m.httpEquiv)}"`
+                    : null;
+        if (!attr)
+            continue;
+        out.push(`<meta ${attr} content="${escapeAttr(m.content)}" />`);
+    }
+    for (const [k, v] of Object.entries(head.og ?? {})) {
+        out.push(`<meta property="og:${escapeAttr(k)}" content="${escapeAttr(v)}" />`);
+    }
+    for (const [k, v] of Object.entries(head.twitter ?? {})) {
+        out.push(`<meta name="twitter:${escapeAttr(k)}" content="${escapeAttr(v)}" />`);
+    }
+    if (head.extra)
+        out.push(head.extra);
+    return out.join("");
+}

package/dist/ids.js

@@ -1,6 +1,6 @@
-// IDs opacos derivados do entryName. Puro, sem dependencias de runtime.
-// (funciona em Node, Workers, Deno, Bun). Nao e segredo de estado:
-// apenas evita expor dados do servidor no HTML.
+// Opaque IDs derived from the entryName. Pure, no runtime dependencies.
+// (works on Node, Workers, Deno, Bun). Not a state secret:
+// it just avoids exposing server internals in the HTML.
 function hashString(input) {
     let h1 = 0xdeadbeef;
     let h2 = 0x41c6ce57;

package/dist/index.d.ts

@@ -1,24 +1,89 @@
 import type { Next } from "hono";
+import { type AssetsResolver, type ViteManifest } from "./assets.js";
+import { type HeadProps } from "./head.js";
 export { getIds } from "./ids.js";
 export type { SharedIds } from "./ids.js";
+export { renderHead } from "./head.js";
+export type { HeadMetaItem, HeadProps } from "./head.js";
+export { CACHE_IMMUTABLE, CACHE_NO_STORE, createManifestAssets, immutableHeaders, manifestCssFor, manifestImportsFor, manifestKeysFor, } from "./assets.js";
+export type { AssetsResolver, ManifestAssetsOptions, ViteManifest, ViteManifestChunk, } from "./assets.js";
+export { notFoundHandler, errorHandler } from "./handlers.js";
+export type { ErrorPageOptions, ServerErrorHandlerOptions } from "./handlers.js";
+export { initFiles, doctorChecks, checkAppLink, versionsMatch, isSafeAppPath } from "./scaffold.js";
+export type { DoctorIssue, DoctorOptions, InitFile } from "./scaffold.js";
 export type SsrPageLoader = () => Promise<{
     default: unknown;
 }>;
 export type RenderProps = {
     title?: string;
     data?: Record<string, unknown>;
+    /** HTTP status of the shell response. @default 200 */
+    status?: number;
+    /** Extra response headers merged into the shell response. */
+    headers?: Record<string, string>;
+    /** Per-page head tags, merged after the shell `head` option. */
+    head?: string | HeadProps;
 };
+export type PrefetchMode = false | "hover" | "all";
 export type ShellOptions = {
     title?: string;
     lang?: string;
     assetsBase?: string;
+    /**
+     * Resolve the client JS URL for an entry.
+     * - String: base prefix (`/static` -> `/static/<entry>.js`).
+     * - Vite manifest object or resolver function: hashed files.
+     * @default "/static"
+     */
+    assets?: string | ViteManifest | AssetsResolver;
+    /** Extra CSS links per HTML response. Strings are hrefs verbatim. */
+    styles?: string[];
     stylesHref?: string | ((isProd: boolean) => string);
+    /** Global head HTML (fonts, meta) — page `head` prop is appended after it. */
     head?: string;
-    /** Override manual do mapa entryName -> loader (opcional; sem isso o shell
-     *  resolve o mapa automaticamente via ssr-manifest). */
+    /**
+     * CSP nonce applied to `<script>`, `<link>` and `<style data-hs>` tags
+     * emitted by the shell. Pass a per-request nonce string or a function
+     * reading it from the Hono context (e.g. set by `secureHeaders()`).
+     */
+    nonce?: string | ((c: unknown) => string | undefined);
+    /**
+     * `<link rel="modulepreload">` for the current entry (+ its manifest
+     * imports). @default true in prod, false in dev.
+     */
+    preload?: boolean;
+    /** Prefetch other client entries. @default false */
+    prefetch?: PrefetchMode;
+    /**
+     * Warn once when serialized `data` exceeds this many bytes.
+     * @default 102400 (100KB). Set to `false` to disable.
+     */
+    dataLimit?: number | false;
+    /** Manual override of the entryName -> loader map (otherwise resolved via ssr-manifest). */
     ssrPages?: Record<string, SsrPageLoader>;
+    /**
+     * Known entry names. When set (or auto-detected from the manifest),
+     * unknown entries throw a dev-friendly error listing available pages.
+     * In production the error message is generic.
+     */
+    knownEntries?: string[];
+    /** `false` disables unknown-entry validation. @default true */
+    strict?: boolean;
+    /** Default status when `c.render(entry)` omits it. @default 200 */
+    status?: number;
+    /** Default headers merged into every shell response. */
+    headers?: Record<string, string>;
+    /**
+     * Force prod/dev asset behavior. Defaults to auto-detect
+     * (`import.meta.env.PROD`, else `NODE_ENV === "production"`).
+     */
+    isProd?: boolean;
 };
 export type ShellContext = {
     render: (entryName: string, props?: RenderProps) => Response | Promise<Response>;
 };
-export declare function shell(options?: ShellOptions): (c: any, next: Next) => Promise<void>;
+/** Visible for tests. */
+export declare function __resetDataLimitWarned(): void;
+export declare function shell(options?: ShellOptions): ((c: any, next: Next) => Promise<void>) & {
+    availableEntries: () => string[] | undefined;
+};

package/dist/index.js

@@ -1,7 +1,13 @@
+import { createManifestAssets, manifestCssFor, manifestImportsFor, } from "./assets.js";
+import { renderHead } from "./head.js";
 import { getIds } from "./ids.js";
-import { ssrPages as autoSsrPages } from "./ssr-manifest.js";
+import { allEntries as autoAllEntries, ssrLayouts as autoSsrLayouts, ssrPages as autoSsrPages, } from "./ssr-manifest.js";
 import { devEntryUrl } from "./virtual.js";
 export { getIds } from "./ids.js";
+export { renderHead } from "./head.js";
+export { CACHE_IMMUTABLE, CACHE_NO_STORE, createManifestAssets, immutableHeaders, manifestCssFor, manifestImportsFor, manifestKeysFor, } from "./assets.js";
+export { notFoundHandler, errorHandler } from "./handlers.js";
+export { initFiles, doctorChecks, checkAppLink, versionsMatch, isSafeAppPath } from "./scaffold.js";
 function escapeAttr(value) {
     return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
 }
@@ -15,70 +21,337 @@ function isValidEntryName(entryName) {
     const parts = entryName.split("/");
     return parts.every((p) => p.length > 0 && p !== "." && p !== ".." && !p.includes(String.fromCharCode(0)));
 }
-function serializePageData(data, dataId) {
+function nonceAttr(nonce) {
+    return nonce ? ` nonce="${escapeAttr(nonce)}"` : "";
+}
+function serializePageData(data, dataId, dataLimit) {
     if (!data)
-        return "";
+        return { json: "", html: "" };
     let json;
     try {
         json = JSON.stringify(data);
     }
     catch {
-        throw new Error("hono-svelte: props.data precisa ser serializavel em JSON");
+        throw new Error("hono-svelte: props.data must be JSON-serializable");
     }
     if (json === undefined)
+        return { json: "", html: "" };
+    checkDataLimit(json, dataLimit);
+    const safe = json.replace(/</g, "\\u003c");
+    const lt = String.fromCharCode(60);
+    return {
+        json,
+        html: lt + 'script type="application/json" id="' + dataId + '">' + safe + lt + "/script>",
+    };
+}
+const warnedDataLimit = new Set();
+function checkDataLimit(json, dataLimit) {
+    if (dataLimit === false)
+        return;
+    const bytes = new TextEncoder().encode(json).length;
+    if (bytes <= dataLimit)
+        return;
+    const key = String(dataLimit);
+    if (warnedDataLimit.has(key))
+        return;
+    warnedDataLimit.add(key);
+    const kb = (bytes / 1024).toFixed(1);
+    const limitKb = (dataLimit / 1024).toFixed(0);
+    console.warn(`[hono-svelte] page data is ${kb}KB (limit ${limitKb}KB). ` +
+        `data is inlined in the HTML — move large/sensitive payloads to a typed API (hc<AppType>).`);
+}
+/** Visible for tests. */
+export function __resetDataLimitWarned() {
+    warnedDataLimit.clear();
+}
+/**
+ * Build-time flags. `import.meta.env.PROD/DEV` MUST be accessed statically
+ * (no `as unknown`, no intermediate variable) so Vite/esbuild can replace
+ * them with literals per bundle. In plain node (no Vite define) the access
+ * throws at module-eval time, hence the try/catch.
+ *
+ * NOTE: the server bundle is ALWAYS production (built with
+ * `vite build --mode production`), so when Vite replaced the flag the answer
+ * is baked in. The NODE_ENV fallback only matters for unbundled runtimes
+ * (tests, `vite dev` SSR). `node ./dist/index.js` needs no env prefix.
+ */
+function detectProd() {
+    try {
+        if (import.meta.env.PROD !== undefined)
+            return import.meta.env.PROD;
+    }
+    catch {
+        // plain node / vitest: no import.meta.env — bundled server is prod
+        return true;
+    }
+    return globalThis.process?.env?.NODE_ENV === "production";
+}
+function isDev() {
+    try {
+        if (import.meta.env.DEV !== undefined)
+            return import.meta.env.DEV;
+    }
+    catch {
+        // plain node / vitest
+        return false;
+    }
+    return globalThis.process?.env?.NODE_ENV !== "production";
+}
+function defaultKnownEntries(ssrPages) {
+    const keys = Object.keys(ssrPages);
+    if (ssrPages.__allEntries !== undefined) {
+        return ssrPages.__allEntries;
+    }
+    return keys.length > 0 ? keys : undefined;
+}
+function renderNotFoundHint(available, _prod) {
+    if (!available || available.length === 0) {
+        return "hono-svelte: unknown entry (check pagesDir and the entryName passed to c.render)";
+    }
+    const list = [...available].sort().slice(0, 20).join('", "');
+    const more = available.length > 20 ? ` (+${available.length - 20} more)` : "";
+    return `hono-svelte: unknown entry. Available pages: "${list}"${more}`;
+}
+function resolveAssetUrl(assets, assetsBase, entryName) {
+    const resolver = typeof assets === "function"
+        ? assets
+        : typeof assets === "object" && assets !== null
+            ? createManifestAssets(assets)
+            : (entry) => `${assetsBase}/${entry}.js`;
+    return resolver(entryName);
+}
+function manifestFor(assets) {
+    return typeof assets === "object" && assets !== null ? assets : undefined;
+}
+function prefetchUrls(mode, entryName, allEntries, resolveUrl) {
+    if (!mode || !allEntries)
+        return [];
+    if (mode === "all")
+        return allEntries.filter((e) => e !== entryName).map(resolveUrl);
+    return [];
+}
+function prefetchHoverScript(nonce, dataId, urls) {
+    if (urls.length === 0)
         return "";
-    json = json.replace(/</g, "\\u003c");
     const lt = String.fromCharCode(60);
-    return lt + 'script type="application/json" id="' + dataId + '">' + json + lt + "/script>";
+    const map = JSON.stringify(Object.fromEntries(urls.map((u) => [u.entry, u.url])));
+    const code = `(function(){var m=${map};` +
+        `function pre(u){if(document.querySelector('link[rel=\"prefetch\"][href=\"'+u+'\"]'))return;` +
+        `var l=document.createElement('link');l.rel='prefetch';l.href=u;document.head.appendChild(l);}` +
+        `document.addEventListener('mouseover',function(e){var a=e.target&&e.target.closest?e.target.closest('a[href]'):null;` +
+        `if(!a)return;try{var p=new URL(a.href,location.origin).pathname.replace(/^\\//,'');` +
+        `var u=m[p];if(u)pre(u);}catch(_){}},{passive:true});})();`;
+    return lt + `script${nonceAttr(nonce)}>${code}` + lt + "/script>";
 }
 export function shell(options = {}) {
     const titleDefault = options.title ?? "App";
     const lang = options.lang ?? "en";
     const assetsBase = (options.assetsBase ?? "/static").replace(/\/$/, "");
+    const assetsOpt = options.assets ?? assetsBase;
     const head = options.head ?? "";
+    const defaultStatus = options.status ?? 200;
+    const defaultHeaders = options.headers ?? {};
+    const dataLimit = options.dataLimit ?? 102400;
+    const strict = options.strict ?? true;
+    const extraStyles = options.styles ?? [];
     const resolveStyles = typeof options.stylesHref === "function"
         ? options.stylesHref
         : () => options.stylesHref;
-    // Zero config: com pages() ativo, este modulo e redirecionado para o
-    // manifesto in-memory pelo resolveId do plugin (enforce: "pre").
+    // Zero config: with pages() active, this module is redirected to the
+    // in-memory manifest by the plugin's resolveId (enforce: "pre").
     const ssrPages = options.ssrPages ?? autoSsrPages;
-    return async function shellMiddleware(c, next) {
+    // NOTE: `p` in the bundle below is the layouts map. It must come from the
+    // VIRTUAL manifest (ssrPages.__layouts), never from the stub — the stub's
+    // ssrLayouts is always {}. When the caller passes a manual ssrPages map,
+    // __layouts travels on the same object (see vite.ts manifestSource).
+    const ssrLayouts = ssrPages.__layouts ??
+        autoSsrPages.__layouts ??
+        autoSsrLayouts;
+    const staticKnown = options.knownEntries ??
+        (autoAllEntries.length > 0 ? [...autoAllEntries] : undefined) ??
+        defaultKnownEntries(ssrPages);
+    function availableEntries() {
+        if (staticKnown)
+            return staticKnown;
+        return defaultKnownEntries(ssrPages);
+    }
+    /**
+     * Client entries have a JS bundle (input() in the plugin). The virtual
+     * manifest carries them via `clientEntries`; the static stub has none.
+     * Layout-wrapped STATIC pages are SSR (no script branch) — their chain
+     * is rendered server-side.
+     */
+    function hasClientEntry(entryName) {
+        const fromManifest = ssrPages.__clientEntries;
+        if (fromManifest)
+            return fromManifest.includes(entryName);
+        const auto = autoSsrPages.__clientEntries;
+        if (auto)
+            return auto.includes(entryName);
+        return false;
+    }
+    function layoutChainFor(entryName) {
+        if (entryName === "layout" || entryName.endsWith("/layout"))
+            return [];
+        const layouts = Object.keys(ssrLayouts);
+        if (layouts.length === 0)
+            return [];
+        const chain = [];
+        const parts = entryName.split("/");
+        for (let i = 1; i < parts.length; i++) {
+            const layout = parts.slice(0, i).join("/") + "/layout";
+            if (layouts.includes(layout))
+                chain.push(layout);
+        }
+        if (layouts.includes("layout"))
+            chain.unshift("layout");
+        return chain;
+    }
+    function resolveNonce(c) {
+        if (typeof options.nonce === "function") {
+            try {
+                return options.nonce(c) ?? undefined;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return options.nonce;
+    }
+    async function renderSsrBody(loader, pageData, nonce, layoutChain) {
+        const mod = await loader();
+        const { render } = await import("svelte/server");
+        const renderOpts = {};
+        if (pageData !== undefined)
+            renderOpts.props = pageData;
+        if (nonce)
+            renderOpts.csp = { nonce };
+        const rendered = render(mod.default, renderOpts);
+        let html = rendered.html ?? rendered.body ?? "";
+        let headValue = typeof rendered.head === "function" ? rendered.head() : (rendered.head ?? "");
+        if (layoutChain.length > 0) {
+            const { createRawSnippet } = await import("svelte");
+            for (const layoutLoader of layoutChain) {
+                const layoutMod = await layoutLoader();
+                const childHtml = html;
+                // The snippet MUST render a single wrapper element: the server
+                // renderer pushes render() output verbatim, and the client
+                // createRawSnippet takes get_first_child(fragment). An empty render
+                // breaks hydration ("Cannot set properties of null"). The extra div
+                // is hydration-safe (hydrate reuses SSR DOM).
+                const childSnippet = createRawSnippet(() => ({ render: () => `<div>${childHtml}</div>` }));
+                const wrapped = render(layoutMod.default, {
+                    ...(pageData !== undefined ? { props: pageData } : {}),
+                    props: { ...(pageData ?? {}), children: childSnippet },
+                    ...(nonce ? { csp: { nonce } } : {}),
+                });
+                html = wrapped.html ?? wrapped.body ?? "";
+                const layoutHead = typeof wrapped.head === "function" ? wrapped.head() : (wrapped.head ?? "");
+                headValue = layoutHead + headValue;
+            }
+        }
+        return { html, head: headValue };
+    }
+    async function inner(c, next) {
         c.setRenderer(async (entryName, props) => {
             if (!isValidEntryName(entryName)) {
-                throw new Error(`hono-svelte: entryName invalido: ${JSON.stringify(entryName)}`);
+                throw new Error(`hono-svelte: invalid entryName: ${JSON.stringify(entryName)}`);
+            }
+            const loader = ssrPages[entryName];
+            // A page is SSR when it is static (no <script>) — LAYOUTS DON'T MATTER
+            // here. A static page wrapped in layouts SSRs the page and wraps it in
+            // the layout chain (same rule as pages().staticEntries/clientEntries).
+            // Client entries (has <script>) always go the script branch.
+            const chain = layoutChainFor(entryName)
+                .map((l) => ssrLayouts[l])
+                .filter((l) => l !== undefined);
+            const isSsr = loader !== undefined && !hasClientEntry(entryName);
+            if (strict && !isSsr) {
+                const known = availableEntries();
+                if (known && !known.includes(entryName)) {
+                    throw new Error(`${renderNotFoundHint(known)} (got ${JSON.stringify(entryName)})`);
+                }
             }
             const ids = getIds(entryName);
             const title = props?.title ?? titleDefault;
-            const isProd = import.meta.env?.PROD ?? false;
+            const isProd = options.isProd ?? detectProd();
+            const nonce = resolveNonce(c);
+            const nAttr = nonceAttr(nonce);
             const stylesHref = resolveStyles(isProd) ?? (isProd ? "/static/styles.css" : "/src/styles.css");
-            const dataHtml = props?.data ? serializePageData(props.data, ids.dataId) : "";
+            const { html: dataHtml } = serializePageData(props?.data, ids.dataId, dataLimit);
             const lt = String.fromCharCode(60);
-            const loader = ssrPages[entryName];
             let bodyHtml = "";
             let ssrHead = "";
-            if (loader !== undefined) {
-                const mod = await loader();
-                const { render } = await import("svelte/server");
-                const rendered = render(mod.default);
+            if (isSsr) {
+                const rendered = await renderSsrBody(loader, props?.data, nonce, chain);
                 bodyHtml = rendered.html;
-                ssrHead = rendered.head ?? "";
+                ssrHead = rendered.head;
             }
+            const resolveUrl = (entry) => isProd ? resolveAssetUrl(assetsOpt, assetsBase, entry) : devEntryUrl(entry);
             let scriptHtml = "";
-            if (loader === undefined) {
-                const src = isProd ? `${assetsBase}/${entryName}.js` : devEntryUrl(entryName);
-                scriptHtml = lt + `script type="module" src="${escapeAttr(src)}">` + lt + "/script>";
+            let preloadHtml = "";
+            let prefetchHtml = "";
+            if (!isSsr) {
+                const src = resolveUrl(entryName);
+                scriptHtml = lt + `script type="module" src="${escapeAttr(src)}"${nAttr}>` + lt + "/script>";
+                const shouldPreload = options.preload ?? isProd;
+                const manifest = isProd ? manifestFor(assetsOpt) : undefined;
+                if (shouldPreload) {
+                    const urls = [src];
+                    if (manifest) {
+                        for (const imp of manifestImportsFor(manifest, entryName)) {
+                            if (!urls.includes(imp))
+                                urls.push(imp);
+                        }
+                    }
+                    preloadHtml = urls
+                        .map((u) => lt + `link rel="modulepreload" href="${escapeAttr(u)}"${nAttr} />`)
+                        .join("");
+                }
+                if (isProd && options.prefetch) {
+                    const known = availableEntries();
+                    if (options.prefetch === "all" && known) {
+                        for (const u of prefetchUrls("all", entryName, known, resolveUrl)) {
+                            prefetchHtml += lt + `link rel="prefetch" href="${escapeAttr(u)}"${nAttr} />`;
+                        }
+                    }
+                    else if (options.prefetch === "hover" && known) {
+                        const others = known.filter((e) => e !== entryName && ssrPages[e] === undefined);
+                        prefetchHtml = prefetchHoverScript(nonce, ids.dataId, others.map((e) => ({ entry: e, url: resolveUrl(e) })));
+                    }
+                }
             }
+            const status = props?.status ?? defaultStatus;
+            const headers = { ...defaultHeaders, ...(props?.headers ?? {}) };
+            const pageHead = props?.head !== undefined ? renderHead(props.head) : "";
+            const manifestNow = isProd ? manifestFor(assetsOpt) : undefined;
+            const cssLinks = (manifestNow ? manifestCssFor(manifestNow, entryName) : [])
+                .map((href) => lt + `link rel="stylesheet" href="${escapeAttr(href)}"${nAttr} />`)
+                .join("") +
+                extraStyles
+                    .map((href) => lt + `link rel="stylesheet" href="${escapeAttr(href)}"${nAttr} />`)
+                    .join("");
             return c.html(`<!doctype html><html lang="${escapeAttr(lang)}"><head><title>${escapeAttr(title)}</title>` +
                 `<meta charset="utf-8" /><meta content="width=device-width, initial-scale=1" name="viewport" />` +
                 (head ? head : "") +
-                `<link rel="stylesheet" href="${escapeAttr(stylesHref)}" />` +
+                `<link rel="stylesheet" href="${escapeAttr(stylesHref)}"${nAttr} />` +
+                cssLinks +
                 ssrHead +
+                pageHead +
+                preloadHtml +
+                prefetchHtml +
                 scriptHtml +
                 `</head>` +
                 `<body class="bg-base-200 min-h-screen text-base-content"><div id="${ids.rootId}">${bodyHtml}</div>` +
                 dataHtml +
-                `</body></html>`);
+                `</body></html>`, status, headers);
         });
         await next();
-    };
+    }
+    async function shellMiddleware(c, next) {
+        return inner(c, next);
+    }
+    const mw = shellMiddleware;
+    mw.availableEntries = availableEntries;
+    return mw;
 }

package/dist/scaffold.d.ts

@@ -0,0 +1,22 @@
+export type InitFile = {
+    path: string;
+    content: string;
+    skipIfExists: boolean;
+};
+export declare function initFiles(): InitFile[];
+export type DoctorIssue = {
+    /** Machine-readable code, e.g. "missing-dist". */
+    code: string;
+    message: string;
+    fix: string;
+};
+export type DoctorOptions = {
+    /** Root of the hono-svelte package (where `dist/` lives). @default cwd */
+    packageRoot?: string;
+    /** Root of the app being checked. @default cwd */
+    appRoot?: string;
+};
+export declare function versionsMatch(_linkedVersion: string, _appWants: string): boolean;
+export declare function doctorChecks(opts?: DoctorOptions): DoctorIssue[];
+export declare function checkAppLink(appRoot: string): DoctorIssue | null;
+export declare function isSafeAppPath(appRoot: string, target: string): boolean;

package/dist/scaffold.js

@@ -0,0 +1,107 @@
+// `hono-svelte init` + `hono-svelte doctor` helpers.
+//
+// The package exposes pure helpers (`initFiles`, `doctorChecks`) so they can
+// be unit-tested; the thin CLI wrapper lives in `src/cli.ts` (compiled to
+// `dist/cli.js`, invoked via the `hono-svelte-doctor` bin).
+import { existsSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+const ENV_DTS = `import type { RenderProps } from "hono-svelte";
+
+declare module "hono" {
+  interface ContextRenderer {
+    (entryName: string, props?: RenderProps): Response | Promise<Response>;
+  }
+}
+`;
+const VITE_CONFIG = `import build from "@hono/vite-build/node";
+import devServer from "@hono/vite-dev-server";
+import { svelte } from "@sveltejs/vite-plugin-svelte";
+import { pages } from "hono-svelte/vite";
+import { resolve } from "node:path";
+import { defineConfig } from "vite";
+
+const appPages = pages();
+
+export default defineConfig(({ command, mode }) => {
+  if (mode === "client") {
+    return {
+      plugins: [svelte(), appPages],
+      build: {
+        rollupOptions: {
+          input: { ...appPages.input(), styles: resolve("src/styles.css") },
+          output: {
+            entryFileNames: "static/[name].js",
+            chunkFileNames: "static/chunks/[name]-[hash].js",
+            assetFileNames: "static/[name][extname]",
+          },
+        },
+      },
+    };
+  }
+
+  if (command === "serve") {
+    return {
+      plugins: [svelte(), appPages, devServer({ entry: "src/routes/index.ts" })],
+    };
+  }
+
+  return {
+    plugins: [svelte(), appPages, build({ entry: "src/routes/index.ts", staticRoot: "./dist" })],
+  };
+});
+`;
+const INDEX_SVELTE = `<main>
+  <h1>Welcome</h1>
+  <a href="/dashboard">Sign in</a>
+</main>
+`;
+export function initFiles() {
+    return [
+        { path: "src/env.d.ts", content: ENV_DTS, skipIfExists: true },
+        { path: "vite.config.ts", content: VITE_CONFIG, skipIfExists: true },
+        { path: "src/pages/index.svelte", content: INDEX_SVELTE, skipIfExists: true },
+    ];
+}
+export function versionsMatch(_linkedVersion, _appWants) {
+    return true;
+}
+export function doctorChecks(opts = {}) {
+    const packageRoot = opts.packageRoot ? resolve(opts.packageRoot) : process.cwd();
+    const appRoot = opts.appRoot ? resolve(opts.appRoot) : process.cwd();
+    const issues = [];
+    for (const file of ["dist/index.js", "dist/vite.js", "dist/index.d.ts", "dist/vite.d.ts"]) {
+        if (!existsSync(join(packageRoot, file))) {
+            issues.push({
+                code: "missing-dist",
+                message: `hono-svelte dist is missing (${file} not found). The package was not built.`,
+                fix: "Run `npm run build` in the hono-svelte package directory.",
+            });
+            break;
+        }
+    }
+    const viteConfig = join(appRoot, "vite.config.ts");
+    if (!existsSync(viteConfig) && !existsSync(join(appRoot, "vite.config.js"))) {
+        issues.push({
+            code: "missing-vite-config",
+            message: "No vite config found in the app.",
+            fix: "Run `hono-svelte init` to scaffold one, or copy the README quick-start.",
+        });
+    }
+    return issues;
+}
+export function checkAppLink(appRoot) {
+    const appLink = join(resolve(appRoot), "node_modules", "hono-svelte");
+    if (!existsSync(join(appLink, "package.json"))) {
+        return {
+            code: "missing-link",
+            message: `node_modules/hono-svelte is missing or a stale junction in ${appRoot}.`,
+            fix: "Run `npm install` inside the app directory to recreate the file: link.",
+        };
+    }
+    return null;
+}
+export function isSafeAppPath(appRoot, target) {
+    const root = resolve(appRoot);
+    const abs = isAbsolute(target) ? target : resolve(root, target);
+    return abs === root || abs.startsWith(root + "/");
+}

package/dist/ssr-manifest.d.ts

@@ -1,3 +1,11 @@
 export declare const ssrPages: Record<string, () => Promise<{
     default: unknown;
 }>>;
+export declare const ssrLayouts: Record<string, () => Promise<{
+    default: unknown;
+}>>;
+export declare const allEntries: string[];
+export declare const layoutEntries: string[];
+export declare const clientEntries: string[];
+export declare const staticEntries: string[];
+export declare function hasClient(_entryName: string): boolean;