hono-preact 0.1.0

package/dist/server/actions-handler.d.ts

@@ -0,0 +1,33 @@
+import type { MiddlewareHandler } from 'hono';
+import { type ActionGuardFn } from '../iso/index';
+type GlobModule = {
+    __moduleKey?: unknown;
+    serverActions?: Record<string, unknown>;
+    actionGuards?: ActionGuardFn[];
+    [key: string]: unknown;
+};
+type LazyGlob = Record<string, () => Promise<unknown>>;
+type EagerGlob = Record<string, GlobModule>;
+export interface ActionsHandlerOptions {
+    /**
+     * When true, rebuild the actions map on every request (so edits to
+     * `.server.ts` files take effect without a server restart). When false
+     * (default), the map is built once on first request and cached for the
+     * life of the process. The framework's generated server entry passes
+     * `{ dev: import.meta.env.DEV }`; custom wirings should set this
+     * explicitly rather than relying on a Vite-only build-time constant.
+     */
+    dev?: boolean;
+    /**
+     * Called for every error an action throws (other than `ActionGuardError`,
+     * which is treated as a structured response). Use it to hook into your
+     * observability stack (Sentry, console, etc.). The handler still
+     * responds with a sanitized 500; the hook is purely a side channel.
+     */
+    onError?: (err: unknown, ctx: {
+        module: string;
+        action: string;
+    }) => void;
+}
+export declare function actionsHandler(glob: LazyGlob | EagerGlob, opts?: ActionsHandlerOptions): MiddlewareHandler;
+export {};

package/dist/server/actions-handler.js

