@sjcx/vorma 0.0.0-pre.0

package/dist/materialize-DZ7VSLFk.js

@@ -0,0 +1,739 @@
+import { _ as DOCUMENT_PROTOCOL, h as BROWSER_STATE_PROTOCOL } from "./value-transport-Bst4Hk-n.js";
+import { B as RevalidationError, D as projectRouteState, L as NavigationError } from "./route-context-CtY_9U_W.js";
+import { Cause, Deferred, Effect, Exit, Option, Result, Scope } from "effect";
+import { AsyncResult } from "effect/unstable/reactivity";
+//#region src/client/head.ts
+const comments = DOCUMENT_PROTOCOL.headComments;
+const REGIONS = [
+	{
+		selectFn: (s) => s.title === void 0 ? [] : [s.title],
+		start: comments.title,
+		end: comments.meta
+	},
+	{
+		selectFn: (s) => s.meta,
+		start: comments.meta,
+		end: comments.rest
+	},
+	{
+		selectFn: (s) => s.rest,
+		start: comments.rest,
+		end: comments.assets
+	}
+];
+function applyHead(sections) {
+	for (const region of REGIONS) {
+		const applied = reconcileRegion(region.selectFn(sections), region);
+		if (Result.isFailure(applied)) return applied;
+	}
+	return Result.succeed(void 0);
+}
+/** Reads the server-rendered head state from the three managed regions. */
+function readDocumentHead() {
+	const sections = [];
+	for (const region of REGIONS) {
+		const boundary = findBoundary({
+			startMarker: region.start,
+			endMarker: region.end
+		});
+		if (boundary === null) return failHeadReconciliation(`Missing head boundary comments ${region.start}`);
+		const elements = [];
+		for (let node = boundary.start.nextSibling; node !== null && node !== boundary.end; node = node.nextSibling) if (node.nodeType === Node.ELEMENT_NODE) elements.push(readHeadElement(node));
+		sections.push(elements);
+	}
+	const title = sections[0] ?? [];
+	if (title.length > 1) return failHeadReconciliation("The managed title region contains more than one element");
+	return Result.succeed({
+		title: title[0],
+		meta: sections[1] ?? [],
+		rest: sections[2] ?? []
+	});
+}
+function failHeadReconciliation(message) {
+	return Result.fail({
+		_tag: "HeadReconciliationError",
+		message
+	});
+}
+function findBoundary(input) {
+	let opening;
+	for (const node of document.head.childNodes) {
+		if (node.nodeType !== Node.COMMENT_NODE) continue;
+		const value = node.nodeValue?.trim();
+		if (value === input.startMarker) opening = node;
+		else if (value === input.endMarker && opening !== void 0) return {
+			start: opening,
+			end: node
+		};
+	}
+	return null;
+}
+function createHeadElement(wire) {
+	const element = document.createElement(wire.tag);
+	if (wire.attrs !== void 0) for (const [name, value] of Object.entries(wire.attrs)) element.setAttribute(name, value === true ? "" : value);
+	if (wire.html !== void 0) element.innerHTML = wire.html;
+	return element;
+}
+function readHeadElement(element) {
+	const attributes = Object.fromEntries([...element.attributes].map((attribute) => {
+		return [attribute.name, attribute.value];
+	}));
+	return {
+		tag: element.localName,
+		...Object.keys(attributes).length === 0 ? {} : { attrs: attributes },
+		...element.innerHTML === "" ? {} : { html: element.innerHTML }
+	};
+}
+function computeFingerprint(element) {
+	const attributes = [];
+	for (const attribute of element.attributes) attributes.push([attribute.name, attribute.value]);
+	attributes.sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+	return JSON.stringify([
+		element.tagName.toUpperCase(),
+		attributes,
+		element.innerHTML
+	]);
+}
+function reconcileRegion(elements, region) {
+	const boundary = findBoundary({
+		startMarker: region.start,
+		endMarker: region.end
+	});
+	if (boundary === null) return elements.length === 0 ? Result.succeed(void 0) : failHeadReconciliation(`Missing head boundary comments ${region.start}`);
+	const parent = boundary.end.parentNode;
+	if (parent === null) return failHeadReconciliation(`Detached head boundary ${region.start}`);
+	return Result.try({
+		try: () => {
+			const current = [];
+			for (let node = boundary.start.nextSibling; node !== null && node !== boundary.end; node = node.nextSibling) if (node.nodeType === Node.ELEMENT_NODE) current.push(node);
+			const currentByFingerprint = /* @__PURE__ */ new Map();
+			for (const element of current) {
+				const key = computeFingerprint(element);
+				const list = currentByFingerprint.get(key);
+				if (list === void 0) currentByFingerprint.set(key, [element]);
+				else list.push(element);
+			}
+			const desired = /* @__PURE__ */ new Map();
+			for (const wire of elements) {
+				const element = createHeadElement(wire);
+				const key = computeFingerprint(element);
+				desired.delete(key);
+				desired.set(key, element);
+			}
+			const used = /* @__PURE__ */ new Set();
+			const final = [];
+			for (const [key, fresh] of desired) {
+				const match = currentByFingerprint.get(key)?.find((element) => !used.has(element));
+				if (match === void 0) final.push(fresh);
+				else {
+					used.add(match);
+					final.push(match);
+				}
+			}
+			for (let node = boundary.start.nextSibling; node !== null && node !== boundary.end;) {
+				const next = node.nextSibling;
+				if (node.nodeType !== Node.ELEMENT_NODE || !used.has(node)) parent.removeChild(node);
+				node = next;
+			}
+			let cursor = boundary.start;
+			for (const element of final) {
+				if (cursor.nextSibling !== element) parent.insertBefore(element, cursor.nextSibling);
+				cursor = element;
+			}
+		},
+		catch: (error) => {
+			return {
+				_tag: "HeadReconciliationError",
+				message: error instanceof Error ? error.message : String(error)
+			};
+		}
+	});
+}
+//#endregion
+//#region src/client/history.ts
+const USER_STATE_FIELD = BROWSER_STATE_PROTOCOL.historyStateFields.userState;
+const ENTRY_KEY_FIELD = BROWSER_STATE_PROTOCOL.historyStateFields.entryKey;
+const SCROLL_STORAGE_KEY = BROWSER_STATE_PROTOCOL.scrollStorageKey;
+/** The history state as a record of fields; a state that is not an object holds no fields. */
+function readStateRecord(value) {
+	return typeof value === "object" && value !== null ? value : {};
+}
+function createEntryKey() {
+	return Math.random().toString(36).slice(2);
+}
+/** Reads native user state and Vorma's entry key without imposing a user-data codec. */
+function readBrowserPosition() {
+	return Result.try({
+		try: () => {
+			const state = readStateRecord(window.history.state);
+			const key = state[ENTRY_KEY_FIELD];
+			return {
+				href: window.location.href,
+				userState: state[USER_STATE_FIELD],
+				key: typeof key === "string" ? key : void 0
+			};
+		},
+		catch: (cause) => {
+			return {
+				_tag: "HistoryStateError",
+				message: "The browser refused the history read",
+				cause
+			};
+		}
+	});
+}
+/** Writes a new or replaced history entry and returns the position it produced. */
+function writeBrowserPosition(input) {
+	const next = {
+		[USER_STATE_FIELD]: input.userState,
+		[ENTRY_KEY_FIELD]: input.key
+	};
+	return Result.flatMap(Result.try({
+		try: () => {
+			if (input.replace) window.history.replaceState({
+				...readStateRecord(window.history.state),
+				...next
+			}, "", input.href);
+			else window.history.pushState(next, "", input.href);
+		},
+		catch: (cause) => {
+			return {
+				_tag: "HistoryStateError",
+				message: "The browser refused the history write",
+				cause
+			};
+		}
+	}), readBrowserPosition);
+}
+/** One remembered position when the stored entry has that shape. */
+function readRememberedEntry(entry) {
+	if (!Array.isArray(entry)) return [];
+	const key = entry[0];
+	const position = entry[1];
+	if (typeof key !== "string" || typeof position !== "object" || position === null || !("x" in position) || !("y" in position) || typeof position.x !== "number" || typeof position.y !== "number" || !Number.isFinite(position.x) || !Number.isFinite(position.y)) return [];
+	return [[key, {
+		x: position.x,
+		y: position.y
+	}]];
+}
+/** The remembered positions; storage that is absent, unreadable, or not in this shape remembers nothing. */
+function readRemembered() {
+	const stored = Result.try(() => sessionStorage.getItem(SCROLL_STORAGE_KEY));
+	if (Result.isFailure(stored) || stored.success === null) return [];
+	const text = stored.success;
+	const parsed = Result.try(() => JSON.parse(text));
+	if (Result.isFailure(parsed) || !Array.isArray(parsed.success)) return [];
+	return parsed.success.flatMap(readRememberedEntry);
+}
+/** Remembers the scroll position of the entry `key` names. */
+function rememberScroll(key, scroll) {
+	const entries = readRemembered().filter(([other]) => other !== key);
+	entries.push([key, scroll]);
+	Result.try(() => {
+		sessionStorage.setItem(SCROLL_STORAGE_KEY, JSON.stringify(entries.slice(-50)));
+	});
+}
+function recallScroll(key) {
+	return readRemembered().find(([other]) => other === key)?.[1];
+}
+//#endregion
+//#region src/client/freshness.ts
+const IDLE_ATTEMPT = {
+	coveredSequence: null,
+	phase: "idle",
+	skipWorkIndicator: false,
+	waiters: [],
+	latest: AsyncResult.initial()
+};
+function settleWaiters(waiters, outcome) {
+	return waiters.map((waiter) => {
+		return () => Deferred.doneUnsafe(waiter, outcome);
+	});
+}
+/**
+* Registers a demand after `sequence` from an authorized trigger; merges into
+* an outstanding demand. The epoch advances with it, and every query
+* computation that evaluates for the new epoch expects itself through
+* `expectQueries`; expectations from before the merge are dropped, because a
+* retained query that no consumer holds does not evaluate and cannot answer.
+*/
+function registerDemand(facts, input) {
+	const running = facts.attempt.phase === "running";
+	const previous = facts.demand === null ? {
+		skipWorkIndicator: input.skipWorkIndicator,
+		waiters: []
+	} : facts.demand;
+	return {
+		facts: {
+			demand: {
+				afterSequence: input.sequence,
+				skipWorkIndicator: previous.skipWorkIndicator && input.skipWorkIndicator,
+				renewed: running,
+				expectedQueries: /* @__PURE__ */ new Set(),
+				acknowledgedQueries: /* @__PURE__ */ new Map(),
+				routeReadSequence: null,
+				waiters: input.waiter === void 0 ? previous.waiters : [...previous.waiters, input.waiter]
+			},
+			epoch: facts.epoch + 1,
+			attempt: running ? facts.attempt : {
+				...facts.attempt,
+				phase: "idle",
+				latest: AsyncResult.waiting(facts.attempt.latest)
+			}
+		},
+		complete: [],
+		startAttempt: !running
+	};
+}
+/** An attempt starts for the outstanding demand, recording the sequence it covers and taking the demand's waiters. */
+function startAttempt(facts) {
+	const demand = facts.demand;
+	if (demand === null) return facts;
+	return {
+		...facts,
+		demand: {
+			...demand,
+			waiters: [],
+			renewed: false
+		},
+		attempt: {
+			coveredSequence: demand.afterSequence,
+			phase: "running",
+			skipWorkIndicator: demand.skipWorkIndicator,
+			waiters: [...facts.attempt.waiters, ...demand.waiters],
+			latest: AsyncResult.waiting(facts.attempt.latest)
+		}
+	};
+}
+/** The running attempt failed and the application's schedule will run another; its waiters wait on. */
+function holdAttemptForRetry(facts, error) {
+	return {
+		facts: {
+			...facts,
+			attempt: {
+				...facts.attempt,
+				phase: "retrying",
+				latest: AsyncResult.fail(error)
+			}
+		},
+		complete: [],
+		startAttempt: false
+	};
+}
+/**
+* Resolves the demand once its route read committed and every expected
+* query has acknowledged. A query leaves the expected set when its
+* computation is released without a successor, so a query that unmounted is
+* not waited for.
+*/
+function completeIfSatisfied(facts, demand) {
+	const outstanding = [...demand.expectedQueries].some((id) => {
+		const acknowledged = demand.acknowledgedQueries.get(id);
+		return !(acknowledged !== void 0 && acknowledged > demand.afterSequence);
+	});
+	if (demand.routeReadSequence === null || outstanding) return {
+		facts: {
+			...facts,
+			demand
+		},
+		complete: [],
+		startAttempt: false
+	};
+	const result = { _tag: "Refreshed" };
+	return {
+		facts: {
+			...facts,
+			demand: null,
+			attempt: {
+				...IDLE_ATTEMPT,
+				latest: AsyncResult.success(result)
+			}
+		},
+		complete: settleWaiters([...facts.attempt.waiters, ...demand.waiters], Effect.succeed(result)),
+		startAttempt: false
+	};
+}
+/** A read with `sequence` committed without a route error. */
+function satisfyDemand(facts, input) {
+	const demand = facts.demand;
+	const latest = facts.attempt.latest;
+	if (demand === null) return {
+		facts: {
+			...facts,
+			attempt: {
+				...IDLE_ATTEMPT,
+				latest
+			}
+		},
+		complete: [],
+		startAttempt: false
+	};
+	if (input.sequence <= demand.afterSequence) return {
+		facts: {
+			...facts,
+			demand: {
+				...demand,
+				waiters: [...facts.attempt.waiters, ...demand.waiters]
+			},
+			attempt: {
+				...IDLE_ATTEMPT,
+				latest
+			}
+		},
+		complete: [],
+		startAttempt: true
+	};
+	return completeIfSatisfied(facts, {
+		...demand,
+		routeReadSequence: input.sequence
+	});
+}
+/** An expected query read settled: a qualifying success acknowledges; a failure of a qualifying read fails the attempt. */
+function acknowledgeQuery(facts, input) {
+	const demand = facts.demand;
+	if (demand === null || !demand.expectedQueries.has(input.id) || input.sequence !== void 0 && input.sequence <= demand.afterSequence) return {
+		facts,
+		complete: [],
+		startAttempt: false
+	};
+	if (!input.success || input.sequence === void 0) return failAttempt(facts, makeRevalidationError("query", `Query ${input.id} failed to read`));
+	return completeIfSatisfied(facts, {
+		...demand,
+		acknowledgedQueries: new Map([...demand.acknowledgedQueries, [input.id, input.sequence]])
+	});
+}
+/** Query computations evaluated for the outstanding demand's epoch; each must acknowledge or be released. */
+function expectQueries(facts, ids) {
+	const demand = facts.demand;
+	if (demand === null || ids.size === 0) return {
+		facts,
+		complete: [],
+		startAttempt: false
+	};
+	return {
+		facts: {
+			...facts,
+			demand: {
+				...demand,
+				expectedQueries: /* @__PURE__ */ new Set([...demand.expectedQueries, ...ids])
+			}
+		},
+		complete: [],
+		startAttempt: false
+	};
+}
+/** A query's computation was released with no successor; a demand waiting only on it completes. */
+function releaseQuery(facts, id) {
+	const demand = facts.demand;
+	if (demand === null || !demand.expectedQueries.has(id)) return {
+		facts,
+		complete: [],
+		startAttempt: false
+	};
+	const expectedQueries = new Set(demand.expectedQueries);
+	expectedQueries.delete(id);
+	return completeIfSatisfied(facts, {
+		...demand,
+		expectedQueries
+	});
+}
+/** The running attempt failed. Its captured batch fails; a newer demand starts another attempt. */
+function failAttempt(facts, error) {
+	const { demand, attempt } = facts;
+	const again = demand !== null && (demand.renewed || attempt.coveredSequence !== null && demand.afterSequence > attempt.coveredSequence);
+	return {
+		facts: {
+			...facts,
+			demand,
+			attempt: {
+				...attempt,
+				phase: demand === null || again ? "idle" : "failed",
+				waiters: [],
+				latest: AsyncResult.fail(error)
+			}
+		},
+		complete: settleWaiters(attempt.waiters, Effect.fail(error)),
+		startAttempt: again
+	};
+}
+/** The navigation that was running the attempt ended without settling it; the attempt's waiters return to the demand. */
+function abandonAttempt(facts) {
+	const { demand, attempt } = facts;
+	return {
+		facts: {
+			...facts,
+			demand: demand === null ? null : {
+				...demand,
+				waiters: [...attempt.waiters, ...demand.waiters]
+			},
+			attempt: {
+				...attempt,
+				phase: "idle",
+				waiters: []
+			}
+		},
+		complete: [],
+		startAttempt: demand !== null
+	};
+}
+/** Whether a new attempt may start: a demand exists, no attempt is running, and no failed attempt already covered the demand's sequence. */
+function canStartAttempt(facts) {
+	const { demand, attempt } = facts;
+	if (demand === null || attempt.phase === "running") return false;
+	return !(attempt.phase === "failed" && attempt.coveredSequence !== null && demand.afterSequence <= attempt.coveredSequence);
+}
+/** Retires the demand and settles every waiter with the given error. */
+function retireDemand(facts, error) {
+	return {
+		facts: {
+			...facts,
+			demand: null,
+			attempt: {
+				...IDLE_ATTEMPT,
+				latest: AsyncResult.fail(error)
+			}
+		},
+		complete: settleWaiters([...facts.attempt.waiters, ...facts.demand === null ? [] : facts.demand.waiters], Effect.fail(error)),
+		startAttempt: false
+	};
+}
+function makeRevalidationError(reason, cause) {
+	return new RevalidationError({
+		reason,
+		cause: Cause.isCause(cause) ? cause : Cause.fail(cause)
+	});
+}
+//#endregion
+//#region src/client/document-recovery.ts
+/** Loads the browser's current URL as a document after client navigation cannot complete. */
+function reloadDocument(core, cause) {
+	const refresh = retireDemand(core.getState().freshness, makeRevalidationError("route", cause));
+	core.updateState((state) => {
+		return {
+			...state,
+			freshness: refresh.facts
+		};
+	});
+	for (const complete of refresh.complete) complete();
+	core.publishEvent({
+		_tag: "FailureReported",
+		source: "navigation",
+		cause
+	});
+	window.location.reload();
+}
+//#endregion
+//#region src/client/stylesheets.ts
+const BUNDLE_ATTRIBUTE = DOCUMENT_PROTOCOL.attributes.cssBundle;
+const PRELOAD_ATTRIBUTE = DOCUMENT_PROTOCOL.attributes.cssPreload;
+const preparations = /* @__PURE__ */ new WeakMap();
+function findLink(input) {
+	for (const link of document.head.querySelectorAll("link")) if (link.getAttribute(input.attribute) === input.value) return link;
+	return null;
+}
+/** Reads the stylesheet bundles that the initial document applied. */
+function readDocumentStylesheets() {
+	return [...document.head.querySelectorAll("link")].flatMap((link) => {
+		const bundle = link.getAttribute(BUNDLE_ATTRIBUTE);
+		return bundle === null ? [] : [bundle];
+	});
+}
+/** Starts managed CSS preloads and waits for every load or error without applying destination styles. */
+function prepareStylesheets(bundles) {
+	return Effect.forEach(new Set(bundles), (path) => {
+		return Effect.gen(function* () {
+			const preparation = yield* acquireStylesheet(path);
+			if (preparation !== void 0) yield* Deferred.await(preparation.settled);
+		});
+	}, {
+		concurrency: "unbounded",
+		discard: true
+	});
+}
+function acquireStylesheet(path) {
+	return Effect.acquireRelease(Effect.sync(() => {
+		if (findLink({
+			attribute: BUNDLE_ATTRIBUTE,
+			value: path
+		}) !== null) return;
+		const existing = findLink({
+			attribute: PRELOAD_ATTRIBUTE,
+			value: path
+		});
+		const previous = existing === null ? void 0 : preparations.get(existing);
+		if (previous !== void 0) {
+			previous.owners += 1;
+			return previous;
+		}
+		existing?.remove();
+		const link = document.createElement("link");
+		link.rel = "preload";
+		link.as = "style";
+		link.href = path;
+		link.setAttribute(PRELOAD_ATTRIBUTE, path);
+		function dispose() {
+			link.removeEventListener("load", settle);
+			link.removeEventListener("error", settle);
+		}
+		const preparation = {
+			link,
+			settled: Deferred.makeUnsafe(),
+			owners: 1,
+			dispose
+		};
+		preparations.set(link, preparation);
+		function settle() {
+			dispose();
+			Deferred.doneUnsafe(preparation.settled, Effect.void);
+		}
+		link.addEventListener("load", settle);
+		link.addEventListener("error", settle);
+		document.head.append(link);
+		return preparation;
+	}), (preparation) => {
+		return Effect.sync(() => {
+			if (preparation === void 0) return;
+			preparation.owners -= 1;
+			if (preparation.owners === 0 && !preparation.link.hasAttribute(BUNDLE_ATTRIBUTE)) {
+				preparation.dispose();
+				preparation.link.remove();
+			}
+		});
+	});
+}
+/** Publishes managed styles after their preload attempts have settled. */
+function applyStylesheets(bundles) {
+	for (const path of new Set(bundles)) {
+		const prepared = findLink({
+			attribute: PRELOAD_ATTRIBUTE,
+			value: path
+		});
+		if (prepared === null) continue;
+		prepared.removeAttribute(PRELOAD_ATTRIBUTE);
+		prepared.setAttribute(BUNDLE_ATTRIBUTE, path);
+		prepared.removeAttribute("as");
+		document.head.append(prepared);
+		prepared.rel = "stylesheet";
+	}
+}
+//#endregion
+//#region src/client/commit.ts
+/** Accepts a prepared route as the committed frame. Callers hold the uninterruptible region. */
+function commitFrame(core, input) {
+	const position = input.position.kind === "adopt" ? Result.succeed(input.position.position) : writeBrowserPosition(input.position);
+	if (Result.isFailure(position)) return Result.fail(new NavigationError({
+		stage: "transition",
+		cause: Cause.fail(position.failure)
+	}));
+	if (input.documentUpdate === "apply") {
+		const applied = Result.flatMap(applyHead(input.head), () => {
+			return Result.try(() => applyStylesheets(input.cssBundles));
+		});
+		if (Result.isFailure(applied)) {
+			const cause = Cause.fail(applied.failure);
+			reloadDocument(core, cause);
+			return Result.fail(new NavigationError({
+				stage: "publication",
+				cause
+			}));
+		}
+	}
+	const previous = core.getState().frame;
+	const frame = {
+		href: position.success.href,
+		historyState: position.success.userState,
+		key: position.success.key,
+		clientBuildId: core.getClientBuildId(),
+		entries: input.entries,
+		error: input.error,
+		head: input.head,
+		cssBundles: input.cssBundles,
+		scope: input.scope,
+		revision: previous === null ? 1 : previous.revision + 1,
+		committedAt: input.committedAt === void 0 ? Date.now() : input.committedAt,
+		scrollIntent: input.scrollIntent
+	};
+	core.updateState((state) => {
+		return {
+			...state,
+			frame
+		};
+	});
+	if (previous !== null && previous.scope !== frame.scope) core.forkFiber(Scope.close(previous.scope, Exit.void));
+	core.publishEvent({
+		_tag: "RouteCommitted",
+		previous: previous === null ? Option.none() : Option.some(projectRouteState(previous)),
+		current: projectRouteState(frame),
+		reason: input.reason
+	});
+	return Result.succeed(frame);
+}
+//#endregion
+//#region src/client/materialize.ts
+let developmentModules;
+/** Native imports cache production modules; development retains accepted replacement namespaces. */
+function enableDevelopmentModules() {
+	const modules = /* @__PURE__ */ new Map();
+	const replacements = /* @__PURE__ */ new Map();
+	developmentModules = modules;
+	return {
+		replaceFn(input) {
+			const url = new URL(input.url, window.location.href);
+			url.searchParams.delete("t");
+			const previous = modules.get(url.href);
+			modules.set(url.href, input.module);
+			for (const [name, value] of Object.entries(previous ?? {})) {
+				for (const [old, replacement] of replacements) if (replacement === value) replacements.set(old, input.module[name]);
+				replacements.set(value, input.module[name]);
+			}
+			return replacements;
+		},
+		closeFn() {
+			if (developmentModules === modules) developmentModules = void 0;
+		}
+	};
+}
+function loadModule(url) {
+	return Effect.tryPromise({
+		try: async () => {
+			const key = developmentModules === void 0 ? url : new URL(url, window.location.href).href;
+			const existing = developmentModules?.get(key);
+			if (existing !== void 0) return existing;
+			const module = await import(
+				/* @vite-ignore */
+				url
+);
+			if (developmentModules !== void 0 && !developmentModules.has(key)) developmentModules.set(key, module);
+			return developmentModules?.get(key) ?? module;
+		},
+		catch: (cause) => {
+			return {
+				_tag: "ModuleLoadError",
+				url,
+				cause
+			};
+		}
+	});
+}
+/** Loads one position independently, retaining its decoded facts and selected view. */
+function materializeRoute(route) {
+	const reference = route.moduleReference;
+	return reference === null ? Effect.succeed({
+		...route,
+		definition: void 0
+	}) : Effect.flatMap(loadModule(reference.url), (module) => {
+		const firstName = reference.exportNames[0];
+		const definition = firstName === void 0 ? void 0 : module[firstName];
+		if (definition === void 0 || reference.exportNames.some((name) => module[name] !== definition)) return Effect.fail({
+			_tag: "ModuleLoadError",
+			url: reference.url,
+			cause: "A route must select one view declaration value; aliases must reference that same value"
+		});
+		return Effect.succeed({
+			...route,
+			definition
+		});
+	});
+}
+//#endregion
+export { readDocumentHead as C, rememberScroll as S, satisfyDemand as _, readDocumentStylesheets as a, readBrowserPosition as b, acknowledgeQuery as c, failAttempt as d, holdAttemptForRetry as f, retireDemand as g, releaseQuery as h, prepareStylesheets as i, canStartAttempt as l, registerDemand as m, materializeRoute as n, reloadDocument as o, makeRevalidationError as p, commitFrame as r, abandonAttempt as s, enableDevelopmentModules as t, expectQueries as u, startAttempt as v, recallScroll as x, createEntryKey as y };