hono-preact 0.1.0 → 0.3.0

package/dist/iso/internal/action-result-store.d.ts

@@ -0,0 +1,28 @@
+type Listener = () => void;
+export type StoredActionResult = {
+    kind: 'success';
+    data: unknown;
+    submittedPayload: unknown;
+} | {
+    kind: 'deny';
+    status: number;
+    message: string;
+    data?: unknown;
+    submittedPayload: unknown;
+} | {
+    kind: 'error';
+    message: string;
+    submittedPayload: unknown | null;
+};
+type Entry = StoredActionResult & {
+    module: string;
+    action: string;
+};
+export declare function setLastActionResult(module: string, action: string, result: StoredActionResult): void;
+export declare function clearLastActionResult(module: string, action: string): void;
+export declare function getLastActionResult(stub?: {
+    __module: string;
+    __action: string;
+}): Entry | null;
+export declare function subscribeActionResults(listener: Listener): () => void;
+export {};

package/dist/iso/internal/action-result-store.js

@@ -0,0 +1,35 @@
+const results = new Map();
+const listeners = new Set();
+function key(module, action) {
+    return `${module}::${action}`;
+}
+export function setLastActionResult(module, action, result) {
+    const k = key(module, action);
+    // Delete-then-set to bump to most-recent position in Map iteration order,
+    // so no-stub readers see the latest action result, not the earliest.
+    results.delete(k);
+    results.set(k, { ...result, module, action });
+    for (const l of listeners)
+        l();
+}
+export function clearLastActionResult(module, action) {
+    if (results.delete(key(module, action))) {
+        for (const l of listeners)
+            l();
+    }
+}
+export function getLastActionResult(stub) {
+    if (stub)
+        return results.get(key(stub.__module, stub.__action)) ?? null;
+    // No stub: return the most recently written entry.
+    let last = null;
+    for (const entry of results.values())
+        last = entry;
+    return last;
+}
+export function subscribeActionResults(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}

package/dist/iso/internal/contexts.d.ts

@@ -1,5 +1,4 @@
 import type { Context } from 'hono';
-import type { GuardResult } from '../guard.js';
 export declare const HonoRequestContext: import("preact").Context<{
     context?: Context;
 }>;
@@ -7,6 +6,5 @@ export declare const LoaderIdContext: import("preact").Context<string | null>;
 export declare const LoaderDataContext: import("preact").Context<{
     data: unknown;
 } | null>;
-export declare const GuardResultContext: import("preact").Context<GuardResult | null>;
 export declare const ActiveLoaderIdContext: import("preact").Context<symbol | null>;
 export declare const LoaderErrorContext: import("preact").Context<Error | null>;

package/dist/iso/internal/contexts.js

@@ -2,6 +2,5 @@ import { createContext } from 'preact';
 export const HonoRequestContext = createContext({});
 export const LoaderIdContext = createContext(null);
 export const LoaderDataContext = createContext(null);
-export const GuardResultContext = createContext(null);
 export const ActiveLoaderIdContext = createContext(null);
 export const LoaderErrorContext = createContext(null);

package/dist/iso/internal/envelope.js