@@ -0,0 +1,159 @@
+import { ActionGuardError, GuardRedirect, } from '../iso/index.js';
+import { runRequestScope } from '../iso/internal/index.js';
+import { sseGeneratorResponse, sseReadableStreamResponse, isAsyncGenerator, } from './sse.js';
+async function buildActionsMap(glob) {
+    const result = {};
+    for (const [, moduleOrLoader] of Object.entries(glob)) {
+        const mod = typeof moduleOrLoader === 'function'
+            ? await moduleOrLoader()
+            : moduleOrLoader;
+        const key = mod.__moduleKey;
+        if (typeof key === 'string' && mod.serverActions) {
+            result[key] = {
+                actions: mod.serverActions,
+                guards: mod.actionGuards ?? [],
+            };
+        }
+    }
+    return result;
+}
+async function runActionGuards(guards, ctx) {
+    const run = async (index) => {
+        if (index >= guards.length)
+            return;
+        // Track whether the guard explicitly opted to pass control on. Without
+        // this check a guard that forgets `return next()` (or just `next()`)
+        // would silently fall through to the action body — the OPPOSITE of every
+        // other middleware system users have seen (Express, Hono, Koa: blocked
+        // by default; opt in to pass). Make ambiguous returns loud instead of
+        // silently insecure. To block, throw ActionGuardError. To pass, await
+        // (or return) next().
+        let nextCalled = false;
+        await guards[index](ctx, () => {
+            nextCalled = true;
+            return run(index + 1);
+        });
+        if (!nextCalled) {
+            throw new Error(`ActionGuard for '${ctx.module}.${ctx.action}' returned without ` +
+                `calling next() or throwing. Guards must either: (a) await/return ` +
+                `next() to pass control on, or (b) throw ActionGuardError to block. ` +
+                `Returning silently is ambiguous and would let the action run.`);
+        }
+    };
+    await run(0);
+}
+export function actionsHandler(glob, opts = {}) {
+    const { dev = false, onError } = opts;
+    let cachedMapPromise = null;
+    return async (c) => {
+        const actionsMapPromise = dev
+            ? buildActionsMap(glob)
+            : (cachedMapPromise ??= buildActionsMap(glob).catch((err) => {
+                cachedMapPromise = null;
+                return Promise.reject(err);
+            }));
+        let actionsMap;
+        try {
+            actionsMap = await actionsMapPromise;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return c.json({ error: `Failed to load actions: ${message}` }, 503);
+        }
+        let module;
+        let action;
+        let payload;
+        const contentType = c.req.header('Content-Type') ?? '';
+        if (contentType.startsWith('multipart/form-data')) {
+            let formData;
+            try {
+                formData = await c.req.formData();
+            }
+            catch {
+                return c.json({ error: 'Invalid form data' }, 400);
+            }
+            const rawModule = formData.get('__module');
+            const rawAction = formData.get('__action');
+            if (typeof rawModule !== 'string' || typeof rawAction !== 'string') {
+                return c.json({ error: 'Form data must include __module and __action fields' }, 400);
+            }
+            module = rawModule;
+            action = rawAction;
+            const payloadObj = {};
+            for (const [key, value] of formData.entries()) {
+                if (key === '__module' || key === '__action')
+                    continue;
+                const existing = payloadObj[key];
+                if (existing !== undefined) {
+                    payloadObj[key] = Array.isArray(existing)
+                        ? [...existing, value]
+                        : [existing, value];
+                }
+                else {
+                    payloadObj[key] = value;
+                }
+            }
+            payload = payloadObj;
+        }
+        else {
+            let body;
+            try {
+                body = await c.req.json();
+            }
+            catch {
+                return c.json({ error: 'Invalid JSON body' }, 400);
+            }
+            const { module: m, action: a, payload: p } = body;
+            if (typeof m !== 'string' || typeof a !== 'string') {
+                return c.json({ error: 'Request body must include string fields: module, action' }, 400);
+            }
+            module = m;
+            action = a;
+            payload = p;
+        }
+        const entry = actionsMap[module];
+        if (!entry) {
+            return c.json({ error: `Module '${module}' not found` }, 404);
+        }
+        try {
+            await runActionGuards(entry.guards, { c, module, action, payload });
+        }
+        catch (err) {
+            if (err instanceof ActionGuardError) {
+                return c.json({ error: err.message }, err.status);
+            }
+            if (err instanceof GuardRedirect) {
+                return c.json({ __redirect: err.location });
+            }
+            throw err;
+        }
+        const fn = entry.actions[action];
+        if (typeof fn !== 'function') {
+            return c.json({ error: `Action '${action}' not found in module '${module}'` }, 404);
+        }
+        const signal = c.req.raw.signal;
+        const actionCtx = { c, signal };
+        let result;
+        try {
+            result = await runRequestScope(() => fn(actionCtx, payload));
+        }
+        catch (err) {
+            if (err instanceof ActionGuardError) {
+                return c.json({ error: err.message }, err.status);
+            }
+            if (err instanceof GuardRedirect) {
+                return c.json({ __redirect: err.location });
+            }
+            onError?.(err, { module, action });
+            const message = dev && err instanceof Error ? err.message : 'Action failed';
+            return c.json({ error: message }, 500);
+        }
+        if (isAsyncGenerator(result)) {
+            return sseGeneratorResponse(c, result, { emitResult: true });
+        }
+        if (result instanceof ReadableStream) {
+            return sseReadableStreamResponse(c, result);
+        }
+        return c.json(result);
+    };
+}

package/dist/server/context.d.ts

@@ -0,0 +1,6 @@
+export declare const HonoContext: import("preact").Context<{
+    context?: import("hono").Context;
+}>;
+export declare function useHonoContext(): {
+    context?: import("hono").Context;
+};

package/dist/server/context.js

@@ -0,0 +1,6 @@
+import { HonoRequestContext } from '../iso/internal/index.js';
+import { useContext } from 'preact/hooks';
+export const HonoContext = HonoRequestContext;
+export function useHonoContext() {
+    return useContext(HonoContext);
+}

package/dist/server/index.d.ts

@@ -0,0 +1,5 @@
+export { HonoContext, useHonoContext } from './context.js';
+export { renderPage } from './render.js';
+export { actionsHandler } from './actions-handler.js';
+export { loadersHandler } from './loaders-handler.js';
+export { routeServerModules } from './route-server-modules.js';

