@stealthscale/sdk-host 0.1.0 → 0.4.0

package/dist/releases.js

@@ -0,0 +1,404 @@
+import { t as renderProduct } from "./render-CEa8Jhmo.js";
+import { n as deploymentOf } from "./document-CeEtZo2E.js";
+import { MANIFEST_FILE, lineOf, preloadsOf, registerPreloader, resolveProduct, unmetRequirements } from "@stealthscale/sdk-core";
+import { NONE } from "@stealthscale/provider-i18n";
+//#region src/releases/catalogues.ts
+/**
+* Returns a release's words in one language, fetched with the integrity `plugin.json` lists.
+*
+* @param fetching - Fetches a URL with an integrity.
+* @param base - The absolute URL of the release's directory.
+* @param release - The release's description.
+* @param language - The BCP 47 tag the catalogue's file is named after.
+* @throws {@link Error} When the description lists no such file, the response is not a success,
+*   or its body is not an object of words.
+*/
+async function wordsAt(fetching, base, release, language) {
+	const path = `locales/${language}.json`;
+	const integrity = release.files[path];
+	const url = new URL(path, base).href;
+	if (integrity === void 0) throw new Error(`plugin.json lists no ${path}.`);
+	const response = await fetching(url, { integrity });
+	if (!response.ok) throw new Error(`${url} responded with ${String(response.status)}.`);
+	const words = await response.json();
+	if (typeof words !== "object" || words === null || Array.isArray(words)) throw new Error(`${url} contains no object of words.`);
+	return words;
+}
+/**
+* Returns a page's catalogues with the namespaces of loaded releases added.
+*
+* @remarks
+*   A release's words in the page's fallback language are inlined, as the build inlines the
+*   product's. The words in any other language the release lists are fetched when the i18n
+*   instance asks for them, with their integrity. Every other namespace loads as before.
+* @param catalogues - The page's catalogues.
+* @param releases - The loaded releases, each with its words in the fallback language.
+* @param fetching - Fetches a URL with an integrity.
+*/
+function cataloguesWith(catalogues, releases, fetching) {
+	const { bundled, defaults, fallback, languages, load, namespaces } = catalogues;
+	const byId = new Map(releases.map((one) => [one.release.id, one]));
+	const words = Object.fromEntries(releases.map((one) => [one.release.id, one.words]));
+	return {
+		bundled: {
+			...bundled,
+			[fallback]: {
+				...bundled[fallback],
+				...words
+			}
+		},
+		defaults: {
+			...defaults,
+			...words
+		},
+		fallback,
+		languages: [.../* @__PURE__ */ new Set([...languages, ...releases.flatMap(({ release }) => release.languages)])],
+		load: (language, namespace) => {
+			const loaded = byId.get(namespace);
+			return loaded?.release.languages.includes(language) === true ? wordsAt(fetching, loaded.base, loaded.release, language) : load(language, namespace);
+		},
+		namespaces: [...namespaces, ...releases.map(({ release }) => release.id)]
+	};
+}
+//#endregion
+//#region src/releases/load.ts
+/**
+* Returns the report of a refused release.
+*/
+function refusal(plugin, reason, detail) {
+	return {
+		detail,
+		kind: "plugin-refused",
+		plugin,
+		reason
+	};
+}
+/**
+* Returns the message of an error, or the value written as text.
+*/
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Returns the phrase that describes a requirement the page does not meet.
+*/
+function unmetOf({ package: name, provided, range }) {
+	return provided === void 0 ? `requires ${name} ${range}, which the page does not provide` : `requires ${name} ${range}, and the page provides ${provided}`;
+}
+/**
+* Returns the refusal of a release whose requirements or languages the page does not meet, and
+* undefined for a release the page can load.
+*/
+function checked(options, listed) {
+	const { id, languages, requires } = listed.release;
+	const { fallback, namespaces } = options.catalogues;
+	const unmet = unmetRequirements(requires, options.deployment.provided);
+	if (unmet.length > 0) return refusal(id, "requires", unmet.map((one) => unmetOf(one)).join("; "));
+	if (!languages.includes(fallback)) return refusal(id, "catalogue", `has no catalogue in the page's fallback language ${fallback}`);
+	return namespaces.includes(id) ? refusal(id, "catalogue", `names the namespace ${id}, which the page's catalogues contain`) : void 0;
+}
+/**
+* Returns the manifest that a module exports as `manifest`, or undefined where the manifest's
+* contract has no plugin id.
+*/
+function manifestIn(module) {
+	const manifest = typeof module === "object" && module !== null ? Reflect.get(module, "manifest") : void 0;
+	const contract = typeof manifest === "object" && manifest !== null ? Reflect.get(manifest, "contract") : void 0;
+	return typeof (typeof contract === "object" && contract !== null ? Reflect.get(contract, "pluginId") : void 0) === "string" ? manifest : void 0;
+}
+/**
+* Imports a release's manifest, and returns it or the release's refusal.
+*/
+async function manifestOf(options, listed) {
+	const { id } = listed.release;
+	let module;
+	try {
+		module = await options.importing(new URL(MANIFEST_FILE, listed.base).href);
+	} catch (error) {
+		return refusal(id, "manifest", messageOf(error));
+	}
+	const manifest = manifestIn(module);
+	if (manifest === void 0) return refusal(id, "manifest", "manifest.js exports no manifest");
+	return manifest.contract.pluginId === id ? manifest : refusal(id, "manifest", `manifest.js states the plugin ${manifest.contract.pluginId}`);
+}
+/**
+* Returns a release's words in the page's fallback language, or the release's refusal.
+*
+* @remarks
+*   The deployment step wrote the words into the document's deployment after it checked their
+*   integrity. The loader fetches the words only when the document lists the release without them.
+*/
+async function wordsOf(options, listed) {
+	const { base, release, words } = listed;
+	if (words !== void 0) return { words };
+	try {
+		return { words: await wordsAt(options.fetching, base, release, options.catalogues.fallback) };
+	} catch (error) {
+		return { refused: refusal(release.id, "catalogue", messageOf(error)) };
+	}
+}
+/**
+* Loads one release, and returns it or its refusal.
+*
+* @remarks
+*   The words and the manifest load in parallel. A release whose words and manifest both fail is
+*   refused for its words.
+*/
+async function loadedOf(options, listed) {
+	const { base, release } = listed;
+	const refused = checked(options, listed);
+	if (refused !== void 0) return refused;
+	const [read, manifest] = await Promise.all([wordsOf(options, listed), manifestOf(options, listed)]);
+	if ("refused" in read) return read.refused;
+	return "kind" in manifest ? manifest : {
+		base,
+		installed: {
+			...listed.options,
+			manifest
+		},
+		release,
+		words: read.words
+	};
+}
+/**
+* Loads the releases a deployment lists, after checking each against the packages the page
+* provides.
+*
+* @param options - The page's catalogues, the deployment, and how to fetch and to import.
+* @returns The loaded releases and the refused ones, each in the deployment's order.
+*/
+async function loadReleases(options) {
+	const outcomes = await Promise.all(options.deployment.releases.map((listed) => loadedOf(options, listed)));
+	return {
+		loaded: outcomes.flatMap((outcome) => "kind" in outcome ? [] : [outcome]),
+		refused: outcomes.flatMap((outcome) => "kind" in outcome ? [outcome] : [])
+	};
+}
+//#endregion
+//#region src/releases/preload.ts
+/**
+* Writes the preloads of a release's module into a page's document when the release imports the
+* module.
+*/
+/**
+* Returns the listed release whose directory contains a URL, or undefined. Where two bases nest,
+* the function returns the release with the longer base.
+*/
+function listedAt(deployment, url) {
+	return deployment.releases.filter(({ base }) => url.startsWith(base)).toSorted((one, two) => two.base.length - one.base.length)[0];
+}
+/**
+* Returns a `link` element that preloads a module. The element has an `integrity` attribute when
+* the module belongs to a release.
+*/
+function linkOf(target, href, integrity) {
+	const link = target.createElement("link");
+	link.setAttribute("rel", "modulepreload");
+	link.setAttribute("crossorigin", "");
+	link.setAttribute("href", href);
+	if (integrity !== void 0) link.setAttribute("integrity", integrity);
+	return link;
+}
+/**
+* Returns the preloader of a page. For a module of a listed release, the preloader appends a module
+* preload for each module that `preloadsOf` returns. It appends each URL once.
+*
+* @remarks
+*   The preloader does not append a preload for a module that the document already preloads.
+* @param target - The page's document.
+* @param deployment - The deployment that the document states.
+*/
+function preloaderOf(target, deployment) {
+	const written = new Set([...target.querySelectorAll("link[rel=\"modulepreload\"]")].map(({ href }) => href));
+	return (url) => {
+		const listed = listedAt(deployment, url);
+		const preloads = listed === void 0 ? [] : preloadsOf(deployment, listed, url.slice(listed.base.length));
+		for (const { href, integrity } of preloads) {
+			const absolute = new URL(href, target.baseURI).href;
+			if (!written.has(absolute)) {
+				written.add(absolute);
+				target.head.append(linkOf(target, absolute, integrity));
+			}
+		}
+	};
+}
+//#endregion
+//#region src/releases/resolve.ts
+/**
+* Returns a web package for each plugin of a definition. The resolver reads only that a plugin has
+* one.
+*/
+function packagesOf(definition) {
+	return Object.fromEntries(definition.plugins.map(({ manifest }) => {
+		const { pluginId } = manifest.contract;
+		return [pluginId, {
+			directory: ".",
+			name: pluginId
+		}];
+	}));
+}
+/**
+* Returns the definition's resolution with the plugins of releases after its own.
+*/
+function resolutionWith(options, releases) {
+	const { catalogues, definition } = options;
+	const plugins = [...definition.plugins, ...releases.map(({ installed }) => installed)];
+	const words = Object.fromEntries(releases.map(({ release, words: own }) => [release.id, own]));
+	const extended = {
+		...definition,
+		plugins
+	};
+	return resolveProduct(extended, packagesOf(extended), { catalogues: {
+		...catalogues.defaults,
+		...words
+	} });
+}
+/**
+* Returns the product with the admitted releases' plugins, or the build's product where the page
+* admitted none.
+*/
+function productOf(options, admitted, resolved) {
+	const { deployment, product } = options;
+	if (resolved === void 0) return {
+		...product,
+		deployment
+	};
+	const manifests = admitted.map(({ installed }) => [installed.manifest.contract.pluginId, installed.manifest]);
+	return {
+		...resolved,
+		code: product.code,
+		deployment,
+		manifests: {
+			...product.manifests,
+			...Object.fromEntries(manifests)
+		}
+	};
+}
+/**
+* Resolves a product with the releases its page loaded, one release at a time.
+*
+* @param options - The definition, the build's product, the loaded releases, the page's catalogues
+*   and the deployment's id.
+* @returns The product with every admitted release, and each release the resolution refused.
+*/
+function withReleases(options) {
+	const admitted = [];
+	const refused = [];
+	let resolved;
+	for (const loaded of options.loaded) {
+		const { problems, product } = resolutionWith(options, [...admitted, loaded]);
+		if (product === void 0) {
+			const detail = problems.map((problem) => lineOf(problem)).join("; ");
+			refused.push(refusal(loaded.release.id, "resolution", detail));
+		} else {
+			admitted.push(loaded);
+			resolved = product;
+		}
+	}
+	return {
+		admitted,
+		product: productOf(options, admitted, resolved),
+		refused
+	};
+}
+//#endregion
+//#region src/releases/deployed.ts
+/**
+* Fetches a URL with the page's `fetch`.
+*/
+const FETCHING = (url, init) => fetch(url, init);
+/**
+* Imports a module by its absolute URL, which the bundler leaves as written.
+*/
+const IMPORTING = (url) => import(
+	/* @vite-ignore */
+	url
+);
+/**
+* Loads the releases in a page's document and resolves the product with them.
+*
+* @remarks
+*   A document without a deployment renders the build's product. Where the page cannot read the
+*   deployment, the page refuses every release with the reason `deployment`, and the build's
+*   product renders with an empty list of releases. The product's `releases` contains the id of
+*   every release in the document, so the page's first render withholds the same plugins as the
+*   server's render. After the function reads a deployment, it registers the preloader of the
+*   document. The preloader writes the preloads of a release's module when the release imports that
+*   module.
+* @param options - The page's document and catalogues, the definition, the build's product, and how
+*   to fetch and to import.
+* @returns The catalogues and the product to render, and each release the page refused.
+*/
+async function deployedProduct(options) {
+	const { catalogues, definition, fetching = FETCHING, importing = IMPORTING, product } = options;
+	const read = deploymentOf(options.document);
+	if (read.kind === "none") return {
+		catalogues,
+		product,
+		refused: []
+	};
+	if (read.kind === "malformed") {
+		const detail = read.faults.join("; ");
+		return {
+			catalogues,
+			product: {
+				...product,
+				releases: []
+			},
+			refused: [{
+				detail,
+				kind: "plugin-refused",
+				reason: "deployment"
+			}]
+		};
+	}
+	const { deployment } = read;
+	registerPreloader(preloaderOf(options.document, deployment));
+	const { loaded, refused } = await loadReleases({
+		catalogues,
+		deployment,
+		fetching,
+		importing
+	});
+	const released = withReleases({
+		catalogues,
+		definition,
+		deployment: deployment.id,
+		loaded,
+		product
+	});
+	return {
+		catalogues: cataloguesWith(catalogues, released.admitted, fetching),
+		product: {
+			...released.product,
+			releases: deployment.releases.map(({ release }) => release.id)
+		},
+		refused: [...refused, ...released.refused]
+	};
+}
+//#endregion
+//#region src/app/render-deployed.ts
+/**
+* Loads the releases the document's deployment lists, and renders the product resolved with them
+* once the host is ready.
+*
+* @remarks
+*   The host reports each release the page refused. A document without a deployment renders the
+*   build's product.
+* @param options - The definition, and what `renderProduct` renders with.
+* @returns The React root the product renders in, which `unmount` takes down.
+*/
+async function renderDeployed({ catalogues = NONE, definition, product, ...options }) {
+	const deployed = await deployedProduct({
+		catalogues,
+		definition,
+		document,
+		product
+	});
+	return renderProduct({
+		...options,
+		...deployed
+	});
+}
+//#endregion
+export { deployedProduct, renderDeployed };

