hono-preact 0.1.0 → 0.3.0

package/dist/server/sse.d.ts

@@ -1,22 +1,60 @@
 import type { Context } from 'hono';
-export type SseGeneratorOptions = {
-    /** When true, the generator's return value is emitted as `event: result`. */
+import type { StreamObserver, ServerStreamCtx } from '../iso/index';
+/**
+ * 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). 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).
+ * 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.
+ * 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>): 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,78 +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.
+ * 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.
  *
- * 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).
+ * 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 } = options;
-    return streamSSE(c, async (stream) => {
+function buildSseResponse(source, options) {
+    const { emitResult = false, observers, observerCtx, signal, timeoutMs, } = options;
+    const obs = observers ?? [];
+    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;
             }
-            // Aborted; release the generator cleanly.
-            await gen.return(undefined).catch(() => {
-                /* swallow */
-            });
         }
         catch (err) {
-            await gen.return(undefined).catch(() => {
-                /* swallow */
-            });
-            await stream.writeSSE({
-                event: 'error',
-                data: encodeErrorPayload(err),
-            });
+            await source.return(undefined).catch(() => undefined);
+            if (started && observerCtx) {
+                fanError(obs, observerCtx, err, { chunks });
+            }
+            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.
+ *
+ * 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) {
-    return streamSSE(c, async (stream) => {
-        const reader = source.getReader();
-        try {
-            while (!stream.aborted) {
-                const { done, value } = await reader.read();
-                if (done)
-                    return;
-                await stream.writeSSE({ data: JSON.stringify(value) });
-            }
-        }
-        catch (err) {
-            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/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`);
+        },
+    };
+}

package/dist/vite/adapter.d.ts

@@ -0,0 +1,29 @@
+import type { Plugin } from 'vite';
+/**
+ * Static context the framework hands an adapter. `command` and `outDir`
+ * are intentionally absent: they are not known when honoPreact() builds its
+ * plugin array. Adapters that need them read them from their own plugin
+ * hooks (config / configResolved).
+ */
+export interface HonoPreactAdapterContext {
+    /** Vite project root (process.cwd() when honoPreact() is called). */
+    root: string;
+    /** Absolute path of the framework-generated core Hono app module. */
+    coreAppModuleId: string;
+    /** Absolute path where the adapter's wrapEntry() output is written. */
+    entryWrapperId: string;
+    /** Absolute path of the user's api module, if it exists. Used by adapters
+     *  that need to reach api-module exports (e.g. the Node adapter's
+     *  WebSocket `injectWebSocket`). Undefined when the project has no api.ts. */
+    apiModuleId?: string;
+}
+/**
+ * A deployment target. `vitePlugins()` contributes the terminal build/dev
+ * plugins; `wrapEntry()` returns the platform tail that imports the core
+ * Hono app module and adapts it to the runtime.
+ */
+export interface HonoPreactAdapter {
+    name: string;
+    vitePlugins(ctx: HonoPreactAdapterContext): Plugin[];
+    wrapEntry(ctx: HonoPreactAdapterContext): string;
+}

package/dist/vite/adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/vite/client-shim.js

@@ -17,10 +17,11 @@ export function clientShimPlugin(clientEntry) {
     return {
         name: 'hono-preact:client-shim',
         enforce: 'pre',
-        apply(_, { command, mode }) {
-            // Inject during dev (`vite serve`) and the client build only. The SSR
-            // build runs in Node/Workers and does not need the shim.
-            return command === 'serve' || (command === 'build' && mode === 'client');
+        apply(_, { command }) {
+            // The shim is needed for dev and for the build. The `transform` hook
+            // below self-gates to the client entry module, so it never injects
+            // into SSR/worker code regardless of build environment.
+            return command === 'serve' || command === 'build';
         },
         configResolved(config) {
             resolvedEntry = path.resolve(config.root, clientEntry);

package/dist/vite/guard-strip.js

@@ -2,10 +2,33 @@ import { parse } from '@babel/parser';
 import MagicString from 'magic-string';
 import { BABEL_PARSER_PLUGINS } from './parser-options.js';
 const ISO_PACKAGE_SOURCES = new Set(['../iso/index.js', 'hono-preact']);
-const NOOP_IMPORT_SOURCE = 'hono-preact/internal';
-const NOOP_LOCAL_NAME = '__$guardNoop_hpiso';
-function collectLocalBindings(ast, targets) {
+// In the server bundle we strip anything client-only. The replacement
+// `fn` arity matches the documented `(ctx, next) => Promise<void | Outcome>`
+// shape so any user introspecting `mw.fn` sees the right signature; the
+// framework path filters on `runs` before invoking and never executes a
+// wrong-env body.
+const SERVER_BUNDLE_STRIPS = [
+    {
+        name: 'defineClientMiddleware',
+        replacement: `{ __kind: 'middleware', runs: 'client', fn: (_ctx, next) => next() }`,
+    },
+];
+// In the client bundle we strip anything server-only. Stream observers
+// fire on the server-side streaming pipeline (start/chunk/end/error/abort)
+// so they're server-only too.
+const CLIENT_BUNDLE_STRIPS = [
+    {
+        name: 'defineServerMiddleware',
+        replacement: `{ __kind: 'middleware', runs: 'server', fn: (_ctx, next) => next() }`,
+    },
+    {
+        name: 'defineStreamObserver',
+        replacement: `{ __kind: 'observer' }`,
+    },
+];
+function collectLocalBindings(ast, strips) {
     const bindings = new Map();
+    const byName = new Map(strips.map((s) => [s.name, s]));
     for (const node of ast.program.body) {
         if (node.type !== 'ImportDeclaration')
             continue;
@@ -17,11 +40,9 @@ function collectLocalBindings(ast, targets) {
                 continue;
             if (spec.imported.type !== 'Identifier')
                 continue;
-            const name = spec.imported.name;
-            if (name === 'defineServerGuard' || name === 'defineClientGuard') {
-                if (targets.has(name)) {
-                    bindings.set(spec.local.name, name);
-                }
+            const strategy = byName.get(spec.imported.name);
+            if (strategy) {
+                bindings.set(spec.local.name, strategy);
             }
         }
     }
@@ -38,18 +59,15 @@ function findCallsByLocalName(node, bindings, hits) {
     const n = node;
     if (n.type === 'CallExpression' &&
         n.callee?.type === 'Identifier' &&
-        n.callee.name &&
-        bindings.has(n.callee.name) &&
-        n.arguments &&
-        n.arguments.length >= 1 &&
-        n.arguments[0].start !== undefined &&
-        n.arguments[0].end !== undefined) {
-        hits.push({
-            start: n.start,
-            end: n.end,
-            argStart: n.arguments[0].start,
-            argEnd: n.arguments[0].end,
-        });
+        n.callee.name) {
+        const strategy = bindings.get(n.callee.name);
+        if (strategy && n.start !== undefined && n.end !== undefined) {
+            hits.push({
+                strategy,
+                start: n.start,
+                end: n.end,
+            });
+        }
     }
     for (const key of Object.keys(node)) {
         if (key === 'loc' ||
@@ -66,19 +84,27 @@ export function guardStripPlugin() {
         transform(code, id, options) {
             if (!/\.[jt]sx?$/.test(id))
                 return;
+            // F7: `.server.*` files are intentionally skipped in both bundles.
+            // In the client bundle the server-only stub plugin already rewrites
+            // imports of these files; in the server bundle the file's own
+            // body stays as-authored. The validation plugin restricts a
+            // `.server.*` module's named exports to the allowlist, so a user
+            // cannot land a `defineClientMiddleware(...)` value as a recognized
+            // export and ship it to the server.
             if (/\.server\.[jt]sx?$/.test(id))
                 return;
-            const stripping = options?.ssr
-                ? 'defineClientGuard'
-                : 'defineServerGuard';
-            if (!code.includes(stripping))
+            const strips = options?.ssr ? SERVER_BUNDLE_STRIPS : CLIENT_BUNDLE_STRIPS;
+            // Cheap pre-filter: only parse files that mention at least one of the
+            // symbols we strip. Avoids parsing the entire dep graph just to
+            // confirm no strips apply.
+            if (!strips.some((s) => code.includes(s.name)))
                 return;
             const ast = parse(code, {
                 sourceType: 'module',
                 plugins: BABEL_PARSER_PLUGINS,
                 errorRecovery: true,
             });
-            const bindings = collectLocalBindings(ast, new Set([stripping]));
+            const bindings = collectLocalBindings(ast, strips);
             if (bindings.size === 0)
                 return;
             const hits = [];
@@ -87,9 +113,8 @@ export function guardStripPlugin() {
                 return;
             const s = new MagicString(code);
             for (const hit of [...hits].reverse()) {
-                s.overwrite(hit.argStart, hit.argEnd, NOOP_LOCAL_NAME);
+                s.overwrite(hit.start, hit.end, hit.strategy.replacement);
             }
-            s.prepend(`import { ${NOOP_LOCAL_NAME} } from '${NOOP_IMPORT_SOURCE}';\n`);
             return { code: s.toString(), map: s.generateMap({ hires: true }) };
         },
     };

package/dist/vite/hono-preact.d.ts

@@ -1,12 +1,12 @@
-import { type BuildEnvironmentOptions, type Plugin } from 'vite';
+import { type Plugin } from 'vite';
+import type { HonoPreactAdapter } from './adapter.js';
 export interface HonoPreactOptions {
+    /** Deployment target. Required. See hono-preact/adapter-cloudflare. */
+    adapter: HonoPreactAdapter;
     layout?: string;
     routes?: string;
     api?: string;
+    appConfig?: string;
     clientEntry?: string;
-    entry?: string;
-    clientBuild?: BuildEnvironmentOptions;
-    serverBuild?: BuildEnvironmentOptions;
-    sharedBuild?: BuildEnvironmentOptions;
 }
-export declare function honoPreact(options?: HonoPreactOptions): Plugin[];
+export declare function honoPreact(options: HonoPreactOptions): Plugin[];