ignotum 0.0.13 → 0.0.15

package/dist/runtime/bootstrap-BISQSn_O.js

@@ -0,0 +1,916 @@
+import { m as upgrade, p as initial } from "./id--1m0NuUL.js";
+import { _ as matchPattern, f as useRouterSnapshot, g as matchDirectory, h as compilePatterns, i as RouterContext, m as parseLocation, p as decodeRouteInputs, y as mountManagedSync } from "./router-BSBI1oN1.js";
+import { i as LayoutMetadata, l as appDefinitionLimits, o as StaticMetadata, u as ExecutionSelection } from "./routes-Ce8TVP-T.js";
+import { Deferred, Effect, Predicate, Schema } from "effect";
+import { useErrorBoundary, useLayoutEffect, useState } from "preact/hooks";
+import { Fragment, createElement, render } from "preact";
+//#region ../shared/dist/routing/metadata.js
+const MetadataInput = Schema.Struct({
+	applicationName: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256)),
+	layouts: Schema.Array(LayoutMetadata).check(Schema.isMaxLength(appDefinitionLimits.layouts)),
+	page: Schema.optional(StaticMetadata),
+	outcome: Schema.Literals([
+		"Matched",
+		"Invalid",
+		"NotFound"
+	])
+}).annotate({ parseOptions: { onExcessProperty: "error" } });
+var InvalidMetadata = class extends Schema.TaggedError()("InvalidMetadata", { message: Schema.String }) {};
+/**
+* Layouts run from outermost to nearest. Values remain plain text: document writers must escape
+* HTML text and attributes, and browser writers must use textContent and setAttribute.
+* `remove` names managed tags absent from this result, including after navigation.
+*/
+const resolveMetadata = Effect.fn("Routing.resolveMetadata")(function* (input) {
+	const { applicationName, layouts, page, outcome } = yield* Schema.decodeEffect(MetadataInput)(input).pipe(Effect.mapError(() => InvalidMetadata.make({ message: "Static metadata is invalid." })));
+	let title = applicationName;
+	let template;
+	let description;
+	let robots;
+	for (const layout of layouts) {
+		title = layout.title ?? title;
+		template = layout.titleTemplate ?? template;
+		description = layout.meta?.description ?? description;
+		robots = layout.meta?.robots ?? robots;
+	}
+	const matchedPage = outcome === "NotFound" ? void 0 : page;
+	const pageTitle = matchedPage?.title;
+	if (pageTitle !== void 0) title = template === void 0 ? pageTitle : template.replace("%s", () => pageTitle);
+	description = matchedPage?.meta?.description ?? description;
+	robots = outcome === "Matched" ? matchedPage?.meta?.robots ?? robots : "noindex";
+	const remove = [];
+	if (description === void 0) remove.push("description");
+	if (robots === void 0) remove.push("robots");
+	return {
+		title,
+		meta: {
+			description,
+			robots
+		},
+		remove
+	};
+});
+//#endregion
+//#region ../shared/dist/routing.js
+const reservedSegments = (segments) => segments[0] === "_ignotum";
+/** Accept a root-relative location before a URL parser can discard invalid dot segments. */
+const matchLocation = Effect.fn("Routing.matchLocation")(function* (patterns, input) {
+	const parsed = yield* parseLocation(input).pipe(Effect.result);
+	if (parsed._tag === "Failure") {
+		const error = parsed.failure;
+		const partial = error.partial;
+		const segments = partial?.segments ?? [];
+		const reserved = reservedSegments(segments);
+		const branch = partial?.pathComplete ? matchPattern(patterns, segments) : matchDirectory(patterns, segments);
+		return {
+			_tag: "Invalid",
+			status: 400,
+			route: !reserved && partial?.pathComplete ? branch.route : void 0,
+			layouts: reserved ? [] : branch.layouts,
+			reserved,
+			location: void 0,
+			issues: error.issues
+		};
+	}
+	const location = parsed.success;
+	const reserved = reservedSegments(location.segments);
+	const branch = matchPattern(patterns, location.segments);
+	if (reserved || branch.route === void 0) return {
+		_tag: "NotFound",
+		status: 404,
+		layouts: reserved ? [] : branch.layouts,
+		reserved,
+		location
+	};
+	const route = branch.route;
+	const decoded = yield* decodeRouteInputs(route, branch.params, location.search).pipe(Effect.result);
+	if (decoded._tag === "Failure") return {
+		_tag: "Invalid",
+		status: 400,
+		route,
+		layouts: branch.layouts,
+		reserved: false,
+		location,
+		issues: decoded.failure.issues
+	};
+	return {
+		_tag: "Matched",
+		status: 200,
+		route,
+		layouts: branch.layouts,
+		reserved: false,
+		location,
+		...decoded.success
+	};
+});
+//#endregion
+//#region src/client/router-history.ts
+const HistoryEntryV1 = Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	key: Schema.String
+});
+const HistoryEntryV2 = Schema.Struct({
+	formatVersion: Schema.Literal(2),
+	key: Schema.String,
+	index: Schema.NullOr(Schema.Int)
+});
+const HistoryEntry = upgrade(initial(HistoryEntryV1), HistoryEntryV2, (old) => ({
+	formatVersion: 2,
+	key: old.key,
+	index: null
+}));
+const HistoryState = Schema.Struct({ __ignotumRouter: HistoryEntry });
+const StateObject = Schema.Record(Schema.String, Schema.Unknown);
+const hrefOf = (browser) => `${browser.location.pathname}${browser.location.search}${browser.location.hash}`;
+/** Serializes router corrections to native traversal without adding duplicate entries. */
+var RouterHistory = class {
+	browser;
+	onTraversal;
+	committed;
+	actual;
+	positions = /* @__PURE__ */ new Map();
+	seeking;
+	originalScrollRestoration;
+	direction = -1;
+	scrollPending = false;
+	expectedKey;
+	scroll = /* @__PURE__ */ new Map();
+	constructor(browser, onTraversal) {
+		this.browser = browser;
+		this.onTraversal = onTraversal;
+		const parsed = Schema.decodeUnknownOption(HistoryState)(browser.history.state);
+		const entry = parsed._tag === "Some" ? parsed.value.__ignotumRouter : void 0;
+		this.actual = this.committed = {
+			key: entry?.key ?? browser.crypto.randomUUID(),
+			index: entry?.index ?? 0,
+			href: hrefOf(browser)
+		};
+		this.write(this.actual, false);
+		this.originalScrollRestoration = browser.history.scrollRestoration;
+		browser.history.scrollRestoration = "manual";
+		browser.addEventListener("popstate", this.onPop);
+		browser.addEventListener("scroll", this.saveScroll);
+	}
+	write(position, push) {
+		const parsed = Schema.decodeUnknownOption(StateObject)(this.browser.history.state);
+		const owned = { __ignotumRouter: Schema.encodeSync(HistoryEntry)({
+			formatVersion: 2,
+			key: position.key,
+			index: position.index
+		}) };
+		const state = parsed._tag === "Some" ? {
+			...parsed.value,
+			...owned
+		} : owned;
+		if (push) this.browser.history.pushState(state, "", position.href);
+		else this.browser.history.replaceState(state, "", position.href);
+		this.positions.set(position.key, position.index);
+	}
+	saveScroll = () => {
+		if (this.scrollPending) return;
+		this.scroll.set(this.committed.key, {
+			x: this.browser.scrollX,
+			y: this.browser.scrollY
+		});
+	};
+	captureScroll() {
+		this.saveScroll();
+		this.scrollPending = true;
+		return this.scroll.get(this.committed.key) ?? {
+			x: this.browser.scrollX,
+			y: this.browser.scrollY
+		};
+	}
+	finishScroll() {
+		this.scrollPending = false;
+		this.saveScroll();
+	}
+	restoreSourceScroll() {
+		if (!this.scrollPending) return;
+		const saved = this.scroll.get(this.committed.key);
+		if (saved !== void 0) this.browser.scrollTo(saved.x, saved.y);
+		this.finishScroll();
+	}
+	onPop = () => {
+		const parsed = Schema.decodeUnknownOption(HistoryState)(this.browser.history.state);
+		const entry = parsed._tag === "Some" ? parsed.value.__ignotumRouter : void 0;
+		const key = entry?.key ?? this.browser.crypto.randomUUID();
+		const index = entry?.index ?? this.positions.get(key) ?? this.actual.index + this.direction;
+		this.actual = {
+			key,
+			index,
+			href: hrefOf(this.browser)
+		};
+		this.write(this.actual, false);
+		const expected = this.expectedKey;
+		this.expectedKey = void 0;
+		const seeking = this.seeking;
+		if (seeking !== void 0 && (expected === key || seeking.position.key === key)) {
+			this.advanceSeek();
+			return;
+		}
+		if (seeking !== void 0) {
+			this.seeking = void 0;
+			Effect.runSync(Deferred.succeed(seeking.done, false));
+		}
+		this.onTraversal(this.actual);
+	};
+	advanceSeek() {
+		const seeking = this.seeking;
+		if (seeking === void 0 || this.expectedKey !== void 0) return;
+		if (this.actual.key === seeking.position.key) {
+			this.seeking = void 0;
+			Effect.runSync(Deferred.succeed(seeking.done, true));
+		} else {
+			this.expectedKey = seeking.position.key;
+			this.browser.history.go(seeking.position.index - this.actual.index);
+		}
+	}
+	seek(position) {
+		if (this.seeking !== void 0) {
+			if (this.seeking.position.key === position.key) return Effect.runPromise(Deferred.await(this.seeking.done));
+			Effect.runSync(Deferred.succeed(this.seeking.done, false));
+		}
+		const done = Deferred.makeUnsafe();
+		this.seeking = {
+			position,
+			done
+		};
+		this.advanceSeek();
+		return Effect.runPromise(Deferred.await(done));
+	}
+	commit(position, kind) {
+		if (kind === "push" || kind === "replace") this.write(position, kind === "push");
+		this.actual = this.committed = position;
+	}
+	back = () => {
+		this.direction = -1;
+		this.browser.history.back();
+	};
+	forward = () => {
+		this.direction = 1;
+		this.browser.history.forward();
+	};
+	dispose() {
+		this.browser.removeEventListener("popstate", this.onPop);
+		this.browser.removeEventListener("scroll", this.saveScroll);
+		this.browser.history.scrollRestoration = this.originalScrollRestoration;
+		if (this.seeking !== void 0) Effect.runSync(Deferred.succeed(this.seeking.done, false));
+	}
+};
+//#endregion
+//#region src/client/router-store.ts
+const ErrorComponent = Schema.declare((value) => Predicate.isFunction(value));
+const InvalidComponent = Schema.declare((value) => Predicate.isFunction(value));
+const NotFoundComponent = Schema.declare((value) => Predicate.isFunction(value));
+const PageModule = Schema.Struct({
+	error: Schema.optional(ErrorComponent),
+	invalid: Schema.optional(InvalidComponent),
+	component: Schema.declare((value) => Predicate.isFunction(value))
+});
+const LayoutModule = Schema.Struct({
+	error: Schema.optional(ErrorComponent),
+	invalid: Schema.optional(InvalidComponent),
+	notFound: Schema.optional(NotFoundComponent),
+	component: Schema.declare((value) => Predicate.isFunction(value))
+});
+const ModuleExports = Schema.Record(Schema.String, Schema.Unknown);
+var BranchLoadError = class extends Schema.TaggedError()("BranchLoadError", {
+	error: Schema.Unknown,
+	branch: Schema.declare((value) => Predicate.isObject(value))
+}) {};
+const locationOf = (href, key, origin) => {
+	const parsed = new URL(href, origin);
+	let hash = parsed.hash.slice(1);
+	try {
+		hash = decodeURIComponent(hash);
+	} catch {}
+	return {
+		pathname: parsed.pathname,
+		search: parsed.search,
+		hash,
+		key
+	};
+};
+/** One store per mount. Load caches contain code and CSS only, never component/query state. */
+var RouterStore = class {
+	registration;
+	browser;
+	selection;
+	patterns;
+	listeners = /* @__PURE__ */ new Set();
+	modules = /* @__PURE__ */ new Map();
+	styles = /* @__PURE__ */ new Map();
+	styleCleanups = /* @__PURE__ */ new Set();
+	redirects = /* @__PURE__ */ new Set();
+	history;
+	blockers = /* @__PURE__ */ new Set();
+	blocked;
+	upgrading = false;
+	admission;
+	serial = 0;
+	transition;
+	committedHref;
+	disposed = false;
+	started = false;
+	snapshot = {
+		location: void 0,
+		branch: void 0,
+		navigation: { status: "idle" },
+		failure: void 0,
+		commit: 0
+	};
+	constructor(registration, selection, browser) {
+		this.registration = registration;
+		this.browser = browser;
+		this.selection = Schema.decodeSync(ExecutionSelection)(selection);
+		this.patterns = Effect.runSync(compilePatterns(registration.routes, registration.layouts));
+		for (const reference of [...registration.routes.map((route) => route.page), ...registration.layouts.map((layout) => layout.module)]) if (!registration.modules.has(reference.module)) throw new Error(`Client module '${reference.module}' is missing from registration.`);
+	}
+	getSnapshot = () => this.snapshot;
+	subscribe = (listener) => {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	};
+	update(snapshot) {
+		this.snapshot = snapshot;
+		for (const listener of this.listeners) listener();
+	}
+	start() {
+		if (this.started) throw new Error("The Ignotum router has already started.");
+		this.started = true;
+		this.history = new RouterHistory(this.browser, this.onTraversal);
+		this.browser.addEventListener("beforeunload", this.onBeforeUnload);
+		const position = this.history.committed;
+		return this.transitionTo(position.href, "initial", position.key, {}, position);
+	}
+	onTraversal = (position) => {
+		this.redirects.clear();
+		this.history?.seek(this.history.committed);
+		this.transitionTo(position.href, "traverse", position.key, {}, position);
+	};
+	back = () => this.history?.back();
+	forward = () => this.history?.forward();
+	onBeforeUnload = (event) => {
+		if (this.upgrading || this.blockers.size === 0) return;
+		event.preventDefault();
+		event.returnValue = "";
+	};
+	/** Internal platform upgrade entry; route confirmation never delays this reload. */
+	stopForUpgrade = () => {
+		if (this.disposed) return;
+		this.upgrading = true;
+		this.browser.removeEventListener("beforeunload", this.onBeforeUnload);
+		this.blockers.clear();
+		this.cancelPending();
+	};
+	upgrade = () => {
+		if (this.disposed) return;
+		this.stopForUpgrade();
+		this.browser.location.reload();
+	};
+	setAdmission(admission) {
+		this.admission = admission;
+	}
+	setBlocker(id, when) {
+		if (when) this.blockers.add(id);
+		else this.blockers.delete(id);
+		if (!when && this.blocked?.remaining.delete(id) === true) this.releaseBlocked();
+	}
+	getBlocker(id) {
+		const blocked = this.blocked;
+		const from = this.snapshot.location;
+		if (blocked === void 0 || from === void 0 || !blocked.remaining.has(id)) return { status: "idle" };
+		return {
+			status: "blocked",
+			from,
+			to: blocked.transition.location,
+			proceed: () => {
+				if (this.blocked !== blocked) return;
+				blocked.remaining.delete(id);
+				this.releaseBlocked();
+			},
+			reset: () => {
+				if (this.blocked !== blocked) return;
+				this.cancelPending();
+				this.update({
+					...this.snapshot,
+					navigation: { status: "idle" }
+				});
+			}
+		};
+	}
+	releaseBlocked() {
+		const blocked = this.blocked;
+		if (blocked === void 0) return;
+		if (blocked.remaining.size === 0) {
+			this.blocked = void 0;
+			this.loadTransition(blocked.transition);
+		} else this.update({ ...this.snapshot });
+	}
+	navigate(href, options = {}, redirect = false) {
+		if (this.disposed || this.upgrading) return Promise.resolve({ status: "cancelled" });
+		if (!redirect) this.redirects.clear();
+		if (href === this.committedHref) {
+			this.cancelPending();
+			this.update({
+				...this.snapshot,
+				navigation: { status: "idle" },
+				failure: void 0
+			});
+			return Promise.resolve({ status: "committed" });
+		}
+		if (redirect) {
+			if (this.committedHref !== void 0) this.redirects.add(this.committedHref);
+			if (this.redirects.has(href) || this.redirects.size >= 32) {
+				const error = /* @__PURE__ */ new Error(`Ignotum redirect loop at '${href}'.`);
+				this.cancelPending();
+				this.update({
+					...this.snapshot,
+					navigation: { status: "idle" },
+					failure: {
+						error,
+						retry: () => {
+							this.redirects.clear();
+							this.navigate(href, options, true);
+						}
+					}
+				});
+				return Promise.resolve({
+					status: "failed",
+					error
+				});
+			}
+		}
+		const key = options.replace === true ? this.snapshot.location?.key ?? this.browser.crypto.randomUUID() : this.browser.crypto.randomUUID();
+		return this.transitionTo(href, options.replace === true ? "replace" : "push", key, options);
+	}
+	preload = async (href) => {
+		if (this.disposed || this.upgrading || this.admission !== void 0 && !await this.admission.validate()) return;
+		const outcome = Effect.runSync(matchLocation(this.patterns, href));
+		await this.loadBranch(outcome, false);
+	};
+	cancelPending() {
+		if (this.history !== void 0) this.history.seek(this.history.committed);
+		this.blocked = void 0;
+		if (this.transition !== void 0) Effect.runSync(Deferred.succeed(this.transition.completion, { status: "cancelled" }));
+		this.transition = void 0;
+	}
+	transitionTo(href, kind, key, options = {}, historyPosition) {
+		if (this.disposed || this.upgrading) return Promise.resolve({ status: "cancelled" });
+		const sourceScroll = this.history?.captureScroll() ?? {
+			x: this.browser.scrollX,
+			y: this.browser.scrollY
+		};
+		this.cancelPending();
+		const location = locationOf(href, key, this.browser.location.origin);
+		const previous = this.snapshot.location;
+		const searchOnly = previous !== void 0 && previous.pathname === location.pathname && previous.hash === location.hash;
+		const completion = Deferred.makeUnsafe();
+		const position = historyPosition ?? {
+			key,
+			href,
+			index: (this.history?.committed.index ?? 0) + (kind === "push" ? 1 : 0)
+		};
+		const transition = {
+			id: ++this.serial,
+			href,
+			location,
+			kind,
+			completion,
+			position,
+			scroll: options.scroll ?? (searchOnly ? "preserve" : "auto"),
+			searchOnly,
+			sourceScroll
+		};
+		this.transition = transition;
+		if (kind !== "initial" && this.blockers.size > 0 && this.snapshot.location !== void 0) {
+			this.blocked = {
+				transition,
+				remaining: new Set(this.blockers)
+			};
+			this.update({
+				...this.snapshot,
+				navigation: { status: "idle" },
+				failure: void 0
+			});
+		} else this.loadTransition(transition);
+		return Effect.runPromise(Deferred.await(completion));
+	}
+	loadTransition(transition) {
+		const { href, location, kind } = transition;
+		const outcome = Effect.runSync(matchLocation(this.patterns, href));
+		this.update({
+			...this.snapshot,
+			navigation: {
+				status: "loading",
+				to: location
+			},
+			failure: void 0
+		});
+		const load = async () => {
+			if (this.admission !== void 0 && !await this.admission.validate()) throw new Error("The app must verify its current selection before navigating.");
+			if (this.upgrading || this.disposed) throw new Error("The app is updating.");
+			return this.loadBranch(outcome);
+		};
+		load().then(async (branch) => {
+			if (this.transition !== transition || this.disposed) return;
+			try {
+				const history = this.history;
+				if (history !== void 0) {
+					if (!await history.seek(history.committed) || this.transition !== transition || this.disposed) return;
+					if (kind === "traverse") {
+						if (!await history.seek(transition.position) || this.transition !== transition || this.disposed) return;
+					}
+					history.commit(transition.position, kind);
+				}
+				this.applyMetadata(outcome);
+				this.committedHref = href;
+				this.update({
+					location,
+					branch,
+					navigation: { status: "idle" },
+					failure: void 0,
+					commit: transition.id
+				});
+			} catch (error) {
+				this.fail(transition, error);
+			}
+		}, (error) => {
+			this.fail(transition, error);
+			if (!this.upgrading) this.admission?.recoverLoad();
+		});
+	}
+	/** Called by the mounted view after Preact has committed the destination DOM. */
+	rendered(commit) {
+		if (this.transition?.id !== commit || this.snapshot.commit !== commit) {
+			if (this.snapshot.navigation.status === "idle" && this.blocked === void 0) this.history?.restoreSourceScroll();
+			return;
+		}
+		const transition = this.transition;
+		const document = this.browser.document;
+		if (!transition.searchOnly) {
+			const target = document.querySelector("#app main, #app [role=main]") ?? document.getElementById("app");
+			if (target !== null) {
+				if (!target.hasAttribute("tabindex")) target.setAttribute("tabindex", "-1");
+				target.focus({ preventScroll: true });
+			}
+		}
+		const saved = this.history?.scroll.get(transition.location.key);
+		if (transition.kind === "traverse" && saved !== void 0) this.browser.scrollTo(saved.x, saved.y);
+		else if (transition.scroll === "auto") {
+			const target = transition.location.hash === "" ? null : document.getElementById(transition.location.hash);
+			if (target !== null) target.scrollIntoView();
+			else this.browser.scrollTo(0, 0);
+		} else this.browser.scrollTo(transition.sourceScroll.x, transition.sourceScroll.y);
+		this.history?.finishScroll();
+		Effect.runSync(Deferred.succeed(this.transition.completion, { status: "committed" }));
+		this.transition = void 0;
+	}
+	fail(transition, error) {
+		if (this.transition !== transition || this.disposed) return;
+		this.transition = void 0;
+		const loadFailure = error instanceof BranchLoadError ? error : void 0;
+		const originalError = loadFailure === void 0 ? error : loadFailure.error;
+		this.update({
+			...this.snapshot,
+			navigation: { status: "idle" },
+			failure: {
+				error: originalError,
+				branch: transition.kind === "initial" ? void 0 : loadFailure?.branch,
+				retry: () => {
+					this.transitionTo(transition.href, transition.kind, transition.location.key, { scroll: transition.scroll }, transition.position);
+				}
+			}
+		});
+		Effect.runSync(Deferred.succeed(transition.completion, {
+			status: "failed",
+			error: originalError
+		}));
+	}
+	loadStyle(href) {
+		const absolute = new URL(href, this.browser.location.origin).href;
+		const cached = this.styles.get(absolute);
+		if (cached !== void 0) return cached;
+		const document = this.browser.document;
+		const existing = Array.from(document.querySelectorAll("link[rel=\"stylesheet\"]")).find((link) => link.href === absolute);
+		if (existing?.sheet !== null && existing?.sheet !== void 0) return Promise.resolve();
+		const link = existing ?? document.createElement("link");
+		const promise = Effect.runPromise(Effect.callback((resume) => {
+			const cleanup = () => {
+				link.removeEventListener("load", onLoad);
+				link.removeEventListener("error", onError);
+				this.styleCleanups.delete(cancel);
+			};
+			const onLoad = () => {
+				cleanup();
+				resume(Effect.void);
+			};
+			const onError = () => {
+				cleanup();
+				link.remove();
+				resume(Effect.fail(/* @__PURE__ */ new Error(`Could not load route stylesheet '${href}'.`)));
+			};
+			const cancel = () => {
+				cleanup();
+				if (existing === void 0) link.remove();
+				resume(Effect.fail(/* @__PURE__ */ new Error("Router disposed.")));
+			};
+			this.styleCleanups.add(cancel);
+			link.addEventListener("load", onLoad);
+			link.addEventListener("error", onError);
+			if (existing === void 0) {
+				link.rel = "stylesheet";
+				link.crossOrigin = "anonymous";
+				link.href = absolute;
+				document.head.append(link);
+			}
+			return Effect.sync(cleanup);
+		})).catch((error) => {
+			this.styles.delete(absolute);
+			throw error;
+		});
+		this.styles.set(absolute, promise);
+		return promise;
+	}
+	loadModule(id) {
+		const cached = this.modules.get(id);
+		if (cached !== void 0) return cached;
+		const module = this.registration.modules.get(id);
+		if (module === void 0) return Promise.reject(/* @__PURE__ */ new Error(`Client module '${id}' is not registered.`));
+		const loaded = Promise.resolve().then(module.load).then(Schema.decodeUnknownSync(ModuleExports)).catch((error) => {
+			this.modules.delete(id);
+			throw error;
+		});
+		this.modules.set(id, loaded);
+		return loaded;
+	}
+	async loadExport(reference) {
+		const exports = await this.loadModule(reference.module);
+		if (!Object.hasOwn(exports, reference.exportName)) throw new Error(`Module '${reference.module}' has no '${reference.exportName}' export.`);
+		return exports[reference.exportName];
+	}
+	async loadBranch(outcome, withStyles = true) {
+		const route = outcome._tag === "NotFound" ? void 0 : outcome.route;
+		const available = /* @__PURE__ */ new Map();
+		try {
+			const [layouts, page] = await Promise.all([
+				Promise.all(outcome.layouts.map(async (layout) => {
+					const [loaded] = await Promise.all([this.loadExport(layout.module).then(Schema.decodeUnknownSync(LayoutModule)), withStyles ? Promise.all((this.registration.modules.get(layout.module.module)?.styles ?? []).map((href) => this.loadStyle(href))) : void 0]);
+					const result = {
+						id: layout.id,
+						...loaded
+					};
+					available.set(layout.id, result);
+					return result;
+				})),
+				route === void 0 ? void 0 : this.loadExport(route.page).then(Schema.decodeUnknownSync(PageModule)),
+				Promise.all(withStyles ? [...this.registration.styles ?? [], ...route === void 0 ? [] : this.registration.modules.get(route.page.module)?.styles ?? []].map(async (href) => this.loadStyle(href)) : [])
+			]);
+			return {
+				outcome,
+				layouts,
+				page: page?.component,
+				pageBoundaries: page
+			};
+		} catch (error) {
+			const layouts = [];
+			for (const definition of outcome.layouts) {
+				const loaded = available.get(definition.id);
+				if (loaded === void 0) break;
+				layouts.push(loaded);
+			}
+			throw BranchLoadError.make({
+				error,
+				branch: {
+					outcome,
+					layouts,
+					page: void 0
+				}
+			});
+		}
+	}
+	setRenderError(error) {
+		if (this.snapshot.branch !== void 0) this.applyMetadata(this.snapshot.branch.outcome, error);
+	}
+	applyMetadata(outcome, renderError = false) {
+		const resolved = Effect.runSync(resolveMetadata({
+			applicationName: this.registration.applicationName,
+			layouts: outcome.layouts.map((layout) => layout.metadata),
+			page: outcome._tag === "NotFound" ? void 0 : outcome.route?.metadata,
+			outcome: renderError ? "Invalid" : outcome._tag
+		}));
+		const document = this.browser.document;
+		document.title = resolved.title;
+		for (const name of ["description", "robots"]) {
+			const tags = Array.from(document.head.querySelectorAll(`meta[name="${name}"]`));
+			const value = resolved.meta[name];
+			if (value === void 0) {
+				for (const tag of tags) tag.remove();
+				continue;
+			}
+			const tag = tags.shift() ?? document.createElement("meta");
+			for (const duplicate of tags) duplicate.remove();
+			tag.name = name;
+			tag.content = value;
+			if (!tag.isConnected) document.head.append(tag);
+		}
+	}
+	dispose() {
+		this.disposed = true;
+		this.cancelPending();
+		this.history?.dispose();
+		this.browser.removeEventListener("beforeunload", this.onBeforeUnload);
+		for (const cleanup of this.styleCleanups) cleanup();
+		this.listeners.clear();
+	}
+};
+//#endregion
+//#region src/client/route-boundaries.ts
+const DefaultError = ({ error, retry }) => createElement("div", { role: "alert" }, error instanceof Error ? error.message : "This page could not load or render. ", createElement("button", { onClick: retry }, "Retry"));
+const Boundary = ({ children, component, branch, router, onRetry }) => {
+	const [failure, setFailure] = useState();
+	const [, reset] = useErrorBoundary((error) => {
+		setFailure({
+			branch,
+			error
+		});
+		router.setRenderError(true);
+	});
+	return failure?.branch !== branch ? children : createElement(component, {
+		error: failure.error,
+		retry: () => {
+			router.setRenderError(false);
+			onRetry?.();
+			setFailure(void 0);
+			reset();
+		}
+	});
+};
+const Branch = ({ branch, location, router, failure }) => {
+	const outcome = branch.outcome;
+	let child;
+	let lastLayout = branch.layouts.length - 1;
+	let boundaryOwner;
+	if (outcome._tag === "Matched" && branch.page !== void 0) child = createElement(branch.page, {
+		key: outcome.route.id,
+		params: outcome.params,
+		searchParams: outcome.searchParams
+	});
+	else if (outcome._tag === "Invalid" && branch.pageBoundaries?.invalid !== void 0) child = createElement(branch.pageBoundaries.invalid, {
+		location,
+		issues: outcome.issues
+	});
+	else {
+		child = createElement("main", { "data-ignotum-outcome": outcome._tag }, outcome._tag === "Invalid" ? "Invalid URL" : "Page not found");
+		for (let index = lastLayout; index >= 0; index--) {
+			const layout = branch.layouts[index];
+			if (outcome._tag === "Invalid" && layout.invalid !== void 0) {
+				child = createElement(layout.invalid, {
+					location,
+					issues: outcome.issues
+				});
+				lastLayout = index;
+				boundaryOwner = index;
+				break;
+			}
+			if (outcome._tag === "NotFound" && layout.notFound !== void 0) {
+				child = createElement(layout.notFound, { location });
+				lastLayout = index;
+				boundaryOwner = index;
+				break;
+			}
+		}
+	}
+	if (branch.pageBoundaries?.error !== void 0 && outcome._tag === "Matched") child = createElement(Boundary, {
+		key: "page-boundary",
+		component: branch.pageBoundaries.error,
+		branch,
+		router,
+		children: child
+	});
+	let sharedLayouts = 0;
+	while (sharedLayouts <= lastLayout && branch.layouts[sharedLayouts]?.id === failure?.branch?.layouts[sharedLayouts]?.id) sharedLayouts++;
+	const loadFailure = failure === void 0 ? null : createElement(LoadFailure, {
+		failure,
+		router,
+		layouts: branch.layouts.slice(0, sharedLayouts)
+	});
+	for (let index = lastLayout; index >= 0; index--) {
+		const layout = branch.layouts[index];
+		if (layout.error !== void 0 && index !== boundaryOwner) child = createElement(Boundary, {
+			key: layout.id,
+			component: layout.error,
+			branch,
+			router,
+			children: child
+		});
+		child = createElement(layout.component, {
+			key: layout.id,
+			children: createElement(Fragment, {}, child, index === sharedLayouts - 1 ? loadFailure : null)
+		});
+	}
+	return createElement(Boundary, {
+		component: DefaultError,
+		branch,
+		router,
+		children: createElement(Fragment, {}, child, sharedLayouts === 0 ? loadFailure : null)
+	});
+};
+const LoadFailure = ({ failure, router, layouts }) => {
+	const branch = failure.branch;
+	if (branch === void 0) return createElement("div", { "data-ignotum-load-error": "" }, createElement(DefaultError, failure));
+	let child = createElement(DefaultError, failure);
+	let found = false;
+	for (const layout of [...layouts ?? branch.layouts].reverse()) {
+		if (layout.error === void 0) continue;
+		if (!found) {
+			child = createElement(layout.error, {
+				error: failure.error,
+				retry: failure.retry
+			});
+			found = true;
+		} else child = createElement(Boundary, {
+			component: layout.error,
+			branch,
+			router,
+			onRetry: failure.retry,
+			children: child
+		});
+	}
+	return createElement("div", { "data-ignotum-load-error": "" }, createElement(Boundary, {
+		component: DefaultError,
+		branch,
+		router,
+		onRetry: failure.retry,
+		children: child
+	}));
+};
+//#endregion
+//#region src/client/bootstrap.ts
+const RouterView = ({ router }) => {
+	const snapshot = useRouterSnapshot(router);
+	useLayoutEffect(() => {
+		router.rendered(snapshot.commit);
+	}, [router, snapshot]);
+	return createElement(RouterContext.Provider, { value: router }, snapshot.branch === void 0 || snapshot.location === void 0 ? createElement("div", { role: "status" }, snapshot.failure === void 0 ? "Loading…" : null) : createElement(Branch, {
+		branch: snapshot.branch,
+		location: snapshot.location,
+		router,
+		failure: snapshot.failure
+	}), snapshot.failure !== void 0 && snapshot.branch === void 0 ? createElement(LoadFailure, {
+		failure: snapshot.failure,
+		router
+	}) : null);
+};
+const mounts = /* @__PURE__ */ new WeakSet();
+const ManagedStatus = ({ client }) => {
+	const [snapshot, setSnapshot] = useState(client.upgrade.getSnapshot);
+	useLayoutEffect(() => client.upgrade.subscribe(() => setSnapshot(client.upgrade.getSnapshot())), [client]);
+	if (snapshot.phase === "ready" && snapshot.recovery.length === 0) return null;
+	return createElement("aside", {
+		"data-ignotum-update": snapshot.phase,
+		role: snapshot.phase === "error" ? "alert" : "status"
+	}, snapshot.message ?? (snapshot.phase === "connecting" ? "Connecting to the app…" : null), snapshot.recovery.length === 0 ? null : createElement("ul", null, snapshot.recovery.map((message) => createElement("li", { key: message }, message))), snapshot.phase === "error" ? createElement("button", {
+		type: "button",
+		onClick: () => client.retry()
+	}, "Reload app") : null, snapshot.recovery.length === 0 ? null : createElement("button", {
+		type: "button",
+		onClick: client.upgrade.dismissRecovery
+	}, "Dismiss"));
+};
+/** The platform owns mounting. Generated registrations contain no Preact render/bootstrap code. */
+const mountClient = (registration, selection) => {
+	const root = window.document.getElementById("app");
+	if (root === null) throw new Error("Ignotum mount element is missing.");
+	if (mounts.has(root)) throw new Error("The Ignotum client is already mounted.");
+	const router = new RouterStore(registration, selection, window);
+	const managed = mountManagedSync(selection, window, {
+		stopAdmission: router.stopForUpgrade,
+		reload: router.upgrade
+	});
+	router.setAdmission({
+		validate: managed.client.validate,
+		recoverLoad: managed.client.recoverLoad
+	});
+	render(createElement(Fragment, null, createElement(ManagedStatus, { client: managed.client }), createElement(RouterView, { router })), root);
+	const ready = managed.client.whenReady().then((accepted) => accepted ? router.start() : { status: "cancelled" });
+	mounts.add(root);
+	let disposed = false;
+	return {
+		ready,
+		upgrade: () => managed.client.upgrade.require(),
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			mounts.delete(root);
+			router.dispose();
+			managed.dispose();
+			render(null, root);
+		}
+	};
+};
+//#endregion
+export { mountClient as t };
+
+//# sourceMappingURL=bootstrap-BISQSn_O.js.map