package/dist/render-CEa8Jhmo.js

@@ -0,0 +1,238 @@
+import { c as HostProvider, f as onCaughtError, l as HostNotFound, p as createHost, r as listedRoutesOf, t as createHostRoutes } from "./create-routes-D4iCBYZe.js";
+import { n as useSections, t as ProductFrame } from "./frame-HZM1zS7g.js";
+import { NOBODY, constantSession, hostContract } from "@stealthscale/sdk-core";
+import { conditionContextOf } from "@stealthscale/sdk-plugin";
+import { localStore } from "@stealthscale/settings";
+import { Navigate, RouterProvider, createAppRootRoute, createRoute, createRouter, notFound, redirect, routeHref, routeMap, routerOptions } from "@stealthscale/provider-router";
+import { c } from "react/compiler-runtime";
+import { jsx } from "react/jsx-runtime";
+import { CheckIcon, ChevronDownIcon, CircleAlertIcon, MinusIcon, PlusIcon } from "lucide-react";
+import { createRoot } from "react-dom/client";
+import { Shell } from "@stealthscale/provider-shell";
+//#region src/app/glyphs.tsx
+/**
+* Lists the glyphs the settings sections' forms render where a product states none.
+*/
+/**
+* The marks of the settings forms: a check in a checked box and beside a picked option, a select's
+* chevron, a number field's steppers, and the mark before an error.
+*/
+const GLYPHS = {
+	checkbox: /* @__PURE__ */ jsx(CheckIcon, {}),
+	error: /* @__PURE__ */ jsx(CircleAlertIcon, {}),
+	number: {
+		decrement: /* @__PURE__ */ jsx(MinusIcon, {}),
+		increment: /* @__PURE__ */ jsx(PlusIcon, {})
+	},
+	select: {
+		indicator: /* @__PURE__ */ jsx(ChevronDownIcon, {}),
+		selected: /* @__PURE__ */ jsx(CheckIcon, {})
+	}
+};
+//#endregion
+//#region src/app/site-root.tsx
+/**
+* Opens the first section the main menu lists, in place of the site root.
+*
+* @remarks
+*   The router's `beforeLoad` has already sent a person with no section to the sign-in page or to
+*   the not-found page. The component reads the sections in the main menu's own order, which sorts
+*   entries without a rank by their text in the person's language, so the site root opens the
+*   section the main menu lists first. The navigation replaces the site root in the history, so
+*   Back does not return to it.
+* @returns The router's navigation to the section, or nothing while the main menu lists none.
+*/
+function SiteRoot() {
+	const $ = c(2);
+	const [first] = useSections().sections;
+	let t0;
+	if ($[0] !== first) {
+		t0 = first === void 0 ? null : /* @__PURE__ */ jsx(Navigate, {
+			replace: true,
+			to: first.href
+		});
+		$[0] = first;
+		$[1] = t0;
+	} else t0 = $[1];
+	return t0;
+}
+//#endregion
+//#region src/app/tree.ts
+/**
+* Returns true where the main menu lists a page the person may open.
+*
+* @param product - The product's routes.
+* @param stores - The stores a route's condition reads.
+*/
+function hasSection(product, stores) {
+	return listedRoutesOf(product.routes, stores).some(({ navigation }) => {
+		return navigation?.menu === hostContract.menus.main.id;
+	});
+}
+/**
+* Returns true where a plugin declares a route at the site root, which then takes the place of the
+* host's.
+*/
+function rootedAtSite(product) {
+	return product.routes.some(({ parent, path }) => {
+		return parent === void 0 && (path === "/" || path === "");
+	});
+}
+/**
+* Returns a product's route tree.
+*
+* @remarks
+*   The site root opens the first section the person may open. Without one, it sends a person who
+*   is not signed in to the product's sign-in route, with the site root as the `redirect` search,
+*   and renders the not-found page otherwise. A plugin's route at `/` takes the site root's place.
+*   Every route renders the host's not-found page in the frame where its condition stops it.
+* @param product - The product, whose routes the host compiles.
+* @param frame - The component of the root route. The host's frame where left out.
+* @param shell - The document around the frame. The frame renders alone where left out.
+*/
+function productTreeOf(product, frame = ProductFrame, shell) {
+	const root = createAppRootRoute()({
+		component: frame,
+		notFoundComponent: HostNotFound,
+		...shell === void 0 ? {} : { shellComponent: shell }
+	});
+	const site = createRoute({
+		beforeLoad: ({ context, location }) => {
+			const { host, routes } = context;
+			if (hasSection(product, host.stores)) return;
+			if (product.signIn !== void 0 && !conditionContextOf(host.stores).authenticated) throw redirect({
+				replace: true,
+				search: { redirect: location.href },
+				to: routeHref(routes, product.signIn)
+			});
+			throw notFound();
+		},
+		component: SiteRoot,
+		getParentRoute: () => root,
+		path: "/"
+	});
+	const routes = createHostRoutes(product)(root);
+	return root.addChildren(rootedAtSite(product) ? routes : [site, ...routes]);
+}
+//#endregion
+//#region src/app/router.ts
+/**
+* Returns a product's router: the frame at the root, the site root, and the plugins' routes, with
+* the host and its data client in the router's context.
+*
+* @param host - The host the router's context contains.
+* @param product - The product, whose routes the host compiles.
+* @param options - The base path, the frame, the history and the document around the frame.
+*/
+function createProductRouter(host, product, options = {}) {
+	const tree = productTreeOf(product, options.frame, options.shell);
+	const { basepath, history } = options;
+	return createRouter({
+		...routerOptions({
+			data: host.data,
+			host,
+			routes: routeMap(tree)
+		}),
+		...basepath === void 0 ? {} : { basepath },
+		...history === void 0 ? {} : { history },
+		routeTree: tree
+	});
+}
+//#endregion
+//#region src/app/sources.ts
+/**
+* Returns the sources the product's definition names, or none where it names no module.
+*
+* @param product - The product, with the definition's importers.
+*/
+function sourcesOf(product) {
+	const importer = product.code?.sources;
+	return importer === void 0 ? Promise.resolve({}) : importer();
+}
+/**
+* Returns the product's own frame, or undefined where the product renders the host's.
+*
+* @param product - The product, with the definition's importers.
+* @throws {@link Error} Where the frame's module exports another number of functions than one.
+*/
+async function frameOf(product) {
+	const importer = product.code?.frame;
+	if (importer === void 0) return void 0;
+	const functions = Object.values(await importer()).filter((value) => typeof value === "function");
+	if (functions.length !== 1) throw new Error(`The module of the product's frame exports ${String(functions.length)} functions, and a frame's module exports one.`);
+	return functions[0];
+}
+//#endregion
+//#region src/app/hosted.ts
+/**
+* Returns the host over the product's sources, and the router over the host.
+*
+* @remarks
+*   Without the sources' session the session is constant and nobody is signed in, and without their
+*   store the host keeps choices in the page's local storage. The router's root renders the
+*   product's own frame where the definition names one.
+* @param product - The product, with the definition's importers.
+* @param options - The base path, the glyphs and the refused releases.
+*/
+async function hostedOf(product, options) {
+	const sources = await sourcesOf(product);
+	const store = sources.store ?? localStore();
+	const host = createHost({
+		...sources,
+		glyphs: options.glyphs ?? GLYPHS,
+		product,
+		refused: options.refused,
+		session: sources.session ?? constantSession(NOBODY),
+		store
+	});
+	return {
+		host,
+		router: createProductRouter(host, product, {
+			basepath: options.basepath,
+			frame: await frameOf(product)
+		}),
+		store
+	};
+}
+//#endregion
+//#region src/app/render.tsx
+/**
+* Renders a product into the page from its definition, for the entry a product's build generates.
+*/
+/**
+* Renders the product once the host is ready: the shell over the product's locales, themes and
+* store, the host, and the router with the frame at its root.
+*
+* @remarks
+*   The root takes the host's `onCaughtError`, so a page that throws the router's not-found writes
+*   nothing to the console.
+* @param options - The product, the catalogues, the themes, the glyphs, the refused releases, the
+*   base path and the element.
+* @returns The React root the product renders in, which `unmount` takes down.
+* @throws {@link Error} Where no element is given and the document has none with the id `root`.
+*/
+async function renderProduct({ basepath, catalogues, element = document.querySelector("#root"), glyphs, product, refused, themes }) {
+	if (element === null) throw new Error("A product renders into the element with the id root, and the document has none.");
+	const { host, router, store } = await hostedOf(product, {
+		basepath,
+		glyphs,
+		refused
+	});
+	await host.ready();
+	const root = createRoot(element, { onCaughtError });
+	root.render(/* @__PURE__ */ jsx(Shell, {
+		app: product.productId,
+		catalogues,
+		locales: product.locales,
+		store,
+		themes,
+		children: /* @__PURE__ */ jsx(HostProvider, {
+			host,
+			router,
+			children: /* @__PURE__ */ jsx(RouterProvider, { router })
+		})
+	}));
+	return root;
+}
+//#endregion
+export { createProductRouter as n, GLYPHS as r, renderProduct as t };

