hono-preact 0.1.0 → 0.2.0

package/dist/server/render.js

@@ -1,8 +1,8 @@
 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';
+import { env, isOutcome, } from '../iso/index.js';
+import { HonoRequestContext, runRequestScope, captureRequestScope, takeServerStreamingLoaders, dispatchServer, partitionUse, } from '../iso/internal.js';
 function escapeHtml(str) {
     return str
         .replace(/&/g, '&')
@@ -24,6 +24,27 @@ function toAttrs(obj) {
         .map(([k, v]) => `${k}="${escapeHtml(String(v))}"`)
         .join(' ');
 }
+// Outcome translation for the root chain dispatched around prerender. The
+// root layer (appConfig.use) only legitimately produces `redirect` or
+// `deny`; a `render` outcome is page-scope and must not flow through here.
+// Defense-in-depth: surface programmer error as a 500 rather than crash.
+function translateRootOutcome(c, outcome) {
+    if (outcome.__outcome === 'redirect') {
+        if (outcome.headers) {
+            for (const [k, v] of Object.entries(outcome.headers))
+                c.header(k, v);
+        }
+        return c.redirect(outcome.to, outcome.status);
+    }
+    if (outcome.__outcome === 'deny') {
+        if (outcome.headers) {
+            for (const [k, v] of Object.entries(outcome.headers))
+                c.header(k, v);
+        }
+        return c.text(outcome.message ?? 'Forbidden', outcome.status);
+    }
+    return c.text('render outcome is page-scope only and cannot be issued by root middleware', 500);
+}
 export async function renderPage(c, node, options) {
     const dispatcher = createDispatcher();
     const previousEnv = env.current;
@@ -37,33 +58,68 @@ export async function renderPage(c, node, options) {
     // binder restores per-request isolation for `getRequestStore` /
     // `getRequestHonoContext` reads from generator continuations.
     let bindRequestScope = (fn) => fn();
+    let rootResult;
     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.
+        rootResult = await runRequestScope(async () => {
             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 };
+            const location = {
+                path: reqUrl.pathname,
+                searchParams: Object.fromEntries(reqUrl.searchParams),
+                // Path params are route-match output; the root layer runs before
+                // route matching, so they're empty here. Page-layer middleware
+                // (added in a follow-up) will have them populated.
+                pathParams: {},
+            };
+            const rootUse = options?.appConfig?.use ?? [];
+            const serverMw = partitionUse(rootUse).middleware.filter((m) => m.runs === 'server');
+            const ctx = {
+                scope: 'page',
+                c,
+                signal: c.req.raw.signal,
+                location,
+            };
+            const dispatch = await dispatchServer({
+                middleware: serverMw,
+                ctx,
+                inner: 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.
+                    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 {
+                        kind: 'value',
+                        html: rendered.html,
+                        streamingLoaders: loaders,
+                    };
+                },
+            });
+            if (dispatch.kind === 'outcome') {
+                return { kind: 'outcome', outcome: dispatch.outcome };
+            }
+            return dispatch.value;
         }, { honoContext: c });
-        html = result.html;
-        streamingLoaders = result.streamingLoaders;
     }
     catch (e) {
-        if (e instanceof GuardRedirect)
-            return c.redirect(e.location);
+        if (isOutcome(e))
+            return translateRootOutcome(c, e);
         throw e;
     }
     finally {
         env.current = previousEnv;
     }
+    if (rootResult.kind === 'outcome') {
+        return translateRootOutcome(c, rootResult.outcome);
+    }
+    html = rootResult.html;
+    streamingLoaders = rootResult.streamingLoaders;
     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>)
@@ -137,6 +193,16 @@ export async function renderPage(c, node, options) {
                     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 {
@@ -185,19 +251,24 @@ export async function renderPage(c, node, options) {
             });
         }
     });
