hono-preact 0.1.0 → 0.2.0

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/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 {};

package/dist/iso/internal/page-middleware-host.js

@@ -0,0 +1,119 @@
+import { Fragment as _Fragment, jsx as _jsx } from "preact/jsx-runtime";
+import { useLocation } from 'preact-iso';
+import { Suspense } from 'preact/compat';
+import { useContext, useEffect, useRef } from 'preact/hooks';
+import { isBrowser } from '../is-browser.js';
+import { isRedirect, isRender } from '../outcomes.js';
+import { dispatchServer, dispatchClient } from './middleware-runner.js';
+import { partitionUse } from './use-partitioner.js';
+import wrapPromise from './wrap-promise.js';
+import { HonoRequestContext } from './contexts.js';
+function startChain(use, location, honoCtx) {
+    const { middleware } = partitionUse(use);
+    if (isBrowser()) {
+        const client = middleware.filter((m) => m.runs === 'client');
+        if (client.length === 0)
+            return Promise.resolve({ outcome: undefined });
+        return dispatchClient({
+            middleware: client,
+            ctx: { scope: 'page', location },
+            inner: async () => undefined,
+        }).then((r) => r.kind === 'outcome' ? { outcome: r.outcome } : { outcome: undefined });
+    }
+    const server = middleware.filter((m) => m.runs === 'server');
+    if (server.length === 0)
+        return Promise.resolve({ outcome: undefined });
+    if (!honoCtx) {
+        // Reject (don't throw synchronously). `wrapPromise` consumes a Promise;
+        // a sync throw here never reaches it, so the Suspense/ErrorBoundary path
+        // ends up surfacing a coerced "[object Object]"-style message instead of
+        // this explicit one. Returning a rejected promise routes the message
+        // through `wrapPromise.read()` -> the boundary's error state correctly.
+        return Promise.reject(new Error('<PageMiddlewareHost> rendered server-side without a HonoContext.Provider. ' +
+            'renderPage must wrap the prerendered tree in <HonoContext.Provider value={{ context: c }}>.'));
+    }
+    return dispatchServer({
+        middleware: server,
+        ctx: {
+            scope: 'page',
+            c: honoCtx,
+            signal: (honoCtx.req?.raw?.signal ??
+                new AbortController().signal),
+            location,
+        },
+        inner: async () => undefined,
+    }).then((r) => r.kind === 'outcome' ? { outcome: r.outcome } : { outcome: undefined });
+}
+function HostConsumer({ resultRef, children, }) {
+    // resultRef.current is populated by the parent before this consumer
+    // renders; the null branch is just a type-narrow guard.
+    const wrapped = resultRef.current;
+    const { outcome } = wrapped ? wrapped.read() : { outcome: undefined };
+    const { route } = useLocation();
+    // Client-side redirect: navigate in an effect rather than during render.
+    // Render-time side effects are forbidden by Suspense semantics; doing
+    // route() in render would also fire on every Preact re-entry during
+    // suspension resume. Keyed on the resolved target so a fresh outcome
+    // for the same path doesn't refire (the outcome is cached per chain,
+    // so this only changes when the path itself changes and a new chain
+    // produces a redirect to a different target).
+    const redirectTo = isRedirect(outcome) && isBrowser() ? outcome.to : null;
+    useEffect(() => {
+        if (redirectTo !== null)
+            route(redirectTo);
+        // `route` is intentionally omitted from deps: it comes from
+        // useLocation() which is stable per LocationProvider mount, and
+        // referencing it here would re-fire the effect on every render the
+        // provider produces.
+    }, [redirectTo]);
+    if (outcome === undefined) {
+        return _jsx(_Fragment, { children: children });
+    }
+    if (isRedirect(outcome)) {
+        if (isBrowser()) {
+            // Effect above will schedule the navigation; render nothing in the
+            // meantime so the old tree doesn't briefly flash.
+            return null;
+        }
+        // Server: rethrow so renderPage's outer handler can translate to HTTP redirect.
+        throw outcome;
+    }
+    if (isRender(outcome)) {
+        const Alt = outcome.Component;
+        // Equality-by-reference semantics: each `render(Component)` call
+        // returns a fresh outcome object, but the wrapped chain caches its
+        // result for the lifetime of a path. Within the same path render
+        // outcomes are stable. Across paths, the `resultRef` is rewrapped
+        // (see PageMiddlewareHost below), so a fresh chain produces a fresh
+        // outcome and Preact remounts naturally when `Alt` differs. If a
+        // middleware returns the SAME component reference across paths,
+        // Preact treats it as the same element and preserves state. That's
+        // the documented semantic; if callers need a forced remount, they
+        // can wrap the returned component or vary props.
+        return _jsx(Alt, {});
+    }
+    // Deny on the page-render path: rethrow so the outer error boundary or
+    // handler can translate to the right response.
+    throw outcome;
+}
+export const PageMiddlewareHost = ({ use = [], location, fallback, children }) => {
+    const honoCtx = useContext(HonoRequestContext).context;
+    // Lazy ref pattern. `useRef(null)` serves a dual purpose: it's the
+    // "not-yet-computed" sentinel AND the persistent slot for the wrapped
+    // chain result. We compute on first render and on subsequent renders
+    // ONLY when the path changed. `useRef(wrapPromise(startChain(...)))`
+    // would evaluate `startChain` every render before useRef decided whether
+    // to keep it, which synchronously fires `dispatchServer`/`dispatchClient`
+    // every render. That's O(renders) middleware invocations instead of
+    // O(navigations); auth checks, analytics, redirects would all repeat.
+    const resultRef = useRef(null);
+    const prevPath = useRef(location.path);
+    if (resultRef.current === null) {
+        resultRef.current = wrapPromise(startChain(use, location, honoCtx));
+    }
+    else if (prevPath.current !== location.path) {
+        prevPath.current = location.path;
+        resultRef.current = wrapPromise(startChain(use, location, honoCtx));
+    }
+    return (_jsx(Suspense, { fallback: fallback, children: _jsx(HostConsumer, { resultRef: resultRef, children: children }) }));
+};

