create-ailk 0.8.0 → 0.9.0

package/dist/design-presets.js

@@ -0,0 +1,642 @@
+/**
+ * Design section presets (#6816) — a design package's `sections` block
+ * (page type → section type → look fields) validated at scaffold time and
+ * applied onto the page files of the page types the site's roster places.
+ * Spec docs/specs/6816-the-preset-validator-and-applier-spec.md D1–D5.
+ *
+ * A preset changes how a placed section LOOKS, never what a page SAYS or
+ * EMITS: `validateDesignPresets` refuses anything but a look field (the look
+ * groups #6815 declared, shipped inside `component-catalog.json` because this
+ * package cannot import the registry), and `applyDesignPresets` is a bounded
+ * text splice that replaces or inserts one look-field value span at a time —
+ * there is no YAML library to re-print a page with, and a re-print would
+ * rewrite every byte of a customer's frontmatter.
+ *
+ * Pure apart from the two catalog/roster readers: every directory it reads is
+ * passed in (no `import.meta.url` — Jest's CJS transform, the #6812 constraint).
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DesignPackageError } from "./design-package.js";
+import { TemplateError } from "./template-manifest.js";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+/** Read `<pkgRoot>/component-catalog.json` into the look catalog. Throws naming the file on a missing `look` or `schema`. */
+export function readSectionLookCatalog(catalogPath) {
+    const doc = JSON.parse(readFileSync(catalogPath, "utf8"));
+    if (!Array.isArray(doc.sections)) {
+        throw new Error(`${catalogPath}: no sections[] array`);
+    }
+    const out = {};
+    for (const raw of doc.sections) {
+        const entry = raw;
+        const type = String(entry.type);
+        if (!Array.isArray(entry.look)) {
+            throw new Error(`${catalogPath}: sections["${type}"] has no look group`);
+        }
+        if (!isPlainObject(entry.schema)) {
+            throw new Error(`${catalogPath}: sections["${type}"] has no schema`);
+        }
+        const properties = entry.schema["properties"];
+        out[type] = {
+            look: entry.look.map(String),
+            properties: isPlainObject(properties) ? properties : {},
+        };
+    }
+    return out;
+}
+/** Every `pageType` a manifest file's rows name, added into `out`. */
+function addPageTypesFrom(file, out) {
+    if (!existsSync(file))
+        return;
+    const doc = JSON.parse(readFileSync(file, "utf8"));
+    for (const row of Array.isArray(doc.rows) ? doc.rows : []) {
+        const pageType = row.pageType;
+        if (typeof pageType === "string")
+            out.add(pageType);
+    }
+}
+/**
+ * Every `pageType` named by a row of a shipped `TEMPLATE-MANIFEST.json` under
+ * `<siteTemplatesDir>/*`, `<siteTemplatesDir>/shapes/*`, and — a treeless
+ * alias's own GENERATED record (spec 6892 D1/D5), which has no directory of
+ * its own — every `<siteTemplatesDir>/aliases/*.TEMPLATE-MANIFEST.json` file.
+ */
+export function shippedPageTypes(siteTemplatesDir) {
+    const dirs = [];
+    for (const parent of [siteTemplatesDir, join(siteTemplatesDir, "shapes")]) {
+        if (!existsSync(parent))
+            continue;
+        for (const entry of readdirSync(parent, { withFileTypes: true })) {
+            if (entry.isDirectory())
+                dirs.push(join(parent, entry.name));
+        }
+    }
+    const out = new Set();
+    for (const dir of dirs) {
+        addPageTypesFrom(join(dir, "TEMPLATE-MANIFEST.json"), out);
+    }
+    const aliasesDir = join(siteTemplatesDir, "aliases");
+    if (existsSync(aliasesDir)) {
+        for (const entry of readdirSync(aliasesDir, { withFileTypes: true })) {
+            if (entry.isFile() && entry.name.endsWith(".TEMPLATE-MANIFEST.json")) {
+                addPageTypesFrom(join(aliasesDir, entry.name), out);
+            }
+        }
+    }
+    return out;
+}
+// ── D3: validateDesignPresets ──────────────────────────────────────────────
+/** The JSON Schema keywords the value check evaluates (spec § 1.2); `default` is not a constraint. */
+const SUPPORTED_KEYWORDS = new Set([
+    "anyOf",
+    "const",
+    "default",
+    "enum",
+    "exclusiveMinimum",
+    "properties",
+    "type",
+]);
+function describe(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+/** The allowed values a schema enumerates (`enum`, `const`, or an `anyOf` of those), or undefined. */
+function enumeratedValues(schema) {
+    if (Array.isArray(schema["enum"]))
+        return schema["enum"];
+    if (hasOwn(schema, "const"))
+        return [schema["const"]];
+    if (Array.isArray(schema["anyOf"])) {
+        const out = [];
+        for (const branch of schema["anyOf"]) {
+            const values = isPlainObject(branch) ? enumeratedValues(branch) : undefined;
+            if (values === undefined)
+                return undefined;
+            out.push(...values);
+        }
+        return out;
+    }
+    return undefined;
+}
+function checkValue(schema, value, field, label) {
+    if (!isPlainObject(schema))
+        return undefined;
+    for (const keyword of Object.keys(schema)) {
+        if (!SUPPORTED_KEYWORDS.has(keyword)) {
+            throw new Error(`validateDesignPresets: unsupported JSON Schema keyword "${keyword}" on ${label}`);
+        }
+    }
+    if (Array.isArray(schema["anyOf"])) {
+        const branches = schema["anyOf"];
+        let last;
+        for (const branch of branches) {
+            last = checkValue(branch, value, field, label);
+            if (last === undefined)
+                break;
+        }
+        if (last !== undefined) {
+            const values = enumeratedValues(schema);
+            return values !== undefined
+                ? { field, reason: `must be one of ${values.map(describe).join(", ")}` }
+                : last;
+        }
+    }
+    const rawType = schema["type"];
+    if (rawType !== undefined) {
+        const type = typeof rawType === "string" ? rawType : "";
+        if (!["string", "number", "integer", "boolean", "object"].includes(type)) {
+            throw new Error(`validateDesignPresets: unsupported JSON Schema type ${JSON.stringify(rawType)} on ${label}`);
+        }
+        const ok = type === "object"
+            ? isPlainObject(value)
+            : type === "integer"
+                ? Number.isInteger(value)
+                : typeof value === type;
+        if (!ok)
+            return { field, reason: `must be a${type === "object" || type === "integer" ? "n" : ""} ${type}` };
+    }
+    if (Array.isArray(schema["enum"]) && !schema["enum"].includes(value)) {
+        return {
+            field,
+            reason: `must be one of ${schema["enum"].map(describe).join(", ")}`,
+        };
+    }
+    if (hasOwn(schema, "const") && schema["const"] !== value) {
+        return { field, reason: `must be one of ${describe(schema["const"])}` };
+    }
+    const min = schema["exclusiveMinimum"];
+    if (typeof min === "number" && !(typeof value === "number" && value > min)) {
+        return { field, reason: `must be greater than ${min}` };
+    }
+    if (isPlainObject(schema["properties"]) && isPlainObject(value)) {
+        const properties = schema["properties"];
+        for (const [sub, subValue] of Object.entries(value)) {
+            if (!hasOwn(properties, sub)) {
+                return { field: `${field}.${sub}`, reason: `is not a field of ${label}` };
+            }
+            const failure = checkValue(properties[sub], subValue, `${field}.${sub}`, `${label}.${sub}`);
+            if (failure !== undefined)
+                return failure;
+        }
+    }
+    return undefined;
+}
+/**
+ * Refuse, with a `DesignPackageError` whose `field` names the page type, the
+ * section type and the field, the first preset (key order) that names a page
+ * type no shipped roster places, an unregistered section type, a field
+ * outside the type's look group, or a value outside that field's schema
+ * (D3's table, R1–R5b). A valid block returns without effect. Pure.
+ */
+export function validateDesignPresets(sections, opts) {
+    function refuse(field, reason) {
+        throw new DesignPackageError(opts.file, field, reason);
+    }
+    for (const [pageType, bySection] of Object.entries(sections)) {
+        if (!opts.pageTypes.has(pageType)) {
+            refuse(`sections.${pageType}`, `is not a page type any shipped shape places (known: ${[...opts.pageTypes].sort().join(", ")})`);
+        }
+        for (const [sectionType, preset] of Object.entries(bySection)) {
+            const at = `sections.${pageType}.${sectionType}`;
+            const entry = hasOwn(opts.catalog, sectionType)
+                ? opts.catalog[sectionType]
+                : undefined;
+            if (entry === undefined)
+                refuse(at, "is not a registered section type");
+            if (!isPlainObject(preset))
+                refuse(at, "must be a mapping of look fields");
+            const { look, properties } = entry;
+            for (const [field, value] of Object.entries(preset)) {
+                const fieldAt = `${at}.${field}`;
+                if (!look.includes(field)) {
+                    if (hasOwn(properties, field)) {
+                        refuse(fieldAt, `is a content field of section type "${sectionType}" — a design preset sets look fields only`);
+                    }
+                    refuse(fieldAt, field === "variant"
+                        ? `section type "${sectionType}" has no variants`
+                        : `is not a field of section type "${sectionType}"`);
+                }
+                const failure = checkValue(properties[field], value, fieldAt, `${sectionType}.${field}`);
+                if (failure === undefined)
+                    continue;
+                if (field === "variant" && failure.field === fieldAt) {
+                    const variants = isPlainObject(properties[field])
+                        ? enumeratedValues(properties[field])
+                        : undefined;
+                    refuse(fieldAt, `"${describe(value)}" is not a variant of section type "${sectionType}"` +
+                        (variants !== undefined ? ` (variants: ${variants.map(describe).join(", ")})` : ""));
+                }
+                refuse(failure.field, failure.reason);
+            }
+        }
+    }
+}
+function cannotLocate(file, index, what) {
+    const where = index === undefined ? "sections" : `sections[${index}]`;
+    throw new TemplateError(`${file}: ${where} — cannot locate ${what} for a design preset`);
+}
+function skipSpace(text, i, end) {
+    while (i < end && /\s/.test(text[i]))
+        i++;
+    return i;
+}
+/** End (exclusive) of a quoted scalar opening at `i`, or -1 when unterminated. */
+function endOfQuoted(text, i, end) {
+    const quote = text[i];
+    for (let j = i + 1; j < end; j++) {
+        const ch = text[j];
+        if (quote === '"' && ch === "\\") {
+            j++;
+        }
+        else if (ch === quote) {
+            if (quote === "'" && text[j + 1] === "'") {
+                j++;
+                continue;
+            }
+            return j + 1;
+        }
+    }
+    return -1;
+}
+/** End (exclusive) of the flow value starting at `i`: a collection, a quoted scalar or a plain scalar. */
+function endOfFlowValue(text, i, end) {
+    const ch = text[i];
+    if (ch === '"' || ch === "'")
+        return endOfQuoted(text, i, end);
+    if (ch === "{" || ch === "[") {
+        let depth = 0;
+        for (let j = i; j < end; j++) {
+            const c = text[j];
+            if (c === '"' || c === "'") {
+                const close = endOfQuoted(text, j, end);
+                if (close < 0)
+                    return -1;
+                j = close - 1;
+            }
+            else if (c === "{" || c === "[") {
+                depth++;
+            }
+            else if (c === "}" || c === "]") {
+                depth--;
+                if (depth === 0)
+                    return j + 1;
+            }
+        }
+        return -1;
+    }
+    let j = i;
+    while (j < end && !",]}".includes(text[j]))
+        j++;
+    while (j > i && /\s/.test(text[j - 1]))
+        j--;
+    return j > i ? j : -1;
+}
+/**
+ * A YAML scalar's string value — quoted (a trailing `# comment` allowed) or
+ * plain (a whitespace-preceded `# comment` stripped) — or undefined when it
+ * cannot be read (an unterminated quote, an escape JSON does not share).
+ */
+function scalarText(raw) {
+    const text = raw.trim();
+    if (text.startsWith('"') || text.startsWith("'")) {
+        const close = endOfQuoted(text, 0, text.length);
+        if (close < 0 || !/^\s*(?:#.*)?$/.test(text.slice(close)))
+            return undefined;
+        const quoted = text.slice(0, close);
+        if (quoted.startsWith("'"))
+            return quoted.slice(1, -1).replace(/''/g, "'");
+        try {
+            return JSON.parse(quoted);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return text.replace(/\s+#.*$/, "");
+}
+/** The end of an inline scalar value starting at `i` on its line (before any trailing comment). */
+function endOfInlineScalar(text, i, lineEnd) {
+    const start = skipSpace(text, i, lineEnd);
+    if (text[start] === '"' || text[start] === "'") {
+        const close = endOfQuoted(text, start, lineEnd);
+        return close < 0 ? lineEnd : close;
+    }
+    const comment = /[ \t]+#/.exec(text.slice(start, lineEnd));
+    let end = comment ? start + comment.index : lineEnd;
+    while (end > start && /\s/.test(text[end - 1]))
+        end--;
+    return end;
+}
+/** Parse the flow mapping whose `{` is at `open`; undefined when it is not one. */
+function parseFlowMapping(text, open, end) {
+    if (text[open] !== "{")
+        return undefined;
+    const entries = [];
+    let i = skipSpace(text, open + 1, end);
+    while (i < end && text[i] !== "}") {
+        let key;
+        if (text[i] === '"' || text[i] === "'") {
+            const close = endOfQuoted(text, i, end);
+            if (close < 0)
+                return undefined;
+            const unquoted = scalarText(text.slice(i, close));
+            if (unquoted === undefined)
+                return undefined;
+            key = unquoted;
+            i = close;
+        }
+        else {
+            const colon = text.indexOf(":", i);
+            if (colon < 0 || colon >= end)
+                return undefined;
+            key = text.slice(i, colon).trim();
+            i = colon;
+        }
+        i = skipSpace(text, i, end);
+        if (text[i] !== ":")
+            return undefined;
+        const valueStart = skipSpace(text, i + 1, end);
+        const valueEnd = endOfFlowValue(text, valueStart, end);
+        if (valueEnd < 0)
+            return undefined;
+        entries.push({ key, valueStart, valueEnd });
+        i = skipSpace(text, valueEnd, end);
+        if (text[i] === ",")
+            i = skipSpace(text, i + 1, end);
+        else if (text[i] !== "}")
+            return undefined;
+    }
+    if (text[i] !== "}")
+        return undefined;
+    return { open, close: i, entries };
+}
+function locateFlow(text, open, end, file) {
+    const out = [];
+    let i = skipSpace(text, open + 1, end);
+    while (i < end && text[i] !== "]") {
+        const index = out.length;
+        const element = parseFlowMapping(text, i, end);
+        if (element === undefined)
+            cannotLocate(file, index, "a { … } mapping");
+        const typeEntry = element.entries.find((e) => e.key === "type");
+        const dataEntry = element.entries.find((e) => e.key === "data");
+        if (typeEntry === undefined)
+            cannotLocate(file, index, "its type");
+        if (dataEntry === undefined)
+            cannotLocate(file, index, "its data");
+        const type = scalarText(text.slice(typeEntry.valueStart, typeEntry.valueEnd));
+        if (type === undefined)
+            cannotLocate(file, index, "its type");
+        const data = parseFlowMapping(text, dataEntry.valueStart, end);
+        if (data === undefined)
+            cannotLocate(file, index, "its data mapping");
+        out.push({
+            type,
+            form: "flow",
+            dataOpen: data.open,
+            dataClose: data.close,
+            entryColumn: -1,
+            entries: data.entries,
+        });
+        i = skipSpace(text, element.close + 1, end);
+        if (text[i] === ",")
+            i = skipSpace(text, i + 1, end);
+        else if (text[i] !== "]")
+            cannotLocate(file, index, "the , or ] after it");
+    }
+    if (text[i] !== "]")
+        cannotLocate(file, undefined, "the closing ]");
+    return out;
+}
+function splitLines(text, start, end) {
+    const lines = [];
+    let i = start;
+    while (i < end) {
+        let nl = text.indexOf("\n", i);
+        if (nl < 0 || nl > end)
+            nl = end;
+        const body = text.slice(i, nl);
+        const indent = body.length - body.trimStart().length;
+        lines.push({ start: i, end: nl, indent, blank: body.trim() === "" });
+        i = nl + 1;
+    }
+    return lines;
+}
+const BLOCK_KEY_RE = /^([A-Za-z_][\w-]*):(?:[ \t]+(.*?))?[ \t]*$/;
+function locateBlock(text, lines, file) {
+    const first = lines.find((l) => !l.blank);
+    if (first === undefined)
+        return [];
+    const itemIndent = first.indent;
+    const isItemStart = (l) => !l.blank && l.indent === itemIndent && text.startsWith("- ", l.start + itemIndent);
+    const items = [];
+    for (const line of lines) {
+        if (line.blank) {
+            items.at(-1)?.push(line);
+            continue;
+        }
+        if (isItemStart(line))
+            items.push([line]);
+        else if (line.indent > itemIndent && items.length > 0)
+            items.at(-1).push(line);
+        else
+            cannotLocate(file, items.length, "a block sequence item");
+    }
+    const keyColumn = itemIndent + 2;
+    return items.map((item, index) => {
+        // A key line sits at the item's key column (the first one after `- `).
+        const keyAt = (l) => {
+            if (l.blank || l.indent > keyColumn)
+                return undefined;
+            if (l.indent !== keyColumn && l !== item[0])
+                return undefined;
+            return BLOCK_KEY_RE.exec(text.slice(l.start + keyColumn, l.end));
+        };
+        let type;
+        let dataLine = -1;
+        for (const [n, l] of item.entries()) {
+            const m = keyAt(l);
+            if (m?.[1] === "type" && m[2] !== undefined)
+                type = scalarText(m[2]);
+            if (m?.[1] === "data")
+                dataLine = n;
+        }
+        if (type === undefined)
+            cannotLocate(file, index, "its type");
+        if (dataLine < 0)
+            cannotLocate(file, index, "its data");
+        const data = item[dataLine];
+        if (keyAt(data)?.[2] !== undefined)
+            cannotLocate(file, index, "its data mapping");
+        const entryColumn = keyColumn + 2;
+        const entries = [];
+        // An entry's value ends at its line's scalar (before any comment), or at
+        // the last deeper line when the value continues below it.
+        let open;
+        let lastDeep = -1;
+        const close = () => {
+            if (open !== undefined) {
+                const { key, valueStart, lineEnd, inlineEnd } = open;
+                entries.push({ key, valueStart, valueEnd: lastDeep > lineEnd ? lastDeep : inlineEnd });
+            }
+            open = undefined;
+        };
+        for (const l of item.slice(dataLine + 1)) {
+            if (l.blank)
+                continue;
+            if (l.indent <= keyColumn)
+                break;
+            if (l.indent === entryColumn) {
+                const m = BLOCK_KEY_RE.exec(text.slice(l.start + entryColumn, l.end));
+                if (!m)
+                    cannotLocate(file, index, "a data entry");
+                close();
+                const key = m[1];
+                const valueStart = l.start + entryColumn + key.length + 1;
+                open = {
+                    key,
+                    valueStart,
+                    lineEnd: l.end,
+                    inlineEnd: endOfInlineScalar(text, valueStart, l.end),
+                };
+            }
+            else if (l.indent < entryColumn || open === undefined) {
+                cannotLocate(file, index, "a data entry");
+            }
+            lastDeep = l.end;
+        }
+        close();
+        return {
+            type,
+            form: "block",
+            dataOpen: data.end,
+            dataClose: data.end,
+            entryColumn,
+            entries,
+        };
+    });
+}
+/**
+ * Locate a page's `sections[]` in its frontmatter — the prettier-formatted
+ * flow form (`sections:\n  [ { "id": …, "type": …, "data": { … } }, … ]`)
+ * or the block form (`  - id: …\n    type: …\n    data:\n      key: value`).
+ * Undefined when the page has no frontmatter or no column-0 `sections:` key.
+ * Any other shape throws `TemplateError` naming the element (D5).
+ */
+export function locatePageSections(text, file) {
+    const open = /^---\r?\n/.exec(text);
+    if (!open)
+        return undefined;
+    const closeMatch = /^---[ \t]*\r?$/m.exec(text.slice(open[0].length));
+    if (!closeMatch)
+        return undefined;
+    const fmStart = open[0].length;
+    const fmEnd = fmStart + closeMatch.index;
+    const key = /^sections:[ \t]*/m.exec(text.slice(fmStart, fmEnd));
+    if (!key)
+        return undefined;
+    const afterKey = fmStart + key.index + key[0].length;
+    // The value ends at the next column-0 key, or the frontmatter's end.
+    // A column-0 `- ` line is an indentless sequence item, not a key.
+    const nextKey = /\n(?=[^\s#-])/.exec(text.slice(afterKey, fmEnd));
+    const valueEnd = nextKey ? afterKey + nextKey.index : fmEnd;
+    const first = skipSpace(text, afterKey, valueEnd);
+    if (text[first] === "[")
+        return locateFlow(text, first, valueEnd, file);
+    const lineEnd = text.indexOf("\n", afterKey);
+    if (lineEnd >= 0 && text.slice(afterKey, lineEnd).trim() === "") {
+        const lines = splitLines(text, lineEnd + 1, valueEnd);
+        const firstLine = lines.find((l) => !l.blank);
+        if (firstLine === undefined || text.startsWith("- ", firstLine.start + firstLine.indent)) {
+            return locateBlock(text, lines, file);
+        }
+    }
+    return cannotLocate(file, undefined, "a flow or block sequence");
+}
+/** The frontmatter's column-0 `type:` value, or undefined when it has none. */
+function pageTypeOf(text, file) {
+    const fm = /^---\r?\n([\s\S]*?)\r?\n---[ \t]*\r?$/m.exec(text);
+    if (!fm || fm.index !== 0)
+        return undefined;
+    const m = /^type:[ \t]*(.+?)[ \t]*$/m.exec(fm[1]);
+    if (!m)
+        return undefined;
+    const type = scalarText(m[1]);
+    if (type === undefined) {
+        throw new TemplateError(`${file}: type — cannot read the page type for a design preset`);
+    }
+    return type;
+}
+/**
+ * Set one look field on section `index` of a page, splicing only its value
+ * span (D5): an existing value is replaced; an absent field is inserted as
+ * `data`'s first entry. Throws `TemplateError` when the page cannot be located.
+ */
+export function setSectionLookField(text, file, index, field, value) {
+    const section = locatePageSections(text, file)?.[index];
+    if (section === undefined)
+        cannotLocate(file, index, "the section");
+    const rendered = JSON.stringify(value);
+    const existing = section.entries.find((e) => e.key === field);
+    if (section.form === "flow") {
+        if (existing !== undefined) {
+            return text.slice(0, existing.valueStart) + rendered + text.slice(existing.valueEnd);
+        }
+        const entry = `${JSON.stringify(field)}: ${rendered}`;
+        const firstEntry = section.entries[0];
+        if (firstEntry === undefined) {
+            return `${text.slice(0, section.dataOpen)}{ ${entry} }${text.slice(section.dataClose + 1)}`;
+        }
+        // The first entry's key starts where the whitespace after `{` ends.
+        const keyStart = skipSpace(text, section.dataOpen + 1, firstEntry.valueStart);
+        const between = text.slice(section.dataOpen + 1, keyStart);
+        const nl = between.lastIndexOf("\n");
+        const separator = nl < 0 ? " " : between.slice(nl);
+        return `${text.slice(0, keyStart)}${entry},${separator}${text.slice(keyStart)}`;
+    }
+    if (existing !== undefined) {
+        return `${text.slice(0, existing.valueStart)} ${rendered}${text.slice(existing.valueEnd)}`;
+    }
+    const line = `\n${" ".repeat(section.entryColumn)}${field}: ${rendered}`;
+    return text.slice(0, section.dataOpen) + line + text.slice(section.dataOpen);
+}
+/**
+ * Write a validated preset block's look fields onto the sections a page
+ * already places, for the pages whose `type:` is in `opts.pageTypes` (the
+ * roster's placed set) and has a preset. Never adds, removes, reorders,
+ * retypes or re-ids a section; never changes a byte outside the value it
+ * sets. Returns only the pages whose text changed. Pure; trusts its input to
+ * have passed `validateDesignPresets`.
+ */
+export function applyDesignPresets(pages, sections, opts) {
+    const changed = [];
+    const applied = [];
+    for (const page of pages) {
+        const pageType = pageTypeOf(page.text, page.path);
+        if (pageType === undefined || !opts.pageTypes.has(pageType))
+            continue;
+        if (!hasOwn(sections, pageType))
+            continue;
+        const presets = sections[pageType];
+        const located = locatePageSections(page.text, page.path);
+        if (located === undefined)
+            continue;
+        let text = page.text;
+        located.forEach((section, index) => {
+            const preset = hasOwn(presets, section.type) ? presets[section.type] : undefined;
+            if (!isPlainObject(preset))
+                return;
+            for (const [field, value] of Object.entries(preset)) {
+                text = setSectionLookField(text, page.path, index, field, value);
+                applied.push({ path: page.path, pageType, index, sectionType: section.type, field });
+            }
+        });
+        if (text !== page.text)
+            changed.push({ path: page.path, text });
+    }
+    return { pages: changed, applied };
+}