@stealthscale/vite-plugin-product 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -1,12 +1,246 @@
-import { dirname, join, posix, relative, resolve, sep } from "node:path";
-import { normalizePath } from "vite";
-import { lineOf, resolveProduct } from "@stealthscale/sdk-core";
-import { dependencies, importer, literal, manifestAt, owning, quoted, text } from "@stealthscale/vite-plugin-base";
+import { createRequire } from "node:module";
+import { build, normalizePath, parseSync } from "vite";
+import { PROVIDED_FILE, RELEASE_FILE, lineOf, releaseProblems, resolveProduct } from "@stealthscale/sdk-core";
+import { dependencies, exportTarget, importer, literal, manifestAt, owning, packageAt, quoted, text } from "@stealthscale/vite-plugin-base";
 import { LOCALES, cataloguesOf } from "@stealthscale/vite-plugin-i18n";
+import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { validateHotkey } from "@tanstack/hotkeys";
 import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+//#region src/page.ts
+/**
+* Writes the document and the entry of a page the plugin serves at `index.html`: a product's page
+* or a plugin's standalone page.
+*/
+/**
+* The page's document, from the project root.
+*/
+const DOCUMENT = "index.html";
+/**
+* The language of a document whose page states none.
+*/
+const LANGUAGE = "en-US";
+/**
+* Returns the path of the page's document for a specifier that names it, and undefined for any
+* other specifier.
+*
+* @param root - The project root.
+* @param id - The specifier: `index.html`, `/index.html` or the document's path name the document.
+*/
+function documentIdOf(root, id) {
+	const document = normalizePath(join(root, DOCUMENT));
+	return id === DOCUMENT || id === `/${DOCUMENT}` || id === document ? document : void 0;
+}
+/**
+* Returns the specifier of a module by its path from the project root, such as `/src/glyphs.tsx`.
+*/
+function rootedOf(path) {
+	return posix.join("/", normalizePath(path));
+}
+/**
+* Returns the source of a page's document: its language and title, an element with the id `root`,
+* and the entry.
+*/
+function documentSource({ entry, language, title }) {
+	return [
+		"<!doctype html>",
+		`<html lang=${quoted(language)}>`,
+		"  <head>",
+		"    <meta charset=\"utf-8\" />",
+		"    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />",
+		`    <title>${title}</title>`,
+		"  </head>",
+		"  <body>",
+		"    <div id=\"root\"></div>",
+		`    <script type="module" src="/@id/${entry}"><\/script>`,
+		"  </body>",
+		"</html>",
+		""
+	].join("\n");
+}
+/**
+* Returns the source of a page's entry: the stylesheet and the static imports, every other module
+* through `import()`, and a call of the render function with the members.
+*
+* @remarks
+*   The entry imports the stylesheet and modules without components statically, and the page's
+*   other modules through `import()`. The bundled dev server installs the React refresh runtime in
+*   the entry's own body, and a chunk the entry imports statically runs before that body, so a
+*   component in a chunk the bundler shares between the entry and a lazy module would run before
+*   the runtime and throw. Behind `import()`, every component runs after it. A module the entry
+*   alone imports statically builds into the entry's chunk, so it adds no chunk of its own. The
+*   entry awaits nothing at its top level, because a module with a top-level await makes the
+*   bundler move every module it shares with a lazy module into a chunk of its own.
+* @param render - The name of the render function, which the first module exports.
+* @param modules - The modules the entry imports through `import()`, the render function's first.
+* @param members - The members of the object the render function receives.
+* @param statics - The modules without components the entry imports statically.
+*/
+function entrySource(render, modules, members, statics = []) {
+	return [
+		"import \"@stealthscale/theme/styles.css\";",
+		...statics.map(({ from, names }) => `import ${names} from ${quoted(from)};`),
+		"",
+		"async function start() {",
+		`  const [${modules.map(({ names }) => names).join(", ")}] = await Promise.all([`,
+		...modules.map(({ from }) => `    import(${quoted(from)}),`),
+		"  ]);",
+		"",
+		`  await ${render}({ ${members.join(", ")} });`,
+		"}",
+		"",
+		"void start();",
+		""
+	].join("\n");
+}
+//#endregion
+//#region src/app.ts
+/**
+* The specifier of the page's entry.
+*/
+const ENTRY$1 = "virtual:product-app";
+/**
+* The resolved id of the page's entry, behind the NUL that marks it as generated.
+*/
+const RESOLVED_ENTRY$1 = `\0${ENTRY$1}`;
+/**
+* The document's title while no product resolved.
+*/
+const UNTITLED = "Product";
+/**
+* The address a dev server's fallback rewrites every address without a file to.
+*/
+const INDEX = "/index.html";
+/**
+* Returns the router's base path for the build's base: the base where it is a path other than the
+* site's root, and undefined for any other base.
+*
+* @remarks
+*   A relative base and a URL state where the files are served from, and the address of the page
+*   is unknown to the build, so they give no base path.
+*/
+function basepathOf(base) {
+	return base.startsWith("/") && base !== "/" ? base : void 0;
+}
+/**
+* Returns the source of the page's document, in the product's first locale and titled with its id.
+*
+* @remarks
+*   `HostProvider` replaces the title with the product's name once the product renders.
+*/
+function documentOf$1(build) {
+	return documentSource({
+		entry: ENTRY$1,
+		language: build.product?.locales?.[0] ?? "en-US",
+		title: build.product?.productId ?? UNTITLED
+	});
+}
+/**
+* Returns the source of the page's entry, which renders the product with `renderProduct` over
+* `virtual:product`, `virtual:i18n` and `virtual:stealth-themes`.
+*
+* @remarks
+*   The entry imports `virtual:stealth-themes` statically. The module is a list of names and
+*   renders nothing, and a module behind `import()` would build into a chunk of its own. A page
+*   that loads releases renders with `renderDeployed` from `@stealthscale/sdk-host/releases` and
+*   passes the definition, so the loader and the resolver build into no other product's page.
+*/
+function entryOf$2(page, build) {
+	const basepath = basepathOf(build.base);
+	const { glyphs, runtime = false } = page;
+	const render = runtime ? "renderDeployed" : "renderProduct";
+	return entrySource(render, [
+		{
+			from: runtime ? "@stealthscale/sdk-host/releases" : "@stealthscale/sdk-host/app",
+			names: `{ ${render} }`
+		},
+		{
+			from: "virtual:i18n",
+			names: "{ catalogues }"
+		},
+		{
+			from: "virtual:product",
+			names: runtime ? "{ definition, product }" : "{ product }"
+		},
+		...glyphs === void 0 ? [] : [{
+			from: rootedOf(glyphs),
+			names: "{ glyphs }"
+		}]
+	], [
+		...basepath === void 0 ? [] : [`basepath: ${quoted(basepath)}`],
+		"catalogues",
+		...runtime ? ["definition"] : [],
+		...glyphs === void 0 ? [] : ["glyphs"],
+		"product",
+		"themes"
+	], [{
+		from: "virtual:stealth-themes",
+		names: "{ themes }"
+	}]);
+}
+/**
+* Returns the id the page's document or its entry resolves to, and undefined for any other
+* specifier.
+*
+* @param root - The project root.
+* @param id - The specifier.
+*/
+function appIdOf(root, id) {
+	if (id === ENTRY$1 || id === `/@id/${ENTRY$1}`) return RESOLVED_ENTRY$1;
+	return documentIdOf(root, id);
+}
+/**
+* Returns the source of the page's document or its entry, and undefined for any other id.
+*
+* @param root - The project root.
+* @param page - The page's glyphs, and whether the page loads releases at run time.
+* @param build - The build's base and the resolved product.
+* @param id - The resolved id.
+*/
+function appSourceOf(root, page, build, id) {
+	if (id === RESOLVED_ENTRY$1) return entryOf$2(page, build);
+	return documentIdOf(root, id) === void 0 ? void 0 : documentOf$1(build);
+}
+/**
+* Returns the hook that adds the middleware serving the page's document, and undefined under a
+* server that bundles, whose bundle contains the document.
+*
+* @remarks
+*   A server that serves one module per file reads `index.html` from disk and finds none. Vite runs
+*   the middleware after its fallback has rewritten every address without a file to `/index.html`,
+*   and before its own document middleware. The middleware reads the build when a page asks, so it
+*   serves the product's latest locale and id.
+* @param server - The dev server.
+* @param build - The build's base and the resolved product.
+*/
+function documentHookOf(server, build) {
+	/**
+	* Sends the page's document after every plugin's transforms of a document, and passes a failed
+	* transform to the next middleware.
+	*/
+	const sent = async (request, response, next) => {
+		try {
+			const html = await server.transformIndexHtml(INDEX, documentOf$1(build), request.originalUrl);
+			response.setHeader("Content-Type", "text/html");
+			response.end(html);
+		} catch (error) {
+			next(error);
+		}
+	};
+	return server.config.experimental.bundledDev === true ? void 0 : () => {
+		server.middlewares.use((request, response, next) => {
+			if (request.url === INDEX) sent(request, response, next);
+			else next();
+		});
+	};
+}
+//#endregion
 //#region src/catalogues.ts
 /**
+* Directory of the build's output the catalogues are written to.
+*/
+const CATALOGUES = ".product";
+/**
 * Returns true where a value is an object whose members can be read by name.
 */
 function isRecord$1(value) {
@@ -129,47 +363,238 @@ function cataloguesFor(product, api) {
 		}
 	};
 }
