hono-preact 0.1.0

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

@@ -0,0 +1,123 @@
+import { readSSE } from './sse-decoder.js';
+/**
+ * POST to /__loaders and consume the response.
+ *
+ * Static loaders return JSON; the parsed value resolves the returned promise.
+ * Streaming loaders return SSE; the first chunk resolves the promise, and
+ * subsequent chunks fire callbacks.onChunk. Stream errors after the first
+ * chunk fire callbacks.onError. Stream end fires callbacks.onEnd.
+ */
+export async function fetchLoaderData(moduleKey, loaderName, location, signal, callbacks) {
+    const res = await fetch('/__loaders', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ module: moduleKey, loader: loaderName, location }),
+        signal,
+    });
+    if (!res.ok) {
+        const body = (await res.json().catch(() => ({})));
+        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.
+        if (json !== null &&
+            typeof json === 'object' &&
+            '__redirect' in json &&
+            typeof json.__redirect === 'string') {
+            if (typeof window !== 'undefined') {
+                window.location.assign(json.__redirect);
+            }
+            return new Promise(() => {
+                /* never resolves; page is navigating */
+            });
+        }
+        return json;
+    }
+    if (!res.body) {
+        throw new Error('Streaming loader response has no body');
+    }
+    // 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
+    }
+    // Continue consuming chunks in the background. Each subsequent message
+    // pushes a value via onChunk. Errors fire onError. End fires onEnd.
+    (async () => {
+        try {
+            while (true) {
+                const step = await iter.next();
+                if (step.done) {
+                    callbacks.onEnd();
+                    return;
+                }
+                const ev = step.value;
+                if (ev.event === 'message') {
+                    try {
+                        callbacks.onChunk(JSON.parse(ev.data));
+                    }
+                    catch {
+                        // malformed mid-stream chunk: skip
+                    }
+                }
+                else 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;
+                        callbacks.onError(err);
+                    }
+                    catch {
+                        callbacks.onError(new Error('Streamed error'));
+                    }
+                    return;
+                }
+                // Ignore other event types
+            }
+        }
+        catch (err) {
+            if (signal.aborted)
+                return;
+            callbacks.onError(err instanceof Error ? err : new Error(String(err)));
+        }
+    })();
+    return firstChunk;
+}

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

@@ -0,0 +1,15 @@
+import type { RouteHook } from 'preact-iso';
+import type { LoaderRef } from '../define-loader.js';
+export type LoaderRunCallbacks<T> = {
+    onChunk: (value: T) => void;
+    onError: (err: Error) => void;
+    onEnd: () => void;
+};
+/**
+ * Invoke a loader at runtime. Picks between client-side RPC fetch
+ * (when in browser + has __moduleKey) and direct fn invocation (SSR
+ * or test). Direct fn handles async-generator + ReadableStream by
+ * unwrapping the first chunk and registering continued chunks with
+ * the per-id streaming-SSR registry.
+ */
+export declare function runLoader<T>(loaderRef: LoaderRef<T>, location: RouteHook, id: string, signal: AbortSignal, callbacks: LoaderRunCallbacks<T>): Promise<T>;

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

