@yaawn/workflow 0.3.1 → 0.5.0

package/dist/config/messages.js

@@ -0,0 +1,86 @@
+import { readStrictObject, readString } from "./strict-json.js";
+const MESSAGE_KEYS = [
+    "help",
+    "version",
+    "headerTitle",
+    "introTitle",
+    "introSubtitle",
+    "intro",
+    "outroTitle",
+    "outro",
+    "noTerminal",
+    "configLoadFailed",
+    "invalidConfig",
+    "installFailed",
+    "installCancelled",
+    "pathOutsideRoot",
+    "installing",
+    "fileKept",
+    "syncSourceMissing",
+    "syncFailed",
+    "synced",
+    "syncedReplaced",
+    "languagesInstalled",
+    "languagesNone",
+    "languagesFailed",
+    "sectionFileMissing",
+    "currentItems",
+    "noItems",
+    "emptySubmit",
+    "duplicateItem",
+    "itemsAdded",
+    "itemsUnchanged",
+    "selectedCount",
+    "noneSelected",
+    "modeTitle",
+    "modeInstall",
+    "modeUninstall",
+    "uninstallHeaderTitle",
+    "uninstallList",
+    "uninstallConfirm",
+    "uninstallYes",
+    "uninstallNo",
+    "uninstalling",
+    "uninstallCancelled",
+    "nothingToRemove",
+    "uninstallRemoved",
+    "uninstallPruned",
+    "uninstallKeptPlans",
+    "uninstallFailed",
+    "uninstallRemovedSoFar",
+    "uninstallNpmHint",
+    "uninstallNoTerminal",
+    "invalidAgent",
+    "linkCreated",
+    "linkExisted",
+    "linkSkipped",
+    "linkFailed",
+    "importsCreated",
+    "importsExisted",
+    "importsSkipped",
+    "importsFailed",
+    "linksFailed",
+    "uninstallImportsEntry",
+    "projectsUpdated",
+    "projectsSkipped",
+];
+/** Reads the messages object: every message is required and must be a non-empty string; unknown keys are rejected. */
+export function decodeMessages(value, at) {
+    const object = readStrictObject(value, at, MESSAGE_KEYS);
+    const messages = {};
+    for (const key of MESSAGE_KEYS) {
+        messages[key] = readMessage(object[key], at.key(key));
+    }
+    return messages;
+}
+function readMessage(value, at) {
+    if (value === undefined || value === "") {
+        throw at.error("is required");
+    }
+    return readString(value, at);
+}
+const PLACEHOLDER = /\{([^{}]+)\}/g;
+/** Replaces every {name} placeholder in template with its value in one pass; unknown placeholders stay. */
+export function fill(template, values) {
+    return template.replace(PLACEHOLDER, (placeholder, name) => Object.hasOwn(values, name) ? (values[name] ?? placeholder) : placeholder);
+}

package/dist/config/names.js

@@ -0,0 +1,40 @@
+import path from "node:path";
+const FORBIDDEN_NAME_CHARACTERS = /[/\\*]/;
+const NUL = "\u0000";
+const WINDOWS_DRIVE = /^[A-Za-z]:/;
+/** Reports whether name is a single plain path segment. */
+export function isFileName(name) {
+    return name !== "" && name !== "." && name !== ".." && !FORBIDDEN_NAME_CHARACTERS.test(name) && !name.includes(NUL);
+}
+/** Reports whether candidate is absolute on any platform, including a Windows drive. */
+export function isAbsolutePath(candidate) {
+    return path.posix.isAbsolute(candidate) || path.win32.isAbsolute(candidate) || WINDOWS_DRIVE.test(candidate);
+}
+/**
+ * Reports whether dir is a slash-separated relative path without empty,
+ * "." or ".." segments, so it can only point inside its root.
+ */
+export function isRelativeDir(dir) {
+    if (dir === "" || isAbsolutePath(dir)) {
+        return false;
+    }
+    return dir.split("/").every(isFileName);
+}
+/**
+ * Reports whether pattern looks like "<dir>/<prefix>*": relative, no "..",
+ * and scoped to the owned prefix, so the delete step can never touch
+ * entries the project owns.
+ */
+export function isRemovePattern(pattern, ownedPrefix) {
+    const separator = pattern.lastIndexOf("/");
+    const dir = pattern.slice(0, separator + 1);
+    const last = pattern.slice(separator + 1);
+    if (last !== `${ownedPrefix}*`) {
+        return false;
+    }
+    return dir === "" || isRelativeDir(dir.slice(0, -1));
+}
+/** Returns the directory part of a removeFirst pattern, relative to the sync target ("." for the target itself). */
+export function removeDir(pattern) {
+    return path.posix.dirname(pattern);
+}