package/dist/server/index.js

@@ -0,0 +1,5 @@
+export { HonoContext, useHonoContext } from './context.js';
+export { renderPage } from './render.js';
+export { actionsHandler } from './actions-handler.js';
+export { loadersHandler } from './loaders-handler.js';
+export { routeServerModules } from './route-server-modules.js';

package/dist/server/loaders-handler.d.ts

@@ -0,0 +1,30 @@
+import type { MiddlewareHandler } from 'hono';
+type GlobModule = {
+    default?: unknown;
+    __moduleKey?: unknown;
+    [key: string]: unknown;
+};
+type LazyGlob = Record<string, () => Promise<unknown>>;
+type EagerGlob = Record<string, GlobModule>;
+export interface LoadersHandlerOptions {
+    /**
+     * When true, rebuild the loaders map on every request (so edits to
+     * `.server.ts` files take effect without a server restart). When false
+     * (default), the map is built once on first request and cached for the
+     * life of the process. The framework's generated server entry passes
+     * `{ dev: import.meta.env.DEV }`; custom wirings should set this
+     * explicitly rather than relying on a Vite-only build-time constant.
+     */
+    dev?: boolean;
+    /**
+     * Called for every error a loader throws. Use it to hook into your
+     * observability stack (Sentry, console, etc.). The handler still
+     * responds with a sanitized 500; the hook is purely a side channel.
+     */
+    onError?: (err: unknown, ctx: {
+        module: string;
+        loader: string;
+    }) => void;
+}
+export declare function loadersHandler(glob: LazyGlob | EagerGlob, opts?: LoadersHandlerOptions): MiddlewareHandler;
+export {};

package/dist/server/loaders-handler.js

