hono-preact 0.3.0 → 0.5.0

package/dist/iso/define-routes.d.ts

@@ -51,7 +51,6 @@ export type RoutesManifest = {
 export declare function defineRoutes(tree: RouteDef[]): RoutesManifest;
 export type RoutesProps = {
     routes: RoutesManifest;
-    onRouteChange?: (url: string) => void;
 };
 export declare const Routes: ComponentType<RoutesProps>;
 export {};

package/dist/iso/define-routes.js

@@ -1,6 +1,7 @@
 import { h } from 'preact';
 import { lazy, Route, Router, useLocation } from 'preact-iso';
 import { RouteLocationsProvider } from './internal/route-locations.js';
+import { __noteLoadEnd, __noteLoadStart } from './internal/route-change.js';
 function wrapWithRouteLocations(serverMod, location, node) {
     const moduleKey = serverMod
         ?.__moduleKey;
@@ -158,7 +159,10 @@ function makeLayoutGroupComponent(layoutImport, server, layoutPathPattern, child
         const inner = buildInnerRoutes(children, viewCache);
         const Wrapper = (location) => {
             const layoutLocation = deriveLayoutLocation(location, layoutPathPattern);
-            const layoutNode = h(Layout, null, h(Router, null, ...inner));
+            const layoutNode = h(Layout, null, h(asRouteComponent(Router), {
+                onLoadStart: __noteLoadStart,
+                onLoadEnd: __noteLoadEnd,
+            }, ...inner));
             return wrapWithRouteLocations(serverMod, layoutLocation, layoutNode);
         };
         return { default: Wrapper };
@@ -276,8 +280,11 @@ export function defineRoutes(tree) {
         serverRoutes: collectServerRoutes(tree),
     };
 }
-export const Routes = ({ routes, onRouteChange, }) => {
-    return h(asRouteComponent(Router), onRouteChange ? { onRouteChange } : null, ...routes.flat.map((r) => h(Route, {
+export const Routes = ({ routes }) => {
+    return h(asRouteComponent(Router), {
+        onLoadStart: __noteLoadStart,
+        onLoadEnd: __noteLoadEnd,
+    }, ...routes.flat.map((r) => h(Route, {
         key: r.key,
         path: r.path,
         component: asRouteComponent(r.component),

package/dist/iso/form.js

@@ -34,6 +34,12 @@ export function Form({ action, children, ...rest }) {
             ? window.location.pathname + window.location.search
             : '/';
         const fd = new FormData(formEl);
+        // Source the action identity from props, not the DOM hidden inputs. On an
+        // initial SSR page those inputs render empty (server-side defineAction
+        // carries no name metadata) and Preact's hydrate() does not patch their
+        // values, so reading them back would post __module/__action='' and 404.
+        fd.set('__module', moduleKey);
+        fd.set('__action', actionName);
         const payload = collectFormData(fd);
         let handle;
         if (optimistic)

package/dist/iso/index.d.ts

@@ -36,3 +36,9 @@ export type { RouteChangeHandler } from './route-change.js';
 export { Head } from './head.js';
 export type { HeadProps } from './head.js';
 export { ClientScript } from './client-script.js';
+export { useViewTransitionLifecycle, type ViewTransitionLifecycle, type ViewTransitionPhaseCallback, } from './view-transition-lifecycle.js';
+export type { ViewTransitionEvent, NavDirection, ViewTransitionReason, } from './internal/view-transition-event.js';
+export { useViewTransitionTypes, subscribeViewTransitionTypes, type ViewTransitionTypesInput, type ViewTransitionTypesNav, } from './view-transition-types.js';
+export { getNavDirection as getViewTransitionDirection } from './internal/history-shim.js';
+export { useViewTransitionName, useViewTransitionClass, ViewTransitionName, ViewTransitionGroup, type ViewTransitionNameProps, type ViewTransitionGroupProps, } from './view-transition-name.js';
+export { Persist, PersistHost, type PersistProps } from './persist.js';

package/dist/iso/index.js

@@ -32,3 +32,12 @@ export { isBrowser, env } from './is-browser.js';
 export { useRouteChange } from './route-change.js';
 export { Head } from './head.js';
 export { ClientScript } from './client-script.js';
+// View transition lifecycle hook.
+export { useViewTransitionLifecycle, } from './view-transition-lifecycle.js';
+// View transitions types.
+export { useViewTransitionTypes, subscribeViewTransitionTypes, } from './view-transition-types.js';
+export { getNavDirection as getViewTransitionDirection } from './internal/history-shim.js';
+// View transition name + group hooks and components.
+export { useViewTransitionName, useViewTransitionClass, ViewTransitionName, ViewTransitionGroup, } from './view-transition-name.js';
+// Persist components.
+export { Persist, PersistHost } from './persist.js';

package/dist/iso/internal/history-shim.d.ts

@@ -0,0 +1,20 @@
+import type { NavDirection } from './view-transition-event.js';
+export declare function onNavigation(listener: () => void): () => void;
+export declare function installHistoryShim(): void;
+export declare function getNavDirection(): NavDirection;
+/**
+ * True once any client-side navigation (push, replace, or popstate) has
+ * occurred since the page loaded. Before the first navigation the document is
+ * still showing its server-rendered, freshly hydrated route. PageMiddlewareHost
+ * uses this to pick its render strategy: on the initial load it renders the
+ * server children during hydration and applies the client middleware outcome
+ * afterwards (so a Suspense boundary never resolves to non-SSR content
+ * mid-hydration, which would orphan the server route DOM); after a navigation
+ * it suspends on the chain normally. `lastDirection` only ever moves away from
+ * 'initial' (never back), so this is a monotonic "have we navigated yet" flag.
+ */
+export declare function hasClientNavigated(): boolean;
+/** Test-only reset. Do not call from production code. */
+export declare function resetHistoryShimForTesting(): void;
+/** Test-only direction setter. Do not call from production code. */
+export declare function setNavDirectionForTesting(dir: NavDirection): void;

package/dist/iso/internal/history-shim.js

@@ -0,0 +1,110 @@
+let installed = false;
+let counter = 0;
+let lastDirection = 'initial';
+// Fires synchronously whenever a navigation occurs (pushState / replaceState /
+// popstate), BEFORE the resulting re-render. Lets the view-transition scheduler
+// observe a navigation at navigation time rather than only at render time (which
+// Preact's render batching can coalesce away). See route-change.ts.
+const navListeners = new Set();
+export function onNavigation(listener) {
+    navListeners.add(listener);
+    return () => navListeners.delete(listener);
+}
+function notifyNavigation() {
+    for (const listener of navListeners)
+        listener();
+}
+let originalPush = null;
+let originalReplace = null;
+let popstateListener = null;
+function readCounterFromState() {
+    if (typeof history === 'undefined')
+        return 0;
+    const state = history.state;
+    return state?.__hpVtIdx ?? 0;
+}
+export function installHistoryShim() {
+    if (installed)
+        return;
+    if (typeof history === 'undefined' || typeof window === 'undefined')
+        return;
+    installed = true;
+    counter = readCounterFromState();
+    lastDirection = 'initial';
+    originalPush = history.pushState.bind(history);
+    originalReplace = history.replaceState.bind(history);
+    history.pushState = function patchedPush(state, title, url) {
+        counter += 1;
+        const merged = {
+            ...(state ?? {}),
+            __hpVtIdx: counter,
+        };
+        originalPush(merged, title, url);
+        lastDirection = 'push';
+        notifyNavigation();
+    };
+    history.replaceState = function patchedReplace(state, title, url) {
+        const merged = {
+            ...(state ?? {}),
+            __hpVtIdx: counter,
+        };
+        originalReplace(merged, title, url);
+        lastDirection = 'replace';
+        notifyNavigation();
+    };
+    popstateListener = (e) => {
+        const incoming = e.state?.__hpVtIdx ?? 0;
+        lastDirection =
+            incoming < counter ? 'back' : incoming > counter ? 'forward' : 'replace';
+        counter = incoming;
+        notifyNavigation();
+    };
+    window.addEventListener('popstate', popstateListener, { capture: true });
+    // Stamp the current entry so subsequent diffs are well-defined.
+    if (history.state?.__hpVtIdx === undefined) {
+        originalReplace({ ...(history.state ?? {}), __hpVtIdx: counter }, '');
+    }
+}
+export function getNavDirection() {
+    return lastDirection;
+}
+/**
+ * True once any client-side navigation (push, replace, or popstate) has
+ * occurred since the page loaded. Before the first navigation the document is
+ * still showing its server-rendered, freshly hydrated route. PageMiddlewareHost
+ * uses this to pick its render strategy: on the initial load it renders the
+ * server children during hydration and applies the client middleware outcome
+ * afterwards (so a Suspense boundary never resolves to non-SSR content
+ * mid-hydration, which would orphan the server route DOM); after a navigation
+ * it suspends on the chain normally. `lastDirection` only ever moves away from
+ * 'initial' (never back), so this is a monotonic "have we navigated yet" flag.
+ */
+export function hasClientNavigated() {
+    return lastDirection !== 'initial';
+}
+/** Test-only reset. Do not call from production code. */
+export function resetHistoryShimForTesting() {
+    if (installed &&
+        typeof history !== 'undefined' &&
+        originalPush &&
+        originalReplace) {
+        history.pushState = originalPush;
+        history.replaceState = originalReplace;
+    }
+    if (typeof window !== 'undefined' && popstateListener) {
+        window.removeEventListener('popstate', popstateListener, {
+            capture: true,
+        });
+    }
+    installed = false;
+    counter = 0;
+    lastDirection = 'initial';
+    originalPush = null;
+    originalReplace = null;
+    popstateListener = null;
+    navListeners.clear();
+}
+/** Test-only direction setter. Do not call from production code. */
+export function setNavDirectionForTesting(dir) {
+    lastDirection = dir;
+}

package/dist/iso/internal/merge-refs.d.ts

@@ -0,0 +1,4 @@
+import type { Ref } from 'preact';
+type AnyRef<T> = Ref<T> | null | undefined;
+export declare function mergeRefs<T>(...refs: AnyRef<T>[]): (node: T | null) => void;
+export {};

package/dist/iso/internal/merge-refs.js

@@ -0,0 +1,14 @@
+export function mergeRefs(...refs) {
+    return (node) => {
+        for (const ref of refs) {
+            if (ref == null)
+                continue;
+            if (typeof ref === 'function') {
+                ref(node);
+            }
+            else {
+                ref.current = node;
+            }
+        }
+    };
+}

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

@@ -1,12 +1,13 @@
 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 { useContext, useEffect, useRef, useState } 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 { hasClientNavigated } from './history-shim.js';
 import { HonoRequestContext } from './contexts.js';
 function startChain(use, location, honoCtx) {
     const { middleware } = partitionUse(use);
@@ -44,68 +45,147 @@ function startChain(use, location, honoCtx) {
         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]);
+/**
+ * Applies a settled host outcome to the rendered tree. Shared rendering logic
+ * for both host strategies (Suspense and Deferred).
+ */
+function renderOutcome(outcome, children) {
     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.
+            // The navigation is scheduled in an effect; render nothing meanwhile so
+            // the old tree doesn't briefly flash.
             return null;
         }
-        // Server: rethrow so renderPage's outer handler can translate to HTTP redirect.
+        // Server: rethrow so renderPage's outer handler can translate to an 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.
+        // 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 chain is re-dispatched, 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; callers needing a forced remount can wrap the 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;
+/**
+ * Suspense strategy: suspend on the middleware chain and render its outcome.
+ * Used for SSR (prerender awaits the suspension) and for post-navigation client
+ * renders (no hydration to mismatch, a fallback is fine while the chain runs).
+ */
+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, and route()
+    // in render would also re-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.
+    const redirectTo = isRedirect(outcome) && isBrowser() ? outcome.to : null;
+    useEffect(() => {
+        if (redirectTo === null)
+            return;
+        // A plain SPA route() is correct here. This consumer only runs on the
+        // server (where the redirect outcome is thrown above, not routed) and for
+        // post-navigation client renders; initial-load redirects are handled by
+        // DeferredHost, which renders the SSR content during hydration so there is
+        // no server-committed tree for the Router to orphan. (The
+        // orphan-on-hydration-mismatch is expected Preact behavior, see
+        // preactjs/preact#4442.)
+        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]);
+    return renderOutcome(outcome, children);
+}
+/**
+ * Deferred strategy: used on the INITIAL document load (browser, before any
+ * client navigation). Renders the server-rendered children during hydration so
+ * the hydrated DOM matches SSR, then runs the client chain post-hydration and
+ * applies its outcome as a normal update. This avoids a Suspense boundary
+ * resolving to non-SSR content mid-hydration, which orphans the server route
+ * DOM (expected Preact behavior, preactjs/preact#4442) and stacks the redirect
+ * target on top (the "client redirect double-mount").
+ *
+ * Timing contract: on the initial load the client middleware runs AFTER
+ * hydration (in the effect), not before first paint. The server already
+ * authorized and rendered this content, so a client guard is advisory here and
+ * applies once hydrated; anything it would redirect away from is already on
+ * screen from SSR, so deferring exposes nothing new. Post-navigation renders
+ * take SuspenseHost, where the chain blocks the render as before.
+ *
+ * Known limitation: this matches the COMMON case where the server passed and
+ * rendered `children`. If a SERVER middleware instead rendered an alternative
+ * (so SSR markup != children) and the client produces no matching outcome, the
+ * client still renders `children` and the SSR/client mismatch is on the user -
+ * the framework does not transmit the server outcome to the client. This is
+ * pre-existing (it predates the deferred strategy) and out of scope here.
+ */
+function DeferredHost({ use, location, honoCtx, children, }) {
+    const { route } = useLocation();
+    // null = chain not yet settled, or settled to a redirect/pass: keep rendering
+    // the server children. A settled render()/deny outcome is stored so it can be
+    // swapped in via a normal post-hydration update.
+    const [applied, setApplied] = useState(null);
+    useEffect(() => {
+        let cancelled = false;
+        // Reset to the server children before re-dispatching, so a stale render()
+        // outcome from a previous path cannot linger if this host is ever reused
+        // across a path change (in practice it only handles the initial load, but
+        // a persisted layout host could in principle see location.path change).
+        setApplied(null);
+        startChain(use, location, honoCtx).then((result) => {
+            if (cancelled)
+                return;
+            if (isRedirect(result.outcome)) {
+                // SPA navigate from the fully hydrated tree. Because the server's
+                // content (not null) was rendered during hydration, there is no
+                // orphaned route DOM for the Router to stack the target on top of.
+                route(result.outcome.to);
+            }
+            else if (result.outcome !== undefined) {
+                // render() / deny: surface after hydration via a normal update.
+                setApplied(result);
+            }
+            // undefined (chain passed): keep the already-rendered children.
+        });
+        return () => {
+            cancelled = true;
+        };
+        // Re-dispatch if the path changes (mirrors SuspenseHost's per-path dispatch).
+    }, [location.path]);
+    if (applied === null)
+        return _jsx(_Fragment, { children: children });
+    return renderOutcome(applied.outcome, children);
+}
+/**
+ * Suspense strategy wrapper. Lazily dispatches the chain once per path (see the
+ * lazy-ref note below) and renders the outcome through HostConsumer.
+ */
+function SuspenseHost({ use, location, honoCtx, fallback, children, }) {
     // 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.
+    // "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) {
@@ -116,4 +196,27 @@ export const PageMiddlewareHost = ({ use = [], location, fallback, children }) =
         resultRef.current = wrapPromise(startChain(use, location, honoCtx));
     }
     return (_jsx(Suspense, { fallback: fallback, children: _jsx(HostConsumer, { resultRef: resultRef, children: children }) }));
+}
+export const PageMiddlewareHost = ({ use = [], location, fallback, children }) => {
+    const honoCtx = useContext(HonoRequestContext).context;
+    // Choose the render strategy ONCE per mount so the hook order stays stable
+    // across renders (hasClientNavigated() flips to true after the first
+    // navigation, which would otherwise change which child - and its hooks - we
+    // render).
+    //
+    // Initial document load (browser, no navigation yet) -> DeferredHost: a
+    // Suspense boundary that suspends during hydration and resolves to non-SSR
+    // content (e.g. null for a redirect) orphans the server-rendered route DOM
+    // (expected Preact behavior, preactjs/preact#4442), which the Router then
+    // stacks the redirect target on top of. Rendering the server children during
+    // hydration and applying the client outcome afterwards removes that mismatch.
+    //
+    // Server render and post-navigation client renders have no hydration to
+    // mismatch, so the Suspense path (suspend on the chain, render the outcome)
+    // is correct there.
+    const deferRef = useRef(isBrowser() && !hasClientNavigated());
+    if (deferRef.current) {
+        return (_jsx(DeferredHost, { use: use, location: location, honoCtx: honoCtx, children: children }));
+    }
+    return (_jsx(SuspenseHost, { use: use, location: location, honoCtx: honoCtx, fallback: fallback, children: children }));
 };

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

@@ -0,0 +1,10 @@
+import type { ComponentChildren } from 'preact';
+export interface PersistEntry {
+    children: ComponentChildren;
+    viewTransitionName: string | undefined;
+}
+export declare function __persistRegistryWrite(id: string, entry: PersistEntry): void;
+export declare function __persistRegistryRead(): ReadonlyMap<string, PersistEntry>;
+export declare function __persistRegistrySubscribe(sub: () => void): () => void;
+/** Test-only reset. Do not call from production code. */
+export declare function __persistRegistryResetForTesting(): void;

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

@@ -0,0 +1,24 @@
+let map = new Map();
+const subs = new Set();
+export function __persistRegistryWrite(id, entry) {
+    // Replace the map reference so consumers using identity-checks can detect.
+    const next = new Map(map);
+    next.set(id, entry);
+    map = next;
+    for (const sub of subs)
+        sub();
+}
+export function __persistRegistryRead() {
+    return map;
+}
+export function __persistRegistrySubscribe(sub) {
+    subs.add(sub);
+    return () => {
+        subs.delete(sub);
+    };
+}
+/** Test-only reset. Do not call from production code. */
+export function __persistRegistryResetForTesting() {
+    map = new Map();
+    subs.clear();
+}

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

@@ -1,4 +1,27 @@
-type Sub = (to: string, from: string | undefined) => void;
+import { ViewTransitionEvent } from './view-transition-event.js';
+export type PhaseName = 'beforeTransition' | 'beforeSwap' | 'afterSwap' | 'afterTransition';
+type PhaseSub = (event: ViewTransitionEvent) => void | Promise<void>;
+type LegacySub = (to: string, from: string | undefined) => void;
+export declare function __subscribePhase(phase: PhaseName, sub: PhaseSub): () => void;
+export declare function __subscribeRouteChange(sub: LegacySub): () => void;
+export declare function __noteLoadStart(): void;
+export declare function __noteLoadEnd(): void;
+/** @internal Test-only reset for coordinator state. */
+export declare function __resetTransitionStateForTesting(): void;
+/**
+ * @internal Install the view-transition render scheduler (client only).
+ *
+ * Takes ownership of `options.debounceRendering`: it captures the previous value
+ * as `prevDebounce` (delegated to for every non-navigation flush) and installs
+ * `scheduleRender` in its place. This assumes nothing else permanently overrides
+ * `options.debounceRendering` afterward. `preact/compat`'s `flushSync` swaps it
+ * temporarily and restores it, so that composes fine; a second permanent
+ * override would shadow this scheduler (the install is idempotent, so calling it
+ * twice is a no-op, not a double-install). Reversed by
+ * `__resetTransitionStateForTesting`.
+ */
+export declare function installNavTransitionScheduler(): void;
 export declare function __dispatchRouteChange(to: string, from: string | undefined): void;
-export declare function __subscribeRouteChange(sub: Sub): () => void;
+/** @internal Test-only reset for default-types installer. */
+export declare function resetDefaultTypesForTesting(): void;
 export {};