@@ -13,8 +13,7 @@ export const Envelope = ({ as = 'section', children, }) => {
     const dataLoader = isBrowser() ? 'null' : JSON.stringify(ctx.data ?? null);
     if (typeof as === 'string') {
         const Tag = as;
-        const props = { id, 'data-loader': dataLoader };
-        return (_jsx(Tag, { ...props, children: children }));
+        return (_jsx(Tag, { id: id, "data-loader": dataLoader, children: children }));
     }
     const Wrapper = as;
     return (_jsx(Wrapper, { id: id, "data-loader": dataLoader, children: children }));

package/dist/iso/internal/form-submit-store.d.ts

@@ -0,0 +1,9 @@
+type Listener = () => void;
+export declare function beginSubmit(module: string, action: string): void;
+export declare function endSubmit(module: string, action: string): void;
+export declare function isPending(stub?: {
+    __module: string;
+    __action: string;
+}): boolean;
+export declare function subscribe(listener: Listener): () => void;
+export {};

package/dist/iso/internal/form-submit-store.js

@@ -0,0 +1,32 @@
+const counts = new Map();
+const listeners = new Set();
+function key(module, action) {
+    return `${module}::${action}`;
+}
+export function beginSubmit(module, action) {
+    const k = key(module, action);
+    counts.set(k, (counts.get(k) ?? 0) + 1);
+    for (const l of listeners)
+        l();
+}
+export function endSubmit(module, action) {
+    const k = key(module, action);
+    const n = (counts.get(k) ?? 0) - 1;
+    if (n <= 0)
+        counts.delete(k);
+    else
+        counts.set(k, n);
+    for (const l of listeners)
+        l();
+}
+export function isPending(stub) {
+    if (stub)
+        return (counts.get(key(stub.__module, stub.__action)) ?? 0) > 0;
+    return counts.size > 0;
+}
+export function subscribe(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}

package/dist/iso/internal/loader-fetch.js

@@ -1,4 +1,5 @@
 import { readSSE } from './sse-decoder.js';
+import { TimeoutError } from '../action.js';
 /**
  * POST to /__loaders and consume the response.
  *
@@ -15,22 +16,55 @@ export async function fetchLoaderData(moduleKey, loaderName, location, signal, c
         signal,
     });
     if (!res.ok) {
+        // Try to parse a deny outcome envelope first; it carries `message`
+        // rather than `error`. Fall back to the legacy `{ error }` shape.
         const body = (await res.json().catch(() => ({})));
+        if (body.__outcome === 'timeout' && typeof body.timeoutMs === 'number') {
+            throw new TimeoutError(body.timeoutMs);
+        }
+        if (body.__outcome === 'deny') {
+            // The `deny()` constructor defaults `message` for first-party
+            // callers, but a hand-rolled envelope from custom server middleware
+            // might still arrive without one. Surface a deny-aware fallback
+            // instead of the generic "Loader failed" so the user sees a hint
+            // that the status came from an explicit deny.
+            const msg = typeof body.message === 'string'
+                ? body.message
+                : `Request denied (${res.status})`;
+            throw new Error(msg);
+        }
         throw new Error(body.error ?? `Loader failed with status ${res.status}`);
     }
     const contentType = res.headers.get('Content-Type') ?? '';
     if (!contentType.includes('text/event-stream')) {
         const json = (await res.json());
-        // Server-side `GuardRedirect` thrown from a loader (or a guard that runs
-        // inside it) comes back as a `{ __redirect }` envelope. Hand off to the
-        // browser via `location.assign` and return a promise that never settles:
-        // the current document is being replaced, no caller will see a value.
+        // Collision risk note (deferred from middleware review C6): a loader
+        // that legitimately returns data shaped `{ __outcome: 'redirect', to:
+        // <string> }` would be misinterpreted here and navigate the browser.
+        // The probability is low (the magic key is namespaced and unusual) and
+        // a wire-version sentinel like `__envelope: 'hono-preact/redirect'` or
+        // a `X-Hono-Preact-Outcome: redirect` response header would close the
+        // gap. Deferred for v0.2: body-key sniffing is the documented contract
+        // for v0.1.
+        // Server-side middleware that throws `redirect(...)` comes back as a
+        // redirect outcome envelope. Hand off to the browser via
+        // `location.assign` and return a promise that never settles: the
+        // current document is being replaced, no caller will see a value.
+        //
+        // Trust boundary: `to` is taken straight from the JSON body and passed
+        // to `window.location.assign`. The framework's own handlers emit safe
+        // (typically same-origin) values, but a compromised or misconfigured
+        // server (or a proxy injecting JSON) could push the client anywhere.
+        // We don't validate origin here for v0.1; treat your own server as
+        // part of the trusted boundary. A same-origin check is a deferred
+        // enhancement (see C4 in the middleware review).
         if (json !== null &&
             typeof json === 'object' &&
-            '__redirect' in json &&
-            typeof json.__redirect === 'string') {
+            json.__outcome === 'redirect' &&
+            typeof json.to === 'string') {
+            const to = json.to;
             if (typeof window !== 'undefined') {
-                window.location.assign(json.__redirect);
+                window.location.assign(to);
             }
             return new Promise(() => {
                 /* never resolves; page is navigating */
@@ -44,40 +78,7 @@ export async function fetchLoaderData(moduleKey, loaderName, location, signal, c
     // SSE: read the first message event synchronously (await first chunk),
     // then kick off an async loop that pushes subsequent chunks to callbacks.
     const iter = readSSE(res.body);
-    let firstChunk;
-    while (true) {
-        const step = await iter.next();
-        if (step.done) {
-            // Stream closed before any data event: error
-            throw new Error('Streaming loader closed before emitting any data');
-        }
-        const ev = step.value;
-        if (ev.event === 'message') {
-            try {
-                firstChunk = JSON.parse(ev.data);
-            }
-            catch {
-                throw new Error('Malformed first chunk in streaming loader');
-            }
-            break;
-        }
-        if (ev.event === 'error') {
-            try {
-                const parsed = JSON.parse(ev.data);
-                const err = new Error(parsed.message ?? 'Streamed error');
-                if (parsed.name)
-                    err.name = parsed.name;
-                throw err;
-            }
-            catch (e) {
-                if (e instanceof Error && e.message.startsWith('Malformed')) {
-                    throw new Error('Malformed error event in streaming loader');
-                }
-                throw e;
-            }
-        }
-        // Other events (result, etc.): ignore for loaders
-    }
+    const firstChunk = await readFirstChunk(iter);
     // Continue consuming chunks in the background. Each subsequent message
     // pushes a value via onChunk. Errors fire onError. End fires onEnd.
     (async () => {
@@ -97,6 +98,16 @@ export async function fetchLoaderData(moduleKey, loaderName, location, signal, c
                         // malformed mid-stream chunk: skip
                     }
                 }
+                else if (ev.event === 'timeout') {
+                    try {
+                        const parsed = JSON.parse(ev.data);
+                        callbacks.onError(new TimeoutError(parsed.timeoutMs ?? 0));
+                    }
+                    catch {
+                        callbacks.onError(new Error('Malformed timeout event in streaming loader'));
+                    }
+                    return;
+                }
                 else if (ev.event === 'error') {
                     try {
                         const parsed = JSON.parse(ev.data);
@@ -121,3 +132,53 @@ export async function fetchLoaderData(moduleKey, loaderName, location, signal, c
     })();
     return firstChunk;
 }
+/**
+ * Drain the SSE stream until the first `message` event and parse it as `T`.
+ * `timeout` / `error` events before the first message reject with the
+ * appropriate error. Other event types are ignored.
+ */
+async function readFirstChunk(iter) {
+    while (true) {
+        const step = await iter.next();
+        if (step.done) {
+            throw new Error('Streaming loader closed before emitting any data');
+        }
+        const ev = step.value;
+        if (ev.event === 'message') {
+            try {
+                return JSON.parse(ev.data);
+            }
+            catch {
+                throw new Error('Malformed first chunk in streaming loader');
+            }
+        }
+        if (ev.event === 'timeout') {
+            let timeoutMs = 0;
+            try {
+                const parsed = JSON.parse(ev.data);
+                timeoutMs = parsed.timeoutMs ?? 0;
+            }
+            catch (e) {
+                throw new Error(`Malformed timeout event in streaming loader: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            throw new TimeoutError(timeoutMs);
+        }
+        if (ev.event === 'error') {
+            let message = 'Streamed error';
+            let name;
+            try {
+                const parsed = JSON.parse(ev.data);
+                message = parsed.message ?? message;
+                name = parsed.name;
+            }
+            catch {
+                throw new Error('Malformed error event in streaming loader');
+            }
+            const err = new Error(message);
+            if (name)
+                err.name = name;
+            throw err;
+        }
+        // Other events (result, etc.): ignore for loaders
+    }
+}

package/dist/iso/internal/loader-runner.js

@@ -2,6 +2,9 @@ import { isBrowser } from '../is-browser.js';
 import { getRequestHonoContext } from '../cache.js';
 import { fetchLoaderData } from './loader-fetch.js';
 import { registerServerStreamingLoader } from './streaming-ssr.js';
+import { dispatchServer } from './middleware-runner.js';
+import { partitionUse } from './use-partitioner.js';
+import { fanStart, fanChunk, fanEnd, fanError, } from './stream-observer-runner.js';
 function isAsyncGenerator(value) {
     return (value != null &&
         typeof value === 'object' &&
@@ -45,15 +48,109 @@ export function runLoader(loaderRef, location, id, signal, callbacks) {
                 return c;
             },
         };
-        const result = await loaderRef.fn(ctx);
-        if (isAsyncGenerator(result)) {
-            const step = await result.next();
-            if (step.done) {
-                return undefined; // generator returned without yielding
+        // Partition the loader's `use` array into middleware + observers. The
+        // dispatcher only consumes middleware; observers attach to the streaming
+        // pump below so chunks emitted during SSR flush observer hooks the same
+        // way the RPC/SSE path does.
+        const { middleware: allMiddleware, observers } = partitionUse((loaderRef.use ?? []));
+        const serverMw = allMiddleware.filter((m) => m.runs === 'server');
+        // Pre-build a ServerLoaderCtx so observers and middleware see the same
+        // ctx shape they see on the RPC path. `c` proxies through the lazy
+        // getter so test paths (no request scope) keep working when no consumer
+        // reads it.
+        const serverCtx = Object.defineProperties({
+            scope: 'loader',
+            signal,
+            location,
+            module: loaderRef.__moduleKey ?? '<unkeyed>',
+            loader: loaderName,
+        }, {
+            c: {
+                get: () => ctx.c,
+                enumerable: true,
+            },
+        });
+        /**
+         * Wrap a generator that has already yielded its first chunk so that
+         * subsequent yields fire observer hooks. Index 0 has already fired
+         * before this wrapper runs (see runInner below), so we count from 1.
+         *
+         * Implemented as a real `async function*` (not a hand-rolled object)
+         * so the result conforms to AsyncGenerator's full structural contract
+         * (including `[Symbol.asyncDispose]` on newer libs).
+         */
+        function wrapGeneratorWithObservers(gen, startIndex) {
+            async function* wrapped() {
+                let chunks = startIndex;
+                try {
+                    while (true) {
+                        const step = await gen.next();
+                        if (step.done) {
+                            fanEnd(observers, serverCtx, {
+                                chunks,
+                                result: step.value,
+                            });
+                            return step.value;
+                        }
+                        fanChunk(observers, serverCtx, step.value, chunks);
+                        chunks += 1;
+                        yield step.value;
+                    }
+                }
+                catch (err) {
+                    fanError(observers, serverCtx, err, { chunks });
+                    throw err;
+                }
             }
-            registerServerStreamingLoader(id, result);
-            return step.value;
+            return wrapped();
+        }
+        const runInner = async () => {
+            const result = await loaderRef.fn(ctx);
+            if (isAsyncGenerator(result)) {
+                if (observers.length > 0) {
+                    fanStart(observers, serverCtx);
+                }
+                const step = await result.next();
+                if (step.done) {
+                    // Generator returned without yielding. Fire onEnd with chunks=0
+                    // so observers see a clean lifecycle even on empty streams.
+                    if (observers.length > 0) {
+                        fanEnd(observers, serverCtx, {
+                            chunks: 0,
+                            result: step.value,
+                        });
+                    }
+                    return undefined;
+                }
+                if (observers.length > 0) {
+                    fanChunk(observers, serverCtx, step.value, 0);
+                    // Register the OBSERVED wrapper so renderPage's drain fires
+                    // onChunk for every subsequent yield and onEnd / onError at
+                    // termination.
+                    registerServerStreamingLoader(id, wrapGeneratorWithObservers(result, 1));
+                }
+                else {
+                    registerServerStreamingLoader(id, result);
+                }
+                return step.value;
+            }
+            return result;
+        };
+        // Empty middleware path bypasses the dispatcher so existing call sites
+        // keep their exact prior behavior. Observer fanout above still fires
+        // through runInner; the dispatcher is only about ordered middleware
+        // before/after the inner.
+        if (serverMw.length === 0) {
+            return (await runInner());
+        }
+        const dispatch = await dispatchServer({
+            middleware: serverMw,
+            ctx: serverCtx,
+            inner: runInner,
+        });
+        if (dispatch.kind === 'outcome') {
+            throw dispatch.outcome;
         }
-        return result;
+        return dispatch.value;
     })();
 }

package/dist/iso/internal/loader.d.ts

@@ -1,13 +1,13 @@
-import type { ComponentChildren, JSX } from 'preact';
+import type { ComponentChildren } from 'preact';
 import type { RouteHook } from 'preact-iso';
 import type { LoaderRef } from '../define-loader.js';
 export { serializeLocationForCache } from './cache-key.js';
 type LoaderHostProps<T> = {
     loader: LoaderRef<T>;
     location?: RouteHook;
-    fallback?: JSX.Element;
+    fallback?: ComponentChildren;
     errorFallback?: ComponentChildren | ((err: Error, reset: () => void) => ComponentChildren);
     children: ComponentChildren;
 };
-export declare function LoaderHost<T>({ loader: loaderRef, location: locationProp, fallback, errorFallback, children, }: LoaderHostProps<T>): JSX.Element;
+export declare function LoaderHost<T>({ loader: loaderRef, location: locationProp, fallback, errorFallback, children, }: LoaderHostProps<T>): import("preact").JSX.Element;
 export { LoaderHost as Loader };

package/dist/iso/internal/middleware-runner.d.ts

@@ -0,0 +1,22 @@
+import type { ServerMiddleware, ClientMiddleware, ServerCtx, ClientPageCtx, Scope } from '../define-middleware.js';
+import { type Outcome } from '../outcomes.js';
+export type DispatchResult<T> = {
+    kind: 'ok';
+    value: T;
+} | {
+    kind: 'outcome';
+    outcome: Outcome;
+};
+type ServerDispatchArgs<T, S extends Scope> = {
+    middleware: ReadonlyArray<ServerMiddleware<S>>;
+    ctx: ServerCtx<S>;
+    inner: () => Promise<T>;
+};
+export declare function dispatchServer<T, S extends Scope = Scope>(args: ServerDispatchArgs<T, S>): Promise<DispatchResult<T>>;
+type ClientDispatchArgs<T> = {
+    middleware: ReadonlyArray<ClientMiddleware>;
+    ctx: ClientPageCtx;
+    inner: () => Promise<T>;
+};
+export declare function dispatchClient<T>(args: ClientDispatchArgs<T>): Promise<DispatchResult<T>>;
+export {};

package/dist/iso/internal/middleware-runner.js

@@ -0,0 +1,79 @@
+import { isOutcome } from '../outcomes.js';
+export async function dispatchServer(args) {
+    let innerResult;
+    const runChain = async (index) => {
+        if (index >= args.middleware.length) {
+            innerResult = await args.inner();
+            return;
+        }
+        const mw = args.middleware[index];
+        let nextCalled = false;
+        const next = async () => {
+            if (nextCalled) {
+                throw new Error(`Middleware at index ${index} called next() more than once. ` +
+                    `Each middleware must call next() exactly once: a second call ` +
+                    `would re-run the downstream chain (and the inner function) ` +
+                    `with the original ctx, producing duplicate side effects.`);
+            }
+            nextCalled = true;
+            await runChain(index + 1);
+            return innerResult;
+        };
+        const ret = await mw.fn(args.ctx, next);
+        if (isOutcome(ret)) {
+            throw ret;
+        }
+        if (!nextCalled) {
+            throw new Error(`Middleware at index ${index} returned without calling next() or short-circuiting via a thrown outcome. ` +
+                `Middleware must either: (a) await/return next() to pass control on, or (b) throw a redirect/deny/render outcome to short-circuit. ` +
+                `Returning silently is ambiguous and would let downstream code run.`);
+        }
+    };
+    try {
+        await runChain(0);
+    }
+    catch (thrown) {
+        if (isOutcome(thrown)) {
+            return { kind: 'outcome', outcome: thrown };
+        }
+        throw thrown;
+    }
+    return { kind: 'ok', value: innerResult };
+}
+export async function dispatchClient(args) {
+    let innerResult;
+    const runChain = async (index) => {
+        if (index >= args.middleware.length) {
+            innerResult = await args.inner();
+            return;
+        }
+        const mw = args.middleware[index];
+        let nextCalled = false;
+        const next = async () => {
+            if (nextCalled) {
+                throw new Error(`Middleware at index ${index} called next() more than once. ` +
+                    `Each middleware must call next() exactly once: a second call ` +
+                    `would re-run the downstream chain (and the inner function) ` +
+                    `with the original ctx, producing duplicate side effects.`);
+            }
+            nextCalled = true;
+            await runChain(index + 1);
+            return innerResult;
+        };
+        const ret = await mw.fn(args.ctx, next);
+        if (isOutcome(ret))
+            throw ret;
+        if (!nextCalled) {
+            throw new Error(`Middleware at index ${index} returned without calling next() or short-circuiting via a thrown outcome.`);
+        }
+    };
+    try {
+        await runChain(0);
+    }
+    catch (thrown) {
+        if (isOutcome(thrown))
+            return { kind: 'outcome', outcome: thrown };
+        throw thrown;
+    }
+    return { kind: 'ok', value: innerResult };
+}

package/dist/iso/internal/page-middleware-host.d.ts

@@ -0,0 +1,13 @@
+import { type ComponentChildren, type FunctionComponent, type JSX } from 'preact';
+import { type RouteHook } from 'preact-iso';
+import type { Middleware } from '../define-middleware.js';
+import type { StreamObserver } from '../define-stream-observer.js';
+type AnyObserver = StreamObserver<unknown, never>;
+type UseEntry = Middleware | AnyObserver;
+export declare const PageMiddlewareHost: FunctionComponent<{
+    use?: ReadonlyArray<UseEntry>;
+    location: RouteHook;
+    fallback?: JSX.Element;
+    children: ComponentChildren;
+}>;
+export {};