@@ -0,0 +1,117 @@
+import { GuardRedirect } from '../iso/index.js';
+import { runRequestScope } from '../iso/internal/index.js';
+import { sseGeneratorResponse, sseReadableStreamResponse, isAsyncGenerator, } from './sse.js';
+async function buildLoadersMap(glob) {
+    const result = {};
+    for (const [, moduleOrLoader] of Object.entries(glob)) {
+        const mod = typeof moduleOrLoader === 'function'
+            ? await moduleOrLoader()
+            : moduleOrLoader;
+        const moduleKey = mod.__moduleKey;
+        if (typeof moduleKey !== 'string')
+            continue;
+        const sl = mod.serverLoaders;
+        if (sl && typeof sl === 'object') {
+            for (const [name, val] of Object.entries(sl)) {
+                // Two accepted shapes:
+                //   1. a raw loader function `(ctx) => ...` (used by unit-test fixtures)
+                //   2. a `LoaderRef` returned by `defineLoader(fn)`, whose `.fn`
+                //      property carries the original loader (used by user code)
+                if (typeof val === 'function') {
+                    result[`${moduleKey}::${name}`] = val;
+                }
+                else if (val && typeof val.fn === 'function') {
+                    result[`${moduleKey}::${name}`] = val.fn;
+                }
+            }
+        }
+    }
+    return result;
+}
+function validateLocation(loc) {
+    if (typeof loc !== 'object' || loc === null)
+        return null;
+    const o = loc;
+    if (typeof o.path !== 'string')
+        return null;
+    if (typeof o.pathParams !== 'object' || o.pathParams === null)
+        return null;
+    if (typeof o.searchParams !== 'object' || o.searchParams === null)
+        return null;
+    return {
+        path: o.path,
+        pathParams: o.pathParams,
+        searchParams: o.searchParams,
+    };
+}
+export function loadersHandler(glob, opts = {}) {
+    const { dev = false, onError } = opts;
+    let cachedMapPromise = null;
+    return async (c) => {
+        const loadersMapPromise = dev
+            ? buildLoadersMap(glob)
+            : (cachedMapPromise ??= buildLoadersMap(glob).catch((err) => {
+                cachedMapPromise = null;
+                return Promise.reject(err);
+            }));
+        let loadersMap;
+        try {
+            loadersMap = await loadersMapPromise;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return c.json({ error: `Failed to load loaders: ${message}` }, 503);
+        }
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: 'Invalid JSON body' }, 400);
+        }
+        const { module, loader: loaderName, location } = body;
+        if (typeof module !== 'string') {
+            return c.json({ error: 'Request body must include string field: module' }, 400);
+        }
+        if (typeof loaderName !== 'string') {
+            return c.json({ error: 'Request body must include string field: loader' }, 400);
+        }
+        const validatedLocation = validateLocation(location);
+        if (!validatedLocation) {
+            return c.json({
+                error: 'Request body must include object field: location with shape { path: string, pathParams: object, searchParams: object }',
+            }, 400);
+        }
+        const loaderFn = loadersMap[`${module}::${loaderName}`];
+        if (!loaderFn) {
+            return c.json({ error: `Loader '${module}::${loaderName}' not found` }, 404);
+        }
+        const signal = c.req.raw.signal;
+        try {
+            const result = await runRequestScope(() => Promise.resolve(loaderFn({ c, location: validatedLocation, signal })), { honoContext: c });
+            if (isAsyncGenerator(result)) {
+                return sseGeneratorResponse(c, result, { emitResult: false });
+            }
+            if (result instanceof ReadableStream) {
+                return sseReadableStreamResponse(c, result);
+            }
+            return c.json(result);
+        }
+        catch (err) {
+            // GuardRedirect thrown from a loader (or a guard that runs inside it)
+            // is a control-flow signal, not an error. The client RPC stub
+            // recognizes the `__redirect` envelope and navigates the browser
+            // rather than surfacing this as a thrown error in user code.
+            if (err instanceof GuardRedirect) {
+                return c.json({ __redirect: err.location });
+            }
+            onError?.(err, { module, loader: loaderName });
+            // In production we never leak the loader's error message: it may
+            // carry PII, internal stack hints, or details that help an attacker
+            // probe the system. Loader errors users want to surface should be
+            // returned as data, not thrown.
+            const message = dev && err instanceof Error ? err.message : 'Loader failed';
+            return c.json({ error: message }, 500);
+        }
+    };
+}

package/dist/server/middleware/location.d.ts

@@ -0,0 +1 @@
+export declare const location: import("hono").MiddlewareHandler<any, string, {}, Response>;

package/dist/server/middleware/location.js

@@ -0,0 +1,10 @@
+import { createMiddleware } from "hono/factory";
+import { locationStub } from "preact-iso/prerender";
+export const location = createMiddleware(async (c, next) => {
+    const url = new URL(c.req.url);
+    // Pass pathname + search so preact-iso's SSR `globalThis.location` carries
+    // the query string. Streaming loaders read `ctx.location.searchParams` and
+    // would otherwise see empty params on initial render.
+    locationStub(url.pathname + url.search);
+    await next();
+});

package/dist/server/render.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from 'hono';
+import type { VNode } from 'preact';
+export declare function renderPage(c: Context, node: VNode, options?: {
+    defaultTitle?: string;
+}): Promise<Response>;

package/dist/server/render.js