package/dist/render-DRndY-TD.d.ts

@@ -0,0 +1,54 @@
+import { Product } from "@stealthscale/sdk-core";
+import { PluginRefused } from "@stealthscale/sdk-plugin";
+import { Catalogues } from "@stealthscale/provider-i18n";
+import { FormGlyphs } from "@stealthscale/component-forms/form";
+import { Root } from "react-dom/client";
+//#region src/app/render.d.ts
+/**
+ * Lists what a product renders with.
+ */
+interface ProductRenderOptions {
+  /**
+   * The base the product is served at, such as `/docs/`. The site's root where left out.
+   */
+  readonly basepath?: string | undefined;
+  /**
+   * The catalogues, from `virtual:i18n`. Every key renders as itself where left out.
+   */
+  readonly catalogues?: Catalogues | undefined;
+  /**
+   * The element the product renders into. The element with the id `root` where left out.
+   */
+  readonly element?: Element | null | undefined;
+  /**
+   * Glyphs the settings sections' forms render. Lucide's where left out.
+   */
+  readonly glyphs?: FormGlyphs | undefined;
+  /**
+   * The product, from `virtual:product`.
+   */
+  readonly product: Product;
+  /**
+   * Releases the page did not load, which the host reports as it is created.
+   */
+  readonly refused?: readonly PluginRefused[] | undefined;
+  /**
+   * The themes the product offers, the first applied until a person picks another.
+   */
+  readonly themes?: readonly string[] | undefined;
+}
+/**
+ * Renders the product once the host is ready: the shell over the product's locales, themes and
+ * store, the host, and the router with the frame at its root.
+ *
+ * @remarks
+ *   The root takes the host's `onCaughtError`, so a page that throws the router's not-found writes
+ *   nothing to the console.
+ * @param options - The product, the catalogues, the themes, the glyphs, the refused releases, the
+ *   base path and the element.
+ * @returns The React root the product renders in, which `unmount` takes down.
+ * @throws {@link Error} Where no element is given and the document has none with the id `root`.
+ */
+declare function renderProduct({ basepath, catalogues, element, glyphs, product, refused, themes }: ProductRenderOptions): Promise<Root>;
+//#endregion
+export { renderProduct as n, ProductRenderOptions as t };