hono-preact 0.2.0 → 0.4.0

package/dist/server/page-action-resolvers.js

@@ -0,0 +1,147 @@
+function extractActions(mod) {
+    const moduleKey = mod.__moduleKey;
+    if (typeof moduleKey !== 'string' || !mod.serverActions)
+        return [];
+    const out = [];
+    for (const [name, val] of Object.entries(mod.serverActions)) {
+        if (typeof val !== 'function')
+            continue;
+        // `defineAction` attaches `use` and `timeoutMs` as non-enumerable
+        // properties on the function (see packages/iso/src/action.ts). Read
+        // them here as the single deserialization boundary; the handler reads
+        // `entry.fn`, `entry.use`, `entry.timeoutMs` through the typed
+        // ActionEntry shape from this point on.
+        const metadata = val;
+        out.push({
+            name,
+            entry: {
+                fn: val,
+                use: metadata.use ?? [],
+                timeoutMs: metadata.timeoutMs,
+                moduleKey,
+            },
+        });
+    }
+    return out;
+}
+function segmentsOf(p) {
+    return p.split('/').filter((s) => s !== '');
+}
+function urlPathMatchesPattern(urlPath, pattern) {
+    const ps = segmentsOf(pattern);
+    const us = segmentsOf(urlPath);
+    for (let i = 0; i < ps.length; i++) {
+        const p = ps[i];
+        if (p === '*')
+            return true;
+        if (i >= us.length)
+            return false;
+        if (p.startsWith(':'))
+            continue;
+        if (p !== us[i])
+            return false;
+    }
+    return ps.length === us.length;
+}
+function patternScore(pattern) {
+    let score = 0;
+    for (const seg of segmentsOf(pattern)) {
+        if (seg === '*')
+            score += 0;
+        else if (seg.startsWith(':'))
+            score += 1;
+        else
+            score += 2;
+    }
+    return score;
+}
+/**
+ * Build action resolvers keyed by route path and by module key. Each
+ * ServerRoute contributes its own serverActions and its ancestors' serverActions
+ * to the merged map for that path. Ancestor entries are written first so that
+ * a page-level action shadows a same-named layout action when names collide.
+ *
+ * Lazy semantics: the first call triggers loading all server modules. The result
+ * is cached for the process lifetime (unless dev=true, which rebuilds on every
+ * call so edits take effect without restarting the server).
+ *
+ * NOTE: framework-private. Intended consumer is the generated server entry and
+ * pageActionHandler.
+ */
+export function makePageActionResolvers(serverRoutes, options = {}) {
+    const dev = options.dev ?? false;
+    let buildPromise = null;
+    const build = async () => {
+        // Load each distinct server thunk once; a thunk may appear as `server`
+        // on one route and as an `ancestor` on its children.
+        const thunkCache = new Map();
+        const load = (thunk) => {
+            let p = thunkCache.get(thunk);
+            if (!p) {
+                p = thunk().then((m) => m);
+                thunkCache.set(thunk, p);
+            }
+            return p;
+        };
+        const byPathMap = new Map();
+        const byModuleKeyMap = new Map();
+        await Promise.all(serverRoutes.map(async (route) => {
+            const ancestorMods = await Promise.all(route.ancestors.map(load));
+            const selfMod = await load(route.server);
+            const merged = new Map();
+            // Write ancestors first (outer -> inner), then self. Later writes
+            // shadow earlier ones, so a page-level action wins over a layout
+            // action of the same name.
+            for (const mod of [...ancestorMods, selfMod]) {
+                for (const { name, entry } of extractActions(mod)) {
+                    merged.set(name, entry);
+                    let m = byModuleKeyMap.get(entry.moduleKey);
+                    if (!m) {
+                        m = new Map();
+                        byModuleKeyMap.set(entry.moduleKey, m);
+                    }
+                    m.set(name, entry);
+                }
+            }
+            byPathMap.set(route.path, merged);
+        }));
+        return { byPathMap, byModuleKeyMap };
+    };
+    const get = () => {
+        if (dev)
+            return build();
+        if (buildPromise)
+            return buildPromise;
+        buildPromise = build().catch((err) => {
+            buildPromise = null;
+            return Promise.reject(err);
+        });
+        return buildPromise;
+    };
+    return {
+        async byPath(path) {
+            const { byPathMap } = await get();
+            let bestPattern = null;
+            let bestScore = -1;
+            let bestDepth = -1;
+            for (const pattern of byPathMap.keys()) {
+                if (!urlPathMatchesPattern(path, pattern))
+                    continue;
+                const score = patternScore(pattern);
+                const depth = segmentsOf(pattern).length;
+                if (score > bestScore || (score === bestScore && depth > bestDepth)) {
+                    bestPattern = pattern;
+                    bestScore = score;
+                    bestDepth = depth;
+                }
+            }
+            return bestPattern
+                ? (byPathMap.get(bestPattern) ?? new Map())
+                : new Map();
+        },
+        async byModuleKey(moduleKey, actionName) {
+            const { byModuleKeyMap } = await get();
+            return byModuleKeyMap.get(moduleKey)?.get(actionName);
+        },
+    };
+}

