fuzor 0.3.0 → 0.5.0

package/dist/runtime/router.js

@@ -0,0 +1,678 @@
+import { mountPageScriptsEffect } from "./page-scripts.js";
+import { makeRouteMatches } from "./route-matches.js";
+import { makeClientRouteMatcher } from "./client-routes.js";
+import { errorHtml, notFoundHtml } from "../boundaries.js";
+import { nearestScope, normalizeBase, routeKey, stripBase, withBase } from "../route-path.js";
+import { coordinateNavigation } from "./coordinated-navigation.js";
+import { abortRouteData, loadRouteData } from "./data.js";
+import { commitTemplate, makeRouteAnnouncer, makeScrollManager, makeHeadManager, templateIdentity, renderIslandError } from "./dom-renderer.js";
+import { navigateDocument, navigationBrowser, supportsBrowserNavigation } from "./browser-support.js";
+import { makeNavigationCoordinator, NavigationLifecycleError } from "./coordinator.js";
+import { NavigationError } from "./navigation.js";
+import { mountIslandsEffect } from "./islands.js";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Scope from "effect/Scope";
+import * as Atom from "effect/reactivity/Atom";
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+/** Canonical route key (see `routeKey`); undecodable paths are returned unchanged and match no route. */
+export function normalizePath(path) {
+    const pathname = new URL(path, "http://fuzor.local").pathname;
+    return routeKey(pathname) ?? pathname;
+}
+const outsideBase = "\0outside-base";
+const documentRouters = new WeakMap();
+const activeRouters = new WeakMap();
+/** The started SPA router that owns `document`, for code that did not create it (islands, app scripts). */
+export function getRouter(document = globalThis.document) {
+    return document ? activeRouters.get(document) : undefined;
+}
+export function createRouterWith(outlet, options, transports) {
+    const document = outlet.ownerDocument;
+    const window = document.defaultView;
+    let registry = AtomRegistry.make();
+    const pathAtom = Atom.make("/").pipe(Atom.keepAlive);
+    const paramsAtom = Atom.make({}).pipe(Atom.keepAlive);
+    const stateAtom = Atom.make(undefined).pipe(Atom.keepAlive);
+    const routeAtom = Atom.make(undefined).pipe(Atom.keepAlive);
+    const urlAtom = Atom.make(document.baseURI).pipe(Atom.keepAlive);
+    const templates = new Map();
+    for (const template of document.querySelectorAll("template[data-fuzor-route]")) {
+        templates.set(normalizePath(template.dataset.fuzorRoute), template);
+    }
+    const clientMatch = makeClientRouteMatcher(options.clientRoutes);
+    const resolveMatches = makeRouteMatches(options.routeTree);
+    const matches = () => { const route = registry.get(routeAtom); return route?.kind === "page" ? resolveMatches(route.path) : []; };
+    for (const target of Object.values(options.clientRoutes ?? {})) {
+        const template = templates.get(normalizePath(target));
+        if (!template)
+            throw new Error(`Client route template ${target} is not compiled.`);
+        if (template.hasAttribute("data-fuzor-data"))
+            throw new Error("Client route templates cannot have server data; load data through client APIs.");
+    }
+    let renderer;
+    const acceptsRoute = (route) => Boolean(renderer?.match(route) || templateFor(route));
+    const templateFor = (route) => templates.get(route) ?? templates.get(clientMatch(route)?.template ?? "");
+    /** Boundary templates keyed by scope; the compiler emits `data-fuzor-not-found="/docs/"` and `data-fuzor-error="/"`. */
+    const boundaries = (kind, fallback) => {
+        const found = new Map();
+        for (const template of document.querySelectorAll(`template[data-fuzor-${kind}]`)) {
+            found.set(normalizePath(template.getAttribute(`data-fuzor-${kind}`) || "/"), template);
+        }
+        if (!found.has("/")) {
+            const template = document.createElement("template");
+            template.innerHTML = fallback;
+            found.set("/", template);
+        }
+        return found;
+    };
+    const notFoundTemplates = boundaries("not-found", notFoundHtml);
+    const errorTemplates = boundaries("error", errorHtml);
+    const boundaryFor = (templates, route) => templates.get(nearestScope(route === outsideBase ? "/" : route, templates.keys()) ?? "/");
+    const boundaryTemplates = new Set([...notFoundTemplates.values(), ...errorTemplates.values()]);
+    const redirects = JSON.parse(document.querySelector("script[data-fuzor-redirects]")?.textContent ?? "{}");
+    const metadata = JSON.parse(document.querySelector("script[data-fuzor-metadata]")?.textContent ?? "{}");
+    const headFor = (template, route) => {
+        for (const [kind, templates, title] of [["not-found", notFoundTemplates, "Page not found"], ["error", errorTemplates, "Something went wrong"]]) {
+            for (const [scope, candidate] of templates)
+                if (candidate === template)
+                    return { title, ...metadata[`${kind}:${scope}`] };
+        }
+        return metadata[route] ?? metadata[clientMatch(route)?.template ?? ""] ?? {};
+    };
+    const loadData = (change) => {
+        void loadRouteData(outlet, { search: new URL(change.destination.url).search })
+            .catch(error => { if (error?.name !== "AbortError")
+            report(error); });
+    };
+    const paramsOf = (template) => boundaryTemplates.has(template) ? {} : JSON.parse(template.getAttribute("data-fuzor-params") ?? "{}");
+    const matchOf = (template, route) => {
+        const dynamic = templates.has(route) ? undefined : clientMatch(route);
+        const pattern = dynamic?.pattern ?? template.getAttribute("data-fuzor-pattern");
+        return Object.freeze({ kind: boundaryTemplates.has(template) ? "not-found" : "page", path: route === outsideBase ? "/" : route,
+            ...(pattern ? { pattern } : {}), params: dynamic?.params ?? paramsOf(template) });
+    };
+    const updateHead = makeHeadManager(document, metadata[""]);
+    const base = normalizeBase(options.base);
+    /** Route key for an adapter pathname, with the deployment base removed for document transports. */
+    const routeOf = (pathname) => {
+        if (logicalTransport)
+            return normalizePath(pathname);
+        const inner = stripBase(pathname, base);
+        return inner === undefined ? outsideBase : normalizePath(inner);
+    };
+    let owner;
+    let adapter;
+    let logicalTransport = Boolean(options.navigation);
+    /** Set when the build has no in-place transport this browser supports; navigation then loads documents. */
+    let documentOnly = false;
+    let transition;
+    let startVersion = 0;
+    let starting;
+    let closing = Promise.resolve();
+    let registryClosed = false;
+    const token = Symbol("Fuzor router");
+    const closures = new WeakMap();
+    const stopScope = (scope) => {
+        const existing = closures.get(scope);
+        if (existing)
+            return existing;
+        if (owner === scope) {
+            startVersion++;
+            owner = undefined;
+            transition = undefined;
+            starting = undefined;
+        }
+        const activeRegistry = registry;
+        const cleanup = Effect.runPromise(Scope.close(scope, Exit.void)).catch(report).finally(() => {
+            activeRegistry.dispose();
+            registryClosed = true;
+            if (documentRouters.get(document) === token) {
+                documentRouters.delete(document);
+                activeRouters.delete(document);
+            }
+        });
+        closures.set(scope, cleanup);
+        closing = cleanup;
+        return cleanup;
+    };
+    const report = options.onError ?? (error => console.error(error));
+    const blockers = new Set();
+    const isBlocked = (attempt) => {
+        for (const blocker of blockers) {
+            try {
+                if (blocker(attempt))
+                    return true;
+            }
+            catch (error) {
+                report(error);
+            }
+        }
+        return false;
+    };
+    /** Set while a command the blockers already allowed dispatches its own browser event. */
+    let approvedCommand = false;
+    let approvedTraversal;
+    let restoringTraversal = false;
+    const onBeforeUnload = (event) => {
+        if (isBlocked({ url: document.location?.href ?? document.baseURI, kind: "document" })) {
+            event.preventDefault();
+            event.returnValue = "";
+        }
+    };
+    // beforeunload listeners can disable the back/forward cache, so one exists only while blockers do.
+    const block = (blocker) => {
+        if (blockers.size === 0)
+            window?.addEventListener("beforeunload", onBeforeUnload);
+        blockers.add(blocker);
+        return () => {
+            if (blockers.delete(blocker) && blockers.size === 0)
+                window?.removeEventListener("beforeunload", onBeforeUnload);
+        };
+    };
+    /** Scroll and focus choices of pending `navigate()` calls, keyed by destination URL. */
+    const policies = new Map();
+    /** Route-fatal errors of the latest transition to each URL, read back by `navigate()`. */
+    const failures = new Map();
+    /** Replacement navigations started by compiled redirects, keyed by the redirected URL. */
+    const redirecting = new Map();
+    const navigate = (href, request = {}) => {
+        let settleCommitted;
+        let failCommitted;
+        const committed = new Promise((resolve, reject) => { settleCommitted = resolve; failCommitted = reject; });
+        const finished = (async () => {
+            if (!owner || !transition)
+                throw new NavigationError("Unsupported", "Start the Fuzor router before navigating");
+            const base = logicalTransport ? (await Effect.runPromise(adapter.current)).url : document.baseURI;
+            let url;
+            try {
+                url = new URL(href, base);
+            }
+            catch (error) {
+                throw new NavigationError("InvalidUrl", String(error));
+            }
+            const accepted = options.acceptsUrl?.(url) ?? (url.origin === new URL(document.baseURI).origin && ["http:", "https:"].includes(url.protocol));
+            // Like browser link navigation, a push to the current URL replaces the entry instead of duplicating it.
+            const history = (request.history ?? "auto") === "auto" ? (url.href === registry.get(urlAtom) ? "replace" : "push") : request.history;
+            if (request.document || documentOnly) {
+                if (logicalTransport)
+                    throw new NavigationError("Unsupported", "Embedded documents cannot load another document; navigate without document: true");
+                if (isBlocked({ url: url.href, kind: "document" }))
+                    return { status: "blocked", url: url.href };
+                await Effect.runPromise(navigateDocument(navigationBrowser(window, document), url.href, history === "replace"));
+                return { status: "document", url: url.href };
+            }
+            if (!logicalTransport && !accepted)
+                throw new NavigationError("InvalidUrl", `${url.href} is outside this app; use document: true to leave it`);
+            if (isBlocked({ url: url.href, kind: history }))
+                return { status: "blocked", url: url.href };
+            if (request.scroll || request.focus)
+                policies.set(url.href, { ...(request.scroll ? { scroll: request.scroll } : {}), ...(request.focus ? { focus: request.focus } : {}) });
+            approvedCommand = true;
+            let pending;
+            try {
+                pending = Effect.runPromise(adapter.navigate({ href: url.href, history, ...(request.state === undefined ? {} : { state: request.state }) }));
+            }
+            finally {
+                approvedCommand = false;
+            }
+            let result;
+            try {
+                result = await pending;
+            }
+            catch (error) {
+                policies.delete(url.href);
+                throw error;
+            }
+            let destination = result.change.destination.url;
+            settleCommitted({ status: "committed", url: destination });
+            const exit = await Effect.runPromiseExit(result.finished);
+            // A compiled redirect continues as a replacement navigation, which aborts this one in browsers with the
+            // Navigation API; report where it ended.
+            const redirect = redirecting.get(destination);
+            if (redirect) {
+                redirecting.delete(destination);
+                const followed = await redirect;
+                if (followed.status !== "completed")
+                    return followed;
+                destination = followed.url;
+                const route = registry.get(routeAtom);
+                return { status: "completed", url: destination, ...(route ? { route } : {}) };
+            }
+            if (Exit.isFailure(exit)) {
+                if (Cause.hasInterruptsOnly(exit.cause))
+                    return { status: "cancelled", url: destination };
+                return { status: "failed", url: destination, error: Cause.squash(exit.cause) };
+            }
+            const route = registry.get(routeAtom);
+            if (failures.has(destination)) {
+                const error = failures.get(destination);
+                failures.delete(destination);
+                return { status: "failed", url: destination, ...(route ? { route } : {}), error };
+            }
+            return { status: "completed", url: destination, ...(route ? { route } : {}) };
+        })();
+        finished.then(settleCommitted, failCommitted);
+        // Callers often await only one of the two; the other must not report an unhandled rejection.
+        committed.catch(() => { });
+        return Object.assign(finished, { committed, finished });
+    };
+    const prefetched = new Set();
+    const onIntent = (event) => {
+        if (window?.navigator?.connection?.saveData)
+            return;
+        const link = linkFor(event);
+        const raw = link?.getAttribute("href") ?? link?.getAttributeNS("http://www.w3.org/1999/xlink", "href");
+        if (!link || raw == null || link.hasAttribute("data-fuzor-reload") || link.hasAttribute("download"))
+            return;
+        let url;
+        try {
+            url = new URL(raw, logicalTransport ? registry.get(urlAtom) : link.baseURI || document.baseURI);
+        }
+        catch {
+            return;
+        }
+        if (!logicalTransport && url.origin !== new URL(document.baseURI).origin)
+            return;
+        const template = templateFor(routeOf(url.pathname));
+        if (!template)
+            return;
+        for (const host of template.content.querySelectorAll("fuzor-island[src]")) {
+            const name = host.getAttribute("src");
+            const key = `island:${name}`;
+            const load = options.islands?.[name];
+            if (!load || prefetched.has(key))
+                continue;
+            prefetched.add(key);
+            // Failures are ignored here; activation reports them if the page is actually opened.
+            void load().catch(() => { prefetched.delete(key); });
+        }
+    };
+    const linkFor = (event) => {
+        // composedPath() sees through open shadow roots; SVG anchors are not HTMLAnchorElements.
+        for (const node of event.composedPath()) {
+            const element = node;
+            if (typeof element.getAttribute !== "function" || typeof element.localName !== "string")
+                continue;
+            const name = element.localName;
+            if ((name === "a" || name === "area") && (element.hasAttribute("href") || element.hasAttributeNS("http://www.w3.org/1999/xlink", "href")))
+                return element;
+        }
+        return undefined;
+    };
+    const onClick = (event) => {
+        if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey)
+            return;
+        const link = linkFor(event);
+        if (!link)
+            return;
+        const target = link.getAttribute("target");
+        if ((target && target !== "_self") || link.hasAttribute("download") || link.hasAttribute("data-fuzor-reload"))
+            return;
+        const raw = (link.getAttribute("href") ?? link.getAttributeNS("http://www.w3.org/1999/xlink", "href") ?? "").trim();
+        if (logicalTransport && (raw.startsWith("#") || raw.startsWith("?"))) {
+            let logical;
+            try {
+                logical = new URL(raw, registry.get(urlAtom));
+            }
+            catch {
+                return;
+            }
+            if (!acceptsRoute(routeOf(logical.pathname)) && !Object.hasOwn(redirects, routeOf(logical.pathname)))
+                return;
+            event.preventDefault();
+            void navigate(logical.href).catch(report);
+            return;
+        }
+        let url;
+        try {
+            url = new URL(raw, link.baseURI || document.baseURI);
+        }
+        catch {
+            return;
+        }
+        const transport = new URL(document.baseURI);
+        const allowed = options.acceptsUrl?.(url) ?? (url.origin === transport.origin && url.host === transport.host &&
+            (logicalTransport ? url.protocol === transport.protocol : ["http:", "https:"].includes(url.protocol)));
+        if (!allowed || !(acceptsRoute(routeOf(url.pathname)) || Object.hasOwn(redirects, routeOf(url.pathname))))
+            return;
+        event.preventDefault();
+        void navigate(logicalTransport ? url.pathname + url.search + url.hash : url.href).catch(report);
+    };
+    const start = () => {
+        if (starting)
+            return starting;
+        const version = ++startVersion;
+        starting = (async () => {
+            await closing;
+            if (version !== startVersion)
+                return async () => { };
+            if (documentRouters.has(document)) {
+                starting = undefined;
+                throw new Error("Only one active Fuzor SPA router can own document navigation");
+            }
+            if (registryClosed) {
+                registry = AtomRegistry.make();
+                registryClosed = false;
+            }
+            const scope = await Effect.runPromise(Scope.make());
+            if (version !== startVersion) {
+                await Effect.runPromise(Scope.close(scope, Exit.void));
+                return async () => { };
+            }
+            if (documentRouters.has(document)) {
+                await Effect.runPromise(Scope.close(scope, Exit.void));
+                starting = undefined;
+                throw new Error("Only one active Fuzor SPA router can own document navigation");
+            }
+            documentRouters.set(document, token);
+            activeRouters.set(document, api);
+            owner = scope;
+            const scoped = (effect) => Effect.runPromise(effect.pipe(Effect.provideService(Scope.Scope, scope)));
+            try {
+                const scrolling = window ? makeScrollManager(outlet, window) : undefined;
+                if (window)
+                    await scoped(Effect.acquireRelease(Effect.sync(() => {
+                        const hide = (event) => {
+                            // Keep this entry's scroll position for a reload or a later return from another document.
+                            if (adapter && !adapter.capabilities.nativeScroll)
+                                scrolling?.remember(Effect.runSync(adapter.current).key);
+                            if (!event.persisted)
+                                void stopScope(scope);
+                        };
+                        window.addEventListener("pagehide", hide);
+                        return hide;
+                    }), hide => Effect.sync(() => window.removeEventListener("pagehide", hide))));
+                await scoped(Effect.addFinalizer(() => Effect.sync(() => { abortRouteData(outlet); restoringTraversal = false; approvedTraversal = undefined; })));
+                const announcer = await scoped(Effect.acquireRelease(Effect.sync(() => makeRouteAnnouncer(document, outlet)), announcer => Effect.sync(announcer.dispose)));
+                if (options.renderer) {
+                    renderer = options.renderer(outlet);
+                    const currentRenderer = renderer;
+                    await scoped(Effect.addFinalizer(() => Effect.tryPromise({
+                        try: () => currentRenderer.dispose(), catch: error => error
+                    }).pipe(Effect.catch(error => Effect.sync(() => report(error))), Effect.tap(() => Effect.sync(() => { if (renderer === currentRenderer)
+                        renderer = undefined; })))));
+                }
+                let renderedPath;
+                const coordinator = await scoped(makeNavigationCoordinator({
+                    resolve: change => Effect.tryPromise({
+                        try: async (signal) => {
+                            const route = routeOf(change.destination.pathname);
+                            const found = renderer?.match(route);
+                            if (found && renderer) {
+                                const payload = await renderer.resolve(change.destination.url, signal, renderedPath === undefined);
+                                return { template: boundaryFor(notFoundTemplates, route), match: Object.freeze({ kind: "page", path: route, ...found }), tree: { payload } };
+                            }
+                            const template = templateFor(route) ?? boundaryFor(notFoundTemplates, route);
+                            return { template, match: matchOf(template, route) };
+                        }, catch: error => new NavigationLifecycleError("resolve", error)
+                    }),
+                    commit: (resolved, change) => {
+                        const { template, match, tree } = resolved;
+                        if (tree)
+                            return Effect.tryPromise({
+                                try: async (signal) => {
+                                    await renderer.commit(tree.payload, signal);
+                                    if (signal.aborted)
+                                        return;
+                                    abortRouteData(outlet);
+                                    outlet.removeAttribute("data-fuzor-data");
+                                    outlet.removeAttribute("data-fuzor-params");
+                                    registry.set(paramsAtom, match.params);
+                                    registry.set(routeAtom, match);
+                                    registry.set(pathAtom, match.path);
+                                    renderedPath = match.path;
+                                }, catch: error => new NavigationLifecycleError("commit", error)
+                            });
+                        const apply = () => {
+                            const route = routeOf(change.destination.pathname);
+                            const params = match.params;
+                            // Adopt compiler-rendered HTML only on the first matching route commit.
+                            const adopt = renderedPath === undefined && outlet.getAttribute("data-fuzor-initial-route") === route &&
+                                (outlet.getAttribute("data-fuzor-initial-template") ?? route) === templateIdentity(template);
+                            outlet.removeAttribute("data-fuzor-initial-route");
+                            outlet.removeAttribute("data-fuzor-initial-template");
+                            if (!adopt) {
+                                outlet.removeAttribute("data-fuzor-data-ready");
+                                commitTemplate(outlet, template);
+                            }
+                            if (Object.keys(params).length)
+                                outlet.setAttribute("data-fuzor-params", JSON.stringify(params));
+                            else
+                                outlet.removeAttribute("data-fuzor-params");
+                            const data = boundaryTemplates.has(template) ? null : template.getAttribute("data-fuzor-data");
+                            abortRouteData(outlet);
+                            if (data) {
+                                outlet.setAttribute("data-fuzor-data", data);
+                                // Start before island activation so islands share this request through routeData().
+                                loadData(change);
+                            }
+                            else
+                                outlet.removeAttribute("data-fuzor-data");
+                            updateHead(headFor(template, route));
+                            registry.set(paramsAtom, params);
+                            registry.set(routeAtom, match);
+                            registry.set(pathAtom, route);
+                            // The DOM already belongs to this route, even while its islands are still activating.
+                            renderedPath = route;
+                        };
+                        const startViewTransition = document.startViewTransition;
+                        const animate = options.viewTransitions && change.kind !== "reload" && typeof startViewTransition === "function" &&
+                            !window?.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
+                        const clear = renderer ? Effect.tryPromise({ try: () => renderer.clear(), catch: error => new NavigationLifecycleError("commit", error) }) : Effect.void;
+                        if (!animate)
+                            return clear.pipe(Effect.andThen(Effect.try({ try: apply, catch: error => new NavigationLifecycleError("commit", error) })));
+                        // The DOM update runs inside the transition; the navigation continues once it has been applied.
+                        return clear.pipe(Effect.andThen(Effect.tryPromise({
+                            try: signal => {
+                                const animation = startViewTransition.call(document, () => { if (!signal.aborted)
+                                    apply(); });
+                                // Skipping an animation rejects ready. DOM failures are handled through updateCallbackDone.
+                                void Promise.all([animation.ready, animation.finished]).catch(() => { });
+                                return animation.updateCallbackDone;
+                            },
+                            catch: error => new NavigationLifecycleError("commit", error)
+                        })));
+                    },
+                    activate: (resolved) => Effect.gen(function* () {
+                        if (!resolved.tree)
+                            yield* mountIslandsEffect(outlet, options.islands ?? {}, (error, host, retry) => {
+                                report(error);
+                                renderIslandError(host, retry);
+                            }, options.islandTimeouts);
+                        if (!resolved.tree) {
+                            const template = resolved.template;
+                            const route = template.getAttribute("data-fuzor-route") ?? (template.hasAttribute("data-fuzor-not-found") ? `not-found:${template.getAttribute("data-fuzor-not-found")}` : `error:${template.getAttribute("data-fuzor-error")}`);
+                            yield* mountPageScriptsEffect(outlet, options.scripts ?? {}, route, { onError: report });
+                        }
+                    }).pipe(Effect.mapError(error => new NavigationLifecycleError("activate", error)))
+                }));
+                await scoped(coordinator.subscribe(() => {
+                    const state = coordinator.state();
+                    if (!state)
+                        return;
+                    // The public state carries the route match, not the template element.
+                    const { route, ...rest } = state;
+                    registry.set(stateAtom, Object.freeze({ ...rest, ...(route ? { route: route.match } : {}) }));
+                }));
+                transition = change => {
+                    if (change.kind === "traverse") {
+                        if (restoringTraversal) {
+                            restoringTraversal = false;
+                            return Effect.void;
+                        }
+                        const approved = approvedTraversal !== undefined && approvedTraversal === change.destination.key;
+                        approvedTraversal = undefined;
+                        if (!approved && blockers.size && isBlocked({ url: change.destination.url, kind: "traverse" })) {
+                            // Back/Forward already changed the URL and could not be cancelled: return to the previous entry.
+                            if (change.delta !== null && change.delta !== 0) {
+                                restoringTraversal = true;
+                                return adapter.traverse(-change.delta).pipe(Effect.asVoid, Effect.catch(error => Effect.sync(() => { restoringTraversal = false; report(error); })));
+                            }
+                            report(new Error("A navigation blocker could not undo a traversal with an unknown distance; the navigation continued."));
+                        }
+                    }
+                    const redirect = redirects[routeOf(change.destination.pathname)];
+                    if (redirect !== undefined) {
+                        // A successor navigation: it does not wait for the transition that discovered it.
+                        return Effect.sync(() => {
+                            if (/^https?:\/\//i.test(redirect)) {
+                                window?.location.replace(redirect);
+                                return;
+                            }
+                            const target = new URL(logicalTransport ? redirect : withBase(redirect, base), change.destination.url);
+                            if (!target.search)
+                                target.search = new URL(change.destination.url).search;
+                            const followed = Effect.runPromise(adapter.navigate({ href: target.href, history: "replace" })).then(async (result) => {
+                                const exit = await Effect.runPromiseExit(result.finished);
+                                const url = result.change.destination.url;
+                                return Exit.isSuccess(exit) ? { status: "completed", url }
+                                    : Cause.hasInterruptsOnly(exit.cause) ? { status: "cancelled", url } : { status: "failed", url, error: Cause.squash(exit.cause) };
+                            });
+                            followed.catch(report);
+                            redirecting.set(change.destination.url, followed.catch(error => ({ status: "failed", url: target.href, error })));
+                            if (redirecting.size > 32)
+                                redirecting.delete(redirecting.keys().next().value);
+                        });
+                    }
+                    registry.set(urlAtom, change.destination.url);
+                    failures.delete(change.destination.url);
+                    const policy = change.kind === "traverse" ? undefined : policies.get(change.destination.url);
+                    policies.delete(change.destination.url);
+                    const pathname = routeOf(change.destination.pathname);
+                    const firstRender = renderedPath === undefined;
+                    // A pending or canceled commit cannot be treated as a settled same-page query change.
+                    const replaced = Boolean(renderer?.match(pathname)) || pathname !== renderedPath || change.kind === "reload" || coordinator.state()?.phase !== "completed";
+                    // The first render must not overwrite the position this entry had before a reload.
+                    if (!adapter?.capabilities.nativeScroll && renderedPath !== undefined)
+                        scrolling?.save(change);
+                    // Route-fatal failures (resolve/commit) show the nearest error boundary; the URL has already
+                    // committed, so there is no rollback. Island failures stay inside their own boundaries.
+                    const work = replaced ? coordinator.transition(change).pipe(Effect.catch(error => (renderer ? Effect.tryPromise({ try: () => renderer.clear(), catch: cleanup => cleanup }).pipe(Effect.catch(cleanup => Effect.sync(() => report(cleanup)))) : Effect.void).pipe(Effect.andThen(Effect.sync(() => {
+                        report(error);
+                        failures.set(change.destination.url, error);
+                        if (failures.size > 32)
+                            failures.delete(failures.keys().next().value);
+                        const route = routeOf(change.destination.pathname);
+                        try {
+                            const template = boundaryFor(errorTemplates, route);
+                            commitTemplate(outlet, template);
+                            updateHead(headFor(template, route));
+                        }
+                        catch (boundaryError) {
+                            report(boundaryError);
+                            const fallback = document.createElement("p");
+                            fallback.setAttribute("role", "alert");
+                            fallback.textContent = "Something went wrong.";
+                            outlet.replaceChildren(fallback);
+                        }
+                        outlet.removeAttribute("data-fuzor-params");
+                        abortRouteData(outlet);
+                        outlet.removeAttribute("data-fuzor-data");
+                        registry.set(paramsAtom, {});
+                        registry.set(routeAtom, undefined);
+                        registry.set(pathAtom, route);
+                        renderedPath = route;
+                    }))))) : Effect.void;
+                    return work.pipe(Effect.tap(() => Effect.sync(() => {
+                        // Query-only changes keep the DOM but still follow the URL with fresh data.
+                        if (!replaced && outlet.hasAttribute("data-fuzor-data"))
+                            loadData(change);
+                        if (replaced && change.kind !== "reload") {
+                            if (policy?.focus !== "preserve")
+                                scrolling?.focus();
+                            announcer.announce();
+                        }
+                        if (!adapter?.capabilities.nativeScroll) {
+                            if (policy?.scroll !== "preserve")
+                                scrolling?.finish(change, replaced, firstRender);
+                        }
+                        // The browser's own anchor scroll ran before the router inserted the page, so the target did
+                        // not exist yet. Scroll once for the initial URL unless the page has already been scrolled.
+                        else if (firstRender && change.destination.hash && window && window.scrollY === 0)
+                            scrolling?.finish(change, replaced, firstRender);
+                    })));
+                };
+                if (options.navigation) {
+                    if (options.navigation.capabilities.nativeScroll && options.navigation.capabilities.documentNavigation)
+                        throw new Error("Use the default browser adapter selection for native Navigation API interception");
+                    if (options.navigation.capabilities.interception)
+                        throw new Error("Inject an adapter without a preinstalled interception handler");
+                    adapter = await scoped(coordinateNavigation(options.navigation, transition, report));
+                }
+                else {
+                    if (!window)
+                        throw new Error("A browser window or an injected navigation adapter is required");
+                    const browser = navigationBrowser(window, document);
+                    const httpDocument = ["http:", "https:"].includes(window.location.protocol);
+                    if (!httpDocument && !transports.hash)
+                        throw new Error(`This router build has no fragment routing for ${window.location.protocol} documents; use createRouter from fuzor/runtime or the embedded router.`);
+                    if (transports.hash && (transports.alwaysHash || !httpDocument)) {
+                        logicalTransport = true;
+                        adapter = await scoped(coordinateNavigation(await scoped(transports.hash(window)), transition, report));
+                    }
+                    else if (!(transports.browser && supportsBrowserNavigation(browser) && !options.acceptsUrl) && !transports.history) {
+                        // No in-place transport for this browser: pages still work, as document loads.
+                        documentOnly = true;
+                        adapter = await scoped(coordinateNavigation(await Effect.runPromise(transports.document(window)), transition, report));
+                    }
+                    else
+                        adapter = transports.browser && supportsBrowserNavigation(browser) && !options.acceptsUrl
+                            ? await scoped(transports.browser(browser, {
+                                // Interception policy, identical to the History fallback: links and programmatic navigation to
+                                // compiled routes or redirects render in place; traversals are checked against blockers; reloads,
+                                // form submissions (GET and POST) and data-fuzor-reload links stay document navigations.
+                                accepts: (url, event) => {
+                                    const source = event.sourceElement;
+                                    const form = !!event.formData || source?.localName === "form" || source?.localName === "button" || source?.localName === "input";
+                                    const accepted = event.navigationType !== "reload" && !form && (acceptsRoute(routeOf(url.pathname)) || Object.hasOwn(redirects, routeOf(url.pathname))) &&
+                                        !source?.closest?.("[data-fuzor-reload]");
+                                    if (!accepted || approvedCommand || !blockers.size || !event.cancelable)
+                                        return accepted;
+                                    const kind = event.navigationType === "traverse" ? "traverse" : event.navigationType === "replace" ? "replace" : "push";
+                                    if (isBlocked({ url: url.href, kind })) {
+                                        event.preventDefault();
+                                        return false;
+                                    }
+                                    if (kind === "traverse")
+                                        approvedTraversal = event.destination.key;
+                                    return true;
+                                },
+                                options: change => {
+                                    const policy = policies.get(change.destination.url);
+                                    return policy && { scroll: policy.scroll === "preserve" ? "manual" : "after-transition", focusReset: policy.focus === "preserve" ? "manual" : "after-transition" };
+                                },
+                                transition
+                            }))
+                            : await scoped(transports.history(window, { transition, onError: report, ...(options.acceptsUrl ? { acceptsUrl: options.acceptsUrl } : {}) }));
+                    if (!adapter.capabilities.nativeScroll)
+                        await scoped(Effect.acquireRelease(Effect.sync(() => { const previous = window.history.scrollRestoration; window.history.scrollRestoration = "manual"; return previous; }), previous => Effect.sync(() => { window.history.scrollRestoration = previous; })));
+                }
+                const initial = await Effect.runPromise(adapter.current);
+                // A navigation that starts while the first page renders (a deep link, a quick tap) supersedes that
+                // render. That interruption is normal; only real failures stop the router.
+                const first = await Effect.runPromiseExit(transition({ kind: "reload", from: initial, destination: initial, delta: 0 }));
+                if (Exit.isFailure(first) && !Cause.hasInterruptsOnly(first.cause))
+                    throw Cause.squash(first.cause);
+                if (!adapter?.capabilities.interception && !documentOnly)
+                    await scoped(Effect.acquireRelease(Effect.sync(() => document.addEventListener("click", onClick)), () => Effect.sync(() => document.removeEventListener("click", onClick))));
+                if (options.prefetch === "intent")
+                    await scoped(Effect.acquireRelease(Effect.sync(() => { document.addEventListener("pointerover", onIntent, { passive: true }); document.addEventListener("focusin", onIntent); }), () => Effect.sync(() => { document.removeEventListener("pointerover", onIntent); document.removeEventListener("focusin", onIntent); })));
+                return () => stopScope(scope);
+            }
+            catch (error) {
+                const cancelled = owner !== scope;
+                await stopScope(scope);
+                if (cancelled)
+                    return () => stopScope(scope);
+                throw error;
+            }
+        })();
+        return starting;
+    };
+    const api = { matches, subscribeMatches: (listener) => registry.subscribe(routeAtom, () => listener(matches())), start, block, navigation: () => adapter, dispose: () => { startVersion++; if (!owner)
+            starting = undefined; return owner ? stopScope(owner) : closing; }, navigate, state: () => registry.get(stateAtom), subscribeState: (listener) => registry.subscribe(stateAtom, listener), route: () => registry.get(routeAtom), subscribeRoute: (listener) => registry.subscribe(routeAtom, listener), url: () => registry.get(urlAtom), subscribeUrl: (listener) => registry.subscribe(urlAtom, listener), path: () => registry.get(pathAtom), params: () => registry.get(paramsAtom), subscribeParams: (listener) => registry.subscribe(paramsAtom, listener), subscribe: (listener) => registry.subscribe(pathAtom, listener) };
+    return api;
+}
+//# sourceMappingURL=router.js.map