@unbound-app/cli 0.11.0 → 1.1.1

package/dist/settings-typings-BRlzDlLI.mjs

@@ -0,0 +1,2585 @@
+import { createRequire } from "node:module";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fetchManifest, resolveHermesTargets } from "@unbound-app/rollup-plugin-hermes/manifest";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { promisify } from "node:util";
+import { createHash } from "node:crypto";
+import { parseSync } from "rolldown/utils";
+import { gzipSync } from "node:zlib";
+import { fileURLToPath } from "node:url";
+import { rolldown } from "rolldown";
+// \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res, err) => () => {
+	if (err) throw err[0];
+	try {
+		return fn && (res = fn(fn = 0)), res;
+	} catch (e) {
+		throw err = [e], e;
+	}
+};
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+// ../types/typings/addons.ts
+/** The kinds of addon, as a manifest's `type` declares them. One manager governs each, in this start order. */
+const ADDON_KINDS = [
+	"plugin",
+	"theme",
+	"icon-pack",
+	"font"
+];
+/**
+* The globals a plugin bundle is evaluated with, in parameter order. Bytecode compiled against an earlier
+* list receives them by position, so new globals are only ever appended.
+*/
+const ADDON_SCOPE_GLOBALS = [
+	"React",
+	"unbound",
+	"addon",
+	"patcher",
+	"logger",
+	"setTimeout",
+	"setInterval",
+	"clearTimeout",
+	"clearInterval",
+	"commands"
+];
+// ../contracts/src/addon-assets.ts
+/** The folder, at the plugin root and beside the built bundle, that holds a plugin's images. */
+const ASSETS_DIRECTORY = "assets";
+/** The image types a plugin ships: the formats React Native's `Image` decodes. An SVG is a component, not an asset. */
+const ASSET_TYPES = [
+	"png",
+	"jpg",
+	"webp",
+	"gif"
+];
+/** The pixel densities a plugin image can ship at, as its `@2x` and `@3x` file suffixes name them. */
+const ASSET_SCALES = [
+	"1",
+	"2",
+	"3"
+];
+/** Path segments joined by `/`, each starting with a letter, digit, `_` or `-`, so no name can leave its folder. */
+const ASSET_NAME_PATTERN = "^[\\w-][\\w.-]*(?:/[\\w-][\\w.-]*)*$";
+const ASSET_NAME = new RegExp(ASSET_NAME_PATTERN);
+/**
+* @description Tells whether `value` can name a plugin asset: path segments without `..`, at most 200 characters.
+* @param value The untrusted value.
+* @returns Whether it is a safe asset name.
+*/
+function isAssetName(value) {
+	return typeof value === "string" && value.length <= 200 && ASSET_NAME.test(value);
+}
+/**
+* @description Names an image file beside an addon's bundle. Files are named by content, so equal images share one.
+* @param main The manifest's `main`, such as `index.js`.
+* @param sha256 The file's SHA-256.
+* @param type The file's type.
+* @returns The file's path relative to the manifest, such as `assets/<sha256>.png`.
+*/
+function getAssetPath(main, sha256, type) {
+	return `${main.slice(0, main.lastIndexOf("/") + 1)}${ASSETS_DIRECTORY}/${sha256}.${type}`;
+}
+// ../contracts/src/addon-locales.ts
+/** The Discord locale every plugin ships in its bundle, and the source of truth for its message keys. */
+const SOURCE_LOCALE = "en-US";
+/** The folder, beside a plugin's `src/` and beside its built bundle, that holds one JSON file per locale. */
+const LOCALES_DIRECTORY = "i18n";
+/** A Discord locale code, such as `de`, `en-GB` or `es-419`. It names a file, so it holds no path characters. */
+const LOCALE_CODE_PATTERN = "^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$";
+const LOCALE_CODE = new RegExp(LOCALE_CODE_PATTERN);
+/**
+* @description Tells whether `value` is a locale code that can name a locale file.
+* @param value The untrusted value.
+* @returns Whether it is a path-safe locale code.
+*/
+function isLocaleCode(value) {
+	return typeof value === "string" && value.length <= 35 && LOCALE_CODE.test(value);
+}
+/**
+* @description Names the folder of locale files beside an addon's bundle.
+* @param main The manifest's `main`, such as `index.js`.
+* @returns The folder's path relative to the manifest, such as `i18n`.
+*/
+function getLocalesDirectory(main) {
+	return `${main.slice(0, main.lastIndexOf("/") + 1)}${LOCALES_DIRECTORY}`;
+}
+/**
+* @description Names a locale file beside an addon's bundle, as the build emits it and the client downloads it.
+* @param main The manifest's `main`, such as `index.js`.
+* @param code The locale code.
+* @returns The file's path relative to the manifest, such as `i18n/de.json`.
+*/
+function getLocalePath(main, code) {
+	return `${getLocalesDirectory(main)}/${code}.json`;
+}
+// ../contracts/src/addon-files.ts
+/**
+* @description Lists every extra file a manifest names beside its bundle, once per path; publishing copies them and installing downloads them.
+* @param manifest The manifest.
+* @returns The files, each with its SHA-256: the images, then the locales.
+*/
+function listAddonFiles(manifest) {
+	const files = /* @__PURE__ */ new Map();
+	for (const [name, asset] of Object.entries(manifest.assets ?? {})) for (const [scale, sha256] of Object.entries(asset.scales)) {
+		if (!sha256) continue;
+		const path = getAssetPath(manifest.main, sha256, asset.type);
+		const label = `asset ${name}${scale === "1" ? "" : `@${scale}x`}`;
+		if (!files.has(path)) files.set(path, {
+			kind: "asset",
+			path,
+			sha256,
+			label
+		});
+	}
+	for (const [code, sha256] of Object.entries(manifest.locales ?? {})) {
+		const path = getLocalePath(manifest.main, code);
+		files.set(path, {
+			kind: "locale",
+			path,
+			sha256,
+			label: `locale ${code}`
+		});
+	}
+	return [...files.values()];
+}
+// src/rollup/hermes-bytecode.ts
+const run = promisify(execFile);
+const FALL_BACK_TO_GLOBAL = /* @__PURE__ */ new Set([
+	"unbound",
+	"setTimeout",
+	"setInterval",
+	"clearTimeout",
+	"clearInterval"
+]);
+const parameters = ADDON_SCOPE_GLOBALS.map((name) => FALL_BACK_TO_GLOBAL.has(name) ? `${name} = globalThis.${name}` : name).join(", ");
+/**
+* @description Wraps a plugin bundle the way the client evaluates its source, so the compiled program's completion value is the same factory.
+* @param code The plugin's final bundle expression.
+* @returns The wrapped source.
+*/
+function bytecodeSource(code) {
+	return `((${parameters}) => { return ${code} })`;
+}
+/**
+* @description Names the compiled bundle beside a source bundle, matching the loader's lookup.
+* @param fileName The source bundle's file name, such as `index.js`.
+* @param version The Hermes bytecode version.
+* @returns The bytecode file name, such as `index.98.hbc`.
+*/
+function bytecodeFileName(fileName, version) {
+	return `${fileName.replace(/\.[^.]+$/, "")}.${version}.hbc`;
+}
+function firstError(error) {
+	const output = (error instanceof Error && "stderr" in error && typeof error.stderr === "string" ? error.stderr : void 0) ?? (error instanceof Error ? error.message : String(error));
+	return output.split("\n").find((line) => line.includes("error:"))?.trim() ?? output.trim();
+}
+async function compile(hermesc, directory, source, output) {
+	await run(hermesc, [
+		"--emit-binary",
+		"-O",
+		"-g1",
+		"-Wno-direct-eval",
+		"-Wno-undefined-variable",
+		"--out",
+		output,
+		source
+	], { cwd: directory });
+	return readFile(output);
+}
+/**
+* @description Counts how many of hermesc's newest versions to resolve so every wanted version is among them.
+* @param latest hermesc's versions, newest first.
+* @param wanted The bytecode versions to compile for.
+* @returns The number of newest versions to resolve.
+*/
+function hermescCount(latest, wanted) {
+	const missing = wanted.filter((version) => !latest.includes(version));
+	if (missing.length) throw new Error(`hermesc does not publish bytecode ${missing.join(", ")}.`);
+	return Math.max(...wanted.map((version) => latest.indexOf(version)), 0) + 1;
+}
+/**
+* @description Compiles each plugin bundle to Hermes bytecode for exactly the bytecode versions the client ships.
+* @param options The bytecode versions to compile for, and the name the bytecode's source locations use.
+* @returns The rollup plugin.
+*/
+function hermesBytecode({ versions, sourceName }) {
+	let targets;
+	return {
+		name: "hermes-bytecode",
+		async generateBundle(_outputOptions, bundle) {
+			targets ??= (await resolveHermesTargets(this, { versions: hermescCount((await fetchManifest(this)).latest, versions) })).filter((target) => versions.includes(target.version));
+			const executable = process.platform === "win32" ? "hermesc.exe" : "hermesc";
+			const directory = await mkdtemp(join(tmpdir(), "plugin-bytecode-"));
+			try {
+				for (const chunk of Object.values(bundle)) {
+					if (chunk.type !== "chunk") continue;
+					const source = `unbound-plugin/${sourceName}.js`;
+					await mkdir(join(directory, "unbound-plugin"), { recursive: true });
+					await writeFile(join(directory, source), bytecodeSource(chunk.code));
+					for (const { version, dir } of targets) {
+						if (!dir) {
+							this.warn(`hermesc for bytecode version ${version} is unavailable, skipping it.`);
+							continue;
+						}
+						const compiled = await compile(resolve(dir, process.platform, executable), directory, source, join(directory, `${version}.hbc`)).catch((error) => {
+							this.warn(`hermesc ${version} could not compile ${chunk.fileName}, so that runtime loads its source: ${firstError(error)}`);
+						});
+						if (compiled) this.emitFile({
+							type: "asset",
+							fileName: bytecodeFileName(chunk.fileName, version),
+							source: compiled
+						});
+					}
+				}
+			} finally {
+				await rm(directory, {
+					recursive: true,
+					force: true
+				});
+			}
+		}
+	};
+}
+// src/rollup/diagnostic.ts
+const SEVERITIES = ["error", "warning"];
+/**
+* @description Builds a diagnostic, placing it on the whole file when it has no line.
+* @param init The diagnostic's fields.
+* @returns The diagnostic.
+*/
+function diagnostic({ line = 0, column = 0, ...rest }) {
+	return {
+		...rest,
+		line,
+		column
+	};
+}
+/**
+* @description Tells whether a value is a diagnostic, such as one a rollup plugin carried in a log's `meta`.
+* @param value The value to test.
+* @returns Whether it has every field a diagnostic needs.
+*/
+function isDiagnostic(value) {
+	if (!value || typeof value !== "object") return false;
+	return "file" in value && typeof value.file === "string" && "line" in value && typeof value.line === "number" && "column" in value && typeof value.column === "number" && "message" in value && typeof value.message === "string" && "severity" in value && typeof value.severity === "string" && SEVERITIES.includes(value.severity);
+}
+/**
+* @description Drops a message's closing full stop, so a suffix such as a rule name can follow it.
+* @param text The message.
+* @returns The message without its closing full stop.
+*/
+function withoutFullStop(text) {
+	const trimmed = text.trim();
+	return trimmed.endsWith(".") ? trimmed.slice(0, -1) : trimmed;
+}
+function sentence(text) {
+	return `${withoutFullStop(text)}.`;
+}
+/**
+* @description Formats a diagnostic as `file:L:C  <path>  <problem>.  Fix: <fix>.`, the line every
+* check, `ubd build` and `ubd check` print.
+* @param diagnostic The diagnostic.
+* @param file The file as the reader should see it; defaults to the diagnostic's own.
+* @returns The line.
+*/
+function formatDiagnostic(diagnostic, file = diagnostic.file) {
+	const parts = [
+		diagnostic.line ? `${file}:${diagnostic.line}:${diagnostic.column}` : file,
+		diagnostic.path,
+		sentence(diagnostic.message)
+	];
+	if (diagnostic.fix) parts.push(`Fix: ${sentence(diagnostic.fix)}`);
+	return parts.filter(Boolean).join("  ");
+}
+/**
+* @description Orders diagnostics by file, then errors before warnings, then by position.
+* @param diagnostics The diagnostics.
+* @returns A sorted copy.
+*/
+function sortDiagnostics(diagnostics) {
+	return diagnostics.toSorted((a, b) => a.file.localeCompare(b.file) || SEVERITIES.indexOf(a.severity) - SEVERITIES.indexOf(b.severity) || a.line - b.line || a.column - b.column || a.message.localeCompare(b.message));
+}
+/**
+* @description Reports a diagnostic from a rollup plugin hook: an error stops the build, a warning
+* does not. Rollup prints the formatted line, and `ubd check` reads the diagnostic back from the
+* log's `meta`, so both show the same problem the same way.
+* @param context The hook's `this`.
+* @param found The diagnostic, with its file relative to the plugin's directory.
+*/
+function reportDiagnostic(context, found) {
+	const log = {
+		message: formatDiagnostic(found),
+		meta: { diagnostic: found }
+	};
+	if (found.severity === "error") context.error(log);
+	context.warn(log);
+}
+/**
+* @description Builds a preset plugin's diagnostic under its `ubd check` id, with the file and any absolute
+* path in the message made relative to the plugin, so `--only <check>` selects it.
+* @param check The check id, one of `BUNDLE_REPORTED_CHECKS`.
+* @param pluginRoot The plugin's directory.
+* @param problem The problem.
+* @returns The diagnostic.
+*/
+function pluginDiagnostic(check, pluginRoot, problem) {
+	const file = isAbsolute(problem.file) ? relative(pluginRoot, problem.file) : problem.file;
+	return diagnostic({
+		...problem,
+		file: file.split(sep).join("/"),
+		message: problem.message.replaceAll(pluginRoot + sep, ""),
+		check
+	});
+}
+/**
+* @description Reports a preset plugin's problem from a rollup hook, as {@link pluginDiagnostic} builds it.
+* @param context The hook's `this`.
+* @param check The check id, one of `BUNDLE_REPORTED_CHECKS`.
+* @param pluginRoot The plugin's directory.
+* @param problem The problem.
+*/
+function reportProblem(context, check, pluginRoot, problem) {
+	reportDiagnostic(context, pluginDiagnostic(check, pluginRoot, problem));
+}
+/**
+* @description Reports several diagnostics at once: each warning on its own, then every error in one failure,
+* whose `meta.diagnostics` `ubd check` reads back, so a build names all its errors rather than the first.
+* @param context The hook's `this`.
+* @param found The diagnostics.
+*/
+function reportDiagnostics(context, found) {
+	const errors = found.filter((item) => item.severity === "error");
+	for (const item of found) if (item.severity === "warning") reportDiagnostic(context, item);
+	if (errors.length === 1 && errors[0]) reportDiagnostic(context, errors[0]);
+	if (errors.length > 1) context.error({
+		message: errors.map((item) => formatDiagnostic(item)).join("\n"),
+		meta: { diagnostics: errors }
+	});
+}
+// src/rollup/source-alias.ts
+const extensions = [
+	".tsx",
+	".ts",
+	".jsx",
+	".js",
+	".mjs",
+	".json"
+];
+const indexFiles = [
+	"index.tsx",
+	"index.ts",
+	"index.jsx",
+	"index.js"
+];
+function isFile(path) {
+	return existsSync(path) && statSync(path).isFile();
+}
+/**
+* @description Resolves a module path the way a bundler would, trying source extensions and then index files.
+* @param candidate An absolute path, with or without its extension.
+* @returns The file it resolves to, or `null` when none exists.
+*/
+function findFile(candidate) {
+	if (isFile(candidate)) return candidate;
+	for (const extension of extensions) if (isFile(`${candidate}${extension}`)) return `${candidate}${extension}`;
+	for (const indexFile of indexFiles) if (isFile(resolve(candidate, indexFile))) return resolve(candidate, indexFile);
+	return null;
+}
+/**
+* @description Resolves `~/` imports to a plugin's `src` directory, mirroring the `paths` in its tsconfig.
+* @param sourceRoot Absolute path of the plugin's `src` directory.
+* @returns The rollup plugin.
+*/
+function sourceAlias(sourceRoot) {
+	return {
+		name: "plugin-source-alias",
+		resolveId(source) {
+			if (!source.startsWith("~/")) return null;
+			return findFile(resolve(sourceRoot, source.slice(2)));
+		}
+	};
+}
+// ../api/testing/icu-parse.ts
+/** A syntax error in an ICU message; `position` is the 1-based character it stopped at. */
+var IcuSyntaxError = class extends Error {
+	position;
+	constructor(reason, position) {
+		super(`${reason} at character ${position}`);
+		this.position = position;
+	}
+};
+function isSpace(char) {
+	return char !== "" && char.trim() === "";
+}
+function fail(reader, reason) {
+	throw new IcuSyntaxError(reason, reader.index + 1);
+}
+function peek(reader) {
+	return reader.text[reader.index] ?? "";
+}
+function skipSpace(reader) {
+	while (isSpace(peek(reader))) reader.index++;
+}
+function readWord(reader) {
+	skipSpace(reader);
+	const start = reader.index;
+	while (reader.index < reader.text.length) {
+		const char = peek(reader);
+		if (isSpace(char) || char === "," || char === "{" || char === "}") break;
+		reader.index++;
+	}
+	return reader.text.slice(start, reader.index);
+}
+function expect(reader, char) {
+	skipSpace(reader);
+	if (peek(reader) !== char) fail(reader, `Expected "${char}"`);
+	reader.index++;
+}
+function readQuoted(reader, inPlural) {
+	const next = reader.text[reader.index + 1] ?? "";
+	if (next === "'") {
+		reader.index += 2;
+		return "'";
+	}
+	if (next !== "{" && next !== "}" && !(inPlural && next === "#")) {
+		reader.index++;
+		return "'";
+	}
+	let quoted = "";
+	reader.index++;
+	while (reader.index < reader.text.length) {
+		const char = peek(reader);
+		if (char === "'" && reader.text[reader.index + 1] === "'") {
+			quoted += "'";
+			reader.index += 2;
+		} else if (char === "'") {
+			reader.index++;
+			return quoted;
+		} else {
+			quoted += char;
+			reader.index++;
+		}
+	}
+	return quoted;
+}
+function readMessage(reader, nested, inPlural) {
+	const nodes = [];
+	let text = "";
+	function flush() {
+		if (text) nodes.push({
+			kind: "text",
+			text
+		});
+		text = "";
+	}
+	while (reader.index < reader.text.length) {
+		const char = peek(reader);
+		if (char === "'") text += readQuoted(reader, inPlural);
+		else if (char === "{") {
+			flush();
+			reader.index++;
+			nodes.push(readArgument(reader));
+		} else if (char === "}") {
+			if (!nested) fail(reader, "Unmatched \"}\"");
+			flush();
+			return nodes;
+		} else if (char === "#" && inPlural) {
+			flush();
+			nodes.push({ kind: "pound" });
+			reader.index++;
+		} else {
+			text += char;
+			reader.index++;
+		}
+	}
+	if (nested) fail(reader, "Unclosed \"{\"");
+	flush();
+	return nodes;
+}
+function readBranches(reader, inPlural) {
+	const branches = /* @__PURE__ */ new Map();
+	let offset = 0;
+	skipSpace(reader);
+	while (reader.index < reader.text.length && peek(reader) !== "}") {
+		const selector = readWord(reader);
+		if (!selector) fail(reader, "Expected a selector");
+		if (selector.startsWith("offset:")) offset = Number(selector.slice(7));
+		else {
+			expect(reader, "{");
+			branches.set(selector, readMessage(reader, true, inPlural));
+			expect(reader, "}");
+		}
+		skipSpace(reader);
+	}
+	return {
+		branches,
+		offset
+	};
+}
+function readStyle(reader) {
+	const start = reader.index;
+	let depth = 0;
+	while (reader.index < reader.text.length) {
+		const char = peek(reader);
+		if (char === "}" && depth === 0) return reader.text.slice(start, reader.index).trim();
+		if (char === "{") depth++;
+		if (char === "}") depth--;
+		reader.index++;
+	}
+	return fail(reader, "Unclosed argument");
+}
+function readArgument(reader) {
+	const name = readWord(reader);
+	if (!name) fail(reader, "Expected an argument name");
+	skipSpace(reader);
+	if (peek(reader) === "}") {
+		reader.index++;
+		return {
+			kind: "argument",
+			name,
+			type: "",
+			style: ""
+		};
+	}
+	expect(reader, ",");
+	const type = readWord(reader);
+	let node;
+	skipSpace(reader);
+	if (type === "plural" || type === "selectordinal") {
+		expect(reader, ",");
+		const { branches, offset } = readBranches(reader, true);
+		node = {
+			kind: "plural",
+			name,
+			ordinal: type === "selectordinal",
+			offset,
+			branches
+		};
+	} else if (type === "select") {
+		expect(reader, ",");
+		node = {
+			kind: "select",
+			name,
+			branches: readBranches(reader, false).branches
+		};
+	} else {
+		if (peek(reader) === ",") reader.index++;
+		node = {
+			kind: "argument",
+			name,
+			type,
+			style: readStyle(reader)
+		};
+	}
+	expect(reader, "}");
+	return node;
+}
+/**
+* @description Parses an ICU MessageFormat string: arguments, `number`/`date`/`time`, `plural`, `selectordinal`,
+* `select`, `#`, `offset:` and apostrophe quoting. The CLI's i18n typings and checks and the testing kit share it.
+* @param message The message, such as `{count, plural, one {# file} other {# files}}`.
+* @returns The message's nodes; throws an `IcuSyntaxError` naming the position of a syntax error.
+*/
+function parseIcu(message) {
+	return readMessage({
+		text: message,
+		index: 0
+	}, false, false);
+}
+// src/rollup/icu-arguments.ts
+const NUMERIC_TYPES = /* @__PURE__ */ new Set([
+	"number",
+	"spellout",
+	"ordinal",
+	"duration"
+]);
+const DATE_TYPES = /* @__PURE__ */ new Set(["date", "time"]);
+function merge(left, right) {
+	if (!left || left.kind === "any") return right;
+	if (right.kind === "any") return left;
+	if (left.kind === "select" && right.kind === "select") return {
+		kind: "select",
+		options: [.../* @__PURE__ */ new Set([...left.options, ...right.options])],
+		other: left.other || right.other
+	};
+	return left.kind === right.kind ? left : { kind: "any" };
+}
+function record(found, name, argument) {
+	found.set(name, merge(found.get(name), argument));
+}
+function argumentOf(node) {
+	if (NUMERIC_TYPES.has(node.type)) return { kind: "number" };
+	return DATE_TYPES.has(node.type) ? { kind: "date" } : { kind: "any" };
+}
+function collect(nodes, found, withoutOther) {
+	for (const node of nodes) {
+		if (node.kind === "text" || node.kind === "pound") continue;
+		if (node.kind === "argument") {
+			record(found, node.name, argumentOf(node));
+			continue;
+		}
+		const selectors = [...node.branches.keys()];
+		for (const branch of node.branches.values()) collect(branch, found, withoutOther);
+		if (!node.branches.has("other")) withoutOther.push(node.name);
+		record(found, node.name, node.kind === "select" ? {
+			kind: "select",
+			options: selectors.filter((selector) => selector !== "other"),
+			other: node.branches.has("other")
+		} : { kind: "number" });
+	}
+}
+/**
+* @description Lists the arguments an ICU MessageFormat string reads, nested branches included.
+* @param message The message, such as `{count, plural, one {# file} other {# files}}`.
+* @returns Each argument by name; throws naming the position of a syntax error.
+*/
+function readIcuArguments(message) {
+	return readIcuMessage(message).arguments;
+}
+/**
+* @description Reads an ICU MessageFormat string: the arguments it reads, and the branching ones that lack `other`.
+* @param message The message, such as `{count, plural, one {# file} other {# files}}`.
+* @returns Each argument by name, and the names of plural, selectordinal and select arguments without `other`.
+*/
+function readIcuMessage(message) {
+	const found = /* @__PURE__ */ new Map();
+	const withoutOther = [];
+	collect(parseIcu(message), found, withoutOther);
+	return {
+		arguments: found,
+		withoutOther
+	};
+}
+/**
+* @description Spells a string as a single-quoted TypeScript literal, as the repo's formatter writes it.
+* @param value The string.
+* @returns The literal, such as `'male'`.
+*/
+function typeLiteral(value) {
+	return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+}
+/**
+* @description Spells a property key the way the formatter leaves it: bare when it is an identifier, quoted otherwise.
+* @param key The key.
+* @returns The key as written in a type literal.
+*/
+function typeKey(key) {
+	return /^[A-Za-z_$][\w$]*$/.test(key) ? key : typeLiteral(key);
+}
+/**
+* @description Spells the TypeScript type `format` accepts for one argument.
+* @param argument The argument.
+* @returns The type, such as `number` or `'male' | 'female'`.
+*/
+function icuArgumentType(argument) {
+	if (argument.kind === "number") return "number";
+	if (argument.kind === "date") return "Date | number";
+	if (argument.kind === "any" || argument.options.length === 0) return "string | number";
+	return [...argument.options.map((option) => typeLiteral(option)), ...argument.other ? ["(string & {})"] : []].join(" | ");
+}
+// src/rollup/build-report-schema.ts
+const count = Type.Integer({ minimum: 0 });
+const counts = Type.Record(Type.String(), count, { additionalProperties: false });
+const reportSectionSchema = Type.Union([
+	Type.Literal("inlined"),
+	Type.Literal("shipped"),
+	Type.Literal("metro")
+]);
+/** What one feature plugin adds to the build report. Entries with the same section and label merge into one line. */
+const reportEntrySchema = Type.Object({
+	section: reportSectionSchema,
+	label: Type.String(),
+	/** Show how many entries merged, as `(3 <unit>s)`, or `(3)` for `''`. */
+	unit: Type.Optional(Type.String()),
+	/** Bytes this entry adds; merged entries sum them. */
+	bytes: Type.Optional(count),
+	/** Counts this entry under a kind, such as `keyed` or `uncached`. */
+	tally: Type.Optional(Type.String()),
+	/** Where the entry comes from, such as `src/index.tsx:12`. */
+	location: Type.Optional(Type.String()),
+	/** Names this entry in the `ubd dev` summary, such as `uncached filter`. */
+	issue: Type.Optional(Type.String())
+});
+/** One line of a report section: every contribution with the same section and label, merged. */
+const reportGroupSchema = Type.Object({
+	label: Type.String(),
+	/** When set, the line shows how many contributions it merged, as `(3 <unit>s)`, or `(3)` for `''`. */
+	unit: Type.Optional(Type.String()),
+	items: count,
+	bytes: count,
+	/** Contributions counted by kind, such as `{ keyed: 9, uncached: 1 }`. */
+	tallies: counts,
+	/** Where each located contribution came from, such as `src/index.tsx:12`. */
+	locations: Type.Array(Type.String()),
+	/** Contributions `ubd dev` names in its one-line summary, counted by noun, such as `uncached filter`. */
+	issues: counts
+});
+const budgetNameSchema = Type.Union([Type.Literal("bundle"), Type.Literal("assets")]);
+const reportWarningSchema = Type.Union([Type.Object({
+	kind: Type.Literal("budget"),
+	budget: budgetNameSchema,
+	bytes: count,
+	limit: count
+}), Type.Object({
+	kind: Type.Literal("shim"),
+	library: Type.String(),
+	modules: Type.Array(Type.String())
+})]);
+/** What `ubd build` reports for one plugin, written by the preset's `build-report` plugin. */
+const buildReportSchema = Type.Object({
+	name: Type.String(),
+	version: Type.String(),
+	bundle: Type.Object({
+		file: Type.String(),
+		bytes: count,
+		gzip: count,
+		bytecode: Type.Array(Type.Object({
+			version: Type.Integer(),
+			bytes: count
+		}))
+	}),
+	inlined: Type.Array(reportGroupSchema),
+	shipped: Type.Array(reportGroupSchema),
+	metro: Type.Array(reportGroupSchema),
+	/** The largest source modules by rendered size, before minification. */
+	modules: Type.Array(Type.Object({
+		id: Type.String(),
+		bytes: count
+	})),
+	/** Each budget's limit in bytes. */
+	budgets: Type.Object({
+		bundle: count,
+		assets: count
+	}),
+	warnings: Type.Array(reportWarningSchema)
+});
+// src/rollup/report-line.ts
+/** Report entries ride the bundle as assets under this folder; the `build-report` plugin removes them before the write. */
+const REPORT_ENTRY_FOLDER = ".unbound-report/";
+let emitted = 0;
+/**
+* @description Wraps a report entry as an asset to pass to `this.emitFile`, from any hook up to `generateBundle`.
+* @param entry The line to add.
+* @returns The asset carrying the entry.
+* @example this.emitFile(reportLine({ section: 'inlined', label: 'svg', unit: '', bytes: xml.length }));
+*/
+function reportLine(entry) {
+	emitted += 1;
+	return {
+		type: "asset",
+		fileName: `${REPORT_ENTRY_FOLDER}${emitted}.json`,
+		source: JSON.stringify(entry)
+	};
+}
+/**
+* @description Removes every report entry from the bundle, so none is written to `dist`.
+* @param bundle The output bundle, in `generateBundle`.
+* @param warn Reports an entry that is not a valid {@link ReportEntry}, which is dropped.
+* @returns The entries, in emit order.
+*/
+function takeReportEntries(bundle, warn) {
+	const entries = [];
+	for (const [fileName, file] of Object.entries(bundle)) {
+		if (!fileName.startsWith(".unbound-report/") || file.type !== "asset") continue;
+		const entry = JSON.parse(String(file.source));
+		delete bundle[fileName];
+		if (Value.Check(reportEntrySchema, entry)) entries.push(entry);
+		else warn(`Failed to read the build report entry ${fileName}: it is not a reportLine entry.`);
+	}
+	return entries;
+}
+/**
+* @description Merges entries with the same section and label into one report line each, in first-seen order.
+* @param entries The entries.
+* @param section The section to merge.
+* @returns The section's lines.
+*/
+function mergeEntries(entries, section) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (entry.section !== section) continue;
+		const group = groups.get(entry.label) ?? {
+			label: entry.label,
+			items: 0,
+			bytes: 0,
+			tallies: {},
+			locations: [],
+			issues: {}
+		};
+		group.items += 1;
+		group.bytes += entry.bytes ?? 0;
+		group.unit ??= entry.unit;
+		if (entry.tally) group.tallies[entry.tally] = (group.tallies[entry.tally] ?? 0) + 1;
+		if (entry.location) group.locations.push(entry.location);
+		if (entry.issue) group.issues[entry.issue] = (group.issues[entry.issue] ?? 0) + 1;
+		groups.set(entry.label, group);
+	}
+	return [...groups.values()];
+}
+// src/rollup/locales.ts
+/** The bare specifier a plugin imports its own messages from; the build resolves it to a generated module. */
+const LOCALE_MODULE = "@unbound-app/i18n";
+/**
+* Where `ubd build` and `ubd dev` write the ambient typings of {@link LOCALE_MODULE}, relative to the plugin.
+* It sits in `src/`, which every plugin tsconfig includes, so the editor finds it with no setup.
+*/
+const LOCALE_TYPINGS = "src/unbound-i18n.d.ts";
+const VIRTUAL_ID = "\0unbound-locales";
+const CHECK = "locales";
+/**
+* @description Names the en-US file whose presence turns a plugin's locale support on.
+* @param pluginRoot The plugin's directory.
+* @returns The absolute path of `i18n/en-US.json`.
+*/
+function sourceLocalePath(pluginRoot) {
+	return join(pluginRoot, LOCALES_DIRECTORY, `${SOURCE_LOCALE}.json`);
+}
+/**
+* @description Reads one locale file as a table of message keys to strings.
+* @param path The file's absolute path.
+* @returns The table; throws naming the file when it is not valid JSON or not an object of strings.
+*/
+function readTable(path) {
+	let value;
+	try {
+		value = JSON.parse(readFileSync(path, "utf8"));
+	} catch (error) {
+		throw new Error(`${path} is not valid JSON: ${error.message}`);
+	}
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${path} must be a JSON object of message keys to strings.`);
+	const table = {};
+	for (const [key, message] of Object.entries(value)) {
+		if (typeof message !== "string") throw new Error(`${path}: ${key} must be a string, not ${typeof message}.`);
+		table[key] = message;
+	}
+	return table;
+}
+function argumentsOf(path, key, message) {
+	try {
+		return readIcuArguments(message);
+	} catch (error) {
+		throw new Error(`${path}: ${key} is not valid ICU MessageFormat: ${error.message}.`);
+	}
+}
+function sameNames(left, right) {
+	return left.size === right.size && [...left.keys()].every((name) => right.has(name));
+}
+function names(found) {
+	return found.size ? [...found.keys()].map((name) => `{${name}}`).join(", ") : "none";
+}
+function readTranslation(path, code, source, warnings) {
+	const table = readTable(path);
+	const kept = {};
+	for (const [key, message] of Object.entries(table)) {
+		const expected = source[key];
+		if (expected === void 0) {
+			warnings.push({
+				file: `${LOCALES_DIRECTORY}/${code}.json`,
+				path: key,
+				message: `is not in ${SOURCE_LOCALE}.json, so it is left out`,
+				fix: `add it to ${SOURCE_LOCALE}.json, or remove it (ubd i18n --prune)`
+			});
+			continue;
+		}
+		const found = argumentsOf(path, key, message);
+		const wanted = argumentsOf(path, key, expected);
+		if (!sameNames(found, wanted)) warnings.push({
+			file: `${LOCALES_DIRECTORY}/${code}.json`,
+			path: key,
+			message: `has placeholders ${names(found)}, but ${SOURCE_LOCALE}.json has ${names(wanted)}`,
+			fix: `use the placeholders ${SOURCE_LOCALE}.json uses`
+		});
+		kept[key] = message;
+	}
+	const text = JSON.stringify(kept);
+	return {
+		text,
+		digest: createHash("sha256").update(text).digest("hex")
+	};
+}
+/**
+* @description Reads and validates a plugin's `i18n/` folder: every file must be a JSON object of strings in
+* valid ICU syntax, and en-US.json is required. Keys en-US lacks, and placeholders it disagrees on, are warnings.
+* @param pluginRoot The plugin's directory.
+* @returns The folder, or `undefined` when the plugin has none; throws naming the file that is invalid.
+*/
+function readLocaleFolder(pluginRoot) {
+	const directory = join(pluginRoot, LOCALES_DIRECTORY);
+	if (!existsSync(directory)) return;
+	const files = readdirSync(directory).filter((name) => name.endsWith(".json"));
+	if (files.length === 0) return;
+	const sourcePath = sourceLocalePath(pluginRoot);
+	if (!existsSync(sourcePath)) throw new Error(`${directory} has translations but no ${SOURCE_LOCALE}.json, which every plugin must ship.`);
+	const source = readTable(sourcePath);
+	const translations = /* @__PURE__ */ new Map();
+	const warnings = [];
+	for (const [key, message] of Object.entries(source)) argumentsOf(sourcePath, key, message);
+	for (const file of files.sort()) {
+		const code = file.slice(0, -5);
+		if (code === "en-US") continue;
+		if (!isLocaleCode(code)) throw new Error(`${join(directory, file)} is not named after a Discord locale code, such as de.json or pt-BR.json.`);
+		translations.set(code, readTranslation(join(directory, file), code, source, warnings));
+	}
+	return {
+		source,
+		translations,
+		warnings
+	};
+}
+function comment$1(message) {
+	return message.replaceAll("*/", "*\\/").replaceAll("\n", " ");
+}
+/**
+* @description Writes the typings of {@link LOCALE_MODULE} from en-US, as an ambient module declaration:
+* `messages` has its keys, and `format` takes each key's placeholders, typed from their ICU argument types.
+* @param source The en-US messages.
+* @returns The `.d.ts` source.
+*/
+function localeTypings(source) {
+	const messages = [];
+	const vars = [];
+	for (const [key, message] of Object.entries(source)) {
+		const name = typeKey(key);
+		const found = readIcuArguments(message);
+		messages.push(`\t\t/** ${comment$1(message)} */\n\t\treadonly ${name}: string;`);
+		if (found.size) {
+			const fields = [...found].map(([argument, type]) => `${typeKey(argument)}: ${icuArgumentType(type)}`);
+			vars.push(`\t\t${name}: { ${fields.join("; ")} };`);
+		}
+	}
+	return [
+		"// Generated by ubd from i18n/en-US.json. Do not edit: `ubd build` and `ubd dev` rewrite it.",
+		"",
+		`declare module '${LOCALE_MODULE}' {`,
+		"	/** Every en-US message, read in the user's locale. */",
+		`\texport type Messages = {\n${messages.join("\n")}\n\t};`,
+		"",
+		"	/** The placeholder values each message that has placeholders takes. */",
+		vars.length ? `\texport type FormatVars = {\n${vars.join("\n")}\n\t};` : "	export type FormatVars = Record<never, never>;",
+		"",
+		"	/** Each message in the user's locale, falling back to en-US. */",
+		"	export const messages: Messages;",
+		"	/** Formats a message that has no placeholders. */",
+		"	export function format(key: Exclude<keyof Messages, keyof FormatVars>): string;",
+		"	/** Formats a message, filling its placeholders from `vars`. */",
+		"	export function format<K extends keyof FormatVars>(key: K, vars: FormatVars[K]): string;",
+		"	/**",
+		"	 * Re-renders the component when the user's locale changes or its translation loads, and returns the locale code.",
+		"	 * The build adds it to components and hooks that read `messages` or `format`.",
+		"	 */",
+		"	export function useMessages(): string;",
+		"",
+		"	/** Every key of the plugin's en-US.json. */",
+		"	export type MessageKey = keyof Messages;",
+		"",
+		"	global {",
+		"		/** Gives the plugin's commands, toasts and dialogs its message keys. */",
+		"		// oxlint-disable-next-line typescript/consistent-type-definitions -- merging needs an interface.",
+		"		interface UnboundMessageKeys extends Record<MessageKey, true> {}",
+		"	}",
+		"}",
+		""
+	].join("\n");
+}
+/**
+* @description Rewrites `src/unbound-i18n.d.ts` from the plugin's en-US file, leaving the file alone when it is current.
+* @param pluginRoot The plugin's directory.
+* @returns Whether the file changed; `false` when the plugin has no en-US file. Throws when en-US is invalid.
+*/
+function writeLocaleTypings(pluginRoot) {
+	const sourcePath = sourceLocalePath(pluginRoot);
+	if (!existsSync(sourcePath)) return false;
+	const typings = localeTypings(readTable(sourcePath));
+	const path = join(pluginRoot, LOCALE_TYPINGS);
+	if (existsSync(path) && readFileSync(path, "utf8") === typings) return false;
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, typings);
+	return true;
+}
+/**
+* @description The source of {@link LOCALE_MODULE}: en-US inlined as the synchronous fallback, and the other
+* locales read from beside the installed bundle by the plugin's scoped `i18n.createLocales`.
+* @param source The en-US messages.
+* @returns The module's source.
+*/
+function localeModuleSource(source) {
+	return [
+		"import { i18n } from '@unbound-app/api';",
+		`const locales = i18n.createLocales(${JSON.stringify(source)});`,
+		"export const messages = locales.messages;",
+		"export const format = locales.format;",
+		"export const useMessages = locales.useMessages;"
+	].join("\n");
+}
+function importTarget(source, importer, pluginRoot) {
+	if (source.startsWith("~/")) return resolve(pluginRoot, "src", source.slice(2));
+	if (source.startsWith(".")) return resolve(dirname(importer), source);
+}
+function isInsideFolder(target, folder) {
+	return target === folder || dirname(target) === folder;
+}
+/**
+* @description Resolves {@link LOCALE_MODULE} to one generated module for the plugin being built, and refuses
+* an import of the `i18n/` folder or its files by path: a JSON file would put that language in the bundle.
+* @param pluginRoot The plugin's directory.
+* @returns The rollup plugin.
+*/
+function localeModule(pluginRoot) {
+	const folder = join(pluginRoot, LOCALES_DIRECTORY);
+	return {
+		name: "unbound-locale-module",
+		resolveId(source, importer) {
+			if (source === "@unbound-app/i18n") {
+				if (!existsSync(sourceLocalePath(pluginRoot))) reportProblem(this, CHECK, pluginRoot, {
+					file: importer ?? "i18n",
+					severity: "error",
+					message: `imports ${LOCALE_MODULE}, but the plugin has no ${LOCALES_DIRECTORY}/${SOURCE_LOCALE}.json`,
+					fix: `add ${LOCALES_DIRECTORY}/${SOURCE_LOCALE}.json beside src/, with every message key`
+				});
+				return VIRTUAL_ID;
+			}
+			const target = importer && importTarget(source, importer, pluginRoot);
+			if (!target || !isInsideFolder(target, folder)) return null;
+			reportProblem(this, CHECK, pluginRoot, {
+				file: importer ?? "",
+				severity: "error",
+				message: `imports ${source} by path, which would bundle its languages`,
+				fix: `import from '${LOCALE_MODULE}' instead: it inlines en-US and loads the rest on demand`
+			});
+			return null;
+		},
+		load(id) {
+			if (id !== VIRTUAL_ID) return null;
+			const sourcePath = sourceLocalePath(pluginRoot);
+			this.addWatchFile(sourcePath);
+			return localeModuleSource(readTable(sourcePath));
+		},
+		transform(code, id) {
+			if (id !== VIRTUAL_ID) return null;
+			this.emitFile(reportLine({
+				section: "inlined",
+				label: `${SOURCE_LOCALE} strings`,
+				bytes: Buffer.byteLength(code)
+			}));
+			return null;
+		}
+	};
+}
+/**
+* @description Validates the plugin's `i18n/` folder, writes the typings of {@link LOCALE_MODULE}, emits each
+* locale but en-US beside the bundle as `i18n/<code>.json`, and lists their SHA-256 under `locales` in the dist manifest.
+* @param pluginRoot The plugin's directory.
+* @returns The rollup plugin.
+*/
+function locales(pluginRoot) {
+	let folder;
+	return {
+		name: "unbound-locales",
+		buildStart() {
+			try {
+				folder = readLocaleFolder(pluginRoot);
+			} catch (error) {
+				reportProblem(this, CHECK, pluginRoot, {
+					file: LOCALES_DIRECTORY,
+					severity: "error",
+					message: error.message
+				});
+			}
+			if (!folder) return;
+			for (const warning of folder.warnings) reportProblem(this, CHECK, pluginRoot, {
+				...warning,
+				severity: "warning"
+			});
+			for (const file of readdirSync(join(pluginRoot, LOCALES_DIRECTORY))) {
+				if (!file.endsWith(".json")) continue;
+				this.addWatchFile(join(pluginRoot, LOCALES_DIRECTORY, file));
+			}
+			writeLocaleTypings(pluginRoot);
+		},
+		generateBundle(_options, bundle) {
+			const manifest = bundle["manifest.json"];
+			if (!folder?.translations.size || manifest?.type !== "asset") return;
+			const parsed = JSON.parse(String(manifest.source));
+			const digests = {};
+			for (const [code, { text, digest }] of folder.translations) {
+				digests[code] = digest;
+				this.emitFile({
+					type: "asset",
+					fileName: getLocalePath(parsed.main, code),
+					source: text
+				});
+			}
+			manifest.source = `${JSON.stringify({
+				...parsed,
+				locales: digests
+			}, null, "	")}\n`;
+		}
+	};
+}
+// src/rollup/byte-size.ts
+const UNITS = {
+	b: 1,
+	kb: 1024,
+	mb: 1048576
+};
+const SIZE = /^(\d+(?:\.\d+)?)\s*(b|kb|mb)?$/i;
+/**
+* @description Reads a budget size such as `50kb` as bytes.
+* @param size The size, in bytes or with a `b`, `kb` or `mb` unit.
+* @returns The size in bytes.
+*/
+function parseByteSize(size) {
+	if (typeof size === "number") return size;
+	const match = SIZE.exec(size.trim());
+	if (!match) throw new Error(`"${size}" is not a size. Write bytes, or a number with b, kb or mb.`);
+	const unit = match[2]?.toLowerCase() ?? "b";
+	return Math.round(Number(match[1]) * UNITS[unit]);
+}
+/**
+* @description Renders a byte count for the build report, such as `18.4 KB`.
+* @param bytes The size in bytes.
+* @returns The size with one decimal and its unit.
+*/
+function formatBytes(bytes) {
+	if (bytes < UNITS.kb) return `${bytes} B`;
+	if (bytes < UNITS.mb) return `${(bytes / UNITS.kb).toFixed(1)} KB`;
+	return `${(bytes / UNITS.mb).toFixed(1)} MB`;
+}
+// ../client/scripts/build/shim-libraries.ts
+/** Each library in Discord's bundle the client shims, by package name, with the props that find its entry module. */
+var shim_libraries_default = {
+	"@gorhom/bottom-sheet": [
+		"BottomSheetModal",
+		"BottomSheetView",
+		"useBottomSheet"
+	],
+	"@protobuf-ts/runtime": [
+		"BinaryReader",
+		"BinaryWriter",
+		"MessageType"
+	],
+	"@react-native-clipboard/clipboard": ["useClipboard", "default"],
+	"@react-native-community/netinfo": [
+		"NetInfoStateType",
+		"useNetInfo",
+		"configure"
+	],
+	"@react-navigation/elements": [
+		"HeaderBackButton",
+		"useHeaderHeight",
+		"getHeaderTitle"
+	],
+	"@react-navigation/native": [
+		"NavigationContainer",
+		"useNavigation",
+		"CommonActions"
+	],
+	"@react-navigation/native-stack": ["createNativeStackNavigator", "NativeStackView"],
+	"@react-navigation/stack": ["createStackNavigator", "CardStyleInterpolators"],
+	"@sentry/react-native": [
+		"captureException",
+		"withScope",
+		"wrap",
+		"init"
+	],
+	"@shopify/flash-list": ["FlashList", "MasonryFlashList"],
+	"base64-js": [
+		"toByteArray",
+		"fromByteArray",
+		"byteLength"
+	],
+	"big-integer": ["randBetween", "isInstance"],
+	buffer: [
+		"Buffer",
+		"SlowBuffer",
+		"kMaxLength"
+	],
+	"chroma-js": [
+		"scale",
+		"mix",
+		"contrast",
+		"temperature"
+	],
+	"date-fns": [
+		"format",
+		"addDays",
+		"differenceInDays",
+		"parseISO"
+	],
+	events: [
+		"EventEmitter",
+		"once",
+		"listenerCount"
+	],
+	lodash: [
+		"debounce",
+		"throttle",
+		"cloneDeep",
+		"chunk"
+	],
+	moment: [
+		"isMoment",
+		"duration",
+		"utc",
+		"locale"
+	],
+	pako: [
+		"inflate",
+		"deflate",
+		"Inflate",
+		"gzip"
+	],
+	punycode: [
+		"toASCII",
+		"toUnicode",
+		"ucs2"
+	],
+	qs: [
+		"parse",
+		"stringify",
+		"formats"
+	],
+	"react-native-gesture-handler": [
+		"GestureDetector",
+		"Gesture",
+		"GestureHandlerRootView"
+	],
+	"react-native-image-picker": ["launchImageLibrary", "launchCamera"],
+	"react-native-keyboard-controller": [
+		"KeyboardProvider",
+		"KeyboardController",
+		"useKeyboardHandler"
+	],
+	"react-native-nitro-modules": ["NitroModules", "getHybridObjectConstructor"],
+	"react-native-reanimated": [
+		"useSharedValue",
+		"useAnimatedStyle",
+		"ReduceMotion"
+	],
+	"react-native-safe-area-context": [
+		"SafeAreaProvider",
+		"useSafeAreaInsets",
+		"initialWindowMetrics"
+	],
+	"react-native-screens": [
+		"enableScreens",
+		"ScreenStack",
+		"enableFreeze"
+	],
+	"react-native-svg": [
+		"Svg",
+		"Path",
+		"SvgXml"
+	],
+	"react-native-url-polyfill": ["setupURLPolyfill"],
+	scheduler: [
+		"unstable_scheduleCallback",
+		"unstable_now",
+		"unstable_NormalPriority"
+	],
+	"simple-markdown": [
+		"parserFor",
+		"outputFor",
+		"defaultRules"
+	],
+	tinycolor2: [
+		"mostReadable",
+		"readability",
+		"fromRatio"
+	],
+	"ts-pattern": [
+		"match",
+		"P",
+		"isMatching"
+	],
+	uuid: [
+		"v4",
+		"v1",
+		"validate",
+		"NIL"
+	]
+};
+// src/rollup/build-report.ts
+/** The variable through which `ubd build` and `ubd dev` tell the preset where to write the report. */
+const BUILD_REPORT_ENV = "UNBOUND_BUILD_REPORT";
+const DEFAULT_BUDGET = {
+	bundle: "50kb",
+	assets: "500kb"
+};
+const TOP_MODULES = 5;
+const SHIPPED_UNITS = { i18n: "locale" };
+const manifestSchema = Type.Object({
+	main: Type.String(),
+	version: Type.Optional(Type.String()),
+	assets: Type.Optional(Type.Record(Type.String(), Type.Object({
+		type: Type.Union(ASSET_TYPES.map((type) => Type.Literal(type))),
+		scales: Type.Record(Type.String(), Type.String())
+	}))),
+	locales: Type.Optional(Type.Record(Type.String(), Type.String()))
+});
+const SHIPPED_LABELS = {
+	asset: ASSETS_DIRECTORY,
+	locale: LOCALES_DIRECTORY
+};
+const BYTECODE_FILE = /^(.+)\.(\d+)\.hbc$/;
+function sizeOf(file) {
+	if (file.type === "chunk") return Buffer.byteLength(file.code);
+	return typeof file.source === "string" ? Buffer.byteLength(file.source) : file.source.byteLength;
+}
+function stem(fileName) {
+	return fileName.replace(/\.[^.]+$/, "");
+}
+function cleanId(id) {
+	return id.replace(/^\0/, "").replace(/\?.*$/, "");
+}
+function displayId(id, pluginRoot) {
+	const path = cleanId(id);
+	const nodeModules = path.lastIndexOf("/node_modules/");
+	if (nodeModules !== -1) return path.slice(nodeModules + 1);
+	return isAbsolute(path) ? relative(pluginRoot, path) : path;
+}
+/**
+* @description Reads the package a bundled module belongs to from its path.
+* @param id The module id.
+* @returns The package name, such as `lodash` or `@scope/name`, when the module is in `node_modules`.
+*/
+function packageOf(id) {
+	const path = cleanId(id);
+	const nodeModules = path.lastIndexOf("/node_modules/");
+	if (nodeModules === -1) return;
+	const [first, second] = path.slice(nodeModules + 14).split("/");
+	return first?.startsWith("@") && second ? `${first}/${second}` : first;
+}
+function readManifest(bundle) {
+	const manifest = bundle["manifest.json"];
+	if (manifest?.type !== "asset") return;
+	const parsed = JSON.parse(String(manifest.source));
+	return Value.Check(manifestSchema, parsed) ? parsed : void 0;
+}
+function shippedEntries(bundle, entry, manifest) {
+	const entries = [];
+	const listed = /* @__PURE__ */ new Set();
+	for (const file of manifest ? listAddonFiles(manifest) : []) {
+		const output = bundle[file.path];
+		listed.add(file.path);
+		if (!output) continue;
+		const label = SHIPPED_LABELS[file.kind];
+		entries.push({
+			section: "shipped",
+			label,
+			unit: SHIPPED_UNITS[label] ?? "",
+			bytes: sizeOf(output)
+		});
+	}
+	for (const file of Object.values(bundle)) {
+		const bytecode = BYTECODE_FILE.exec(file.fileName);
+		if (file === entry || listed.has(file.fileName) || file.fileName === "manifest.json" || bytecode?.[1] === stem(entry.fileName)) continue;
+		entries.push({
+			section: "shipped",
+			label: "files",
+			unit: "",
+			bytes: sizeOf(file)
+		});
+	}
+	return entries;
+}
+function bytecodeSizes(bundle, entry) {
+	return Object.values(bundle).map((file) => ({
+		match: BYTECODE_FILE.exec(file.fileName),
+		bytes: sizeOf(file)
+	})).filter(({ match }) => match?.[1] === stem(entry.fileName)).map(({ match, bytes }) => ({
+		version: Number(match?.[2]),
+		bytes
+	})).toSorted((a, b) => a.version - b.version);
+}
+function shimWarnings(entry, pluginRoot) {
+	const bundled = /* @__PURE__ */ new Map();
+	for (const id of Object.keys(entry.modules)) {
+		const library = packageOf(id);
+		if (!library || !Object.hasOwn(shim_libraries_default, library)) continue;
+		bundled.set(library, [...bundled.get(library) ?? [], displayId(id, pluginRoot)]);
+	}
+	return [...bundled].map(([library, modules]) => ({
+		kind: "shim",
+		library,
+		modules
+	}));
+}
+function budgetWarnings(sizes, budgets) {
+	return Object.keys(budgets).filter((budget) => sizes[budget] > budgets[budget]).map((budget) => ({
+		kind: "budget",
+		budget,
+		bytes: sizes[budget],
+		limit: budgets[budget]
+	}));
+}
+/**
+* @description Measures a written plugin bundle: its size, what features inlined into it, the files shipped beside it, and what breaks a budget.
+* @param bundle The output bundle, with the report entries already taken out.
+* @param entries The entries feature plugins contributed with `reportLine`.
+* @param options The plugin's directory and its budgets in bytes.
+* @returns The report, or `undefined` when the bundle has no entry chunk.
+*/
+function createReport(bundle, entries, { pluginRoot, budgets }) {
+	const entry = Object.values(bundle).find((file) => file.type === "chunk" && file.isEntry);
+	if (!entry) return;
+	const bytes = sizeOf(entry);
+	const manifest = readManifest(bundle);
+	const shipped = mergeEntries([...shippedEntries(bundle, entry, manifest), ...entries], "shipped");
+	const assets = shipped.find((group) => group.label === "assets")?.bytes ?? 0;
+	const modules = Object.entries(entry.modules).map(([id, module]) => ({
+		id: displayId(id, pluginRoot),
+		bytes: module.renderedLength
+	})).toSorted((a, b) => b.bytes - a.bytes).slice(0, TOP_MODULES);
+	return {
+		name: basename(pluginRoot),
+		version: manifest?.version ?? "",
+		bundle: {
+			file: entry.fileName,
+			bytes,
+			gzip: gzipSync(entry.code).byteLength,
+			bytecode: bytecodeSizes(bundle, entry)
+		},
+		inlined: mergeEntries(entries, "inlined"),
+		shipped,
+		metro: mergeEntries(entries, "metro"),
+		modules,
+		budgets,
+		warnings: [...budgetWarnings({
+			bundle: bytes,
+			assets
+		}, budgets), ...shimWarnings(entry, pluginRoot)]
+	};
+}
+/**
+* @description Collects the entries feature plugins add with `reportLine`, keeps them out of `dist`, and writes the build report after the bundle is written.
+* @param options The plugin's directory, its budgets, and where to write the report.
+* @returns The rollup plugin. Its `generateBundle` runs last, so it sees the bytecode and every emitted file.
+*/
+function buildReport({ pluginRoot, budget = {}, reportFile }) {
+	const budgets = {
+		bundle: parseByteSize(budget.bundle ?? DEFAULT_BUDGET.bundle),
+		assets: parseByteSize(budget.assets ?? DEFAULT_BUDGET.assets)
+	};
+	let entries = [];
+	return {
+		name: "build-report",
+		generateBundle: {
+			order: "post",
+			handler(_options, bundle) {
+				entries = takeReportEntries(bundle, (message) => this.warn(message));
+			}
+		},
+		async writeBundle(_options, bundle) {
+			if (!reportFile) return;
+			const report = createReport(bundle, entries, {
+				pluginRoot,
+				budgets
+			});
+			if (report) await writeFile(reportFile, JSON.stringify(report));
+		}
+	};
+}
+// src/rollup/output-only.ts
+/** The `api` flag on a plugin that only wraps, minifies or compiles the chunk, so `ubd check` renders without it. */
+const OUTPUT_ONLY = "unboundOutputOnly";
+/**
+* @description Marks a plugin as output-only: `ubd check` leaves it out when it renders the chunk for the plugins that check it.
+* @param plugin The plugin.
+* @returns A copy carrying the flag in its `api`.
+*/
+function outputOnly(plugin) {
+	return {
+		...plugin,
+		api: {
+			...plugin.api,
+			[OUTPUT_ONLY]: true
+		}
+	};
+}
+// ../contracts/src/settings-schema.ts
+const BUILDERS$1 = "setting.boolean/number/integer/string/choice/array/section/button/notice from '@unbound-app/settings/schema'";
+const ENTITIES = [
+	"user",
+	"channel",
+	"guild",
+	"role"
+];
+const COMMON = [
+	"kind",
+	"displayAs",
+	"title",
+	"subtitle",
+	"hidden",
+	"requiresRestart",
+	"visibleWhen",
+	"disabledWhen",
+	"default"
+];
+const TYPEBOX = /* @__PURE__ */ new Set([
+	"type",
+	"anyOf",
+	"items",
+	"required",
+	"properties",
+	"additionalProperties",
+	"$schema",
+	"$id"
+]);
+const SPEC = {
+	boolean: {
+		displays: ["switch", "checkbox"],
+		keys: []
+	},
+	number: {
+		displays: [
+			"input",
+			"slider",
+			"stepper",
+			"duration"
+		],
+		keys: [
+			"minimum",
+			"maximum",
+			"multipleOf",
+			"units"
+		]
+	},
+	integer: {
+		displays: [
+			"input",
+			"slider",
+			"stepper",
+			"duration"
+		],
+		keys: [
+			"minimum",
+			"maximum",
+			"multipleOf",
+			"units"
+		]
+	},
+	string: {
+		displays: [
+			"input",
+			"multiline",
+			"secret",
+			"url",
+			"color",
+			"image",
+			"font",
+			"emoji",
+			...ENTITIES
+		],
+		keys: [
+			"minLength",
+			"maxLength",
+			"placeholder",
+			"alpha",
+			"presets",
+			"palette",
+			"maxSize"
+		]
+	},
+	choice: {
+		displays: [
+			"radio",
+			"picker",
+			"segmented"
+		],
+		keys: ["options"]
+	},
+	array: {
+		displays: [
+			"list",
+			"checkboxes",
+			...ENTITIES
+		],
+		keys: [
+			"of",
+			"minItems",
+			"maxItems"
+		]
+	},
+	button: {
+		displays: ["button", "danger"],
+		keys: ["action", "confirm"]
+	},
+	notice: {
+		displays: ["notice"],
+		keys: ["tone"]
+	}
+};
+const DISPLAY_KEYS = {
+	minLength: ["input", "multiline"],
+	maxLength: ["input", "multiline"],
+	placeholder: [
+		"input",
+		"multiline",
+		"secret",
+		"url"
+	],
+	alpha: ["color"],
+	presets: ["color"],
+	palette: ["color"],
+	maxSize: ["image"],
+	units: ["duration"]
+};
+const SNOWFLAKE = /^\d{17,20}$/;
+const URL_PATTERN = /^https?:\/\/[^\s/$.?#][^\s]*$/i;
+const EMOJI = /^[^\s:]+(?::\d{17,20})?$/;
+function textOf(value) {
+	return typeof value === "string" ? value : JSON.stringify(value) ?? "nothing";
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* @description Tells a nested settings section from a setting or action.
+* @param node A property of a settings schema.
+* @returns Whether it is a section.
+*/
+function isSettingsGroup(node) {
+	return node.kind === "section";
+}
+/**
+* @description Tells an action from a stored setting.
+* @param node A property of a settings schema or section.
+* @returns Whether it is an action.
+*/
+function isButton(node) {
+	return node.kind === "button";
+}
+/**
+* @description Tells a notice from a stored setting or an action.
+* @param node A property of a settings schema or section.
+* @returns Whether it is a notice.
+*/
+function isNotice(node) {
+	return node.kind === "notice";
+}
+/**
+* @description Tells a stored setting from a row that stores nothing, a button or a notice.
+* @param node A property of a settings schema or section.
+* @returns Whether it is a stored setting.
+*/
+function isStored(node) {
+	return !isButton(node) && !isNotice(node);
+}
+/**
+* @description Tells an http or https URL, as a `displayAs: 'url'` setting holds.
+* @param value The text.
+* @returns Whether it is one.
+*/
+function isHttpUrl(value) {
+	return URL_PATTERN.test(value);
+}
+/**
+* @description Tells a Discord id, as an entity setting holds.
+* @param value The text.
+* @returns Whether it is one.
+*/
+function isSnowflake(value) {
+	return SNOWFLAKE.test(value);
+}
+function isEntityDisplay(display) {
+	return ENTITIES.includes(display);
+}
+function isMultiple(value, step) {
+	const ratio = value / step;
+	return Math.abs(ratio - Math.round(ratio)) < 1e-9;
+}
+function isStringValue(field, value) {
+	const within = value.length >= (field.minLength ?? 0) && value.length <= (field.maxLength ?? Infinity);
+	switch (field.displayAs) {
+		case "color": return (field.alpha ? /^#[0-9a-f]{6}(?:[0-9a-f]{2})?$/i : /^#[0-9a-f]{6}$/i).test(value);
+		case "url": return within && (value === "" || isHttpUrl(value));
+		case "emoji": return value === "" || EMOJI.test(value);
+		case "user":
+		case "channel":
+		case "guild":
+		case "role": return value === "" || isSnowflake(value);
+		default: return within;
+	}
+}
+function isItemValue(field, value) {
+	switch (field.kind) {
+		case "boolean": return typeof value === "boolean";
+		case "string": return typeof value === "string" && isStringValue(field, value);
+		case "choice": return field.options.some((choice) => choice.const === value);
+		case "array": {
+			const display = field.displayAs;
+			const item = field.of.kind === "string" && isEntityDisplay(display) ? {
+				...field.of,
+				displayAs: display
+			} : field.of;
+			return Array.isArray(value) && value.length >= (field.minItems ?? 0) && value.length <= (field.maxItems ?? Infinity) && new Set(value).size === value.length && value.every((each) => isItemValue(item, each));
+		}
+		default: return typeof value === "number" && Number.isFinite(value) && (field.kind !== "integer" || Number.isInteger(value)) && value >= (field.minimum ?? -Infinity) && value <= (field.maximum ?? Infinity) && (field.multipleOf === void 0 || isMultiple(value, field.multipleOf));
+	}
+}
+/**
+* @description Checks a value against one setting, by its primitive and display: the same check at build time (each default) and on device (each stored value and write).
+* @param field The setting.
+* @param value The value.
+* @returns Whether the setting can hold it.
+*/
+function isSettingValue(field, value) {
+	return isItemValue(field, value);
+}
+function issue(reader, path, problem, fix) {
+	reader.issues.push({
+		path,
+		problem,
+		fix
+	});
+}
+function readLabels(node, path, reader) {
+	for (const key of [
+		"title",
+		"subtitle",
+		"confirm",
+		"placeholder"
+	]) if (node[key] !== void 0 && typeof node[key] !== "string") issue(reader, path, `has a non-string \`${key}\``, "set it to a message key");
+	if (node.hidden !== true && typeof node.title !== "string") issue(reader, path, "has no title", "add `title: <message key>`, or `hidden: true`");
+	for (const key of ["visibleWhen", "disabledWhen"]) {
+		const condition = node[key];
+		if (condition === void 0) continue;
+		if (typeof condition === "string") reader.conditions.push([
+			path,
+			key,
+			condition
+		]);
+		else if (!isObject(condition) || condition.predicate !== true) issue(reader, `${path}.${key}`, "is not a predicate or a key", "write `(settings) => boolean` or a boolean setting key");
+	}
+}
+function readChoices(node, path, reader) {
+	const options = Array.isArray(node.options) ? node.options : [];
+	if (options.length === 0) issue(reader, path, "has no options", "add at least one entry to `options`");
+	if (!options.every((choice) => isObject(choice) && typeof choice.const === "string" && typeof choice.title === "string")) issue(reader, path, "has an option without a message key", "map each option to a key or { title, subtitle }");
+	if (node.displayAs === "segmented" && options.length > 4) issue(reader, path, `shows ${options.length} options as segmented, which fits at most 4`, "use displayAs: 'radio' or 'picker'");
+}
+function readDisplay(node, path, reader) {
+	const display = textOf(node.displayAs);
+	for (const [key, displays] of Object.entries(DISPLAY_KEYS)) if (node[key] !== void 0 && !displays.includes(display)) issue(reader, path, `sets \`${key}\`, which only displayAs ${displays.map((name) => `'${name}'`).join("/")} takes`, `remove \`${key}\` or change displayAs`);
+	if (display === "slider" && (node.minimum === void 0 || node.maximum === void 0)) issue(reader, path, "shows as a slider without both `min` and `max`", "set both, or use displayAs: 'input'");
+	if (node.palette === true && !Array.isArray(node.presets)) issue(reader, path, "sets `palette` without `presets`", "add `presets`");
+	if (node.kind === "choice") readChoices(node, path, reader);
+	if (node.kind === "array") {
+		const of = isObject(node.of) ? node.of : {};
+		const choice = of.kind === "choice";
+		if (of.kind !== "string" && !choice) issue(reader, path, "holds items that are not strings or choices", "set `of: setting.string()` or `of: setting.choice(...)`");
+		else if (choice !== (display === "checkboxes")) issue(reader, path, `shows ${choice ? "choices" : "strings"} as '${display}'`, choice ? "use displayAs: 'checkboxes'" : "use displayAs: 'list' or an entity picker");
+		if (choice) readChoices(of, path, reader);
+	}
+	if (node.kind === "notice" && ![
+		"info",
+		"warning",
+		"danger"
+	].includes(textOf(node.tone))) issue(reader, path, `has the tone ${textOf(node.tone)}`, "set `tone` to 'info', 'warning' or 'danger'");
+	if (node.kind === "button" && (typeof node.action !== "string" || !node.action)) issue(reader, path, "has no `action`", "set `action: '<name of an export of src/actions.ts>'`");
+}
+function copy(node, keys) {
+	return Object.fromEntries(Object.entries(node).filter(([key]) => keys.includes(key)));
+}
+function readField(node, path, reader) {
+	const spec = isObject(node) && typeof node.kind === "string" ? SPEC[node.kind] : void 0;
+	if (!isObject(node) || !spec) {
+		issue(reader, path, "is not built with a setting builder", `use ${BUILDERS$1}`);
+		return;
+	}
+	for (const key of Object.keys(node)) if (!COMMON.includes(key) && !spec.keys.includes(key) && !TYPEBOX.has(key)) issue(reader, path, `has the unsupported \`${key}\` option`, "remove it");
+	if (!spec.displays.includes(textOf(node.displayAs))) {
+		issue(reader, path, `cannot show as '${textOf(node.displayAs)}'`, `use displayAs ${spec.displays.map((name) => `'${name}'`).join(", ")}`);
+		return;
+	}
+	readLabels(node, path, reader);
+	readDisplay(node, path, reader);
+	const kept = copy(node, [...COMMON, ...spec.keys]);
+	if (isObject(kept.of)) kept.of = copy(kept.of, [
+		"kind",
+		"displayAs",
+		"options",
+		...SPEC.string?.keys ?? []
+	]);
+	const field = kept;
+	if (!isStored(field)) return field;
+	if (field.kind === "boolean") reader.booleans.add(path);
+	if (!isSettingValue(field, node.default)) issue(reader, path, `has the default ${JSON.stringify(node.default)}, which its own display or constraints reject`, "change the default or the constraints");
+	return field;
+}
+function readProperties(node, path, reader, visit) {
+	for (const [key, child] of Object.entries(isObject(node.properties) ? node.properties : {})) {
+		const at = path ? `${path}.${key}` : key;
+		if (key.includes(".")) {
+			issue(reader, at, "has a dot in its key", "rename it");
+			continue;
+		}
+		visit(key, child, at);
+	}
+}
+function readGroup(node, path, reader) {
+	const properties = {};
+	readLabels(node, path, reader);
+	if (!["group", "collapsible"].includes(textOf(node.displayAs))) issue(reader, path, `cannot show as '${textOf(node.displayAs)}'`, "use displayAs 'group' or 'collapsible'");
+	readProperties(node, path, reader, (key, child, at) => {
+		if (isObject(child) && child.kind === "section") {
+			issue(reader, at, "nests a section inside a section", "move its settings into the outer section");
+			return;
+		}
+		const field = readField(child, at, reader);
+		if (field) properties[key] = field;
+	});
+	return {
+		...copy(node, COMMON),
+		properties
+	};
+}
+/**
+* @description Validates the JSON a plugin's `defineSettings(...)` evaluates to and copies the supported options out of it.
+* @param value The evaluated schema.
+* @returns The supported part of the schema, and every problem found, each naming its property.
+*/
+function readSettingsSchema(value) {
+	const reader = {
+		issues: [],
+		booleans: /* @__PURE__ */ new Set(),
+		conditions: []
+	};
+	const properties = {};
+	if (!isObject(value) || value.kind !== "settings") {
+		issue(reader, "", "does not default-export defineSettings(...)", "write `export default defineSettings({ ... })` with defineSettings from '@unbound-app/settings/schema'");
+		return {
+			schema: {
+				kind: "settings",
+				properties
+			},
+			issues: reader.issues
+		};
+	}
+	readProperties(value, "", reader, (key, child, at) => {
+		const node = isObject(child) && child.kind === "section" ? readGroup(child, at, reader) : readField(child, at, reader);
+		if (node) properties[key] = node;
+	});
+	for (const [path, key, condition] of reader.conditions) if (!reader.booleans.has(condition)) issue(reader, `${path}.${key}`, `names "${condition}", which is not a boolean setting`, "name a boolean setting by its dot-separated key, or write a predicate");
+	return {
+		schema: {
+			kind: "settings",
+			...typeof value.title === "string" ? { title: value.title } : {},
+			properties
+		},
+		issues: reader.issues
+	};
+}
+// src/rollup/predicate-scope.ts
+/** Globals a predicate may read: pure built-ins. */
+const SAFE_GLOBALS = /* @__PURE__ */ new Set([
+	"undefined",
+	"NaN",
+	"Infinity",
+	"Boolean",
+	"Number",
+	"String",
+	"Math",
+	"Array",
+	"Object",
+	"JSON",
+	"isNaN",
+	"isFinite",
+	"parseInt",
+	"parseFloat"
+]);
+const TYPE_FIELDS = /* @__PURE__ */ new Set([
+	"typeAnnotation",
+	"returnType",
+	"typeParameters",
+	"typeArguments"
+]);
+const IMPURE = {
+	AssignmentExpression: "assigns a variable",
+	UpdateExpression: "assigns a variable",
+	ThisExpression: "reads `this`",
+	NewExpression: "constructs an object",
+	ImportExpression: "imports a module",
+	AwaitExpression: "awaits",
+	YieldExpression: "yields"
+};
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof Reflect.get(value, "type") === "string";
+}
+function children(node) {
+	const found = [];
+	for (const [field, value] of Object.entries(node)) {
+		if (TYPE_FIELDS.has(field)) continue;
+		for (const item of Array.isArray(value) ? value : [value]) if (isNode(item)) found.push([field, item]);
+	}
+	return found;
+}
+function walk(node, visit, parent, field = "") {
+	visit(node, parent, field);
+	for (const [childField, child] of children(node)) walk(child, visit, node, childField);
+}
+function declaredNames(fn) {
+	const names = /* @__PURE__ */ new Set();
+	walk(fn, (node) => {
+		if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
+			for (const param of node.params) if (param.type === "Identifier") names.add(param.name);
+		}
+		if (node.type === "VariableDeclarator" && node.id.type === "Identifier") names.add(node.id.name);
+	});
+	return names;
+}
+function isReference(parent, field) {
+	if (parent?.type === "MemberExpression") return field !== "property" || parent.computed;
+	if (parent?.type === "Property") return field !== "key" || parent.computed;
+	return !(parent?.type === "VariableDeclarator" && field === "id" || (parent?.type === "ArrowFunctionExpression" || parent?.type === "FunctionExpression") && field === "params");
+}
+/**
+* @description Checks that a `visibleWhen` or `disabledWhen` predicate can be lifted into the plugin bundle on its own:
+* it reads only its parameter, its own locals and pure built-ins, and assigns, constructs and imports nothing.
+* @param fn The predicate's function node.
+* @returns Every problem, each at its offset in the schema file.
+*/
+function checkPredicate(fn) {
+	if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression") return [{
+		offset: fn.start,
+		problem: "is not a function",
+		fix: "write `(settings) => boolean` inline"
+	}];
+	const names = declaredNames(fn);
+	const problems = [];
+	walk(fn, (node, parent, field) => {
+		const impure = IMPURE[node.type];
+		if (impure) {
+			problems.push({
+				offset: node.start,
+				problem: impure,
+				fix: "keep the predicate pure: read `settings` and return a boolean"
+			});
+			return;
+		}
+		if (node.type !== "Identifier" || !isReference(parent, field)) return;
+		if (!names.has(node.name) && !SAFE_GLOBALS.has(node.name)) problems.push({
+			offset: node.start,
+			problem: `reads outer variable "${node.name}"`,
+			fix: "read only the predicate's `settings` parameter; the predicate runs in the plugin bundle without settings.ts"
+		});
+	});
+	return problems;
+}
+// src/rollup/settings-source.ts
+const CONDITIONS = /* @__PURE__ */ new Set(["visibleWhen", "disabledWhen"]);
+/**
+* @description Lists the offset each line of a source starts at, for {@link toLocation}.
+* @param source The source.
+* @returns The offsets.
+*/
+function lineStarts(source) {
+	const starts = [0];
+	for (let i = 0, len = source.length; i < len; i++) if (source[i] === "\n") starts.push(i + 1);
+	return starts;
+}
+/**
+* @description Turns an offset into a line and column.
+* @param starts The source's {@link lineStarts}.
+* @param offset The offset.
+* @returns The 1-based line and column.
+*/
+function toLocation(starts, offset) {
+	const line = Math.max(0, starts.findLastIndex((start) => start <= offset));
+	return {
+		line: line + 1,
+		column: offset - (starts[line] ?? 0) + 1
+	};
+}
+function keyName(property) {
+	if (property.type !== "Property") return;
+	if (property.key.type === "Identifier") return property.key.name;
+	return property.key.type === "Literal" && typeof property.key.value === "string" ? property.key.value : void 0;
+}
+function unwrap(node) {
+	let current = node;
+	while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
+function objectArgument(node, index) {
+	const argument = node?.type === "CallExpression" ? node.arguments[index] : void 0;
+	return argument?.type === "ObjectExpression" ? argument : void 0;
+}
+function rootObject(program) {
+	const exported = program.body.find((node) => node.type === "ExportDefaultDeclaration");
+	if (!exported) return;
+	let call = exported.declaration;
+	if (call.type === "Identifier") {
+		const name = call.name;
+		call = program.body.flatMap((node) => node.type === "VariableDeclaration" ? node.declarations : []).find((node) => node.id.type === "Identifier" && node.id.name === name)?.init;
+	}
+	return {
+		start: exported.start,
+		object: objectArgument(call, 0)
+	};
+}
+/**
+* @description Reads settings.ts's syntax: where each property is written, and the source of each predicate, checked to be liftable.
+* @param fileName The schema file's name, for the parser.
+* @param source The schema file's source.
+* @returns The offsets, predicates and problems.
+*/
+function readSettingsSource(fileName, source) {
+	const { program } = parseSync(fileName, source, { lang: "ts" });
+	const result = {
+		offsets: /* @__PURE__ */ new Map(),
+		predicates: [],
+		problems: [],
+		starts: lineStarts(source)
+	};
+	const root = rootObject(program);
+	if (!root) return result;
+	result.offsets.set("", root.start);
+	function visitOptions(options, path) {
+		for (const property of options?.properties ?? []) {
+			const option = keyName(property);
+			if (property.type !== "Property" || !option || !CONDITIONS.has(option)) continue;
+			const fn = unwrap(property.value);
+			if (fn.type === "Literal" || fn.type === "TemplateLiteral") continue;
+			const problems = checkPredicate(fn);
+			result.offsets.set(`${path}.${option}`, property.start);
+			result.problems.push(...problems.map((problem) => ({
+				...problem,
+				path: `${path}.${option}`
+			})));
+			if (!problems.length) result.predicates.push({
+				path,
+				option: option === "visibleWhen" ? "visibleWhen" : "disabledWhen",
+				source: source.slice(fn.start, fn.end)
+			});
+		}
+	}
+	function visit(object, prefix) {
+		for (const property of object?.properties ?? []) {
+			const key = keyName(property);
+			if (!key || property.type !== "Property") continue;
+			const path = prefix ? `${prefix}.${key}` : key;
+			result.offsets.set(path, property.start);
+			visitOptions(objectArgument(property.value, 0), path);
+			if (!prefix) visit(objectArgument(property.value, 1), path);
+		}
+	}
+	visit(root.object, "");
+	return result;
+}
+/**
+* @description Reads the named exports of a plugin's `src/actions.ts`, and which of them are functions: a function declaration, or a const bound to a function.
+* @param fileName The file's name, for the parser.
+* @param source The file's source.
+* @returns Each export's name, and whether it is a function.
+*/
+function readActionExports(fileName, source) {
+	const { program } = parseSync(fileName, source);
+	const exports = /* @__PURE__ */ new Map();
+	for (const node of program.body) {
+		if (node.type !== "ExportNamedDeclaration" || node.exportKind === "type") continue;
+		const { declaration } = node;
+		if (declaration?.type === "FunctionDeclaration" && declaration.id) exports.set(declaration.id.name, true);
+		if (declaration?.type === "VariableDeclaration") for (const declarator of declaration.declarations) {
+			const init = declarator.init ? unwrap(declarator.init) : void 0;
+			if (declarator.id.type === "Identifier") exports.set(declarator.id.name, init?.type === "ArrowFunctionExpression" || init?.type === "FunctionExpression");
+		}
+		for (const spec of node.specifiers) {
+			const name = spec.exported.type === "Identifier" ? spec.exported.name : String(spec.exported.value);
+			if (!exports.has(name)) exports.set(name, false);
+		}
+	}
+	return exports;
+}
+// src/rollup/settings-read.ts
+const SOURCE_MESSAGES = "i18n/en-US.json";
+/** A plugin's settings schema file, beside `src/`. */
+const SETTINGS_FILE = "settings.ts";
+/** The runtime module plugin source reads its settings from. */
+const SETTINGS_MODULE = "@unbound-app/settings";
+/** The build-time module `settings.ts` imports its builders from; it exists only while the build evaluates the file. */
+const SETTINGS_SCHEMA_MODULE = "@unbound-app/settings/schema";
+const BUILDERS = fileURLToPath(import.meta.resolve("@unbound-app/cli/settings/schema"));
+/**
+* @description Names a plugin's settings schema file.
+* @param pluginRoot The plugin's directory.
+* @returns The absolute path of `settings.ts`.
+*/
+function settingsPath(pluginRoot) {
+	return join(pluginRoot, SETTINGS_FILE);
+}
+/**
+* @description Bundles `settings.ts` in memory, resolving the builders module to the CLI's implementation, and imports it.
+* @param path The schema file.
+* @returns Its default export as JSON, and the files it was bundled from.
+*/
+async function evaluateSettings(path) {
+	const bundle = await rolldown({
+		input: path,
+		platform: "node",
+		logLevel: "silent",
+		plugins: [{
+			name: "unbound-settings-schema",
+			resolveId: (source) => source === "@unbound-app/settings/schema" ? BUILDERS : null
+		}]
+	});
+	try {
+		const { output } = await bundle.generate({ format: "esm" });
+		const module = await import(`data:text/javascript;base64,${Buffer.from(output[0].code).toString("base64")}`);
+		const watchFiles = (await bundle.watchFiles).filter((file) => file !== BUILDERS);
+		return {
+			value: JSON.parse(JSON.stringify(module.default ?? null)),
+			watchFiles
+		};
+	} finally {
+		await bundle.close();
+	}
+}
+function readMessages(pluginRoot, issues) {
+	if (!existsSync(sourceLocalePath(pluginRoot))) {
+		issues.push({
+			path: "",
+			problem: `labels are message keys, but the plugin has no ${SOURCE_MESSAGES}`,
+			fix: `create ${SOURCE_MESSAGES} with a key for each title, subtitle and option`
+		});
+		return {};
+	}
+	try {
+		return readTable(sourceLocalePath(pluginRoot));
+	} catch (error) {
+		issues.push({
+			path: "",
+			problem: error.message.replace(pluginRoot + sep, ""),
+			fix: "fix its JSON"
+		});
+		return {};
+	}
+}
+function screamingSnake(path) {
+	return path.replaceAll(/([a-z0-9])([A-Z])/g, "$1_$2").replaceAll(/[^A-Za-z0-9]+/g, "_").toUpperCase();
+}
+function labelsOf(node) {
+	const labels = [
+		["title", node.title],
+		["subtitle", node.subtitle],
+		["placeholder", node.placeholder],
+		["confirm", node.confirm]
+	];
+	for (const options of [node.options, node.of?.options]) for (const option of options ?? []) labels.push([`option ${option.const}`, option.title], [`option ${option.const} subtitle`, option.subtitle]);
+	return labels;
+}
+function checkKeys(schema, messages, issues) {
+	const nodes = schema.title ? [["", { title: schema.title }]] : [];
+	for (const [key, node] of Object.entries(schema.properties)) {
+		nodes.push([key, node]);
+		if (isSettingsGroup(node)) for (const [child, field] of Object.entries(node.properties)) nodes.push([`${key}.${child}`, field]);
+	}
+	for (const [path, node] of nodes) for (const [label, key] of labelsOf(node)) {
+		if (typeof key !== "string" || Object.hasOwn(messages, key)) continue;
+		const suggested = screamingSnake([path || "settings", label === "title" ? "" : label].join("_"));
+		issues.push({
+			path,
+			problem: `${label} ${JSON.stringify(key)} is not a key of ${SOURCE_MESSAGES}`,
+			fix: `add "${key}" (or "${suggested.replace(/_$/, "")}") to ${SOURCE_MESSAGES}`
+		});
+	}
+}
+function schemaNodes(schema) {
+	return Object.entries(schema.properties).flatMap(([key, node]) => [[key, node], ...isSettingsGroup(node) ? Object.entries(node.properties).map(([child, field]) => [`${key}.${child}`, field]) : []]);
+}
+function checkPredicates(schema, source, issues) {
+	const lifted = new Set(source.predicates.map(({ path, option }) => `${path}.${option}`));
+	const failed = new Set(source.problems.map(({ path }) => path));
+	for (const [path, node] of schemaNodes(schema)) for (const option of ["visibleWhen", "disabledWhen"]) {
+		const at = `${path}.${option}`;
+		if (typeof node[option] === "object" && !lifted.has(at) && !failed.has(at)) issues.push({
+			path: at,
+			problem: "is a predicate the build cannot find",
+			fix: "write the predicate inline in the builder options"
+		});
+	}
+}
+function checkActions(schema, actionsPath, issues) {
+	const buttons = schemaNodes(schema).flatMap(([path, node]) => !isSettingsGroup(node) && isButton(node) ? [[path, node.action]] : []);
+	if (!buttons.length) return;
+	if (!actionsPath) {
+		issues.push({
+			path: buttons[0]?.[0] ?? "",
+			problem: "is a button, but the plugin has no src/actions.ts",
+			fix: `create src/actions.ts and export function ${buttons[0]?.[1] ?? "action"}() from it`
+		});
+		return;
+	}
+	const exports = readActionExports(actionsPath, readFileSync(actionsPath, "utf8"));
+	for (const [path, action] of buttons) {
+		if (exports.get(action)) continue;
+		issues.push({
+			path,
+			problem: exports.has(action) ? `runs "${action}", which src/actions.ts exports but not as a function` : `runs "${action}", which src/actions.ts does not export`,
+			fix: `write \`export function ${action}() {}\` or \`export const ${action} = () => {}\` in src/actions.ts`
+		});
+	}
+}
+function formatIssue({ path, problem, fix, offset }, source) {
+	let at = path;
+	while (at && !source.offsets.has(at)) at = at.slice(0, Math.max(0, at.lastIndexOf(".")));
+	const found = offset ?? source.offsets.get(at);
+	const { line, column } = found === void 0 ? {
+		line: 1,
+		column: 1
+	} : toLocation(source.starts, found);
+	return diagnostic({
+		file: SETTINGS_FILE,
+		line,
+		column,
+		path: path || "settings",
+		severity: "error",
+		message: problem,
+		fix,
+		check: "settings"
+	});
+}
+/**
+* @description Reads a plugin's `settings.ts`: evaluates it, validates the schema, lifts its predicates and checks every label against en-US.
+* @param pluginRoot The plugin's directory.
+* @returns The settings with every problem formatted, or `undefined` when the plugin has no settings.ts.
+*/
+async function readPluginSettings(pluginRoot) {
+	const path = settingsPath(pluginRoot);
+	if (!existsSync(path)) return;
+	const source = readSettingsSource(path, readFileSync(path, "utf8"));
+	const issues = source.problems.map(({ path: at, offset, problem, fix }) => ({
+		path: at,
+		offset,
+		problem,
+		fix
+	}));
+	const messages = readMessages(pluginRoot, issues);
+	let schema = {
+		kind: "settings",
+		properties: {}
+	};
+	let watchFiles = [path];
+	try {
+		const evaluated = await evaluateSettings(path);
+		const result = readSettingsSchema(evaluated.value);
+		({schema} = result);
+		watchFiles = evaluated.watchFiles;
+		issues.push(...result.issues);
+	} catch (error) {
+		issues.push({
+			path: "",
+			problem: `failed to evaluate: ${error instanceof Error ? error.message : String(error)}`,
+			fix: "fix that error"
+		});
+	}
+	if (Object.keys(messages).length) checkKeys(schema, messages, issues);
+	const actionsPath = findFile(join(pluginRoot, "src", "actions")) ?? void 0;
+	checkPredicates(schema, source, issues);
+	checkActions(schema, actionsPath, issues);
+	return {
+		schema,
+		messages,
+		predicates: source.predicates,
+		actionsPath,
+		issues: issues.map((issue) => formatIssue(issue, source)),
+		watchFiles
+	};
+}
+// src/rollup/settings-typings.ts
+/**
+* Where `ubd build` and `ubd dev` write the ambient typings of {@link SETTINGS_MODULE} and {@link SETTINGS_SCHEMA_MODULE}.
+* It sits in `src/`, which every plugin tsconfig includes, beside the `@unbound-app/i18n` typings.
+*/
+const SETTINGS_TYPINGS = "src/unbound-settings.d.ts";
+const HEADER = "// Generated by ubd from settings.ts and i18n/en-US.json. Do not edit: `ubd build` and `ubd dev` rewrite it.";
+const REFINED_TYPES = [
+	"	/** A `color` setting: `#RRGGBB`, or `#RRGGBBAA` with `alpha`. */",
+	"	export type HexColor = import('@unbound-app/api/types').HexColor;",
+	"	/** A `url` setting: an http or https URL. */",
+	"	export type HttpUrl = import('@unbound-app/api/types').HttpUrl;",
+	"	/** A Discord id, as an entity setting holds it. */",
+	"	export type Snowflake = import('@unbound-app/api/types').Snowflake;",
+	"	/** An `emoji` setting: a Unicode emoji or a custom emoji's name, then `:` and its id when custom. */",
+	"	export type EmojiString = import('@unbound-app/api/types').EmojiString;"
+].join("\n");
+const UTILS = `import('${SETTINGS_MODULE}')`;
+const SCHEMA_TYPINGS = `declare module '${SETTINGS_SCHEMA_MODULE}' {
+	/** A message key of this plugin's i18n/en-US.json. */
+	export type MessageKey = import('@unbound-app/i18n').MessageKey;
+	type HexColor = ${UTILS}.HexColor;
+	type HttpUrl = ${UTILS}.HttpUrl;
+	type Snowflake = ${UTILS}.Snowflake;
+	type EmojiString = ${UTILS}.EmojiString;
+	type Settings = import('${SETTINGS_MODULE}').Settings;
+	type ActionName = import('${SETTINGS_MODULE}').ActionName;
+	type Never<K extends string> = { [P in K]?: never };
+
+	const stored: unique symbol;
+	const item: unique symbol;
+	const section: unique symbol;
+	const button: unique symbol;
+	const notice: unique symbol;
+	const definition: unique symbol;
+
+	/** A stored setting, from one of the \`setting\` builders. */
+	export type Setting = { readonly [stored]: true };
+	/** An \`array\` item, from \`setting.string()\` or \`setting.choice({ options })\`; \`T\` is its value. */
+	export type Item<T> = { readonly [item]: T };
+	/** A section from \`setting.section\`. */
+	export type Section = { readonly [section]: true };
+	/** A button row from \`setting.button\`; it stores nothing. */
+	export type Button = { readonly [button]: true };
+	/** A notice row from \`setting.notice\`; it stores nothing. */
+	export type Notice = { readonly [notice]: true };
+	/** What \`defineSettings\` returns: the default export of settings.ts. */
+	export type SettingsDefinition = { readonly [definition]: true };
+
+	/** Shows the row only while it holds: a predicate of every setting, defaults applied, or a boolean setting's key. */
+	export type Condition = ((settings: Settings) => boolean) | import('${SETTINGS_MODULE}').BooleanSettingKey;
+
+	/** What every setting, section and button takes. A hidden setting needs no title. */
+	export type Common = {
+		/** The row's sub-label. */
+		subtitle?: MessageKey;
+		visibleWhen?: Condition;
+		disabledWhen?: Condition;
+		/** Changing it shows a hint to restart Discord. */
+		requiresRestart?: boolean;
+	} & (
+		| { /** Stored and typed, but not drawn. */ hidden: true; title?: MessageKey }
+		| { hidden?: false; /** The row's label or the section's title. */ title: MessageKey }
+	);
+
+	type Range = { min?: number; max?: number };
+	type NumberDisplay<Step> =
+		| ({ displayAs?: 'input' } & Range & Never<'step' | 'units'>)
+		| ({ /** The default when \`min\` and \`max\` are set. */ displayAs?: 'slider'; min: number; max: number; step?: number } & Never<'units'>)
+		| ({ displayAs: 'stepper' } & Range & Step & Never<'units'>)
+		| ({ displayAs: 'duration'; /** The units offered, smallest first. */ units?: ('ms' | 's' | 'm' | 'h' | 'd')[] } & Range & Never<'step'>);
+
+	type TextOptions = { minLength?: number; maxLength?: number; placeholder?: MessageKey };
+	type ColorOptions = { alpha?: boolean; default: HexColor } & (
+		| { palette?: false; presets?: HexColor[] }
+		| { /** Draws \`presets\` inline. */ palette: true; presets: [HexColor, ...HexColor[]] }
+	);
+	type StringDisplay =
+		| ({ displayAs?: 'input' | 'multiline'; default: string } & TextOptions & Never<'alpha' | 'presets' | 'palette' | 'maxSize'>)
+		| ({ displayAs: 'secret'; default: string; placeholder?: MessageKey } & Never<'minLength' | 'maxLength' | 'alpha' | 'presets' | 'palette' | 'maxSize'>)
+		| ({ displayAs: 'url'; default: HttpUrl | ''; placeholder?: MessageKey } & Never<'minLength' | 'maxLength' | 'alpha' | 'presets' | 'palette' | 'maxSize'>)
+		| ({ displayAs: 'color' } & ColorOptions & Never<'minLength' | 'maxLength' | 'placeholder' | 'maxSize'>)
+		| ({ displayAs: 'image'; default?: string; /** The largest file, in bytes. */ maxSize?: number } & Never<'minLength' | 'maxLength' | 'placeholder' | 'alpha' | 'presets' | 'palette'>)
+		| ({ displayAs: 'font'; default?: string } & Never<'minLength' | 'maxLength' | 'placeholder' | 'alpha' | 'presets' | 'palette' | 'maxSize'>)
+		| ({ /** \`name\`, or \`name:id\` for a custom emoji. */ displayAs: 'emoji'; default?: EmojiString } & Never<'minLength' | 'maxLength' | 'placeholder' | 'alpha' | 'presets' | 'palette' | 'maxSize'>)
+		| ({ displayAs: 'user' | 'channel' | 'guild' | 'role'; default?: Snowflake | '' } & Never<'minLength' | 'maxLength' | 'placeholder' | 'alpha' | 'presets' | 'palette' | 'maxSize'>);
+
+	/** An option's label: a message key, or a title and a subtitle a radio group shows under it. */
+	export type OptionLabel = MessageKey | { title: MessageKey; subtitle?: MessageKey };
+	type Options = Record<string, OptionLabel>;
+
+	/** The builders, one per stored primitive; \`displayAs\` picks the widget. */
+	export const setting: {
+		/** A \`boolean\`: a switch, or a checkbox. */
+		boolean(options: Common & { default: boolean; displayAs?: 'switch' | 'checkbox' }): Setting;
+		/** A \`number\`: an input; a slider with \`min\` and \`max\`; a stepper, which needs \`step\`; or a duration in milliseconds. */
+		number(options: Common & { default: number } & NumberDisplay<{ step: number }>): Setting;
+		/** A whole \`number\`: an input; a slider with \`min\` and \`max\`; a stepper; or a duration in milliseconds. */
+		integer(options: Common & { default: number } & NumberDisplay<{ step?: number }>): Setting;
+		/** A \`string\` item of an \`array\`. */
+		string(): Item<string>;
+		/** A \`string\`: an input, a multiline input, a secret, a URL, a color, an image, a font, an emoji or a Discord entity. */
+		string(options: Common & StringDisplay): Setting;
+		/** A choice item of an \`array\`. */
+		choice<const O extends Options>(options: { options: O }): Item<keyof O & string>;
+		/** One of \`options\`' keys: a radio group (up to 5 options), a picker sheet (more), or a segmented control (up to 4). */
+		choice<const O extends Options>(
+			options: Common & { options: O; default: NoInfer<keyof O & string>; displayAs?: 'radio' | 'picker' | 'segmented' },
+		): Setting;
+		/** A list of \`of\`: strings as an editable list or a Discord entity picker, choices as checkboxes. */
+		array<const T>(
+			options: Common & { of: Item<T>; default?: NoInfer<T>[]; minItems?: number; maxItems?: number } & (string extends T
+				? { displayAs?: 'list' | 'user' | 'channel' | 'guild' | 'role' }
+				: { displayAs?: 'checkboxes' }),
+		): Setting;
+		/** A section of settings, titled by \`title\`. */
+		section(
+			options: Common & { displayAs?: 'group' | 'collapsible' },
+			properties: Record<string, Setting | Button | Notice>,
+		): Section;
+		/** A button row that calls \`action\`, a function src/actions.ts exports, asking \`confirm\` first when set. */
+		button(
+			options: Common & { action: ActionName; confirm?: MessageKey; displayAs?: 'button' | 'danger' },
+		): Button;
+		/** A message row, shown while \`visibleWhen\` holds; it stores nothing. \`tone\` is \`info\` unless set. */
+		notice(options: {
+			title: MessageKey;
+			subtitle?: MessageKey;
+			tone?: 'info' | 'warning' | 'danger';
+			visibleWhen?: Condition;
+		}): Notice;
+	};
+
+	/** Declares the plugin's settings; \`title\` names the section holding the top-level ones. */
+	export function defineSettings(
+		properties: Record<string, Setting | Section | Button | Notice>,
+		options?: { title?: MessageKey },
+	): SettingsDefinition;
+}`;
+function literalUnion(values) {
+	return values.length ? values.map((value) => JSON.stringify(value)).join(" | ") : "never";
+}
+function stringType(displayAs, empty) {
+	const unset = empty ? " | ''" : "";
+	switch (displayAs) {
+		case "color": return `${UTILS}.HexColor`;
+		case "url": return `${UTILS}.HttpUrl${unset}`;
+		case "emoji": return `${UTILS}.EmojiString`;
+		case "user":
+		case "channel":
+		case "guild":
+		case "role": return `${UTILS}.Snowflake${unset}`;
+		default: return "string";
+	}
+}
+/**
+* @description Writes the TypeScript type a setting's value has, narrowed by its display.
+* @param field The setting.
+* @returns The type's source.
+*/
+function settingType(field) {
+	switch (field.kind) {
+		case "boolean": return "boolean";
+		case "string": return stringType(field.displayAs, true);
+		case "choice": return literalUnion(field.options.map((choice) => choice.const));
+		case "array": return `(${field.of.kind === "choice" ? literalUnion(field.of.options.map((choice) => choice.const)) : stringType(field.displayAs, false)})[]`;
+		default: return "number";
+	}
+}
+function comment(labels, messages, indent) {
+	const lines = [labels.title, labels.subtitle].filter((key) => key !== void 0).map((key) => (messages[key] ?? key).replaceAll("*/", "*\\/").replaceAll("\n", " "));
+	if (!lines.length) return [];
+	return [
+		`${indent}/**`,
+		...lines.flatMap((line, index) => index ? [`${indent} *`, `${indent} * ${line}`] : [`${indent} * ${line}`]),
+		`${indent} */`
+	];
+}
+function key(name) {
+	return /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+}
+const ACTION_NAME = "Extract<{ [K in keyof Actions]: Actions[K] extends () => void | Promise<void> ? K : never }[keyof Actions], string>";
+/**
+* @description Writes the ambient typings of the builders and of a plugin's settings, each property documented with its en-US title and subtitle.
+* @param schema The plugin's validated settings schema.
+* @param messages The plugin's en-US messages.
+* @param hasActions Whether the plugin has a `src/actions.ts`, whose exports name `ActionName`.
+* @returns The `.d.ts` source.
+*/
+function settingsTypings(schema, messages, hasActions = false) {
+	const shape = [];
+	const paths = [];
+	const booleans = [];
+	function addField(path, name, field, indent) {
+		const type = settingType(field);
+		shape.push(...comment(field, messages, indent), `${indent}${key(name)}: ${type};`);
+		paths.push(...comment(field, messages, "		"), `\t\t${JSON.stringify(path)}: ${type};`);
+		if (field.kind === "boolean") booleans.push(JSON.stringify(path));
+	}
+	for (const [name, node] of Object.entries(schema.properties)) {
+		if (!isSettingsGroup(node)) {
+			if (isStored(node)) addField(name, name, node, "		");
+			continue;
+		}
+		shape.push(...comment(node, messages, "		"), `\t\treadonly ${key(name)}: {`);
+		paths.push(...comment(node, messages, "		"), `\t\t${JSON.stringify(name)}: Settings[${JSON.stringify(name)}];`);
+		for (const [child, field] of Object.entries(node.properties)) if (isStored(field)) addField(`${name}.${child}`, child, field, "			");
+		shape.push("		};");
+	}
+	return [
+		HEADER,
+		"",
+		SCHEMA_TYPINGS,
+		"",
+		`declare module '${SETTINGS_MODULE}' {`,
+		REFINED_TYPES,
+		"",
+		"	/** The plugin's settings: reads apply defaults, and writes are validated and saved to its Bucket. */",
+		`\texport type Settings = {\n${shape.join("\n")}\n\t};`,
+		"",
+		"	/** Each setting and section by its dot-separated key. */",
+		`\ttype SettingValues = {\n${paths.join("\n")}\n\t};`,
+		"",
+		"	/** Every setting and section by its dot-separated key; buttons and notices are not settings. */",
+		"	export type SettingKey = keyof SettingValues;",
+		"	/** The value of the setting or section at `K`. */",
+		"	export type SettingsEntry<K extends SettingKey> = SettingValues[K];",
+		"",
+		"	/** The functions src/actions.ts exports, which a `setting.button` can run. */",
+		hasActions ? `\ttype Actions = typeof import('./actions');\n\texport type ActionName = ${ACTION_NAME};` : "	export type ActionName = never;",
+		"",
+		"	/** The keys of the boolean settings, which `visibleWhen` and `disabledWhen` can name. */",
+		`\texport type BooleanSettingKey = ${booleans.length ? booleans.join(" | ") : "never"};`,
+		"",
+		"	/** The plugin's settings. Assign a property, a section's too, to save it. */",
+		"	export const settings: Settings;",
+		"	/** Reads a setting or a whole section, and re-renders the component when it changes. */",
+		"	export function useSetting<K extends SettingKey>(key: K): SettingsEntry<K>;",
+		"	/** Puts every setting back to its default. */",
+		"	export function resetSettings(): void;",
+		"	/** The settings panel generated from settings.ts; a custom `getSettingsPanel` can render it too. */",
+		"	export function SettingsPanel(): import('react').ReactElement;",
+		"}",
+		""
+	].join("\n");
+}
+/**
+* @description Rewrites `src/unbound-settings.d.ts`, leaving the file alone when it is current.
+* @param pluginRoot The plugin's directory.
+* @param typings The `.d.ts` source from {@link settingsTypings}.
+* @returns Whether the file changed.
+*/
+function writeSettingsTypings(pluginRoot, typings) {
+	const path = join(pluginRoot, SETTINGS_TYPINGS);
+	if (existsSync(path) && readFileSync(path, "utf8") === typings) return false;
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, typings);
+	return true;
+}
+export { ASSET_NAME_PATTERN as $, readIcuMessage as A, reportProblem as B, readLocaleFolder as C, reportLine as D, writeLocaleTypings as E, formatDiagnostic as F, hermesBytecode as G, withoutFullStop as H, isDiagnostic as I, LOCALES_DIRECTORY as J, hermescCount as K, pluginDiagnostic as L, findFile as M, sourceAlias as N, buildReportSchema as O, diagnostic as P, ASSETS_DIRECTORY as Q, reportDiagnostic as R, locales as S, sourceLocalePath as T, bytecodeFileName as U, sortDiagnostics as V, bytecodeSource as W, SOURCE_LOCALE as X, LOCALE_CODE_PATTERN as Y, isLocaleCode as Z, formatBytes as _, SETTINGS_MODULE as a, __commonJSMin as at, LOCALE_TYPINGS as b, settingsPath as c, __require as ct, OUTPUT_ONLY as d, ASSET_SCALES as et, outputOnly as f, shim_libraries_default as g, buildReport as h, SETTINGS_FILE as i, ADDON_KINDS as it, IcuSyntaxError as j, readIcuArguments as k, lineStarts as l, __toCommonJS as lt, DEFAULT_BUDGET as m, settingsTypings as n, getAssetPath as nt, SETTINGS_SCHEMA_MODULE as o, __esmMin as ot, BUILD_REPORT_ENV as p, listAddonFiles as q, writeSettingsTypings as r, isAssetName as rt, readPluginSettings as s, __exportAll as st, SETTINGS_TYPINGS as t, ASSET_TYPES as tt, toLocation as u, __toESM as ut, parseByteSize as v, readTable as w, localeModule as x, LOCALE_MODULE as y, reportDiagnostics as z };