package/dist/iso/internal/route-boundary.d.ts

@@ -14,6 +14,7 @@ export declare class ErrorBoundary extends Component<ErrorBoundaryProps, {
     static getDerivedStateFromError(error: unknown): {
         error: Error;
     };
+    componentDidCatch(error: unknown): void;
     reset: () => void;
     render(): ComponentChildren;
 }

package/dist/iso/internal/route-boundary.js

@@ -1,11 +1,27 @@
 import { jsx as _jsx } from "preact/jsx-runtime";
 import { Component } from 'preact';
 import { Suspense } from 'preact/compat';
+import { isOutcome } from '../outcomes.js';
 export class ErrorBoundary extends Component {
     state = { error: null };
+    // Outcomes (redirect/deny/render) are NOT errors; they are control-flow
+    // signals that the dispatcher / renderPage outer catch is responsible for
+    // translating. If RouteBoundary swallowed them here, every page-scope
+    // throw from `PageMiddlewareHost` (HostConsumer rethrowing a deny on SSR,
+    // for example) would be coerced into `new Error(String(outcome))` and
+    // surfaced as the fallback UI, with no 302 / 403 / etc. reaching the
+    // network. Re-throw outcomes so the outer handler sees them. The same
+    // guard lives in `componentDidCatch` because Preact invokes both hooks
+    // when the boundary catches; whichever fires first must not swallow.
     static getDerivedStateFromError(error) {
+        if (isOutcome(error))
+            throw error;
         return { error: error instanceof Error ? error : new Error(String(error)) };
     }
+    componentDidCatch(error) {
+        if (isOutcome(error))
+            throw error;
+    }
     reset = () => {
         this.setState({ error: null });
     };

package/dist/iso/internal/stream-observer-runner.d.ts

@@ -0,0 +1,13 @@
+import type { StreamObserver, ServerStreamCtx } from '../define-stream-observer.js';
+export declare function fanStart(observers: ReadonlyArray<StreamObserver<unknown, never>>, ctx: ServerStreamCtx): void;
+export declare function fanChunk(observers: ReadonlyArray<StreamObserver<unknown, never>>, ctx: ServerStreamCtx, chunk: unknown, index: number): void;
+export declare function fanEnd(observers: ReadonlyArray<StreamObserver<unknown, never>>, ctx: ServerStreamCtx, info: {
+    chunks: number;
+    result: unknown;
+}): void;
+export declare function fanError(observers: ReadonlyArray<StreamObserver<unknown, never>>, ctx: ServerStreamCtx, err: unknown, info: {
+    chunks: number;
+}): void;
+export declare function fanAbort(observers: ReadonlyArray<StreamObserver<unknown, never>>, ctx: ServerStreamCtx, info: {
+    chunks: number;
+}): void;

package/dist/iso/internal/stream-observer-runner.js

@@ -0,0 +1,48 @@
+function safeCall(fn) {
+    if (!fn)
+        return;
+    try {
+        fn();
+    }
+    catch (err) {
+        // Observer errors are isolated: surface via console for visibility but do
+        // not propagate. The stream is the source of truth; observers are a side
+        // channel and cannot corrupt the channel they observe.
+        // eslint-disable-next-line no-console
+        console.error('[stream-observer] hook threw and was isolated:', err);
+    }
+}
+export function fanStart(observers, ctx) {
+    for (const o of observers) {
+        safeCall(o.onStart ? () => o.onStart(ctx) : undefined);
+    }
+}
+export function fanChunk(observers, ctx, chunk, index) {
+    for (const o of observers) {
+        safeCall(o.onChunk ? () => o.onChunk(ctx, chunk, index) : undefined);
+    }
+}
+export function fanEnd(observers, ctx, info) {
+    for (const o of observers) {
+        safeCall(o.onEnd
+            ? () => 
+            // The partitioner widens observers to TResult=never (the only
+            // shape that admits arbitrary user-declared TResult); the call
+            // site provides whatever the underlying stream produced. The
+            // cast bridges the invariance gap and is safe because TS
+            // can't reason about the contravariant function-parameter
+            // shape across the array boundary.
+            o.onEnd(ctx, info)
+            : undefined);
+    }
+}
+export function fanError(observers, ctx, err, info) {
+    for (const o of observers) {
+        safeCall(o.onError ? () => o.onError(ctx, err, info) : undefined);
+    }
+}
+export function fanAbort(observers, ctx, info) {
+    for (const o of observers) {
+        safeCall(o.onAbort ? () => o.onAbort(ctx, info) : undefined);
+    }
+}

package/dist/iso/internal/use-partitioner.d.ts

@@ -0,0 +1,9 @@
+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 function partitionUse(use: ReadonlyArray<UseEntry>): {
+    middleware: Middleware[];
+    observers: AnyObserver[];
+};
+export {};

package/dist/iso/internal/use-partitioner.js

@@ -0,0 +1,11 @@
+export function partitionUse(use) {
+    const middleware = [];
+    const observers = [];
+    for (const entry of use) {
+        if (entry.__kind === 'middleware')
+            middleware.push(entry);
+        else
+            observers.push(entry);
+    }
+    return { middleware, observers };
+}

package/dist/iso/internal/use-types.d.ts

@@ -0,0 +1,7 @@
+import type { ServerMiddleware, ClientMiddleware, Scope } from '../define-middleware.js';
+import type { StreamObserver } from '../define-stream-observer.js';
+export type Use<S extends Scope, Streaming extends boolean, T = unknown, R = void> = ReadonlyArray<ServerMiddleware<S> | (S extends 'page' ? ClientMiddleware : never) | (Streaming extends true ? StreamObserver<T, R> : never)>;
+export type PageUse = ReadonlyArray<ServerMiddleware<'page'> | ClientMiddleware | StreamObserver<unknown, never>>;
+export type AppUse = PageUse;
+export type LoaderUse<T, Streaming extends boolean> = Use<'loader', Streaming, T, void>;
+export type ActionUse<TChunk, TResult, Streaming extends boolean> = Use<'action', Streaming, TChunk, TResult>;

package/dist/iso/internal/use-types.js

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

package/dist/iso/internal.d.ts

@@ -1,19 +1,20 @@
 export { Loader } from './internal/loader.js';
 export { Envelope } from './internal/envelope.js';
 export { RouteBoundary } from './internal/route-boundary.js';
-export { Guards, GuardGate, useGuardResult } from './internal/guards.js';
 export { OptimisticOverlay } from './internal/optimistic-overlay.js';
-export { LoaderIdContext, LoaderDataContext, GuardResultContext, } from './internal/contexts.js';
+export { LoaderIdContext, LoaderDataContext } from './internal/contexts.js';
 export { ReloadContext } from './reload-context.js';
 export { RouteLocationsContext, RouteLocationsProvider, } from './internal/route-locations.js';
 export { getPreloadedData, deletePreloadedData } from './internal/preload.js';
 export { runRequestScope, getRequestStore, captureRequestScope, } from './cache.js';
 export { default as wrapPromise } from './internal/wrap-promise.js';
-export { runServerGuards, runClientGuards } from './guard.js';
 export { HonoRequestContext } from './internal/contexts.js';
+export { PageMiddlewareHost } from './internal/page-middleware-host.js';
 export { __dispatchRouteChange, __subscribeRouteChange, } from './internal/route-change.js';
 export { installStreamRegistry, subscribeToLoaderStream, } from './internal/stream-registry.js';
 export { registerServerStreamingLoader, takeServerStreamingLoaders, } from './internal/streaming-ssr.js';
 export type { ServerLoaderStream } from './internal/streaming-ssr.js';
+export { dispatchServer, dispatchClient, type DispatchResult, } from './internal/middleware-runner.js';
+export { partitionUse } from './internal/use-partitioner.js';
+export { fanStart, fanChunk, fanEnd, fanError, fanAbort, } from './internal/stream-observer-runner.js';
 export { __$createLoaderStub_hpiso } from './internal/loader-stub.js';
-export { __$guardNoop_hpiso } from './internal/guard-noop.js';

package/dist/iso/internal.js

@@ -3,8 +3,8 @@
 // These primitives compose the default <Page> pipeline. They're kept
 // behind a subpath so the front door (@hono-preact/iso) stays small.
 // Use them when definePage bindings or <Page> props don't express
-// what you need (e.g. distinct fallbacks for guards vs. loader, custom
-// pipeline ordering, advanced SSR work).
+// what you need (e.g. custom middleware composition, distinct fallbacks
+// for the middleware host vs. the loader, advanced SSR work).
 //
 // STABILITY: this subpath is intentionally less stable than the package's
 // main surface. Symbols may be renamed, retyped, or removed in any
@@ -27,23 +27,25 @@
 export { Loader } from './internal/loader.js';
 export { Envelope } from './internal/envelope.js';
 export { RouteBoundary } from './internal/route-boundary.js';
-export { Guards, GuardGate, useGuardResult } from './internal/guards.js';
 export { OptimisticOverlay } from './internal/optimistic-overlay.js';
-export { LoaderIdContext, LoaderDataContext, GuardResultContext, } from './internal/contexts.js';
+export { LoaderIdContext, LoaderDataContext } from './internal/contexts.js';
 export { ReloadContext } from './reload-context.js';
 export { RouteLocationsContext, RouteLocationsProvider, } from './internal/route-locations.js';
 export { getPreloadedData, deletePreloadedData } from './internal/preload.js';
 export { runRequestScope, getRequestStore, captureRequestScope, } from './cache.js';
 export { default as wrapPromise } from './internal/wrap-promise.js';
-export { runServerGuards, runClientGuards } from './guard.js';
 export { HonoRequestContext } from './internal/contexts.js';
+export { PageMiddlewareHost } from './internal/page-middleware-host.js';
 export { __dispatchRouteChange, __subscribeRouteChange, } from './internal/route-change.js';
 export { installStreamRegistry, subscribeToLoaderStream, } from './internal/stream-registry.js';
 export { registerServerStreamingLoader, takeServerStreamingLoaders, } from './internal/streaming-ssr.js';
+// Middleware dispatcher + observer fanout. Internal-stability subpath.
+export { dispatchServer, dispatchClient, } from './internal/middleware-runner.js';
+export { partitionUse } from './internal/use-partitioner.js';
+export { fanStart, fanChunk, fanEnd, fanError, fanAbort, } from './internal/stream-observer-runner.js';
 // ─── Section 2: framework-emitted (DO NOT IMPORT FROM USER CODE) ─────────
 // The `__$..._hpiso` naming makes the convention visible at every grep:
 // these symbols are referenced by code the framework's Vite plugins emit
 // (serverOnlyPlugin's loader stubs, guardStripPlugin's no-op replacement).
 // User code that imports them couples to plugin internals.
 export { __$createLoaderStub_hpiso } from './internal/loader-stub.js';
-export { __$guardNoop_hpiso } from './internal/guard-noop.js';

package/dist/iso/outcomes.d.ts

@@ -0,0 +1,38 @@
+import type { FunctionComponent } from 'preact';
+import type { RedirectStatusCode, ClientErrorStatusCode, ServerErrorStatusCode } from 'hono/utils/http-status';
+export type ErrorStatusCode = ClientErrorStatusCode | ServerErrorStatusCode;
+export type { RedirectStatusCode };
+export type RedirectOutcome = {
+    __outcome: 'redirect';
+    to: string;
+    status: RedirectStatusCode;
+    headers: Record<string, string> | undefined;
+};
+export type DenyOutcome = {
+    __outcome: 'deny';
+    status: ErrorStatusCode;
+    message: string;
+    headers: Record<string, string> | undefined;
+};
+export type RenderOutcome = {
+    __outcome: 'render';
+    Component: FunctionComponent;
+};
+export type Outcome = RedirectOutcome | DenyOutcome | RenderOutcome;
+type RedirectInput = string | {
+    to: string;
+    status?: RedirectStatusCode;
+    headers?: Record<string, string>;
+};
+export declare function redirect(input: RedirectInput): RedirectOutcome;
+type DenyInput = {
+    status: ErrorStatusCode;
+    message?: string;
+    headers?: Record<string, string>;
+};
+export declare function deny(status: ErrorStatusCode, message?: string): DenyOutcome;
+export declare function deny(spec: DenyInput): DenyOutcome;
+export declare function isOutcome(value: unknown): value is Outcome;
+export declare function isRedirect(value: unknown): value is RedirectOutcome;
+export declare function isDeny(value: unknown): value is DenyOutcome;
+export declare function isRender(value: unknown): value is RenderOutcome;