package/dist/server/render.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx } from "preact/jsx-runtime";
 import { createDispatcher, HoofdProvider } from 'hoofd/preact';
 import { prerender, locationStub } from 'preact-iso/prerender';
-import { env, isOutcome, } from '../iso/index.js';
-import { HonoRequestContext, runRequestScope, captureRequestScope, takeServerStreamingLoaders, dispatchServer, partitionUse, } from '../iso/internal.js';
+import { env, isOutcome, ActionResultContext, } from '../iso/index.js';
+import { HonoRequestContext, runRequestScope, captureRequestScope, takeServerStreamingLoaders, dispatchServer, partitionUse, getActionResultSlot, } from '../iso/internal.js';
+import { speculationRulesTag } from './speculation-rules.js';
 function escapeHtml(str) {
     return str
         .replace(/&/g, '&')
@@ -45,6 +46,42 @@ function translateRootOutcome(c, outcome) {
     }
     return c.text('render outcome is page-scope only and cannot be issued by root middleware', 500);
 }
+function buildActionResultContext() {
+    const slot = getActionResultSlot();
+    if (!slot)
+        return null;
+    if (slot.resolution.kind === 'success') {
+        return {
+            module: slot.module,
+            action: slot.action,
+            kind: 'success',
+            data: slot.resolution.data,
+            submittedPayload: slot.submittedPayload,
+        };
+    }
+    if (slot.resolution.kind === 'error') {
+        return {
+            module: slot.module,
+            action: slot.action,
+            kind: 'error',
+            message: slot.resolution.message,
+            submittedPayload: slot.submittedPayload,
+        };
+    }
+    const { outcome } = slot.resolution;
+    if (outcome.__outcome === 'deny') {
+        return {
+            module: slot.module,
+            action: slot.action,
+            kind: 'deny',
+            status: outcome.status,
+            message: outcome.message,
+            data: outcome.data,
+            submittedPayload: slot.submittedPayload,
+        };
+    }
+    return null;
+}
 export async function renderPage(c, node, options) {
     const dispatcher = createDispatcher();
     const previousEnv = env.current;
@@ -92,7 +129,7 @@ export async function renderPage(c, node, options) {
                     // while we await suspended children.
                     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 rendered = await prerender(_jsx(ActionResultContext.Provider, { value: buildActionResultContext(), children: _jsx(HonoRequestContext.Provider, { value: { context: c }, children: _jsx(HoofdProvider, { value: dispatcher, children: node }) }) }));
                     const loaders = takeServerStreamingLoaders();
                     return {
                         kind: 'value',
@@ -130,6 +167,7 @@ export async function renderPage(c, node, options) {
         titleSource != null ? `<title>${escapeHtml(titleSource)}</title>` : '',
         ...metas.map((m) => `<meta ${toAttrs(m)} />`),
         ...links.map((l) => `<link ${toAttrs(l)} />`),
+        speculationRulesTag(options?.appConfig ?? {}),
     ]
         .filter(Boolean)
         .join('\n        ');
@@ -183,65 +221,105 @@ export async function renderPage(c, node, options) {
     // 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 () => {
+    // Multi-producer backpressure via TransformStream. Each loader pump writes
+    // to a shared `writer`, awaiting `writer.ready` before each write so that
+    // the per-loader iteration is paced by the consumer's read rate (not by
+    // however fast the generator yields). Without this, a tight-loop streaming
+    // loader would buffer chunks into the ReadableStream queue unbounded; see
+    // render-stream.test.tsx "pauses production when the HTML consumer is
+    // slow (backpressure)".
+    const { writable, readable: responseStream } = new TransformStream();
+    const writer = writable.getWriter();
+    // When the consumer cancels the readable side (e.g. Hono drops the response,
+    // or the runtime tears down the request), the writable side transitions to
+    // an errored state and `writer.closed` rejects. Propagate to the loader
+    // generators symmetrically with the request-signal abort path below. The
+    // `aborted` guard makes the self-triggered case (`writer.abort()` in our
+    // own finally) a no-op.
+    writer.closed.catch(() => {
+        if (aborted)
+            return;
+        aborted = true;
+        for (const { gen } of streamingLoaders) {
+            gen.return(undefined).catch(() => {
+                /* swallow */
+            });
+        }
+    });
+    // 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.
+    void bindRequestScope(async () => {
+        // Yield one microtask before doing anything else. `renderPage` is still
+        // on the synchronous frame that constructs this response (TransformStream
+        // is created, then `c.body(...)` runs and commits the headers). Resuming
+        // a generator can call `setCookie(ctx.c, ...)`, which mutates Hono's
+        // prepared headers; deferring the pump guarantees the response is built
+        // first, so post-first-yield header writes are consistently excluded
+        // rather than racing construction. Cookies must be set before the
+        // loader's first yield to reach the streamed response.
+        await Promise.resolve();
+        try {
+            if (aborted)
+                return;
+            await writer.ready;
+            if (aborted)
+                return;
+            await writer.write(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 {
-                    if (aborted)
-                        return;
-                    controller.enqueue(encoder.encode(`<!doctype html>${beforeBody}\n${bootstrap}\n`));
-                    // Yield one microtask before advancing any loader generator past
-                    // its first yield. `renderPage` is still on the synchronous frame
-                    // that constructs this response (`new ReadableStream(...)` returns,
-                    // then `c.body(...)` runs and commits the headers). Resuming a
-                    // generator can call `setCookie(ctx.c, ...)`, which mutates Hono's
-                    // prepared headers; deferring the pump guarantees the response is
-                    // built first, so post-first-yield header writes are consistently
-                    // excluded rather than racing construction. Cookies must be set
-                    // before the loader's first yield to reach the streamed response.
-                    await Promise.resolve();
-                    // 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`));
+                    while (!aborted) {
+                        const step = await gen.next();
+                        if (aborted)
+                            return;
+                        await writer.ready;
+                        if (aborted)
+                            return;
+                        if (step.done) {
+                            await writer.write(encoder.encode(`<script>window.__HP_STREAM__.end(${jsonForScript(loaderId)});document.currentScript.remove()</script>\n`));
+                            return;
                         }
-                    }));
-                    if (!aborted)
-                        controller.enqueue(encoder.encode(afterBody));
+                        await writer.write(encoder.encode(`<script>window.__HP_STREAM__.push(${jsonForScript(loaderId)},${jsonForScript(step.value)});document.currentScript.remove()</script>\n`));
+                    }
                 }
-                finally {
-                    if (!aborted)
-                        controller.close();
+                catch (err) {
+                    if (aborted)
+                        return;
+                    const message = err instanceof Error ? err.message : String(err);
+                    const name = err instanceof Error ? err.name : 'Error';
+                    try {
+                        await writer.ready;
+                        if (aborted)
+                            return;
+                        await writer.write(encoder.encode(`<script>window.__HP_STREAM__.error(${jsonForScript(loaderId)},${jsonForScript({ message, name })});document.currentScript.remove()</script>\n`));
+                    }
+                    catch {
+                        /* swallow: writable side closed/errored */
+                    }
                 }
-            });
-        },
-        cancel() {
-            aborted = true;
-            for (const { gen } of streamingLoaders) {
-                gen.return(undefined).catch(() => {
+            }));
+            if (!aborted) {
+                await writer.ready;
+                if (!aborted)
+                    await writer.write(encoder.encode(afterBody));
+            }
+        }
+        catch {
+            /* swallow: writable side closed/errored mid-pump */
+        }
+        finally {
+            if (aborted) {
+                writer.abort().catch(() => {
+                    /* swallow */
+                });
+            }
+            else {
+                writer.close().catch(() => {
                     /* swallow */
                 });
             }
-        },
+        }
     });
     requestSignal.addEventListener('abort', () => {
         aborted = true;
@@ -250,6 +328,9 @@ export async function renderPage(c, node, options) {
                 /* swallow */
             });
         }