@@ -0,0 +1,203 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { createDispatcher, HoofdProvider } from 'hoofd/preact';
+import { prerender, locationStub } from 'preact-iso/prerender';
+import { GuardRedirect, env } from '../iso/index.js';
+import { HonoRequestContext, runRequestScope, captureRequestScope, takeServerStreamingLoaders, } from '../iso/internal/index.js';
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+// JSON.stringify produces a string that is JS-evaluable but NOT safe to embed
+// inside <script>...</script>: any '</script>' substring in the payload closes
+// the script tag and turns the rest into HTML. Escaping '<' as < keeps the
+// output valid JSON (and so still parseable by the consumer) while preventing
+// </script>, <!--, and <![CDATA[ from escaping the script context.
+function jsonForScript(value) {
+    return JSON.stringify(value).replace(/</g, '\\u003c');
+}
+function toAttrs(obj) {
+    return Object.entries(obj)
+        .filter(([, v]) => v != null)
+        .map(([k, v]) => `${k}="${escapeHtml(String(v))}"`)
+        .join(' ');
+}
+export async function renderPage(c, node, options) {
+    const dispatcher = createDispatcher();
+    const previousEnv = env.current;
+    env.current = 'server';
+    let html;
+    let streamingLoaders;
+    // Binder that re-enters the per-request ALS store; populated inside the
+    // scope below. Streaming loaders that yield, then resume from outside
+    // `runRequestScope` (the ReadableStream.start callback runs after this
+    // frame returns) lose ALS propagation on V8. Wrapping the drain in this
+    // binder restores per-request isolation for `getRequestStore` /
+    // `getRequestHonoContext` reads from generator continuations.
+    let bindRequestScope = (fn) => fn();
+    try {
+        const result = await runRequestScope(async () => {
+            // preact-iso's `LocationProvider` reads `globalThis.location` once,
+            // synchronously, when it mounts. Set it on the same microtask as the
+            // `prerender` call so no other request can interleave and trample
+            // the global between us writing it and the provider reading it.
+            // Children resume from reducer state, never re-reading the global,
+            // so the rest of this render is safe even if another request resets
+            // `globalThis.location` while we await suspended children.
+            const reqUrl = new URL(c.req.url);
+            locationStub(reqUrl.pathname + reqUrl.search);
+            bindRequestScope = captureRequestScope();
+            const rendered = await prerender(_jsx(HonoRequestContext.Provider, { value: { context: c }, children: _jsx(HoofdProvider, { value: dispatcher, children: node }) }));
+            const loaders = takeServerStreamingLoaders();
+            return { html: rendered.html, streamingLoaders: loaders };
+        }, { honoContext: c });
+        html = result.html;
+        streamingLoaders = result.streamingLoaders;
+    }
+    catch (e) {
+        if (e instanceof GuardRedirect)
+            return c.redirect(e.location);
+        throw e;
+    }
+    finally {
+        env.current = previousEnv;
+    }
+    const { title, lang, metas = [], links = [] } = dispatcher.toStatic();
+    // Only inject a <title> when hoofd produced one or the caller provided a
+    // defaultTitle. Layouts that render their own static <title> (via <Head>)
+    // would otherwise be overridden by an empty injected one (browsers use
+    // the last <title> in <head>).
+    const titleSource = title ?? options?.defaultTitle;
+    const headTags = [
+        titleSource != null ? `<title>${escapeHtml(titleSource)}</title>` : '',
+        ...metas.map((m) => `<meta ${toAttrs(m)} />`),
+        ...links.map((l) => `<link ${toAttrs(l)} />`),
+    ]
+        .filter(Boolean)
+        .join('\n        ');
+    const inner = html.replace('</head>', `${headTags}\n      </head>`);
+    // If the rendered tree already starts with <html>, the user's Layout owns
+    // the document shell. Inject hoofd's lang into that <html> tag (if hoofd
+    // dispatched one) and emit only the doctype; do not double-wrap.
+    // Otherwise (custom server entry rendering a fragment) keep the framework's
+    // <html lang> wrapper for backward compatibility.
+    const startsWithHtml = /^\s*<html(\s|>)/i.test(inner);
+    const fullHtml = startsWithHtml
+        ? lang != null
+            ? inner.replace(/<html(\s|>)/i, `<html lang="${escapeHtml(lang)}"$1`)
+            : inner
+        : `<html lang="${escapeHtml(lang ?? 'en-US')}">\n${inner}\n</html>`;
+    // Non-streaming case: preserve existing single-shot behavior.
+    if (streamingLoaders.length === 0) {
+        return c.html(`<!doctype html>${fullHtml}`);
+    }
+    // Streaming case: split at </body> so we can interleave per-loader chunk
+    // script tags between the rendered body and the closing tags.
+    const bodyCloseIdx = fullHtml.lastIndexOf('</body>');
+    const beforeBody = bodyCloseIdx >= 0 ? fullHtml.slice(0, bodyCloseIdx) : fullHtml;
+    const afterBody = bodyCloseIdx >= 0 ? fullHtml.slice(bodyCloseIdx) : '';
+    // Inline bootstrap installs a queue on window.__HP_STREAM__ so that
+    // events flushed BEFORE the client bundle loads are buffered. The
+    // client entry calls installStreamRegistry() which drains the queue.
+    // Each emitted script self-removes after running so the DOM doesn't
+    // accumulate inert <script> nodes over the life of the page.
+    //
+    // The queue is capped at HP_STREAM_QUEUE_CAP events. If the client bundle
+    // never loads (slow network, blocked CDN, ad-blocker on the script URL),
+    // a long-running streaming page would otherwise grow this buffer without
+    // bound. When the cap is hit, additional events are silently dropped and
+    // `capped` is set so installStreamRegistry can see lossage occurred.
+    // Picked 1000 so realistic apps (50-100 chunks per page is high) never
+    // hit it; pathological cases trade data loss for bounded memory.
+    const HP_STREAM_QUEUE_CAP = 1000;
+    const bootstrap = `<script>window.__HP_STREAM__=window.__HP_STREAM__||{queue:[],capped:false,` +
+        `_p(e){if(this.queue.length>=${HP_STREAM_QUEUE_CAP}){this.capped=true;return}this.queue.push(e)},` +
+        `push(id,v){this._p({type:"push",loaderId:id,value:v})},` +
+        `end(id){this._p({type:"end",loaderId:id})},` +
+        `error(id,e){this._p({type:"error",loaderId:id,error:e})}};` +
+        `document.currentScript.remove()</script>`;
+    const encoder = new TextEncoder();
+    const requestSignal = c.req.raw.signal;
+    // Tracks whether the consumer (Hono/runtime) has cancelled or the request
+    // signal has aborted. Set by `cancel()` and by the abort listener below.
+    // Every controller op in the pump short-circuits when this is true so we
+    // do not enqueue or close on an already-terminated controller (which would
+    // throw and, for the per-loader catch, get logged as a synthetic error
+    // chunk that nobody can read anyway).
+    let aborted = false;
+    const responseStream = new ReadableStream({
+        start(controller) {
+            // Re-enter the captured request scope so generator continuations and
+            // anything they touch (e.g. `getRequestHonoContext`, per-request loader
+            // caches) see the same per-request store the initial prerender saw.
+            return bindRequestScope(async () => {
+                try {
+                    if (aborted)
+                        return;
+                    controller.enqueue(encoder.encode(`<!doctype html>${beforeBody}\n${bootstrap}\n`));
+                    // Drive each pending generator in parallel; emit script tags per chunk.
+                    await Promise.all(streamingLoaders.map(async ({ loaderId, gen }) => {
+                        try {
+                            while (!aborted) {
+                                const step = await gen.next();
+                                if (aborted)
+                                    return;
+                                if (step.done) {
+                                    controller.enqueue(encoder.encode(`<script>window.__HP_STREAM__.end(${jsonForScript(loaderId)});document.currentScript.remove()</script>\n`));
+                                    return;
+                                }
+                                controller.enqueue(encoder.encode(`<script>window.__HP_STREAM__.push(${jsonForScript(loaderId)},${jsonForScript(step.value)});document.currentScript.remove()</script>\n`));
+                            }
+                        }
+                        catch (err) {
+                            if (aborted)
+                                return;
+                            const message = err instanceof Error ? err.message : String(err);
+                            const name = err instanceof Error ? err.name : 'Error';
+                            controller.enqueue(encoder.encode(`<script>window.__HP_STREAM__.error(${jsonForScript(loaderId)},${jsonForScript({ message, name })});document.currentScript.remove()</script>\n`));
+                        }
+                    }));
+                    if (!aborted)
+                        controller.enqueue(encoder.encode(afterBody));
+                }
+                finally {
+                    if (!aborted)
+                        controller.close();
+                }
+            });
+        },
+        cancel() {
+            aborted = true;
+            for (const { gen } of streamingLoaders) {
+                gen.return(undefined).catch(() => {
+                    /* swallow */
+                });
+            }
+        },
+    });
+    requestSignal.addEventListener('abort', () => {
+        aborted = true;
+        for (const { gen } of streamingLoaders) {
+            gen.return(undefined).catch(() => {
+                /* swallow */
+            });
+        }
+    });
+    return new Response(responseStream, {
+        status: 200,
+        headers: {
+            'Content-Type': 'text/html; charset=utf-8',
+            'Transfer-Encoding': 'chunked',
+            // Prevent buffering / transformation by intermediate proxies. nginx
+            // honors `X-Accel-Buffering: no` to flush per chunk; `no-transform`
+            // stops middleboxes from rebuffering or gzipping the stream as a
+            // single response. We deliberately do NOT add `no-store`: streamed
+            // HTML can still be legitimately cacheable, and users can override
+            // via their own middleware.
+            'X-Accel-Buffering': 'no',
+            'Cache-Control': 'no-transform',
+        },
+    });
+}

