hono-preact 0.2.0 → 0.3.0

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        ');

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>;

package/dist/server/sse.js

@@ -1,130 +1,155 @@
-import { streamSSE } from 'hono/streaming';
 import { fanStart, fanChunk, fanEnd, fanError, fanAbort, } from '../iso/internal.js';
+function sseEncodeTransform() {
+    const encoder = new TextEncoder();
+    return new TransformStream({
+        transform(frame, controller) {
+            const lines = [];
+            if (frame.event)
+                lines.push(`event: ${frame.event}`);
+            if (frame.id)
+                lines.push(`id: ${frame.id}`);
+            lines.push(`data: ${frame.data}`);
+            controller.enqueue(encoder.encode(lines.join('\n') + '\n\n'));
+        },
+    });
+}
+function isTimeoutAbort(signal) {
+    return Boolean(signal?.aborted &&
+        signal.reason instanceof DOMException &&
+        signal.reason.name === 'TimeoutError');
+}
 function encodeErrorPayload(err) {
     const message = err instanceof Error ? err.message : String(err);
     const name = err instanceof Error ? err.name : 'Error';
     return JSON.stringify({ message, name });
 }
 /**
- * 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).
+ * Adapt a `ReadableStream<T>` as an async generator (with no return value).
+ * The reader is released in `finally`, which fires either when the consumer
+ * stops iterating or when the source is exhausted.
+ */
+async function* iterReadable(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            yield value;
+        }
+    }
+    finally {
+        reader.cancel().catch(() => undefined);
+    }
+}
+/**
+ * The shared pump implementation. Iterates `source` (a generator that may
+ * return a final value), encodes each yielded value as a JSON `data:` frame,
+ * runs the observer lifecycle, and translates errors into `event: error` or
+ * `event: timeout` frames.
  *
- * When `observers` is provided, the pump fires the corresponding lifecycle
- * hooks (`onStart` / `onChunk` / `onEnd` / `onError` / `onAbort`) so
- * users can attach instrumentation via `defineStreamObserver(...)`.
+ * Observer state (`chunks`, `started`, `finished`) lives in the outer
+ * function scope so the outer ReadableStream's `cancel()` callback can fire
+ * `onAbort` when the consumer cancels mid-stream.
  */