@@ -0,0 +1,59 @@
+import { isBrowser } from '../is-browser.js';
+import { getRequestHonoContext } from '../cache.js';
+import { fetchLoaderData } from './loader-fetch.js';
+import { registerServerStreamingLoader } from './streaming-ssr.js';
+function isAsyncGenerator(value) {
+    return (value != null &&
+        typeof value === 'object' &&
+        typeof value[Symbol.asyncIterator] === 'function' &&
+        typeof value.next === 'function');
+}
+/**
+ * Invoke a loader at runtime. Picks between client-side RPC fetch
+ * (when in browser + has __moduleKey) and direct fn invocation (SSR
+ * or test). Direct fn handles async-generator + ReadableStream by
+ * unwrapping the first chunk and registering continued chunks with
+ * the per-id streaming-SSR registry.
+ */
+export function runLoader(loaderRef, location, id, signal, callbacks) {
+    const useFetchPath = isBrowser() &&
+        typeof fetch === 'function' &&
+        loaderRef.__moduleKey !== undefined;
+    const loaderName = loaderRef.__loaderName ?? 'default';
+    if (useFetchPath) {
+        return fetchLoaderData(loaderRef.__moduleKey, loaderName, {
+            path: location.path,
+            pathParams: (location.pathParams ?? {}),
+            searchParams: (location.searchParams ?? {}),
+        }, signal, callbacks);
+    }
+    // Direct-fn path. Result may be a Promise<T>, a
+    // Promise<ReadableStream<T>>, or an AsyncGenerator<T>. For an async
+    // generator (server-side streaming loader), take the first chunk
+    // for the Suspense render and register the rest with the per-request
+    // streaming-ssr registry so renderPage can flush further chunks.
+    return (async () => {
+        const ctx = {
+            location,
+            signal,
+            get c() {
+                const c = getRequestHonoContext();
+                if (c === undefined) {
+                    throw new Error('ctx.c is not available: this loader was invoked without an active server request scope. ' +
+                        'Loaders that read ctx.c run inside loadersHandler (RPC) or renderPage (SSR); test/edge paths must avoid reading it.');
+                }
+                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
+            }
+            registerServerStreamingLoader(id, result);
+            return step.value;
+        }
+        return result;
+    })();
+}

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

@@ -0,0 +1,8 @@
+import { type LoaderRef } from '../define-loader.js';
+type StubOpts = {
+    __moduleKey: string;
+    __loaderName: string;
+    params?: string[] | '*';
+};
+export declare function __$createLoaderStub_hpiso<T = unknown>(opts: StubOpts): LoaderRef<T>;
+export {};

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

@@ -0,0 +1,19 @@
+import { defineLoader } from '../define-loader.js';
+import { fetchLoaderData } from './loader-fetch.js';
+export function __$createLoaderStub_hpiso(opts) {
+    // LoaderHost's useLoaderRunner is the actual driver in the browser; this fn
+    // is the SSR / direct-fn fallback path only. The callbacks are intentionally
+    // no-ops: the consumer awaits the returned Promise<T> for the final value and
+    // has no use for intermediate chunk or error notifications.
+    const fn = async ({ location, signal, }) => fetchLoaderData(opts.__moduleKey, opts.__loaderName, {
+        path: location.path,
+        pathParams: location.pathParams,
+        searchParams: location.searchParams,
+    }, signal ?? new AbortController().signal, { onChunk: () => { }, onError: () => { }, onEnd: () => { } });
+    // defineLoader does the cache + symbol + useData/useError plumbing.
+    return defineLoader(fn, {
+        __moduleKey: opts.__moduleKey,
+        __loaderName: opts.__loaderName,
+        params: opts.params,
+    });
+}

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

@@ -0,0 +1,13 @@
+import type { ComponentChildren, JSX } 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;
+    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 { LoaderHost as Loader };

