@sjcx/vorma 0.0.0-pre.1 → 0.0.0-pre.3

package/dist/client/react/index.js

@@ -1,3237 +0,0 @@
-import { _ as DOCUMENT_PROTOCOL, b as HTTP_PROTOCOL, i as encodeTransportedValue, o as canonicalizeRequestPathForMatcher, r as decodeTransportedValue } from "../../value-transport-Bst4Hk-n.js";
-import { A as routeStateAtom, B as RevalidationError, C as committedFrameAtom, D as projectRouteState, E as projectRouteError, F as HandlerError, H as getQueryRedirect, I as InputError, L as NavigationError, M as clientStateAtom, N as BuildMismatchError, P as CancelledByDedupeKeyError, R as PrefetchError, S as buildMismatchAtom, T as navigationStateAtom, V as TransportError, _ as CLIENT_TRANSPORT_TYPE_ENTRIES, a as readSynchronizationTarget, b as createLinkIntent, c as createWorkIndicator, d as ClientCoordinator, f as clientRuntime, g as toHref, h as universalRuntime, i as getRouteMatchAtom, j as workStateAtom, k as revalidationStateAtom, m as publishApplicationContexts, n as getClientLoaderDataAtom, o as runSynchronizationTarget, p as provideClientContext, r as getLoaderDataAtom, t as createRouteContext, u as CLIENT_UNAVAILABLE_ERROR, v as allowsInterception, x as getLinkStateAtomFor, y as attachPointerModalityTracking, z as QueryRedirected } from "../../route-context-CtY_9U_W.js";
-import { h as encodeScalar, i as serializeSearchParams, t as buildHref } from "../../href-Cqyax8Y0.js";
-import { i as readTransportedValue, n as readEndpointErrorEnvelope, r as readRedirectStatus, t as getStaticAssetDestination } from "../../static-assets-BrH3O0M8.js";
-import { C as readDocumentHead, S as rememberScroll, _ as satisfyDemand, a as readDocumentStylesheets, b as readBrowserPosition, c as acknowledgeQuery, d as failAttempt, f as holdAttemptForRetry, g as retireDemand, h as releaseQuery, i as prepareStylesheets, l as canStartAttempt, m as registerDemand, n as materializeRoute, o as reloadDocument, p as makeRevalidationError, r as commitFrame, s as abandonAttempt, u as expectQueries, v as startAttempt, x as recallScroll, y as createEntryKey } from "../../materialize-DZ7VSLFk.js";
-import { Brand, Cause, Context, Deferred, Duration, Effect, Exit, Fiber, FiberSet, Layer, Option, PubSub, RcMap, Result, Scope, Stream, identity } from "effect";
-import { FetchHttpClient, Headers, HttpBody, HttpClient, HttpClientRequest } from "effect/unstable/http";
-import { AsyncResult, Atom, AtomRegistry, Reactivity } from "effect/unstable/reactivity";
-import { RegistryContext, scheduleTask, useAtomValue } from "@effect/atom-react";
-import { createRoot } from "react-dom/client";
-import { deepEquals } from "@vorma/primitives/json";
-import { Component, createContext, memo, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
-import { jsx } from "react/jsx-runtime";
-//#region src/client/client-loaders.ts
-const CONFIRMED_DYNAMIC_PATH_CAPACITY = 4096;
-function toKnownMatch(route) {
-	return {
-		pattern: route.pattern,
-		params: route.params,
-		splatValues: route.splatValues,
-		input: route.searchInput
-	};
-}
-function createClientLoaderRegistry() {
-	/** By authored pattern. */
-	const facts = /* @__PURE__ */ new Map();
-	const confirmedPaths = /* @__PURE__ */ new Map();
-	let module = null;
-	/** Built from the registrations on first use after they change. */
-	let matcher = null;
-	function getMatcher() {
-		if (module === null) return null;
-		if (matcher === null) matcher = module.createLearnedMatcher([...facts.values()].map((own) => {
-			return {
-				pattern: own.compiled,
-				value: own
-			};
-		}));
-		return matcher;
-	}
-	function matchLearned(path) {
-		const learned = getMatcher();
-		if (learned === null) return null;
-		const chain = learned.matchPath(path);
-		if (chain === null) return null;
-		const proven = [];
-		for (const match of chain) {
-			const own = match.value;
-			proven.push({
-				pattern: own.pattern,
-				params: match.params,
-				splatValues: match.splatValues,
-				facts: own
-			});
-		}
-		return proven;
-	}
-	function selectStaticPrefix(chain) {
-		const end = chain.findIndex((match) => !match.facts.isStatic);
-		return end === -1 ? chain : chain.slice(0, end);
-	}
-	/** The chain the registry can prove for `path`: the confirmed chain while the learned patterns agree with it, else the static prefix of a learned match. */
-	function proveChain(path) {
-		const learned = matchLearned(path);
-		const confirmed = confirmedPaths.get(path);
-		if (confirmed !== void 0) {
-			if (learned === null || learned.length === confirmed.length && learned.every((match, index) => {
-				return confirmed[index]?.pattern === match.pattern;
-			})) {
-				confirmedPaths.delete(path);
-				confirmedPaths.set(path, confirmed);
-				return confirmed;
-			}
-			confirmedPaths.delete(path);
-		}
-		return learned === null ? [] : selectStaticPrefix(learned);
-	}
-	/** A position's search input parsed from the contract structure; null when parsing refuses it. */
-	function readSearchInput(input) {
-		const parsed = input.module.parseSearch({
-			document: input.search.document,
-			searchParams: input.searchParams
-		});
-		return Result.isFailure(parsed) ? null : { value: parsed.success };
-	}
-	function recordConfirmedPath(input) {
-		confirmedPaths.delete(input.path);
-		const firstDynamicIndex = input.matches.findIndex((match) => !match.facts.isStatic);
-		if (firstDynamicIndex === -1) return;
-		if (!input.matches.some((match, index) => {
-			return index >= firstDynamicIndex && match.facts.view?.clientLoader !== void 0;
-		})) return;
-		confirmedPaths.set(input.path, input.matches);
-		if (confirmedPaths.size <= CONFIRMED_DYNAMIC_PATH_CAPACITY) return;
-		for (const leastRecentlyUsedPath of confirmedPaths.keys()) {
-			confirmedPaths.delete(leastRecentlyUsedPath);
-			break;
-		}
-	}
-	return {
-		replaceViewsFn: (replacements) => {
-			for (const own of facts.values()) if (own.view !== void 0 && replacements.has(own.view)) own.view = replacements.get(own.view);
-		},
-		recordConfirmedChain: (chain) => {
-			const proven = [];
-			for (const route of chain.routes) {
-				let own = facts.get(route.pattern);
-				if (own === void 0) {
-					own = {
-						pattern: route.pattern,
-						compiled: route.compiledPattern,
-						isStatic: route.compiledPattern.segments.every((segment) => {
-							return segment.kind === "static" || segment.kind === "index";
-						}),
-						search: route.searchContract === null ? null : { document: route.searchContract },
-						view: route.definition
-					};
-					facts.set(route.pattern, own);
-					matcher = null;
-				}
-				proven.push({
-					pattern: route.pattern,
-					params: route.params,
-					splatValues: route.splatValues,
-					facts: own
-				});
-			}
-			const path = canonicalizeRequestPathForMatcher(chain.url.pathname);
-			if (Result.isSuccess(path)) recordConfirmedPath({
-				path: path.success,
-				matches: proven
-			});
-		},
-		installMatching: (installed) => {
-			module = installed;
-			matcher = null;
-		},
-		findEligibleMatches: (url) => {
-			if (module === null) return [];
-			const path = canonicalizeRequestPathForMatcher(url.pathname);
-			if (Result.isFailure(path)) return [];
-			const eligible = [];
-			for (const match of proveChain(path.success)) {
-				let input;
-				if (match.facts.search !== null) {
-					const read = readSearchInput({
-						module,
-						search: match.facts.search,
-						searchParams: url.searchParams
-					});
-					if (read === null) break;
-					input = read.value;
-				}
-				eligible.push({
-					match: {
-						pattern: match.pattern,
-						params: match.params,
-						splatValues: match.splatValues,
-						input
-					},
-					view: match.facts.view
-				});
-			}
-			return eligible;
-		}
-	};
-}
-/** Forks one client loader into the current scope, joined to its candidate's server result. */
-function startClientLoader(provideClientFn, input) {
-	const confirmed = Deferred.await(input.confirmation);
-	const context = {
-		trigger: input.trigger,
-		href: input.href,
-		historyState: input.historyState,
-		pattern: input.match.pattern,
-		params: input.match.params,
-		splatValues: input.match.splatValues,
-		input: input.match.input,
-		knownRouteMatches: input.known,
-		serverConfirmedRouteMatches: Effect.map(confirmed, (routes) => routes.map(toKnownMatch)),
-		loaderData: Effect.flatMap(confirmed, (c) => {
-			const route = c.find((route) => route.pattern === input.match.pattern);
-			return route === void 0 ? Effect.interrupt : Effect.succeed(route.loaderData);
-		}),
-		getLoaderData: (pattern) => {
-			return Effect.map(confirmed, (c) => {
-				return Option.map(Option.fromNullishOr(c.find((route) => route.pattern === pattern)), (route) => route.loaderData);
-			});
-		}
-	};
-	return Effect.map(Effect.forkScoped(input.activation === void 0 ? provideClientFn(Effect.suspend(() => input.clientLoader(context))) : Effect.provide(Effect.suspend(() => input.clientLoader(context)), input.activation.client)), (fiber) => {
-		return {
-			pattern: input.match.pattern,
-			fiber
-		};
-	});
-}
-/**
-* Collects loader outcomes and reports the earliest failure in route order.
-* The preparation owner observes failures and interrupts later work as soon
-* as each loader starts, including before this collection begins.
-*/
-function awaitClientLoaders(publishEventFn, running) {
-	return Effect.gen(function* () {
-		const settled = yield* Effect.forEach(running, ({ index, pattern, fiber }) => {
-			return Effect.map(Fiber.await(fiber), (exit) => {
-				return {
-					index,
-					pattern,
-					exit
-				};
-			});
-		}, { concurrency: "unbounded" });
-		const results = /* @__PURE__ */ new Map();
-		let failure = null;
-		for (const { index, pattern, exit } of settled) if (Exit.isSuccess(exit)) results.set(index, AsyncResult.success(exit.value));
-		else if (!Cause.hasInterruptsOnly(exit.cause)) {
-			results.set(index, AsyncResult.failure(exit.cause));
-			if (failure === null || index < failure.index) failure = {
-				index,
-				pattern,
-				cause: exit.cause
-			};
-		}
-		if (failure !== null) publishEventFn({
-			_tag: "FailureReported",
-			source: "clientLoader",
-			cause: failure.cause
-		});
-		return {
-			results,
-			failure
-		};
-	});
-}
-//#endregion
-//#region src/client/browser-http-client.ts
-/** Executes a framework request with native Fetch controls and its caller's scope. */
-function executeBrowserRequest(request) {
-	return Effect.gen(function* () {
-		const fetch = yield* FetchHttpClient.Fetch;
-		let followedUrl;
-		return {
-			response: yield* Effect.flatMap(HttpClient.HttpClient, (client) => HttpClient.withScope(client).execute(request)).pipe(Effect.provide(FetchHttpClient.layer), Effect.provideService(FetchHttpClient.Fetch, async (input, init) => {
-				const response = await fetch(input, init);
-				if (response.redirected) followedUrl = response.url;
-				return response;
-			})),
-			followedUrl
-		};
-	});
-}
-/** The address without the query keys that the client adds to its own route requests. */
-function stripRouteQueryKeys(url) {
-	const stripped = new URL(url);
-	stripped.searchParams.delete(HTTP_PROTOCOL.queryKeys.viewPayload);
-	stripped.searchParams.delete(HTTP_PROTOCOL.queryKeys.deployment);
-	return stripped;
-}
-/** The observed redirect destination, excluding Vorma's route query keys. */
-function findFollowedRedirect(followedUrl, requested) {
-	if (followedUrl === void 0 || followedUrl === "") return null;
-	const final = stripRouteQueryKeys(new URL(followedUrl));
-	return final.href === stripRouteQueryKeys(requested).href ? null : final.href;
-}
-//#endregion
-//#region src/client/services.ts
-/** The activation a route-local computation runs under; a mutation holds it until settlement. */
-const CurrentActivation = Context.Service("vorma/client/CurrentActivation");
-function declaresServices(view) {
-	return view.clientOnlyServices !== void 0 || view.universalServices !== void 0;
-}
-/** Builds the activation map in the application scope. */
-function createActivationMap(getApplicationContextsFn) {
-	return RcMap.make({ lookup: (key) => {
-		return Effect.gen(function* () {
-			const scope = yield* Effect.scope;
-			const contexts = getApplicationContextsFn();
-			if (Option.isNone(contexts)) return yield* Effect.fail(CLIENT_UNAVAILABLE_ERROR);
-			const application = contexts.value;
-			const memoMap = yield* Layer.makeMemoMap;
-			const universalServices = key.view.universalServices === void 0 ? Layer.empty : key.view.universalServices;
-			const universal = yield* Layer.buildWithMemoMap(Layer.provide(universalServices, Layer.succeedContext(application.universal)), memoMap, scope);
-			const universalContext = Context.merge(application.universal, universal);
-			const clientOnlyServices = key.view.clientOnlyServices === void 0 ? Layer.empty : key.view.clientOnlyServices;
-			const client = yield* Layer.buildWithMemoMap(Layer.provide(clientOnlyServices, Layer.succeedContext(Context.merge(application.client, universalContext))), memoMap, scope);
-			const clientContext = Context.add(Context.merge(Context.merge(application.client, universalContext), client), CurrentActivation, key);
-			return {
-				key,
-				client: clientContext,
-				universal: universalContext,
-				clientRuntime: Atom.runtime(Layer.succeedContext(clientContext)),
-				universalRuntime: Atom.runtime(Layer.succeedContext(universalContext))
-			};
-		});
-	} });
-}
-/**
-* Acquires every entry's activation in `scope`. A live preparation keeps its
-* hold until this scope acquires it. A cached entry contains only the key;
-* re-entry builds a new activation when no owner retains that key.
-*/
-function acquireActivations(activations, input) {
-	return Effect.forEach(input.entries, (entry) => {
-		const key = "activationKey" in entry ? entry.activationKey : entry.activation?.key;
-		if (key === void 0) return Effect.succeed("activationKey" in entry ? toAcquiredRouteEntry(entry, void 0) : entry);
-		return Effect.map(Effect.provideService(RcMap.get(activations, key), Scope.Scope, input.scope), (activation) => toAcquiredRouteEntry(entry, activation));
-	});
-}
-/** Omits acquired contexts and runtimes from a reusable entry. */
-function toCachedRouteEntry(entry) {
-	const { activation, ...data } = entry;
-	return {
-		...data,
-		activationKey: activation?.key
-	};
-}
-function toAcquiredRouteEntry(entry, activation) {
-	if ("activationKey" in entry) {
-		const { activationKey: _activationKey, ...data } = entry;
-		return {
-			...data,
-			activation
-		};
-	}
-	return {
-		...entry,
-		activation
-	};
-}
-//#endregion
-//#region src/client/endpoints.ts
-const CLIENT_BUILD_ID_HEADER = HTTP_PROTOCOL.requestHeaders.clientBuildId;
-const ACCEPTS_REDIRECT_HEADER = HTTP_PROTOCOL.requestHeaders.clientAcceptsRedirect;
-const DEPLOYMENT_ID_HEADER = HTTP_PROTOCOL.requestHeaders.vercelDeploymentId;
-const SERVER_BUILD_ID_HEADER = HTTP_PROTOCOL.responseHeaders.clientBuildId;
-const BUILD_SKEW_HEADER = HTTP_PROTOCOL.responseHeaders.buildSkew;
-const REDIRECT_HEADER = HTTP_PROTOCOL.responseHeaders.clientRedirect;
-const REDIRECT_STATUS_HEADER = HTTP_PROTOCOL.responseHeaders.clientRedirectStatus;
-const makeOperationId = Brand.nominal();
-function classifyRedirectTarget(target) {
-	const parsed = Result.try(() => new URL(target));
-	if (Result.isFailure(parsed)) return { kind: "invalid" };
-	const url = parsed.success;
-	if (url.protocol !== "http:" && url.protocol !== "https:") return { kind: "invalid" };
-	return url.origin === window.location.origin ? {
-		kind: "navigate",
-		url
-	} : {
-		kind: "document",
-		href: url.href
-	};
-}
-function createEndpointOperations(core, dependencies) {
-	/** The unfinished call per dedupe key; a later call with the key completes the earlier call's cancellation. */
-	const unfinishedByDedupeKey = /* @__PURE__ */ new Map();
-	/** Claims a dedupe key for this call, cancelling the earlier unfinished call that held it. */
-	function claimDedupeKey(key) {
-		const earlier = unfinishedByDedupeKey.get(key);
-		if (earlier !== void 0) Deferred.doneUnsafe(earlier, Effect.void);
-		const cancellation = Deferred.makeUnsafe();
-		unfinishedByDedupeKey.set(key, cancellation);
-		return cancellation;
-	}
-	function releaseDedupeKey(key, cancellation) {
-		if (unfinishedByDedupeKey.get(key) === cancellation) unfinishedByDedupeKey.delete(key);
-	}
-	/** Runs `work` unless the call's dedupe key is claimed by a later call first. */
-	function runUnlessCancelled(input, operationId, cancellation, work) {
-		if (cancellation === void 0 || input.dedupeKey === void 0) return work;
-		const dedupeKey = input.dedupeKey;
-		return Effect.raceFirst(work, Effect.andThen(Deferred.await(cancellation), Effect.fail(new CancelledByDedupeKeyError({
-			...makeBoundary(input, operationId),
-			dedupeKey
-		}))));
-	}
-	function trackOperation(operation) {
-		core.updateState((state) => {
-			return {
-				...state,
-				operations: new Map(state.operations).set(operation.operationId, operation)
-			};
-		});
-	}
-	function settleOperation(operation, outcome) {
-		const settled = {
-			...operation,
-			phase: "settled"
-		};
-		core.publishEvent({
-			_tag: "OperationSettled",
-			operation: settled,
-			outcome
-		});
-		trackOperation(settled);
-		core.updateState((state) => {
-			const operations = new Map(state.operations);
-			operations.delete(operation.operationId);
-			return {
-				...state,
-				operations
-			};
-		});
-	}
-	function makeBoundary(input, operationId) {
-		return {
-			method: input.method,
-			pattern: input.pattern,
-			operationId
-		};
-	}
-	function prepareRequest(input, operationId, kind) {
-		const boundary = makeBoundary(input, operationId);
-		return Effect.gen(function* () {
-			const isRead = input.method === "GET";
-			let search;
-			let formData;
-			let json;
-			if (input.input instanceof FormData) {
-				if (isRead) {
-					const params = new URLSearchParams();
-					for (const [name, value] of input.input) {
-						if (typeof value !== "string") return yield* new InputError({
-							...boundary,
-							message: `File field ${JSON.stringify(name)} cannot be encoded in a GET query`
-						});
-						params.append(name, encodeScalar(value));
-					}
-					search = params.toString();
-				} else formData = input.input;
-			} else if (input.input !== void 0 && isRead) {
-				const serialized = serializeSearchParams({
-					value: input.input,
-					typeEntries: CLIENT_TRANSPORT_TYPE_ENTRIES
-				});
-				if (Result.isFailure(serialized)) return yield* new InputError({
-					...boundary,
-					message: "Endpoint input cannot be serialized as search",
-					cause: serialized.failure
-				});
-				search = serialized.success;
-			} else if (input.input !== void 0) {
-				const transported = encodeTransportedValue({
-					value: input.input,
-					typeEntries: CLIENT_TRANSPORT_TYPE_ENTRIES
-				});
-				if (Result.isFailure(transported)) return yield* new InputError({
-					...boundary,
-					message: "Endpoint input cannot be transported",
-					cause: transported.failure
-				});
-				json = yield* Effect.try({
-					try: () => JSON.stringify(transported.success),
-					catch: (cause) => {
-						return new InputError({
-							...boundary,
-							message: "Endpoint input is not JSON serializable",
-							cause
-						});
-					}
-				});
-			}
-			const href = buildHref({
-				kind: "endpoint",
-				pattern: input.pattern,
-				transportTypeEntries: CLIENT_TRANSPORT_TYPE_ENTRIES,
-				...input.params === void 0 ? {} : { params: input.params },
-				...input.splatValues === void 0 ? {} : { splatValues: input.splatValues },
-				...search === void 0 ? {} : { search }
-			});
-			if (Result.isFailure(href)) return yield* new InputError({
-				...boundary,
-				message: href.failure.reason,
-				cause: href.failure
-			});
-			const resolved = yield* Effect.try({
-				try: () => new URL(href.success, window.location.href),
-				catch: (cause) => {
-					return new InputError({
-						...boundary,
-						message: "Endpoint target is not a valid URL",
-						cause
-					});
-				}
-			});
-			let headers = yield* Effect.try({
-				try: () => {
-					return Headers.fromInput(input.requestOptions?.headers);
-				},
-				catch: (cause) => {
-					return new InputError({
-						...boundary,
-						message: "Endpoint request headers are invalid",
-						cause
-					});
-				}
-			});
-			headers = Headers.set(headers, "accept", "application/json");
-			headers = Headers.set(headers, CLIENT_BUILD_ID_HEADER, core.getClientBuildId());
-			headers = Headers.set(headers, ACCEPTS_REDIRECT_HEADER, "1");
-			const deploymentId = core.getDeploymentId();
-			if (deploymentId !== void 0) headers = Headers.set(headers, DEPLOYMENT_ID_HEADER, deploymentId);
-			let request = HttpClientRequest.make(input.method)(resolved, { headers });
-			if (formData !== void 0) request = HttpClientRequest.setBody(request, HttpBody.formData(formData));
-			else if (json !== void 0) {
-				const contentType = headers["content-type"] === void 0 ? "application/json" : headers["content-type"];
-				request = HttpClientRequest.setBody(request, HttpBody.raw(json, { contentType }));
-			}
-			request = yield* core.prepareRequest({
-				request,
-				requestKind: kind,
-				operationId: Option.some(operationId)
-			}).pipe(Effect.mapError((cause) => {
-				return new TransportError({
-					...boundary,
-					message: "Endpoint request preparation failed",
-					cause
-				});
-			}));
-			return {
-				href: resolved.href,
-				request
-			};
-		});
-	}
-	function readErrorEnvelope(response, input, operationId) {
-		const boundary = makeBoundary(input, operationId);
-		return Effect.gen(function* () {
-			const json = yield* response.json.pipe(Effect.mapError((cause) => {
-				return new TransportError({
-					...boundary,
-					message: "Endpoint error response is not valid JSON",
-					cause,
-					status: response.status
-				});
-			}));
-			const envelope = readEndpointErrorEnvelope(json);
-			if (Result.isFailure(envelope) || envelope.success.error.status !== response.status) return yield* new TransportError({
-				...boundary,
-				message: "Endpoint error response does not satisfy the Vorma protocol",
-				cause: Result.isFailure(envelope) ? envelope.failure : json,
-				status: response.status
-			});
-			const domain = envelope.success.domain;
-			if (domain === void 0) return yield* new HandlerError({
-				...boundary,
-				status: response.status,
-				clientMessage: envelope.success.error.client_message
-			});
-			const revived = decodeTransportedValue({
-				transported: domain.data,
-				typeEntries: CLIENT_TRANSPORT_TYPE_ENTRIES
-			});
-			if (Result.isFailure(revived)) return yield* new TransportError({
-				...boundary,
-				message: "Endpoint error data does not satisfy the Vorma protocol",
-				cause: revived.failure,
-				status: response.status
-			});
-			return yield* Effect.fail(revived.success);
-		});
-	}
-	/** A success body is the handler's output transported by value; the marks restore it. */
-	function readSuccessBody(response, input, operationId) {
-		const boundary = makeBoundary(input, operationId);
-		if (!response.headers["content-type"]?.toLowerCase().includes("json")) return Effect.fail(new TransportError({
-			...boundary,
-			message: "Endpoint success response is not JSON",
-			cause: response.headers["content-type"],
-			status: response.status
-		}));
-		return Effect.gen(function* () {
-			const json = yield* response.json.pipe(Effect.mapError((cause) => {
-				return new TransportError({
-					...boundary,
-					message: "Endpoint success response is not valid JSON",
-					cause,
-					status: response.status
-				});
-			}));
-			const transported = readTransportedValue(json);
-			const revived = Result.flatMap(transported, (value) => {
-				return decodeTransportedValue({
-					transported: value,
-					typeEntries: CLIENT_TRANSPORT_TYPE_ENTRIES
-				});
-			});
-			if (Result.isFailure(revived)) return yield* new TransportError({
-				...boundary,
-				message: "Endpoint success response does not satisfy the Vorma protocol",
-				cause: revived.failure,
-				status: response.status
-			});
-			return revived.success;
-		});
-	}
-	function dispatchEndpointRequest(input, operationId, kind, prepared) {
-		const boundary = makeBoundary(input, operationId);
-		return Effect.gen(function* () {
-			const requestOptions = input.requestOptions;
-			const { response, followedUrl } = yield* core.provideClient(Effect.suspend(() => {
-				const execution = executeBrowserRequest(prepared.request);
-				return requestOptions === void 0 ? execution : execution.pipe(Effect.updateContext((context) => {
-					return Context.add(context, FetchHttpClient.RequestInit, {
-						...Context.getOrUndefined(context, FetchHttpClient.RequestInit),
-						...requestOptions
-					});
-				}));
-			})).pipe(Effect.mapError((cause) => {
-				return new TransportError({
-					...boundary,
-					message: "Endpoint request failed",
-					cause
-				});
-			}));
-			const followed = findFollowedRedirect(followedUrl, new URL(prepared.href));
-			if (followed !== null) return {
-				response,
-				followed
-			};
-			const serverBuildId = response.headers[SERVER_BUILD_ID_HEADER];
-			const mismatch = {
-				clientBuildId: core.getClientBuildId(),
-				serverBuildId,
-				requestedHref: prepared.href,
-				requestKind: kind,
-				status: response.status
-			};
-			if (response.headers[BUILD_SKEW_HEADER] === "1") {
-				core.reportBuildMismatch(mismatch);
-				dependencies.retireReusableFn();
-				return yield* new BuildMismatchError({
-					...boundary,
-					message: "Endpoint request was refused by another build"
-				});
-			}
-			if (serverBuildId === void 0) return yield* new TransportError({
-				...boundary,
-				message: "Endpoint response is missing its Vorma build identity",
-				cause: response.headers,
-				status: response.status
-			});
-			if (serverBuildId !== core.getClientBuildId()) core.reportBuildMismatch(mismatch);
-			return {
-				response,
-				followed: null
-			};
-		});
-	}
-	function classifyEndpointResponse(dispatched, input, operationId) {
-		const { response } = dispatched;
-		const boundary = makeBoundary(input, operationId);
-		const responseMetadata = {
-			status: response.status,
-			headers: response.headers
-		};
-		return Effect.gen(function* () {
-			if (dispatched.followed !== null) {
-				const disposition = classifyRedirectTarget(dispatched.followed);
-				if (disposition.kind === "invalid") return yield* new TransportError({
-					...boundary,
-					message: "Endpoint redirect target must be an HTTP or HTTPS URL",
-					cause: dispatched.followed,
-					status: response.status
-				});
-				return {
-					_tag: "Redirected",
-					redirectUrl: dispatched.followed,
-					redirectStatus: void 0,
-					responseMetadata,
-					disposition
-				};
-			}
-			const redirect = response.headers[REDIRECT_HEADER];
-			if (redirect !== void 0) {
-				const redirectStatus = readRedirectStatus(Number(response.headers[REDIRECT_STATUS_HEADER]));
-				if (Result.isFailure(redirectStatus)) return yield* new TransportError({
-					...boundary,
-					message: "Endpoint redirect is missing a valid intended HTTP status",
-					cause: redirectStatus.failure,
-					status: response.status
-				});
-				const target = Result.try(() => new URL(redirect, response.request.url).href);
-				const disposition = Result.isFailure(target) ? { kind: "invalid" } : classifyRedirectTarget(target.success);
-				if (disposition.kind === "invalid") return yield* new TransportError({
-					...boundary,
-					message: "Endpoint redirect target must be an HTTP or HTTPS URL",
-					cause: redirect,
-					status: response.status
-				});
-				return {
-					_tag: "Redirected",
-					redirectUrl: disposition.kind === "document" ? disposition.href : disposition.url.href,
-					redirectStatus: redirectStatus.success,
-					responseMetadata,
-					disposition
-				};
-			}
-			if (response.status < 200 || response.status >= 300) return yield* readErrorEnvelope(response, input, operationId);
-			return {
-				_tag: "Completed",
-				data: yield* readSuccessBody(response, input, operationId),
-				responseMetadata
-			};
-		});
-	}
-	/** Executes one query. Observer-owned; registers no freshness demand. */
-	function runEndpointQuery(input, reportDispatchFn) {
-		return Effect.gen(function* () {
-			const operationId = makeOperationId(crypto.randomUUID());
-			const operation = {
-				operationId,
-				kind: "Query",
-				request: {
-					method: input.method,
-					pattern: input.pattern,
-					href: Option.none()
-				},
-				phase: "preparing",
-				skipWorkIndicator: input.skipWorkIndicator === true,
-				skipAutoRevalidate: false
-			};
-			let current = operation;
-			trackOperation(operation);
-			const cancellation = input.dedupeKey === void 0 ? void 0 : claimDedupeKey(input.dedupeKey);
-			return yield* Effect.gen(function* () {
-				const prepared = yield* prepareRequest(input, operationId, "Query");
-				current = {
-					...operation,
-					phase: "dispatched",
-					request: {
-						...operation.request,
-						href: Option.some(prepared.href)
-					}
-				};
-				trackOperation(current);
-				reportDispatchFn?.({
-					sequence: core.advanceSequence(),
-					generation: core.getState().generation
-				});
-				const retirement = core.getGenerationRetirement();
-				const classified = yield* runUnlessCancelled(input, operationId, cancellation, Effect.raceFirst(Effect.flatMap(dispatchEndpointRequest(input, operationId, "Query", prepared), (dispatched) => {
-					return classifyEndpointResponse(dispatched, input, operationId);
-				}), Effect.andThen(Deferred.await(retirement), Effect.interrupt)));
-				if (classified._tag === "Redirected") {
-					const navigation = startRedirect(classified);
-					return yield* new QueryRedirected({
-						...makeBoundary(input, operationId),
-						redirectUrl: classified.redirectUrl,
-						redirectStatus: classified.redirectStatus,
-						navigation
-					});
-				}
-				return {
-					data: classified.data,
-					responseMetadata: classified.responseMetadata
-				};
-			}).pipe(Effect.scoped, Effect.onExit((outcome) => {
-				return Effect.sync(() => {
-					if (cancellation !== void 0 && input.dedupeKey !== void 0) releaseDedupeKey(input.dedupeKey, cancellation);
-					settleOperation(current, outcome);
-				});
-			}));
-		});
-	}
-	/** Starts the navigation a redirect requires and returns its observation. */
-	function startRedirect(classified) {
-		if (classified.disposition.kind === "document") {
-			dependencies.navigateDocumentFn(classified.redirectUrl);
-			return Effect.succeed({
-				_tag: "DocumentNavigation",
-				href: classified.redirectUrl
-			});
-		}
-		return dependencies.redirectFn(classified.disposition.url);
-	}
-	/** Executes one mutation with native caller interruption and a scoped activation hold. */
-	function runEndpointMutation(input) {
-		return Effect.gen(function* () {
-			const operationId = makeOperationId(crypto.randomUUID());
-			const skipAutoRevalidate = input.skipAutoRevalidate === true;
-			const skipWorkIndicator = input.skipWorkIndicator === true;
-			const operation = {
-				operationId,
-				kind: "Mutation",
-				request: {
-					method: input.method,
-					pattern: input.pattern,
-					href: Option.none()
-				},
-				phase: "preparing",
-				skipWorkIndicator,
-				skipAutoRevalidate
-			};
-			trackOperation(operation);
-			const cancellation = input.dedupeKey === void 0 ? void 0 : claimDedupeKey(input.dedupeKey);
-			const prepared = yield* prepareRequest(input, operationId, "Mutation").pipe(Effect.onError((cause) => {
-				return Effect.sync(() => {
-					if (cancellation !== void 0 && input.dedupeKey !== void 0) releaseDedupeKey(input.dedupeKey, cancellation);
-					settleOperation(operation, Exit.failCause(cause));
-				});
-			}));
-			const dispatched = {
-				...operation,
-				phase: "dispatched",
-				request: {
-					...operation.request,
-					href: Option.some(prepared.href)
-				}
-			};
-			const activation = yield* Effect.serviceOption(CurrentActivation);
-			let revalidation;
-			function scheduleRefresh() {
-				if (revalidation !== void 0) return revalidation;
-				revalidation = skipAutoRevalidate ? Effect.succeed({ _tag: "Skipped" }) : dependencies.requireRefreshFn({ skipWorkIndicator });
-				return revalidation;
-			}
-			function makeOwned(scope) {
-				return Effect.gen(function* () {
-					trackOperation(dispatched);
-					const classified = yield* runUnlessCancelled(input, operationId, cancellation, Effect.flatMap(dispatchEndpointRequest(input, operationId, "Mutation", prepared), (sent) => {
-						return classifyEndpointResponse(sent, input, operationId);
-					}));
-					if (classified._tag === "Redirected") {
-						if (classified.disposition.kind === "document") {
-							dependencies.navigateDocumentFn(classified.redirectUrl);
-							revalidation = Effect.succeed({
-								_tag: "DocumentNavigation",
-								href: classified.redirectUrl
-							});
-							return {
-								_tag: "Redirected",
-								operationId,
-								redirectUrl: classified.redirectUrl,
-								redirectStatus: classified.redirectStatus,
-								responseMetadata: classified.responseMetadata,
-								revalidation
-							};
-						}
-						const refresh = scheduleRefresh();
-						revalidation = dependencies.redirectFn(classified.disposition.url).pipe(Effect.matchEffect({
-							onFailure: (error) => {
-								return Effect.fail(new RevalidationError({
-									reason: "route",
-									cause: Cause.fail(error)
-								}));
-							},
-							onSuccess: (result) => {
-								switch (result._tag) {
-									case "DocumentNavigation": return Effect.succeed(result);
-									case "Superseded": return Effect.fail(new RevalidationError({
-										reason: "superseded",
-										cause: Cause.fail(result)
-									}));
-									default: return refresh;
-								}
-							}
-						}));
-						return {
-							_tag: "Redirected",
-							operationId,
-							redirectUrl: classified.redirectUrl,
-							redirectStatus: classified.redirectStatus,
-							responseMetadata: classified.responseMetadata,
-							revalidation
-						};
-					}
-					return {
-						_tag: "Completed",
-						operationId,
-						data: classified.data,
-						responseMetadata: classified.responseMetadata,
-						revalidation: scheduleRefresh()
-					};
-				}).pipe(Scope.provide(scope), Effect.onExit((outcome) => {
-					return Effect.andThen(Scope.close(scope, outcome), Effect.sync(() => {
-						const refused = Exit.isFailure(outcome) && Option.exists(Cause.findErrorOption(outcome.cause), (error) => error instanceof BuildMismatchError);
-						if (!Exit.isSuccess(outcome) && !refused) scheduleRefresh();
-						if (cancellation !== void 0 && input.dedupeKey !== void 0) releaseDedupeKey(input.dedupeKey, cancellation);
-						settleOperation(dispatched, outcome);
-					}));
-				}));
-			}
-			return yield* Effect.uninterruptibleMask((restore) => {
-				return Effect.gen(function* () {
-					const scope = yield* Scope.make();
-					if (Option.isSome(activation)) {
-						const held = yield* Effect.exit(Scope.provide(scope)(RcMap.get(core.activations, activation.value)));
-						if (Exit.isFailure(held)) {
-							yield* Scope.close(scope, held);
-							if (cancellation !== void 0 && input.dedupeKey !== void 0) releaseDedupeKey(input.dedupeKey, cancellation);
-							settleOperation(operation, held);
-							return yield* Effect.failCause(held.cause);
-						}
-					}
-					const fiber = yield* FiberSet.run(core.mutationFibers, restore(makeOwned(scope)));
-					return yield* restore(Fiber.join(fiber)).pipe(Effect.ensuring(Fiber.interrupt(fiber)));
-				});
-			});
-		});
-	}
-	return {
-		query: (input) => runEndpointQuery(input, void 0),
-		read: runEndpointQuery,
-		mutate: runEndpointMutation
-	};
-}
-//#endregion
-//#region src/client/modules.ts
-/** Writes a `modulepreload` link for each module path that has none yet. */
-function preloadModules(paths) {
-	if (paths.length === 0) return;
-	const existing = new Set([...document.head.querySelectorAll("link[rel=\"modulepreload\"]")].map((link) => link.getAttribute("href")));
-	for (const path of paths) {
-		if (existing.has(path)) continue;
-		const link = document.createElement("link");
-		link.rel = "modulepreload";
-		link.href = path;
-		document.head.appendChild(link);
-		existing.add(path);
-	}
-}
-//#endregion
-//#region src/client/payload.ts
-function readRoute$1(input) {
-	const { record } = input;
-	function failField(field, cause) {
-		return Result.fail({
-			_tag: "PayloadReadError",
-			pattern: record.pattern,
-			field,
-			cause
-		});
-	}
-	let searchInput;
-	if (record.search_input !== void 0) {
-		const revived = decodeTransportedValue({
-			transported: record.search_input,
-			typeEntries: CLIENT_TRANSPORT_TYPE_ENTRIES
-		});
-		if (Result.isFailure(revived)) return failField("search_input", revived.failure);
-		searchInput = revived.success;
-	}
-	let loaderData;
-	if ("loader_data" in record) {
-		const transported = record.loader_data;
-		if (transported === null || transported === void 0) loaderData = null;
-		else {
-			const revived = decodeTransportedValue({
-				transported,
-				typeEntries: CLIENT_TRANSPORT_TYPE_ENTRIES
-			});
-			if (Result.isFailure(revived)) return failField("loader_data", revived.failure);
-			loaderData = revived.success;
-		}
-	}
-	return Result.succeed({
-		pattern: record.pattern,
-		params: record.params ?? {},
-		splatValues: record.splat_values ?? [],
-		compiledPattern: {
-			kind: "nested",
-			pattern: record.compiled_pattern.pattern ?? record.pattern,
-			segments: record.compiled_pattern.segments
-		},
-		searchContract: record.search_contract ?? null,
-		searchInput,
-		moduleReference: typeof record.import_url === "string" ? {
-			url: record.import_url,
-			exportNames: record.export_names
-		} : null,
-		loaderData
-	});
-}
-function readRoutes(wire) {
-	const serverError = wire.server_error;
-	const routes = [];
-	for (const record of wire.routes) {
-		const route = readRoute$1({ record });
-		if (Result.isFailure(route)) return Result.fail(route.failure);
-		routes.push(route.success);
-	}
-	return Result.succeed({
-		routes,
-		serverError: serverError === void 0 ? void 0 : {
-			index: serverError.index,
-			status: serverError.status,
-			clientMessage: serverError.client_message
-		}
-	});
-}
-function readNavigation(wire) {
-	return Result.map(readRoutes(wire), (routePayload) => {
-		return {
-			...routePayload,
-			head: {
-				title: wire.head.title,
-				meta: wire.head.meta ?? [],
-				rest: wire.head.rest ?? []
-			},
-			deps: wire.deps ?? [],
-			cssBundles: wire.css_bundles ?? [],
-			staticAssets: wire.static_assets ?? []
-		};
-	});
-}
-/** Reads a navigation payload this build's server wrote. */
-function readPayload(raw) {
-	return readNavigation(raw);
-}
-/** Reads the initial document payload, including build identity. */
-function readBootstrapPayload(raw) {
-	const wire = raw;
-	return Result.map(readRoutes(wire), (routePayload) => {
-		return {
-			clientBuildId: wire.client_build_id,
-			developmentMode: wire.is_dev === true,
-			deploymentId: wire.deployment_id,
-			...routePayload
-		};
-	});
-}
-//#endregion
-//#region src/client/static-assets.ts
-const preloads = /* @__PURE__ */ new WeakMap();
-const ATTRIBUTE = DOCUMENT_PROTOCOL.attributes.staticAsset;
-/** Adds shared, scoped resource hints without awaiting resource loading. */
-function preloadStaticAssets(urls) {
-	return Effect.gen(function* () {
-		for (const url of new Set(urls)) yield* Effect.acquireRelease(Effect.sync(() => {
-			const existing = [...document.head.querySelectorAll("link")].find((link) => link.getAttribute(ATTRIBUTE) === url);
-			let preload = existing === void 0 ? void 0 : preloads.get(existing);
-			if (existing !== void 0 && preload === void 0) return;
-			if (preload === void 0) {
-				const destination = getStaticAssetDestination(url);
-				const link = document.createElement("link");
-				link.rel = "preload";
-				link.as = destination;
-				if (destination !== "image") link.crossOrigin = "anonymous";
-				link.href = url;
-				link.setAttribute(ATTRIBUTE, url);
-				preload = {
-					link,
-					owners: 0
-				};
-				preloads.set(link, preload);
-				document.head.append(link);
-			}
-			preload.owners += 1;
-			return preload;
-		}), (retained) => {
-			return Effect.sync(() => {
-				if (retained === void 0) return;
-				retained.owners -= 1;
-				if (retained.owners === 0) retained.link.remove();
-			});
-		});
-	});
-}
-//#endregion
-//#region src/client/prepare.ts
-function failAt$1(stage, cause) {
-	return new NavigationError({
-		stage,
-		cause: Cause.isCause(cause) ? cause : Cause.fail(cause)
-	});
-}
-function readRoute(core, source) {
-	return Effect.gen(function* () {
-		const requestUrl = new URL(source.url);
-		requestUrl.hash = "";
-		const clientBuildId = core.getClientBuildId();
-		requestUrl.searchParams.set(HTTP_PROTOCOL.queryKeys.viewPayload, clientBuildId);
-		const deploymentId = core.getDeploymentId();
-		if (source.requestKind === "Revalidation" && deploymentId !== void 0) requestUrl.searchParams.set(HTTP_PROTOCOL.queryKeys.deployment, deploymentId);
-		const request = HttpClientRequest.get(requestUrl.href).pipe(HttpClientRequest.setHeaders({
-			accept: "application/json",
-			[HTTP_PROTOCOL.requestHeaders.clientAcceptsRedirect]: "1"
-		}));
-		const { response, followedUrl } = yield* Effect.flatMap(core.prepareRequest({
-			request,
-			requestKind: source.requestKind,
-			operationId: Option.none()
-		}), (preparedRequest) => {
-			return core.provideClient(executeBrowserRequest(preparedRequest));
-		}).pipe(Effect.mapError((cause) => failAt$1("request", cause)));
-		const followed = findFollowedRedirect(followedUrl, requestUrl);
-		if (followed !== null) return {
-			_tag: "Redirect",
-			href: followed
-		};
-		const serverBuildId = response.headers[HTTP_PROTOCOL.responseHeaders.clientBuildId];
-		if (response.headers[HTTP_PROTOCOL.responseHeaders.buildSkew] !== void 0) return {
-			_tag: "BuildSkew",
-			mismatch: {
-				clientBuildId,
-				serverBuildId,
-				requestedHref: source.url.href,
-				requestKind: source.requestKind,
-				status: response.status
-			}
-		};
-		const redirect = response.headers[HTTP_PROTOCOL.responseHeaders.clientRedirect];
-		if (redirect !== void 0) return {
-			_tag: "Redirect",
-			href: redirect
-		};
-		const contentType = response.headers["content-type"];
-		if (contentType === void 0 || !contentType.startsWith("application/json")) return yield* failAt$1("request", {
-			status: response.status,
-			contentType
-		});
-		return {
-			_tag: "Payload",
-			raw: yield* Effect.mapError(response.json, (cause) => {
-				return failAt$1("request", {
-					status: response.status,
-					cause
-				});
-			}),
-			status: response.status,
-			serverBuildId
-		};
-	});
-}
-/** Prepares one destination. Known client loaders start before the read settles when `prestart` is set. */
-function prepareRoute(core, input) {
-	const url = input.source.url;
-	let announced = false;
-	function announceReadiness(exit) {
-		if (input.reportReadinessFn !== void 0 && !announced) {
-			announced = true;
-			input.reportReadinessFn(exit);
-		}
-	}
-	const program = Effect.gen(function* () {
-		const sequence = core.advanceSequence();
-		const generation = core.getState().generation;
-		const confirmation = Deferred.makeUnsafe();
-		const positionsByPattern = /* @__PURE__ */ new Map();
-		let failureBoundary = Infinity;
-		const scope = yield* Effect.scope;
-		const committed = core.getState().frame;
-		function getRunningLoaders() {
-			const running = [];
-			for (const position of positionsByPattern.values()) if (position.loader !== void 0 && position.confirmation !== "rejected") running.push({
-				index: position.index,
-				pattern: position.match.pattern,
-				fiber: position.loader
-			});
-			return running;
-		}
-		function canRunLoader(position) {
-			return position.confirmation !== "rejected" && position.index <= failureBoundary;
-		}
-		/** One position acquires its services once and retains all of its preparation work. */
-		function startPreparationPosition(inputPosition) {
-			return Effect.gen(function* () {
-				const { index, match, known, view } = inputPosition;
-				const work = {
-					index,
-					match,
-					confirmation: inputPosition.confirmation,
-					loader: void 0
-				};
-				const preparation = yield* Effect.forkIn(Effect.gen(function* () {
-					let activation;
-					if (view !== void 0 && declaresServices(view)) {
-						const retained = committed?.entries[index];
-						const key = retained?.pattern === match.pattern && retained.activation !== void 0 ? retained.activation.key : {
-							pattern: match.pattern,
-							view
-						};
-						activation = yield* RcMap.get(core.activations, key).pipe(Effect.provideService(Scope.Scope, scope), Effect.mapError((cause) => failAt$1("assets", cause)));
-					}
-					if (!canRunLoader(work) || view?.clientLoader === void 0) return activation;
-					const started = yield* startClientLoader(core.provideClient, {
-						clientLoader: view.clientLoader,
-						trigger: input.trigger,
-						href: url.href,
-						historyState: input.historyState,
-						match,
-						known,
-						confirmation,
-						activation
-					}).pipe(Effect.provideService(Scope.Scope, scope));
-					work.loader = started.fiber;
-					if (!canRunLoader(work)) {
-						yield* Fiber.interrupt(started.fiber);
-						work.loader = void 0;
-						return activation;
-					}
-					yield* Effect.forkIn(Effect.flatMap(Fiber.await(started.fiber), (exit) => {
-						if (Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause) || work.confirmation === "rejected") return Effect.void;
-						failureBoundary = Math.min(failureBoundary, index);
-						return Fiber.interruptAll(getRunningLoaders().filter((other) => {
-							return other.index > failureBoundary;
-						}).map((other) => other.fiber));
-					}), scope);
-					return activation;
-				}), scope);
-				const position = Object.assign(work, { preparation });
-				positionsByPattern.set(match.pattern, position);
-				if (!canRunLoader(position)) position.loader?.interruptUnsafe();
-				return position;
-			});
-		}
-		let payload;
-		if (input.source.kind === "payload") payload = input.source.payload;
-		else {
-			const reading = yield* Effect.forkScoped(Effect.scoped(readRoute(core, input.source)));
-			if (input.prestart) {
-				const eligible = core.clientLoaders.findEligibleMatches(url);
-				const known = eligible.map((entry) => entry.match);
-				for (const [index, { match, view }] of eligible.entries()) if (view?.clientLoader !== void 0) yield* startPreparationPosition({
-					index,
-					match,
-					known,
-					view,
-					confirmation: "pending"
-				});
-			}
-			const response = yield* Fiber.join(reading);
-			if (response._tag !== "Payload") return response;
-			if (response.serverBuildId !== void 0 && response.serverBuildId !== core.getClientBuildId()) core.reportBuildMismatch({
-				clientBuildId: core.getClientBuildId(),
-				serverBuildId: response.serverBuildId,
-				requestedHref: url.href,
-				requestKind: input.source.requestKind,
-				status: response.status
-			});
-			const read = readPayload(response.raw);
-			if (Result.isFailure(read)) return yield* failAt$1("request", read.failure);
-			payload = read.success;
-		}
-		const stylesheetReadiness = yield* Effect.forkIn(prepareStylesheets(payload.cssBundles).pipe(Effect.provideService(Scope.Scope, scope)), scope);
-		yield* preloadStaticAssets(payload.staticAssets).pipe(Effect.provideService(Scope.Scope, scope));
-		if (!core.runsInDevelopmentMode()) preloadModules(payload.deps);
-		const matches = payload.routes.map(toKnownMatch);
-		for (const [pattern, position] of positionsByPattern) if (matches[position.index]?.pattern === pattern) position.confirmation = "confirmed";
-		else {
-			position.confirmation = "rejected";
-			position.preparation.interruptUnsafe();
-			position.loader?.interruptUnsafe();
-			positionsByPattern.delete(pattern);
-		}
-		Deferred.doneUnsafe(confirmation, Effect.succeed(payload.routes));
-		failureBoundary = Infinity;
-		for (const active of getRunningLoaders()) {
-			const exit = active.fiber.pollUnsafe();
-			if (exit !== void 0 && Exit.isFailure(exit) && !Cause.hasInterruptsOnly(exit.cause)) failureBoundary = Math.min(failureBoundary, active.index);
-		}
-		const positions = yield* Effect.forEach(payload.routes, (decoded, index) => {
-			return Effect.gen(function* () {
-				const route = yield* materializeRoute(decoded).pipe(Effect.mapError((cause) => failAt$1("assets", cause)));
-				const position = positionsByPattern.get(route.pattern) ?? (yield* startPreparationPosition({
-					index,
-					match: toKnownMatch(route),
-					known: matches,
-					view: route.definition,
-					confirmation: "confirmed"
-				}));
-				return {
-					route,
-					activation: yield* Fiber.join(position.preparation)
-				};
-			});
-		}, { concurrency: "unbounded" });
-		const routes = positions.map((position) => position.route);
-		core.clientLoaders.recordConfirmedChain({
-			url,
-			routes
-		});
-		announceReadiness(Exit.void);
-		const [clientLoaderOutcome] = yield* Effect.all([awaitClientLoaders(core.publishEvent, getRunningLoaders()), Fiber.join(stylesheetReadiness)], { concurrency: "unbounded" });
-		const entries = positions.map(({ route, activation }, index) => {
-			const settled = clientLoaderOutcome.results.get(index);
-			return {
-				pattern: route.pattern,
-				params: route.params,
-				splatValues: route.splatValues,
-				input: route.searchInput,
-				view: route.definition,
-				loaderData: route.loaderData,
-				clientLoaderData: settled === void 0 ? AsyncResult.initial() : settled,
-				activation
-			};
-		});
-		return {
-			_tag: "Prepared",
-			prepared: {
-				url,
-				entries,
-				error: selectRouteError(payload.serverError, clientLoaderOutcome.failure),
-				head: payload.head,
-				cssBundles: payload.cssBundles,
-				sequence,
-				generation
-			}
-		};
-	});
-	return input.reportReadinessFn === void 0 ? program : Effect.onExit(program, (exit) => {
-		return Effect.sync(() => {
-			if (Exit.isFailure(exit)) announceReadiness(Exit.failCause(exit.cause));
-			else if (exit.value._tag !== "Prepared") announceReadiness(Exit.fail(failAt$1(exit.value._tag === "Redirect" ? "target" : "request", exit.value)));
-		});
-	});
-}
-/** The route error a prepared route carries: the earliest client loader failure, else the failed server loader. */
-function selectRouteError(serverError, clientLoaderFailure) {
-	if (clientLoaderFailure !== null) return {
-		index: clientLoaderFailure.index,
-		pattern: clientLoaderFailure.pattern,
-		source: "clientLoader",
-		error: clientLoaderFailure.cause
-	};
-	if (serverError === void 0) return null;
-	return {
-		index: serverError.index,
-		pattern: void 0,
-		source: "serverLoader",
-		error: {
-			status: serverError.status,
-			clientMessage: serverError.clientMessage
-		}
-	};
-}
-//#endregion
-//#region src/client/prefetch.ts
-/** The part of an address a preparation serves: its path and query. */
-function readDestination(url) {
-	return url.pathname + url.search;
-}
-function createPrefetch(core) {
-	const entries = /* @__PURE__ */ new Map();
-	function clearPending(entry) {
-		if (entries.get(entry.destination) === entry) core.updateState((state) => {
-			const prefetch = new Map(state.prefetch);
-			prefetch.delete(entry.destination);
-			return {
-				...state,
-				prefetch
-			};
-		});
-	}
-	function stopPreparation(entry) {
-		entry.fiber?.interruptUnsafe();
-		core.forkFiber(Scope.close(entry.scope, Exit.void));
-	}
-	function retireEntry(entry) {
-		Deferred.doneUnsafe(entry.observation, Effect.fail(new PrefetchError({ reason: "superseded" })));
-		clearPending(entry);
-		if (entries.get(entry.destination) === entry) entries.delete(entry.destination);
-		stopPreparation(entry);
-	}
-	function settlePreparation(entry, exit) {
-		if (Exit.isSuccess(exit)) {
-			Deferred.doneUnsafe(entry.result, Effect.succeed(exit.value));
-			if (exit.value._tag === "Prepared") return;
-		} else Deferred.doneUnsafe(entry.result, Effect.failCause(exit.cause));
-		const cause = Exit.isFailure(exit) ? exit.cause : Cause.fail(new NavigationError({
-			stage: "target",
-			cause: Cause.fail(exit.value)
-		}));
-		Deferred.doneUnsafe(entry.observation, Effect.fail(new PrefetchError({
-			reason: Cause.hasInterruptsOnly(cause) ? "superseded" : "preparation",
-			cause
-		})));
-		clearPending(entry);
-		if (entries.get(entry.destination) === entry) entries.delete(entry.destination);
-		core.forkFiber(Scope.close(entry.scope, Exit.void));
-	}
-	function openPreparation(url, handle, skipWorkIndicator) {
-		const entry = {
-			destination: readDestination(url),
-			handles: /* @__PURE__ */ new Set([handle]),
-			startSequence: core.getState().sequence,
-			observation: Deferred.makeUnsafe(),
-			result: Deferred.makeUnsafe(),
-			scope: Scope.makeUnsafe(),
-			fiber: void 0,
-			keptAfterObservers: false,
-			consumed: false
-		};
-		entries.set(entry.destination, entry);
-		core.updateState((state) => {
-			return {
-				...state,
-				prefetch: new Map(state.prefetch).set(entry.destination, {
-					href: url.href,
-					skipWorkIndicator
-				})
-			};
-		});
-		entry.fiber = core.forkFiber(Effect.onExit(Effect.provideService(prepareRoute(core, {
-			source: {
-				kind: "request",
-				url,
-				requestKind: "Prefetch"
-			},
-			trigger: "prefetch",
-			historyState: void 0,
-			prestart: true,
-			reportReadinessFn: (exit) => {
-				if (Exit.isSuccess(exit)) {
-					clearPending(entry);
-					Deferred.doneUnsafe(entry.observation, Effect.void);
-				}
-			}
-		}), Scope.Scope, entry.scope), (exit) => Effect.sync(() => settlePreparation(entry, exit))));
-		return entry;
-	}
-	function acquirePreparationHandle(url, skipWorkIndicator) {
-		return Effect.suspend(() => {
-			const handle = {};
-			const destination = readDestination(url);
-			const state = core.getState();
-			const committed = state.frame === null ? null : readDestination(new URL(state.frame.href));
-			const pending = Option.map(state.navigation.pending === null ? Option.none() : Option.some(state.navigation.pending), (item) => {
-				return readDestination(new URL(item.href));
-			});
-			if (destination === committed || Option.contains(pending, destination)) return Effect.fail(new PrefetchError({ reason: "unavailable" }));
-			const existing = entries.get(destination);
-			if (existing !== void 0) {
-				existing.handles.add(handle);
-				return Effect.succeed({
-					entry: existing,
-					handle
-				});
-			}
-			for (const entry of entries.values()) if (entry.handles.size === 0) retireEntry(entry);
-			return Effect.succeed({
-				entry: openPreparation(url, handle, skipWorkIndicator),
-				handle
-			});
-		});
-	}
-	function releasePreparationHandle(entry, handle) {
-		if (!entry.handles.delete(handle)) return;
-		if (entries.get(entry.destination) !== entry) return;
-		if (entry.handles.size === 0 && entry.keptAfterObservers && !entry.consumed) {
-			for (const other of entries.values()) if (other !== entry && other.handles.size === 0) retireEntry(other);
-		}
-		if (entry.handles.size === 0 && !entry.keptAfterObservers && !entry.consumed) retireEntry(entry);
-	}
-	return {
-		awaitReadiness: (url, options) => {
-			return Effect.acquireUseRelease(acquirePreparationHandle(url, options.skipWorkIndicator), ({ entry }) => Deferred.await(entry.observation), ({ entry, handle }, exit) => {
-				return Effect.sync(() => {
-					if (Exit.isSuccess(exit)) entry.keptAfterObservers = true;
-					releasePreparationHandle(entry, handle);
-				});
-			});
-		},
-		holdUntilInterrupted: (url, options) => {
-			return Effect.acquireUseRelease(acquirePreparationHandle(url, options.skipWorkIndicator), () => Effect.never, ({ entry, handle }) => Effect.sync(() => releasePreparationHandle(entry, handle)));
-		},
-		takeForNavigation: (destination) => {
-			const entry = entries.get(destination);
-			if (entry === void 0) return null;
-			clearPending(entry);
-			entries.delete(destination);
-			entry.consumed = true;
-			entry.keptAfterObservers = false;
-			Deferred.doneUnsafe(entry.observation, Effect.fail(new PrefetchError({ reason: "takenByNavigation" })));
-			return {
-				result: Deferred.await(entry.result),
-				startSequence: entry.startSequence,
-				release: () => stopPreparation(entry)
-			};
-		},
-		retirePreparations: () => {
-			for (const entry of entries.values()) retireEntry(entry);
-		}
-	};
-}
-//#endregion
-//#region src/client/scroll.ts
-function readScrollPosition() {
-	return {
-		x: window.scrollX,
-		y: window.scrollY
-	};
-}
-function normalizeFragment(hash) {
-	const raw = hash.startsWith("#") ? hash.slice(1) : hash;
-	if (raw.length === 0) return raw;
-	return Result.getOrElse(Result.try(() => decodeURIComponent(raw)), () => raw);
-}
-/** Applies the target through the browser's scroll calls, the one platform boundary here; a failure comes back as a value. */
-function applyScroll(target) {
-	return Result.try(() => {
-		if ("hash" in target) {
-			document.getElementById(normalizeFragment(target.hash))?.scrollIntoView();
-			return;
-		}
-		window.scrollTo(target.x, target.y);
-	});
-}
-//#endregion
-//#region src/client/navigation.ts
-/** The redirect chain length fetch itself accepts. */
-const REDIRECT_LIMIT = 20;
-/** The largest delay browsers accept without reducing it to a short timeout. */
-const MAX_TIMER_DELAY_MILLIS = 2147483647;
-function failAt(stage, cause) {
-	return new NavigationError({
-		stage,
-		cause: Cause.isCause(cause) ? cause : Cause.fail(cause)
-	});
-}
-/** A failed refresh read as a revalidation failure: the server's refusal is a build mismatch, anything else a route failure. */
-function classifyRefreshFailure(error) {
-	const inner = Cause.findErrorOption(error.cause);
-	const mismatch = Option.isSome(inner) && inner.value instanceof BuildMismatchError;
-	return makeRevalidationError(mismatch ? "build-mismatch" : "route", error.cause);
-}
-/** The navigation options that carry a history entry's user state. */
-function makeHistoryStateOptions(historyState) {
-	return historyState === void 0 ? {} : { historyState };
-}
-function matchesNavigationOptions(left, right) {
-	const { historyState: leftState, ...leftOptions } = left;
-	const { historyState: rightState, ...rightOptions } = right;
-	return Object.is(leftState, rightState) && deepEquals({
-		left: leftOptions,
-		right: rightOptions
-	});
-}
-function leaveDocument(href) {
-	window.location.assign(href);
-	return {
-		_tag: "DocumentNavigation",
-		href
-	};
-}
-/** The deepest entry a scroll can wait for: the last entry, or the error position that replaces the rest. */
-function selectScrollEntryIndex(entryCount, errorIndex) {
-	if (entryCount === 0 && errorIndex !== null) return 0;
-	return errorIndex === null ? entryCount - 1 : Math.min(entryCount - 1, errorIndex);
-}
-/** Navigation follows an enabled fragment first, then a saved position, then the scroll-to-top setting. */
-function decideScrollIntent(input) {
-	const entryIndex = selectScrollEntryIndex(input.entryCount, input.errorIndex);
-	if (normalizeFragment(input.url.hash).length > 0 && input.options.scrollToFragment !== false) return {
-		target: { hash: input.url.hash },
-		entryIndex
-	};
-	if (input.restore !== void 0) return {
-		target: input.restore,
-		entryIndex
-	};
-	if (input.options.scrollToTop === false) return;
-	return {
-		target: {
-			x: 0,
-			y: 0
-		},
-		entryIndex
-	};
-}
-/** The first frame adopts the browser's entry, or gives an entry without a key one. */
-function selectFirstFramePosition(current) {
-	return current.key === void 0 ? {
-		kind: "write",
-		href: current.href,
-		replace: true,
-		userState: current.userState,
-		key: createEntryKey()
-	} : {
-		kind: "adopt",
-		position: current
-	};
-}
-/** Restores a saved position or applies the initial fragment after the first frame renders. */
-function selectFirstFrameScrollIntent(restore, prepared) {
-	const target = restore ?? (normalizeFragment(prepared.url.hash).length > 0 ? { hash: prepared.url.hash } : void 0);
-	return target === void 0 ? void 0 : {
-		target,
-		entryIndex: selectScrollEntryIndex(prepared.entries.length, prepared.error === null ? null : prepared.error.index)
-	};
-}
-function createNavigation(core, prefetch, options) {
-	let active = null;
-	const snapshots = /* @__PURE__ */ new Map();
-	let snapshotExpirationTimer;
-	/** Settles when boot commits its frame or fails; a navigation requested before then waits on it. */
-	const firstFrame = Deferred.makeUnsafe();
-	/** Set by disposal; a review scheduled before it must not touch the registry afterwards. */
-	let retired = false;
-	/** Each query's current computation; a release that names another computation is a replaced one's. */
-	const queryComputations = /* @__PURE__ */ new Map();
-	/** Expectations collected while a demand registers; the record holds the demand before they apply. */
-	let collecting = null;
-	function closeScope(scope) {
-		core.forkFiber(Scope.close(scope, Exit.void));
-	}
-	function clearSnapshotExpirationTimer() {
-		if (snapshotExpirationTimer !== void 0) {
-			window.clearTimeout(snapshotExpirationTimer);
-			snapshotExpirationTimer = void 0;
-		}
-	}
-	function deleteExpiredSnapshots(now) {
-		for (const [destination, snapshot] of snapshots) if (snapshot.expiresAt <= now) snapshots.delete(destination);
-	}
-	/** Runs one timer for the earliest expiry; longer browser delays are resumed in bounded steps. */
-	function scheduleSnapshotExpiration() {
-		clearSnapshotExpirationTimer();
-		let earliest = Infinity;
-		for (const snapshot of snapshots.values()) earliest = Math.min(earliest, snapshot.expiresAt);
-		if (!Number.isFinite(earliest)) return;
-		const delay = Math.min(Math.max(0, earliest - Date.now()), MAX_TIMER_DELAY_MILLIS);
-		snapshotExpirationTimer = window.setTimeout(() => {
-			snapshotExpirationTimer = void 0;
-			deleteExpiredSnapshots(Date.now());
-			scheduleSnapshotExpiration();
-		}, delay);
-	}
-	function retireSnapshots() {
-		snapshots.clear();
-		clearSnapshotExpirationTimer();
-	}
-	function retireReusable() {
-		prefetch.retirePreparations();
-		retireSnapshots();
-	}
-	/** The reusable preparation for `url`: a taken prefetch or a snapshot within its reuse window, whichever read is newer. */
-	function takeReusable(url) {
-		const frame = core.getState().frame;
-		if (frame !== null && frame.error !== null) snapshots.delete(readDestination(new URL(frame.href)));
-		deleteExpiredSnapshots(Date.now());
-		const destination = readDestination(url);
-		const snapshot = snapshots.get(destination);
-		const consumed = prefetch.takeForNavigation(destination);
-		if (consumed !== null) {
-			if (snapshot !== void 0 && snapshot.prepared.sequence > consumed.startSequence) {
-				consumed.release();
-				return {
-					kind: "snapshot",
-					...snapshot
-				};
-			}
-			return {
-				kind: "prefetch",
-				preparation: consumed
-			};
-		}
-		return snapshot === void 0 ? null : {
-			kind: "snapshot",
-			...snapshot
-		};
-	}
-	function applyFreshness(transition) {
-		core.updateState((state) => {
-			return {
-				...state,
-				freshness: transition.facts
-			};
-		});
-		for (const complete of transition.complete) complete();
-		if (transition.startAttempt) ensureAttempt();
-	}
-	/** The fiber scheduling refresh attempts and any application-configured retries. */
-	let retryRunner = null;
-	/** Manual and focus requests postpone route refresh until eight milliseconds after the last request. */
-	let refreshDebounce = null;
-	/**
-	* Starts one refresh attempt for the outstanding demand when one may run.
-	* Returns the candidate, or null when nothing started: no demand, a
-	* navigation that will settle the demand itself, or a failed start.
-	*/
-	function startAttemptNow() {
-		const state = core.getState();
-		const facts = state.freshness;
-		if (state.lifecycle._tag === "Disposed" || refreshDebounce !== null || !canStartAttempt(facts)) return null;
-		const frame = state.frame;
-		if (frame === null) {
-			const position = readBrowserPosition();
-			if (Result.isFailure(position)) {
-				applyFreshness(failAttempt(facts, makeRevalidationError("route", position.failure)));
-				return null;
-			}
-			core.updateState((state) => {
-				return {
-					...state,
-					freshness: startAttempt(facts)
-				};
-			});
-			return startCandidate({
-				kind: "revalidation",
-				source: "navigate",
-				recoverByReload: false,
-				href: position.success.href,
-				options: makeHistoryStateOptions(position.success.userState),
-				historyMode: "adopt",
-				restoreScroll: position.success.key === void 0 ? void 0 : recallScroll(position.success.key)
-			});
-		}
-		core.updateState((state) => {
-			return {
-				...state,
-				freshness: startAttempt(facts)
-			};
-		});
-		if (active?.kind === "navigation") return null;
-		return startCandidate({
-			kind: "revalidation",
-			source: "navigate",
-			recoverByReload: false,
-			href: frame.href,
-			options: makeHistoryStateOptions(frame.historyState),
-			historyMode: "adopt",
-			restoreScroll: void 0
-		});
-	}
-	/** One attempt as the schedule sees it: a retryable failure fails, everything else ends the loop. */
-	function attemptOnce() {
-		return Effect.suspend(() => {
-			const candidate = startAttemptNow();
-			if (candidate === null) return Effect.void;
-			return Effect.flatMap(Effect.exit(Deferred.await(candidate.intent.done)), (exit) => {
-				if (Exit.isSuccess(exit) || core.getState().freshness.demand === null) return Effect.void;
-				const error = Cause.findErrorOption(exit.cause);
-				if (Option.isNone(error)) return Effect.void;
-				const revalidationError = classifyRefreshFailure(error.value);
-				return revalidationError.reason === "build-mismatch" ? Effect.void : Effect.fail(revalidationError);
-			});
-		});
-	}
-	/** Starts a refresh attempt for the outstanding demand when one may run, under the application's schedule when one is stated. */
-	function ensureAttempt() {
-		const state = core.getState();
-		if (state.lifecycle._tag === "Disposed" || refreshDebounce !== null || !canStartAttempt(state.freshness)) return;
-		const schedule = options.refreshRetrySchedule;
-		if (schedule === void 0) {
-			startAttemptNow();
-			return;
-		}
-		retryRunner?.interruptUnsafe();
-		retryRunner = core.forkFiber(Effect.retry(attemptOnce(), schedule).pipe(Effect.catchCause((cause) => {
-			return Effect.sync(() => {
-				const error = Cause.findErrorOption(cause);
-				if (Option.isSome(error)) applyFreshness(failAttempt(core.getState().freshness, error.value));
-			});
-		})));
-	}
-	function setPending(candidate) {
-		core.updateState((state) => {
-			return {
-				...state,
-				navigation: {
-					...state.navigation,
-					pending: candidate === null ? null : {
-						href: candidate.intent.href,
-						source: candidate.source,
-						skipWorkIndicator: candidate.intent.options.skipWorkIndicator === true
-					}
-				}
-			};
-		});
-	}
-	/** Empties the slot; the occupant's region then finds it lost and ends without effect. */
-	function vacateCandidateSlot() {
-		const occupant = active;
-		if (occupant === null) return;
-		active = null;
-		if (occupant.kind === "navigation") setPending(null);
-		occupant.fiber?.interruptUnsafe();
-	}
-	function startCandidate(input) {
-		const candidate = {
-			kind: input.kind,
-			source: input.source,
-			recoverByReload: input.recoverByReload,
-			restoreScroll: input.restoreScroll,
-			reuse: input.kind === "navigation" ? takeReusable(new URL(input.href)) : null,
-			intent: {
-				href: input.href,
-				options: input.options,
-				historyMode: input.historyMode,
-				done: Deferred.makeUnsafe()
-			},
-			fiber: void 0,
-			sequence: void 0,
-			outcome: void 0,
-			frameScope: void 0
-		};
-		const previous = active;
-		active = candidate;
-		previous?.fiber?.interruptUnsafe();
-		if (candidate.kind === "navigation") {
-			setPending(candidate);
-			core.updateState((state) => {
-				return {
-					...state,
-					navigation: {
-						...state.navigation,
-						latest: AsyncResult.waiting(state.navigation.latest)
-					}
-				};
-			});
-		}
-		candidate.fiber = core.forkFiber(Effect.onExit(runCandidate(candidate), (exit) => Effect.sync(() => finalizeCandidate(candidate, exit))));
-		return candidate;
-	}
-	function runCandidate(candidate) {
-		return Effect.gen(function* () {
-			let url = new URL(candidate.intent.href);
-			let redirects = 0;
-			const reuse = candidate.reuse;
-			if (reuse?.kind === "snapshot") {
-				const frame = core.getState().frame;
-				return yield* acceptRoute(candidate, {
-					...reuse.prepared,
-					entries: reuse.prepared.entries.map((entry, index) => {
-						const retained = frame === null ? void 0 : frame.entries[index];
-						return entry.activationKey !== void 0 && retained !== void 0 && retained.pattern === entry.pattern && retained.activation !== void 0 ? {
-							...entry,
-							activationKey: retained.activation.key
-						} : entry;
-					}),
-					generation: core.getState().generation
-				});
-			}
-			let promoted = reuse?.kind === "prefetch" ? reuse.preparation : null;
-			while (true) {
-				const preparationScope = Scope.makeUnsafe();
-				const source = promoted === null ? Effect.provideService(prepareRoute(core, {
-					source: {
-						kind: "request",
-						url,
-						requestKind: candidate.kind === "navigation" ? "Navigation" : "Revalidation"
-					},
-					trigger: candidate.kind,
-					historyState: candidate.intent.options.historyState,
-					prestart: true,
-					reportReadinessFn: void 0
-				}), Scope.Scope, preparationScope) : promoted.result;
-				const release = promoted === null ? Scope.close(preparationScope, Exit.void) : Effect.sync(promoted.release);
-				promoted = null;
-				const step = yield* Effect.ensuring(Effect.gen(function* () {
-					const outcome = yield* source;
-					if (outcome._tag === "Prepared") return {
-						_tag: "Accepted",
-						result: yield* acceptRoute(candidate, outcome.prepared)
-					};
-					return {
-						_tag: "Unprepared",
-						outcome
-					};
-				}), release);
-				if (step._tag === "Accepted") return step.result;
-				const outcome = step.outcome;
-				if (outcome._tag === "BuildSkew") {
-					core.reportBuildMismatch(outcome.mismatch);
-					retireReusable();
-					if (candidate.kind === "revalidation") return yield* new NavigationError({
-						stage: "request",
-						cause: Cause.fail(new BuildMismatchError({
-							method: "GET",
-							pattern: url.pathname,
-							message: "The server refused the loaded build during revalidation"
-						}))
-					});
-					return leaveDocument(url.href);
-				}
-				const target = Result.try(() => new URL(outcome.href, url.href));
-				if (Result.isFailure(target)) return yield* failAt("target", target.failure);
-				if (!/^https?:$/.test(target.success.protocol)) return yield* failAt("target", `Redirect target ${outcome.href} is not an HTTP URL`);
-				if (target.success.origin !== window.location.origin) return leaveDocument(target.success.href);
-				if (++redirects > REDIRECT_LIMIT) return yield* failAt("target", `More than ${REDIRECT_LIMIT} redirects`);
-				const committed = core.getState().frame;
-				if (candidate.kind === "navigation" && committed !== null && readDestination(target.success) === readDestination(new URL(committed.href))) return yield* completeAtCommitted(candidate, committed, target.success);
-				url = target.success;
-				candidate.source = "redirect";
-				candidate.intent = {
-					...candidate.intent,
-					href: url.href,
-					historyMode: candidate.intent.historyMode === "adopt" ? "replace" : candidate.intent.historyMode
-				};
-				if (active === candidate && candidate.kind === "navigation") setPending(candidate);
-			}
-		});
-	}
-	/** Completes a navigation whose redirect returned to the committed destination: Unchanged, or a local commit for a new fragment or state. */
-	function completeAtCommitted(candidate, committed, url) {
-		return Effect.suspend(() => {
-			if (active !== candidate) return Effect.succeed({ _tag: "Superseded" });
-			const intent = candidate.intent;
-			const committedUrl = new URL(committed.href);
-			if (!checkBrowserPositionChanged() && normalizeFragment(url.hash) === normalizeFragment(committedUrl.hash) && Object.is(intent.options.historyState, committed.historyState)) {
-				candidate.outcome = {
-					_tag: "Unchanged",
-					href: committed.href
-				};
-				return Effect.succeed(candidate.outcome);
-			}
-			if (committed.key !== void 0) rememberScroll(committed.key, readScrollPosition());
-			const result = commitLocal({
-				reason: "navigation",
-				frame: committed,
-				url,
-				position: {
-					kind: "write",
-					href: url.href,
-					replace: intent.historyMode === "replace",
-					userState: intent.options.historyState,
-					key: createEntryKey()
-				},
-				options: intent.options,
-				restore: void 0
-			});
-			if (Result.isSuccess(result)) candidate.outcome = result.success;
-			return Effect.fromResult(result);
-		});
-	}
-	function acceptRoute(candidate, prepared) {
-		return Effect.scoped(Effect.gen(function* () {
-			const frame = core.getState().frame;
-			const preparationScope = yield* Effect.scope;
-			const outgoing = frame === null ? [] : yield* Effect.mapError(acquireActivations(core.activations, {
-				entries: frame.entries.filter((entry) => {
-					return entry.view?.beforeRouteReplacement !== void 0;
-				}),
-				scope: preparationScope
-			}), (cause) => failAt("transition", cause));
-			candidate.sequence = prepared.sequence;
-			const frameScope = Scope.makeUnsafe();
-			candidate.frameScope = frameScope;
-			const entries = yield* Effect.mapError(acquireActivations(core.activations, {
-				entries: prepared.entries,
-				scope: frameScope
-			}), (cause) => failAt("assets", cause));
-			const reason = candidate.kind === "revalidation" ? "revalidation" : candidate.recoverByReload ? "popstate" : "navigation";
-			if (frame !== null) {
-				const args = {
-					trigger: reason,
-					current: projectRouteState(frame),
-					next: projectRouteState({
-						href: candidate.intent.href,
-						historyState: candidate.intent.options.historyState,
-						entries: prepared.entries,
-						error: prepared.error
-					})
-				};
-				const hooks = [...outgoing.map((entry) => {
-					return {
-						entry,
-						hook: entry.view?.beforeRouteReplacement
-					};
-				}), ...entries.map((entry) => {
-					return {
-						entry,
-						hook: entry.view?.beforeRouteCommit
-					};
-				})];
-				yield* Effect.catchCause(Effect.forEach(hooks, ({ entry, hook }) => {
-					if (hook === void 0) return Effect.void;
-					const effect = Effect.suspend(() => hook(args));
-					return entry.activation === void 0 ? core.provideClient(effect) : Effect.provide(effect, entry.activation.client);
-				}, {
-					concurrency: "unbounded",
-					discard: true
-				}), (cause) => failAt("transition", cause));
-			}
-			return yield* commitRegion(candidate, {
-				...prepared,
-				entries
-			}, reason, frameScope);
-		}));
-	}
-	function commitRegion(candidate, prepared, reason, frameScope) {
-		/** Synchronous, so nothing interleaves between its checks and the acceptance point. */
-		function runRegion() {
-			const state = core.getState();
-			const lifecycleAdmits = state.lifecycle._tag === "Ready" || candidate.kind === "revalidation" && state.lifecycle._tag === "PreBoot";
-			if (active !== candidate || !lifecycleAdmits || state.generation !== prepared.generation) return Result.succeed({ _tag: "Superseded" });
-			const intent = candidate.intent;
-			const firstFrame = state.frame === null;
-			let position;
-			if (intent.historyMode === "adopt") {
-				const current = readBrowserPosition();
-				if (Result.isFailure(current)) return Result.fail(failAt("transition", current.failure));
-				if (current.success.href !== intent.href) return Result.fail(failAt("transition", "The browser location changed during preparation"));
-				position = selectFirstFramePosition(current.success);
-			} else {
-				if (state.frame !== null && state.frame.key !== void 0) rememberScroll(state.frame.key, readScrollPosition());
-				position = {
-					kind: "write",
-					href: intent.href,
-					replace: intent.historyMode === "replace",
-					userState: intent.options.historyState,
-					key: createEntryKey()
-				};
-			}
-			const committed = commitFrame(core, {
-				reason: firstFrame ? "boot" : reason,
-				entries: prepared.entries,
-				error: prepared.error,
-				head: prepared.head,
-				cssBundles: prepared.cssBundles,
-				documentUpdate: "apply",
-				position,
-				scrollIntent: firstFrame ? selectFirstFrameScrollIntent(candidate.restoreScroll, prepared) : candidate.kind === "revalidation" ? void 0 : decideScrollIntent({
-					url: new URL(intent.href),
-					options: intent.options,
-					restore: candidate.restoreScroll,
-					entryCount: prepared.entries.length,
-					errorIndex: prepared.error === null ? null : prepared.error.index
-				}),
-				committedAt: candidate.reuse?.kind === "snapshot" ? candidate.reuse.committedAt : void 0,
-				scope: frameScope
-			});
-			if (Result.isSuccess(committed)) {
-				candidate.outcome = {
-					_tag: "Committed",
-					href: committed.success.href
-				};
-				return Result.succeed(candidate.outcome);
-			}
-			return Result.fail(committed.failure);
-		}
-		const transitionDocument = document;
-		const startViewTransition = transitionDocument.startViewTransition;
-		const outcome = candidate.kind === "navigation" && options.enableViewTransitions && startViewTransition !== void 0 ? Effect.callback((resume) => {
-			const started = Result.try(() => {
-				return startViewTransition.call(transitionDocument, () => resume(Effect.succeed(runRegion())));
-			});
-			if (Result.isFailure(started)) {
-				resume(Effect.fail(failAt("transition", started.failure)));
-				return;
-			}
-			started.success.ready.catch(() => void 0);
-			started.success.updateCallbackDone.catch((cause) => {
-				resume(Effect.fail(failAt("transition", cause)));
-			});
-		}) : Effect.sync(runRegion);
-		return Effect.flatMap(outcome, Effect.fromResult);
-	}
-	function finalizeCandidate(candidate, rawExit) {
-		const exit = candidate.outcome === void 0 ? rawExit : Exit.succeed(candidate.outcome);
-		const held = active === candidate;
-		if (held) active = null;
-		const interrupted = Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause);
-		if (candidate.frameScope !== void 0 && candidate.outcome === void 0) closeScope(candidate.frameScope);
-		if (candidate.kind === "navigation" && held) {
-			setPending(null);
-			if (!interrupted) core.updateState((state) => {
-				return {
-					...state,
-					navigation: {
-						...state.navigation,
-						latest: AsyncResult.fromExit(exit)
-					}
-				};
-			});
-		}
-		if (held && Exit.isFailure(exit) && !interrupted) {
-			const error = Cause.findErrorOption(exit.cause);
-			if (!(Option.isSome(error) && error.value.stage === "publication") && (candidate.recoverByReload || checkBrowserPositionChanged())) reloadDocument(core, exit.cause);
-		}
-		const facts = core.getState().freshness;
-		if (Exit.isSuccess(exit)) {
-			if (exit.value._tag === "Committed" && candidate.sequence !== void 0) {
-				const frame = core.getState().frame;
-				const reuseWindow = frame?.entries.at(-1)?.view?.reuseLoaderDataWithin;
-				const duration = reuseWindow === void 0 ? Option.none() : Duration.fromInput(reuseWindow);
-				const durationMillis = Option.map(duration, Duration.toMillis);
-				const retainedAt = Date.now();
-				if (frame !== null && frame.error === null && candidate.reuse?.kind !== "snapshot" && Option.isSome(durationMillis) && Number.isFinite(durationMillis.value) && durationMillis.value > 0) {
-					snapshots.set(readDestination(new URL(frame.href)), {
-						prepared: {
-							url: new URL(frame.href),
-							entries: frame.entries.map(toCachedRouteEntry),
-							error: frame.error,
-							head: frame.head,
-							cssBundles: frame.cssBundles,
-							sequence: candidate.sequence,
-							generation: core.getState().generation
-						},
-						committedAt: frame.committedAt,
-						expiresAt: frame.committedAt + durationMillis.value
-					});
-					deleteExpiredSnapshots(retainedAt);
-					scheduleSnapshotExpiration();
-				}
-				const error = frame === null ? null : frame.error;
-				if (facts.demand !== null) applyFreshness(error === null ? satisfyDemand(facts, { sequence: candidate.sequence }) : failAttempt(facts, makeRevalidationError("route", error.error)));
-			}
-		} else if (interrupted) {
-			if (active === null && facts.attempt.phase === "running") applyFreshness(abandonAttempt(facts));
-		} else {
-			const error = Cause.findErrorOption(exit.cause);
-			if (Option.isNone(error)) core.publishEvent({
-				_tag: "FailureReported",
-				source: "navigation",
-				cause: exit.cause
-			});
-			if (held && facts.attempt.phase === "running") {
-				if (candidate.kind === "revalidation") {
-					const revalidationError = Option.match(error, {
-						onNone: () => {
-							return makeRevalidationError("route", exit.cause);
-						},
-						onSome: classifyRefreshFailure
-					});
-					applyFreshness(options.refreshRetrySchedule !== void 0 && revalidationError.reason !== "build-mismatch" ? holdAttemptForRetry(facts, revalidationError) : failAttempt(facts, revalidationError));
-				} else applyFreshness(abandonAttempt(facts));
-			}
-		}
-		Deferred.doneUnsafe(candidate.intent.done, interrupted ? Effect.succeed({ _tag: "Superseded" }) : Exit.isSuccess(exit) ? Effect.succeed(exit.value) : Effect.failCause(exit.cause));
-	}
-	/** Commits the committed entries again at a new position, without a request. */
-	function commitLocal(input) {
-		return Result.map(commitFrame(core, {
-			reason: input.reason,
-			entries: input.frame.entries,
-			error: input.frame.error,
-			head: input.frame.head,
-			cssBundles: input.frame.cssBundles,
-			documentUpdate: "apply",
-			position: input.position,
-			scrollIntent: decideScrollIntent({
-				url: input.url,
-				options: input.options,
-				restore: input.restore,
-				entryCount: input.frame.entries.length,
-				errorIndex: input.frame.error === null ? null : input.frame.error.index
-			}),
-			committedAt: input.frame.committedAt,
-			scope: input.frame.scope
-		}), (frame) => {
-			if (active?.kind === "revalidation" && readDestination(new URL(active.intent.href)) === readDestination(new URL(frame.href))) active.intent = {
-				...active.intent,
-				href: frame.href,
-				options: makeHistoryStateOptions(frame.historyState)
-			};
-			return {
-				_tag: "Committed",
-				href: frame.href
-			};
-		});
-	}
-	function navigateToHref(href, requested) {
-		return Effect.suspend(() => beginNavigation(href, requested));
-	}
-	function recordNavigationTargetFailure(error) {
-		core.updateState((state) => {
-			return {
-				...state,
-				navigation: {
-					...state.navigation,
-					latest: AsyncResult.fail(error)
-				}
-			};
-		});
-	}
-	function beginNavigation(href, requested) {
-		{
-			const state = core.getState();
-			const frame = state.frame;
-			if (state.lifecycle._tag === "PreBoot") {
-				const queued = core.forkFiber(Effect.flatMap(Deferred.await(firstFrame), () => {
-					return beginNavigation(href, requested);
-				}));
-				return Fiber.join(queued);
-			}
-			if (state.lifecycle._tag !== "Ready" || frame === null) return failAt("target", "The client is not ready to navigate");
-			const parsed = Result.try(() => new URL(href, window.location.href));
-			if (Result.isFailure(parsed)) return failAt("target", parsed.failure);
-			const url = parsed.success;
-			if (!/^https?:$/.test(url.protocol) || url.origin !== window.location.origin) return Effect.succeed(leaveDocument(url.href));
-			const captured = Result.try(() => structuredClone(requested.historyState));
-			if (Result.isFailure(captured)) return failAt("target", captured.failure);
-			const options = {
-				...requested,
-				...makeHistoryStateOptions(captured.success)
-			};
-			const committed = new URL(frame.href);
-			if (readDestination(url) === readDestination(committed)) {
-				if (!checkBrowserPositionChanged() && normalizeFragment(url.hash) === normalizeFragment(committed.hash) && Object.is(options.historyState, frame.historyState)) return Effect.succeed({
-					_tag: "Unchanged",
-					href: frame.href
-				});
-				if (frame.key !== void 0) rememberScroll(frame.key, readScrollPosition());
-				return Effect.fromResult(commitLocal({
-					reason: "navigation",
-					frame,
-					url,
-					position: {
-						kind: "write",
-						href: url.href,
-						replace: options.replace === true,
-						userState: options.historyState,
-						key: createEntryKey()
-					},
-					options,
-					restore: void 0
-				}));
-			}
-			const historyMode = options.replace === true ? "replace" : "push";
-			if (active?.kind === "navigation" && readDestination(new URL(active.intent.href)) === readDestination(url)) {
-				const current = active.intent;
-				if (current.href === url.href && matchesNavigationOptions(current.options, options)) return Deferred.await(current.done);
-				active.intent = {
-					href: url.href,
-					options,
-					historyMode,
-					done: Deferred.makeUnsafe()
-				};
-				setPending(active);
-				Deferred.doneUnsafe(current.done, Effect.succeed({ _tag: "Superseded" }));
-				return Deferred.await(active.intent.done);
-			}
-			return Deferred.await(startCandidate({
-				kind: "navigation",
-				source: "navigate",
-				recoverByReload: false,
-				href: url.href,
-				options,
-				historyMode,
-				restoreScroll: void 0
-			}).intent.done);
-		}
-	}
-	function requireRefresh(input) {
-		const waiter = Deferred.makeUnsafe();
-		retireSnapshots();
-		const state = core.getState();
-		refreshDebounce?.interruptUnsafe();
-		refreshDebounce = input.debounce ? core.forkFiber(Effect.sleep("8 millis").pipe(Effect.andThen(Effect.sync(() => {
-			refreshDebounce = null;
-			ensureAttempt();
-		})))) : null;
-		const expected = /* @__PURE__ */ new Set();
-		collecting = expected;
-		applyFreshness(registerDemand(state.freshness, {
-			sequence: state.sequence,
-			waiter,
-			skipWorkIndicator: input.skipWorkIndicator
-		}));
-		collecting = null;
-		applyFreshness(expectQueries(core.getState().freshness, expected));
-		return Deferred.await(waiter);
-	}
-	function invalidateSession() {
-		return Effect.suspend(() => {
-			core.retireGeneration();
-			retireReusable();
-			vacateCandidateSlot();
-			return requireRefresh({
-				skipWorkIndicator: false,
-				debounce: false
-			});
-		});
-	}
-	function settleBoot(outcome) {
-		Deferred.doneUnsafe(firstFrame, Result.isSuccess(outcome) ? Effect.void : Effect.fail(failAt("target", outcome.failure)));
-	}
-	/** Disposal: nothing outstanding survives the application. */
-	function retireAll() {
-		retired = true;
-		Deferred.doneUnsafe(firstFrame, Effect.fail(failAt("target", "The client application is disposed")));
-		retryRunner?.interruptUnsafe();
-		refreshDebounce?.interruptUnsafe();
-		refreshDebounce = null;
-		retireReusable();
-		vacateCandidateSlot();
-		applyFreshness(retireDemand(core.getState().freshness, makeRevalidationError("disposed", "The client application is disposed")));
-	}
-	const queries = {
-		expect: ({ id, token }) => {
-			queryComputations.set(id, token);
-			if (collecting !== null) {
-				collecting.add(id);
-				return;
-			}
-			if (!retired) applyFreshness(expectQueries(core.getState().freshness, /* @__PURE__ */ new Set([id])));
-		},
-		release: ({ id, token }) => {
-			if (queryComputations.get(id) !== token) return;
-			queryComputations.delete(id);
-			if (!retired) applyFreshness(releaseQuery(core.getState().freshness, id));
-		},
-		acknowledge: (acknowledgment) => {
-			const state = core.getState();
-			if (acknowledgment.dispatched !== void 0 && acknowledgment.dispatched.generation !== state.generation) return;
-			applyFreshness(acknowledgeQuery(state.freshness, {
-				id: acknowledgment.id,
-				sequence: acknowledgment.dispatched?.sequence,
-				success: acknowledgment.success
-			}));
-		}
-	};
-	/** Whether the browser moved away from the committed frame during navigation. */
-	function checkBrowserPositionChanged() {
-		const frame = core.getState().frame;
-		if (frame === null) return false;
-		const position = readBrowserPosition();
-		return Result.isFailure(position) || position.success.href !== frame.href || position.success.key !== frame.key;
-	}
-	function handlePopstate() {
-		vacateCandidateSlot();
-		const position = readBrowserPosition();
-		const frame = core.getState().frame;
-		if (Result.isFailure(position)) {
-			reloadDocument(core, Cause.fail(position.failure));
-			return;
-		}
-		if (frame === null) {
-			reloadDocument(core, Cause.fail("No committed route is available for history traversal"));
-			return;
-		}
-		const url = new URL(position.success.href);
-		if (frame.key !== void 0 && frame.key !== position.success.key) rememberScroll(frame.key, readScrollPosition());
-		const restore = position.success.key === void 0 ? void 0 : recallScroll(position.success.key);
-		if (readDestination(url) === readDestination(new URL(frame.href))) {
-			const committed = commitLocal({
-				reason: "popstate",
-				frame,
-				url,
-				position: {
-					kind: "adopt",
-					position: position.success
-				},
-				options: {},
-				restore
-			});
-			if (Result.isFailure(committed) && committed.failure.stage !== "publication") reloadDocument(core, Cause.fail(committed.failure));
-			return;
-		}
-		startCandidate({
-			kind: "navigation",
-			source: "popstate",
-			recoverByReload: true,
-			href: url.href,
-			options: makeHistoryStateOptions(position.success.userState),
-			historyMode: "adopt",
-			restoreScroll: restore
-		});
-	}
-	/** A reload or departure remembers the entry's scroll; boot restores it by the entry's key. */
-	function handlePageHide() {
-		const frame = core.getState().frame;
-		if (frame !== null && frame.key !== void 0) rememberScroll(frame.key, readScrollPosition());
-	}
-	/** A document that becomes visible again is treated as focused; a hidden one is not. */
-	function handleVisibilityChange() {
-		if (document.visibilityState === "visible") handleFocus();
-	}
-	function handleFocus() {
-		const focus = options.revalidateOnWindowFocus;
-		const state = core.getState();
-		const busy = active !== null || state.freshness.attempt.phase === "running" || [...state.operations.values()].some((operation) => operation.phase !== "settled");
-		if (focus === void 0 || state.frame === null || busy || Date.now() - state.frame.committedAt < Duration.toMillis(focus.staleTime)) return;
-		core.forkFiber(Effect.ignore(Effect.tapError(requireRefresh({
-			skipWorkIndicator: focus.skipWorkIndicator,
-			debounce: true
-		}), (error) => {
-			return Effect.sync(() => {
-				core.publishEvent({
-					_tag: "FailureReported",
-					source: "revalidation",
-					cause: Cause.fail(error)
-				});
-			});
-		})));
-	}
-	return {
-		navigate: navigateToHref,
-		recordTargetFailure: recordNavigationTargetFailure,
-		begin: beginNavigation,
-		revalidate: (input) => Effect.suspend(() => requireRefresh({
-			...input,
-			debounce: true
-		})),
-		requireRefresh: (input) => requireRefresh({
-			...input,
-			debounce: false
-		}),
-		settleBoot,
-		retireReusable,
-		retireAll,
-		invalidate: invalidateSession,
-		queries,
-		commitBoot: (prepared, scope, position) => {
-			const restore = position.key === void 0 ? void 0 : recallScroll(position.key);
-			const committed = commitFrame(core, {
-				reason: "boot",
-				entries: prepared.entries,
-				error: prepared.error,
-				head: prepared.head,
-				cssBundles: prepared.cssBundles,
-				documentUpdate: "adopt",
-				position: selectFirstFramePosition(position),
-				scrollIntent: selectFirstFrameScrollIntent(restore, prepared),
-				committedAt: void 0,
-				scope
-			});
-			if (Result.isSuccess(committed)) ensureAttempt();
-			return committed;
-		},
-		attachBrowserListeners: () => {
-			const previousScrollRestoration = window.history.scrollRestoration;
-			window.history.scrollRestoration = "manual";
-			window.addEventListener("popstate", handlePopstate);
-			window.addEventListener("focus", handleFocus);
-			document.addEventListener("visibilitychange", handleVisibilityChange);
-			window.addEventListener("pagehide", handlePageHide);
-			const detachPointerModality = attachPointerModalityTracking();
-			return () => {
-				if (window.history.scrollRestoration === "manual") window.history.scrollRestoration = previousScrollRestoration;
-				detachPointerModality();
-				window.removeEventListener("pagehide", handlePageHide);
-				window.removeEventListener("popstate", handlePopstate);
-				window.removeEventListener("focus", handleFocus);
-				document.removeEventListener("visibilitychange", handleVisibilityChange);
-			};
-		}
-	};
-}
-//#endregion
-//#region src/client/request.ts
-/** Applies the application's request transformation before dispatch. */
-function prepareClientRequest(input) {
-	if (input.prepareRequestFn === void 0) return Effect.succeed(input.context.request);
-	return input.prepareRequestFn(input.context);
-}
-//#endregion
-//#region src/client/assembly.ts
-function createClientApplication(input) {
-	const registry = AtomRegistry.make({ scheduleTask: input.scheduleTaskFn });
-	const scope = Scope.makeUnsafe();
-	const events = Effect.runSync(PubSub.unbounded());
-	let contexts = Option.none();
-	let retirement = Deferred.makeUnsafe();
-	let clientBuildId = "";
-	let deploymentId;
-	let developmentMode = false;
-	let disposal;
-	function getState() {
-		return registry.get(clientStateAtom);
-	}
-	function updateState(updateFn) {
-		registry.update(clientStateAtom, updateFn);
-	}
-	function setLifecycle(lifecycle) {
-		updateState((state) => {
-			return {
-				...state,
-				lifecycle
-			};
-		});
-	}
-	function publishEvent(event) {
-		if (disposal === void 0) PubSub.publishUnsafe(events, event);
-	}
-	function provideClient(effect) {
-		return Effect.suspend(() => {
-			return Option.isNone(contexts) ? Effect.fail(CLIENT_UNAVAILABLE_ERROR) : provideClientContext(contexts.value, effect);
-		});
-	}
-	const core = {
-		registry,
-		scope,
-		memoMap: Effect.runSync(Layer.makeMemoMap),
-		mutationFibers: Effect.runSync(Effect.provideService(FiberSet.make(), Scope.Scope, scope)),
-		events: Stream.fromPubSub(events),
-		publishEvent,
-		getState,
-		updateState,
-		forkFiber: (effect) => Effect.runSync(Effect.forkIn(effect, scope)),
-		advanceSequence: () => {
-			updateState((state) => {
-				return {
-					...state,
-					sequence: state.sequence + 1
-				};
-			});
-			return getState().sequence;
-		},
-		getGenerationRetirement: () => retirement,
-		retireGeneration: () => {
-			const retired = retirement;
-			retirement = Deferred.makeUnsafe();
-			updateState((state) => {
-				return {
-					...state,
-					generation: state.generation + 1
-				};
-			});
-			Deferred.doneUnsafe(retired, Effect.void);
-		},
-		getClientBuildId: () => clientBuildId,
-		getDeploymentId: () => deploymentId,
-		runsInDevelopmentMode: () => developmentMode,
-		clientLoaders: createClientLoaderRegistry(),
-		prepareRequest: (context) => {
-			return provideClient(prepareClientRequest({
-				context,
-				prepareRequestFn: input.options.prepareRequestFn
-			}));
-		},
-		provideClient,
-		reportBuildMismatch: (mismatch) => {
-			updateState((state) => {
-				return {
-					...state,
-					buildMismatch: Option.some(mismatch)
-				};
-			});
-			publishEvent({
-				_tag: "BuildMismatchDetected",
-				mismatch
-			});
-		},
-		activations: Effect.runSync(Effect.provideService(createActivationMap(() => contexts), Scope.Scope, scope))
-	};
-	const prefetch = createPrefetch(core);
-	const navigation = createNavigation(core, prefetch, {
-		enableViewTransitions: input.options.enableViewTransitions === true,
-		refreshRetrySchedule: input.options.refreshRetrySchedule,
-		revalidateOnWindowFocus: input.options.revalidateOnWindowFocus === void 0 ? void 0 : {
-			staleTime: input.options.revalidateOnWindowFocus.staleTime,
-			skipWorkIndicator: input.options.revalidateOnWindowFocus.skipWorkIndicator === true
-		}
-	});
-	const workIndicator = createWorkIndicator(core, input.options.workIndicator);
-	const coordinator = {
-		trackWork: workIndicator.track,
-		registry,
-		events: core.events,
-		publishEvent,
-		navigation,
-		prefetch,
-		queries: navigation.queries,
-		fork: (effect) => core.forkFiber(effect),
-		reportRenderFailure: (failure) => {
-			publishEvent({
-				_tag: "FailureReported",
-				source: "render",
-				cause: Cause.isCause(failure.error) ? failure.error : Cause.die(failure.error)
-			});
-			updateState((state) => {
-				const frame = state.frame;
-				if (frame === null || frame.revision !== failure.revision || failure.index === void 0 || failure.pattern === void 0 || frame.error !== null && frame.error.index <= failure.index) return state;
-				return {
-					...state,
-					frame: {
-						...frame,
-						error: {
-							index: failure.index,
-							pattern: failure.pattern,
-							source: "render",
-							error: failure.error
-						}
-					}
-				};
-			});
-		},
-		endpoints: createEndpointOperations(core, {
-			retireReusableFn: navigation.retireReusable,
-			requireRefreshFn: navigation.requireRefresh,
-			redirectFn: (url) => {
-				return navigation.begin(url.href, { replace: true });
-			},
-			navigateDocumentFn: (href) => {
-				window.location.assign(href);
-			}
-		})
-	};
-	const assembleServices = Effect.gen(function* () {
-		const universalServices = input.options.universalServices === void 0 ? Layer.empty : input.options.universalServices;
-		const universal = yield* Layer.buildWithMemoMap(universalServices, core.memoMap, scope);
-		const universalLayer = Layer.succeedContext(universal);
-		const clientOnly = input.options.clientOnlyServices === void 0 ? Layer.empty : Layer.provide(input.options.clientOnlyServices, universalLayer);
-		const framework = Layer.mergeAll(Layer.succeed(ClientCoordinator, coordinator), Layer.succeed(AtomRegistry.AtomRegistry, registry), Reactivity.layer, FetchHttpClient.layer);
-		return {
-			universal,
-			client: yield* Layer.buildWithMemoMap(Layer.merge(Layer.merge(framework, universalLayer), clientOnly), core.memoMap, scope)
-		};
-	});
-	function startBrowserProgram() {
-		const program = input.options.browserProgram;
-		if (program === void 0) return;
-		core.forkFiber(core.provideClient(program).pipe(Effect.tapCause((cause) => {
-			return Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.sync(() => {
-				publishEvent({
-					_tag: "FailureReported",
-					source: "browserProgram",
-					cause
-				});
-			});
-		}), Effect.ignore));
-	}
-	/**
-	* Imports the matching module in the background, after the first frame.
-	* Once it is installed, client loaders start before the server answers
-	* for every destination the registry can prove; until then, and if it
-	* never arrives, nothing starts early and every navigation proceeds as
-	* it would without the module.
-	*/
-	function loadRouteMatching() {
-		core.forkFiber(Effect.tryPromise(() => import("../../route-matching-D_uSG2P9.js")).pipe(Effect.map((module) => {
-			core.clientLoaders.installMatching(module);
-		}), Effect.tapCause((cause) => {
-			return Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.sync(() => {
-				publishEvent({
-					_tag: "FailureReported",
-					source: "clientLoaderEligibility",
-					cause
-				});
-			});
-		}), Effect.ignore));
-	}
-	/** Creates a typed boot failure; the outer boundary records it after cleanup. */
-	function failBoot(message, cause) {
-		const error = {
-			_tag: "ClientBootError",
-			message,
-			...cause === void 0 ? {} : { cause }
-		};
-		return Exit.fail(error);
-	}
-	let bootStarted = false;
-	let bootFiber;
-	function bootApplication() {
-		if (disposal !== void 0) return Promise.resolve(Exit.fail({
-			_tag: "ClientBootError",
-			message: "The client application is disposed"
-		}));
-		if (getState().lifecycle._tag !== "PreBoot" || bootStarted) return Promise.resolve(Exit.fail({
-			_tag: "ClientBootError",
-			message: "The client application boot already started"
-		}));
-		bootStarted = true;
-		bootFiber = core.forkFiber(Effect.flatMap(Effect.scoped(prepareBoot()), (document) => {
-			return Effect.suspend(() => finishBoot(document));
-		}));
-		return Effect.runPromise(Effect.map(Fiber.await(bootFiber), (exit) => {
-			if (Exit.isSuccess(exit)) return exit;
-			const failure = Exit.findErrorOption(exit);
-			const error = Option.isSome(failure) ? failure.value : {
-				_tag: "ClientBootError",
-				message: "Client application boot did not complete",
-				cause: exit.cause
-			};
-			if (disposal === void 0 && getState().lifecycle._tag === "PreBoot") {
-				setLifecycle({
-					_tag: "BootFailed",
-					error
-				});
-				navigation.settleBoot(Result.fail(error));
-			}
-			return Exit.fail(error);
-		}));
-	}
-	function prepareBoot() {
-		return Effect.gen(function* () {
-			const root = document.getElementById(DOCUMENT_PROTOCOL.elementIds.root);
-			const dataElement = document.getElementById(DOCUMENT_PROTOCOL.elementIds.data);
-			if (root === null || dataElement === null) return yield* failBoot("The document carries no Vorma root or bootstrap payload");
-			const raw = Result.try(() => {
-				return JSON.parse(dataElement.textContent);
-			});
-			if (Result.isFailure(raw)) return yield* failBoot("The bootstrap payload is not JSON", raw.failure);
-			const url = new URL(window.location.href);
-			const bootstrapRead = readBootstrapPayload(raw.success);
-			if (Result.isFailure(bootstrapRead)) return yield* failBoot("The bootstrap payload's values do not restore", bootstrapRead.failure);
-			const bootstrap = bootstrapRead.success;
-			clientBuildId = bootstrap.clientBuildId;
-			deploymentId = bootstrap.deploymentId;
-			developmentMode = bootstrap.developmentMode;
-			if (import.meta.env?.DEV && developmentMode) yield* (yield* Effect.tryPromise(() => import("../../development-B_rxuwY7.js")).pipe(Effect.catch((cause) => failBoot("Could not load development updates", cause)))).installDevelopmentUpdates({
-				core,
-				navigation
-			});
-			const documentHead = readDocumentHead();
-			if (Result.isFailure(documentHead)) return yield* failBoot("The document's managed head could not be read", documentHead.failure);
-			const payload = {
-				routes: bootstrap.routes,
-				serverError: bootstrap.serverError,
-				head: documentHead.success,
-				deps: [],
-				cssBundles: readDocumentStylesheets(),
-				staticAssets: []
-			};
-			const assembled = yield* Effect.result(assembleServices);
-			if (getState().lifecycle._tag === "Disposed") return yield* failBoot("The client application was disposed during boot");
-			if (Result.isFailure(assembled)) return yield* failBoot("Client application services could not be acquired", assembled.failure);
-			contexts = Option.some(assembled.success);
-			publishApplicationContexts({
-				registry,
-				contexts: assembled.success
-			});
-			registry.mount(clientRuntime);
-			yield* workIndicator.start();
-			startBrowserProgram();
-			const read = readBrowserPosition();
-			if (Result.isFailure(read)) publishEvent({
-				_tag: "FailureReported",
-				source: "navigation",
-				cause: Cause.fail(read.failure)
-			});
-			const position = Result.isSuccess(read) ? read.success : {
-				href: url.href,
-				userState: void 0,
-				key: void 0
-			};
-			const prepared = yield* Effect.result(prepareRoute(core, {
-				source: {
-					kind: "payload",
-					url,
-					payload
-				},
-				trigger: "boot",
-				historyState: position.userState,
-				prestart: false,
-				reportReadinessFn: void 0
-			}));
-			if (getState().lifecycle._tag === "Disposed") return yield* failBoot("The client application was disposed during boot");
-			if (Result.isFailure(prepared) || prepared.success._tag !== "Prepared") return yield* failBoot("The initial route could not be prepared", Result.isFailure(prepared) ? prepared.failure : prepared.success);
-			if (getState().frame !== null) return {
-				root,
-				dataElement
-			};
-			const preparedRoute = prepared.success.prepared;
-			return yield* Effect.acquireUseRelease(Scope.fork(scope), (frameScope) => {
-				return Effect.gen(function* () {
-					const entries = yield* Effect.result(acquireActivations(core.activations, {
-						entries: preparedRoute.entries,
-						scope: frameScope
-					}));
-					if (getState().lifecycle._tag === "Disposed") return yield* failBoot("The client application was disposed during boot");
-					if (Result.isFailure(entries)) return yield* failBoot("The initial route's services could not be built", entries.failure);
-					const committed = navigation.commitBoot({
-						...preparedRoute,
-						entries: entries.success
-					}, frameScope, position);
-					if (Result.isFailure(committed)) return yield* failBoot("The initial route could not be committed", committed.failure);
-					return {
-						root,
-						dataElement
-					};
-				});
-			}, (frameScope, exit) => {
-				return getState().frame?.scope === frameScope ? Effect.void : Scope.close(frameScope, exit);
-			});
-		});
-	}
-	/** Renders the committed first frame, attaches the browser listeners, and marks the client ready. */
-	function finishBoot({ root, dataElement }) {
-		input.renderFn(root);
-		const detach = navigation.attachBrowserListeners();
-		Effect.runSync(Scope.addFinalizer(scope, Effect.sync(detach)));
-		loadRouteMatching();
-		dataElement.remove();
-		setLifecycle({ _tag: "Ready" });
-		navigation.settleBoot(Result.succeed(void 0));
-		return Exit.void;
-	}
-	function disposeApplication() {
-		if (disposal !== void 0) return disposal;
-		setLifecycle({ _tag: "Disposed" });
-		navigation.retireAll();
-		const frame = getState().frame;
-		disposal = Effect.runPromise((bootFiber === void 0 ? Effect.void : Fiber.interrupt(bootFiber)).pipe(Effect.andThen(Effect.sync(input.disposeRendererFn)), Effect.ensuring(frame === null ? Effect.void : Scope.close(frame.scope, Exit.void)), Effect.ensuring(Scope.close(scope, Exit.void)), Effect.ensuring(PubSub.shutdown(events)), Effect.ensuring(Effect.sync(() => registry.dispose()))));
-		return disposal;
-	}
-	return {
-		core,
-		coordinator,
-		navigation,
-		prefetch,
-		checkDisposed: () => disposal !== void 0,
-		boot: bootApplication,
-		dispose: disposeApplication
-	};
-}
-//#endregion
-//#region src/client/react/view.tsx
-const Context$1 = createContext(null);
-const ApplicationProvider = Context$1.Provider;
-/** The mounted application. A Vorma component outside one cannot work, and React's protocol for that is a throw to the caller. */
-function useApplication() {
-	const application = useContext(Context$1);
-	if (application === null) throw new Error("Vorma React components render only inside a Vorma client application");
-	return application;
-}
-function makeUiView(definition) {
-	return definition;
-}
-const UiView = { make: makeUiView };
-const RENDER_FAILURE = Symbol("vorma/client/RenderFailure");
-function matchesTaggedFailure(error) {
-	return typeof error === "object" && error !== null && RENDER_FAILURE in error;
-}
-/** Observes the navigation a query redirect started; renders its failure in the boundary and nothing otherwise. */
-function RedirectObservation(props) {
-	const observation = useMemo(() => {
-		return clientRuntime.atom(props.redirect.navigation);
-	}, [props.redirect]);
-	const result = useAtomValue(observation);
-	const Boundary = props.boundary;
-	if (result._tag === "Failure") return /* @__PURE__ */ jsx(Boundary, { error: projectRouteError({
-		pattern: props.pattern,
-		source: "render",
-		error: result.cause
-	}) });
-	return null;
-}
-/** React's catch protocol, attributed to the matched entry that owns the boundary. */
-var RouteBoundary = class RouteBoundary extends Component {
-	state = {
-		revision: this.props.revision,
-		caught: null
-	};
-	static getDerivedStateFromProps(props, state) {
-		return props.revision === state.revision ? null : {
-			revision: props.revision,
-			caught: null
-		};
-	}
-	static getDerivedStateFromError(error) {
-		return { caught: {
-			error,
-			index: void 0,
-			pattern: void 0
-		} };
-	}
-	/** The failure with the position it belongs to: a rethrown one keeps its own, a new one is this boundary's. */
-	attributeFailure(error) {
-		return matchesTaggedFailure(error) ? error[RENDER_FAILURE] : {
-			error,
-			index: this.props.index,
-			pattern: this.props.pattern
-		};
-	}
-	componentDidCatch(error, _info) {
-		const failure = this.attributeFailure(error);
-		if (getQueryRedirect(failure.error) !== void 0) return;
-		this.props.reportFn({
-			index: failure.index,
-			pattern: failure.pattern,
-			revision: this.props.revision,
-			error: failure.error
-		});
-	}
-	render() {
-		if (this.state.caught === null) return this.props.children;
-		const failure = this.attributeFailure(this.state.caught.error);
-		const Boundary = this.props.boundary;
-		if (Boundary === void 0) throw { [RENDER_FAILURE]: failure };
-		const redirect = getQueryRedirect(failure.error);
-		return /* @__PURE__ */ jsx(RouteBoundary, {
-			index: this.props.index,
-			pattern: this.props.pattern,
-			revision: this.props.revision,
-			boundary: void 0,
-			reportFn: this.props.reportFn,
-			children: redirect === void 0 ? /* @__PURE__ */ jsx(Boundary, { error: projectRouteError({
-				...failure,
-				source: "render"
-			}) }) : /* @__PURE__ */ jsx(RedirectObservation, {
-				redirect,
-				boundary: Boundary,
-				pattern: failure.pattern
-			})
-		});
-	}
-};
-/** The nearest authored boundary strictly above an error position, or the application boundary outside the route tree. */
-function selectBoundary(frame, application) {
-	const error = frame.error;
-	if (error === null) return null;
-	for (let index = error.index - 1; index >= 0; index--) {
-		const entry = frame.entries[index];
-		const boundary = (entry?.view)?.descendantErrorBoundary;
-		if (entry !== void 0 && boundary !== void 0) return {
-			index,
-			component: boundary
-		};
-	}
-	return {
-		index: -1,
-		component: application.defaultErrorBoundary
-	};
-}
-/** An owning view's Outlet contains its descendant boundary, not the owning component. */
-function RouteOutlet(props) {
-	const application = useApplication();
-	const frame = useAtomValue(committedFrameAtom);
-	const boundary = frame === null ? null : selectBoundary(frame, application);
-	const scrollIntent = frame?.scrollIntent;
-	const revision = frame?.revision ?? 0;
-	const scrollDepth = boundary === null ? scrollIntent?.entryIndex : boundary.index + 1;
-	useLayoutEffect(() => {
-		if (scrollIntent === void 0 || scrollDepth !== props.index) return;
-		const applied = applyScroll(scrollIntent.target);
-		if (Result.isFailure(applied)) application.coordinator.publishEvent({
-			_tag: "FailureReported",
-			source: "navigation",
-			cause: Cause.die(applied.failure)
-		});
-	}, [
-		application,
-		props.index,
-		revision,
-		scrollDepth,
-		scrollIntent
-	]);
-	if (frame === null) return null;
-	const ownerIndex = props.index - 1;
-	const owner = frame.entries[ownerIndex];
-	const rendersFailure = boundary !== null && boundary.index === ownerIndex;
-	const ownerView = owner?.view;
-	const Boundary = boundary?.component;
-	return /* @__PURE__ */ jsx(RouteBoundary, {
-		index: ownerIndex < 0 ? void 0 : ownerIndex,
-		pattern: owner?.pattern,
-		revision: frame.revision,
-		boundary: rendersFailure ? void 0 : ownerIndex < 0 ? application.defaultErrorBoundary : ownerView?.descendantErrorBoundary,
-		reportFn: application.coordinator.reportRenderFailure,
-		children: rendersFailure && Boundary !== void 0 && frame.error !== null ? /* @__PURE__ */ jsx(Boundary, { error: projectRouteError(frame.error) }) : /* @__PURE__ */ jsx(EntryAtIndex, { index: props.index })
-	}, rendersFailure ? "failure" : "children");
-}
-/** Renders one successful position. Its own rendering failures propagate to an enclosing Outlet. */
-function EntryAtIndex(props) {
-	const frame = useAtomValue(committedFrameAtom);
-	const index = props.index;
-	const entry = frame?.entries[index];
-	const Outlet = useMemo(() => {
-		return function Outlet() {
-			return /* @__PURE__ */ jsx(RouteOutlet, { index: index + 1 });
-		};
-	}, [index]);
-	if (frame === null || entry === void 0) return null;
-	const view = entry.view;
-	if (view === void 0) return /* @__PURE__ */ jsx(RouteOutlet, { index: index + 1 });
-	return /* @__PURE__ */ jsx(MatchedView, {
-		entry,
-		frame,
-		index,
-		view,
-		Outlet
-	}, entry.pattern);
-}
-function MatchedView(props) {
-	const application = useApplication();
-	const [routeContext] = useState(() => {
-		return createRouteContext(props.index, props.entry);
-	});
-	const activation = props.entry.activation;
-	const viewProps = {
-		...routeContext,
-		Outlet: props.Outlet,
-		clientRuntime: activation === void 0 ? clientRuntime : activation.clientRuntime,
-		universalRuntime: activation === void 0 ? universalRuntime : activation.universalRuntime
-	};
-	const View = props.view.component;
-	return /* @__PURE__ */ jsx(RouteBoundary, {
-		index: props.index,
-		pattern: props.entry.pattern,
-		revision: props.frame.revision,
-		boundary: void 0,
-		reportFn: application.coordinator.reportRenderFailure,
-		children: /* @__PURE__ */ jsx(View, { ...viewProps })
-	});
-}
-/** The application boundary encloses every route. */
-function RootOutlet() {
-	return /* @__PURE__ */ jsx(RouteOutlet, { index: 0 });
-}
-//#endregion
-//#region src/client/react/application.tsx
-function makeClientApplication(options) {
-	let root;
-	function renderIntoRoot(rootElement, node) {
-		if (root === void 0) root = createRoot(rootElement);
-		root.render(node);
-	}
-	function Providers(props) {
-		return /* @__PURE__ */ jsx(RegistryContext.Provider, {
-			value: application.core.registry,
-			children: /* @__PURE__ */ jsx(ApplicationProvider, {
-				value: {
-					coordinator: application.coordinator,
-					defaultErrorBoundary: options.defaultErrorBoundary,
-					defaultLinkProps: options.defaultLinkProps
-				},
-				children: props.children
-			})
-		});
-	}
-	const application = createClientApplication({
-		options,
-		scheduleTaskFn: scheduleTask,
-		renderFn: (rootElement) => {
-			renderIntoRoot(rootElement, /* @__PURE__ */ jsx(Providers, { children: /* @__PURE__ */ jsx(RootOutlet, {}) }));
-		},
-		disposeRendererFn: () => {
-			const mounted = root;
-			root = void 0;
-			mounted?.unmount();
-		}
-	});
-	async function boot() {
-		const exit = await application.boot();
-		if (Exit.isSuccess(exit)) return exit;
-		application.core.publishEvent({
-			_tag: "FailureReported",
-			source: "navigation",
-			cause: exit.cause
-		});
-		const rendered = Result.try(() => {
-			const rootElement = document.getElementById(DOCUMENT_PROTOCOL.elementIds.root);
-			const Boundary = options.defaultErrorBoundary;
-			if (rootElement !== null && !application.checkDisposed()) renderIntoRoot(rootElement, /* @__PURE__ */ jsx(Providers, { children: /* @__PURE__ */ jsx(Boundary, { error: {
-				source: "boot",
-				cause: exit.cause,
-				status: 500,
-				clientMessage: Cause.hasInterruptsOnly(exit.cause) ? "The application stopped before it started." : "The application could not start."
-			} }) }));
-		});
-		if (Result.isFailure(rendered)) application.core.publishEvent({
-			_tag: "FailureReported",
-			source: "render",
-			cause: Cause.die(rendered.failure)
-		});
-		return exit;
-	}
-	return {
-		_tag: "ClientApplication",
-		boot,
-		dispose: () => application.dispose()
-	};
-}
-const ClientApplication = { make: makeClientApplication };
-//#endregion
-//#region src/client/react/hooks.ts
-/** Reads a projection; without a selector the value itself is the selection. */
-function useProjection(atom, selectFn) {
-	return useAtomValue(atom, selectFn === void 0 ? identity : selectFn);
-}
-/** Keeps the browser URL synchronized with one typed React target. */
-function useRouteSynchronization(input) {
-	const application = useApplication();
-	const committedHref = useAtomValue(routeStateAtom, (route) => Option.isSome(route) ? route.value.href : void 0);
-	const resolvedTarget = toHref(input);
-	const targetReference = useRef(resolvedTarget);
-	targetReference.current = resolvedTarget;
-	const targetIdentity = Result.isSuccess(resolvedTarget) ? `success\0${resolvedTarget.success}` : `failure\0${input.pattern}\0${resolvedTarget.failure.message}`;
-	const enabled = input.enabled;
-	const debounceDelay = input.debounceDelay;
-	const replace = input.replace;
-	const scrollToTop = input.scrollToTop;
-	const scrollToFragment = input.scrollToFragment;
-	const skipWorkIndicator = input.skipWorkIndicator;
-	useEffect(() => {
-		if (enabled === false) return;
-		const fiber = application.coordinator.fork(Effect.ignore(Effect.flatMap(readSynchronizationTarget({
-			coordinator: application.coordinator,
-			href: targetReference.current,
-			options: {
-				...replace === void 0 ? {} : { replace },
-				...scrollToTop === void 0 ? {} : { scrollToTop },
-				...scrollToFragment === void 0 ? {} : { scrollToFragment },
-				...skipWorkIndicator === void 0 ? {} : { skipWorkIndicator }
-			}
-		}), (target) => {
-			return runSynchronizationTarget({
-				coordinator: application.coordinator,
-				target,
-				debounceDelay
-			});
-		})));
-		return () => fiber.interruptUnsafe();
-	}, [
-		application.coordinator,
-		committedHref,
-		debounceDelay,
-		enabled,
-		replace,
-		scrollToTop,
-		scrollToFragment,
-		skipWorkIndicator,
-		targetIdentity
-	]);
-}
-function useLoaderData(input, selectFn) {
-	return useProjection(getLoaderDataAtom(input), selectFn);
-}
-function useClientLoaderData(input, selectFn) {
-	return useProjection(getClientLoaderDataAtom(input), selectFn);
-}
-function useRouteMatch(input, selectFn) {
-	return useProjection(getRouteMatchAtom(input), selectFn);
-}
-function useRouteState(selectFn) {
-	return useProjection(routeStateAtom, selectFn);
-}
-function useNavigationState(selectFn) {
-	return useProjection(navigationStateAtom, selectFn);
-}
-function useRevalidationState(selectFn) {
-	return useProjection(revalidationStateAtom, selectFn);
-}
-function useWorkState(selectFn) {
-	return useProjection(workStateAtom, selectFn);
-}
-function useBuildMismatch(selectFn) {
-	return useProjection(buildMismatchAtom, selectFn);
-}
-//#endregion
-//#region src/client/react/link.tsx
-const NO_LINK_STATE = Atom.make({
-	active: {
-		exact: false,
-		ancestor: false
-	},
-	pending: {
-		exact: false,
-		ancestor: false
-	}
-});
-const ATTRIBUTES = DOCUMENT_PROTOCOL.attributes;
-/** The active and pending facts of a target under its match rules; an invalid target follows the applicable route boundary. */
-function useLinkState(input) {
-	const href = toHref(input);
-	if (Result.isFailure(href)) throw href.failure;
-	return useAtomValue(getLinkStateAtomFor({
-		href: href.success,
-		pattern: input.pattern,
-		rules: input.matchRules
-	}));
-}
-function LinkComponent(rawProps) {
-	const application = useApplication();
-	const props = {
-		...application.defaultLinkProps,
-		...rawProps
-	};
-	const { href: _href, pattern, params: _params, splatValues: _splatValues, input: _input, hash: _hash, prefetch, prefetchDelayMs, visitOnPointerDown, matchRules, replace, scrollToTop, scrollToFragment, historyState, skipWorkIndicator, children, ...anchorProps } = props;
-	const resolved = toHref(props);
-	if (Result.isFailure(resolved)) throw resolved.failure;
-	const href = resolved.success;
-	const external = Result.map(Result.try(() => new URL(href, window.location.href)), (url) => {
-		return !/^https?:$/.test(url.protocol) || url.origin !== window.location.origin;
-	});
-	const isExternal = Result.getOrElse(external, () => true);
-	const state = useAtomValue(isExternal || matchRules?.skip === true ? NO_LINK_STATE : getLinkStateAtomFor({
-		href,
-		pattern,
-		rules: matchRules
-	}));
-	const wantsPrefetch = prefetch === "intent" && !isExternal;
-	const intent = useMemo(() => {
-		return createLinkIntent({
-			coordinator: application.coordinator,
-			getHrefFn: () => href,
-			skipWorkIndicator: skipWorkIndicator === true
-		});
-	}, [
-		application.coordinator,
-		href,
-		skipWorkIndicator
-	]);
-	useEffect(() => () => intent.reset(), [intent]);
-	/** Whether the browser would handle this activation itself. */
-	function leavesToBrowser(event) {
-		return isExternal || event.defaultPrevented || anchorProps.download !== void 0 || !allowsInterception(event, anchorProps.target);
-	}
-	function navigateToLinkHref() {
-		application.coordinator.fork(Effect.ignore(application.coordinator.navigation.navigate(href, {
-			...replace === void 0 ? {} : { replace },
-			...scrollToTop === void 0 ? {} : { scrollToTop },
-			...scrollToFragment === void 0 ? {} : { scrollToFragment },
-			...historyState === void 0 ? {} : { historyState },
-			...skipWorkIndicator === void 0 ? {} : { skipWorkIndicator }
-		})));
-	}
-	function handleClick(event) {
-		anchorProps.onClick?.(event);
-		if (leavesToBrowser(event)) return;
-		event.preventDefault();
-		navigateToLinkHref();
-	}
-	function handlePointerDown(event) {
-		anchorProps.onPointerDown?.(event);
-		if (visitOnPointerDown !== true || event.pointerType !== "mouse" && event.pointerType !== "pen" || leavesToBrowser(event)) return;
-		event.preventDefault();
-		event.currentTarget.addEventListener("click", (click) => click.preventDefault(), { once: true });
-		navigateToLinkHref();
-	}
-	const attributes = {};
-	if (!isExternal && matchRules?.skip !== true) {
-		if (state.active.exact) {
-			attributes[ATTRIBUTES.linkActiveExact] = "";
-			attributes["aria-current"] = anchorProps["aria-current"] === void 0 ? "page" : anchorProps["aria-current"];
-		}
-		if (state.active.ancestor) attributes[ATTRIBUTES.linkActiveAncestor] = "";
-		if (state.pending.exact) attributes[ATTRIBUTES.linkPendingExact] = "";
-		if (state.pending.ancestor) attributes[ATTRIBUTES.linkPendingAncestor] = "";
-	}
-	return /* @__PURE__ */ jsx("a", {
-		...anchorProps,
-		...attributes,
-		href,
-		onClick: handleClick,
-		onPointerDown: handlePointerDown,
-		onPointerEnter: (event) => {
-			if (wantsPrefetch) intent.begin("pointer", prefetchDelayMs);
-			anchorProps.onPointerEnter?.(event);
-		},
-		onPointerLeave: (event) => {
-			if (wantsPrefetch) intent.end("pointer");
-			anchorProps.onPointerLeave?.(event);
-		},
-		onFocus: (event) => {
-			if (wantsPrefetch) intent.begin("focus", prefetchDelayMs);
-			anchorProps.onFocus?.(event);
-		},
-		onBlur: (event) => {
-			if (wantsPrefetch) intent.end("focus");
-			anchorProps.onBlur?.(event);
-		},
-		onTouchCancel: (event) => {
-			if (wantsPrefetch) intent.reset();
-			anchorProps.onTouchCancel?.(event);
-		},
-		children
-	});
-}
-const Link = memo(LinkComponent);
-//#endregion
-export { ClientApplication, Link, UiView, useBuildMismatch, useClientLoaderData, useLinkState, useLoaderData, useNavigationState, useRevalidationState, useRouteMatch, useRouteState, useRouteSynchronization, useWorkState };