@stealthscale/sdk-host 0.1.0

package/dist/create-routes-CkgZV-dU.js

@@ -0,0 +1,4730 @@
+import { n as translatorOf, r as useProductName, t as pluginWordsOf } from "./words-yI-WdYM3.js";
+import { DataProvider, createDataClient, defineMutation, defineQuery, findRecords, mutateOperation, operationQuery, resetData } from "@stealthscale/provider-data";
+import { HOST, NOBODY, evaluateWhen, hostContract, pluginOf, subjectOf } from "@stealthscale/sdk-core";
+import { sampledTransport } from "@stealthscale/provider-data/testing";
+import { Boundary, HostContext, PluginProvider, RouteDecorations, Slot, changesOf, conditionContextOf, decisionKey, decisionOf, isCommandEnabled, lazyOf, useCommands, useDocumentTitle, useNavigation, usePluginStatuses, useResolvedProduct, useSettings, useToaster } from "@stealthscale/sdk-plugin";
+import { Alert, EmptyState, Toast } from "@stealthscale/component-feedback";
+import { settingKey } from "@stealthscale/settings";
+import { c } from "react/compiler-runtime";
+import { Navigate, Outlet, RouterContextProvider, compileRoutes, createLink, declaredOf, notFound, redirect, routeHref, useDeclaredRoute, useNavigate, useRouteContext, useRouter } from "@stealthscale/provider-router";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Component, Suspense, createElement, lazy, useEffect, useId, useLayoutEffect, useRef, useState, useSyncExternalStore } from "react";
+import { Button } from "@stealthscale/component-actions";
+import { useTranslation } from "@stealthscale/provider-i18n";
+import { normalizeHotkey, useHotkey, useHotkeys } from "@stealthscale/provider-hotkeys";
+import { Command, Dialog } from "@stealthscale/component-modals";
+import { loadNeeds } from "@stealthscale/provider-data/router";
+import { Stack } from "@stealthscale/component-layout";
+import { Link } from "@stealthscale/component-navigation";
+import { Page, Section } from "@stealthscale/component-screen";
+import { List, Text } from "@stealthscale/component-typography";
+import { flushSync } from "react-dom";
+import { Switch } from "@stealthscale/component-forms";
+import { useAnnounce } from "@stealthscale/hooks";
+import { useSchemaForm } from "@stealthscale/component-forms/form";
+/**
+* Returns the message of an emit by a party that may not emit an event.
+*/
+function refused(event, by) {
+	return `${by === void 0 ? "The product" : `The plugin ${by}`} may not emit ${event.id}: only ${event.plugin} emits it.`;
+}
+/**
+* Returns the event bus over the declared events.
+*
+* @remarks
+*   An emit of an event no installed plugin declares throws, and so does an emit by a party other
+*   than the declaring plugin, unless the event states `emit: "anyone"`. The product's own code
+*   emits as no plugin, so it emits an `anyone` event alone. A sticky event keeps its last payload
+*   and hands it to each new subscriber when it subscribes. A subscription to an event no installed
+*   plugin declares receives nothing.
+*/
+function createEventBus({ events, report }) {
+	const declared = new Map(events.map((event) => [event.id, event]));
+	const target = new EventTarget();
+	const kept = /* @__PURE__ */ new Map();
+	let depth = 0;
+	return {
+		emit: (by, eventId, payload) => {
+			const event = declared.get(eventId);
+			if (event === void 0) throw new Error(`No installed plugin declares the event ${eventId}.`);
+			if (event.emit !== "anyone" && by !== event.plugin) throw new Error(refused(event, by));
+			if (depth >= 16) {
+				report({
+					kind: "event-chain-cut",
+					plugin: by,
+					target: eventId
+				});
+				return;
+			}
+			if (event.sticky) kept.set(eventId, payload);
+			depth += 1;
+			try {
+				target.dispatchEvent(new CustomEvent(eventId, { detail: payload }));
+			} finally {
+				depth -= 1;
+			}
+		},
+		subscribe: (by, eventId, handler) => {
+			/**
+			* Passes a payload to the handler, and reports what the handler throws.
+			*/
+			const deliver = (payload) => {
+				try {
+					handler(payload);
+				} catch (error) {
+					report({
+						error,
+						kind: "event-handler-failed",
+						plugin: by,
+						target: eventId
+					});
+				}
+			};
+			/**
+			* Receives the event on the target.
+			*/
+			const listener = (event) => {
+				deliver(event.detail);
+			};
+			target.addEventListener(eventId, listener);
+			if (kept.has(eventId)) deliver(kept.get(eventId));
+			return () => {
+				target.removeEventListener(eventId, listener);
+			};
+		}
+	};
+}
+//#endregion
+//#region src/host/transport.ts
+/**
+* Returns a transport that serves each declared query and mutation with its sample's data.
+*/
+function sampledFrom(product) {
+	return sampledTransport(Object.fromEntries([...product.queries, ...product.mutations].map(({ operation, sample }) => [operation.id, { data: sample.data }])));
+}
+/**
+* Returns the error of an operation no installed plugin declares.
+*/
+function undeclared(id) {
+	return /* @__PURE__ */ new Error(`No installed plugin declares the operation ${id}.`);
+}
+/**
+* Returns true for the data of one event of the changes stream.
+*/
+function isBatch(data) {
+	return typeof data === "object" && data !== null && "changes" in data && Array.isArray(data.changes);
+}
+/**
+* Returns the transport the host's data client runs on.
+*
+* @remarks
+*   The transport refuses an operation no installed plugin declares, and every subscription but
+*   the product's changes stream. A declared mutation that resolves announces the changes its
+*   declarations name for its variables. Each batch of the stream is announced after the client
+*   received it.
+*/
+function guardedTransport({ changed, changes, product, transport = sampledFrom(product) }) {
+	const declared = new Set([...product.queries, ...product.mutations].map(({ operation }) => operation.id));
+	return {
+		run: async (operation, variables, options) => {
+			if (!declared.has(operation.id)) throw undeclared(operation.id);
+			const data = await transport.run(operation, variables, options);
+			const made = product.mutations.filter((mutation) => mutation.operation.id === operation.id).flatMap((mutation) => changesOf(mutation.changes, variables));
+			if (made.length > 0) changed(made);
+			return data;
+		},
+		subscribe: (operation, variables, next, signal) => {
+			if (operation.id !== changes?.id) return Promise.reject(undeclared(operation.id));
+			return transport.subscribe(operation, variables, (data) => {
+				next(data);
+				if (isBatch(data)) changed(data.changes);
+			}, signal);
+		}
+	};
+}
+//#endregion
+//#region src/host/data.ts
+/**
+* Creates the host's data client: its transport guarded to the declared operations, the decisions
+* each query's data states primed into the access store, changes announced on the bus, and the
+* person sent to sign in where the gateway refuses the session.
+*/
+/**
+* Returns the decisions one decision selector finds in a query's data.
+*
+* @remarks
+*   A record whose member is not a boolean states no decision, so `useAccess` asks the access
+*   source for it.
+*/
+function foundBy(selector, type, data) {
+	return findRecords(data, selector).flatMap(({ id, record }) => {
+		const allowed = record[selector.field];
+		return typeof allowed === "boolean" ? [{
+			allowed,
+			permission: selector.permission,
+			resource: {
+				id,
+				type
+			}
+		}] : [];
+	});
+}
+/**
+* Returns the decisions one arrival of a query's data states, through the decision selectors of
+* every query declared for its operation.
+*
+* @remarks
+*   A selector whose permission states no resource kind finds nothing.
+*/
+function decisionsIn(product, arrival) {
+	const kinds = new Map(product.permissions.map(({ id, resource }) => [id, resource]));
+	return product.queries.filter(({ operation }) => operation.id === arrival.operation).flatMap(({ decisions }) => decisions).flatMap((selector) => {
+		const type = kinds.get(selector.permission);
+		return type === void 0 ? [] : foundBy(selector, type, arrival.data);
+	});
+}
+/**
+* Returns the data client of the page or the request.
+*
+* @remarks
+*   Each arrival of a declared query's data, from a fetch or from a server render the page
+*   hydrates, primes the decisions its selectors state. A refusal of the session reads the session
+*   again and invalidates the router, so the sign-in redirect applies.
+*/
+function createHostData({ access, connection, data, events, product, session }) {
+	return createDataClient({
+		changes: data?.changes,
+		onData: (arrival) => {
+			const decisions = decisionsIn(product, arrival);
+			if (decisions.length > 0) access.prime(decisions);
+		},
+		onUnauthenticated: () => {
+			session.refresh();
+			connection()?.invalidate();
+		},
+		transport: guardedTransport({
+			changed: (changes) => {
+				events.emit(HOST, hostContract.events.recordsChanged.id, { changes });
+			},
+			changes: data?.changes,
+			product,
+			transport: data?.transport
+		})
+	});
+}
+//#endregion
+//#region src/host/internals.ts
+/**
+* The internals of each host `createHost` created.
+*/
+const INTERNALS = /* @__PURE__ */ new WeakMap();
+/**
+* Returns a connector with no connection.
+*
+* @remarks
+*   A disconnect leaves a later connection in place, so a `HostProvider` that unmounts after
+*   another mounted does not remove the newer one.
+*/
+function connector() {
+	let kept;
+	return {
+		connect: (connection) => {
+			kept = connection;
+			return () => {
+				if (kept === connection) kept = void 0;
+			};
+		},
+		current: () => kept
+	};
+}
+/**
+* Records a host's internals, for the host's own parts to read.
+*/
+function remember(host, internals) {
+	INTERNALS.set(host, internals);
+}
+/**
+* Returns a host's internals.
+*
+* @throws {@link Error} Where `createHost` did not create the host.
+*/
+function internalsOf(host) {
+	const internals = INTERNALS.get(host);
+	if (internals === void 0) throw new Error("The host was not created by createHost, so it has no runtime to provide.");
+	return internals;
+}
+//#endregion
+//#region src/host/manifests.ts
+/**
+* Checks that the manifests map code to every name the resolved product declares.
+*
+* @remarks
+*   The types of `definePlugin` refuse a manifest that lacks code, so the check covers an untyped
+*   caller, such as a product assembled by hand.
+*/
+/**
+* The words of each kind in the message of a missing entry.
+*/
+const WORDS = {
+	command: "the command",
+	extension: "the extension",
+	route: "the route",
+	section: "the settings section"
+};
+/**
+* Returns the names of a record a manifest may leave out.
+*/
+function namesOf(record) {
+	return record === void 0 ? [] : Object.keys(record);
+}
+/**
+* Returns the names of the settings sections whose component a manifest maps.
+*/
+function componentsOf(settings) {
+	return settings === void 0 ? [] : Object.entries(settings).filter(([, entry]) => entry.component !== void 0).map(([name]) => name);
+}
+/**
+* Returns the key of every entry the manifests map to code: `<kind>:<qualified id>`.
+*/
+function mappedOf(manifests) {
+	const mapped = /* @__PURE__ */ new Set();
+	for (const [pluginId, { code }] of Object.entries(manifests)) {
+		const named = [
+			["route", namesOf(code.routes)],
+			["extension", namesOf(code.extensions)],
+			["command", namesOf(code.commands)],
+			["section", componentsOf(code.settings)]
+		];
+		for (const [kind, names] of named) for (const name of names) mapped.add(`${kind}:${pluginId}/${name}`);
+	}
+	return mapped;
+}
+/**
+* Throws where a manifest lacks the code of a route, an extension, a command, or a settings section
+* that renders a component.
+*
+* @remarks
+*   The host's own routes take no manifest: the host renders them itself.
+* @param product - The resolved product, with each installed plugin's manifest.
+* @throws {@link Error} Naming every declaration whose code is missing.
+*/
+function validateManifests(product) {
+	const mapped = mappedOf(product.manifests);
+	const missing = [
+		...product.routes.map(({ id }) => ["route", id]),
+		...product.extensions.map(({ id }) => ["extension", id]),
+		...product.commands.map(({ id }) => ["command", id]),
+		...product.settings.sections.filter(({ component }) => component).map(({ id }) => ["section", id])
+	].filter(([kind, id]) => pluginOf(id) !== HOST && !mapped.has(`${kind}:${id}`));
+	if (missing.length > 0) throw new Error(missing.map(([kind, id]) => `No manifest maps ${WORDS[kind]} ${id} to code.`).join(" "));
+}
+//#endregion
+//#region src/stores/store.ts
+/**
+* Returns a store that keeps one value and calls its listeners after each change.
+*
+* @remarks
+*   The listeners run over a copy of the set, so a listener that subscribes or unsubscribes while
+*   the others run changes the next notification and not this one. Setting the same object again
+*   calls no listener, because `useSyncExternalStore` compares snapshots by identity.
+* @param initial - The value before the first change.
+*/
+function writable(initial) {
+	let value = initial;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		get: () => value,
+		set: (next) => {
+			if (Object.is(next, value)) return;
+			value = next;
+			for (const listener of [...listeners]) listener();
+		},
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+//#endregion
+//#region src/stores/mounted.ts
+/**
+* Returns the mounted store, with no slot on screen.
+*
+* @remarks
+*   Each `mount` records one instance, in mount order, until the function it returns is called. A
+*   slot whose last instance unmounts leaves the store. A second call of that function changes
+*   nothing.
+*/
+function createMountedStore() {
+	const instances = /* @__PURE__ */ new Map();
+	const state = writable(/* @__PURE__ */ new Map());
+	let next = 0;
+	/**
+	* Publishes every mounted instance, grouped by slot.
+	*/
+	const publish = () => {
+		const grouped = /* @__PURE__ */ new Map();
+		for (const [slotId, slot] of instances.values()) grouped.set(slotId, [...grouped.get(slotId) ?? [], slot]);
+		state.set(grouped);
+	};
+	return {
+		get: state.get,
+		mount: (slotId, slot) => {
+			const instance = next;
+			next += 1;
+			instances.set(instance, [slotId, slot]);
+			publish();
+			return () => {
+				if (instances.delete(instance)) publish();
+			};
+		},
+		subscribe: state.subscribe
+	};
+}
+//#endregion
+//#region src/stores/pages.ts
+/**
+* Returns the page store, with no contribution.
+*
+* @remarks
+*   A slot lists its contributions by `order`, then in the order they were placed. A contribution
+*   renders nothing until its content is filled, and keeps its place while its content changes. A
+*   `place` for a key already placed replaces the contribution, and the earlier `place`'s leave
+*   function then changes nothing.
+*/
+function createPageStore() {
+	const placed = /* @__PURE__ */ new Map();
+	const state = writable(/* @__PURE__ */ new Map());
+	let sequence = 0;
+	/**
+	* Publishes every contribution, grouped by slot and ordered.
+	*/
+	const publish = () => {
+		const ordered = [...placed].toSorted(([, one], [, other]) => one.order - other.order || one.sequence - other.sequence);
+		const grouped = /* @__PURE__ */ new Map();
+		for (const [key, { content, order, slotId }] of ordered) grouped.set(slotId, [...grouped.get(slotId) ?? [], {
+			content,
+			key,
+			order
+		}]);
+		state.set(grouped);
+	};
+	return {
+		fill: (key, content) => {
+			const contribution = placed.get(key);
+			if (contribution === void 0 || contribution.content === content) return;
+			placed.set(key, {
+				...contribution,
+				content
+			});
+			publish();
+		},
+		get: state.get,
+		place: (slotId, key, order) => {
+			sequence += 1;
+			const mine = sequence;
+			placed.set(key, {
+				content: null,
+				order,
+				sequence: mine,
+				slotId
+			});
+			publish();
+			return () => {
+				if (placed.get(key)?.sequence !== mine) return;
+				placed.delete(key);
+				publish();
+			};
+		},
+		subscribe: state.subscribe
+	};
+}
+//#endregion
+//#region src/stores/quarantine.ts
+/**
+* Returns the quarantine store, with no target quarantined.
+*
+* @remarks
+*   The count is per render, not per second, so a target rendered sixty times a minute and one
+*   rendered once an hour follow one rule. A render that commits returns its target's count to
+*   zero. A quarantine lasts until `retry` or a reload: no store keeps it, because a reload may
+*   load a release that fixed the fault.
+*/
+function createQuarantineStore({ after, report }) {
+	const failures = /* @__PURE__ */ new Map();
+	const state = writable(/* @__PURE__ */ new Map());
+	return {
+		failed: (target, error) => {
+			const count = (failures.get(target) ?? 0) + 1;
+			failures.set(target, count);
+			report({
+				error,
+				kind: "render-failed",
+				target
+			});
+			if (count < after || state.get().has(target)) return;
+			state.set(new Map([...state.get(), [target, {
+				error,
+				target
+			}]]));
+			report({
+				error,
+				kind: "quarantined",
+				target
+			});
+		},
+		get: state.get,
+		rendered: (target) => {
+			failures.delete(target);
+		},
+		retry: (target) => {
+			failures.delete(target);
+			if (!state.get().has(target)) return;
+			state.set(new Map([...state.get()].filter(([quarantined]) => quarantined !== target)));
+		},
+		subscribe: state.subscribe
+	};
+}
+//#endregion
+//#region src/stores/reports.ts
+/**
+* Returns the report store, empty.
+*/
+function createReportStore() {
+	const state = writable([]);
+	return {
+		add: (entry) => {
+			state.set([...state.get(), entry].slice(-100));
+		},
+		get: state.get,
+		subscribe: state.subscribe
+	};
+}
+//#endregion
+//#region src/host/page.ts
+/**
+* Failed renders in a row after which a target is quarantined, where the product states none.
+*/
+const QUARANTINE_AFTER = 3;
+/**
+* The prefix of every line the host writes to the console.
+*/
+const PREFIX = "[host]";
+/**
+* Writes an entry to the console: as an error where the entry has an error, else as a warning.
+*/
+function toConsole(entry) {
+	if ("error" in entry) console.error(`${PREFIX} ${entry.kind}`, entry);
+	else console.warn(`${PREFIX} ${entry.kind}`, entry);
+}
+/**
+* Returns the page's stores, empty, and the function that reports an entry into them.
+*/
+function createPage({ quarantineAfter = QUARANTINE_AFTER, report: receiver = toConsole }) {
+	const reports = createReportStore();
+	/**
+	* Adds an entry to the reports store and passes it to the receiver.
+	*/
+	const report = (entry) => {
+		reports.add(entry);
+		receiver(entry);
+	};
+	return {
+		report,
+		stores: {
+			mounted: createMountedStore(),
+			pages: createPageStore(),
+			quarantine: createQuarantineStore({
+				after: quarantineAfter,
+				report
+			}),
+			reports
+		}
+	};
+}
+//#endregion
+//#region src/host/ready.ts
+/**
+* Returns the values of a record a manifest may leave out.
+*/
+function valuesOf(record) {
+	return record === void 0 ? [] : Object.values(record);
+}
+/**
+* Returns every importer a plugin's code lists: its pages, extensions, commands and sections, and
+* their fallbacks.
+*/
+function importersOf(code) {
+	return [
+		...valuesOf(code.routes).flatMap((route) => typeof route === "function" ? [route] : [route.component, route.fallback]),
+		...valuesOf(code.extensions).flatMap(({ component, fallback }) => [component, fallback]),
+		...valuesOf(code.commands).map(({ run }) => run),
+		...valuesOf(code.settings).map(({ component }) => component)
+	].filter((importer) => importer !== void 0);
+}
+/**
+* Imports every module of the plugins named, and resolves once every import settled.
+*
+* @remarks
+*   A failed import does not fail the caller. The page or the extension whose module failed reports
+*   the failure when it renders.
+* @param manifests - Each installed plugin's manifest, by plugin id.
+* @param pluginIds - Ids of the plugins whose modules to import.
+*/
+async function importPlugins(manifests, pluginIds) {
+	const importers = Object.entries(manifests).filter(([pluginId]) => pluginIds.has(pluginId)).flatMap(([, manifest]) => importersOf(manifest.code));
+	await Promise.allSettled(importers.map((load) => load()));
+}
+/**
+* Imports the modules of every eager plugin, and resolves once every import settled.
+*/
+async function importEager(product) {
+	const eager = product.plugins.filter((plugin) => plugin.eager).map(({ id }) => id);
+	await importPlugins(product.manifests, new Set(eager));
+}
+/**
+* Resolves once a promise settles, or once the milliseconds pass, whichever comes first.
+*/
+function within(promise, milliseconds) {
+	return new Promise((resolve) => {
+		const timer = setTimeout(resolve, milliseconds);
+		/**
+		* Stops the timer and resolves.
+		*/
+		const settle = () => {
+			clearTimeout(timer);
+			resolve();
+		};
+		promise.then(settle, settle);
+	});
+}
+/**
+* Resolves once the eager imports settled and the flag source identified the session, or once the
+* timeout passed for the identification.
+*
+* @param eager - The eager plugins' imports.
+* @param identified - The flag source's identification of the first session.
+* @param timeout - Milliseconds to wait at most for the identification.
+*/
+async function readied(eager, identified, timeout) {
+	await Promise.all([eager, within(identified, timeout)]);
+}
+//#endregion
+//#region src/commands/registry.ts
+/**
+* Returns the one function a command's module exports.
+*
+* @throws {@link Error} Where the module exports no function or more than one.
+*/
+function functionOf(module, commandId) {
+	const found = Object.values(module).filter((value) => typeof value === "function");
+	if (found.length !== 1) throw new Error(`The module of ${commandId} exports ${String(found.length)} functions, and a command's module exports one.`);
+	return found[0];
+}
+/**
+* Returns the function that runs a command by its qualified id with its arguments.
+*
+* @remarks
+*   A run rejects where no installed plugin declares the command, and where its plugin is off or
+*   its condition is false at the moment of the run, so a control rendered before a permission was
+*   revoked cannot run it. The module of each importer is imported once. An import that fails is
+*   forgotten, so the next run imports again. Each need is a function that runs the needed command
+*   through the same checks. The call runs inside the `stealth:command:<id>` performance measure.
+*   A run that is in progress when its plugin turns off completes.
+*/
+function createCommandRegistry({ hostOf, matched, product, stores }) {
+	const imports = /* @__PURE__ */ new Map();
+	/**
+	* Returns the function of a command's module, imported once per importer.
+	*/
+	const imported = (command) => {
+		const entry = (product.manifests[command.plugin]?.code.commands ?? {})[command.id.slice(command.plugin.length + 1)];
+		if (entry === void 0) return Promise.reject(/* @__PURE__ */ new Error(`No manifest maps the command ${command.id} to code.`));
+		const known = imports.get(entry.run);
+		if (known !== void 0) return known;
+		const loading = entry.run().then((module) => functionOf(module, command.id));
+		imports.set(entry.run, loading);
+		loading.catch(() => {
+			imports.delete(entry.run);
+		});
+		return loading;
+	};
+	/**
+	* Runs a command by its qualified id, and resolves with its result.
+	*/
+	const run = async (commandId, args) => {
+		const command = product.commands.find(({ id }) => id === commandId);
+		if (command === void 0) throw new Error(`No installed plugin declares the command ${commandId}.`);
+		if (!isCommandEnabled(command, stores, matched())) throw new Error(`The command ${commandId} cannot run: its condition is false.`);
+		const call = await imported(command);
+		const needs = Object.fromEntries(Object.entries(command.needs).map(([name, needed]) => [name, (given) => run(needed, given)]));
+		const start = performance.now();
+		try {
+			return await call(args, needs, hostOf(command.plugin));
+		} finally {
+			performance.measure(`stealth:command:${commandId}`, { start });
+		}
+	};
+	return run;
+}
+//#endregion
+//#region src/host/api.ts
+/**
+* Builds the API a command's function receives beside its arguments: the host as the command's
+* plugin sees it at the time of the run.
+*/
+/**
+* The error of a navigation before `HostProvider` connected the router.
+*/
+const UNCONNECTED = "The host is not connected to a router. HostProvider connects one when it renders.";
+/**
+* Returns the functions that run declared queries and mutations through the host's data client.
+*/
+function dataOf(product, client) {
+	return {
+		mutate: (mutation, variables) => {
+			const declared = product.mutations.find(({ id }) => id === mutation.id);
+			if (declared === void 0) return Promise.reject(/* @__PURE__ */ new Error(`No installed plugin declares the mutation ${mutation.id}.`));
+			return mutateOperation(client, defineMutation(declared.operation.id), variables, { changes: (given) => changesOf(declared.changes, given) });
+		},
+		query: (query, variables) => {
+			const declared = product.queries.find(({ id }) => id === query.id);
+			if (declared === void 0) return Promise.reject(/* @__PURE__ */ new Error(`No installed plugin declares the query ${query.id}.`));
+			return client.query(operationQuery(defineQuery(declared.operation.id), variables, {
+				resources: declared.records,
+				staleTime: declared.staleTime
+			}));
+		}
+	};
+}
+/**
+* Resolves with the decision on one resource once the stores state one, and asks the access source
+* for it meanwhile.
+*
+* @remarks
+*   Every change of the stores that leaves the check pending asks for it again, so a check the host
+*   dropped on a change of subject is asked for again.
+*/
+function decided(stores, check) {
+	return new Promise((resolve) => {
+		const stops = [];
+		/**
+		* Resolves with the decision where the stores state one, and asks for it otherwise.
+		*/
+		const settle = () => {
+			const decision = decisionOf(stores.access.get(), stores.session.get(), check);
+			if (decision === "pending") {
+				stores.access.request(check);
+				return;
+			}
+			for (const stop of stops) stop();
+			resolve(decision === "allowed");
+		};
+		stops.push(stores.access.subscribe(settle), stores.session.subscribe(settle));
+		settle();
+	});
+}
+/**
+* Resolves whether the person has a permission: on the resource where a resource id is given for a
+* scoped permission, and for the tenant otherwise.
+*/
+function allowed(stores, product, permission, resourceId) {
+	const type = product.permissions.find(({ id }) => id === permission)?.resource;
+	if (resourceId === void 0 || type === void 0) return Promise.resolve(stores.session.get().permissions.has(permission));
+	return decided(stores, {
+		permission,
+		resource: {
+			id: resourceId,
+			type
+		}
+	});
+}
+/**
+* Returns the function that builds a plugin's `HostApi` at the time of a run.
+*
+* @remarks
+*   The session, the connection and the deepest matched route are read when the function is
+*   called, so each run sees the page as it is then. Before `HostProvider` connects the router,
+*   `matched` is undefined, `navigate` rejects, and `t` returns the key.
+*/
+function hostApiOf({ connection, data, events, product, stores, toaster }) {
+	const hostData = dataOf(product, data);
+	return (pluginId) => {
+		const connected = connection();
+		return {
+			can: (permission, resourceId) => allowed(stores, product, permission.id, resourceId),
+			data: hostData,
+			emit: (event, payload) => {
+				events.emit(pluginId, event.id, payload);
+			},
+			flag: (flag) => stores.flags.read(flag.id) ?? flag.default ?? false,
+			matched: connected?.matched().at(-1),
+			navigate: (to, options) => connected === void 0 ? Promise.reject(/* @__PURE__ */ new Error(UNCONNECTED)) : connected.navigate(to, options),
+			pluginId,
+			session: stores.session.get().session,
+			t: (key, values) => connected?.translate(pluginId, key, values) ?? key,
+			toaster
+		};
+	};
+}
+//#endregion
+//#region src/recovery/stale.ts
+/**
+* Records the version under the key in the tab's session storage, and returns true where it did.
+*
+* @returns False where the key contains the version already, or where the browser refuses the
+*   storage.
+*/
+function recordReload(key, version) {
+	try {
+		if (window.sessionStorage.getItem(key) === version) return false;
+		window.sessionStorage.setItem(key, version);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Returns the function that reloads the page after a module failed to import, once per build
+* version, and returns true while the page reloads.
+*
+* @remarks
+*   The function records the product's version under `stealth.<productId>.reloaded` before it
+*   reloads. For a version recorded before, it returns false, so a chunk the new build lacks as
+*   well renders the error component instead of a second reload. A server has no page to reload,
+*   and a page whose storage the browser refuses cannot record the version, so both return false.
+* @param product - The product: its id names the storage key, and its version is the build's.
+*/
+function staleRecovery({ productId, version }) {
+	const key = `stealth.${productId}.reloaded`;
+	let reloading = false;
+	return () => {
+		if (reloading) return true;
+		if (typeof window === "undefined" || !recordReload(key, version)) return false;
+		reloading = true;
+		window.location.reload();
+		return true;
+	};
+}
+/**
+* Listens for Vite's `vite:preloadError` event until the returned function is called, and cancels
+* the event where the page reloads.
+*
+* @remarks
+*   Vite's preload helper dispatches the cancelable event on the window for a stylesheet that
+*   failed to preload and for a module that failed to import. A cancelled event makes the import
+*   resolve with no module, which the host's importers keep pending while the page reloads. An
+*   event the listener does not cancel rejects the import.
+* @param recover - Reloads the page once per build version, and returns true while it reloads.
+*/
+function listenForStaleChunks(recover) {
+	/**
+	* Reloads the page for the failed import, and cancels the event where it does.
+	*/
+	const listener = (event) => {
+		if (recover()) event.preventDefault();
+	};
+	window.addEventListener("vite:preloadError", listener);
+	return () => {
+		window.removeEventListener("vite:preloadError", listener);
+	};
+}
+//#endregion
+//#region src/recovery/instrument.ts
+/**
+* The instrumented form of each product the host received, so one product object shares one
+* recovery and one measure per plugin.
+*/
+const INSTRUMENTED = /* @__PURE__ */ new WeakMap();
+/**
+* Returns a promise that never settles, for an import whose page reloads.
+*/
+function reloading() {
+	return new Promise(() => {});
+}
+/**
+* Returns the module an import resolved with.
+*
+* @throws {@link Error} Where the import resolved with no module, as Vite's preload helper resolves
+*   an import whose `vite:preloadError` event a listener cancelled.
+*/
+function moduleOf(module, pluginId) {
+	if (module === void 0) throw new Error(`An import of a module of ${pluginId} resolved with no module.`);
+	return module;
+}
+/**
+* Imports a plugin's module through its importer, measures the plugin's first import, and reloads
+* the page where the import fails.
+*
+* @returns The module, or a promise that never settles while the page reloads.
+* @throws The import's error where the page does not reload.
+*/
+async function imported(importer, pluginId, loading) {
+	const start = loading.startOf(pluginId);
+	let module;
+	try {
+		module = moduleOf(await importer(), pluginId);
+	} catch (error) {
+		if (loading.recover()) return reloading();
+		throw error;
+	}
+	if (start !== void 0) performance.measure(`stealth:load:${pluginId}`, { start });
+	return module;
+}
+/**
+* Returns the importer wrapped, or undefined where a manifest states none.
+*/
+function maybe(importer, wrap) {
+	return importer === void 0 ? void 0 : wrap(importer);
+}
+/**
+* Returns a record with each value mapped, or undefined where a manifest leaves the record out.
+*/
+function mapped(record, map) {
+	return record === void 0 ? void 0 : Object.fromEntries(Object.entries(record).map(([name, value]) => [name, map(value)]));
+}
+/**
+* Returns a plugin's code with every importer wrapped: pages, fallbacks, extensions, commands and
+* settings sections.
+*/
+function codeOf(code, wrap) {
+	return {
+		commands: mapped(code.commands, (entry) => ({
+			...entry,
+			run: wrap(entry.run)
+		})),
+		extensions: mapped(code.extensions, (entry) => ({
+			component: wrap(entry.component),
+			fallback: maybe(entry.fallback, wrap)
+		})),
+		routes: mapped(code.routes, (route) => typeof route === "function" ? wrap(route) : {
+			component: wrap(route.component),
+			fallback: maybe(route.fallback, wrap)
+		}),
+		settings: mapped(code.settings, (entry) => ({
+			...entry,
+			component: maybe(entry.component, wrap)
+		}))
+	};
+}
+/**
+* Returns what the importers of one product share.
+*/
+function loadingOf(product) {
+	const started = /* @__PURE__ */ new Set();
+	return {
+		recover: staleRecovery(product),
+		startOf: (pluginId) => {
+			const first = !started.has(pluginId);
+			started.add(pluginId);
+			return first ? performance.now() : void 0;
+		}
+	};
+}
+/**
+* Returns the product with every importer of its manifests wrapped, once per product object.
+*
+* @remarks
+*   A wrapped importer measures its plugin's first import as `stealth:load:<plugin id>`, from the
+*   moment the import starts until the module resolves. Where an import rejects or resolves with no
+*   module, the page reloads once per build version, and the import never settles. A second failure
+*   for the same version rejects, and the route's error component or the extension's boundary
+*   renders it. `createRuntime` and `createHostRoutes` both wrap the product they receive, so a
+*   product that passes one object to `createHost` and `createHostRoutes` shares one recovery and
+*   one measure per plugin.
+* @param product - The product, with each installed plugin's manifest.
+*/
+function instrumented(product) {
+	const known = INSTRUMENTED.get(product);
+	if (known !== void 0) return known;
+	const loading = loadingOf(product);
+	const manifests = Object.fromEntries(Object.entries(product.manifests).map(([pluginId, manifest]) => [pluginId, {
+		...manifest,
+		code: codeOf(manifest.code, (importer) => () => imported(importer, pluginId, loading))
+	}]));
+	const result = {
+		product: {
+			...product,
+			manifests
+		},
+		recover: loading.recover
+	};
+	INSTRUMENTED.set(product, result);
+	return result;
+}
+//#endregion
+//#region src/host/runtime.ts
+/**
+* Builds the runtime the hooks of `sdk-plugin` read: the product, the stores, the bus, the toaster,
+* the setting store, the report and the command registry.
+*/
+/**
+* Returns the runtime of one host, with the product's one toaster.
+*
+* @remarks
+*   The runtime's product is the given product with its manifests' importers wrapped by
+*   `instrumented`, so every import of a plugin's module, an extension's included, is measured and
+*   recovers from a chunk that no longer exists. The toaster raises toasts at the end of the
+*   window's bottom edge, five at a time, overlapping until a pointer rests on them. A command runs
+*   with the routes matched at the moment of its run, and with no route before `HostProvider`
+*   connects the router.
+*/
+function createRuntime({ connection, data, events, product, report, settings, stores }) {
+	const { product: loaded, recover } = instrumented(product);
+	const toaster = Toast.createToaster({
+		max: 5,
+		overlap: true,
+		placement: "bottom-end"
+	});
+	return {
+		events,
+		product: loaded,
+		recover,
+		report,
+		run: createCommandRegistry({
+			hostOf: hostApiOf({
+				connection,
+				data,
+				events,
+				product: loaded,
+				stores,
+				toaster
+			}),
+			matched: () => {
+				const connected = connection();
+				return connected === void 0 ? void 0 : new Set(connected.matched());
+			},
+			product: loaded,
+			stores
+		}),
+		settings,
+		stores,
+		toaster
+	};
+}
+//#endregion
+//#region src/host/sequence.ts
+/**
+* Runs the host's side of a change of session: the `host/sessionChanged` event, the reset of the
+* previous subject's data and decisions, and the flag source's identification.
+*/
+/**
+* Emits the session as the sticky `host/sessionChanged` now and after every change, and identifies
+* each session to the flag source.
+*
+* @remarks
+*   The switch and placement stores move to a new subject's keys before the event, because they
+*   subscribed to the session first. A change of subject then resets the data client and clears
+*   the access store, so a subject renders no data and no decision of the subject before it. The
+*   flags keep their values while the flag source identifies the new session.
+*/
+function followSession({ access, data, events, flags, session }) {
+	let subject = subjectOf(session.get().session);
+	/**
+	* Emits the session as the host.
+	*/
+	const announce = (current) => {
+		events.emit(HOST, hostContract.events.sessionChanged.id, current);
+	};
+	announce(session.get().session);
+	return {
+		identified: flags.identify(session.get().session),
+		stop: session.subscribe(() => {
+			const current = session.get().session;
+			const next = subjectOf(current);
+			announce(current);
+			if (next !== subject) {
+				subject = next;
+				resetData(data);
+				access.clear();
+			}
+			flags.identify(current);
+		})
+	};
+}
+//#endregion
+//#region src/stores/access.ts
+/**
+* Milliseconds the checks of a failed batch read as denied before the next read asks again.
+*/
+const DENIED_FOR = 3e4;
+/**
+* Returns the start every decision key on one resource shares.
+*/
+function resourcePrefix({ id, type }) {
+	return `${JSON.stringify([type, id]).slice(0, -1)},`;
+}
+/**
+* Returns the store of decisions, empty.
+*/
+function decisionsOf(source) {
+	const state = writable({
+		decisions: /* @__PURE__ */ new Map(),
+		source
+	});
+	const timers = /* @__PURE__ */ new Set();
+	/**
+	* Writes decisions over the known ones.
+	*/
+	const decide = (entries) => {
+		state.set({
+			...state.get(),
+			decisions: new Map([...state.get().decisions, ...entries])
+		});
+	};
+	/**
+	* Removes the decisions whose keys a predicate accepts.
+	*/
+	const remove = (accepts) => {
+		const kept = [...state.get().decisions].filter(([key]) => !accepts(key));
+		if (kept.length !== state.get().decisions.size) state.set({
+			...state.get(),
+			decisions: new Map(kept)
+		});
+	};
+	return {
+		cancel: () => {
+			for (const timer of timers) clearTimeout(timer);
+			timers.clear();
+		},
+		decide,
+		deny: (keys) => {
+			decide(keys.map((key) => [key, false]));
+			const timer = setTimeout(() => {
+				timers.delete(timer);
+				remove((key) => keys.includes(key) && state.get().decisions.get(key) === false);
+			}, DENIED_FOR);
+			timers.add(timer);
+		},
+		remove,
+		state
+	};
+}
+/**
+* Returns the batches sent to the source, each settled through one of the two callbacks.
+*
+* @param source - The product's access source.
+* @param decided - Receives a batch's keys and the decision of each.
+* @param failed - Receives a failed batch's keys and the error.
+*/
+function batchesOf(source, decided, failed) {
+	const queued = /* @__PURE__ */ new Map();
+	const flying = /* @__PURE__ */ new Map();
+	let generation = 0;
+	/**
+	* Sends the queued checks in one call, and nothing where none is queued.
+	*/
+	const flush = async () => {
+		const batch = [...queued];
+		const keys = batch.map(([key]) => key);
+		const started = generation;
+		if (batch.length === 0) return;
+		queued.clear();
+		for (const [key, check] of batch) flying.set(key, check);
+		try {
+			const allowed = await source.check(batch.map(([, check]) => check));
+			if (allowed.length !== keys.length) throw new Error(`The access source decided ${String(allowed.length)} of ${String(keys.length)} checks.`);
+			if (started === generation) decided(keys, allowed);
+		} catch (error) {
+			if (started === generation) failed(keys, error);
+		} finally {
+			if (started === generation) for (const key of keys) flying.delete(key);
+		}
+	};
+	/**
+	* Queues a check, and sends the queue at the end of the task.
+	*/
+	const queue = (key, check) => {
+		if (queued.size === 0) queueMicrotask(() => {
+			flush();
+		});
+		queued.set(key, check);
+	};
+	return {
+		clear: () => {
+			const waiting = [...queued, ...flying];
+			generation += 1;
+			queued.clear();
+			flying.clear();
+			for (const [key, check] of waiting) queue(key, check);
+		},
+		has: (key) => queued.has(key) || flying.has(key),
+		queue
+	};
+}
+/**
+* Returns the access store over the product's access source.
+*
+* @remarks
+*   Every check requested in one task goes to `check` in one call, with a known decision, a queued
+*   check and a check in flight left out. A batch that rejects, or resolves with a list of another
+*   length, denies its checks for 30 seconds and reports `access-failed`. A change of subject, or a
+*   notification from the source, clears the store. A batch still in flight then writes nothing,
+*   and its checks go to the source again, because their readers keep reading them as pending and
+*   would not ask again. A primed decision for a permission no installed plugin declares is
+*   ignored.
+*/
+function createAccessStore({ product, report, source }) {
+	const declared = new Set(product.permissions.map(({ id }) => id));
+	const { cancel, decide, deny, remove, state } = decisionsOf(source !== void 0);
+	const batches = source === void 0 ? void 0 : batchesOf(source, (keys, allowed) => {
+		decide(keys.map((key, index) => [key, allowed[index] === true]));
+	}, (keys, error) => {
+		deny(keys);
+		report({
+			error,
+			kind: "access-failed"
+		});
+	});
+	/**
+	* Drops every decision, every queued check and every batch in flight.
+	*/
+	const clear = () => {
+		batches?.clear();
+		cancel();
+		remove(() => true);
+	};
+	const stop = source?.subscribe?.(clear);
+	return {
+		clear,
+		dispose: () => {
+			stop?.();
+			cancel();
+		},
+		forget: (resource) => {
+			const prefix = resource === void 0 ? "" : resourcePrefix(resource);
+			remove((key) => key.startsWith(prefix));
+		},
+		get: state.get,
+		hydrate: decide,
+		prime: (decisions) => {
+			decide(decisions.filter(({ permission }) => declared.has(permission)).map((decision) => [decisionKey(decision), decision.allowed]));
+		},
+		request: (check) => {
+			const key = decisionKey(check);
+			if (batches === void 0 || state.get().decisions.has(key) || batches.has(key)) return;
+			batches.queue(key, check);
+		},
+		subscribe: state.subscribe
+	};
+}
+//#endregion
+//#region src/stores/availability.ts
+/**
+* Computes whether each installed plugin is on, and why it is not, from its kill switch, its
+* switch, its condition and the plugins it requires.
+*/
+/**
+* The availability of a plugin that passes every test.
+*/
+const ON = { on: true };
+/**
+* Returns every installed plugin's availability, in install order.
+*
+* @remarks
+*   A plugin is computed on first need, so it is computed after every plugin its condition names
+*   and every plugin it requires, whatever the install order. A plugin on a ring of conditions and
+*   requirements, which the build refuses, reads as off to the plugin that asks.
+*/
+function availabilityOf({ availability, flags, plugins, session, switches }) {
+	const installed = new Map(plugins.map((plugin) => [plugin.id, plugin]));
+	const known = /* @__PURE__ */ new Map();
+	const computing = /* @__PURE__ */ new Set();
+	/**
+	* Returns true where a plugin is installed, not being computed, and on.
+	*/
+	const on = (pluginId) => {
+		const plugin = installed.get(pluginId);
+		return plugin !== void 0 && !computing.has(pluginId) && computed(plugin).on;
+	};
+	const context = {
+		...conditionContextOf({
+			availability,
+			flags,
+			session
+		}),
+		on
+	};
+	/**
+	* Returns a plugin's availability: the reason of the first test it fails, else on.
+	*/
+	const tested = (plugin) => {
+		if (flags.read(plugin.killSwitch) === false) return {
+			on: false,
+			reason: "unavailable"
+		};
+		if (!plugin.locked && switches[plugin.id] === false) return {
+			on: false,
+			reason: "off"
+		};
+		if (!evaluateWhen(plugin.when, context)) return {
+			on: false,
+			reason: "condition"
+		};
+		if (plugin.requires.some(({ optional, pluginId }) => optional !== true && !on(pluginId))) return {
+			on: false,
+			reason: "requirement"
+		};
+		return ON;
+	};
+	/**
+	* Returns a plugin's availability, computed once per computation.
+	*/
+	const computed = (plugin) => {
+		const done = known.get(plugin.id);
+		if (done !== void 0) return done;
+		computing.add(plugin.id);
+		const state = tested(plugin);
+		computing.delete(plugin.id);
+		known.set(plugin.id, state);
+		return state;
+	};
+	return plugins.map((plugin) => [plugin.id, computed(plugin)]);
+}
+/**
+* Returns the availability store, computed now and again whenever the session, a flag or a switch
+* changes.
+*
+* @remarks
+*   The tests run in this order, and the first a plugin fails gives its reason: its kill switch is
+*   on (`unavailable`), it is locked or switched on (`off`), its condition is true (`condition`),
+*   and every plugin it requires without `optional` is on (`requirement`). A computation that
+*   changes no plugin's state publishes nothing. A plugin whose reason changes while it remains
+*   off is published without a call to `changed`.
+*/
+function createAvailabilityStore({ changed, flags, product, session, switches }) {
+	const availability = writable({});
+	/**
+	* Returns every plugin's availability as the stores are now.
+	*/
+	const compute = () => availabilityOf({
+		availability,
+		flags,
+		plugins: product.plugins,
+		session,
+		switches: switches.get()
+	});
+	const first = compute();
+	let states = new Map(first.map(([pluginId, state]) => [pluginId, state.on]));
+	availability.set(Object.fromEntries(first));
+	/**
+	* Computes every plugin's availability again, publishes it where it changed, and passes each
+	* plugin that turned on or off to `changed`.
+	*/
+	const recompute = () => {
+		const entries = compute();
+		const next = Object.fromEntries(entries);
+		if (JSON.stringify(next) === JSON.stringify(availability.get())) return;
+		const before = states;
+		states = new Map(entries.map(([pluginId, state]) => [pluginId, state.on]));
+		availability.set(next);
+		for (const [pluginId, state] of entries) if (before.get(pluginId) !== state.on) changed({
+			...state,
+			pluginId
+		});
+	};
+	const stops = [
+		session.subscribe(recompute),
+		flags.subscribe(recompute),
+		switches.subscribe(recompute)
+	];
+	return {
+		dispose: () => {
+			for (const stop of stops) stop();
+		},
+		get: availability.get,
+		subscribe: availability.subscribe
+	};
+}
+//#endregion
+//#region src/stores/flag-session.ts
+/**
+* Returns the record of the variants served, for no subject yet.
+*
+* @param queue - Receives `flag-exposed` for each variant the subject is served first.
+*/
+function exposuresOf(queue) {
+	const served = /* @__PURE__ */ new Set();
+	let current;
+	return {
+		expose: (flag, value) => {
+			if (typeof value !== "string") return;
+			const key = JSON.stringify([flag.id, value]);
+			if (served.has(key)) return;
+			served.add(key);
+			queue({
+				flag: flag.id,
+				kind: "flag-exposed",
+				variant: value
+			});
+		},
+		reset: (subject) => {
+			if (subject === current) return;
+			current = subject;
+			served.clear();
+		},
+		serve: (subject, flag, value) => {
+			if (subject === current) served.add(JSON.stringify([flag.id, value]));
+		}
+	};
+}
+/**
+* Returns whom the flag source evaluates for: every session for a source without `identify`, and no
+* session until the first `identify` resolves for a source with it.
+*
+* @param source - The product's flag source.
+* @param failed - Receives the error of an `identify` that rejected and was not overtaken.
+*/
+function identityOf(source, failed) {
+	let identified = source?.identify === void 0;
+	let generation = 0;
+	return {
+		identify: async (session) => {
+			if (source?.identify === void 0) return true;
+			generation += 1;
+			identified = false;
+			const started = generation;
+			try {
+				await source.identify(session);
+			} catch (error) {
+				if (started === generation) failed(error);
+				return false;
+			}
+			if (started !== generation) return false;
+			identified = true;
+			return true;
+		},
+		stop: () => {
+			generation += 1;
+		},
+		trusted: () => identified ? source : void 0
+	};
+}
+//#endregion
+//#region src/stores/flags.ts
+/**
+* Keeps the flags the page reads for the session, each evaluated on its first read, and the
+* overrides of this tab.
+*
+* @remarks
+*   A flag takes the value of the first of these that states one fitting the flag: the tab's
+*   override, the flag source, the product, the contract's default. A value that does not fit is
+*   reported as `flag-ignored`, and the next one applies. The store evaluates a flag only when the
+*   page reads it, so a flag service that records an exposure on evaluation records one only for a
+*   variant the person saw.
+*/
+/**
+* Returns true where a value fits a flag: a boolean for a release or an ops flag, one of its
+* variants for an experiment.
+*/
+function fits(flag, value) {
+	return flag.type === "boolean" ? typeof value === "boolean" : typeof value === "string" && flag.variants?.includes(value) === true;
+}
+/**
+* Returns the flag source's value for a flag, or undefined where the source states none or throws.
+* A throw queues `flags-failed`.
+*/
+function stated(flag, source, queue) {
+	if (source === void 0) return void 0;
+	try {
+		return source.evaluate({
+			id: flag.id,
+			type: flag.type
+		});
+	} catch (error) {
+		queue({
+			error,
+			kind: "flags-failed"
+		});
+		return;
+	}
+}
+/**
+* Returns the reading of the first of these that states a value fitting the flag: the flag source,
+* the product, the contract's default.
+*
+* @param flag - The declared flag.
+* @param source - The flag source, or undefined while it evaluates for no identified session.
+* @param queue - Receives `flags-failed` for a source that throws, and `flag-ignored` for a value
+*   that does not fit.
+*/
+function evaluate(flag, source, queue) {
+	const value = stated(flag, source, queue);
+	if (fits(flag, value)) return {
+		origin: "source",
+		value
+	};
+	if (value !== void 0) queue({
+		flag: flag.id,
+		kind: "flag-ignored",
+		source: "source",
+		value
+	});
+	if (fits(flag, flag.product)) return {
+		origin: "product",
+		value: flag.product
+	};
+	if (flag.product !== void 0) queue({
+		flag: flag.id,
+		kind: "flag-ignored",
+		source: "product",
+		value: flag.product
+	});
+	return {
+		origin: "contract",
+		value: flag.default
+	};
+}
+/**
+* Returns true where two maps contain the same reading objects.
+*/
+function same(shown, taken) {
+	return shown.size === taken.size && [...taken].every(([id, reading]) => shown.get(id) === reading);
+}
+/**
+* Returns the store's state, empty, and the queue of its reports.
+*/
+function publishedOf(report) {
+	const state = writable({
+		overrides: {},
+		readings: /* @__PURE__ */ new Map()
+	});
+	const readings = /* @__PURE__ */ new Map();
+	const pending = [];
+	let overrides = {};
+	let scheduled = false;
+	/**
+	* Publishes the readings and the overrides where they changed, then passes each queued report on.
+	*/
+	const flush = () => {
+		const shown = state.get();
+		scheduled = false;
+		if (shown.overrides !== overrides || !same(shown.readings, readings)) state.set({
+			overrides,
+			readings: new Map(readings)
+		});
+		for (const entry of pending.splice(0)) report(entry);
+	};
+	return {
+		flush,
+		queue: (entry) => {
+			pending.push(entry);
+		},
+		readings,
+		schedule: () => {
+			if (scheduled) return;
+			scheduled = true;
+			queueMicrotask(flush);
+		},
+		setOverrides: (next) => {
+			overrides = next;
+		},
+		state
+	};
+}
+/**
+* Returns true where a parsed value is an object whose members can be read by name.
+*/
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Returns the object stored text contains, or an empty object for no text, for text that is not
+* JSON, and for JSON that is not an object.
+*/
+function parsed(text) {
+	if (text === null) return {};
+	try {
+		const value = JSON.parse(text);
+		return isRecord$1(value) ? value : {};
+	} catch {
+		return {};
+	}
+}
+/**
+* Returns the overrides the tab's storage contains that fit a declared flag, and queues
+* `flag-ignored` for each that does not fit. An override for a flag no installed plugin declares is
+* left out without a report.
+*/
+function storedOverrides(storage, key, declared, queue) {
+	const kept = [];
+	for (const [id, value] of Object.entries(parsed(storage?.getItem(key) ?? null))) {
+		const flag = declared.get(id);
+		if (flag === void 0) continue;
+		if (fits(flag, value)) kept.push([id, value]);
+		else queue({
+			flag: id,
+			kind: "flag-ignored",
+			source: "override",
+			value
+		});
+	}
+	return Object.fromEntries(kept);
+}
+/**
+* Writes the overrides to the tab's storage, or removes the key where none is left.
+*
+* @returns False where the storage refused the write. The overrides then last until the page
+*   reloads.
+*/
+function written(storage, key, overrides) {
+	try {
+		if (Object.keys(overrides).length === 0) storage.removeItem(key);
+		else storage.setItem(key, JSON.stringify(overrides));
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Returns the overrides with a flag's override replaced, or removed where the value is undefined.
+*/
+function withOverride(overrides, id, value) {
+	const kept = Object.entries(overrides).filter(([flag]) => flag !== id);
+	return Object.fromEntries(value === void 0 ? kept : [...kept, [id, value]]);
+}
+/**
+* Returns the store's `read`: the tab's override, else the reading the page took, else a first
+* evaluation, published at the end of the task.
+*/
+function readerOf({ declared, exposures, identity, published }) {
+	/**
+	* Evaluates a flag the page reads for the first time, and publishes the reading at the end of
+	* the task.
+	*/
+	const first = (flag) => {
+		const reading = evaluate(flag, identity.trusted(), published.queue);
+		published.readings.set(flag.id, reading);
+		exposures.expose(flag, reading.value);
+		published.schedule();
+		return reading.value;
+	};
+	return (id) => {
+		const overridden = published.state.get().overrides[id];
+		if (overridden !== void 0) return overridden;
+		const known = published.readings.get(id);
+		if (known !== void 0) return known.value;
+		const flag = declared.get(id);
+		return flag === void 0 ? void 0 : first(flag);
+	};
+}
+/**
+* Returns the store's `override`, which does nothing without the tab's storage. An override drops
+* the flag's reading, so the page evaluates the flag again once the override is removed.
+*/
+function overriderOf({ declared, published }, storage, key) {
+	return (id, value) => {
+		const flag = declared.get(id);
+		if (storage === void 0 || flag === void 0) return;
+		if (value !== void 0 && !fits(flag, value)) published.queue({
+			flag: id,
+			kind: "flag-ignored",
+			source: "override",
+			value
+		});
+		else {
+			const next = withOverride(published.state.get().overrides, id, value);
+			published.readings.delete(id);
+			published.setOverrides(next);
+			written(storage, key, next);
+		}
+		published.flush();
+	};
+}
+/**
+* Returns the function that evaluates again every flag the page has read, publishes the readings
+* that changed, and reports the variants the subject is served for the first time.
+*/
+function reevaluatorOf({ exposures, identity, published }, flags) {
+	return () => {
+		for (const flag of flags) {
+			const reading = published.readings.get(flag.id);
+			if (reading === void 0) continue;
+			const next = evaluate(flag, identity.trusted(), published.queue);
+			if (next.value !== reading.value || next.origin !== reading.origin) published.readings.set(flag.id, next);
+			exposures.expose(flag, next.value);
+		}
+		published.flush();
+	};
+}
+/**
+* Returns a store's hydration: the server's readings until `settle`, with the tab's overrides set
+* aside until then.
+*
+* @remarks
+*   A reading for a flag the browser's build does not declare, or whose value does not fit the
+*   flag, is left out, as a server and a browser of two builds may differ.
+* @param shared - The declared flags, the exposures and the state the store's parts share.
+* @param reevaluate - Evaluates again every flag the page has read.
+* @param waiting - Returns true while the flag source has not identified the session.
+*/
+function hydrationOf(shared, reevaluate, waiting) {
+	const { declared, exposures, published } = shared;
+	let active = false;
+	let aside = {};
+	return {
+		active: () => active,
+		hydrate: (readings, subject) => {
+			active = true;
+			aside = published.state.get().overrides;
+			published.setOverrides({});
+			for (const [id, reading] of readings) {
+				const flag = declared.get(id);
+				if (flag === void 0 || !fits(flag, reading.value)) continue;
+				published.readings.set(id, reading);
+				exposures.serve(subject, flag, reading.value);
+			}
+			published.flush();
+		},
+		settle: () => {
+			if (!active) return;
+			active = false;
+			published.setOverrides(aside);
+			if (waiting()) published.flush();
+			else reevaluate();
+		}
+	};
+}
+/**
+* Returns the flag store over the product's flags, its flag source and the tab's storage.
+*
+* @remarks
+*   A first read evaluates the flag and returns its value at once, and publishes the reading at the
+*   end of the task, because the hooks read a flag inside a `useSyncExternalStore` snapshot. The
+*   source is asked only once it identified the session. Until then a flag takes the product's
+*   value or its default. Each notification of the source and each identification evaluates again
+*   the flags the page has read, and the previous values remain while `identify` is pending.
+*   `flag-exposed` is reported the first time the session's subject is served each variant of an
+*   experiment. An override counts no exposure. A store a server render hydrated reads the
+*   server's readings until `settle`, and evaluates again only then.
+*/
+function createFlagStore({ overrides: storage, product, report, source }) {
+	const published = publishedOf(report);
+	const declared = new Map(product.flags.map((flag) => [flag.id, flag]));
+	const key = `stealth.${product.productId}.flag-overrides`;
+	const shared = {
+		declared,
+		exposures: exposuresOf(published.queue),
+		identity: identityOf(source, (error) => {
+			published.queue({
+				error,
+				kind: "flags-failed"
+			});
+			published.flush();
+		}),
+		published
+	};
+	const reevaluate = reevaluatorOf(shared, product.flags);
+	const hydration = hydrationOf(shared, reevaluate, () => source !== void 0 && shared.identity.trusted() === void 0);
+	published.setOverrides(storedOverrides(storage, key, declared, published.queue));
+	published.flush();
+	const stop = source?.subscribe(() => {
+		if (shared.identity.trusted() !== void 0 && !hydration.active()) reevaluate();
+	});
+	return {
+		dispose: () => {
+			stop?.();
+			shared.identity.stop();
+		},
+		get: published.state.get,
+		hydrate: hydration.hydrate,
+		identify: async (session) => {
+			shared.exposures.reset(subjectOf(session));
+			if (await shared.identity.identify(session) && !hydration.active()) reevaluate();
+		},
+		override: overriderOf(shared, storage, key),
+		read: readerOf(shared),
+		settle: hydration.settle,
+		snapshot: () => [...published.readings],
+		subscribe: published.state.subscribe
+	};
+}
+//#endregion
+//#region src/stores/subject.ts
+/**
+* Names the subject a person's stored choices belong to.
+*/
+/**
+* Returns the subject a session's stored choices are kept under: its person and tenant, or
+* `anyone` for a session nobody signed in to.
+*/
+function subjectFor({ session }) {
+	return subjectOf(session) ?? "anyone";
+}
+//#endregion
+//#region src/stores/placements.ts
+/**
+* The version of the stored value this host writes and reads.
+*/
+const VERSION = 1;
+/**
+* The members of a slot's placement.
+*/
+const MEMBERS = [
+	"add",
+	"order",
+	"remove"
+];
+/**
+* The check of no stored value.
+*/
+const NOTHING = {
+	dropped: [],
+	slots: {}
+};
+/**
+* Returns true for a plain object.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Returns true for a list.
+*/
+function isList(value) {
+	return Array.isArray(value);
+}
+/**
+* Returns one slot's placement with the members and ids the installed plugins allow, and a reason
+* for each part it drops.
+*/
+function placementOf(slot, stated, extensions) {
+	if (!isRecord(stated)) return { dropped: [`${slot.id} is not a placement`] };
+	const dropped = [];
+	const placement = {};
+	/**
+	* Returns true for the id of an extension an installed plugin declares.
+	*/
+	const declared = (id) => typeof id === "string" && extensions.has(id);
+	for (const member of MEMBERS) {
+		const listed = stated[member];
+		const path = `${slot.id}.${member}`;
+		if (listed === void 0) continue;
+		if (member === "add" && !slot.region) dropped.push(`${path} places extensions in a slot that is not a region`);
+		else if (isList(listed)) {
+			for (const id of listed.filter((one) => !declared(one))) dropped.push(`${path} lists ${JSON.stringify(id)}, which no installed plugin declares`);
+			placement[member] = listed.filter((one) => declared(one));
+		} else dropped.push(`${path} is not a list`);
+	}
+	return {
+		dropped,
+		placement
+	};
+}
+/**
+* Returns the placements of the slots an installed plugin declares, and a reason for each part it
+* drops.
+*/
+function checkedOf(stated, slots, extensions) {
+	const dropped = [];
+	const kept = {};
+	for (const [slotId, placement] of Object.entries(stated)) {
+		const slot = slots[slotId];
+		if (slot === void 0) {
+			dropped.push(`${slotId} is not a slot an installed plugin declares`);
+			continue;
+		}
+		const read = placementOf(slot, placement, extensions);
+		dropped.push(...read.dropped);
+		if (read.placement !== void 0) kept[slotId] = read.placement;
+	}
+	return {
+		dropped,
+		slots: kept
+	};
+}
+/**
+* Returns the placements stored text contains, checked, or why the store drops the whole value.
+*/
+function readOf(text, slots, extensions) {
+	if (text === null) return NOTHING;
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return {
+			dropped: ["the stored value is not JSON"],
+			slots: {}
+		};
+	}
+	if (!isRecord(parsed) || !isRecord(parsed["slots"])) return {
+		dropped: ["the stored value has no slots"],
+		slots: {}
+	};
+	const { version } = parsed;
+	if (typeof version === "number" && version > VERSION) return NOTHING;
+	return version === VERSION ? checkedOf(parsed["slots"], slots, extensions) : {
+		dropped: [`the stored value is not version ${String(VERSION)}`],
+		slots: {}
+	};
+}
+/**
+* Returns the placement store over the setting store, for the session's subject.
+*
+* @remarks
+*   The store checks a stored value once per text it reads, so one value is reported once. A change
+*   of subject reads the new subject's key and follows it alone. `update` checks the change,
+*   reports what it drops, and writes the rest over the placements of the slots it does not name.
+*/
+function createPlacementStore({ product, report, session, store }) {
+	const extensions = new Set(product.extensions.map(({ id }) => id));
+	let subject = subjectFor(session.get());
+	let text;
+	/**
+	* Returns the key of the placements for the current subject.
+	*/
+	const keyOf = () => settingKey(product.productId, `${subject}.placements`);
+	/**
+	* Reports each reason a check dropped a part.
+	*/
+	const reported = ({ dropped, slots }) => {
+		for (const reason of dropped) report({
+			key: keyOf(),
+			kind: "setting-dropped",
+			reason
+		});
+		return slots;
+	};
+	/**
+	* Returns the stored placements where the stored text changed, else the current ones.
+	*/
+	const read = (current) => {
+		const stored = store.read(keyOf());
+		if (stored === text) return current;
+		text = stored;
+		return reported(readOf(stored, product.slots, extensions));
+	};
+	const state = writable(read({}));
+	/**
+	* Reads the stored placements again, and publishes them where they changed.
+	*/
+	const refresh = () => {
+		state.set(read(state.get()));
+	};
+	let stop = store.subscribe(keyOf(), refresh);
+	const stopSession = session.subscribe(() => {
+		const next = subjectFor(session.get());
+		if (next === subject) return;
+		subject = next;
+		stop();
+		stop = store.subscribe(keyOf(), refresh);
+		refresh();
+	});
+	return {
+		dispose: () => {
+			stopSession();
+			stop();
+		},
+		get: state.get,
+		reset: () => {
+			store.clear(keyOf());
+			refresh();
+		},
+		subscribe: state.subscribe,
+		update: (change) => {
+			const slots = reported(checkedOf({
+				...state.get(),
+				...change
+			}, product.slots, extensions));
+			store.write(keyOf(), JSON.stringify({
+				slots,
+				version: VERSION
+			}));
+			refresh();
+		}
+	};
+}
+//#endregion
+//#region src/stores/session.ts
+/**
+* Keeps the session a product's source reports, with its grants as sets of the ids the installed
+* plugins declare.
+*/
+/**
+* Returns a session's state, with its permissions and entitlements reduced to the declared ids.
+*/
+function stateOf(session, permissions, entitlements) {
+	return {
+		entitlements: new Set(session.entitlements.filter((id) => entitlements.has(id))),
+		permissions: new Set(session.permissions.filter((id) => permissions.has(id))),
+		session
+	};
+}
+/**
+* Returns the session store, which reads the source now and again after each notification.
+*
+* @remarks
+*   A permission or an entitlement no installed plugin declares is left out of the sets, so a
+*   check for it is false. A notification after which `read` returns the same object changes
+*   nothing. A `read` that throws keeps the last session and reports `session-failed`. Before the
+*   first successful read the session is `NOBODY`.
+*/
+function createSessionStore({ product, report, source }) {
+	const permissions = new Set(product.permissions.map(({ id }) => id));
+	const entitlements = new Set(product.entitlements.map(({ id }) => id));
+	/**
+	* Returns the source's session, or undefined after reporting a `read` that threw.
+	*/
+	const read = () => {
+		try {
+			return source.read();
+		} catch (error) {
+			report({
+				error,
+				kind: "session-failed"
+			});
+			return;
+		}
+	};
+	const store = writable(stateOf(read() ?? NOBODY, permissions, entitlements));
+	/**
+	* Reads the source, and publishes the session where it is another object.
+	*/
+	const refresh = () => {
+		const session = read();
+		if (session !== void 0 && session !== store.get().session) store.set(stateOf(session, permissions, entitlements));
+	};
+	return {
+		dispose: source.subscribe(refresh),
+		get: store.get,
+		refresh,
+		subscribe: store.subscribe
+	};
+}
+//#endregion
+//#region src/stores/switches.ts
+/**
+* Returns a switchable plugin's switch as stored, or the product's `enabled` where nothing is
+* stored. A stored value other than `on` and `off` is reported and reads as `enabled`.
+*/
+function switchOf(plugin, key, store, report) {
+	const stored = store.read(key);
+	if (stored === "on") return true;
+	if (stored === "off") return false;
+	if (stored !== null) report({
+		key,
+		kind: "setting-dropped",
+		reason: `the stored switch is ${JSON.stringify(stored)}, neither "on" nor "off"`
+	});
+	return plugin.enabled;
+}
+/**
+* Returns the switch store over the setting store, for the session's subject.
+*
+* @remarks
+*   A change of subject reads every switch from the new subject's keys and follows those keys
+*   alone. A write to a key the store follows, from this tab or another, reads that switch again.
+*/
+function createSwitchStore({ product, report, session, store }) {
+	const switchable = product.plugins.filter(({ locked }) => !locked);
+	const locked = product.plugins.filter((plugin) => plugin.locked);
+	let subject = subjectFor(session.get());
+	/**
+	* Returns the key of a plugin's switch for the current subject.
+	*/
+	const keyOf = (pluginId) => settingKey(product.productId, `${subject}.plugin.${pluginId}`);
+	/**
+	* Reads every switch of the subject, and reports a value stored for a locked plugin.
+	*/
+	const read = () => {
+		for (const { id } of locked) if (store.read(keyOf(id)) !== null) report({
+			key: keyOf(id),
+			kind: "setting-dropped",
+			reason: "the plugin is locked"
+		});
+		return Object.fromEntries(switchable.map((plugin) => [plugin.id, switchOf(plugin, keyOf(plugin.id), store, report)]));
+	};
+	const state = writable(read());
+	/**
+	* Reads one plugin's switch again, and publishes it where it changed.
+	*/
+	const refresh = (plugin) => {
+		const on = switchOf(plugin, keyOf(plugin.id), store, report);
+		if (state.get()[plugin.id] !== on) state.set({
+			...state.get(),
+			[plugin.id]: on
+		});
+	};
+	/**
+	* Follows the key of every switchable plugin for the current subject.
+	*/
+	const follow = () => switchable.map((plugin) => store.subscribe(keyOf(plugin.id), () => {
+		refresh(plugin);
+	}));
+	let stops = follow();
+	const stopSession = session.subscribe(() => {
+		const next = subjectFor(session.get());
+		if (next === subject) return;
+		subject = next;
+		for (const stop of stops) stop();
+		stops = follow();
+		state.set(read());
+	});
+	return {
+		dispose: () => {
+			stopSession();
+			for (const stop of stops) stop();
+		},
+		get: state.get,
+		set: (pluginId, on) => {
+			const plugin = switchable.find(({ id }) => id === pluginId);
+			if (plugin === void 0) return;
+			store.write(keyOf(pluginId), on ? "on" : "off");
+			refresh(plugin);
+		},
+		subscribe: state.subscribe
+	};
+}
+//#endregion
+//#region src/host/state.ts
+/**
+* Creates the host's stores that follow the session: the session, the decisions, the flags, the
+* switches, the availability and the placements.
+*/
+/**
+* Returns the tab's session storage where overrides are on, or undefined.
+*
+* @remarks
+*   Overrides are on outside a production build unless the product states otherwise. A server has
+*   no tab, and a page whose storage the browser refuses keeps no override.
+* @param overrides - The product's choice, where it states one.
+*/
+function overridesOf(overrides) {
+	if (!(overrides ?? process.env.NODE_ENV !== "production") || typeof window === "undefined") return;
+	try {
+		return window.sessionStorage;
+	} catch {
+		return;
+	}
+}
+/**
+* Returns the stores that follow the session, each created from the product's sources.
+*
+* @remarks
+*   The availability store emits `host/pluginChanged` as the host for every plugin that turns on or
+*   off.
+*/
+function createState({ events, options, report }) {
+	const { product, store } = options;
+	const session = createSessionStore({
+		product,
+		report,
+		source: options.session
+	});
+	const access = createAccessStore({
+		product,
+		report,
+		source: options.access
+	});
+	const flags = createFlagStore({
+		overrides: overridesOf(options.overrides),
+		product,
+		report,
+		source: options.flags
+	});
+	const switches = createSwitchStore({
+		product,
+		report,
+		session,
+		store
+	});
+	const availability = createAvailabilityStore({
+		changed: (change) => {
+			events.emit(HOST, hostContract.events.pluginChanged.id, change);
+		},
+		flags,
+		product,
+		session,
+		switches
+	});
+	const placements = createPlacementStore({
+		product,
+		report,
+		session,
+		store
+	});
+	return {
+		dispose: () => {
+			availability.dispose();
+			placements.dispose();
+			switches.dispose();
+			flags.dispose();
+			access.dispose();
+			session.dispose();
+		},
+		stores: {
+			access,
+			availability,
+			flags,
+			placements,
+			session
+		},
+		switches
+	};
+}
+//#endregion
+//#region src/host/create-host.ts
+/**
+* Creates the host of one page, or of one request on a server.
+*/
+/**
+* Milliseconds `ready` waits for the flag source's first identification, where the product states
+* none.
+*/
+const FLAGS_TIMEOUT = 1e3;
+/**
+* Creates a host for one page, or for one request on a server.
+*
+* @remarks
+*   The host subscribes to the session source, the setting store, the flag source and the access
+*   source as it is created. It emits the session as `host/sessionChanged`, and starts the flag
+*   source's identification and the eager plugins' imports. The imports go through the runtime's
+*   product, whose importers measure each plugin's first import and recover from a chunk that no
+*   longer exists. `dispose` ends the subscriptions and cancels the data client's fetches.
+* @throws {@link Error} Where the product's manifests lack code for a declared name.
+*/
+function createHost(options) {
+	const { product } = options;
+	validateManifests(product);
+	const page = createPage(options);
+	const events = createEventBus({
+		events: product.events,
+		report: page.report
+	});
+	const state = createState({
+		events,
+		options,
+		report: page.report
+	});
+	const { access, flags, session } = state.stores;
+	const connection = connector();
+	const data = createHostData({
+		access,
+		connection: connection.current,
+		data: options.data,
+		events,
+		product,
+		session
+	});
+	const sequence = followSession({
+		access,
+		data,
+		events,
+		flags,
+		session
+	});
+	const stores = {
+		...state.stores,
+		...page.stores
+	};
+	const runtime = createRuntime({
+		connection: connection.current,
+		data,
+		events,
+		product,
+		report: page.report,
+		settings: options.store,
+		stores
+	});
+	const eager = importEager(runtime.product);
+	let ready;
+	const host = {
+		data,
+		dispose: () => {
+			sequence.stop();
+			state.dispose();
+			data.cancelQueries();
+		},
+		ready: () => {
+			ready ??= readied(eager, sequence.identified, options.flagsTimeout ?? FLAGS_TIMEOUT);
+			return ready;
+		},
+		retry: page.stores.quarantine.retry,
+		stores
+	};
+	remember(host, {
+		access,
+		connect: connection.connect,
+		flags,
+		glyphs: options.glyphs,
+		runtime,
+		switches: state.switches
+	});
+	return host;
+}
+//#endregion
+//#region src/parts/content.tsx
+/**
+* Renders the root route's outlet inside the `content` region, so the region's extensions decorate
+* every page.
+*
+* @remarks
+*   The frame renders it where the page belongs. A frame that renders `Outlet` in its place renders
+*   pages without the region, and the extension statuses read the region as not mounted.
+*/
+function HostContent() {
+	const $ = c(1);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = /* @__PURE__ */ jsx(Slot, {
+			slot: hostContract.slots.content,
+			children: /* @__PURE__ */ jsx(Outlet, {})
+		});
+		$[0] = t0;
+	} else t0 = $[0];
+	return t0;
+}
+//#endregion
+//#region src/routes/not-found.ts
+/**
+* Returns true for the data of a page whose plugin a switch or a kill switch stopped.
+*/
+function isStopped(data) {
+	return "plugin" in data && typeof data.plugin === "string" && "reason" in data && (data.reason === "off" || data.reason === "unavailable");
+}
+/**
+* Returns true for the data of a page the host quarantined.
+*/
+function isQuarantined(data) {
+	return "target" in data && typeof data.target === "string" && data.target.startsWith("route:") && "reason" in data && data.reason === "quarantined";
+}
+/**
+* Reads the data of a not-found error as the host's not-found data.
+*
+* @remarks
+*   Every route of the tree can throw a not-found error, so data of another shape, from a route the
+*   product wrote, reads as none.
+* @param data - The data the router passes the not-found component.
+* @returns The data the route evaluator threw, or nothing.
+*/
+function notFoundDataOf(data) {
+	if (typeof data !== "object" || data === null) return void 0;
+	return isStopped(data) || isQuarantined(data) ? data : void 0;
+}
+//#endregion
+//#region src/parts/not-found.tsx
+/**
+* Renders the root's not-found page: for a page whose plugin a switch or a kill switch stopped, for
+* a page the host quarantined, and for an address no route matches.
+*/
+/**
+* Returns the ref of the page's heading, which takes focus where the page replaced the page a
+* person was on without a navigation.
+*
+* @remarks
+*   The router records an address as resolved only after the pages of its navigation rendered, so
+*   the resolved address equals the address while the page first renders only where no navigation
+*   led to it: a switch, a kill switch, a condition or a quarantine changed under the person.
+*/
+function useHeading() {
+	const $ = c(6);
+	const heading = useRef(null);
+	const router = useRouter();
+	let t0;
+	if ($[0] !== router.state.location.href || $[1] !== router.state.resolvedLocation?.href) {
+		t0 = () => router.state.resolvedLocation?.href === router.state.location.href;
+		$[0] = router.state.location.href;
+		$[1] = router.state.resolvedLocation?.href;
+		$[2] = t0;
+	} else t0 = $[2];
+	const [replaced] = useState(t0);
+	let t1;
+	let t2;
+	if ($[3] !== replaced) {
+		t1 = () => {
+			if (replaced) heading.current?.focus();
+		};
+		t2 = [replaced];
+		$[3] = replaced;
+		$[4] = t1;
+		$[5] = t2;
+	} else {
+		t1 = $[4];
+		t2 = $[5];
+	}
+	useEffect(t1, t2);
+	return heading;
+}
+/**
+* Renders the not-found page the router's data describes.
+*
+* @remarks
+*   A page whose plugin a switch turned off names the plugin and offers a button that turns it on.
+*   A page whose plugin a kill switch stopped names the plugin and offers nothing. A quarantined
+*   page offers a retry that lifts the quarantine. Data of another shape, or none, renders a plain
+*   not-found page, which states nothing about the address. The host runs the router's
+*   `beforeLoad` again after a switch or a retry, and the page renders again in this one's place.
+*/
+function HostNotFound(t0) {
+	const $ = c(25);
+	const { data } = t0;
+	let t1;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = { strict: false };
+		$[0] = t1;
+	} else t1 = $[0];
+	const { host } = useRouteContext(t1);
+	const { i18n, t } = useTranslation("host");
+	const heading = useHeading();
+	let T0;
+	let T1;
+	let found;
+	let t2;
+	let t3;
+	let t4;
+	if ($[1] !== data || $[2] !== heading || $[3] !== host || $[4] !== i18n || $[5] !== t) {
+		found = notFoundDataOf(data);
+		const reason = found?.reason ?? "plain";
+		const plugin = found === void 0 || found.reason === "quarantined" ? "" : pluginWordsOf(i18n).t(found.plugin, "plugin.name");
+		T1 = EmptyState.Root;
+		T0 = EmptyState.Content;
+		t2 = /* @__PURE__ */ jsx(EmptyState.Title, {
+			as: "h1",
+			ref: heading,
+			tabIndex: -1,
+			children: t(`notFound.${reason}.title`, { plugin })
+		});
+		t3 = /* @__PURE__ */ jsx(EmptyState.Description, { children: t(`notFound.${reason}.description`, { plugin }) });
+		t4 = found?.reason === "off" ? /* @__PURE__ */ jsx(Button, {
+			onClick: () => {
+				internalsOf(host).switches.set(found.plugin, true);
+			},
+			children: t("notFound.off.action", { plugin })
+		}) : null;
+		$[1] = data;
+		$[2] = heading;
+		$[3] = host;
+		$[4] = i18n;
+		$[5] = t;
+		$[6] = T0;
+		$[7] = T1;
+		$[8] = found;
+		$[9] = t2;
+		$[10] = t3;
+		$[11] = t4;
+	} else {
+		T0 = $[6];
+		T1 = $[7];
+		found = $[8];
+		t2 = $[9];
+		t3 = $[10];
+		t4 = $[11];
+	}
+	let t5;
+	if ($[12] !== found || $[13] !== host || $[14] !== t) {
+		t5 = found?.reason === "quarantined" ? /* @__PURE__ */ jsx(Button, {
+			onClick: () => {
+				host.retry(found.target);
+			},
+			children: t("notFound.quarantined.action")
+		}) : null;
+		$[12] = found;
+		$[13] = host;
+		$[14] = t;
+		$[15] = t5;
+	} else t5 = $[15];
+	let t6;
+	if ($[16] !== T0 || $[17] !== t2 || $[18] !== t3 || $[19] !== t4 || $[20] !== t5) {
+		t6 = /* @__PURE__ */ jsxs(T0, { children: [
+			t2,
+			t3,
+			t4,
+			t5
+		] });
+		$[16] = T0;
+		$[17] = t2;
+		$[18] = t3;
+		$[19] = t4;
+		$[20] = t5;
+		$[21] = t6;
+	} else t6 = $[21];
+	let t7;
+	if ($[22] !== T1 || $[23] !== t6) {
+		t7 = /* @__PURE__ */ jsx(T1, { children: t6 });
+		$[22] = T1;
+		$[23] = t6;
+		$[24] = t7;
+	} else t7 = $[24];
+	return t7;
+}
+//#endregion
+//#region src/parts/connection.ts
+/**
+* Returns the qualified ids of the declared routes the router matched, outermost first.
+*
+* @remarks
+*   The root and every route the product wrote without a name state no id, so the list leaves them
+*   out.
+*/
+function matchedOf(router) {
+	return router.state.matches.flatMap((match) => declaredOf(match)?.id ?? []);
+}
+/**
+* Returns the connection of a router and the catalogues' instance.
+*
+* @remarks
+*   `navigate` resolves the reference through the route map the router's context contains, with
+*   the parameters filled in, and passes the search beside the path, as `RouteLink` does. It
+*   rejects where the map contains no such route or a parameter the path names is missing.
+* @param router - The router whose context contains the host.
+* @param i18n - The instance `useTranslation` returns.
+*/
+function connectionOf(router, i18n) {
+	const words = pluginWordsOf(i18n);
+	const { routes } = router.options.context;
+	return {
+		invalidate: () => {
+			router.invalidate();
+		},
+		matched: () => matchedOf(router),
+		navigate: async (to, options) => {
+			await router.navigate({
+				...options?.search === void 0 ? {} : { search: options.search },
+				to: routeHref(routes, to, options?.params)
+			});
+		},
+		translate: (namespace, key, values) => words.t(namespace, key, values)
+	};
+}
+//#endregion
+//#region src/parts/connect.ts
+/**
+* Keeps a host in step with its router and with the page while `HostProvider` is mounted.
+*/
+/**
+* Returns true where an override changed, or a reading the page took was replaced or dropped.
+*
+* @remarks
+*   The flag store keeps a reading's object until its value or its origin changes. A first read
+*   adds a reading with the value the reader already used, a route condition included, so a reading
+*   added alone changes nothing a condition read.
+*/
+function changedFlags(previous, next) {
+	if (previous.overrides !== next.overrides) return true;
+	for (const [id, reading] of previous.readings) if (next.readings.get(id) !== reading) return true;
+	return false;
+}
+/**
+* Calls `invalidate` once per task after a change a route condition reads: the session, a plugin's
+* availability, a quarantine, an override, or the value of a flag the page read. Returns a
+* function that stops the calls.
+*/
+function followStores(stores, invalidate) {
+	let queued = false;
+	let flags = stores.flags.get();
+	const queue = () => {
+		if (queued) return;
+		queued = true;
+		queueMicrotask(() => {
+			queued = false;
+			invalidate();
+		});
+	};
+	const stops = [
+		stores.availability.subscribe(queue),
+		stores.quarantine.subscribe(queue),
+		stores.session.subscribe(queue),
+		stores.flags.subscribe(() => {
+			const next = stores.flags.get();
+			if (changedFlags(flags, next)) queue();
+			flags = next;
+		})
+	];
+	return () => {
+		for (const stop of stops) stop();
+	};
+}
+/**
+* Emits `host/navigated` for the address the router resolved before the call, and after each
+* navigation it resolves. Returns a function that stops the emits.
+*
+* @remarks
+*   A load that resolves the address already resolved, such as an invalidation, emits nothing.
+*/
+function followNavigations(events, router) {
+	const announce = (href) => {
+		const navigated = {
+			href,
+			matched: matchedOf(router)
+		};
+		events.emit(HOST, hostContract.events.navigated.id, navigated);
+	};
+	const resolved = router.state.resolvedLocation;
+	if (resolved !== void 0) announce(resolved.href);
+	return router.subscribe("onResolved", ({ hrefChanged, toLocation }) => {
+		if (hrefChanged) announce(toLocation.href);
+	});
+}
+/**
+* Connects a host to its router until the caller unmounts.
+*
+* @remarks
+*   The host's API and its commands read the router's matches, its navigation and the catalogues
+*   through the connection. The router runs `beforeLoad` again once per task after a change a route
+*   condition reads, so a session change, a switch, a kill switch or a quarantine costs one
+*   invalidation. The host emits `host/navigated` after every navigation the router resolves.
+*   Vite's `vite:preloadError` event reloads the page once per build version. The last effect ends
+*   the hydration from a server render, once the stores' readers are subscribed, so what the
+*   browser's flags change renders again.
+*/
+function useConnected(host, router) {
+	const $ = c(21);
+	const { i18n } = useTranslation("host");
+	let t0;
+	if ($[0] !== host) {
+		t0 = internalsOf(host);
+		$[0] = host;
+		$[1] = t0;
+	} else t0 = $[1];
+	const { connect, flags, runtime } = t0;
+	const { stores } = host;
+	let t1;
+	let t2;
+	if ($[2] !== connect || $[3] !== i18n || $[4] !== router) {
+		t1 = () => connect(connectionOf(router, i18n));
+		t2 = [
+			connect,
+			i18n,
+			router
+		];
+		$[2] = connect;
+		$[3] = i18n;
+		$[4] = router;
+		$[5] = t1;
+		$[6] = t2;
+	} else {
+		t1 = $[5];
+		t2 = $[6];
+	}
+	useEffect(t1, t2);
+	let t3;
+	let t4;
+	if ($[7] !== runtime.recover) {
+		t3 = () => listenForStaleChunks(runtime.recover);
+		t4 = [runtime.recover];
+		$[7] = runtime.recover;
+		$[8] = t3;
+		$[9] = t4;
+	} else {
+		t3 = $[8];
+		t4 = $[9];
+	}
+	useEffect(t3, t4);
+	let t5;
+	let t6;
+	if ($[10] !== router || $[11] !== stores) {
+		t5 = () => followStores(stores, () => {
+			router.invalidate();
+		});
+		t6 = [router, stores];
+		$[10] = router;
+		$[11] = stores;
+		$[12] = t5;
+		$[13] = t6;
+	} else {
+		t5 = $[12];
+		t6 = $[13];
+	}
+	useEffect(t5, t6);
+	let t7;
+	let t8;
+	if ($[14] !== router || $[15] !== runtime.events) {
+		t7 = () => followNavigations(runtime.events, router);
+		t8 = [router, runtime.events];
+		$[14] = router;
+		$[15] = runtime.events;
+		$[16] = t7;
+		$[17] = t8;
+	} else {
+		t7 = $[16];
+		t8 = $[17];
+	}
+	useEffect(t7, t8);
+	let t10;
+	let t9;
+	if ($[18] !== flags) {
+		t9 = () => {
+			flags.settle();
+		};
+		t10 = [flags];
+		$[18] = flags;
+		$[19] = t10;
+		$[20] = t9;
+	} else {
+		t10 = $[19];
+		t9 = $[20];
+	}
+	useEffect(t9, t10);
+}
+//#endregion
+//#region src/parts/failed.tsx
+/**
+* Renders the failure page as the document's main landmark, with the product's name in its
+* heading.
+*
+* @remarks
+*   The page replaces the frame, so it renders the landmark the frame's own main region was.
+*/
+function HostFailed(t0) {
+	const $ = c(17);
+	const { product } = t0;
+	const { t } = useTranslation("host");
+	const name = useProductName(product);
+	let t1;
+	if ($[0] !== name || $[1] !== t) {
+		t1 = t("failed.title", { product: name });
+		$[0] = name;
+		$[1] = t;
+		$[2] = t1;
+	} else t1 = $[2];
+	let t2;
+	if ($[3] !== t1) {
+		t2 = /* @__PURE__ */ jsx(EmptyState.Title, {
+			as: "h1",
+			children: t1
+		});
+		$[3] = t1;
+		$[4] = t2;
+	} else t2 = $[4];
+	let t3;
+	if ($[5] !== t) {
+		t3 = t("failed.description");
+		$[5] = t;
+		$[6] = t3;
+	} else t3 = $[6];
+	let t4;
+	if ($[7] !== t3) {
+		t4 = /* @__PURE__ */ jsx(EmptyState.Description, { children: t3 });
+		$[7] = t3;
+		$[8] = t4;
+	} else t4 = $[8];
+	let t5;
+	if ($[9] !== t) {
+		t5 = t("failed.reload");
+		$[9] = t;
+		$[10] = t5;
+	} else t5 = $[10];
+	let t6;
+	if ($[11] !== t5) {
+		t6 = /* @__PURE__ */ jsx(Button, {
+			onClick: _temp$4,
+			children: t5
+		});
+		$[11] = t5;
+		$[12] = t6;
+	} else t6 = $[12];
+	let t7;
+	if ($[13] !== t2 || $[14] !== t4 || $[15] !== t6) {
+		t7 = /* @__PURE__ */ jsx(EmptyState.Root, {
+			as: "main",
+			children: /* @__PURE__ */ jsxs(EmptyState.Content, { children: [
+				t2,
+				t4,
+				t6
+			] })
+		});
+		$[13] = t2;
+		$[14] = t4;
+		$[15] = t6;
+		$[16] = t7;
+	} else t7 = $[16];
+	return t7;
+}
+function _temp$4() {
+	window.location.reload();
+}
+//#endregion
+//#region src/parts/last-boundary.ts
+/**
+* Catches an error that escapes every plugin's boundary: in the product's frame, in a part of the
+* host or in a provider.
+*/
+/**
+* Renders its children, and the host's failure page in their place once a render of them throws.
+*
+* @remarks
+*   React catches a render error in a class component alone. The boundary never resets, because
+*   the state of the providers above the failure is unknown, so a person reloads the page to leave
+*   it. Each error is reported as `render-failed` with the target `host`.
+*/
+var LastBoundary = class extends Component {
+	/**
+	* Returns the state after a render of the tree threw.
+	*/
+	static getDerivedStateFromError() {
+		return { failed: true };
+	}
+	/**
+	* The state before any render threw.
+	*/
+	state = { failed: false };
+	/**
+	* Reports the error a render threw.
+	*/
+	componentDidCatch(error) {
+		this.props.runtime.report({
+			error,
+			kind: "render-failed",
+			target: "host"
+		});
+	}
+	/**
+	* Renders the tree, or the failure page after a render of it threw.
+	*/
+	render() {
+		return this.state.failed ? createElement(HostFailed, { product: this.props.runtime.product }) : this.props.children;
+	}
+};
+//#endregion
+//#region src/parts/provider.tsx
+/**
+* Renders the host's contexts around a product's router: the runtime the hooks of `sdk-plugin`
+* read, the data client, the `root` region and the last boundary.
+*/
+/**
+* Provides a host to the product's tree, once per render tree.
+*
+* @remarks
+*   The `root` region renders around the router, so its extensions render outside every route and
+*   read the router's matches through the router's context. The provider connects the host to the
+*   router (`useConnected`) and titles the document with the product's name as it mounts and as
+*   the language changes, before any page titles it. It renders the failure page in place of a
+*   tree that throws outside the router.
+*/
+function HostProvider(t0) {
+	const $ = c(19);
+	const { children, host, router } = t0;
+	let t1;
+	if ($[0] !== host) {
+		t1 = internalsOf(host);
+		$[0] = host;
+		$[1] = t1;
+	} else t1 = $[1];
+	const { runtime } = t1;
+	const name = useProductName(runtime.product);
+	useConnected(host, router);
+	let t2;
+	let t3;
+	if ($[2] !== name) {
+		t2 = () => {
+			document.title = name;
+		};
+		t3 = [name];
+		$[2] = name;
+		$[3] = t2;
+		$[4] = t3;
+	} else {
+		t2 = $[3];
+		t3 = $[4];
+	}
+	useLayoutEffect(t2, t3);
+	let t4;
+	if ($[5] !== children) {
+		t4 = /* @__PURE__ */ jsx(Slot, {
+			slot: hostContract.slots.root,
+			children
+		});
+		$[5] = children;
+		$[6] = t4;
+	} else t4 = $[6];
+	let t5;
+	if ($[7] !== router || $[8] !== t4) {
+		t5 = /* @__PURE__ */ jsx(RouterContextProvider, {
+			router,
+			children: t4
+		});
+		$[7] = router;
+		$[8] = t4;
+		$[9] = t5;
+	} else t5 = $[9];
+	let t6;
+	if ($[10] !== host.data || $[11] !== t5) {
+		t6 = /* @__PURE__ */ jsx(DataProvider, {
+			client: host.data,
+			children: t5
+		});
+		$[10] = host.data;
+		$[11] = t5;
+		$[12] = t6;
+	} else t6 = $[12];
+	let t7;
+	if ($[13] !== runtime || $[14] !== t6) {
+		t7 = /* @__PURE__ */ jsx(HostContext, {
+			value: runtime,
+			children: t6
+		});
+		$[13] = runtime;
+		$[14] = t6;
+		$[15] = t7;
+	} else t7 = $[15];
+	let t8;
+	if ($[16] !== runtime || $[17] !== t7) {
+		t8 = /* @__PURE__ */ jsx(LastBoundary, {
+			runtime,
+			children: t7
+		});
+		$[16] = runtime;
+		$[17] = t7;
+		$[18] = t8;
+	} else t8 = $[18];
+	return t8;
+}
+//#endregion
+//#region src/commands/run.ts
+/**
+* Runs a command without arguments, and reports a rejection as `command-failed` under the command's
+* plugin and as an error toast.
+*
+* @remarks
+*   A key press and the palette have no caller to receive a rejection, so the host reports it.
+* @param status - The command, as `useCommands` returns it.
+* @param runtime - The host's report and toaster.
+* @param title - The error toast's title, translated.
+*/
+function runReporting(status, runtime, title) {
+	status.run().catch((error) => {
+		runtime.report({
+			error,
+			kind: "command-failed",
+			plugin: status.command.plugin,
+			target: status.command.id
+		});
+		runtime.toaster.create({
+			title,
+			type: "error"
+		});
+	});
+}
+//#endregion
+//#region src/commands/keys.ts
+/**
+* Returns the commands that bind keys, grouped by chord in the form the operating system reads,
+* each group in install order.
+*/
+function chordsOf(commands) {
+	const chords = /* @__PURE__ */ new Map();
+	for (const status of commands) {
+		const { keys } = status.command;
+		if (keys === void 0) continue;
+		const chord = normalizeHotkey(keys);
+		chords.set(chord, [...chords.get(chord) ?? [], status]);
+	}
+	return chords;
+}
+/**
+* Binds every chord the product's commands bind, and renders nothing.
+*
+* @remarks
+*   One registration per chord, because the hotkeys library runs every handler registered for a
+*   chord. A press runs the first command of the chord, in install order, whose `enabled` is true,
+*   without arguments, and runs nothing where none is. A chord with `Mod` runs while a text field
+*   has focus, and a single key or a `Shift` or `Alt` chord does not, the library's defaults. A
+*   command that rejects is reported as `command-failed` and raises an error toast.
+*/
+function CommandKeys() {
+	const $ = c(1);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = { strict: false };
+		$[0] = t0;
+	} else t0 = $[0];
+	const { host } = useRouteContext(t0);
+	const { runtime } = internalsOf(host);
+	const commands = useCommands();
+	const { t } = useTranslation("host");
+	useHotkeys([...chordsOf(commands)].map((t1) => {
+		const [hotkey, bound] = t1;
+		return {
+			callback: () => {
+				const first = bound.find(_temp$3);
+				if (first !== void 0) runReporting(first, runtime, t("commands.failed", { label: first.label }));
+			},
+			hotkey
+		};
+	}));
+	return null;
+}
+function _temp$3(t0) {
+	const { enabled } = t0;
+	return enabled;
+}
+//#endregion
+//#region src/commands/palette.tsx
+/**
+* Renders the command palette: the commands a key could run and the main menu's pages, in a dialog
+* `Mod+K` opens.
+*/
+/**
+* The chord that opens the palette, which the build refuses to a command.
+*/
+const PALETTE = "Mod+K";
+/**
+* Returns true for a command the palette lists: it is enabled, takes no arguments and resolves
+* with no result.
+*/
+function isListed({ command, enabled }) {
+	return enabled && !command.takesArguments && !command.returnsResult;
+}
+/**
+* Returns the rows the palette lists: each command a key could run under its plugin's name, then
+* each page of the main menu under `Go to`.
+*
+* @remarks
+*   A command matches its catalogue's `keywords.<label>` beside its label, where the catalogue
+*   states it.
+*/
+function useChoices(runtime) {
+	const $ = c(10);
+	const commands = useCommands();
+	const entries = useNavigation();
+	const navigate = useNavigate();
+	const { i18n, t } = useTranslation("host");
+	let t0;
+	if ($[0] !== commands || $[1] !== entries || $[2] !== i18n || $[3] !== navigate || $[4] !== runtime || $[5] !== t) {
+		const words = pluginWordsOf(i18n);
+		let t1;
+		if ($[7] !== navigate || $[8] !== t) {
+			t1 = (t2) => {
+				const { href, label: label_0, routeId } = t2;
+				return {
+					action: {
+						group: t("palette.goTo"),
+						label: label_0,
+						value: `route:${routeId}`
+					},
+					run: () => {
+						navigate({ to: href });
+					}
+				};
+			};
+			$[7] = navigate;
+			$[8] = t;
+			$[9] = t1;
+		} else t1 = $[9];
+		t0 = [...commands.filter(_temp$2).map((status_0) => {
+			const { id, label, plugin } = status_0.command;
+			const keywords = `keywords.${label}`;
+			return {
+				action: {
+					group: words.t(plugin, "plugin.name"),
+					keywords: words.exists(plugin, keywords) ? words.t(plugin, keywords) : void 0,
+					label: status_0.label,
+					shortcut: status_0.keys,
+					value: id
+				},
+				run: () => {
+					runReporting(status_0, runtime, t("commands.failed", { label: status_0.label }));
+				}
+			};
+		}), ...entries.map(t1)];
+		$[0] = commands;
+		$[1] = entries;
+		$[2] = i18n;
+		$[3] = navigate;
+		$[4] = runtime;
+		$[5] = t;
+		$[6] = t0;
+	} else t0 = $[6];
+	return t0;
+}
+function _temp$2(status) {
+	return isListed(status);
+}
+/**
+* Renders the palette in a dialog that `Mod+K` opens and closes.
+*
+* @remarks
+*   Choosing a row closes the dialog, then runs the command or navigates to the page. The dialog
+*   renders where the palette renders, the `overlay` region at the end of the frame, so it needs no
+*   portal and renders on a server while closed.
+*/
+function CommandPalette() {
+	const $ = c(38);
+	const [open, setOpen] = useState(false);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = { strict: false };
+		$[0] = t0;
+	} else t0 = $[0];
+	const { host } = useRouteContext(t0);
+	let t1;
+	if ($[1] !== host) {
+		t1 = internalsOf(host);
+		$[1] = host;
+		$[2] = t1;
+	} else t1 = $[2];
+	const choices = useChoices(t1.runtime);
+	const { t } = useTranslation("host");
+	let t2;
+	if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+		t2 = () => {
+			setOpen(_temp2);
+		};
+		$[3] = t2;
+	} else t2 = $[3];
+	useHotkey(PALETTE, t2);
+	let t3;
+	if ($[4] !== t) {
+		t3 = t("palette.label");
+		$[4] = t;
+		$[5] = t3;
+	} else t3 = $[5];
+	let t4;
+	if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+		t4 = (t5) => {
+			const { open: next } = t5;
+			setOpen(next);
+		};
+		$[6] = t4;
+	} else t4 = $[6];
+	let t5;
+	if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+		t5 = /* @__PURE__ */ jsx(Dialog.Backdrop, {});
+		$[7] = t5;
+	} else t5 = $[7];
+	let t6;
+	if ($[8] !== choices) {
+		t6 = choices.map(_temp3);
+		$[8] = choices;
+		$[9] = t6;
+	} else t6 = $[9];
+	let t7;
+	if ($[10] !== t) {
+		t7 = t("palette.commands");
+		$[10] = t;
+		$[11] = t7;
+	} else t7 = $[11];
+	let t8;
+	if ($[12] !== t) {
+		t8 = (matches) => t("palette.count", { count: matches });
+		$[12] = t;
+		$[13] = t8;
+	} else t8 = $[13];
+	let t9;
+	if ($[14] !== choices) {
+		t9 = (value) => {
+			setOpen(false);
+			for (const choice of choices) if (choice.action.value === value) choice.run();
+		};
+		$[14] = choices;
+		$[15] = t9;
+	} else t9 = $[15];
+	let t10;
+	if ($[16] !== t) {
+		t10 = t("palette.search");
+		$[16] = t;
+		$[17] = t10;
+	} else t10 = $[17];
+	let t11;
+	if ($[18] !== t) {
+		t11 = t("palette.search");
+		$[18] = t;
+		$[19] = t11;
+	} else t11 = $[19];
+	let t12;
+	if ($[20] !== t10 || $[21] !== t11) {
+		t12 = /* @__PURE__ */ jsx(Command.Input, {
+			"aria-label": t10,
+			placeholder: t11
+		});
+		$[20] = t10;
+		$[21] = t11;
+		$[22] = t12;
+	} else t12 = $[22];
+	let t13;
+	if ($[23] !== t) {
+		t13 = t("palette.none");
+		$[23] = t;
+		$[24] = t13;
+	} else t13 = $[24];
+	let t14;
+	if ($[25] !== t13) {
+		t14 = /* @__PURE__ */ jsx(Command.List, { children: /* @__PURE__ */ jsx(Command.Empty, { children: t13 }) });
+		$[25] = t13;
+		$[26] = t14;
+	} else t14 = $[26];
+	let t15;
+	if ($[27] !== t12 || $[28] !== t14 || $[29] !== t6 || $[30] !== t7 || $[31] !== t8 || $[32] !== t9) {
+		t15 = /* @__PURE__ */ jsx(Dialog.Positioner, { children: /* @__PURE__ */ jsx(Dialog.Content, { children: /* @__PURE__ */ jsxs(Command.Root, {
+			actions: t6,
+			"aria-label": t7,
+			count: t8,
+			onRun: t9,
+			children: [t12, t14]
+		}) }) });
+		$[27] = t12;
+		$[28] = t14;
+		$[29] = t6;
+		$[30] = t7;
+		$[31] = t8;
+		$[32] = t9;
+		$[33] = t15;
+	} else t15 = $[33];
+	let t16;
+	if ($[34] !== open || $[35] !== t15 || $[36] !== t3) {
+		t16 = /* @__PURE__ */ jsxs(Dialog.Root, {
+			"aria-label": t3,
+			onOpenChange: t4,
+			open,
+			placement: "top",
+			scrollBehavior: "inside",
+			size: "lg",
+			variant: "plain",
+			children: [t5, t15]
+		});
+		$[34] = open;
+		$[35] = t15;
+		$[36] = t3;
+		$[37] = t16;
+	} else t16 = $[37];
+	return t16;
+}
+function _temp3(t0) {
+	const { action } = t0;
+	return action;
+}
+function _temp2(shown) {
+	return !shown;
+}
+//#endregion
+//#region src/parts/toasts.tsx
+/**
+* Renders the toast region with each toast's title, description and action.
+*
+* @remarks
+*   The host renders no glyph of its own, so a toast has no mark and no close button. A toast
+*   closes after its type's duration and on Escape, and the region pauses every toast while a
+*   pointer rests on it or focus is inside it. Alt+T moves focus to the region.
+*/
+function HostToasts() {
+	const $ = c(8);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = { strict: false };
+		$[0] = t0;
+	} else t0 = $[0];
+	const { host } = useRouteContext(t0);
+	const { t } = useTranslation("host");
+	let t1;
+	if ($[1] !== t) {
+		t1 = t("toasts.label");
+		$[1] = t;
+		$[2] = t1;
+	} else t1 = $[2];
+	let t2;
+	if ($[3] !== host) {
+		t2 = internalsOf(host);
+		$[3] = host;
+		$[4] = t2;
+	} else t2 = $[4];
+	let t3;
+	if ($[5] !== t1 || $[6] !== t2.runtime.toaster) {
+		t3 = /* @__PURE__ */ jsx(Toast.Region, {
+			label: t1,
+			toaster: t2.runtime.toaster,
+			children: _temp$1
+		});
+		$[5] = t1;
+		$[6] = t2.runtime.toaster;
+		$[7] = t3;
+	} else t3 = $[7];
+	return t3;
+}
+function _temp$1(toast) {
+	return /* @__PURE__ */ jsxs(Toast.Root, { children: [/* @__PURE__ */ jsxs(Toast.Content, { children: [/* @__PURE__ */ jsx(Toast.Title, { children: toast.title }), /* @__PURE__ */ jsx(Toast.Description, { children: toast.description })] }), toast.action === void 0 ? null : /* @__PURE__ */ jsx(Toast.ActionTrigger, { children: toast.action.label })] });
+}
+//#endregion
+//#region src/parts/root.tsx
+/**
+* Renders the product's frame inside the `layout` region, the `overlay` region after it, and the
+* keys of the product's commands.
+*
+* @remarks
+*   The router renders the root route's component inside a catch boundary of its own, so the
+*   component renders the host's last boundary around the frame, and an error in the frame
+*   renders the failure page and is reported with the target `host`.
+*/
+function HostRoot(t0) {
+	const $ = c(10);
+	const { children } = t0;
+	let t1;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = { strict: false };
+		$[0] = t1;
+	} else t1 = $[0];
+	const { host } = useRouteContext(t1);
+	let t2;
+	if ($[1] !== host) {
+		t2 = internalsOf(host);
+		$[1] = host;
+		$[2] = t2;
+	} else t2 = $[2];
+	let t3;
+	if ($[3] !== children) {
+		t3 = /* @__PURE__ */ jsx(Slot, {
+			slot: hostContract.slots.layout,
+			children
+		});
+		$[3] = children;
+		$[4] = t3;
+	} else t3 = $[4];
+	let t4;
+	let t5;
+	if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+		t4 = /* @__PURE__ */ jsxs(Slot, {
+			slot: hostContract.slots.overlay,
+			children: [/* @__PURE__ */ jsx(CommandPalette, {}), /* @__PURE__ */ jsx(HostToasts, {})]
+		});
+		t5 = /* @__PURE__ */ jsx(CommandKeys, {});
+		$[5] = t4;
+		$[6] = t5;
+	} else {
+		t4 = $[5];
+		t5 = $[6];
+	}
+	let t6;
+	if ($[7] !== t2.runtime || $[8] !== t3) {
+		t6 = /* @__PURE__ */ jsxs(LastBoundary, {
+			runtime: t2.runtime,
+			children: [
+				t3,
+				t4,
+				t5
+			]
+		});
+		$[7] = t2.runtime;
+		$[8] = t3;
+		$[9] = t6;
+	} else t6 = $[9];
+	return t6;
+}
+//#endregion
+//#region src/routes/mapping.ts
+/**
+* Returns what the manifest of a route's plugin maps the route to.
+*
+* @remarks
+*   The manifest's code states a page as its importer alone, or as an entry with a fallback. A
+*   route whose plugin has no manifest maps to nothing.
+* @param product - The product, with each installed plugin's manifest.
+* @param routeId - Qualified id of the route.
+*/
+function mappingOf(product, routeId) {
+	const plugin = pluginOf(routeId);
+	const name = routeId.slice(plugin.length + 1);
+	const manifest = product.manifests[plugin];
+	const code = (manifest?.code.routes)?.[name];
+	const marker = manifest?.contract.routes[name];
+	const entry = typeof code === "function" ? { component: code } : code;
+	return {
+		component: entry?.component,
+		fallback: entry?.fallback,
+		search: marker?.search
+	};
+}
+/**
+* Returns the one function a page's module exports, as the component the host renders.
+*
+* @param module - The module the importer resolved with.
+* @param routeId - Qualified id of the route, which the error names.
+* @throws {@link Error} Where the module exports no function or more than one.
+*/
+function componentOf(module, routeId) {
+	const found = Object.values(module).filter((value) => typeof value === "function");
+	if (found.length !== 1) throw new Error(`The module of ${routeId} exports ${String(found.length)} functions, and a page's module exports one.`);
+	return found[0];
+}
+//#endregion
+//#region src/routes/error.tsx
+/**
+* Renders a plugin page that threw: its manifest's fallback where it states one, else the host's
+* error page, and counts each error towards the page's quarantine.
+*/
+/**
+* Marks a route error component that has counted no error yet.
+*/
+const UNCOUNTED = Symbol("uncounted");
+/**
+* Returns the error component of a plugin's route.
+*
+* @remarks
+*   The router renders the component for an error that the page or its loader throws. Each error
+*   counts one failure towards the route's quarantine, once however often the component renders
+*   it. The fallback renders in its plugin's scope, without props.
+* @param routeId - Qualified id of the route.
+* @param fallback - Imports the component the manifest renders in the page's place, where it
+*   states one.
+*/
+function routeErrorOf(routeId, fallback) {
+	const target = `route:${routeId}`;
+	const Fallback = fallback === void 0 ? void 0 : lazy(async () => ({ default: componentOf(await fallback(), routeId) }));
+	/**
+	* Renders the fallback or the host's error page, and counts the error.
+	*/
+	return function RouteError({ error }) {
+		const { host } = useRouteContext({ strict: false });
+		const { quarantine } = host.stores;
+		const { t } = useTranslation("host");
+		const counted = useRef(UNCOUNTED);
+		useEffect(() => {
+			if (counted.current === error) return;
+			counted.current = error;
+			quarantine.failed(target, error);
+		}, [error, quarantine]);
+		if (Fallback !== void 0) return /* @__PURE__ */ jsx(PluginProvider, {
+			pluginId: pluginOf(routeId),
+			children: /* @__PURE__ */ jsx(Suspense, {
+				fallback: null,
+				children: /* @__PURE__ */ jsx(Fallback, {})
+			})
+		});
+		return /* @__PURE__ */ jsx(EmptyState.Root, { children: /* @__PURE__ */ jsxs(EmptyState.Content, { children: [/* @__PURE__ */ jsx(EmptyState.Title, {
+			as: "h1",
+			children: t("page.failed.title")
+		}), /* @__PURE__ */ jsx(EmptyState.Description, { children: t("page.failed.description") })] }) });
+	};
+}
+//#endregion
+//#region src/routes/evaluate.ts
+/**
+* Evaluates a plugin route's condition before the route loads, against the host in the router's
+* context.
+*/
+/**
+* Returns the plugin whose state stops a plugin, with that plugin's reason: the plugin itself where
+* a switch or its kill switch stopped it, else the first plugin it requires without `optional` that
+* a switch or a kill switch stopped. Returns undefined where a condition stops the plugin.
+*
+* @remarks
+*   A plugin the walk has passed reads as stopped by a condition, so a ring of requirements, which
+*   the build refuses, ends the walk.
+* @param pluginId - Id of the plugin that is not on.
+* @param plugins - The installed plugins, with the plugins each requires.
+* @param availability - Every installed plugin's availability, by plugin id.
+* @param seen - Ids of the plugins the walk has passed.
+*/
+function stoppedBy(pluginId, plugins, availability, seen = /* @__PURE__ */ new Set()) {
+	const reason = availability[pluginId]?.reason;
+	if (reason === "off" || reason === "unavailable") return {
+		plugin: pluginId,
+		reason
+	};
+	if (reason !== "requirement" || seen.has(pluginId)) return void 0;
+	const walked = /* @__PURE__ */ new Set([...seen, pluginId]);
+	return plugins.filter(({ id }) => id === pluginId).flatMap(({ requires }) => requires).filter(({ optional }) => optional !== true).map((required) => stoppedBy(required.pluginId, plugins, availability, walked)).find((found) => found !== void 0);
+}
+/**
+* Returns true where a condition requires a signed-in person at its top level or in a top-level
+* `allOf`.
+*/
+function requiresSignIn(when) {
+	return when.authenticated === true || (when.allOf?.some((one) => one.authenticated === true) ?? false);
+}
+/**
+* Returns the evaluator of the product's plugin routes, which reads the host in the router's
+* context.
+*
+* @remarks
+*   The evaluator throws the router's not-found error where the route's plugin is not on, with the
+*   plugin and its reason as data where a switch or a kill switch stopped it, and where the route
+*   is quarantined, with the target as data. Where the condition is false for a person who is not
+*   signed in, the product states a sign-in route, and the condition requires sign-in at its top
+*   level or in a top-level `allOf`, it throws the router's redirect to the sign-in route, with the
+*   address the navigation enters as the `redirect` search. Otherwise it returns the condition.
+* @param product - The installed plugins and the sign-in route.
+*/
+function evaluatorOf(product) {
+	return ({ pluginId, routeId, when }, { host, routes }, location) => {
+		const context = conditionContextOf(host.stores);
+		const target = `route:${routeId}`;
+		if (!context.on(pluginId)) {
+			const data = stoppedBy(pluginId, product.plugins, host.stores.availability.get());
+			throw data === void 0 ? notFound() : notFound({ data });
+		}
+		if (host.stores.quarantine.get().has(target)) throw notFound({ data: {
+			reason: "quarantined",
+			target
+		} });
+		if (when === void 0 || evaluateWhen(when, context)) return true;
+		if (product.signIn !== void 0 && !context.authenticated && requiresSignIn(when)) throw redirect({
+			search: { redirect: location?.href },
+			to: routeHref(routes, product.signIn)
+		});
+		return false;
+	};
+}
+//#endregion
+//#region src/routes/loader.ts
+/**
+* Builds the loader of a route from the queries the route's declaration reads.
+*/
+/**
+* Returns the queries a page reads, in the form the data foundation's loader takes.
+*/
+function needsOf(product, route) {
+	return route.data.flatMap(({ query, variables }) => product.queries.filter(({ id }) => id === query).map((declared) => ({
+		operation: defineQuery(declared.operation.id),
+		resources: declared.records,
+		variables
+	})));
+}
+/**
+* Returns the loader of a route that reads data, or undefined for a route that reads none.
+*
+* @remarks
+*   The loader loads each query through the data client in the router's context, with the variables
+*   the route's parameters and search contain.
+* @param product - The product, whose queries the route's data names.
+* @param route - The route as the build resolved it.
+*/
+function loaderOf(product, route) {
+	return route.data.length === 0 ? void 0 : loadNeeds(needsOf(product, route));
+}
+//#endregion
+//#region src/routes/page.ts
+/**
+* Loads a plugin's page and renders it as its route's component: in the plugin's scope, with the
+* extensions placed around the route, and with the route's count of failed renders returned to zero
+* after it commits.
+*/
+/**
+* Returns the route component of a page: a plugin's page, the settings frame or a settings page.
+*
+* @remarks
+*   The component reads the host from the router's context. A render of the page that throws
+*   commits nothing, so the route's count of failed renders returns to zero only after a render
+*   that commits.
+* @param pluginId - Id of the plugin that declares the route, or the settings page, whose scope
+*   the page renders in.
+* @param routeId - The route's qualified id, under which its failed renders and the extensions
+*   around it are recorded.
+* @param page - The component the route renders: a plugin's page, the settings frame or a settings
+*   page.
+*/
+function hostPageOf(pluginId, routeId, page) {
+	const target = `route:${routeId}`;
+	/**
+	* Renders the page in its plugin's scope, with the extensions placed around its route.
+	*/
+	return function HostPage() {
+		const { host } = useRouteContext({ strict: false });
+		const { quarantine } = host.stores;
+		useEffect(() => {
+			quarantine.rendered(target);
+		});
+		return createElement(PluginProvider, { pluginId }, createElement(RouteDecorations, { routeId }, createElement(page)));
+	};
+}
+/**
+* Imports a plugin's page and, in parallel, every module of the plugins whose extensions load with
+* it, and returns the module of the page's route component.
+*
+* @remarks
+*   A module of the other plugins that fails to import leaves the page to render, and its extension
+*   reports the failure when it renders.
+* @param product - The product, with each installed plugin's manifest.
+* @param route - The route as the build resolved it, with the plugins that load with its page.
+* @returns The module whose default export is the route component.
+* @throws {@link Error} Where no installed manifest maps the route to code, or where the page's
+*   module exports no function or more than one.
+*/
+async function loadPage(product, route) {
+	const { component } = mappingOf(product, route.id);
+	if (component === void 0) throw new Error(`No manifest maps the route ${route.id} to code.`);
+	const [module] = await Promise.all([component(), importPlugins(product.manifests, new Set(route.loads))]);
+	return { default: hostPageOf(route.plugin, route.id, componentOf(module, route.id)) };
+}
+//#endregion
+//#region src/settings/placement.ts
+/**
+* Places a product's settings sections on the settings pages the settings menu lists: each on its
+* target page, else on the first listed page of its plugin.
+*
+* @remarks
+*   A page the menu lists is a page the host renders: its plugin is on and its condition is true.
+*   A section whose target page is not listed and whose plugin has no listed page renders nowhere,
+*   and the host reports it as unplaced.
+*/
+/**
+* Rank of a section without an `order`, which follows every ranked section.
+*/
+const UNRANKED = Number.MAX_SAFE_INTEGER;
+/**
+* Returns the id of the route the host compiles for a settings page: `host/settings/<page id>`.
+*
+* @param pageId - Qualified id of the settings page.
+*/
+function pageRouteOf(pageId) {
+	return `${hostContract.routes.settings.id}/${pageId}`;
+}
+/**
+* Returns the id of the page a section renders on: its target where the menu lists it, else the
+* first listed page of its plugin, else undefined.
+*
+* @param section - A section, with its target page and its plugin.
+* @param listed - Ids of the routes the settings menu lists, in menu order.
+* @param pages - Every settings page.
+*/
+function placedOn(section, listed, pages) {
+	if (listed.includes(pageRouteOf(section.target))) return section.target;
+	return listed.map((routeId) => pages.find((page) => pageRouteOf(page.id) === routeId)).find((page) => page?.plugin === section.plugin)?.id;
+}
+/**
+* Returns the sections that render on a page, ranked by `order`, the unranked after the ranked in
+* install order.
+*
+* @param pageId - Qualified id of the page.
+* @param sections - The sections that render, in install order.
+* @param listed - Ids of the routes the settings menu lists, in menu order.
+* @param pages - Every settings page.
+*/
+function sectionsOn(pageId, sections, listed, pages) {
+	return sections.filter((section) => placedOn(section, listed, pages) === pageId).toSorted((one, other) => (one.order ?? UNRANKED) - (other.order ?? UNRANKED));
+}
+/**
+* Returns the sections that render on no page.
+*
+* @param sections - The sections that render, in install order.
+* @param listed - Ids of the routes the settings menu lists, in menu order.
+* @param pages - Every settings page.
+*/
+function unplacedOf(sections, listed, pages) {
+	return sections.filter((section) => placedOn(section, listed, pages) === void 0);
+}
+//#endregion
+//#region src/settings/use-sections.ts
+/**
+* Reads the settings sections that render, and the settings pages the settings menu lists, in a
+* part under the settings route.
+*/
+/**
+* Returns the ids of the sections whose plugin is on and whose condition is true, joined by spaces,
+* which no qualified id contains.
+*/
+function shownOf(sections, stores) {
+	const context = conditionContextOf(stores);
+	return sections.filter(({ plugin, when }) => context.on(plugin) && evaluateWhen(when, context)).map(({ id }) => id).join(" ");
+}
+/**
+* Returns the sections that render and the pages the settings menu lists, and renders again when a
+* plugin turns on or off, a flag changes or the session changes.
+*/
+function useSections() {
+	const $ = c(22);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = { strict: false };
+		$[0] = t0;
+	} else t0 = $[0];
+	const { host } = useRouteContext(t0);
+	const { availability, flags, session } = host.stores;
+	const { settings } = useResolvedProduct();
+	const entries = useNavigation(hostContract.menus.settings);
+	let t1;
+	if ($[1] !== availability || $[2] !== flags || $[3] !== session) {
+		t1 = (changed) => {
+			const stops = [
+				availability,
+				flags,
+				session
+			].map((store) => store.subscribe(changed));
+			return () => {
+				for (const stop of stops) stop();
+			};
+		};
+		$[1] = availability;
+		$[2] = flags;
+		$[3] = session;
+		$[4] = t1;
+	} else t1 = $[4];
+	const subscribe = t1;
+	let t2;
+	if ($[5] !== availability || $[6] !== flags || $[7] !== session || $[8] !== settings.sections) {
+		t2 = () => shownOf(settings.sections, {
+			availability,
+			flags,
+			session
+		});
+		$[5] = availability;
+		$[6] = flags;
+		$[7] = session;
+		$[8] = settings.sections;
+		$[9] = t2;
+	} else t2 = $[9];
+	const read = t2;
+	const t3 = useSyncExternalStore(subscribe, read, read);
+	let t4;
+	if ($[10] !== t3) {
+		t4 = new Set(t3.split(" "));
+		$[10] = t3;
+		$[11] = t4;
+	} else t4 = $[11];
+	const shown = t4;
+	let t5;
+	if ($[12] !== entries) {
+		t5 = entries.map(_temp);
+		$[12] = entries;
+		$[13] = t5;
+	} else t5 = $[13];
+	let t6;
+	if ($[14] !== settings.sections || $[15] !== shown) {
+		let t7;
+		if ($[17] !== shown) {
+			t7 = (t8) => {
+				const { id } = t8;
+				return shown.has(id);
+			};
+			$[17] = shown;
+			$[18] = t7;
+		} else t7 = $[18];
+		t6 = settings.sections.filter(t7);
+		$[14] = settings.sections;
+		$[15] = shown;
+		$[16] = t6;
+	} else t6 = $[16];
+	let t7;
+	if ($[19] !== t5 || $[20] !== t6) {
+		t7 = {
+			listed: t5,
+			shown: t6
+		};
+		$[19] = t5;
+		$[20] = t6;
+		$[21] = t7;
+	} else t7 = $[21];
+	return t7;
+}
+function _temp(t0) {
+	const { routeId } = t0;
+	return routeId;
+}
+//#endregion
+//#region src/settings/unplaced.ts
+/**
+* Reports the settings sections that render on no settings page.
+*/
+/**
+* Reports each section that renders on no page as `unplaced`, with its target page as the slot,
+* once while the caller is mounted.
+*
+* @remarks
+*   A section is unplaced where its plugin is on, its condition is true, its target page is not
+*   listed and its plugin has no listed page. A section that becomes unplaced after a change is
+*   reported then.
+*/
+function useUnplacedReports() {
+	const $ = c(11);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = { strict: false };
+		$[0] = t0;
+	} else t0 = $[0];
+	const { host } = useRouteContext(t0);
+	let t1;
+	if ($[1] !== host) {
+		t1 = internalsOf(host);
+		$[1] = host;
+		$[2] = t1;
+	} else t1 = $[2];
+	const { report } = t1.runtime;
+	const { settings } = useResolvedProduct();
+	const { listed, shown } = useSections();
+	let t2;
+	if ($[3] !== listed || $[4] !== settings.pages || $[5] !== shown) {
+		t2 = unplacedOf(shown, listed, settings.pages);
+		$[3] = listed;
+		$[4] = settings.pages;
+		$[5] = shown;
+		$[6] = t2;
+	} else t2 = $[6];
+	const unplaced = t2;
+	let t3;
+	if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+		t3 = /* @__PURE__ */ new Set();
+		$[7] = t3;
+	} else t3 = $[7];
+	const reported = useRef(t3);
+	let t4;
+	if ($[8] !== report || $[9] !== unplaced) {
+		t4 = () => {
+			for (const { id, target } of unplaced) if (!reported.current.has(id)) {
+				reported.current.add(id);
+				report({
+					kind: "unplaced",
+					slot: target,
+					target: id
+				});
+			}
+		};
+		$[8] = report;
+		$[9] = unplaced;
+		$[10] = t4;
+	} else t4 = $[10];
+	useEffect(t4);
+}
+//#endregion
+//#region src/settings/frame.tsx
+/**
+* Renders the navigation package's link as the router's link.
+*/
+const MenuLink = createLink(Link);
+/**
+* Renders the settings frame around the settings page the router matched.
+*
+* @returns The page, with its title, the settings menu and the matched page in its body.
+*/
+function SettingsFrame() {
+	const $ = c(20);
+	const { t } = useTranslation("host");
+	const entries = useNavigation(hostContract.menus.settings);
+	const current = useDeclaredRoute()?.id;
+	useUnplacedReports();
+	let t0;
+	if ($[0] !== t) {
+		t0 = t("settings.title");
+		$[0] = t;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== t0) {
+		t1 = /* @__PURE__ */ jsx(Page.Header, { children: /* @__PURE__ */ jsx(Page.Title, { children: t0 }) });
+		$[2] = t0;
+		$[3] = t1;
+	} else t1 = $[3];
+	let t2;
+	if ($[4] !== t) {
+		t2 = t("settings.menu");
+		$[4] = t;
+		$[5] = t2;
+	} else t2 = $[5];
+	let t3;
+	if ($[6] !== current || $[7] !== entries) {
+		let t4;
+		if ($[9] !== current) {
+			t4 = (t5) => {
+				const { href, label, routeId } = t5;
+				return /* @__PURE__ */ jsx(MenuLink, {
+					inherit: routeId !== current,
+					to: href,
+					variant: "plain",
+					children: label
+				}, routeId);
+			};
+			$[9] = current;
+			$[10] = t4;
+		} else t4 = $[10];
+		t3 = entries.map(t4);
+		$[6] = current;
+		$[7] = entries;
+		$[8] = t3;
+	} else t3 = $[8];
+	let t4;
+	if ($[11] !== t3) {
+		t4 = /* @__PURE__ */ jsx(Stack, {
+			direction: "row",
+			gap: "lg",
+			wrap: true,
+			children: t3
+		});
+		$[11] = t3;
+		$[12] = t4;
+	} else t4 = $[12];
+	let t5;
+	if ($[13] !== t2 || $[14] !== t4) {
+		t5 = /* @__PURE__ */ jsx(Page.Nav, {
+			"aria-label": t2,
+			children: t4
+		});
+		$[13] = t2;
+		$[14] = t4;
+		$[15] = t5;
+	} else t5 = $[15];
+	let t6;
+	if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+		t6 = /* @__PURE__ */ jsx(Page.Body, { children: /* @__PURE__ */ jsx(Outlet, {}) });
+		$[16] = t6;
+	} else t6 = $[16];
+	let t7;
+	if ($[17] !== t1 || $[18] !== t5) {
+		t7 = /* @__PURE__ */ jsxs(Page.Root, { children: [
+			t1,
+			t5,
+			t6
+		] });
+		$[17] = t1;
+		$[18] = t5;
+		$[19] = t7;
+	} else t7 = $[19];
+	return t7;
+}
+//#endregion
+//#region src/settings/index-page.tsx
+/**
+* Replaces the settings route's own address with the first page of the settings menu.
+*
+* @remarks
+*   The menu always lists the host's Plugins page: the host is always on, and the page's condition
+*   is the product's, which the settings route has already passed. The first entry sorts by rank,
+*   then by translated title, so the redirect runs in the page and not before the route loads, and
+*   a server renders the frame without a page.
+* @returns The router's redirect to the first page.
+*/
+function SettingsIndex() {
+	const $ = c(2);
+	const first = useNavigation(hostContract.menus.settings)[0];
+	let t0;
+	if ($[0] !== first.href) {
+		t0 = /* @__PURE__ */ jsx(Navigate, {
+			replace: true,
+			to: first.href
+		});
+		$[0] = first.href;
+		$[1] = t0;
+	} else t0 = $[1];
+	return t0;
+}
+//#endregion
+//#region src/settings/dependents.ts
+/**
+* Returns the plugins that are on and require a plugin without `optional`, directly or through
+* another plugin that does, in install order.
+*
+* @remarks
+*   A plugin is not on while a plugin it requires without `optional` is not on, so switching the
+*   plugin off turns these off with it. The set of plugins turned off grows until no plugin joins
+*   it, so the walk ends on a ring of requirements too.
+* @param plugins - The installed plugins, with the plugins each requires.
+* @param pluginId - Id of the plugin being switched off.
+* @param on - Returns true where a plugin is on.
+*/
+function dependentsOf(plugins, pluginId, on) {
+	const off = /* @__PURE__ */ new Set([pluginId]);
+	let grown = true;
+	while (grown) {
+		grown = false;
+		for (const plugin of plugins) if (plugin.requires.some((required) => required.optional !== true && off.has(required.pluginId)) && !off.has(plugin.id) && on(plugin.id)) {
+			off.add(plugin.id);
+			grown = true;
+		}
+	}
+	return plugins.filter((plugin) => plugin.id !== pluginId && off.has(plugin.id));
+}
+//#endregion
+//#region src/settings/confirmation.tsx
+/**
+* Asks a person to confirm a switch that turns other plugins off with the plugin they switch off.
+*/
+/**
+* Renders a warning that names the plugins that turn off with the plugin, with a button that keeps
+* it on and a button that turns it off.
+*
+* @remarks
+*   The warning mounts with its words, which a screen reader does not reliably announce from a new
+*   live region, so the confirmation announces them through the announcer's region, politely,
+*   without moving focus off the switch. The plugins are listed in the person's language.
+* @returns The warning.
+*/
+function Confirmation(t0) {
+	const $ = c(41);
+	const { dependents, name, onSettle } = t0;
+	const { i18n, t } = useTranslation("host");
+	const announce = useAnnounce();
+	let t1;
+	let title;
+	if ($[0] !== dependents || $[1] !== i18n.language || $[2] !== name || $[3] !== t) {
+		const plugins = new Intl.ListFormat(i18n.language, { type: "conjunction" }).format(dependents);
+		let t2;
+		if ($[6] !== name || $[7] !== t) {
+			t2 = t("plugins.confirm.title", { plugin: name });
+			$[6] = name;
+			$[7] = t;
+			$[8] = t2;
+		} else t2 = $[8];
+		title = t2;
+		t1 = t("plugins.confirm.description", {
+			count: dependents.length,
+			plugins
+		});
+		$[0] = dependents;
+		$[1] = i18n.language;
+		$[2] = name;
+		$[3] = t;
+		$[4] = t1;
+		$[5] = title;
+	} else {
+		t1 = $[4];
+		title = $[5];
+	}
+	const description = t1;
+	let t2;
+	let t3;
+	if ($[9] !== announce || $[10] !== description || $[11] !== title) {
+		t2 = () => {
+			announce(`${title} ${description}`);
+		};
+		t3 = [
+			announce,
+			description,
+			title
+		];
+		$[9] = announce;
+		$[10] = description;
+		$[11] = title;
+		$[12] = t2;
+		$[13] = t3;
+	} else {
+		t2 = $[12];
+		t3 = $[13];
+	}
+	useEffect(t2, t3);
+	let t4;
+	if ($[14] !== title) {
+		t4 = /* @__PURE__ */ jsx(Alert.Title, { children: title });
+		$[14] = title;
+		$[15] = t4;
+	} else t4 = $[15];
+	let t5;
+	if ($[16] !== description) {
+		t5 = /* @__PURE__ */ jsx(Alert.Description, { children: description });
+		$[16] = description;
+		$[17] = t5;
+	} else t5 = $[17];
+	let t6;
+	if ($[18] !== t4 || $[19] !== t5) {
+		t6 = /* @__PURE__ */ jsxs(Alert.Content, { children: [t4, t5] });
+		$[18] = t4;
+		$[19] = t5;
+		$[20] = t6;
+	} else t6 = $[20];
+	let t7;
+	if ($[21] !== onSettle) {
+		t7 = () => {
+			onSettle(false);
+		};
+		$[21] = onSettle;
+		$[22] = t7;
+	} else t7 = $[22];
+	let t8;
+	if ($[23] !== t) {
+		t8 = t("plugins.confirm.keep");
+		$[23] = t;
+		$[24] = t8;
+	} else t8 = $[24];
+	let t9;
+	if ($[25] !== t7 || $[26] !== t8) {
+		t9 = /* @__PURE__ */ jsx(Button, {
+			onClick: t7,
+			size: "sm",
+			variant: "outline",
+			children: t8
+		});
+		$[25] = t7;
+		$[26] = t8;
+		$[27] = t9;
+	} else t9 = $[27];
+	let t10;
+	if ($[28] !== onSettle) {
+		t10 = () => {
+			onSettle(true);
+		};
+		$[28] = onSettle;
+		$[29] = t10;
+	} else t10 = $[29];
+	let t11;
+	if ($[30] !== t) {
+		t11 = t("plugins.confirm.action");
+		$[30] = t;
+		$[31] = t11;
+	} else t11 = $[31];
+	let t12;
+	if ($[32] !== t10 || $[33] !== t11) {
+		t12 = /* @__PURE__ */ jsx(Button, {
+			onClick: t10,
+			palette: "error",
+			size: "sm",
+			children: t11
+		});
+		$[32] = t10;
+		$[33] = t11;
+		$[34] = t12;
+	} else t12 = $[34];
+	let t13;
+	if ($[35] !== t12 || $[36] !== t9) {
+		t13 = /* @__PURE__ */ jsxs(Alert.Aside, { children: [t9, t12] });
+		$[35] = t12;
+		$[36] = t9;
+		$[37] = t13;
+	} else t13 = $[37];
+	let t14;
+	if ($[38] !== t13 || $[39] !== t6) {
+		t14 = /* @__PURE__ */ jsxs(Alert.Root, {
+			live: "off",
+			status: "warning",
+			children: [t6, t13]
+		});
+		$[38] = t13;
+		$[39] = t6;
+		$[40] = t14;
+	} else t14 = $[40];
+	return t14;
+}
+//#endregion
+//#region src/settings/plugin-row.tsx
+/**
+* Renders one installed plugin on the Plugins page: its name, its description, its state and the
+* switch a person turns it on and off with.
+*/
+/**
+* Keys of the words that state why a plugin is not on, by the reason, where its switch does not
+* state it.
+*/
+const REASONS = {
+	condition: "plugins.reason.condition",
+	requirement: "plugins.reason.requirement",
+	unavailable: "plugins.reason.unavailable"
+};
+/**
+* Returns the key of the words that state why a plugin is always on or not on, or undefined where
+* its switch states it.
+*/
+function noteOf(status) {
+	if (!status.switchable) return "plugins.always";
+	return status.reason === void 0 || status.reason === "off" ? void 0 : REASONS[status.reason];
+}
+/**
+* Renders the plugin's switch, which is disabled and on for a locked plugin, and the confirmation
+* where switching it off turns other plugins off.
+*
+* @remarks
+*   The switch is on until the person confirms. Once they settle, the confirmation closes and
+*   focus returns to the switch, because the button that had focus is gone.
+* @param props - The plugin's state, the person's switch, the plugins that turn off with it and the
+*   callback that switches it.
+* @returns The list's item.
+*/
+function PluginRow(t0) {
+	const $ = c(6);
+	const { dependents, onSwitch, status, switched } = t0;
+	const { i18n, t } = useTranslation("host");
+	const words = pluginWordsOf(i18n);
+	const [pending, setPending] = useState(false);
+	const input = useId();
+	const name = words.t(status.id, "plugin.name");
+	const note = noteOf(status);
+	let t1;
+	if ($[0] !== input) {
+		t1 = { hiddenInput: input };
+		$[0] = input;
+		$[1] = t1;
+	} else t1 = $[1];
+	let t2;
+	if ($[2] !== dependents || $[3] !== onSwitch) {
+		t2 = (t3) => {
+			const { checked } = t3;
+			if (!checked && dependents.length > 0) setPending(true);
+			else onSwitch(checked);
+		};
+		$[2] = dependents;
+		$[3] = onSwitch;
+		$[4] = t2;
+	} else t2 = $[4];
+	let t3;
+	if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+		t3 = /* @__PURE__ */ jsx(Switch.Control, { children: /* @__PURE__ */ jsx(Switch.Thumb, {}) });
+		$[5] = t3;
+	} else t3 = $[5];
+	return /* @__PURE__ */ jsxs(List.Item, { children: [/* @__PURE__ */ jsxs(Switch.Root, {
+		checked: switched,
+		disabled: !status.switchable,
+		ids: t1,
+		onCheckedChange: t2,
+		spread: true,
+		children: [/* @__PURE__ */ jsx(Switch.Label, { children: /* @__PURE__ */ jsxs(Stack, {
+			as: "span",
+			gap: "xs",
+			children: [
+				/* @__PURE__ */ jsx(Text, {
+					as: "span",
+					size: "sm",
+					children: name
+				}),
+				/* @__PURE__ */ jsx(Text, {
+					as: "span",
+					size: "sm",
+					tone: "muted",
+					children: words.t(status.id, "plugin.description")
+				}),
+				note === void 0 ? null : /* @__PURE__ */ jsx(Text, {
+					as: "span",
+					size: "sm",
+					tone: "muted",
+					children: t(note)
+				})
+			]
+		}) }), t3]
+	}), pending ? /* @__PURE__ */ jsx(Confirmation, {
+		dependents: dependents.map((t4) => {
+			const { id } = t4;
+			return words.t(id, "plugin.name");
+		}),
+		name,
+		onSettle: (off) => {
+			flushSync(() => {
+				setPending(false);
+			});
+			if (off) onSwitch(false);
+			document.querySelector(`[id="${input}"]`).focus();
+		}
+	}) : null] });
+}
+//#endregion
+//#region src/settings/plugin-list.tsx
+/**
+* Renders the list of installed plugins on the host's Plugins page.
+*/
+/**
+* Renders a section with a row per installed plugin, in install order, and writes a switch to the
+* host's switch store.
+*
+* @remarks
+*   A switch writes under the person and the tenant of the session, so the choice applies to them
+*   alone. The host evaluates every plugin again after a switch, and the pages, menus, commands and
+*   settings of a plugin that turns off leave the page without a reload.
+* @returns The section.
+*/
+function PluginList() {
+	const $ = c(24);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = { strict: false };
+		$[0] = t0;
+	} else t0 = $[0];
+	const { host } = useRouteContext(t0);
+	const { switches } = internalsOf(host);
+	const { t } = useTranslation("host");
+	const { plugins } = useResolvedProduct();
+	const statuses = usePluginStatuses();
+	const switched = useSyncExternalStore(switches.subscribe, switches.get, switches.get);
+	let t1;
+	if ($[1] !== statuses) {
+		t1 = (pluginId) => statuses.some((status) => status.id === pluginId && status.on);
+		$[1] = statuses;
+		$[2] = t1;
+	} else t1 = $[2];
+	const on = t1;
+	const t2 = Section;
+	const t3 = true;
+	let t4;
+	if ($[3] !== t) {
+		t4 = t("plugins.title");
+		$[3] = t;
+		$[4] = t4;
+	} else t4 = $[4];
+	let t5;
+	if ($[5] !== t4) {
+		t5 = /* @__PURE__ */ jsx(Section.Title, { children: t4 });
+		$[5] = t4;
+		$[6] = t5;
+	} else t5 = $[6];
+	let t6;
+	if ($[7] !== t) {
+		t6 = t("plugins.about");
+		$[7] = t;
+		$[8] = t6;
+	} else t6 = $[8];
+	let t7;
+	if ($[9] !== t6) {
+		t7 = /* @__PURE__ */ jsx(Section.Description, { children: t6 });
+		$[9] = t6;
+		$[10] = t7;
+	} else t7 = $[10];
+	let t8;
+	if ($[11] !== t5 || $[12] !== t7) {
+		t8 = /* @__PURE__ */ jsxs(Section.Header, { children: [t5, t7] });
+		$[11] = t5;
+		$[12] = t7;
+		$[13] = t8;
+	} else t8 = $[13];
+	const t9 = Section;
+	const t10 = List;
+	const t11 = "lg";
+	const t12 = "plain";
+	const t13 = statuses.map((status_0) => /* @__PURE__ */ jsx(PluginRow, {
+		dependents: dependentsOf(plugins, status_0.id, on),
+		onSwitch: (checked) => {
+			switches.set(status_0.id, checked);
+		},
+		status: status_0,
+		switched: switched[status_0.id] ?? true
+	}, status_0.id));
+	let t14;
+	if ($[14] !== t10.Root || $[15] !== t13) {
+		t14 = /* @__PURE__ */ jsx(t10.Root, {
+			gap: t11,
+			variant: t12,
+			children: t13
+		});
+		$[14] = t10.Root;
+		$[15] = t13;
+		$[16] = t14;
+	} else t14 = $[16];
+	let t15;
+	if ($[17] !== t14 || $[18] !== t9.Body) {
+		t15 = /* @__PURE__ */ jsx(t9.Body, { children: t14 });
+		$[17] = t14;
+		$[18] = t9.Body;
+		$[19] = t15;
+	} else t15 = $[19];
+	let t16;
+	if ($[20] !== t15 || $[21] !== t2.Root || $[22] !== t8) {
+		t16 = /* @__PURE__ */ jsxs(t2.Root, {
+			annotated: t3,
+			children: [t8, t15]
+		});
+		$[20] = t15;
+		$[21] = t2.Root;
+		$[22] = t8;
+		$[23] = t16;
+	} else t16 = $[23];
+	return t16;
+}
+//#endregion
+//#region src/settings/component-section.ts
+/**
+* Renders a settings section's component from its plugin's manifest, loaded on its first render.
+*/
+/**
+* Renders the component the section's manifest maps it to, with `{ sectionId }` as its props.
+*
+* @returns The component, which suspends while its module loads.
+*/
+function ComponentSection(t0) {
+	const $ = c(9);
+	const { section } = t0;
+	let t1;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = { strict: false };
+		$[0] = t1;
+	} else t1 = $[0];
+	const { host } = useRouteContext(t1);
+	let t2;
+	if ($[1] !== section.id || $[2] !== section.plugin.length) {
+		t2 = section.id.slice(section.plugin.length + 1);
+		$[1] = section.id;
+		$[2] = section.plugin.length;
+		$[3] = t2;
+	} else t2 = $[3];
+	const name = t2;
+	let t3;
+	if ($[4] !== host || $[5] !== name || $[6] !== section.id || $[7] !== section.plugin) {
+		const importer = (internalsOf(host).runtime.product.manifests[section.plugin]?.code)?.settings?.[name]?.component;
+		const props = { sectionId: section.id };
+		t3 = createElement(lazyOf(importer, section.id), props);
+		$[4] = host;
+		$[5] = name;
+		$[6] = section.id;
+		$[7] = section.plugin;
+		$[8] = t3;
+	} else t3 = $[8];
+	return t3;
+}
+//#endregion
+//#region src/settings/section-failed.tsx
+/**
+* Renders the alert, which states that the section could not be shown.
+*
+* @returns The alert, in the error status.
+*/
+function SectionFailed() {
+	const $ = c(11);
+	const { t } = useTranslation("host");
+	let t0;
+	if ($[0] !== t) {
+		t0 = t("settings.failed.title");
+		$[0] = t;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== t0) {
+		t1 = /* @__PURE__ */ jsx(Alert.Title, { children: t0 });
+		$[2] = t0;
+		$[3] = t1;
+	} else t1 = $[3];
+	let t2;
+	if ($[4] !== t) {
+		t2 = t("settings.failed.description");
+		$[4] = t;
+		$[5] = t2;
+	} else t2 = $[5];
+	let t3;
+	if ($[6] !== t2) {
+		t3 = /* @__PURE__ */ jsx(Alert.Description, { children: t2 });
+		$[6] = t2;
+		$[7] = t3;
+	} else t3 = $[7];
+	let t4;
+	if ($[8] !== t1 || $[9] !== t3) {
+		t4 = /* @__PURE__ */ jsx(Alert.Root, {
+			status: "error",
+			children: /* @__PURE__ */ jsxs(Alert.Content, { children: [t1, t3] })
+		});
+		$[8] = t1;
+		$[9] = t3;
+		$[10] = t4;
+	} else t4 = $[10];
+	return t4;
+}
+//#endregion
+//#region src/settings/guarded.tsx
+/**
+* Renders a settings section's content in its plugin's scope, inside a boundary of its own.
+*
+* @remarks
+*   A render of the content that throws counts one failure towards the quarantine of
+*   `section:<id>` and shows an alert in the content's place, so the other sections of the page
+*   keep running. A quarantined section shows the alert without rendering.
+*/
+/**
+* Renders the content, or the alert once it failed or while it is quarantined.
+*
+* @returns The content in its plugin's scope, suspended while it loads.
+*/
+function Guarded(t0) {
+	const $ = c(1);
+	const { children, section } = t0;
+	let t1;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = { strict: false };
+		$[0] = t1;
+	} else t1 = $[0];
+	const { host } = useRouteContext(t1);
+	const { quarantine } = host.stores;
+	const target = `section:${section.id}`;
+	const read = () => quarantine.get().has(target);
+	return useSyncExternalStore(quarantine.subscribe, read, read) ? /* @__PURE__ */ jsx(SectionFailed, {}) : /* @__PURE__ */ jsx(PluginProvider, {
+		pluginId: section.plugin,
+		children: /* @__PURE__ */ jsx(Suspense, {
+			fallback: null,
+			children: /* @__PURE__ */ jsx(Boundary, {
+				fallback: /* @__PURE__ */ jsx(SectionFailed, {}),
+				onError: (error) => {
+					quarantine.failed(target, error);
+				},
+				onRendered: () => {
+					quarantine.rendered(target);
+				},
+				resetKey: section,
+				children
+			})
+		})
+	});
+}
+//#endregion
+//#region src/settings/schema-section.tsx
+/**
+* Renders the section's form, with the host's glyphs and a Save button.
+*
+* @remarks
+*   The form's id is `settings.<section name>`, so each word of the form is a key of the plugin's
+*   catalogue under `settings.<section name>`. A valid submission writes the values over the stored
+*   ones and raises a success toast, and the form keeps the values. An invalid one focuses the
+*   first refused field.
+* @returns The form.
+*/
+function SchemaSection(t0) {
+	const $ = c(38);
+	const { schema, section } = t0;
+	let t1;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = { strict: false };
+		$[0] = t1;
+	} else t1 = $[0];
+	const { host } = useRouteContext(t1);
+	const { i18n, t } = useTranslation("host");
+	const toaster = useToaster();
+	let t2;
+	if ($[1] !== section.id) {
+		t2 = {
+			id: section.id,
+			kind: "settingsSection"
+		};
+		$[1] = section.id;
+		$[2] = t2;
+	} else t2 = $[2];
+	const { update, values } = useSettings(t2);
+	let t3;
+	if ($[3] !== section.id || $[4] !== section.plugin.length) {
+		t3 = section.id.slice(section.plugin.length + 1);
+		$[3] = section.id;
+		$[4] = section.plugin.length;
+		$[5] = t3;
+	} else t3 = $[5];
+	const t4 = `settings.${t3}`;
+	let t5;
+	if ($[6] !== t || $[7] !== toaster || $[8] !== update) {
+		t5 = (t6) => {
+			const { value } = t6;
+			update(value);
+			toaster.create({
+				title: t("settings.saved"),
+				type: "success"
+			});
+		};
+		$[6] = t;
+		$[7] = toaster;
+		$[8] = update;
+		$[9] = t5;
+	} else t5 = $[9];
+	let t6;
+	if ($[10] !== schema) {
+		t6 = { ...schema };
+		$[10] = schema;
+		$[11] = t6;
+	} else t6 = $[11];
+	let t7;
+	if ($[12] !== i18n || $[13] !== section.plugin) {
+		t7 = translatorOf(i18n, section.plugin);
+		$[12] = i18n;
+		$[13] = section.plugin;
+		$[14] = t7;
+	} else t7 = $[14];
+	let t8;
+	if ($[15] !== t4 || $[16] !== t5 || $[17] !== t6 || $[18] !== t7 || $[19] !== values) {
+		t8 = {
+			id: t4,
+			onSubmit: t5,
+			schema: t6,
+			translate: t7,
+			values
+		};
+		$[15] = t4;
+		$[16] = t5;
+		$[17] = t6;
+		$[18] = t7;
+		$[19] = values;
+		$[20] = t8;
+	} else t8 = $[20];
+	const form = useSchemaForm(t8);
+	const T0 = form.AppForm;
+	const T1 = form.Form;
+	let t9;
+	if ($[21] !== host) {
+		t9 = internalsOf(host);
+		$[21] = host;
+		$[22] = t9;
+	} else t9 = $[22];
+	const t10 = t9.glyphs;
+	let t11;
+	if ($[23] !== form.Fields) {
+		t11 = /* @__PURE__ */ jsx(form.Fields, {});
+		$[23] = form.Fields;
+		$[24] = t11;
+	} else t11 = $[24];
+	const T2 = form.Submit;
+	let t12;
+	if ($[25] !== t) {
+		t12 = t("settings.save");
+		$[25] = t;
+		$[26] = t12;
+	} else t12 = $[26];
+	let t13;
+	if ($[27] !== form.Submit || $[28] !== t12) {
+		t13 = /* @__PURE__ */ jsx(T2, { children: t12 });
+		$[27] = form.Submit;
+		$[28] = t12;
+		$[29] = t13;
+	} else t13 = $[29];
+	let t14;
+	if ($[30] !== form.Form || $[31] !== t11 || $[32] !== t13 || $[33] !== t9.glyphs) {
+		t14 = /* @__PURE__ */ jsxs(T1, {
+			glyphs: t10,
+			children: [t11, t13]
+		});
+		$[30] = form.Form;
+		$[31] = t11;
+		$[32] = t13;
+		$[33] = t9.glyphs;
+		$[34] = t14;
+	} else t14 = $[34];
+	let t15;
+	if ($[35] !== form.AppForm || $[36] !== t14) {
+		t15 = /* @__PURE__ */ jsx(T0, { children: t14 });
+		$[35] = form.AppForm;
+		$[36] = t14;
+		$[37] = t15;
+	} else t15 = $[37];
+	return t15;
+}
+//#endregion
+//#region src/settings/section.tsx
+/**
+* Renders the section's heading, translated in its plugin's catalogue, beside its content.
+*
+* @returns A `section` element named by its heading.
+*/
+function SettingsSection(t0) {
+	const $ = c(14);
+	const { section } = t0;
+	const { i18n } = useTranslation("host");
+	let t1;
+	if ($[0] !== i18n || $[1] !== section.label || $[2] !== section.plugin) {
+		t1 = pluginWordsOf(i18n).t(section.plugin, section.label);
+		$[0] = i18n;
+		$[1] = section.label;
+		$[2] = section.plugin;
+		$[3] = t1;
+	} else t1 = $[3];
+	let t2;
+	if ($[4] !== t1) {
+		t2 = /* @__PURE__ */ jsx(Section.Header, { children: /* @__PURE__ */ jsx(Section.Title, { children: t1 }) });
+		$[4] = t1;
+		$[5] = t2;
+	} else t2 = $[5];
+	let t3;
+	if ($[6] !== section) {
+		t3 = section.schema === void 0 ? /* @__PURE__ */ jsx(ComponentSection, { section }) : /* @__PURE__ */ jsx(SchemaSection, {
+			schema: section.schema,
+			section
+		});
+		$[6] = section;
+		$[7] = t3;
+	} else t3 = $[7];
+	let t4;
+	if ($[8] !== section || $[9] !== t3) {
+		t4 = /* @__PURE__ */ jsx(Section.Body, { children: /* @__PURE__ */ jsx(Guarded, {
+			section,
+			children: t3
+		}) });
+		$[8] = section;
+		$[9] = t3;
+		$[10] = t4;
+	} else t4 = $[10];
+	let t5;
+	if ($[11] !== t2 || $[12] !== t4) {
+		t5 = /* @__PURE__ */ jsxs(Section.Root, {
+			annotated: true,
+			children: [t2, t4]
+		});
+		$[11] = t2;
+		$[12] = t4;
+		$[13] = t5;
+	} else t5 = $[13];
+	return t5;
+}
+//#endregion
+//#region src/settings/page.tsx
+/**
+* Returns the component of a settings page's route.
+*
+* @remarks
+*   The page renders, in order, the sections whose target it is and the sections of its plugin
+*   whose target page is not rendered, where their plugin is on and their condition is true. A page
+*   that renders no section and is not the Plugins page states that it has nothing to set.
+*/
+function settingsPageOf(page) {
+	const plugins = page.id === hostContract.settings.pages.plugins.id;
+	/**
+	* Renders the page's content below the settings menu.
+	*/
+	return function SettingsPage() {
+		const { i18n, t } = useTranslation("host");
+		const { settings } = useResolvedProduct();
+		const { listed, shown } = useSections();
+		const sections = sectionsOn(page.id, shown, listed, settings.pages);
+		useDocumentTitle(pluginWordsOf(i18n).t(page.plugin, page.label));
+		if (!plugins && sections.length === 0) return /* @__PURE__ */ jsx(EmptyState.Root, { children: /* @__PURE__ */ jsx(EmptyState.Content, { children: /* @__PURE__ */ jsx(EmptyState.Title, { children: t("settings.empty") }) }) });
+		return /* @__PURE__ */ jsxs(Fragment, { children: [plugins ? /* @__PURE__ */ jsx(PluginList, {}) : null, sections.map((section) => /* @__PURE__ */ jsx(SettingsSection, { section }, section.id))] });
+	};
+}
+//#endregion
+//#region src/settings/routes.ts
+/**
+* Id of the route at the settings route's own address, which opens the first settings page.
+*/
+const SETTINGS_INDEX = `${hostContract.routes.settings.id}/index`;
+/**
+* Returns the declaration of the settings route's index: a child at `/` without a condition, which
+* the settings route's own condition guards.
+*/
+function settingsIndexOf() {
+	return {
+		component: SettingsIndex,
+		id: SETTINGS_INDEX,
+		parent: hostContract.routes.settings.id,
+		path: "/"
+	};
+}
+/**
+* Returns the component of a route the host renders itself, or undefined for a plugin's route.
+*
+* @remarks
+*   The settings frame and each settings page render as a plugin's page does: in the scope of the
+*   route's plugin, with the extensions placed around the route, and with the route's count of
+*   failed renders returned to zero after a render that commits. A settings page loads with the
+*   modules of the plugins in its `loads`.
+* @param product - The product, with each installed plugin's manifest.
+* @param route - The route as the build resolved it.
+*/
+function hostComponentOf(product, route) {
+	if (route.id === hostContract.routes.settings.id) return hostPageOf(HOST, route.id, SettingsFrame);
+	const page = product.settings.pages.find(({ id }) => pageRouteOf(id) === route.id);
+	return page === void 0 ? void 0 : { load: async () => {
+		await importPlugins(product.manifests, new Set(route.loads));
+		return { default: hostPageOf(route.plugin, route.id, settingsPageOf(page)) };
+	} };
+}
+//#endregion
+//#region src/routes/create-routes.ts
+/**
+* Compiles a product's routes under the product's root route: the plugins' pages, the settings
+* route with its index, and a route per settings page.
+*/
+/**
+* Returns a route as the router's compiler takes it, with the host's own component for the
+* settings route and the settings pages.
+*/
+function declarationOf(product, route) {
+	return {
+		component: hostComponentOf(product, route) ?? { load: () => loadPage(product, route) },
+		id: route.id,
+		loader: loaderOf(product, route),
+		navigation: route.navigation,
+		parent: route.parent,
+		path: route.path,
+		sample: route.sample,
+		search: mappingOf(product, route.id).search,
+		when: {
+			pluginId: route.plugin,
+			routeId: route.id,
+			when: route.when
+		}
+	};
+}
+/**
+* Returns a function of the product's root route that compiles every route of the product under
+* it.
+*
+* @remarks
+*   The routes compile in one call, so the compiler sees every path at once. Each route loads its
+*   page with the modules of the plugins in its `loads`, loads its `data` through the data client
+*   in the router's context, validates its search with its contract's validator, and evaluates its
+*   condition against the host in the router's context. The settings route renders the settings
+*   frame, its index opens the first settings page, and each settings page renders its sections.
+*   The pages import through the manifests' importers as `instrumented` wraps them.
+* @param product - The product, with each installed plugin's manifest.
+* @returns The function that compiles the routes under the root, for the root's `addChildren`.
+*/
+function createHostRoutes(product) {
+	const loaded = instrumented(product).product;
+	const declarations = [...loaded.routes.map((route) => declarationOf(loaded, route)), settingsIndexOf()];
+	const evaluate = evaluatorOf(product);
+	return (root) => compileRoutes(declarations, {
+		errorComponent: ({ id }) => routeErrorOf(id, mappingOf(loaded, id).fallback),
+		evaluate,
+		parent: root
+	});
+}
+//#endregion
+export { HostContent as a, sampledFrom as c, HostNotFound as i, HostRoot as n, createHost as o, HostProvider as r, internalsOf as s, createHostRoutes as t };