-export function sseGeneratorResponse(c, gen, options = {}) {
-    const { emitResult = false, observers, observerCtx } = options;
+function buildSseResponse(source, options) {
+    const { emitResult = false, observers, observerCtx, signal, timeoutMs, } = options;
     const obs = observers ?? [];
-    return streamSSE(c, async (stream) => {
-        let chunks = 0;
-        let started = false;
+    let chunks = 0;
+    let started = false;
+    let finished = false;
+    async function* framePump() {
         if (obs.length > 0 && observerCtx) {
             fanStart(obs, observerCtx);
             started = true;
         }
         try {
-            while (!stream.aborted) {
-                const step = await gen.next();
+            while (true) {
+                const step = await source.next();
                 if (step.done) {
                     if (emitResult && step.value !== undefined) {
-                        await stream.writeSSE({
-                            event: 'result',
-                            data: JSON.stringify(step.value),
-                        });
+                        yield { event: 'result', data: JSON.stringify(step.value) };
                     }
                     if (started && observerCtx) {
                         fanEnd(obs, observerCtx, { chunks, result: step.value });
                     }
+                    finished = true;
                     return;
                 }
-                await stream.writeSSE({ data: JSON.stringify(step.value) });
+                yield { data: JSON.stringify(step.value) };
                 if (started && observerCtx) {
                     fanChunk(obs, observerCtx, step.value, chunks);
                 }
                 chunks += 1;
             }
-            // Loop exited because the response stream was aborted (typically a
-            // client disconnect). Release the generator and notify observers.
-            await gen.return(undefined).catch(() => {
-                /* swallow */
-            });
-            if (started && observerCtx) {
-                fanAbort(obs, observerCtx, { chunks });
-            }
         }
         catch (err) {
-            await gen.return(undefined).catch(() => {
-                /* swallow */
-            });
+            await source.return(undefined).catch(() => undefined);
             if (started && observerCtx) {
                 fanError(obs, observerCtx, err, { chunks });
             }
-            await stream.writeSSE({
-                event: 'error',
-                data: encodeErrorPayload(err),
-            });
+            if (isTimeoutAbort(signal) && typeof timeoutMs === 'number') {
+                yield { event: 'timeout', data: JSON.stringify({ timeoutMs }) };
+            }
+            else {
+                yield { event: 'error', data: encodeErrorPayload(err) };
+            }
+            finished = true;
         }
+    }
+    const pump = framePump();
+    const body = new ReadableStream({
+        async pull(controller) {
+            const { value, done } = await pump.next();
+            if (done) {
+                controller.close();
+            }
+            else {
+                controller.enqueue(value);
+            }
+        },
+        cancel() {
+            // Consumer cancelled before the pump completed. Notify observers via
+            // `onAbort` exactly when we've genuinely been aborted mid-stream
+            // (i.e. the source started but didn't finish naturally).
+            if (!finished && started && observerCtx) {
+                fanAbort(obs, observerCtx, { chunks });
+            }
+            pump.return(undefined).catch(() => undefined);
+            source.return(undefined).catch(() => undefined);
+        },
+    }).pipeThrough(sseEncodeTransform());
+    return new Response(body, {
+        headers: {
+            'content-type': 'text/event-stream',
+            'cache-control': 'no-cache',
+        },
     });
 }
 /**
- * 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.
+ * Wrap an async generator as an SSE response.
  *
- * 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.
+ * 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 function sseReadableStreamResponse(c, source, options = {}) {
-    const { observers, observerCtx } = options;
-    const obs = observers ?? [];
-    return streamSSE(c, async (stream) => {
-        const reader = source.getReader();
-        let chunks = 0;
-        let started = false;
-        if (obs.length > 0 && observerCtx) {
-            fanStart(obs, observerCtx);
-            started = true;
-        }
-        try {
-            while (!stream.aborted) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    if (started && observerCtx) {
-                        fanEnd(obs, observerCtx, { chunks, result: undefined });
-                    }
-                    return;
-                }
-                await stream.writeSSE({ data: JSON.stringify(value) });
-                if (started && observerCtx) {
-                    fanChunk(obs, observerCtx, value, chunks);
-                }
-                chunks += 1;
-            }
-            if (started && observerCtx) {
-                fanAbort(obs, observerCtx, { chunks });
-            }
-        }
-        catch (err) {
-            if (started && observerCtx) {
-                fanError(obs, observerCtx, err, { chunks });
-            }
-            await stream.writeSSE({
-                event: 'error',
-                data: encodeErrorPayload(err),
-            });
-        }
-        finally {
-            reader.cancel().catch(() => {
-                /* swallow */
-            });
-        }
+export function sseGeneratorResponse(_c, gen, options = {}) {
+    return buildSseResponse(gen, options);
+}
+/**
+ * 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 function sseReadableStreamResponse(_c, source, options = {}) {
+    return buildSseResponse(iterReadable(source), {
+        ...options,
+        emitResult: false,
     });
 }
 export function isAsyncGenerator(value) {

package/dist/vite/server-entry.js

@@ -22,9 +22,10 @@ export function generateCoreAppModule(opts) {
         `import { LocationProvider } from 'preact-iso';\n` +
         `import { Routes, env } from 'hono-preact';\n` +
         `import {\n` +
-        `  actionsHandler,\n` +
         `  loadersHandler,\n` +
+        `  makePageActionResolvers,\n` +
         `  makePageUseResolvers,\n` +
+        `  pageActionHandler,\n` +
         `  renderPage,\n` +
         `  routeServerModules,\n` +
         `} from 'hono-preact/server';\n` +
@@ -37,11 +38,18 @@ export function generateCoreAppModule(opts) {
         `const dev = import.meta.env.DEV;\n` +
         `const serverModules = routeServerModules(routes);\n` +
         `const pageUseResolvers = makePageUseResolvers(routes.serverRoutes, { dev });\n` +
+        `const pageActionResolvers = makePageActionResolvers(routes.serverRoutes, { dev });\n` +
         `\n` +
         `export const app = new Hono()\n` +
         apiMount +
         `  .post('/__loaders', loadersHandler(serverModules, { dev, appConfig, resolvePageUse: pageUseResolvers.byPath }))\n` +
-        `  .post('/__actions', actionsHandler(serverModules, { dev, appConfig, resolvePageUse: pageUseResolvers.byModuleKey }))\n` +
+        `  .post('*', pageActionHandler({\n` +
+        `    resolverByPath: pageActionResolvers.byPath,\n` +
+        `    resolvePageUseByPath: pageUseResolvers.byPath,\n` +
+        `    renderPage,\n` +
+        `    resolvePageNode: () => h(Layout, null, h(LocationProvider, null, h(Routes, { routes }))),\n` +
+        `    appConfig,\n` +
+        `  }))\n` +
         `  .get('*', (c) => renderPage(c, h(Layout, null, h(LocationProvider, null, h(Routes, { routes }))), { appConfig }));\n` +
         `\n` +
         `export default app;\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono-preact",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Hono on the edge, Preact in the browser, manifest driven routes, typed RPC, streaming everywhere.",
   "keywords": [
     "hono",
@@ -95,8 +95,8 @@
   },
   "devDependencies": {
     "typescript": "*",
-    "@hono-preact/iso": "0.1.0",
     "@hono-preact/server": "0.1.0",
+    "@hono-preact/iso": "0.1.0",
     "@hono-preact/vite": "0.1.0"
   },
   "scripts": {