+        writer.abort().catch(() => {
+            /* swallow */
+        });
     });
     // Route through `c.body()` rather than `new Response(...)` so Hono merges
     // its prepared headers into the streamed response. A streaming loader's

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

@@ -1,18 +1,17 @@
 import type { RoutesManifest, ServerRoute } 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.
+ * that loadersHandler accepts. 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
+ * loadersHandler 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>>;
 /**
  * Build the two page-layer `use` resolvers wired into loadersHandler and
- * actionsHandler. The loader handler matches by the location's URL path;
+ * pageActionHandler. The loader handler matches by the location's URL path;
  * the action handler matches by the action's owning module key. Both
  * lookups share one underlying composed map populated by loading every
  * routed `.server.*` module exactly once (then caching the result).

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

@@ -1,12 +1,11 @@
 /**
  * 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.
+ * that loadersHandler accepts. 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
+ * loadersHandler 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;
@@ -74,7 +73,7 @@ function pageUseFromMod(mod, patternPath) {
 }
 /**
  * Build the two page-layer `use` resolvers wired into loadersHandler and
- * actionsHandler. The loader handler matches by the location's URL path;
+ * pageActionHandler. The loader handler matches by the location's URL path;
  * the action handler matches by the action's owning module key. Both
  * lookups share one underlying composed map populated by loading every
  * routed `.server.*` module exactly once (then caching the result).

package/dist/server/speculation-rules.d.ts

@@ -0,0 +1,3 @@
+import type { AppConfig } from '../iso/index';
+export declare const SPECULATION_RULES_TAG = "<script type=\"speculationrules\">{\"prefetch\":[{\"where\":{\"and\":[{\"href_matches\":\"/*\"},{\"not\":{\"selector_matches\":\"[data-no-prefetch]\"}}]},\"eagerness\":\"moderate\"}]}</script>";
+export declare function speculationRulesTag(config: AppConfig): string;

package/dist/server/speculation-rules.js

@@ -0,0 +1,8 @@
+const SPECULATION_RULES_JSON = '{"prefetch":[{"where":{"and":[' +
+    '{"href_matches":"/*"},' +
+    '{"not":{"selector_matches":"[data-no-prefetch]"}}' +
+    ']},"eagerness":"moderate"}]}';
+export const SPECULATION_RULES_TAG = `<script type="speculationrules">${SPECULATION_RULES_JSON}</script>`;
+export function speculationRulesTag(config) {
+    return config.speculation === true ? SPECULATION_RULES_TAG : '';
+}

package/dist/server/sse.d.ts

@@ -1,45 +1,60 @@
 import type { Context } from 'hono';
 import type { StreamObserver, ServerStreamCtx } from '../iso/index';
-export type SseGeneratorOptions = {
-    /** When true, the generator's return value is emitted as `event: result`. */
+/**
+ * Options shared by both SSE response helpers. Encodes the lifecycle the SSE
+ * pump runs through:
+ *
+ * - Observer fanout: `onStart` fires before the first chunk, `onChunk` per
+ *   value yielded by the source, `onEnd` on normal completion, `onError` on
+ *   a thrown error, `onAbort` when the consumer cancels the response stream
+ *   before the source finishes.
+ * - Timeout discrimination: when `signal.aborted` and `signal.reason` is a
+ *   `TimeoutError` `DOMException`, the catch path emits `event: timeout`
+ *   with `{ timeoutMs }` instead of the generic `event: error` frame.
+ */
+export type SseResponseOptions = {
+    /**
+     * When true, the generator's return value (if defined) is emitted as
+     * `event: result` before the stream closes. Only meaningful for
+     * generator-sourced responses; ignored for `ReadableStream` sources.
+     */
     emitResult?: boolean;
     /**
      * Stream observers harvested from the loader/action's `use` array (the
-     * non-middleware partition). The SSE pump fires `onStart` before the
-     * first chunk, `onChunk` per yielded value, `onEnd` on clean completion,
-     * `onError` on throw, and `onAbort` when the response stream is aborted
-     * (typically because the client disconnected). Hooks are isolated: a
-     * throwing observer never corrupts the stream.
+     * non-middleware partition). Hooks are isolated: a throwing observer
+     * never corrupts the stream.
      */
     observers?: ReadonlyArray<StreamObserver<unknown, never>>;
     /** Server-stream ctx threaded to each observer hook. */
     observerCtx?: ServerStreamCtx;
+    /**
+     * The handler's timeout signal (from `AbortSignal.timeout(timeoutMs)`),
+     * inspected in the catch path to distinguish a deadline-driven abort
+     * from a generic throw.
+     */
+    signal?: AbortSignal;
+    /** Used only with `signal`; the timeout value reported in the frame. */
+    timeoutMs?: number;
 };