package/dist/config/paths.js

@@ -0,0 +1,73 @@
+import fs from "node:fs";
+import path from "node:path";
+import { PathEscapeError } from "./errors.js";
+import { isAbsolutePath } from "./names.js";
+/**
+ * Joins the slash-separated elements onto root and returns the absolute
+ * result. Rejects absolute elements, results outside root, and existing
+ * symlinks that resolve outside root.
+ */
+export function contain(root, ...elements) {
+    const relative = path.posix.join(...elements);
+    if (isAbsolutePath(relative)) {
+        throw new PathEscapeError(relative, root);
+    }
+    const absoluteRoot = path.resolve(root);
+    const joined = path.join(absoluteRoot, ...relative.split("/"));
+    if (!isWithin(absoluteRoot, joined)) {
+        throw new PathEscapeError(relative, root);
+    }
+    assertNoSymlinkEscape(absoluteRoot, joined);
+    return joined;
+}
+function isWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    if (path.isAbsolute(relative)) {
+        return false;
+    }
+    return relative !== ".." && !relative.startsWith(`..${path.sep}`);
+}
+/** Resolves the deepest existing part of candidate and verifies it still lies inside the resolved root. */
+function assertNoSymlinkEscape(root, candidate) {
+    const realRoot = realpathIfExists(root);
+    if (realRoot === undefined) {
+        return;
+    }
+    const resolved = fs.realpathSync(deepestExisting(root, candidate));
+    if (!isWithin(realRoot, resolved)) {
+        throw new PathEscapeError(candidate, root);
+    }
+}
+function realpathIfExists(target) {
+    try {
+        return fs.realpathSync(target);
+    }
+    catch (error) {
+        if (isMissingEntry(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function deepestExisting(root, candidate) {
+    let current = candidate;
+    while (current !== root && path.dirname(current) !== current) {
+        if (existsWithoutFollowing(current)) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return root;
+}
+function existsWithoutFollowing(target) {
+    try {
+        fs.lstatSync(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isMissingEntry(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}

package/dist/config/settings.js

@@ -0,0 +1,101 @@
+import { JsonLocation, optional, readStrictObject, readString, readStringArrayRecord, readStringRecord, required, sortedKeys, toRecord, } from "./strict-json.js";
+import { isFileName } from "./names.js";
+import { ValidationError } from "./errors.js";
+/** Name of the settings config file. */
+export const SETTINGS_FILE = "settings.json";
+const HEX_COLOR = /^#[0-9a-fA-F]{6}$/;
+const OWNED_PREFIX = /^[a-z0-9]+(-[a-z0-9]+)*-$/;
+const LANGUAGE_TAG = /^[a-z0-9]+$/;
+const SETTINGS_KEYS = [
+    "brandColor",
+    "filePrefix",
+    "outputFileNames",
+    "settingsFileName",
+    "languagePattern",
+    "languageLabels",
+    "languageImplications",
+];
+export function decodeSettings(document) {
+    const at = new JsonLocation(SETTINGS_FILE);
+    const object = readStrictObject(document, at, SETTINGS_KEYS);
+    return {
+        brandColor: required(object, "brandColor", at, readString),
+        filePrefix: required(object, "filePrefix", at, readString),
+        outputFileNames: required(object, "outputFileNames", at, readStringRecord),
+        settingsFileName: required(object, "settingsFileName", at, readString),
+        languagePattern: required(object, "languagePattern", at, readString),
+        languageLabels: required(object, "languageLabels", at, readStringRecord),
+        languageImplications: optional(object, "languageImplications", at, readStringArrayRecord, toRecord([])),
+    };
+}
+export function validateSettings(settings) {
+    if (!HEX_COLOR.test(settings.brandColor)) {
+        throw settingsError("brandColor", "must be a hex colour like #0096ff");
+    }
+    if (!OWNED_PREFIX.test(settings.filePrefix)) {
+        throw settingsError("filePrefix", 'must be lowercase letters, digits and hyphens ending in "-"');
+    }
+    validateOutputFileNames(settings.outputFileNames);
+    if (!isFileName(settings.settingsFileName)) {
+        throw settingsError("settingsFileName", "must be a plain file name");
+    }
+    validateLanguageLabels(settings.languageLabels);
+    validateLanguageImplications(settings.languageImplications);
+    return { ...settings, languageRegExp: compileLanguagePattern(settings.languagePattern) };
+}
+function validateOutputFileNames(outputFileNames) {
+    const keys = sortedKeys(outputFileNames);
+    if (keys.length === 0) {
+        throw settingsError("outputFileNames", "must be a non-empty object");
+    }
+    const invalidKey = keys.find((key) => !isFileName(outputFileNames[key] ?? ""));
+    if (invalidKey !== undefined) {
+        throw settingsError(`outputFileNames.${invalidKey}`, "must be a plain file name");
+    }
+}
+function compileLanguagePattern(pattern) {
+    if (pattern === "") {
+        throw settingsError("languagePattern", "is required");
+    }
+    let compiled;
+    try {
+        compiled = new RegExp(pattern);
+    }
+    catch {
+        throw settingsError("languagePattern", "must be a valid regular expression");
+    }
+    if (countCaptureGroups(pattern) !== 1) {
+        throw settingsError("languagePattern", "must have exactly one capture group");
+    }
+    return compiled;
+}
+// An empty alternative always matches, so the match array has one slot per group.
+function countCaptureGroups(pattern) {
+    const match = new RegExp(`${pattern}|`).exec("");
+    return match === null ? 0 : match.length - 1;
+}
+function validateLanguageLabels(languageLabels) {
+    const invalidKey = sortedKeys(languageLabels).find((key) => key === "" || languageLabels[key] === "");
+    if (invalidKey !== undefined) {
+        throw settingsError(`languageLabels.${invalidKey}`, "must map a tag to a non-empty label");
+    }
+}
+/** Accepts no implications, but rejects any tag that is not lowercase letters and digits. */
+function validateLanguageImplications(implications) {
+    for (const key of sortedKeys(implications)) {
+        const field = `languageImplications.${key}`;
+        if (!LANGUAGE_TAG.test(key)) {
+            throw settingsError(field, "must be keyed by a language tag of lowercase letters and digits");
+        }
+        const implied = implications[key] ?? [];
+        if (implied.length === 0) {
+            throw settingsError(field, "must list at least one language tag");
+        }
+        if (!implied.every((tag) => LANGUAGE_TAG.test(tag))) {
+            throw settingsError(field, "must list language tags of lowercase letters and digits");
+        }
+    }
+}
+export function settingsError(field, problem) {
+    return new ValidationError(SETTINGS_FILE, field, problem);
+}

package/dist/config/strict-json.js

@@ -0,0 +1,119 @@
+import fs from "node:fs";
+import { LoadError, ValidationError } from "./errors.js";
+/** Field name used for problems with the document as a whole. */
+export const DOCUMENT_FIELD = "document";
+/** Where a value sits: its config file and the field path inside it. */
+export class JsonLocation {
+    file;
+    field;
+    constructor(file, field = "") {
+        this.file = file;
+        this.field = field;
+    }
+    key(name) {
+        return new JsonLocation(this.file, this.field === "" ? name : `${this.field}.${name}`);
+    }
+    index(position) {
+        return new JsonLocation(this.file, `${this.field}[${position}]`);
+    }
+    error(problem) {
+        return new ValidationError(this.file, this.field === "" ? DOCUMENT_FIELD : this.field, problem);
+    }
+}
+/** Reads and parses one JSON document; file names it in errors. */
+export function readJsonDocument(filePath, file) {
+    const text = readText(filePath, file);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new ValidationError(file, DOCUMENT_FIELD, "must contain exactly one valid JSON value");
+    }
+}
+function readText(filePath, file) {
+    try {
+        return fs.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        throw new LoadError(file, error);
+    }
+}
+/** Reads an object whose keys must all be in allowedKeys. */
+export function readStrictObject(value, at, allowedKeys) {
+    const object = readObject(value, at);
+    const unknownKey = Object.keys(object).find((key) => !allowedKeys.includes(key));
+    if (unknownKey !== undefined) {
+        throw at.key(unknownKey).error("is not an allowed key");
+    }
+    return object;
+}
+/** Reads an object with arbitrary keys. */
+export function readObject(value, at) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw at.error(typeProblem("an object", value));
+    }
+    return value;
+}
+export function readString(value, at) {
+    if (typeof value !== "string") {
+        throw at.error(typeProblem("a string", value));
+    }
+    return value;
+}
+export function readArray(value, at, readItem) {
+    if (!Array.isArray(value)) {
+        throw at.error(typeProblem("an array", value));
+    }
+    return value.map((item, position) => readItem(item, at.index(position)));
+}
+export function readStringArray(value, at) {
+    return readArray(value, at, readString);
+}
+export function readStringRecord(value, at) {
+    return readRecord(value, at, readString);
+}
+export function readStringArrayRecord(value, at) {
+    return readRecord(value, at, readStringArray);
+}
+function readRecord(value, at, readEntry) {
+    const entries = Object.entries(readObject(value, at));
+    return toRecord(entries.map(([key, entry]) => [key, readEntry(entry, at.key(key))]));
+}
+/** Reads a key that must be present. */
+export function required(object, key, at, read) {
+    if (!Object.hasOwn(object, key)) {
+        throw at.key(key).error("is required");
+    }
+    return read(object[key], at.key(key));
+}
+/** Reads a key that may be absent; fallback stands in for it. */
+export function optional(object, key, at, read, fallback) {
+    return Object.hasOwn(object, key) ? read(object[key], at.key(key)) : fallback;
+}
+/**
+ * Builds a record without a prototype, so keys such as "__proto__" or
+ * "constructor" are plain data and lookups never hit inherited members.
+ */
+export function toRecord(entries) {
+    const record = Object.create(null);
+    for (const [key, value] of entries) {
+        Object.defineProperty(record, key, { value, enumerable: true });
+    }
+    return record;
+}
+/** Returns the keys of record in sorted order, for deterministic validation. */
+export function sortedKeys(record) {
+    return Object.keys(record).sort();
+}
+function typeProblem(expected, value) {
+    return `must be ${expected}, not ${describeKind(value)}`;
+}
+function describeKind(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "an array";
+    }
+    return typeof value === "object" ? "an object" : `a ${typeof value}`;
+}

package/dist/config/tasks.js

@@ -0,0 +1,77 @@
+import { isFileName, isRelativeDir, isRemovePattern } from "./names.js";
+import { JsonLocation, optional, readArray, readStrictObject, readString, readStringArray, readStringRecord, required, sortedKeys, toRecord, } from "./strict-json.js";
+/** Name of the sync task config file. */
+export const INSTALL_TASKS_FILE = "install-tasks.json";
+const TASKS_KEYS = ["syncTargets"];
+const SYNC_TARGET_KEYS = ["source", "target", "seedOnly", "removeFirst", "languageInstructions", "renames"];
+export function decodeInstallTasks(document) {
+    const at = new JsonLocation(INSTALL_TASKS_FILE);
+    const object = readStrictObject(document, at, TASKS_KEYS);
+    return {
+        syncTargets: required(object, "syncTargets", at, (value, location) => readArray(value, location, decodeSyncTarget)),
+    };
+}
+function decodeSyncTarget(value, at) {
+    const object = readStrictObject(value, at, SYNC_TARGET_KEYS);
+    const languageInstructions = optional(object, "languageInstructions", at, readString, "");
+    return {
+        source: required(object, "source", at, readString),
+        target: required(object, "target", at, readString),
+        seedOnly: optional(object, "seedOnly", at, readStringArray, []),
+        removeFirst: optional(object, "removeFirst", at, readStringArray, []),
+        ...(languageInstructions === "" ? {} : { languageInstructions }),
+        renames: optional(object, "renames", at, readStringRecord, toRecord([])),
+    };
+}
+export function validateInstallTasks(tasks, ownedPrefix) {
+    const at = new JsonLocation(INSTALL_TASKS_FILE).key("syncTargets");
+    if (tasks.syncTargets.length === 0) {
+        throw at.error("must be a non-empty array");
+    }
+    tasks.syncTargets.forEach((target, position) => validateSyncTarget(target, at.index(position), ownedPrefix));
+}
+function validateSyncTarget(target, at, ownedPrefix) {
+    if (!isRelativeDir(target.source)) {
+        throw at.key("source").error("must be a relative directory inside the package");
+    }
+    if (!isRelativeDir(target.target)) {
+        throw at.key("target").error("must be a relative directory inside the project");
+    }
+    validateSeedOnly(target.seedOnly, at.key("seedOnly"));
+    validateRemoveFirst(target.removeFirst, at.key("removeFirst"), ownedPrefix);
+    if (target.languageInstructions !== undefined && !isRelativeDir(target.languageInstructions)) {
+        throw at.key("languageInstructions").error("must be a relative directory name");
+    }
+    validateRenames(target.renames, at.key("renames"));
+}
+function validateSeedOnly(seedOnly, at) {
+    const position = seedOnly.findIndex((name) => !isFileName(name));
+    if (position !== -1) {
+        throw at.index(position).error("must be a plain file name");
+    }
+}
+function validateRemoveFirst(removeFirst, at, ownedPrefix) {
+    const position = removeFirst.findIndex((pattern) => !isRemovePattern(pattern, ownedPrefix));
+    if (position !== -1) {
+        throw at.index(position).error(`must look like "dir/${ownedPrefix}*" (relative, no "..")`);
+    }
+}
+/** Keeps both sides plain file names, so a rename can never point outside the target directory. */
+function validateRenames(renames, at) {
+    const invalidSource = sortedKeys(renames).find((source) => !isFileName(source) || !isFileName(renames[source] ?? ""));
+    if (invalidSource !== undefined) {
+        throw at.key(invalidSource).error("must map a plain file name to a plain file name");
+    }
+}
+/** Reports whether a file with this name is only copied when it is missing in the project. */
+export function isSeedOnly(target, name) {
+    return target.seedOnly.includes(name);
+}
+/** Returns the name a file directly inside the source is installed under. */
+export function installedName(target, name) {
+    return Object.hasOwn(target.renames, name) ? (target.renames[name] ?? name) : name;
+}
+/** Lists the renamed destination names in stable order. */
+export function installedRenames(target) {
+    return sortedKeys(target.renames).map((source) => target.renames[source] ?? source);
+}

package/dist/config/wizard.js

@@ -0,0 +1,139 @@
+import { agents, isAgent } from "./agents.js";
+import { decodeMessages } from "./messages.js";
+import { SETTINGS_FILE } from "./settings.js";
+import { JsonLocation, optional, readArray, readStrictObject, readString, required, } from "./strict-json.js";
+/** Name of the wizard config file. */
+export const WIZARD_FILE = "wizard.json";
+export const KIND_TEXT_LIST = "text-list";
+export const KIND_MULTISELECT = "multiselect";
+export const KIND_SINGLE_SELECT = "single-select";
+export const KIND_PROJECTS_LIST = "projects-list";
+const SECTION_KINDS = [KIND_TEXT_LIST, KIND_MULTISELECT, KIND_SINGLE_SELECT, KIND_PROJECTS_LIST];
+const SINGLETON_KINDS = [KIND_MULTISELECT, KIND_SINGLE_SELECT, KIND_PROJECTS_LIST];
+const WIZARD_KEYS = ["sections", "messages"];
+const SECTION_KEYS = ["id", "title", "description", "kind", "targetFile", "placeholder", "options", "default"];
+const OPTION_KEYS = ["value", "label"];
+export function decodeWizard(document) {
+    const at = new JsonLocation(WIZARD_FILE);
+    const object = readStrictObject(document, at, WIZARD_KEYS);
+    return {
+        sections: required(object, "sections", at, (value, location) => readArray(value, location, decodeSection)),
+        messages: required(object, "messages", at, decodeMessages),
+    };
+}
+function decodeSection(value, at) {
+    const object = readStrictObject(value, at, SECTION_KEYS);
+    return {
+        id: required(object, "id", at, readString),
+        title: required(object, "title", at, readString),
+        description: required(object, "description", at, readString),
+        kind: required(object, "kind", at, readSectionKind),
+        targetFile: optional(object, "targetFile", at, readString, ""),
+        placeholder: optional(object, "placeholder", at, readString, ""),
+        options: optional(object, "options", at, (options, location) => readArray(options, location, decodeOption), []),
+        default: optional(object, "default", at, readString, ""),
+    };
+}
+function readSectionKind(value, at) {
+    const kind = readString(value, at);
+    if (!SECTION_KINDS.includes(kind)) {
+        throw at.error(`must be ${SECTION_KINDS.map((name) => `"${name}"`).join(", ")}`);
+    }
+    return kind;
+}
+function decodeOption(value, at) {
+    const object = readStrictObject(value, at, OPTION_KEYS);
+    return {
+        value: required(object, "value", at, readAgent),
+        label: required(object, "label", at, readString),
+    };
+}
+function readAgent(value, at) {
+    const agent = readString(value, at);
+    if (!isAgent(agent)) {
+        throw at.error(`must be one of ${agents().map((name) => `"${name}"`).join(", ")}`);
+    }
+    return agent;
+}
+/** Validates the sections against the settings; messages are complete once decoded. */
+export function validateWizard(wizard, settings) {
+    const at = new JsonLocation(WIZARD_FILE).key("sections");
+    if (wizard.sections.length === 0) {
+        throw at.error("must be a non-empty array");
+    }
+    wizard.sections.forEach((section, position) => validateSection(section, at.index(position), settings));
+    validateUniqueIds(wizard.sections, at);
+    validateSingletonKinds(wizard.sections, at);
+}
+function validateUniqueIds(sections, at) {
+    const seen = new Set();
+    sections.forEach((section, position) => {
+        if (seen.has(section.id)) {
+            throw at.index(position).key("id").error("must be unique");
+        }
+        seen.add(section.id);
+    });
+}
+function validateSingletonKinds(sections, at) {
+    for (const kind of SINGLETON_KINDS) {
+        if (sections.filter((section) => section.kind === kind).length > 1) {
+            throw at.error(`must contain at most one ${kind} section`);
+        }
+    }
+}
+function validateSection(section, at, settings) {
+    validateRequiredTexts(section, at);
+    if (section.kind === KIND_SINGLE_SELECT) {
+        validateSingleSelect(section, at);
+        return;
+    }
+    validateTargetFile(section, at, settings);
+    if (section.options.length > 0 || section.default !== "") {
+        throw at.key("options").error("are only allowed on a single-select section");
+    }
+}
+function validateRequiredTexts(section, at) {
+    for (const name of ["id", "title", "description"]) {
+        if (section[name] === "") {
+            throw at.key(name).error("is required");
+        }
+    }
+}
+function validateTargetFile(section, at, settings) {
+    if (section.kind === KIND_TEXT_LIST) {
+        if (!Object.hasOwn(settings.outputFileNames, section.targetFile)) {
+            throw at.key("targetFile").error(`must name a key of outputFileNames in ${SETTINGS_FILE}`);
+        }
+        return;
+    }
+    if (section.targetFile !== "") {
+        throw at.key("targetFile").error(`must be empty for a ${section.kind} section`);
+    }
+}
+/** Requires a non-empty, unique set of allowed agents and a default that is one of them. */
+function validateSingleSelect(section, at) {
+    if (section.targetFile !== "") {
+        throw at.key("targetFile").error(`must be empty for a ${KIND_SINGLE_SELECT} section`);
+    }
+    if (section.options.length === 0) {
+        throw at.key("options").error("must be a non-empty array");
+    }
+    const seen = new Set();
+    section.options.forEach((option, position) => {
+        const optionAt = at.key("options").index(position);
+        if (seen.has(option.value)) {
+            throw optionAt.key("value").error("must be unique");
+        }
+        seen.add(option.value);
+        if (option.label === "") {
+            throw optionAt.key("label").error("is required");
+        }
+    });
+    if (!seen.has(section.default)) {
+        throw at.key("default").error("must be the value of one of the options");
+    }
+}
+/** Returns the single-select section, if configured. */
+export function singleSelectSection(wizard) {
+    return wizard.sections.find((section) => section.kind === KIND_SINGLE_SELECT);
+}

package/dist/display/index.js

@@ -0,0 +1,3 @@
+export { Renderer } from "./renderer.js";
+export { MODE_INSTALL, MODE_UNINSTALL, ReportCollector, } from "./report.js";
+export { sanitize } from "./sanitize.js";