package/dist/server/route-server-modules.d.ts

@@ -0,0 +1,12 @@
+import type { RoutesManifest } from '../iso/index';
+/**
+ * Convert a RoutesManifest into the array of lazy server-module loaders
+ * that loadersHandler / actionsHandler accept. Previously returned a record
+ * keyed by stringified integers; those keys were unused at the call site
+ * (handlers iterate values only), so the array form is just the same data
+ * without dead surface. Vite-style globs (`Record<string, ...>`) are still
+ * accepted by the handlers directly; this helper is for the
+ * routes-manifest-driven path used by the framework's generated server
+ * entry.
+ */
+export declare function routeServerModules(manifest: RoutesManifest): ReadonlyArray<() => Promise<unknown>>;

package/dist/server/route-server-modules.js

@@ -0,0 +1,13 @@
+/**
+ * Convert a RoutesManifest into the array of lazy server-module loaders
+ * that loadersHandler / actionsHandler accept. Previously returned a record
+ * keyed by stringified integers; those keys were unused at the call site
+ * (handlers iterate values only), so the array form is just the same data
+ * without dead surface. Vite-style globs (`Record<string, ...>`) are still
+ * accepted by the handlers directly; this helper is for the
+ * routes-manifest-driven path used by the framework's generated server
+ * entry.
+ */
+export function routeServerModules(manifest) {
+    return manifest.serverImports;
+}

package/dist/server/sse.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from 'hono';
+export type SseGeneratorOptions = {
+    /** When true, the generator's return value is emitted as `event: result`. */
+    emitResult?: boolean;
+};
+/**
+ * Wrap an async generator as an SSE response.
+ *
+ * Each yield is JSON-encoded and written as a `data:` event.
+ * If `emitResult` is true and the generator's return value is defined,
+ * it is written as `event: result\ndata: <json>` before the stream closes.
+ * If the generator throws, an `event: error\ndata: {"message","name"}` frame
+ * is written and the stream closes cleanly (Hono's default error handler is
+ * never invoked because we catch inside the callback).
+ */
+export declare function sseGeneratorResponse(c: Context, gen: AsyncGenerator<unknown, unknown, unknown>, options?: SseGeneratorOptions): Response;
+/**
+ * Wrap a ReadableStream<T> (with T a JSON-encodable value) as an SSE response.
+ * Each enqueued chunk is JSON-encoded and written as a `data:` event.
+ */
+export declare function sseReadableStreamResponse(c: Context, source: ReadableStream<unknown>): Response;
+export declare function isAsyncGenerator(value: unknown): value is AsyncGenerator<unknown, unknown, unknown>;