package/dist/iso/internal/loader.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { Suspense } from 'preact/compat';
+import { useContext, useId } from 'preact/hooks';
+import { ReloadContext } from '../reload-context.js';
+import { ActiveLoaderIdContext, LoaderDataContext, LoaderErrorContext, LoaderIdContext, } from './contexts.js';
+import { RouteLocationsContext } from './route-locations.js';
+import { ErrorBoundary } from './route-boundary.js';
+import { Envelope } from './envelope.js';
+import { useLoaderRunner } from './use-loader-runner.js';
+export { serializeLocationForCache } from './cache-key.js';
+export function LoaderHost({ loader: loaderRef, location: locationProp, fallback, errorFallback, children, }) {
+    const id = useId();
+    const locMap = useContext(RouteLocationsContext);
+    const ctxLocation = loaderRef.__moduleKey
+        ? locMap?.get(loaderRef.__moduleKey)
+        : undefined;
+    const location = (locationProp ?? ctxLocation);
+    if (!location) {
+        throw new Error(`Loader for module '${loaderRef.__moduleKey ?? '<unkeyed>'}' has no location: ` +
+            `wrap the page in a route that owns this server module, or pass location explicitly.`);
+    }
+    const { reader, overrideData, error, reload, reloading } = useLoaderRunner(loaderRef, location, id);
+    const suspenseContent = (_jsx(Suspense, { fallback: fallback, children: _jsx(DataReader, { reader: reader, overrideData: overrideData, children: _jsx(Envelope, { children: children }) }) }));
+    return (_jsx(LoaderIdContext.Provider, { value: id, children: _jsx(ActiveLoaderIdContext.Provider, { value: loaderRef.__id, children: _jsx(ReloadContext.Provider, { value: { reload, reloading }, children: _jsx(LoaderErrorContext.Provider, { value: error, children: errorFallback != null ? (_jsx(ErrorBoundary, { fallback: errorFallback, children: suspenseContent })) : (suspenseContent) }) }) }) }));
+}
+// Public name consumed by define-loader.ts and user code.
+export { LoaderHost as Loader };
+function DataReader({ reader, overrideData, children }) {
+    const data = overrideData !== undefined ? overrideData : reader.read();
+    return (_jsx(LoaderDataContext.Provider, { value: { data }, children: children }));
+}

package/dist/iso/internal/optimistic-overlay.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentChildren } from 'preact';
+import type { LoaderRef } from '../define-loader.js';
+type OverlayProps<T, A> = {
+    loader: LoaderRef<T>;
+    reducer: (base: T, action: A) => T;
+    pending?: A[];
+    children: ComponentChildren;
+};
+export declare function OptimisticOverlay<T, A>({ reducer, pending, children, }: OverlayProps<T, A>): import("preact").JSX.Element;
+export {};