+/**
+* Returns the catalogue files of a client build, and none under a dev server or for another
+* environment.
+*
+* @param state - The command, the resolved product and the catalogue plugin's api.
+* @param consumer - The consumer of the environment whose bundle is written.
+* @throws {@link Error} When a catalogue cannot be read for a description.
+*/
+function catalogueFiles(state, consumer) {
+	const { command, product, words } = state;
+	if (consumer !== "client" || command !== "build" || product === void 0 || words === void 0) return [];
+	return Object.entries(cataloguesFor(product, words)).map(([name, catalogue]) => ({
+		fileName: `${CATALOGUES}/${name}.json`,
+		source: `${JSON.stringify(catalogue, null, 2)}\n`,
+		type: "asset"
+	}));
+}
+//#endregion
+//#region src/module.ts
+/**
+* The specifier an application imports the product from.
+*/
+const ID = "virtual:product";
+/**
+* The resolved id of the module, behind the NUL that marks it as generated.
+*/
+const RESOLVED = `\0${ID}`;
+/**
+* Returns the source of `virtual:product`.
+*
+* @remarks
+*   The module imports the definition. The page receives each manifest from it, keyed by plugin id,
+*   with its lazy importers and its contract's search validators, and the definition's importers of
+*   its own frame and of its sources as `code`. Every member the build resolved is a literal in the
+*   module. The module exports the definition as well, which a page that loads releases resolves
+*   again with the releases' plugins.
+* @param definition - The definition module's path from the project root, such as
+*   `/src/product.ts`.
+* @param product - The resolved product.
+* @throws {@link Error} When a member of the product cannot be written as source, naming its path.
+*/
+function moduleOf(definition, product) {
+	return [
+		`import definition from ${quoted(definition)};`,
+		"",
+		`const resolved = ${literal(product, "product")};`,
+		"",
+		"export const product = {",
+		"  ...resolved,",
+		"  code: {",
+		"    frame: typeof definition.frame === \"function\" ? definition.frame : undefined,",
+		"    sources: definition.sources,",
+		"  },",
+		"  manifests: Object.fromEntries(",
+		"    definition.plugins.map(({ manifest }) => [manifest.contract.pluginId, manifest]),",
+		"  ),",
+		"};",
+		"",
+		"export { definition };",
+		""
+	].join("\n");
+}
 //#endregion
 //#region src/chunks.ts
 /**
-* Names the chunk each lazy module of an installed plugin's web package builds into: one chunk per
-* plugin, which every page, extension, command and settings section of the plugin shares.
+* Names the chunk each module of a product builds into: one chunk per plugin, which every page,
+* extension, command and settings section of the plugin shares, and under a build one chunk for the
+* other modules outside the application that the startup or a plugin imports statically.
 *
 * @remarks
 *   The product imports each web package's main entry statically, through its definition. The main
 *   entry and every module it imports statically build into the chunks the entry loads, because in
-*   the plugin's chunk they would make the first load fetch the whole plugin.
+*   the plugin's chunk they would make the first load fetch the whole plugin. Groups that place a
+*   module by its path alone make rolldown 1.2 build a module the groups leave into the chunk of a
+*   lazy module that imports it, and export it from there to the chunks that need it. `import()` of
+*   that lazy module then resolves to a namespace with the other module's exports as well. A module
+*   outside every web package that one plugin's lazy modules alone import goes into the plugin's
+*   chunk. Every other module outside the application that the startup or a plugin's modules import
+*   statically goes into the `dependencies` chunk, so a lazy module's chunk contains the lazy
+*   module alone. A module that only another `import()` loads, such as a page the application
+*   loads on demand, keeps its own chunk, so it does not load with the startup.
 */
 /**
-* Returns true where an entry of the build imports a module statically, directly or through other
-* modules.
-*
-* @remarks
-*   The walk follows each module's static importers back towards the entries. A dynamic import
-*   ends the walk, because a module behind one loads after the entry.
+* Name of the chunk that a module outside the application builds into where the startup or a
+* plugin imports it statically and the other groups leave it.
 */
-function initial(id, chunking) {
+const DEPENDENCIES = "dependencies";
+/**
+* Priority of the plugin chunks' group: above the shared chunk's 3, below the vendor chunk's 5.
+*/
+const PRIORITY = 4;
+/**
+* Priority of the dependencies' group: below every other group's, so it claims only the modules
+* they leave.
+*/
+const LAST = 1;
+/**
+* Matches a path that starts with or contains a `node_modules` directory.
+*/
+const INSTALLED = /(?:^|[\\/])node_modules[\\/]/u;
+/**
+* Returns the id of the plugin whose web package contains a module, or undefined for a module
+* outside every web package.
+*/
+function ownerOf(id, packages) {
+	return Object.entries(packages).find(([, { directory }]) => id.startsWith(`${directory}${sep}`))?.[0];
+}
+/**
+* Returns true where the walk over a module's static importers meets a module the test accepts,
+* the module itself included.
+*/
+function leadsTo(id, chunking, ends) {
 	const seen = /* @__PURE__ */ new Set();
 	const queue = [id];
 	for (let next = queue.shift(); next !== void 0; next = queue.shift()) {
 		const info = seen.has(next) ? null : chunking.getModuleInfo(next);
 		seen.add(next);
-		if (info?.isEntry === true) return true;
+		if (ends(next, info)) return true;
 		queue.push(...info?.importers ?? []);
 	}
 	return false;
 }
 /**
+* Returns true for an entry of the build and for `virtual:product`.
+*/
+function startup(id, info) {
+	return id === RESOLVED || info?.isEntry === true;
+}
+/**
+* Returns true where an entry of the build or `virtual:product` imports a module statically,
+* directly or through other modules.
+*
+* @remarks
+*   The walk follows each module's static importers back towards the entries, and ends at
+*   `virtual:product`, because every module the product imports statically loads with it. The
+*   standalone page's entry imports the product through `import()`, so no entry imports the
+*   definition statically there. A dynamic import ends the walk elsewhere, because a module behind
+*   one loads after the entry.
+*/
+function initial(id, chunking) {
+	return leadsTo(id, chunking, startup);
+}
+/**
+* Returns the one plugin whose web package's modules import a module outside every web package,
+* directly or through other modules.
+*
+* @remarks
+*   Returns undefined where an entry or `virtual:product` imports the module statically, where the
+*   walk meets a module outside every web package that no module imports statically, such as a lazy
+*   page of the application, or a module the build does not know, and where the modules of two
+*   plugins import it.
+*/
+function soleOwnerOf(id, chunking, packages) {
+	const owners = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set([id]);
+	const queue = [id];
+	for (let next = queue.shift(); next !== void 0; next = queue.shift()) {
+		const info = chunking.getModuleInfo(next);
+		const owner = ownerOf(next, packages);
+		if (next === RESOLVED || info === null || info.isEntry) return void 0;
+		if (owner === void 0 && info.importers.length === 0) return void 0;
+		if (owner !== void 0) owners.add(owner);
+		for (const importer of info.importers.filter((one) => !seen.has(one))) {
+			seen.add(importer);
+			queue.push(importer);
+		}
+	}
+	const [sole] = owners;
+	return owners.size === 1 ? sole : void 0;
+}
+/**
 * Returns the chunk a module builds into: `plugin-<id>` for a module of an installed plugin's web
-* package that no entry imports statically, and null for every other module.
+* package that no entry imports statically, and for a module outside every web package that only
+* that plugin's lazy modules import, and null for every other module.
 *
 * @param id - The module's id, its absolute path.
 * @param chunking - The context rolldown passes a group's name function.
 * @param packages - Each installed plugin's web package, by plugin id.
 */
 function pluginChunkOf(id, chunking, packages) {
-	const owner = Object.entries(packages).find(([, { directory }]) => id.startsWith(`${directory}${sep}`));
-	return owner === void 0 || initial(id, chunking) ? null : `plugin-${owner[0]}`;
+	const owner = ownerOf(id, packages);
+	if (owner !== void 0) return initial(id, chunking) ? null : `plugin-${owner}`;
+	const sole = soleOwnerOf(id, chunking, packages);
+	return sole === void 0 ? null : `plugin-${sole}`;
+}
+/**
+* Returns the chunk a module builds into where the groups with a higher priority leave it:
+* `dependencies` for a module outside the application that the startup or a plugin's modules import
+* statically, and null for every other module.
+*
+* @remarks
+*   A module of the application is a file under the project root and outside its `node_modules`. A
+*   virtual module's id is not an absolute path. The walk over the module's static importers ends
+*   at an entry, at `virtual:product` and at a module of an installed plugin's web package. A
+*   module it does not meet is one that only another `import()` loads, such as a page the
+*   application loads on demand, which keeps its own chunk.
+* @param id - The module's id, its absolute path for a file.
+* @param chunking - The context rolldown passes a group's name function.
+* @param root - The project root.
+* @param packages - Each installed plugin's web package, by plugin id.
+*/
+function dependencyChunkOf(id, chunking, root, packages) {
+	if (!isAbsolute(id)) return null;
+	const path = relative(root, id);
+	if (!(path.startsWith(`..${sep}`) || isAbsolute(path)) && !INSTALLED.test(path)) return null;
+	return leadsTo(id, chunking, (next, info) => startup(next, info) || ownerOf(next, packages) !== void 0) ? DEPENDENCIES : null;
+}
+/**
+* Returns the configuration whose groups build each installed plugin's lazy modules into a chunk
+* of its own, and under a build every other module outside the application that the startup or a
+* plugin imports statically into the `dependencies` chunk.
+*
+* @remarks
+*   Both groups read the web packages the composition found, and the dependencies' group reads the
+*   project root. Both are read when the bundler places a module, after the composition. A dev
+*   server takes no dependencies' group: `import()` of a lazy module resolves to the module's own
+*   exports there without it, and `vite-config` leaves out its library and shared groups there too,
+*   whose chunks would run components before the React refresh runtime is installed.
+* @param placing - The web packages and the project root, which each group reads when the bundler
+*   places a module.
+* @param command - The command Vite runs under, `build` or `serve`.
+*/
+function chunked(placing, command) {
+	return { build: { rolldownOptions: { output: { codeSplitting: { groups: [{
+		debugName: "plugins",
+		name: (id, chunking) => pluginChunkOf(id, chunking, placing.packages),
+		priority: PRIORITY
+	}, ...command === "build" ? [{
+		debugName: DEPENDENCIES,
+		name: (id, chunking) => dependencyChunkOf(id, chunking, placing.root, placing.packages),
+		priority: LAST
+	}] : []] } } } } };
 }
 //#endregion
 //#region src/discover.ts
@@ -381,43 +806,6 @@ async function compose(composing) {
 	};
 }
 //#endregion