-    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',
-        },
+    // Route through `c.body()` rather than `new Response(...)` so Hono merges
+    // its prepared headers into the streamed response. A streaming loader's
+    // body runs up to its first `yield` during prerender, so a `Set-Cookie`
+    // written via `ctx.c` before that yield is sitting in Hono's prepared
+    // headers by now; constructing the Response directly would drop it. The
+    // non-streaming branch above gets this for free via `c.html()`. Cookies
+    // written after a yield run in the pump below, once headers are already
+    // sent, and are unavoidably lost.
+    return c.body(responseStream, 200, {
+        '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

@@ -1,4 +1,4 @@
-import type { RoutesManifest } from '../iso/index';
+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
@@ -10,3 +10,44 @@ import type { RoutesManifest } from '../iso/index';
  * 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;
+ * 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).
+ *
+ * Ancestor composition: each ServerRoute carries an explicit list of
+ * ancestor server thunks captured during the route-tree walk. The
+ * resolver loads each ancestor's `pageUse` (if any) and concatenates them
+ * outer-first, with the route's own pageUse appended last. So a layout
+ * group's pageUse runs before each nested leaf's pageUse without the user
+ * having to repeat the import in every leaf .server.*. Order matches the
+ * middleware dispatcher's outer -> inner contract: app -> outermost
+ * layout -> ... -> leaf -> per-unit.
+ *
+ * Why route-tree ancestry (not URL-prefix ancestry): two routes can share
+ * a URL prefix without being parent/child in the tree. For example,
+ * `/demo/projects` and `/demo/projects/:projectId/issues/:issueId` are
+ * siblings of the `/demo` layout group; the latter is NOT a descendant of
+ * the former. URL-prefix matching incorrectly conflates them and runs the
+ * shared gate twice on every nested request.
+ *
+ * Lazy semantics: the first call to either resolver triggers the build of
+ * all server modules listed in `serverRoutes`. Subsequent calls return
+ * from the cached map. A failed build is not cached -- the next call
+ * retries -- so a transient import error doesn't permanently poison the
+ * resolver. Modules that don't export `pageUse` (the common case today)
+ * contribute nothing to the composed arrays. When `dev` is true the cache
+ * is bypassed on every call so editing a `.server.*` file's `pageUse`
+ * takes effect without restarting the server.
+ *
+ * NOTE: framework-private. The only intended consumer outside tests is
+ * the generated server entry. Reach for it at your own risk.
+ */
+export declare function makePageUseResolvers(serverRoutes: ReadonlyArray<ServerRoute>, options?: {
+    dev?: boolean;
+}): {
+    byPath: (path: string) => Promise<ReadonlyArray<unknown>>;
+    byModuleKey: (key: string) => Promise<ReadonlyArray<unknown>>;
+};

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

@@ -11,3 +11,187 @@
 export function routeServerModules(manifest) {
     return manifest.serverImports;
 }
+function segmentsOf(path) {
+    return path.split('/').filter((s) => s !== '');
+}
+/**
+ * True when `urlPath` (the concrete URL the user navigated to, with all
+ * params substituted) matches `pattern` exactly: same segment count, and
+ * each pattern segment either equals the URL segment, is a `:param`, or is
+ * a trailing `*`.
+ *
+ * Used at lookup time. `byPath` resolves the URL to the most specific
+ * pattern in the map and returns its already-composed pageUse.
+ */
+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;
+}
+/**
+ * Score a route pattern for tiebreaker purposes when multiple patterns at
+ * the same segment depth match the URL. Mirrors preact-iso's runtime
+ * preference for literal segments: literal=2, param=1, wildcard=0. Within
+ * the same score, the caller falls back to depth, and within the same
+ * depth, to the loaded order in `serverRoutes`. Pre-merged literal wins
+ * over `/admin/users/:id` when the URL is `/admin/users/me`.
+ */
+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;
+}
+function pageUseFromMod(mod, patternPath) {
+    if (mod.pageUse === undefined || mod.pageUse === null)
+        return [];
+    if (Array.isArray(mod.pageUse))
+        return mod.pageUse;
+    // Runtime guard for non-array pageUse: surface a descriptive error so
+    // the user finds the typo (`pageUse = mySingleMw` instead of `[mySingleMw]`)
+    // immediately rather than experiencing a silent gate failure. The
+    // build-time plugin should catch this first; this is the runtime backstop.
+    throw new Error(`Route '${patternPath}' exports a non-array \`pageUse\`. ` +
+        `pageUse must be an array (typically a reference to a const declared as \`[mw1, mw2]\`). ` +
+        `Wrap a single middleware in brackets: pageUse = [myMiddleware].`);
+}
+/**
+ * Build the two page-layer `use` resolvers wired into loadersHandler and
+ * actionsHandler. 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).
+ *
+ * Ancestor composition: each ServerRoute carries an explicit list of
+ * ancestor server thunks captured during the route-tree walk. The
+ * resolver loads each ancestor's `pageUse` (if any) and concatenates them
+ * outer-first, with the route's own pageUse appended last. So a layout
+ * group's pageUse runs before each nested leaf's pageUse without the user
+ * having to repeat the import in every leaf .server.*. Order matches the
+ * middleware dispatcher's outer -> inner contract: app -> outermost
+ * layout -> ... -> leaf -> per-unit.
+ *
+ * Why route-tree ancestry (not URL-prefix ancestry): two routes can share
+ * a URL prefix without being parent/child in the tree. For example,
+ * `/demo/projects` and `/demo/projects/:projectId/issues/:issueId` are
+ * siblings of the `/demo` layout group; the latter is NOT a descendant of
+ * the former. URL-prefix matching incorrectly conflates them and runs the
+ * shared gate twice on every nested request.
+ *
+ * Lazy semantics: the first call to either resolver triggers the build of
+ * all server modules listed in `serverRoutes`. Subsequent calls return
+ * from the cached map. A failed build is not cached -- the next call
+ * retries -- so a transient import error doesn't permanently poison the
+ * resolver. Modules that don't export `pageUse` (the common case today)
+ * contribute nothing to the composed arrays. When `dev` is true the cache
+ * is bypassed on every call so editing a `.server.*` file's `pageUse`
+ * takes effect without restarting the server.
+ *
+ * NOTE: framework-private. The only intended consumer outside tests is
+ * the generated server entry. Reach for it at your own risk.
+ */
+export function makePageUseResolvers(serverRoutes, options = {}) {
+    const dev = options.dev ?? false;
+    let buildPromise = null;
+    const build = async () => {
+        // Load every distinct server thunk exactly once. A given thunk may
+        // appear as `server` on one ServerRoute and as an `ancestor` on
+        // descendants; calling it just once keeps module-init side effects
+        // (e.g. logging, registry insertion) idempotent.
+        const thunkCache = new Map();
+        const load = (thunk) => {
+            let p = thunkCache.get(thunk);
+            if (!p) {
+                p = thunk().then((mod) => mod);
+                thunkCache.set(thunk, p);
+            }
+            return p;
+        };
+        const composedByPath = new Map();
+        const patternByModuleKey = new Map();
+        await Promise.all(serverRoutes.map(async (route) => {
+            const ancestorMods = await Promise.all(route.ancestors.map((t) => load(t)));
+            const selfMod = await load(route.server);
+            const composed = [];
+            for (let i = 0; i < ancestorMods.length; i++) {
+                composed.push(...pageUseFromMod(ancestorMods[i], route.path));
+            }
+            composed.push(...pageUseFromMod(selfMod, route.path));
+            // Two ServerRoutes sharing the same path mean two `.server.*` files
+            // claim the same route -- a route-table error. The route validator
+            // is the right place to surface that; here we simply preserve the
+            // load order (last write wins for the composed map, which matches
+            // the previous behavior of `composedByPath.set(path, ...)`).
+            composedByPath.set(route.path, composed);
+            if (typeof selfMod.__moduleKey === 'string') {
+                patternByModuleKey.set(selfMod.__moduleKey, route.path);
+            }
+        }));
+        return { composedByPath, patternByModuleKey };
+    };
+    const get = () => {
+        if (dev) {
+            // In dev, always rebuild so edits to `pageUse` in any .server.* file
+            // take effect on the next request without restarting the process.
+            return build();
+        }
+        if (buildPromise)
+            return buildPromise;
+        buildPromise = build().catch((err) => {
+            buildPromise = null;
+            return Promise.reject(err);
+        });
+        return buildPromise;
+    };
+    return {
+        async byPath(path) {
+            const { composedByPath } = await get();
+            // The handler receives the matched route's URL path (params
+            // substituted to literal values). Walk the composed map and pick the
+            // best-matching pattern. Tiebreaker: (1) higher specificity score
+            // (literal=2, param=1, wildcard=0); (2) within same score, longer
+            // path; (3) within same length, first inserted. Mirrors preact-iso's
+            // runtime preference for literal matches over parameterized siblings.
+            //
+            // NOTE: O(routes) linear scan. Fine for small apps; a precomputed
+            // trie or a request-keyed memo would help at scale.
+            let bestPattern = null;
+            let bestScore = -1;
+            let bestDepth = -1;
+            for (const pattern of composedByPath.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 ? (composedByPath.get(bestPattern) ?? []) : [];
+        },
+        async byModuleKey(key) {
+            const { composedByPath, patternByModuleKey } = await get();
+            const pattern = patternByModuleKey.get(key);
+            return pattern ? (composedByPath.get(pattern) ?? []) : [];
+        },
+    };
+}

package/dist/server/sse.d.ts

@@ -1,7 +1,19 @@
 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`. */
     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.
+     */
+    observers?: ReadonlyArray<StreamObserver<unknown, never>>;
+    /** Server-stream ctx threaded to each observer hook. */
+    observerCtx?: ServerStreamCtx;
 };
 /**
  * Wrap an async generator as an SSE response.
@@ -12,11 +24,22 @@ export type SseGeneratorOptions = {
  * 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(...)`.
  */
 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.
+ *
+ * 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.
  */
-export declare function sseReadableStreamResponse(c: Context, source: ReadableStream<unknown>): Response;
+export declare function sseReadableStreamResponse(c: Context, source: ReadableStream<unknown>, options?: {
+    observers?: ReadonlyArray<StreamObserver<unknown, never>>;
+    observerCtx?: ServerStreamCtx;
+}): Response;
 export declare function isAsyncGenerator(value: unknown): value is AsyncGenerator<unknown, unknown, unknown>;

package/dist/server/sse.js

@@ -1,4 +1,5 @@
 import { streamSSE } from 'hono/streaming';
+import { fanStart, fanChunk, fanEnd, fanError, fanAbort, } from '../iso/internal.js';
 function encodeErrorPayload(err) {
     const message = err instanceof Error ? err.message : String(err);
     const name = err instanceof Error ? err.name : 'Error';
@@ -13,10 +14,21 @@ function encodeErrorPayload(err) {
  * 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(...)`.
  */
 export function sseGeneratorResponse(c, gen, options = {}) {
-    const { emitResult = false } = options;
+    const { emitResult = false, observers, observerCtx } = options;
+    const obs = observers ?? [];
     return streamSSE(c, async (stream) => {
+        let chunks = 0;
+        let started = false;
+        if (obs.length > 0 && observerCtx) {
+            fanStart(obs, observerCtx);
+            started = true;
+        }
         try {
             while (!stream.aborted) {
                 const step = await gen.next();
@@ -27,19 +39,33 @@ export function sseGeneratorResponse(c, gen, options = {}) {
                             data: JSON.stringify(step.value),
                         });
                     }
+                    if (started && observerCtx) {
+                        fanEnd(obs, observerCtx, { chunks, result: step.value });
+                    }
                     return;
                 }
                 await stream.writeSSE({ data: JSON.stringify(step.value) });
+                if (started && observerCtx) {
+                    fanChunk(obs, observerCtx, step.value, chunks);
+                }
+                chunks += 1;
             }
-            // Aborted; release the generator cleanly.
+            // 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 */
             });
+            if (started && observerCtx) {
+                fanError(obs, observerCtx, err, { chunks });
+            }
             await stream.writeSSE({
                 event: 'error',
                 data: encodeErrorPayload(err),
@@ -50,19 +76,45 @@ export function sseGeneratorResponse(c, 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 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.
  */
-export function sseReadableStreamResponse(c, source) {
+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 (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),

package/dist/vite/adapter-cloudflare.d.ts

@@ -0,0 +1,2 @@
+import type { HonoPreactAdapter } from './adapter.js';
+export declare function cloudflareAdapter(): HonoPreactAdapter;

package/dist/vite/adapter-cloudflare.js

@@ -0,0 +1,25 @@
+// packages/vite/src/adapter-cloudflare.ts
+//
+// Standalone module. NOT re-exported by index.ts: importing `hono-preact/vite`
+// must never pull in `@cloudflare/vite-plugin`. Only importing
+// `hono-preact/adapter-cloudflare` loads this file.
+import { cloudflare } from '@cloudflare/vite-plugin';
+export function cloudflareAdapter() {
+    return {
+        name: 'cloudflare',
+        vitePlugins() {
+            // `@cloudflare/vite-plugin` drives both workerd dev and the build via
+            // the Environment API, and reads the worker entry from wrangler.jsonc
+            // `main`. It needs no entry argument from the framework.
+            // `cloudflare()` may return a single plugin or an array; normalize so
+            // the HonoPreactAdapter contract (a flat Plugin[]) holds either way.
+            const produced = cloudflare();
+            return Array.isArray(produced) ? produced : [produced];
+        },
+        wrapEntry(ctx) {
+            // A Hono app's default export is already a valid Workers fetch handler,
+            // so the platform tail is a bare re-export of the core app module.
+            return `export { default } from ${JSON.stringify(ctx.coreAppModuleId)};\n`;
+        },
+    };
+}

package/dist/vite/adapter-node.d.ts

@@ -0,0 +1,2 @@
+import type { HonoPreactAdapter } from './adapter.js';
+export declare function nodeAdapter(): HonoPreactAdapter;

package/dist/vite/adapter-node.js

@@ -0,0 +1,49 @@
+import { nodeBuildPlugin, nodeDevServerPlugin } from './node-dev-server.js';
+export function nodeAdapter() {
+    return {
+        name: 'node',
+        vitePlugins(ctx) {
+            return [nodeBuildPlugin(ctx), nodeDevServerPlugin(ctx)];
+        },
+        wrapEntry(ctx) {
+            const hasApi = ctx.apiModuleId != null;
+            const apiImport = hasApi
+                ? `import * as __api from ${JSON.stringify(ctx.apiModuleId)};\n`
+                : '';
+            const injectExport = hasApi
+                ? `export const injectWebSocket = __api.injectWebSocket;\n`
+                : '';
+            const injectBoot = hasApi
+                ? `  if (__api.injectWebSocket) __api.injectWebSocket(server);\n`
+                : '';
+            // The outer app serves built client assets under /static/* and mounts
+            // the framework's core Hono app at the root.
+            //
+            // The serve() boot is guarded by `import.meta.env.PROD`. In `vite dev`
+            // the Node dev plugin loads this wrapper through the SSR module runner
+            // purely to obtain `app` (and `injectWebSocket`); PROD is false there so
+            // no rogue HTTP server starts. In the production build it constant-folds
+            // to true and the bundle boots a real server.
+            return (`import { serve } from '@hono/node-server';\n` +
+                `import { serveStatic } from '@hono/node-server/serve-static';\n` +
+                `import { Hono } from 'hono';\n` +
+                `import coreApp from ${JSON.stringify(ctx.coreAppModuleId)};\n` +
+                apiImport +
+                `\n` +
+                `const app = new Hono()\n` +
+                `  .use('/static/*', serveStatic({ root: './dist/client' }))\n` +
+                `  .route('/', coreApp);\n` +
+                `\n` +
+                `export { app };\n` +
+                `export default app;\n` +
+                injectExport +
+                `\n` +
+                `if (import.meta.env.PROD) {\n` +
+                `  const port = Number(process.env.PORT) || 3000;\n` +
+                `  const server = serve({ fetch: app.fetch, port });\n` +
+                `  console.log(\`hono-preact: listening on http://localhost:\${port}\`);\n` +
+                injectBoot +
+                `}\n`);
+        },
+    };
+}