+/** Alias retained for source compatibility with earlier code. */
+export type SseGeneratorOptions = SseResponseOptions;
 /**
  * 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).
- *
- * When `observers` is provided, the pump fires the corresponding lifecycle
- * hooks (`onStart` / `onChunk` / `onEnd` / `onError` / `onAbort`) so
- * users can attach instrumentation via `defineStreamObserver(...)`.
+ * 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` or `event: timeout` frame is written and the
+ * stream closes cleanly. Observer lifecycle hooks (`onStart` / `onChunk` /
+ * `onEnd` / `onError` / `onAbort`) fire from inside the pump.
  */
-export declare function sseGeneratorResponse(c: Context, gen: AsyncGenerator<unknown, unknown, unknown>, options?: SseGeneratorOptions): Response;
+export declare function sseGeneratorResponse(_c: Context, gen: AsyncGenerator<unknown, unknown, unknown>, options?: SseResponseOptions): 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.
- *
- * Observer fanout mirrors `sseGeneratorResponse`: `onStart` fires before the
- * first read, `onChunk` per chunk, `onEnd` on normal completion, `onError` on
- * throw, `onAbort` when the response stream is aborted.
+ * 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. Observer lifecycle hooks fire identically to `sseGeneratorResponse`;
+ * `emitResult` is not meaningful here (streams have no return value) and is
+ * ignored.
  */
-export declare function sseReadableStreamResponse(c: Context, source: ReadableStream<unknown>, options?: {
-    observers?: ReadonlyArray<StreamObserver<unknown, never>>;
-    observerCtx?: ServerStreamCtx;
-}): Response;
+export declare function sseReadableStreamResponse(_c: Context, source: ReadableStream<unknown>, options?: SseResponseOptions): Response;
 export declare function isAsyncGenerator(value: unknown): value is AsyncGenerator<unknown, unknown, unknown>;