-//#region src/module.ts
-/**
-* The specifier an application imports the product from.
-*/
-const ID = "virtual:product";
-/**
-* The resolved id of the module, behind the NUL that marks it as generated.
-*/
-const RESOLVED = `\0${ID}`;
-/**
-* Returns the source of `virtual:product`.
-*
-* @remarks
-*   The module imports the definition. The page receives each manifest from it, keyed by plugin id,
-*   with its lazy importers and its contract's search validators. Every member the build resolved
-*   is a literal in the module, and the page runs no check of its own.
-* @param definition - The definition module's path from the project root, such as
-*   `/src/product.ts`.
-* @param product - The resolved product.
-* @throws {@link Error} When a member of the product cannot be written as source, naming its path.
-*/
-function moduleOf(definition, product) {
-	return [
-		`import definition from ${quoted(definition)};`,
-		"",
-		`const resolved = ${literal(product, "product")};`,
-		"",
-		"export const product = {",
-		"  ...resolved,",
-		"  manifests: Object.fromEntries(",
-		"    definition.plugins.map(({ manifest }) => [manifest.contract.pluginId, manifest]),",
-		"  ),",
-		"};",
-		""
-	].join("\n");
-}
-//#endregion
 //#region src/standalone.ts
 /**
 * Writes the standalone page of a plugin: the definition of the product that runs the plugin, the
@@ -434,11 +822,7 @@ const PRODUCT = "virtual:standalone-product";
 /**
 * Path of the manifest module where the page states none.
 */
-const MANIFEST = "src/manifest.ts";
-/**
-* The page's document, from the project root.
-*/
-const DOCUMENT = "index.html";
+const MANIFEST$1 = "src/manifest.ts";
 /**
 * The specifier of the page's entry.
 */
@@ -460,10 +844,6 @@ const SPECIFIED = /* @__PURE__ */ new Map([
 	[PRODUCT, RESOLVED_PRODUCT]
 ]);
 /**
-* The language of the document where the page states no locale.
-*/
-const LANGUAGE = "en-US";
-/**
 * Returns the source of a definition that passes the plugin's manifest module and each contract
 * package beside it to `standaloneFrom`.
 *
@@ -479,7 +859,7 @@ function sourceOf(from, page) {
 		...beside.map((name, index) => `import * as beside${String(index)} from ${quoted(name)};`),
 		"",
 		"export default standaloneFrom(",
-		`  { from: ${quoted(page.manifest ?? MANIFEST)}, module: plugin },`,
+		`  { from: ${quoted(page.manifest ?? MANIFEST$1)}, module: plugin },`,
 		"  [",
 		...beside.map((name, index) => `    { from: ${quoted(name)}, module: beside${String(index)} },`),
 		"  ],",
@@ -497,10 +877,22 @@ function sourceOf(from, page) {
 * @param page - The manifest module and the contract packages beside the plugin.
 */
 function definitionOf(root, page) {
-	const manifest = join(root, page.manifest ?? MANIFEST);
+	const manifest = join(root, page.manifest ?? MANIFEST$1);
 	return sourceOf(normalizePath(relative(dirname(join(root, GENERATED)), manifest)), page);
 }
 /**
+* Returns the specifier `virtual:product` imports the definition by: `virtual:standalone-product`
+* for a definition the plugin generates, and the definition's path from the project root for any
+* other.
+*
+* @param root - The project root.
+* @param definition - The definition's path from the project root.
+* @param generated - Whether the plugin generates the definition of a standalone page.
+*/
+function importedOf(root, definition, generated) {
+	return generated ? PRODUCT : `/${normalizePath(relative(root, resolve(root, definition)))}`;
+}
+/**
 * Writes the generated definition under the project root, and leaves a file with the same source
 * untouched.
 *
@@ -518,38 +910,19 @@ function generate(root, page) {
 	writeFileSync(file, source);
 }
 /**
-* Returns the source of the page's document: an element with the id `root`, and the entry.
+* Returns the source of the page's document, in the language of the page's first locale.
 */
 function documentOf(page) {
 	const [language = LANGUAGE] = page.locales ?? [];
-	return [
-		"<!doctype html>",
-		`<html lang=${quoted(language)}>`,
-		"  <head>",
-		"    <meta charset=\"utf-8\" />",
-		"    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />",
-		"    <title>Standalone page</title>",
-		"  </head>",
-		"  <body>",
-		"    <div id=\"root\"></div>",
-		`    <script type="module" src="/@id/${ENTRY}"><\/script>`,
-		"  </body>",
-		"</html>",
-		""
-	].join("\n");
+	return documentSource({
+		entry: ENTRY,
+		language,
+		title: "Standalone page"
+	});
 }
 /**
 * Returns the source of the page's entry, which renders the page over `virtual:product` and
 * `virtual:i18n`.
-*
-* @remarks
-*   The entry imports the stylesheet alone, and the page's modules through `import()`. The bundled
-*   dev server installs the React refresh runtime in the entry's own body, and a chunk the entry
-*   imports statically runs before that body, so a component in a chunk the bundler shares between
-*   the entry and a lazy module would run before the runtime and throw. Behind `import()`, every
-*   component runs after it. The entry awaits nothing at its top level, because a module with a
-*   top-level await makes the bundler move every module it shares with a lazy module into a chunk
-*   of its own.
 */
 function entryOf(page) {
 	const { glyphs, locales, themes } = page;
@@ -560,26 +933,24 @@ function entryOf(page) {
 		"product",
 		...themes === void 0 ? [] : [`themes: ${literal(themes, "standalone.themes")}`]
 	];
-	const modules = [
-		["{ renderStandalone }", quoted("@stealthscale/sdk-host/standalone/app")],
-		["{ catalogues }", quoted("virtual:i18n")],
-		["{ product }", quoted("virtual:product")],
-		...glyphs === void 0 ? [] : [["{ glyphs }", quoted(posix.join("/", normalizePath(glyphs)))]]
-	];
-	return [
-		"import \"@stealthscale/theme/styles.css\";",
-		"",
-		"async function start() {",
-		`  const [${modules.map(([names]) => names).join(", ")}] = await Promise.all([`,
-		...modules.map(([, from]) => `    import(${String(from)}),`),
-		"  ]);",
-		"",
-		`  await renderStandalone({ ${members.join(", ")} });`,
-		"}",
-		"",
-		"void start();",
-		""
-	].join("\n");
+	return entrySource("renderStandalone", [
+		{
+			from: "@stealthscale/sdk-host/standalone/app",
+			names: "{ renderStandalone }"
+		},
+		{
+			from: "virtual:i18n",
+			names: "{ catalogues }"
+		},
+		{
+			from: "virtual:product",
+			names: "{ product }"
+		},
+		...glyphs === void 0 ? [] : [{
+			from: rootedOf(glyphs),
+			names: "{ glyphs }"
+		}]
+	], members);
 }
 /**
 * Returns the id the page's document, its entry or its definition resolves to, and undefined for
@@ -589,9 +960,7 @@ function entryOf(page) {
 * @param id - The specifier.
 */
 function pageIdOf(root, id) {
-	const document = normalizePath(join(root, DOCUMENT));
-	if (id === DOCUMENT || id === `/${DOCUMENT}` || id === document) return document;
-	return SPECIFIED.get(id);
+	return documentIdOf(root, id) ?? SPECIFIED.get(id);
 }
 /**
 * Returns the source of the page's document, its entry or its definition, and undefined for any
@@ -607,29 +976,26 @@ function pageIdOf(root, id) {
 * @param id - The resolved id.
 */
 function pageSourceOf(root, page, id) {
-	if (id === normalizePath(join(root, DOCUMENT))) return documentOf(page);
+	if (documentIdOf(root, id) !== void 0) return documentOf(page);
 	if (id === RESOLVED_ENTRY) return entryOf(page);
-	return id === RESOLVED_PRODUCT ? sourceOf(posix.join("/", normalizePath(page.manifest ?? MANIFEST)), page) : void 0;
+	return id === RESOLVED_PRODUCT ? sourceOf(rootedOf(page.manifest ?? MANIFEST$1), page) : void 0;
 }
 //#endregion
 //#region src/plugin.ts
 /**
 * The Vite plugin that composes a product from its plugins while the product builds, serves the
 * result as `virtual:product`, and writes the catalogues the product's services read. Under the
-* `standalone` option it serves a plugin's standalone page as well.
+* `app` option it serves the product's page, and under the `standalone` option a plugin's
+* standalone page.
 */
 /**
-* Directory of the build's output the catalogues are written to.
-*/
-const CATALOGUES = ".product";
-/**
 * Path of the definition module where the options state none.
 */
 const DEFINITION = "src/product.ts";
 /**
-* Priority of the plugin chunks' group: above the shared chunk's 3, below the vendor chunk's 5.
+* The message the plugin throws when the options name both pages, which both serve `index.html`.
 */
-const PRIORITY = 4;
+const BOTH = "The product plugin serves one page at index.html, and the options name both app and standalone.";
 /**
 * Returns the message a product that does not resolve fails with: every problem, then the hints.
 */