package/dist/iso/internal/optimistic-overlay.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { useContext } from 'preact/hooks';
+import { LoaderDataContext } from './contexts.js';
+export function OptimisticOverlay({ reducer, pending = [], children, }) {
+    const ctx = useContext(LoaderDataContext);
+    if (!ctx)
+        throw new Error('<OptimisticOverlay> must be inside a route page that has a loader');
+    const base = ctx.data;
+    const projected = pending.reduce((acc, action) => reducer(acc, action), base);
+    return (_jsx(LoaderDataContext.Provider, { value: { data: projected }, children: children }));
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Pure read of the SSR'd preload payload for a loader. Safe to call during
+ * render: no DOM mutation, no side effects. The caller is responsible for
+ * scheduling `deletePreloadedData` in a useEffect after consuming the
+ * value so the attribute is cleared before a future re-mount could read
+ * a stale payload.
+ *
+ * (Previously this function deleted the attribute synchronously via a
+ * `finally` block during render. That was a real DOM mutation in the
+ * render phase, which Preact's reconciliation does not formally support
+ * and which broke determinism if the component re-rendered before the
+ * effect that consumed the value ran.)
+ */
+export declare function getPreloadedData<T>(id: string): T | null;
+export declare function deletePreloadedData(id: string): void;

package/dist/iso/internal/preload.js

@@ -0,0 +1,36 @@
+import { isBrowser } from '../is-browser.js';
+/**
+ * Pure read of the SSR'd preload payload for a loader. Safe to call during
+ * render: no DOM mutation, no side effects. The caller is responsible for
+ * scheduling `deletePreloadedData` in a useEffect after consuming the
+ * value so the attribute is cleared before a future re-mount could read
+ * a stale payload.
+ *
+ * (Previously this function deleted the attribute synchronously via a
+ * `finally` block during render. That was a real DOM mutation in the
+ * render phase, which Preact's reconciliation does not formally support
+ * and which broke determinism if the component re-rendered before the
+ * effect that consumed the value ran.)
+ */
+export function getPreloadedData(id) {
+    if (!isBrowser()) {
+        return null;
+    }
+    const el = document.getElementById(id);
+    if (!el || !('loader' in el.dataset)) {
+        return null;
+    }
+    try {
+        return JSON.parse(el.dataset.loader ?? 'null');
+    }
+    catch {
+        return null;
+    }
+}
+export function deletePreloadedData(id) {
+    const el = document.getElementById(id);
+    if (!el) {
+        return;
+    }
+    delete el.dataset.loader;
+}

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

@@ -0,0 +1,25 @@
+import { Component } from 'preact';
+import type { ComponentChildren, FunctionComponent, JSX } from 'preact';
+type ErrorFallback = JSX.Element | ((error: Error, reset: () => void) => JSX.Element);
+type ErrorBoundaryProps = {
+    fallback?: ErrorFallback;
+    children: ComponentChildren;
+};
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, {
+    error: Error | null;
+}> {
+    state: {
+        error: Error | null;
+    };
+    static getDerivedStateFromError(error: unknown): {
+        error: Error;
+    };
+    reset: () => void;
+    render(): ComponentChildren;
+}
+export declare const RouteBoundary: FunctionComponent<{
+    fallback?: JSX.Element;
+    errorFallback?: ErrorFallback;
+    children: ComponentChildren;
+}>;
+export {};

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

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { Component } from 'preact';
+import { Suspense } from 'preact/compat';
+export class ErrorBoundary extends Component {
+    state = { error: null };
+    static getDerivedStateFromError(error) {
+        return { error: error instanceof Error ? error : new Error(String(error)) };
+    }
+    reset = () => {
+        this.setState({ error: null });
+    };
+    render() {
+        const { error } = this.state;
+        if (!error)
+            return this.props.children;
+        const f = this.props.fallback;
+        if (typeof f === 'function')
+            return f(error, this.reset);
+        if (f)
+            return f;
+        return null;
+    }
+}
+export const RouteBoundary = ({ fallback, errorFallback, children }) => (_jsx(ErrorBoundary, { fallback: errorFallback, children: _jsx(Suspense, { fallback: fallback, children: children }) }));

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

@@ -0,0 +1,4 @@
+type Sub = (to: string, from: string | undefined) => void;
+export declare function __dispatchRouteChange(to: string, from: string | undefined): void;
+export declare function __subscribeRouteChange(sub: Sub): () => void;
+export {};

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

@@ -0,0 +1,18 @@
+import { flushSync } from 'preact/compat';
+const subs = new Set();
+export function __dispatchRouteChange(to, from) {
+    for (const cb of subs)
+        cb(to, from);
+    if (typeof document === 'undefined')
+        return;
+    const startViewTransition = document.startViewTransition;
+    if (typeof startViewTransition !== 'function')
+        return;
+    startViewTransition.call(document, () => flushSync(() => { }));
+}
+export function __subscribeRouteChange(sub) {
+    subs.add(sub);
+    return () => {
+        subs.delete(sub);
+    };
+}

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

@@ -0,0 +1,11 @@
+import type { ComponentChildren } from 'preact';
+import type { RouteHook } from 'preact-iso';
+export declare const RouteLocationsContext: import("preact").Context<ReadonlyMap<string, RouteHook>>;
+export declare function RouteLocationsProvider({ moduleKey, location, children, }: {
+    moduleKey: string | undefined;
+    location: RouteHook;
+    children?: ComponentChildren;
+}): import("preact").VNode<import("preact").Attributes & {
+    value: ReadonlyMap<string, RouteHook>;
+    children?: ComponentChildren;
+}>;

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

@@ -0,0 +1,15 @@
+import { createContext, h } from 'preact';
+import { useContext, useMemo } from 'preact/hooks';
+const EMPTY_MAP = Object.freeze(new Map());
+export const RouteLocationsContext = createContext(EMPTY_MAP);
+export function RouteLocationsProvider({ moduleKey, location, children, }) {
+    const parent = useContext(RouteLocationsContext);
+    const next = useMemo(() => {
+        if (!moduleKey)
+            return parent;
+        const m = new Map(parent);
+        m.set(moduleKey, location);
+        return m;
+    }, [parent, moduleKey, location]);
+    return h(RouteLocationsContext.Provider, { value: next }, children);
+}

package/dist/iso/internal/sse-decoder.d.ts

@@ -0,0 +1,5 @@
+export type SSEEvent = {
+    event: string;
+    data: string;
+};
+export declare function readSSE(stream: ReadableStream<Uint8Array>): AsyncGenerator<SSEEvent, void, unknown>;

package/dist/iso/internal/sse-decoder.js

@@ -0,0 +1,43 @@
+export async function* readSSE(stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let event = 'message';
+    let dataLines = [];
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                buffer += decoder.decode();
+                if (dataLines.length)
+                    yield { event, data: dataLines.join('\n') };
+                return;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let nl;
+            while ((nl = buffer.indexOf('\n')) !== -1) {
+                const line = buffer.slice(0, nl).replace(/\r$/, '');
+                buffer = buffer.slice(nl + 1);
+                if (line === '') {
+                    if (dataLines.length) {
+                        yield { event, data: dataLines.join('\n') };
+                    }
+                    event = 'message';
+                    dataLines = [];
+                }
+                else if (line.startsWith(':')) {
+                    // SSE comment / keepalive, ignore
+                }
+                else if (line.startsWith('event:')) {
+                    event = line.slice(6).trim();
+                }
+                else if (line.startsWith('data:')) {
+                    dataLines.push(line.slice(5).replace(/^ /, ''));
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/dist/iso/internal/stream-registry.d.ts

@@ -0,0 +1,60 @@
+type StreamEvent = {
+    type: 'push';
+    loaderId: string;
+    value: unknown;
+} | {
+    type: 'end';
+    loaderId: string;
+} | {
+    type: 'error';
+    loaderId: string;
+    error: {
+        message: string;
+        name: string;
+    };
+};
+type Subscriber = {
+    push: (value: unknown) => void;
+    end: () => void;
+    error: (err: Error) => void;
+};
+type StreamRegistry = {
+    push: (loaderId: string, value: unknown) => void;
+    end: (loaderId: string) => void;
+    error: (loaderId: string, error: {
+        message: string;
+        name: string;
+    }) => void;
+    /**
+     * Pre-hydration buffer. The SSR inline bootstrap script populates this
+     * before the client bundle loads. After `installStreamRegistry()` runs,
+     * the field continues to back per-loader buffering of events whose
+     * subscriber hasn't mounted yet (the common case during streaming SSR).
+     */
+    queue?: StreamEvent[];
+};
+declare global {
+    interface Window {
+        __HP_STREAM__?: StreamRegistry;
+    }
+}
+/**
+ * Subscribe a loader mount to events for its loader id. Returns an
+ * unsubscribe function. Drains any buffered events for this id via a
+ * microtask so it is safe to call during a render pass: the current
+ * render commits first, then the drain fires setState-y callbacks and
+ * Preact re-renders normally.
+ */
+export declare function subscribeToLoaderStream(loaderId: string, sub: Subscriber): () => void;
+/**
+ * Install the live dispatcher on `window.__HP_STREAM__`. Any events that
+ * were buffered by the SSR inline bootstrap (in `window.__HP_STREAM__.queue`)
+ * are routed through `dispatchOrBuffer`, which either delivers them to an
+ * already-registered subscriber or holds them until one registers.
+ */
+export declare function installStreamRegistry(): void;
+/**
+ * Test-only: clear all buffers and subscribers. Not exposed via internal.ts.
+ */
+export declare function __resetStreamRegistryForTests(): void;
+export {};

package/dist/iso/internal/stream-registry.js

@@ -0,0 +1,98 @@
+const subscribers = new Map();
+const buffered = new Map();
+function dispatchOrBuffer(ev) {
+    const sub = subscribers.get(ev.loaderId);
+    if (sub) {
+        dispatch(ev, sub);
+    }
+    else {
+        let bucket = buffered.get(ev.loaderId);
+        if (!bucket) {
+            bucket = [];
+            buffered.set(ev.loaderId, bucket);
+        }
+        bucket.push(ev);
+    }
+}
+function dispatch(ev, sub) {
+    if (ev.type === 'push')
+        sub.push(ev.value);
+    else if (ev.type === 'end')
+        sub.end();
+    else if (ev.type === 'error') {
+        const err = new Error(ev.error.message);
+        err.name = ev.error.name;
+        sub.error(err);
+    }
+}
+/**
+ * Subscribe a loader mount to events for its loader id. Returns an
+ * unsubscribe function. Drains any buffered events for this id via a
+ * microtask so it is safe to call during a render pass: the current
+ * render commits first, then the drain fires setState-y callbacks and
+ * Preact re-renders normally.
+ */
+export function subscribeToLoaderStream(loaderId, sub) {
+    subscribers.set(loaderId, sub);
+    const bucket = buffered.get(loaderId);
+    if (bucket && bucket.length > 0) {
+        buffered.delete(loaderId);
+        // Defer to a microtask so this is safe to call during a render: the
+        // current render commits, then the drain fires setState-y callbacks
+        // and Preact re-renders normally.
+        queueMicrotask(() => {
+            // The subscriber may have unmounted between subscribe and the
+            // microtask firing; skip the drain in that case.
+            if (subscribers.get(loaderId) !== sub)
+                return;
+            for (const ev of bucket)
+                dispatch(ev, sub);
+        });
+    }
+    return () => {
+        if (subscribers.get(loaderId) === sub)
+            subscribers.delete(loaderId);
+    };
+}
+/**
+ * Install the live dispatcher on `window.__HP_STREAM__`. Any events that
+ * were buffered by the SSR inline bootstrap (in `window.__HP_STREAM__.queue`)
+ * are routed through `dispatchOrBuffer`, which either delivers them to an
+ * already-registered subscriber or holds them until one registers.
+ */
+export function installStreamRegistry() {
+    if (typeof window === 'undefined')
+        return;
+    const existing = window.__HP_STREAM__;
+    const initialQueue = existing?.queue ?? [];
+    const wasCapped = existing?.capped === true;
+    window.__HP_STREAM__ = {
+        push(loaderId, value) {
+            dispatchOrBuffer({ type: 'push', loaderId, value });
+        },
+        end(loaderId) {
+            dispatchOrBuffer({ type: 'end', loaderId });
+        },
+        error(loaderId, error) {
+            dispatchOrBuffer({ type: 'error', loaderId, error });
+        },
+    };
+    for (const ev of initialQueue)
+        dispatchOrBuffer(ev);
+    if (wasCapped) {
+        // The SSR-emitted bootstrap dropped events because the buffer hit its
+        // cap before this function ran. Surface to the dev console so a slow
+        // bundle-load / blocked CDN scenario is debuggable, not just silently
+        // lossy on the client.
+        console.warn('[hono-preact] streaming bootstrap buffer was capped before the client ' +
+            'bundle loaded — some streaming-loader events were dropped. Likely ' +
+            'cause: slow or blocked client bundle load.');
+    }
+}
+/**
+ * Test-only: clear all buffers and subscribers. Not exposed via internal.ts.
+ */
+export function __resetStreamRegistryForTests() {
+    subscribers.clear();
+    buffered.clear();
+}