@@ -686,38 +1052,6 @@ async function closed(state) {
 	await (await through)?.close();
 }
 /**
-* Returns the configuration whose group builds each installed plugin's lazy modules into a chunk
-* of its own.
-*
-* @remarks
-*   The group names a chunk from the web packages the composition found. A build start records
-*   them before the bundler forms its chunks.
-*/
-function chunked(state) {
-	return { build: { rolldownOptions: { output: { codeSplitting: { groups: [{
-		debugName: "plugins",
-		name: (id, chunking) => pluginChunkOf(id, chunking, state.packages),
-		priority: PRIORITY
-	}] } } } } };
-}
-/**
-* Returns the catalogue files of a client build, and none under a dev server or for another
-* environment.
-*
-* @param state - The command, the resolved product and the catalogue plugin's api.
-* @param consumer - The consumer of the environment whose bundle is written.
-* @throws {@link Error} When a catalogue cannot be read for a description.
-*/
-function catalogueFiles(state, consumer) {
-	const { command, product: resolved, words } = state;
-	if (consumer !== "client" || command !== "build" || resolved === void 0 || words === void 0) return [];
-	return Object.entries(cataloguesFor(resolved, words)).map(([name, catalogue]) => ({
-		fileName: `${CATALOGUES}/${name}.json`,
-		source: `${JSON.stringify(catalogue, null, 2)}\n`,
-		type: "asset"
-	}));
-}
-/**
 * Records a composition: its files, its web packages, its problems, and its product where it
 * resolved, so a composition with problems keeps the last product that resolved.
 *
@@ -734,8 +1068,8 @@ function applied(state, composition, warn) {
 	state.failure = problems.length === 0 ? void 0 : failureOf(composition);
 }
 /**
-* Returns what the page receives after a change: a reload where the product resolved, and the
-* problems in the error overlay where it did not.
+* Returns the notice a page receives after a change, which reloads the page where the product
+* resolved and shows the problems in the error overlay where it did not.
 */
 function noticeOf(state) {
 	return state.failure === void 0 ? {
@@ -806,16 +1140,20 @@ function updated(state, context) {
 	return [];
 }
 /**
-* Returns the specifier `virtual:product` imports the definition by: `virtual:standalone-product`
-* for a definition the plugin generates, and the definition's path from the project root for any
-* other.
-*
-* @param state - The project root.
-* @param definition - The definition's path from the project root.
-* @param generated - Whether the plugin generates the definition of a standalone page.
+* Returns the plugin's state before its first hook, with the working directory as the project root
+* until the configuration resolves.
 */
-function importedOf(state, definition, generated) {
-	return generated ? PRODUCT : `/${normalizePath(relative(state.root, resolve(state.root, definition)))}`;
+function initialState() {
+	return {
+		base: "/",
+		changed: /* @__PURE__ */ new Set(),
+		changes: 0,
+		command: "serve",
+		files: /* @__PURE__ */ new Set(),
+		following: Promise.resolve(),
+		packages: {},
+		root: process.cwd()
+	};
 }
 /**
 * Returns the source of `virtual:product`, which depends on every file the composition read.
@@ -831,6 +1169,41 @@ function served(state, imported, context) {
 	return moduleOf(imported, state.product);
 }
 /**
+* Returns the id the page the options name resolves a specifier to, and undefined for any other
+* specifier or without a page.
+*
+* @param state - The project root.
+* @param options - The plugin's options, which name the page.
+* @param id - The specifier.
+*/
+function pageIdFor(state, options, id) {
+	if (options.app !== void 0) return appIdOf(state.root, id);
+	return options.standalone === void 0 ? void 0 : pageIdOf(state.root, id);
+}
+/**
+* Returns the source of a module of the page the options name, and undefined for any other id or
+* without a page.
+*
+* @remarks
+*   A module of the product's page depends on every file the composition read, because the
+*   document's language and title come from the product.
+* @param state - The project root, the base, the resolved product and the files the composition
+*   read.
+* @param options - The plugin's options, which name the page.
+* @param id - The resolved id.
+* @param context - The load hook's context, which watches the files.
+*/
+function pageServed(state, options, id, context) {
+	const { app, standalone } = options;
+	if (app === void 0) return standalone === void 0 ? void 0 : pageSourceOf(state.root, standalone, id);
+	const source = appSourceOf(state.root, {
+		...app,
+		runtime: options.runtime
+	}, state, id);
+	if (source !== void 0) for (const file of state.files) context.addWatchFile(file);
+	return source;
+}
+/**
 * Creates the plugin that composes a product from its plugins, serves `virtual:product`, builds
 * each plugin's lazy modules into one chunk, and writes the access, flag and operation catalogues
 * of a build.
@@ -841,25 +1214,22 @@ function served(state, imported, context) {
 *   resolves, and `virtual:product` then fails with the problems. A change to a file the
 *   composition read composes the product again: the page reloads, or shows the problems in the
 *   error overlay and keeps the last product. The client build writes the catalogues under
-*   `.product` in its output. Under `standalone`, the plugin writes the definition of the product
-*   that runs the plugin at `node_modules/.stealth/standalone/product.ts` once the configuration
-*   resolves, unless `definition` names one. It serves the page's document as `index.html`, its
-*   entry as `virtual:standalone`, and the generated definition as `virtual:standalone-product`.
-* @param options - The definition's path, and the standalone page.
+*   `.product` in its output. Under `app`, the plugin serves the product's document as
+*   `index.html` and its entry as `virtual:product-app`, which renders the product with
+*   `renderProduct`. A dev server that serves one module per file receives the document from a
+*   middleware. Under `standalone`, the plugin writes the definition of the product that runs the
+*   plugin at `node_modules/.stealth/standalone/product.ts` once the configuration resolves,
+*   unless `definition` names one. It serves the page's document as `index.html`, its entry as
+*   `virtual:standalone`, and the generated definition as `virtual:standalone-product`.
+* @param options - The definition's path, and the product's page or the standalone page.
+* @throws {@link Error} When the options name both pages, which both serve `index.html`.
 */
 function product(options = {}) {
-	const state = {
-		changed: /* @__PURE__ */ new Set(),
-		changes: 0,
-		command: "serve",
-		files: /* @__PURE__ */ new Set(),
-		following: Promise.resolve(),
-		packages: {},
-		root: process.cwd()
-	};
+	const state = initialState();
 	const page = options.standalone;
 	const generated = page !== void 0 && options.definition === void 0;
 	const definition = options.definition ?? (generated ? "node_modules/.stealth/standalone/product.ts" : DEFINITION);
+	if (options.app !== void 0 && page !== void 0) throw new Error(BOTH);
 	return {
 		/**
 		* Composes the product, and reports its warnings and its problems.
@@ -881,16 +1251,34 @@ function product(options = {}) {
 			return closed(state);
 		},
 		/**
-		* Adds the group that builds each installed plugin's lazy modules into a chunk of its own.
+		* Adds the group that builds each installed plugin's lazy modules into a chunk of its own, and
+		* under a build the group of the `dependencies` chunk.
+		*/
+		config(_config, { command }) {
+			return chunked(state, command);
+		},
+		/**
+		* Shows the problems in the error overlay of each page that connects while the product does
+		* not resolve, and returns the hook that serves the product's document under a server that
+		* serves one module per file.
+		*
+		* @remarks
+		*   A server that bundles reloads the page after a change to a file the page imports, and the
+		*   reloaded page starts without the overlay, so the plugin sends the problems again as the
+		*   page connects.
 		*/
-		config() {
-			return chunked(state);
+		configureServer(server) {
+			server.environments.client.hot.on("vite:client:connect", (_payload, client) => {
+				if (state.failure !== void 0) client.send(noticeOf(state));
+			});
+			return options.app === void 0 ? void 0 : documentHookOf(server, state);
 		},
 		/**
-		* Records the project root, the command, the conditions and the catalogue plugin's api, and
-		* writes the generated definition of a standalone page.
+		* Records the project root, the base, the command, the conditions and the catalogue plugin's
+		* api, and writes the generated definition of a standalone page.
 		*/
 		configResolved(config) {
+			state.base = config.base;
 			state.command = config.command;
 			state.conditions = config.ssr.resolve?.conditions;
 			state.root = config.root;
@@ -914,22 +1302,22 @@ function product(options = {}) {
 			return state.files.has(normalizePath(file)) ? updated(state, this) : void 0;
 		},
 		/**
-		* Serves `virtual:product`, and the standalone page's document, entry and definition.
+		* Serves `virtual:product`, the product page's document and entry, and the standalone page's
+		* document, entry and definition.
 		*
 		* @throws {@link Error} When the product did not resolve, with every problem.
 		*/
 		load(id) {
-			if (id === RESOLVED) return served(state, importedOf(state, definition, generated), this);
-			return page === void 0 ? void 0 : pageSourceOf(state.root, page, id);
+			if (id === RESOLVED) return served(state, importedOf(state.root, definition, generated), this);
+			return pageServed(state, options, id, this);
 		},
 		name: "stealth:product",
 		/**
-		* Claims `virtual:product`, and the standalone page's document, entry and definition, leaving
-		* every other import alone.
+		* Claims `virtual:product`, the product page's document and entry, and the standalone page's
+		* document, entry and definition, leaving every other import alone.
 		*/
 		resolveId(id) {
-			if (id === "virtual:product") return RESOLVED;
-			return page === void 0 ? void 0 : pageIdOf(state.root, id);
+			return id === "virtual:product" ? RESOLVED : pageIdFor(state, options, id);
 		},
 		/**
 		* Follows a change to a file the last composition read, which the next composition transforms
@@ -944,4 +1332,1037 @@ function product(options = {}) {
 	};
 }
 //#endregion
-export { ID, product };
+//#region src/provided/facade.ts
+/**
+* Writes the facade of a provided specifier: the entry module a page's import map maps the
+* specifier to, which re-exports the package the product bundles.
+*
+* @remarks
+*   A facade contains no code of its own, so the package's code remains in the chunk the
+*   product's chunk groups put it in, and a release that imports the specifier receives the
+*   product's module. A CommonJS package such as React exports its names from an object, which
+*   `export *` does not forward, so its facade names every export.
+*/
+/**
+* The prefix of a facade's id, behind the NUL that marks the module as generated.
+*/
+const FACADE = "\0stealth-provided:";
+/**
+* Matches a name JavaScript accepts as a binding.
+*/
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/u;
+/**
+* Returns the id of a specifier's facade.
+*/
+function facadeIdOf(specifier) {
+	return `${FACADE}${specifier}`;
+}
+/**
+* Returns the specifier of a facade's id, or undefined for any other id.
+*/
+function specifierOf(id) {
+	return id.startsWith("\0stealth-provided:") ? id.slice(18) : void 0;
+}
+/**
+* Returns a package name or a specifier as part of a chunk's name: without its scope's `@`, and
+* with every other character outside a name written as `-`.
+*/
+function slugOf(name) {
+	return name.replace(/^@/u, "").replaceAll(/[^\w-]+/gu, "-");
+}
+/**
+* Returns the name of a facade's chunk: `provided/` and the specifier's slug.
+*/
+function chunkNameOf(specifier) {
+	return `provided/${slugOf(specifier)}`;
+}
+/**
+* Returns the shape of a module from the bundler's information about it, and from its exports
+* object where it is CommonJS.
+*
+* @remarks
+*   The bundler lists no names for a CommonJS module, whose exports object exists only once the
+*   module runs, so the names come from the object Node loads.
+* @param module - The bundler's information about the module.
+* @param exported - Returns the names of the module's exports object, as Node loads it.
+*/
+function shapeOf(module, exported) {
+	if (module.inputFormat !== "cjs") return {
+		defaulted: module.exports.includes("default"),
+		kind: "module"
+	};
+	return {
+		kind: "commonjs",
+		names: exported().filter((name) => name !== "default" && name !== "__esModule" && IDENTIFIER.test(name))
+	};
+}
+/**
+* Returns the source of a specifier's facade.
+*
+* @param specifier - The provided specifier.
+* @param shape - The exports of the specifier's module.
+*/
+function facadeOf(specifier, shape) {
+	const from = quoted(specifier);
+	if (shape.kind === "module") return [
+		`export * from ${from};`,
+		...shape.defaulted ? [`export { default } from ${from};`] : [],
+		""
+	].join("\n");
+	return [
+		`import provided from ${from};`,
+		"export default provided;",
+		...shape.names.length === 0 ? [] : [`export const { ${shape.names.join(", ")} } = provided;`],
+		""
+	].join("\n");
+}
+//#endregion
+//#region src/provided/pinned.ts
+/**
+* Returns a map from the id of each module of the first build to the name of its chunk.
+*
+* @remarks
+*   The modules of a static entry's chunk have no pin. The second chunk of one name in file name
+*   order takes the name with `-2` appended, and the third takes it with `-3` appended.
+* @param chunks - The chunks of the first build.
+*/
+function pinnedOf(chunks) {
+	const counts = /* @__PURE__ */ new Map();
+	const pinned = /* @__PURE__ */ new Map();
+	const ordered = chunks.filter(({ isEntry }) => !isEntry).toSorted((one, two) => one.fileName.localeCompare(two.fileName));
+	for (const { modules, name } of ordered) {
+		const count = (counts.get(name) ?? 0) + 1;
+		const pin = count === 1 ? name : `${name}-${String(count)}`;
+		counts.set(name, count);
+		for (const id of Object.keys(modules)) pinned.set(id, pin);
+	}
+	return pinned;
+}
+/**
+* Returns the code-splitting group that places each pinned module in the second build.
+*
+* @remarks
+*   A pinned chunk can import a chunk of the facades' code that imports it back. Rolldown defines a
+*   CommonJS module's wrapper at the top level of its chunk, and an ES module that imports it calls
+*   the wrapper at its own top level. In such a cycle a chunk can call a wrapper that is not
+*   defined yet. The group builds each pin's CommonJS modules into a chunk of their own. As long as
+*   those modules require only CommonJS modules, that chunk imports only rolldown's runtime and
+*   other such chunks. It then runs before every chunk that calls its wrappers.
+* @param pins - Returns a map from the id of each module of the first build to its chunk once the
+*   first build has run.
+*/
+function pinnedGroup(pins) {
+	return {
+		debugName: "pinned",
+		name: (id, chunking) => {
+			const pin = pins()?.get(id);
+			if (pin === void 0) return null;
+			return chunking.getModuleInfo(id)?.inputFormat === "cjs" ? `${pin}-cjs` : pin;
+		}
+	};
+}
+//#endregion
+//#region src/provided/first.ts
+/**
+* Runs a product's first build: the build's own configuration without the facades, written
+* nowhere, whose chunks the second build pins the product's modules to.
+*/
+/**
+* Name of the plugin that marks the first build, which leaves the facades out.
+*/
+const FIRST_BUILD = "stealth:provided-first";
+/**
+* Returns true where a configuration's plugins mark the first build.
+*
+* @param plugins - The resolved plugins of a build.
+*/
+function isFirstBuild(plugins) {
+	return plugins.some(({ name }) => name === FIRST_BUILD);
+}
+/**
+* Returns a plugin option with every nested list flattened into one list.
+*/
+function flattened(option) {
+	return Array.isArray(option) ? option.flatMap((one) => flattened(one)) : [option];
+}
+/**
+* Returns the plugins a caller passed inline, with the second build's own facade plugin left out.
+*/
+function inlinePlugins(plugins, own) {
+	return (plugins ?? []).flatMap((option) => flattened(option)).filter((one) => one !== own);
+}
+/**
+* Returns the chunks of the first build of the configuration a second build resolved.
+*
+* @remarks
+*   The first build reads the same configuration file and the same inline configuration, with the
+*   plugin that marks it, without watching and without writing. A facade plugin of the first build
+*   reads the mark and adds nothing, so the first build places each module as the product's build
+*   does without facades.
+* @param config - The second build's configuration file, inline configuration, mode and root.
+* @param own - The second build's facade plugin, which a caller may have passed inline.
+*/
+async function firstBuild(config, own) {
+	const { configFile, inlineConfig, mode, root } = config;
+	return [await build({
+		...inlineConfig,
+		build: {
+			...inlineConfig.build,
+			watch: null,
+			write: false
+		},
+		configFile: configFile ?? false,
+		logLevel: "silent",
+		mode,
+		plugins: [...inlinePlugins(inlineConfig.plugins, own), { name: FIRST_BUILD }],
+		root
+	})].flat().flatMap(({ output }) => output).filter((file) => file.type === "chunk");
+}
+//#endregion
+//#region src/provided/packages.ts
+/**
+* Lists the packages a page provides to the releases it loads, and the specifiers of each.
+*
+* @remarks
+*   A module that keeps state at module level exists once per page, or two copies of it disagree.
+*   The provided packages are React, the libraries whose contexts the providers wrap, the five Zag
+*   modules of the overlays, and the `@stealthscale` packages a plugin's components import: the
+*   SDK, the providers, `settings`, `hooks`, `theme` and every component package. A product
+*   provides a package where a package on its dependency graph depends on it or peers on it.
+*/
+/**
+* The provided specifiers of the packages that are not `@stealthscale` packages, by package.
+*
+* @remarks
+*   React's compiled components import `react/compiler-runtime` and `react/jsx-runtime`, which
+*   are specifiers of their own: a release that bundled either would bundle React's index too.
+*/
+const LIBRARIES = {
+	"@tanstack/react-form": ["@tanstack/react-form"],
+	"@tanstack/react-hotkeys": ["@tanstack/react-hotkeys"],
+	"@tanstack/react-query": ["@tanstack/react-query"],
+	"@tanstack/react-router": ["@tanstack/react-router"],
+	"@tanstack/router-core": ["@tanstack/router-core"],
+	"@zag-js/aria-hidden": ["@zag-js/aria-hidden"],
+	"@zag-js/dismissable": ["@zag-js/dismissable"],
+	"@zag-js/focus-trap": ["@zag-js/focus-trap"],
+	"@zag-js/focus-visible": ["@zag-js/focus-visible"],
+	"@zag-js/remove-scroll": ["@zag-js/remove-scroll"],
+	i18next: ["i18next"],
+	react: [
+		"react",
+		"react/jsx-runtime",
+		"react/compiler-runtime"
+	],
+	"react-dom": ["react-dom"],
+	"react-i18next": ["react-i18next"]
+};
+/**
+* Matches the name of an `@stealthscale` package a page provides.
+*/
+const PROVIDED = /^@stealthscale\/(?:sdk-core|sdk-plugin|settings|hooks|theme|provider-[a-z0-9-]+|component-[a-z0-9-]+)$/u;
+/**
+* The entries of a provided `@stealthscale` package that a page does not map: its manifest, its
+* preset, its test helpers and its stylesheet.
+*/
+const WITHHELD = /* @__PURE__ */ new Set([
+	"./package.json",
+	"./testing",
+	"./theme"
+]);
+/**
+* Returns the specifiers of an `@stealthscale` package from the subpaths its `exports` maps, every
+* entry but the withheld ones and the stylesheets.
+*
+* @param name - The package's name.
+* @param exports - The package's `exports` member.
+*/
+function specifiersOf(name, exports) {
+	if (typeof exports !== "object" || exports === null) return [name];
+	const subpaths = Object.keys(exports).filter((subpath) => subpath.startsWith("."));
+	return (subpaths.length === 0 ? ["."] : subpaths).filter((subpath) => !WITHHELD.has(subpath) && !subpath.endsWith(".css")).map((subpath) => subpath === "." ? name : `${name}/${subpath.slice(2)}`);
+}
+/**
+* Returns the directory a package resolves from: the root where the root's own `node_modules`
+* contains it, else the first package on the graph that does.
+*/
+function foundFrom(name, root, graph) {
+	for (const from of [root, ...graph.map(({ at }) => at)]) {
+		const at = packageAt(name, from);
+		if (at !== void 0) return [from, at];
+	}
+}
+/**
+* Returns true for the name of a package a page provides.
+*/
+function isProvidedPackage(name) {
+	return Object.hasOwn(LIBRARIES, name) || PROVIDED.test(name);
+}
+/**
+* Returns the specifiers and the version of a provided package installed in a directory.
+*
+* @param name - The package's name.
+* @param at - The package's directory.
+* @returns The specifiers and the version, or undefined where the manifest states no version.
+*/
+function installedAt(name, at) {
+	const manifest = manifestAt(at);
+	const version = manifest?.["version"];
+	if (typeof version !== "string") return void 0;
+	return {
+		specifiers: LIBRARIES[name] ?? specifiersOf(name, manifest?.["exports"]),
+		version
+	};
+}
+/**
+* Returns the provided package of a name, or undefined where it is not installed on the graph or
+* states no version.
+*/
+function providedOf$1(name, root, graph) {
+	const found = foundFrom(name, root, graph);
+	const installed = found === void 0 ? void 0 : installedAt(name, found[1]);
+	return found === void 0 || installed === void 0 ? void 0 : {
+		from: found[0],
+		name,
+		...installed
+	};
+}
+/**
+* Returns the names of the packages a package on the graph peers on.
+*/
+function peersOf({ manifest }) {
+	const peers = manifest["peerDependencies"];
+	return typeof peers === "object" && peers !== null ? Object.keys(peers) : [];
+}
+/**
+* Returns every package the product at a root provides, sorted by name.
+*
+* @remarks
+*   The walk of the graph reads `dependencies` alone. A peer is bundled where a module that peers
+*   on it imports it, so the names come from the peers of every package on the graph as well.
+* @param root - The product's root, whose dependency graph the walk reads.
+*/
+function providedPackages(root) {
+	const graph = dependencies(root);
+	return [.../* @__PURE__ */ new Set([...Object.keys(LIBRARIES), ...[...graph.map(({ named: name }) => name), ...graph.flatMap((dependency) => peersOf(dependency))].filter((name) => PROVIDED.test(name))])].toSorted().flatMap((name) => providedOf$1(name, root, graph) ?? []);
+}
+/**
+* Returns the name of the package a specifier imports from: its first segment, or its first two
+* for a scoped package.
+*/
+function packageOf(specifier) {
+	return specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+}
+/**
+* Returns the path a provided specifier resolves from: the `package.json` of the directory its
+* package resolves from.
+*
+* @param provided - The provided packages.
+* @param specifier - A specifier a facade imports, such as `react/jsx-runtime`.
+* @returns The path, or undefined for a specifier no provided package maps.
+*/
+function importerOf(provided, specifier) {
+	const owner = provided.find(({ specifiers }) => specifiers.includes(specifier));
+	return owner === void 0 ? void 0 : join(owner.from, "package.json");
+}
+//#endregion
+//#region src/provided/manifest.ts
+/**
+* Returns the paths of some chunks and of every chunk that they import statically. The given
+* chunks come first.
+*/
+function closureOf(chunks, seeds) {
+	const closure = [];
+	/**
+	* Adds a chunk to the closure, then the chunks that it imports.
+	*/
+	const visit = (name) => {
+		const chunk = chunks.get(name);
+		if (chunk === void 0 || closure.includes(name)) return;
+		closure.push(name);
+		for (const imported of chunk.imports) visit(imported);
+	};
+	for (const seed of seeds) visit(seed);
+	return closure;
+}
+/**
+* Returns the facade chunk of each provided specifier, sorted by specifier.
+*/
+function facadesOf$1(chunks) {
+	return [...chunks.values()].flatMap((chunk) => {
+		const specifier = chunk.facadeModuleId === null ? void 0 : specifierOf(chunk.facadeModuleId);
+		return specifier === void 0 ? [] : [{
+			chunk,
+			specifier
+		}];
+	}).toSorted((one, two) => one.specifier.localeCompare(two.specifier));
+}
+/**
+* Returns the paths of the chunks that a page loads when it starts. These are the entries other
+* than the facades and the chunks that those entries import statically. They also include each
+* chunk of a module that such an entry imports through `import()`, and the static imports of that
+* chunk.
+*/
+function startupOf(chunks, facades) {
+	const provided = new Set(facades.map(({ chunk }) => chunk.fileName));
+	const entries = [...chunks.values()].filter(({ fileName, isEntry }) => isEntry && !provided.has(fileName));
+	const seeds = [...entries.map(({ fileName }) => fileName), ...entries.flatMap(({ dynamicImports }) => dynamicImports)];
+	return new Set(closureOf(chunks, seeds));
+}
+/**
+* Returns what a build provides. The result maps each specifier to the URL of its facade chunk, and
+* to the URLs of the chunks that the facade imports outside the page's startup. It also contains
+* the page's fallback language and the version of each provided package.
+*
+* @param bundle - The build's output files, by file name.
+* @param base - The public base the build serves its files at.
+* @param packages - The packages the build provides.
+* @param language - The page's fallback language.
+*/
+function providedOf(bundle, base, packages, language) {
+	const chunks = new Map(Object.values(bundle).flatMap((file) => file.type === "chunk" ? [[file.fileName, file]] : []));
+	const facades = facadesOf$1(chunks);
+	const startup = startupOf(chunks, facades);
+	return {
+		chunks: Object.fromEntries(facades.map(({ chunk, specifier }) => [specifier, closureOf(chunks, [chunk.fileName]).filter((name) => name !== chunk.fileName && !startup.has(name)).map((name) => `${base}${name}`)])),
+		imports: Object.fromEntries(facades.map(({ chunk, specifier }) => [specifier, `${base}${chunk.fileName}`])),
+		language,
+		versions: Object.fromEntries(packages.map(({ name, version }) => [name, version]))
+	};
+}
+/**
+* Returns the import map of the provided specifiers. The build adds it as the first of its tags in
+* a document's head.
+*
+* @param imports - The URL of each provided specifier's entry, by specifier.
+*/
+function importMapOf(imports) {
+	return {
+		attrs: { type: "importmap" },
+		children: JSON.stringify({ imports }),
+		injectTo: "head-prepend",
+		tag: "script"
+	};
+}
+//#endregion
+//#region src/provided/plugin.ts
+/**
+* Provides a product's shared modules to the releases that its page loads.
+*
+* @remarks
+*   The plugin writes one entry per provided specifier, a file that lists their URLs and the
+*   provided packages' versions, and the import map in the page's document. It runs in a build
+*   alone. A development server does not serve the provided entries, so a product loads releases
+*   from its build.
+*/
+/**
+* Returns the names of the exports object of a CommonJS module that Node loads.
+*/
+function exportedOf(from, specifier) {
+	const loaded = createRequire(from)(specifier);
+	return typeof loaded === "object" && loaded !== null ? Object.keys(loaded) : [];
+}
+/**
+* Returns the page's fallback language from the catalogue plugin.
+*
+* @throws {@link Error} When the configuration lacks the catalogue plugin.
+*/
+function languageOf(api) {
+	if (api === void 0) throw new Error("The configuration lacks the stealth:i18n plugin. The build reads the page's fallback language from that plugin and writes it into provided.json. Add the layers of @stealthscale/vite-config-i18n.");
+	return api.fallback;
+}
+/**
+* Returns the entry chunk of the facade of each specifier of each provided package.
+*/
+function facadesOf(packages) {
+	return packages.flatMap(({ specifiers }) => specifiers.map((specifier) => ({
+		id: facadeIdOf(specifier),
+		name: chunkNameOf(specifier),
+		preserveSignature: "strict",
+		type: "chunk"
+	})));
+}
+/**
+* Returns the source of the facade of a specifier a provided package maps, and null for any other
+* id.
+*
+* @param context - The load hook's context, which resolves and loads the specifier's module.
+* @param packages - The packages the product provides.
+* @param id - The id the hook loads.
+* @throws {@link Error} When the facade's specifier does not resolve.
+*/
+async function facadeSourceOf(context, packages, id) {
+	const specifier = specifierOf(id);
+	const from = specifier === void 0 ? void 0 : importerOf(packages, specifier);
+	if (specifier === void 0 || from === void 0) return null;
+	const resolved = await context.resolve(specifier, from, { skipSelf: true });
+	if (resolved === null) throw new Error(`The provided specifier ${specifier} does not resolve from ${from}.`);
+	return facadeOf(specifier, shapeOf(await context.load({ id: resolved.id }), () => exportedOf(from, specifier)));
+}
+/**
+* Creates the plugin that provides the product's shared modules to the releases its page loads.
+*
+* @remarks
+*   The client build first runs a build of the same configuration without the facades. It then
+*   builds each module of that first build into the chunk of the same name, and each CommonJS
+*   module into a chunk beside it. It emits each facade as an entry chunk that keeps its exports.
+*   A facade imports its specifier, and the plugin resolves the specifier from the package that
+*   depends on it, so the facade and the product share one module. Rolldown builds the code that
+*   only the facades need into chunks that only the facades import. The plugin writes
+*   `.product/provided.json` beside the page. The file contains the chunks that each facade imports
+*   and the page's fallback language. The plugin writes the import map before the module scripts of
+*   every document that the build writes.
+*/
+function provided() {
+	const state = {
+		base: "/",
+		first: false,
+		language: "",
+		packages: []
+	};
+	const plugin = {
+		apply: "build",
+		/**
+		* Runs the first build in the client build, and emits the facade of every provided specifier.
+		*
+		* @throws {@link Error} When the configuration lacks the catalogue plugin.
+		*/
+		async buildStart() {
+			if (state.first || this.environment.config.consumer !== "client") return;
+			state.language = languageOf(state.api);
+			state.pinned = pinnedOf(await firstBuild(this.environment.config, plugin));
+			for (const facade of facadesOf(state.packages)) this.emitFile(facade);
+		},
+		/**
+		* Records the catalogue plugin's api, the public base, whether the build is the first build,
+		* and the packages the product provides.
+		*/
+		configResolved(config) {
+			state.api = cataloguesOf(config.plugins);
+			state.base = config.base;
+			state.first = isFirstBuild(config.plugins);
+			state.packages = state.first ? [] : providedPackages(config.root);
+		},
+		enforce: "pre",
+		/**
+		* Writes `.product/provided.json` into the client build's output.
+		*/
+		generateBundle(_options, bundle) {
+			if (state.pinned === void 0 || this.environment.config.consumer !== "client") return;
+			const listing = providedOf(bundle, state.base, state.packages, state.language);
+			this.emitFile({
+				fileName: PROVIDED_FILE,
+				source: `${JSON.stringify(listing, void 0, 2)}\n`,
+				type: "asset"
+			});
+		},
+		/**
+		* Returns the source of a facade, and nothing for any other id.
+		*
+		* @throws {@link Error} When the facade's specifier does not resolve.
+		*/
+		load(id) {
+			return facadeSourceOf(this, state.packages, id);
+		},
+		name: "stealth:provided",
+		/**
+		* Replaces the client build's code-splitting groups with the one group that pins each module
+		* of the first build to its chunk.
+		*
+		* @remarks
+		*   Rolldown reads the output options before the build starts, and calls the group's name
+		*   function after the first build has run.
+		*/
+		outputOptions(options) {
+			if (state.first || this.environment.config.consumer !== "client") return null;
+			const splitting = typeof options.codeSplitting === "object" ? options.codeSplitting : {};
+			const group = pinnedGroup(() => state.pinned);
+			return {
+				...options,
+				codeSplitting: {
+					...splitting,
+					groups: [group]
+				}
+			};
+		},
+		/**
+		* Claims a facade's id, and resolves a facade's import of a provided specifier from the package
+		* that depends on it.
+		*/
+		resolveId(id, importer) {
+			if (specifierOf(id) !== void 0) return id;
+			const from = importer !== void 0 && specifierOf(importer) !== void 0 ? importerOf(state.packages, id) : void 0;
+			return from === void 0 ? null : this.resolve(id, from, { skipSelf: true });
+		},
+		transformIndexHtml: {
+			/**
+			* Writes the import map as the first tag that the client build adds to a document's head,
+			* so the map precedes the page's module scripts.
+			*/
+			handler(_html, context) {
+				return state.pinned === void 0 || context.bundle === void 0 ? void 0 : [importMapOf(providedOf(context.bundle, state.base, state.packages, state.language).imports)];
+			},
+			order: "post"
+		}
+	};
+	return plugin;
+}
+//#endregion
+//#region src/release/catalogues.ts
+/**
+* Returns the catalogues of a plugin's namespace, the fallback language first.
+*
+* @param api - The catalogue plugin's api.
+* @param namespace - The plugin's namespace, its id.
+* @throws {@link Error} When the namespace has no catalogue in the fallback language.
+*/
+function releaseCatalogues(api, namespace) {
+	const { fallback } = api;
+	const languages = new Set(api.catalogues().filter((catalogue) => catalogue.namespace === namespace).map(({ language }) => language));
+	if (!languages.has(fallback)) throw new Error(`The namespace ${namespace} has no catalogue in the fallback language ${fallback}, and a page refuses such a release.`);
+	const others = [...languages].filter((language) => language !== fallback).toSorted();
+	return {
+		files: [fallback, ...others].map((language) => ({
+			fileName: `locales/${language}.json`,
+			source: `${JSON.stringify(api.words(language, namespace), void 0, 2)}\n`
+		})),
+		languages: [fallback, ...others]
+	};
+}
+//#endregion
+//#region src/release/describe.ts
+/**
+* Writes the parts of a release's description: the caret range of a version, the integrity of a
+* file, and the text of `plugin.json`.
+*/
+/**
+* Matches the major and the minor at the start of a version.
+*/
+const MINOR = /^(\d+)\.(\d+)\./u;
+/**
+* Returns the caret range a release requires of a version it was built against: the version's
+* major and minor, from the minor's first patch.
+*
+* @remarks
+*   A release built against 0.2.3 requires `^0.2.0`, and one built against 1.4.2 requires
+*   `^1.4.0`.
+* @throws {@link Error} When the text does not start with a major and a minor.
+*/
+function caretOf(version) {
+	const match = MINOR.exec(version);
+	if (match === null) throw new Error(`${version} is not a version.`);
+	return `^${match.slice(1, 3).join(".")}.0`;
+}
+/**
+* Returns the integrity of a file's bytes, in the form `sha384-<base64>`.
+*/
+function integrityOf(content) {
+	return `sha384-${createHash("sha384").update(content).digest("base64")}`;
+}
+/**
+* Returns the text of a release's `plugin.json`.
+*
+* @throws {@link Error} When the description is not of the shape a page reads, with every fault.
+*/
+function describedOf(release) {
+	const problems = releaseProblems(release);
+	if (problems.length > 0) throw new Error(["The release's description is malformed:", ...problems.map((problem) => lineOf(problem))].join("\n"));
+	return `${JSON.stringify(release, void 0, 2)}\n`;
+}
+//#endregion
+//#region src/release/evaluate.ts
+/**
+* Reads what a release's build needs from the plugin's own modules in Node: the plugin's id from
+* its manifest, and the recipes its preset declares.
+*/
+/**
+* Returns the member of a value under a key where the value is an object, and undefined otherwise.
+*/
+function memberOf(value, key) {
+	return typeof value === "object" && value !== null ? Reflect.get(value, key) : void 0;
+}
+/**
+* Returns the name of every recipe and every slot recipe a preset declares, under `theme` and
+* under `theme.extend`.
+*
+* @param preset - The preset a package publishes under `./theme`.
+*/
+function recipesOf(preset) {
+	const theme = memberOf(preset, "theme");
+	return [theme, memberOf(theme, "extend")].flatMap((part) => ["recipes", "slotRecipes"].flatMap((key) => {
+		const recipes = memberOf(part, key);
+		return typeof recipes === "object" && recipes !== null ? Object.keys(recipes) : [];
+	}));
+}
+/**
+* Returns the plugin id the `manifest` export of a module states, or undefined where it states
+* none.
+*/
+function pluginIdIn(module) {
+	const id = memberOf(memberOf(memberOf(module, "manifest"), "contract"), "pluginId");
+	return typeof id === "string" ? id : void 0;
+}
+/**
+* Imports the module that exports the plugin's manifest, and returns the plugin's id.
+*
+* @param through - The importer, opened and closed by the caller.
+* @param root - The web package's directory.
+* @param manifest - The module's path from the package's directory.
+* @throws {@link Error} When the module exports no manifest under `manifest`.
+*/
+async function releasedId(through, root, manifest) {
+	const { module } = await through.import(join(root, manifest));
+	const id = pluginIdIn(module);
+	if (id === void 0) throw new Error(`${manifest} exports no manifest under the name manifest, which a page imports from a release's manifest.js.`);
+	return id;
+}
+/**
+* Imports the preset a web package publishes under `./theme`, and throws where it declares a
+* recipe.
+*
+* @remarks
+*   A page compiles its stylesheet from the component packages it provides, so a release's own
+*   recipe would have no rule there. A package without a `./theme` entry passes.
+* @param through - The importer, opened and closed by the caller.
+* @param root - The web package's directory.
+* @param conditions - The conditions the package's `exports` resolve under. None where left out.
+* @throws {@link Error} When the preset declares a recipe, naming every recipe.
+*/
+async function refuseRecipes(through, root, conditions) {
+	const target = exportTarget(manifestAt(root) ?? {}, "./theme", conditions);
+	if (target === void 0) return;
+	const { module } = await through.import(join(root, target));
+	const recipes = recipesOf(memberOf(module, "default"));
+	if (recipes.length > 0) throw new Error(`The package's preset declares the recipes ${recipes.join(", ")}. A release renders the components the page provides and declares no recipe of its own.`);
+}
+//#endregion
+//#region src/release/imports.ts
+/**
+* Decides how a release imports a module of a provided package: by a specifier the page's import
+* map resolves, or not at all.
+*
+* @remarks
+*   A release imports every provided specifier by name and bundles no module of a provided package.
+*   A specifier that the page does not map, such as a subpath its package withholds, would bundle a
+*   second copy of the package's modules into the release, so the build fails on it.
+*/
+/**
+* Returns the provided package a module of a release imports by a specifier, or undefined for a
+* specifier of any other package.
+*
+* @param source - The specifier the module imports.
+* @param importer - The path of the module.
+* @throws {@link Error} When the package is provided but not installed with a version for the
+*   module, or the page does not map the specifier.
+*/
+function providedImportOf(source, importer) {
+	const name = packageOf(source);
+	if (!isProvidedPackage(name)) return void 0;
+	const at = packageAt(name, dirname(importer));
+	const installed = at === void 0 ? void 0 : installedAt(name, at);
+	if (installed === void 0) throw new Error(`${importer} imports ${source}, and ${name} is not installed with a version.`);
+	if (!installed.specifiers.includes(source)) throw new Error(`${importer} imports ${source}, which the page does not map, so the release would bundle a copy of ${name}. Import one of ${installed.specifiers.join(", ")}.`);
+	return {
+		name,
+		version: installed.version
+	};
+}
+//#endregion
+//#region src/release/preloads.ts
+/**
+* Rewrites a release's lazy imports of its own modules, so that the page preloads a module's static
+* imports while the release imports the module.
+*
+* @remarks
+*   The build rewrites each chunk before rolldown writes the hashes into the chunks' names and
+*   minifies them. Rolldown replaces a hash in both copies of a path.
+*/
+/**
+* The specifier of the package that exports `preloaded`.
+*/
+const SDK = "@stealthscale/sdk-core";
+/**
+* Name under which a rewritten chunk imports `preloaded`.
+*/
+const PRELOADED = "__stealth_preloaded__";
+/**
+* Matches the string literal of a lazy import of a module of the release: a relative path between
+* quotes or backticks, without an expression and without a backslash.
+*/
+const RELATIVE = /^(["'`])\.{1,2}\/[^"'`$\\]+\1$/u;
+/**
+* Returns the lazy imports of the release's own modules in a chunk's code, in order.
+*/
+function lazyImportsOf(code) {
+	const { dynamicImports } = parseSync("chunk.js", code).module;
+	return dynamicImports.flatMap(({ end, moduleRequest, start }) => {
+		const literal = code.slice(moduleRequest.start, moduleRequest.end);
+		return RELATIVE.test(literal) ? [{
+			end,
+			literal,
+			start
+		}] : [];
+	});
+}
+/**
+* Returns a chunk's code with each lazy import of a module of the release called through
+* `preloaded`, or undefined for a chunk without such an import.
+*
+* @remarks
+*   The call passes the import's own string literal twice, as the chunk writes it. The literal
+*   contains a relative path alone, so the rewrite constructs no code from an escaped value.
+* @param code - The chunk's code.
+* @param chunk - The chunk's file name, for the error message.
+* @throws {@link Error} When the code already uses the name under which the rewrite imports
+*   `preloaded`.
+*/
+function withPreloads(code, chunk) {
+	const found = lazyImportsOf(code);
+	if (found.length === 0) return void 0;
+	if (code.includes("__stealth_preloaded__")) throw new Error(`The chunk ${chunk} already uses the name ${PRELOADED}. The build imports preloaded under that name.`);
+	const rewritten = found.toReversed().reduce((text, { end, literal, start }) => {
+		const call = `${PRELOADED}(import.meta.url, ${literal}, () => import(${literal}))`;
+		return `${text.slice(0, start)}${call}${text.slice(end)}`;
+	}, code);
+	return `import { preloaded as ${PRELOADED} } from "${SDK}";\n${rewritten}`;
+}
+//#endregion
+//#region src/release/plugin.ts
+/**
+* Builds a plugin's web package as a release that a page loads at run time. The release contains
+* the package's modules, its catalogues and `plugin.json`, which describes them.
+*/
+/**
+* Path from the package's directory to the directory that the build writes a release to. The
+* directory is beside `dist`, because a pack empties `dist` before it writes.
+*/
+const RELEASE_DIRECTORY = "dist-release";
+/**
+* Path from the package's directory to the manifest module when the options leave it out.
+*/
+const MANIFEST = "src/manifest.ts";
+/**
+* Returns the library build configuration of a release.
+*
+* @remarks
+*   The build writes the manifest module as `manifest.js` with its exports, and every other module
+*   under `assets` with a hash in its name. Rolldown builds a module that the manifest shares with
+*   a lazy module into `manifest.js`, so the loader imports the manifest with one request. A
+*   library build leaves out Vite's preload helper and inlines every file that a module imports. It
+*   also leaves `process.env.NODE_ENV` as written, so the configuration defines `NODE_ENV` from the
+*   build's mode. The configuration minifies the output, because a page loads a release and no
+*   bundler reads it.
+* @param root - The package's directory.
+* @param manifest - The manifest module's path from the package's directory.
+* @param mode - The build's mode.
+*/
+function configOf(root, manifest, mode) {
+	return {
+		build: {
+			copyPublicDir: false,
+			emptyOutDir: true,
+			lib: {
+				entry: { manifest: join(root, manifest) },
+				formats: ["es"]
+			},
+			outDir: RELEASE_DIRECTORY,
+			rolldownOptions: {
+				output: {
+					chunkFileNames: "assets/[name]-[hash].js",
+					entryFileNames: "[name].js",
+					minify: true
+				},
+				preserveEntrySignatures: "allow-extension"
+			}
+		},
+		define: { "process.env.NODE_ENV": JSON.stringify(mode) }
+	};
+}
+/**
+* Refuses a package whose preset declares a recipe, and returns the plugin's id.
+*
+* @throws {@link Error} When the preset declares a recipe or the manifest module does not export a
+*   manifest.
+*/
+async function identified(state, manifest) {
+	const through = await importer({
+		conditions: state.conditions,
+		root: state.root
+	});
+	try {
+		await refuseRecipes(through, state.root, state.conditions);
+		return await releasedId(through, state.root, manifest);
+	} finally {
+		await through.close();
+	}
+}
+/**
+* Returns the chunks of a release's bundle.
+*
+* @throws {@link Error} When the bundle contains a file other than a module. A page does not load a
+*   stylesheet or any other such file from a release.
+*/
+function chunksOf(bundle) {
+	const files = Object.values(bundle);
+	const assets = files.filter((file) => file.type === "asset").map(({ fileName }) => fileName);
+	if (assets.length > 0) throw new Error(`The release contains ${assets.join(", ")}. A page does not load such a file from a release. A release's styles come from the page's stylesheet, and the build inlines every other file that a module imports.`);
+	return files.filter((file) => file.type === "chunk");
+}
+/**
+* Returns the version in the manifest of the package in a directory, or the empty string when the
+* manifest has no version.
+*/
+function versionAt(root) {
+	const version = manifestAt(root)?.["version"];
+	return typeof version === "string" ? version : "";
+}
+/**
+* Returns the static imports of each chunk of the release, keyed by the chunk's path. The imports
+* of a chunk are the chunks and provided specifiers that it imports. They include
+* `@stealthscale/sdk-core` for a chunk whose lazy imports the build calls through `preloaded`.
+*/
+function importsOf(chunks, bundle) {
+	const imports = chunks.map(({ dynamicImports, fileName, imports: own }) => {
+		return [fileName, dynamicImports.some((name) => Object.hasOwn(bundle, name)) && !own.includes("@stealthscale/sdk-core") ? [...own, SDK] : own];
+	});
+	return Object.fromEntries(imports.toSorted(([one], [two]) => one.localeCompare(two)));
+}
+/**
+* Returns a map from the name of each provided package that the release's chunks import to its
+* caret range.
+*/
+function requiresOf(state, imports) {
+	const required = Object.values(imports).flat().flatMap((specifier) => {
+		const provided = state.imported.get(specifier);
+		return provided === void 0 ? [] : [[provided.name, caretOf(provided.version)]];
+	});
+	return Object.fromEntries(required.toSorted(([one], [two]) => one.localeCompare(two)));
+}
+/**
+* Returns a map from the path of each file of the release except `plugin.json` to its integrity.
+*/
+function filesOf(chunks, catalogues) {
+	const files = [...chunks.map(({ code, fileName }) => [fileName, integrityOf(code)]), ...catalogues.map(({ fileName, source }) => [fileName, integrityOf(source)])];
+	return Object.fromEntries(files.toSorted(([one], [two]) => one.localeCompare(two)));
+}
+/**
+* Creates the plugin that builds a plugin's web package as a release.
+*
+* @remarks
+*   The build is a library build whose one entry is the module that exports the manifest. The build
+*   keeps every import of a provided specifier as an import by name, and the page's import map
+*   resolves it. It calls each lazy import of a module of the release through `preloaded` of
+*   `@stealthscale/sdk-core`. `preloaded` passes the module's URL to the page's preloader before
+*   the import. The build fails on an import of a provided package that the page does not map. It
+*   also fails on a stylesheet or any other file that is not a module. The plugin writes the
+*   catalogue of the plugin's namespace in each language as `locales/<language>.json`. It writes
+*   `plugin.json` with the plugin's id and version, its languages, each module's static imports,
+*   the caret range of each provided package it imports, and the integrity of every other file. It
+*   fails a package whose preset declares a recipe.
+* @param options - The manifest module's path.
+*/
+function release(options = {}) {
+	const manifest = options.manifest ?? MANIFEST;
+	const state = {
+		imported: /* @__PURE__ */ new Map(),
+		root: process.cwd()
+	};
+	return {
+		apply: "build",
+		/**
+		* Reads the plugin's id from its manifest, and refuses a preset that declares a recipe.
+		*
+		* @throws {@link Error} When the configuration lacks the catalogue plugin, the preset declares a
+		*   recipe, or the manifest module does not export a manifest.
+		*/
+		async buildStart() {
+			const { api } = state;
+			if (api === void 0) throw new Error("The configuration lacks the stealth:i18n plugin. The release build reads the release's catalogues from that plugin. Add the layers of @stealthscale/vite-config-i18n.");
+			state.started = {
+				api,
+				id: await identified(state, manifest)
+			};
+		},
+		/**
+		* Returns the release's build configuration.
+		*/
+		config(config, { mode }) {
+			return configOf(config.root ?? process.cwd(), manifest, mode);
+		},
+		/**
+		* Records the package's directory, the conditions and the catalogue plugin's api.
+		*/
+		configResolved(config) {
+			state.api = cataloguesOf(config.plugins);
+			state.conditions = config.ssr.resolve?.conditions;
+			state.root = config.root;
+		},
+		enforce: "pre",
+		generateBundle: {
+			/**
+			* Writes the release's catalogues and its `plugin.json` after every other plugin has written
+			* its files.
+			*
+			* @throws {@link Error} When the bundle contains a file other than a module, the namespace
+			*   lacks a catalogue in the fallback language, or the description is malformed.
+			*/
+			handler(_options, bundle) {
+				const { api, id } = state.started;
+				const chunks = chunksOf(bundle);
+				const imports = importsOf(chunks, bundle);
+				const catalogues = releaseCatalogues(api, id);
+				const description = describedOf({
+					files: filesOf(chunks, catalogues.files),
+					id,
+					imports,
+					languages: catalogues.languages,
+					requires: requiresOf(state, imports),
+					version: versionAt(state.root)
+				});
+				for (const { fileName, source } of catalogues.files) this.emitFile({
+					fileName,
+					source,
+					type: "asset"
+				});
+				this.emitFile({
+					fileName: RELEASE_FILE,
+					source: description,
+					type: "asset"
+				});
+			},
+			order: "post"
+		},
+		name: "stealth:release",
+		/**
+		* Calls each lazy import of a module of the release through `preloaded`, and records the
+		* package that exports it.
+		*
+		* @throws {@link Error} When the chunk already uses the name under which the rewrite imports
+		*   `preloaded`, or when the manifest module has no installed version of
+		*   `@stealthscale/sdk-core`.
+		*/
+		renderChunk(code, chunk) {
+			const rewritten = withPreloads(code, chunk.fileName);
+			if (rewritten === void 0) return null;
+			state.imported.set(SDK, providedImportOf(SDK, join(state.root, manifest)));
+			return rewritten;
+		},
+		/**
+		* Keeps an import of a provided specifier as an import by name, and records its package.
+		*
+		* @throws {@link Error} When the page does not map the specifier, or its package is not
+		*   installed with a version.
+		*/
+		resolveId(source, importing) {
+			const provided = importing === void 0 ? void 0 : providedImportOf(source, importing);
+			if (provided === void 0) return null;
+			state.imported.set(source, provided);
+			return {
+				external: true,
+				id: source
+			};
+		}
+	};
+}
+//#endregion
+export { ID, RELEASE_DIRECTORY, product, provided, release };