@heroiclands/package-build 22.15.0 → 22.16.0

package/engine/anchors.mjs

@@ -12,7 +12,7 @@
  */
 
 /**
- * The anchors a note declares on its headings — read in one place.
+ * The anchors a note declares on headings and captioned blocks.
  *
  * **A leaf, deliberately.** This is asked by the link checker, by the content
  * index, and by the builds that emit a link, and they cannot all import one
@@ -25,6 +25,8 @@
  * @module
  */
 
+import { scanCaptions } from "./content-captions.mjs";
+
 /**
  * A heading, and the `{#slug}` anchor it declares.
  *
@@ -38,11 +40,10 @@
 const HEADING = /^\s*(#{1,6})\s+(.+?)\s*#*\s*$/;
 const ANCHOR = /^(.*?)\s*\{#([^}]+)\}\s*$/;
 /**
- * The `{#slug}` anchors a note's body declares, with where each one sits.
+ * The `{#slug}` and `:::caption {#slug}` anchors a note declares.
  *
- * Only headings carrying an explicit anchor are collected. A bare `#` heading
- * also starts a journal page, but it declares no slug, so nothing can address
- * it with `#…` — listing it would offer a link that cannot be written.
+ * A bare `#` heading starts a journal page without declaring a slug. Captioned
+ * blocks declare a slug and start an addressable journal page.
  *
  * @param {string} body - The note's markdown body, frontmatter already removed.
  * @param {number} [bodyLine] - The 1-based file line the body starts on, from
@@ -79,5 +80,13 @@ export function collectAnchors(body, bodyLine = 1) {
             line: bodyLine + i,
         });
     }
-    return anchors;
+    for (const caption of scanCaptions(body).captions) {
+        anchors.push({
+            slug: caption.id,
+            name: caption.label,
+            level: 1,
+            line: bodyLine + caption.line - 1,
+        });
+    }
+    return anchors.sort((a, b) => a.line - b.line);
 }

package/engine/asset-bindings.mjs

@@ -22,7 +22,11 @@ function assetFiles(root) {
     return files;
 }
 
-/** Check configured foreign Address bindings against fetched indexes. */
+/**
+ * Check configured foreign Address bindings against fetched indexes.
+ * @param {object} config
+ * @param {{foreignIndex?: Map<string, object>, assets?: object[]}} [options]
+ */
 export function checkForeignAssetBindings(config, { foreignIndex, assets } = {}) {
     const copies = (assets ?? config.packageBuild?.assets ?? []).filter((asset) => asset.bindsTo);
     if (!copies.length) return [];
@@ -39,7 +43,7 @@ export function checkForeignAssetBindings(config, { foreignIndex, assets } = {})
                 {
                     file: "package-build.config.yaml",
                     severity: "error",
-                    message: `asset binding index for ${bindsTo.package} is unavailable; run content-build deps fetch`,
+                    message: `asset binding index for ${bindsTo.package} is unavailable; run package-build deps fetch`,
                 },
             ];
     }

package/engine/base-compiler.mjs

@@ -63,6 +63,10 @@
 
 import { authoredFrontmatter } from "./index-records.mjs";
 import { renderSecretBlocks } from "./content-secrets.mjs";
+import { scanAdmonitions } from "./content-admonitions.mjs";
+import { scanCaptions } from "./content-captions.mjs";
+import { renderMarkdownExpressions } from "./markdown-expressions.mjs";
+import { isGmNote } from "./note-vocabulary.mjs";
 import { cloneAddressState } from "./address-values.mjs";
 import fs from "fs";
 import path from "path";
@@ -82,7 +86,7 @@ import {
 import { isNoteRecord, noteFile } from "./index-records.mjs";
 import { reduceAddressFields } from "./address-fields.mjs";
 import { artPathname, artSlot, unacceptedArtMessage, unresolvedArtMessage } from "./art-fields.mjs";
-import { emitDiagnostic } from "./diagnostics.mjs";
+import { emitDiagnostic, positionOfLiteral } from "./diagnostics.mjs";
 import { assertNoDeclaredPackage } from "./note-package.mjs";
 import { assertNoDeclaredFolder } from "./folder-notes.mjs";
 import {
@@ -434,6 +438,7 @@ export class BasePackCompiler {
      *   routes to no pack at all — a build failure, never a silent drop.
      */
     routesHere(fm) {
+        if (isGmNote(fm) && !this.router?.privateOf?.(this.packName)) return false;
         if (!this.router || !this.packName || !this.docType) return true;
         return (
             this.router.resolve(fm, this.docType, this.packSystem ?? undefined) === this.packName
@@ -600,7 +605,6 @@ export class BasePackCompiler {
         // that converts no prose still compiles a document that carries art.
         this.linkIndex = this.corpus.linkIndex;
         if (this.constructor.convertsWikilinks) {
-            this.contentDocs = this.corpus.contentDocs;
             this.sqlTables = this.corpus.sqlTables;
         }
         // The package's declared present, read once from the same corpus — so
@@ -622,7 +626,8 @@ export class BasePackCompiler {
      *   that does not convert.
      */
     convertBody(fm, body) {
-        const secretError = renderSecretBlocks(body, "book").errors[0];
+        const secretError =
+            renderSecretBlocks(body, "book").errors[0] ?? scanAdmonitions(body).errors[0];
         if (secretError) {
             const error = new Error(secretError.message);
             error.position = {
@@ -638,13 +643,35 @@ export class BasePackCompiler {
         const name = resolveName(fm);
         const { absPath, bodyLine, bodyColumn } = this.currentNote ?? {};
         const { markdown: tabulated, lineMap } = expandNoteTables(body, {
-            docs: this.contentDocs,
             name,
-            fm,
             bodyLine,
             sqlTables: absPath ? this.sqlTables?.get(absPath) : undefined,
         });
-        const { markdown, unresolved } = convertNoteWikilinks(tabulated, {
+        const captionError = scanCaptions(tabulated).errors[0];
+        if (captionError) {
+            const error = new Error(captionError.message);
+            error.position = {
+                line:
+                    (bodyLine ?? 1) +
+                    (lineMap[captionError.line - 1]?.line ?? captionError.line - 1),
+                column: captionError.column,
+            };
+            throw error;
+        }
+        const expressions = renderMarkdownExpressions(tabulated, {
+            fm,
+            dates: reckoningContext(this.linkIndex),
+            sqlResults: absPath ? this.sqlTables?.inline?.get(absPath) : undefined,
+            file: absPath,
+            bodyLine,
+        });
+        if (expressions.findings.length) {
+            const finding = expressions.findings[0];
+            const error = new Error(finding.message);
+            error.position = { line: finding.line, column: finding.column };
+            throw error;
+        }
+        const { markdown, unresolved } = convertNoteWikilinks(expressions.markdown, {
             type: fm.type,
             id: fm.id,
             // Where this note is, so a link that resolves nowhere is reported
@@ -808,7 +835,7 @@ export class BasePackCompiler {
      * a line rather than at a note.
      *
      * Silent where nothing can answer — no published schema, or a subtype the
-     * artifact does not name. `content-build lint` says that out loud once for
+     * artifact does not name. `package-build lint` says that out loud once for
      * the whole build rather than once per note.
      *
      * @param {object} fm - The note's frontmatter.
@@ -1211,13 +1238,22 @@ export class BasePackCompiler {
                 this.onCompiled(fm, doc);
             } catch (err) {
                 this.errorCount++;
+                const repeatedAnchor = err.message.match(
+                    /declares the anchor \{#([^}]+)\} on more than one heading/,
+                );
+                const position =
+                    err.position ??
+                    (repeatedAnchor ?
+                        positionOfLiteral(
+                            fs.readFileSync(absPath, "utf8"),
+                            `{#${repeatedAnchor[1]}}`,
+                            2,
+                        )
+                    :   undefined);
                 // `position` is set by whatever failed if it knew where — an
                 // unresolved address, a bad table directive — so the report
                 // points at the line rather than at the note.
-                this.noteError(
-                    `${this.noteLabel(fm)} failed to compile: ${err.message}`,
-                    err.position,
-                );
+                this.noteError(`${this.noteLabel(fm)} failed to compile: ${err.message}`, position);
             }
         }
 

package/engine/being-measurements.mjs

@@ -0,0 +1,70 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+
+const INCHES_PER_METRE = 39.3701;
+const POUNDS_PER_KILOGRAM = 2.20462;
+
+/** Measurements are displayed as whole imperial units. */
+function safeRound(value) {
+    const rounded = Math.round(value);
+    return Number.isSafeInteger(rounded) && rounded >= 0 ? rounded : null;
+}
+
+/** Read a being's height as a whole number of inches. */
+export function parseBeingHeight(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) && value >= 0 ? safeRound(value * INCHES_PER_METRE) : null;
+    if (typeof value !== "string") return null;
+    const metric = /^(\d+(?:\.\d+)?) ?m$/.exec(value);
+    if (metric) return safeRound(Number(metric[1]) * INCHES_PER_METRE);
+    const imperial = /^(\d+)'(?:\s*(\d{1,2})")?$/.exec(value);
+    if (!imperial) return null;
+    const inches = Number(imperial[2] ?? 0);
+    return inches <= 11 ? safeRound(Number(imperial[1]) * 12 + inches) : null;
+}
+
+/** Read a being's weight as a whole number of pounds. */
+export function parseBeingWeight(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) && value >= 0 ? safeRound(value * POUNDS_PER_KILOGRAM) : null;
+    if (typeof value !== "string") return null;
+    const metric = /^(\d+(?:\.\d+)?) ?kg$/.exec(value);
+    if (metric) return safeRound(Number(metric[1]) * POUNDS_PER_KILOGRAM);
+    const imperial = /^(\d+) ?lbs$/.exec(value);
+    return imperial ? safeRound(Number(imperial[1])) : null;
+}
+
+/** Show a being's height in feet and inches. */
+export function displayBeingHeight(value) {
+    const inches = parseBeingHeight(value);
+    if (inches === null) return String(value);
+    const feet = Math.floor(inches / 12);
+    const remainder = inches % 12;
+    return String(feet) + "′" + (remainder ? " " + String(remainder) + "″" : "");
+}
+
+/** Show a being's weight in pounds. */
+export function displayBeingWeight(value) {
+    const pounds = parseBeingWeight(value);
+    return pounds === null ? String(value) : String(pounds) + " lbs";
+}
+
+/** Check one authored being measurement at its frontmatter position. */
+export function checkBeingMeasurement(note, key, parse) {
+    const value = note.fm?.data?.[key];
+    if (value === undefined || value === null || parse(value) !== null) return [];
+    return [
+        {
+            ...(note.file ? { file: note.file } : {}),
+            ...positionOfFrontmatterPath(note.raw ?? "", ["data", key]),
+            severity: "error",
+            message:
+                "data." +
+                key +
+                (key === "height" ?
+                    " needs metres or feet and inches, such as 1.91m or 6' 3\""
+                :   " needs kilograms or pounds, such as 85kg or 187 lbs"),
+        },
+    ];
+}

package/engine/calendar-artifacts.mjs

@@ -32,7 +32,7 @@ function readIndex(file) {
     const display = path.relative(process.cwd(), file) || file;
     if (!fs.existsSync(file)) {
         const error = new Error(
-            `${display}: error: content index is absent; run content-build content-index`,
+            `${display}: error: content index is absent; run package-build content-index`,
         );
         error.located = true;
         throw error;

package/engine/calendar-choice.mjs

@@ -0,0 +1,32 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
+import { isAddressTuple, parseAddress, renderAddress } from "./address.mjs";
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+
+/**
+ * Require a being's or place's chosen calendar to address a calendar note.
+ * @param {object} note
+ * @param {{index?: object}} [options]
+ */
+export function checkCalendarChoice(note, { index } = {}) {
+    const value = note.fm?.data?.calendar;
+    if (value === undefined || value === null || !index?.addressHit) return [];
+    const tuple = parseAddress(value, {
+        package: index.contentPackage,
+        system: "note",
+        type: "lore",
+        types: index.types,
+        packages: index.packages,
+    });
+    if (tuple.reason || tuple.type !== "lore") return [];
+    const target = index.addressHit(renderAddress(tuple));
+    if (!target || (target.fm ?? target).subType === "calendar") return [];
+    return [
+        {
+            file: note.file,
+            ...positionOfFrontmatterPath(note.raw ?? "", ["data", "calendar"]),
+            severity: "error",
+            message: `data.calendar ${isAddressTuple(value) ? renderAddress(value) : value} names lore whose subType is not calendar`,
+        },
+    ];
+}

package/engine/calendar-human.mjs

@@ -0,0 +1,71 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
+import { calendarStructure } from "./calendars.mjs";
+
+/** The labels a human date may use to name one era. */
+export function eraNames(era) {
+    return [era.abbreviation, era.name, era.marker, era.era.split(".").at(-1), era.era].filter(
+        (value) => typeof value === "string" && value.trim(),
+    );
+}
+
+/** Translate a named date into the addressed form read by the date parser. */
+export function addressedCalendarDate(text, eras) {
+    const first = /^(\d{1,2})\s+(.+)$/.exec(text);
+    let day = null;
+    let rest = text;
+    if (first) {
+        const firstWord = first[2].split(/[\s,]/)[0].toLowerCase();
+        const hasMonth = (calendarStructure(eras[0].calendar).months ?? []).some((month) =>
+            [month.name, month.abbreviation].some(
+                (name) => typeof name === "string" && name.toLowerCase().startsWith(firstWord),
+            ),
+        );
+        if (hasMonth) {
+            day = first[1];
+            rest = first[2];
+        }
+    }
+    const months = calendarStructure(eras[0].calendar).months ?? [];
+    const matchingMonths = months.flatMap((month, index) =>
+        [month.name, month.abbreviation]
+            .filter((name) => typeof name === "string" && name)
+            .filter((name) => rest.toLowerCase().startsWith(name.toLowerCase()))
+            .filter((name) => /^[\s,]/.test(rest.slice(name.length)))
+            .map((name) => ({ name, number: index + 1 })),
+    );
+    if (day !== null && matchingMonths.length === 0)
+        throw new RangeError("date names no month in this calendar");
+    const longest = Math.max(0, ...matchingMonths.map((month) => month.name.length));
+    const choices = [
+        ...new Set(
+            matchingMonths
+                .filter((month) => month.name.length === longest)
+                .map((month) => month.number),
+        ),
+    ];
+    if (choices.length > 1) throw new RangeError("date names an ambiguous month");
+    const monthName = matchingMonths.find((month) => month.name.length === longest)?.name;
+    const afterMonth = monthName ? rest.slice(monthName.length).replace(/^,?\s+/, "") : rest;
+    const match = /^(~?-?\d+)(?:\s+(.+?))?(?:\s+(\d{2}:\d{2}:\d{2}))?$/.exec(afterMonth);
+    if (!match) return null;
+    const [, year, eraName, clock] = match;
+    const selected =
+        eraName === undefined && eras.length === 1 ? eras[0]
+        : eraName === undefined ? null
+        : (() => {
+                const found = eras.filter((era) =>
+                    eraNames(era).some((name) => name.toLowerCase() === eraName.toLowerCase()),
+                );
+                if (found.length > 1) throw new RangeError(`date names ambiguous era ${eraName}`);
+                return found[0] ?? null;
+            })();
+    if (!selected)
+        throw new RangeError(
+            eraName === undefined ?
+                "date needs an era in this calendar"
+            :   `date names unknown era ${eraName}`,
+        );
+    const time = clock ? `:${clock.replaceAll(":", "")}` : "";
+    return `${year}${choices.length ? `/${choices[0]}` : ""}${day === null ? "" : `/${day}${time}`} ${selected.qualifier}`;
+}

package/engine/calendar-notes.mjs

@@ -145,7 +145,7 @@ export const CALENDAR_FIELDS = Object.freeze([
     },
     {
         name: "eras",
-        shape: "list of `{ shortcode, name, marker?, abbreviation?, proclaimedBy?, start, end? }`",
+        shape: "list of `{ shortcode, name, marker?, abbreviation?, proclaimedBy?, start, end?, label? }`",
         kind: "list",
         describe:
             "The year-counts kept in this calendar. A marker names one era and uses these months.",
@@ -669,6 +669,35 @@ function checkEraShortcodes(note) {
             );
         }
         seen.add(shortcode);
+        if (era.label === undefined) return;
+        const label = era.label;
+        const forms = typeof label === "string" ? { after: label } : label;
+        if (!forms || typeof forms !== "object" || Array.isArray(forms)) {
+            findings.push(
+                atData(
+                    note,
+                    ["eras", position, "label"],
+                    "error",
+                    "an era label is a string or an {after, before} map",
+                ),
+            );
+            return;
+        }
+        for (const [key, value] of Object.entries(forms)) {
+            if (
+                !["after", "before"].includes(key) ||
+                typeof value !== "string" ||
+                value.split("{date}").length !== 2
+            )
+                findings.push(
+                    atData(
+                        note,
+                        ["eras", position, "label", key],
+                        "error",
+                        "an era label uses after or before with exactly one {date} slot",
+                    ),
+                );
+        }
     });
     return findings;
 }
@@ -752,8 +781,16 @@ function eraEntries(eras, dateContext = {}) {
     for (const era of Array.isArray(eras) ? eras : []) {
         const shortcode = String(era?.shortcode ?? "");
         if (!shortcode) continue;
-        const start = parseNoteDate(era?.start, { ...dateContext, allowUnknown: false }).date;
-        const end = parseNoteDate(era?.end, { ...dateContext, allowUnknown: false }).date;
+        const start = parseNoteDate(era?.start, {
+            ...dateContext,
+            allowUnknown: false,
+            ignoreEraBounds: true,
+        }).date;
+        const end = parseNoteDate(era?.end, {
+            ...dateContext,
+            allowUnknown: false,
+            ignoreEraBounds: true,
+        }).date;
         entries[shortcode] = written({
             name: String(era?.name ?? ""),
             abbreviation: era?.abbreviation === undefined ? undefined : String(era.abbreviation),
@@ -818,6 +855,7 @@ function moonEntries(moon, body, name, months, dateContext = {}) {
  * @param {string} [opts.contentPackage] - The package shipping the note, which
  *   is a fact about the tree rather than about the note: a note never declares
  *   its own package.
+ * @param {object} [opts.dateContext] - Calendar conversion context.
  * @returns {object} The definition.
  */
 export function compileCalendar({ note, invariants, contentPackage, dateContext = {} }) {

package/engine/calendars.mjs

@@ -104,6 +104,13 @@ export function canonicalYear(year, epoch = CANONICAL_EPOCH) {
     return epoch + (year > 0 ? year - 1 : year);
 }
 
+/** The signed year a reckoning counts at a canonical year, without year zero. */
+export function eraYear(canonical, epoch = CANONICAL_EPOCH) {
+    if (!Number.isSafeInteger(canonical) || !Number.isSafeInteger(epoch))
+        throw new RangeError("era conversion needs whole canonical and epoch years");
+    return canonical >= epoch ? canonical - epoch + 1 : canonical - epoch;
+}
+
 /**
  * The total-order key a date sorts on.
  *
@@ -267,7 +274,7 @@ export function calendarStructure(calendar) {
 /**
  * How long one month of a calendar is, or `null` where the calendar is silent.
  *
- * @param {{months?: readonly CalendarMonth[]|null}} [calendar] - The calendar.
+ * @param {{months?: readonly CalendarMonth[]|null}|undefined} calendar - The calendar.
  * @param {number} month - The month, numbered from 1.
  * @returns {number|null} Its length in days, or `null`.
  */

package/engine/changelog-lint.mjs

@@ -40,7 +40,7 @@
 
 import { codeRegions } from "./code-fences.mjs";
 
-/** The generated scaffold `content-build`/Changesets writes, never authored prose. */
+/** The generated scaffold `package-build`/Changesets writes, never authored prose. */
 const RELEASE_HEADING_RE = /^## /;
 const CHANGES_HEADING_RE = /^### (?:Major|Minor|Patch) Changes\s*$/;
 
@@ -79,7 +79,7 @@ const SCOREBOARD_PATTERNS = [
 
 /** A token that reads as code but sits outside any code span — warning only. */
 const CODE_TOKEN_RE =
-    /\b[a-z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*(?:\(\))?\b|\b[\w-]+(?:\/[\w-]+)+\.[A-Za-z]{1,8}\b|\b[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+\b/g;
+    /(?<![\p{L}\p{N}\p{M}_])[a-z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*(?:\(\))?(?![\p{L}\p{N}\p{M}_])|\b[\w-]+(?:\/[\w-]+)+\.[A-Za-z]{1,8}\b|\b[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+\b/gu;
 
 /** Bullets over this many words read as a paragraph, not a release note. */
 const MAX_BULLET_WORDS = 40;

package/engine/code-fences.mjs

@@ -46,110 +46,36 @@
  * prevent.
  */
 
+import { parseExtensionAttributes } from "./extension-attributes.mjs";
+
 /** A fence line, capturing its indent, its marker, and its info string. */
 export const FENCE_LINE = /^([ \t]*)(`{3,}|~{3,})[ \t]*([^\r\n]*)$/;
 
 /**
- * A fence's info string, read as **org-babel header arguments**.
- *
- * A directive fence carries statements *about the directive* that are no part of
- * the query it holds — whether an empty result is intended, what heading level a
- * section takes, later a caption. Those started as an ad-hoc bare word
- * (`allow-empty`) and a `key=value` (`section-level=3`), each matched by its own
- * regex: a grammar only in the sense that two regexes are one, and with no room
- * to add a third property without adding a third spelling.
- *
- * Org-mode settled this long ago. A babel source block writes them after the
- * language as `:key value`, which is a real grammar with a specification, a
- * parser, and an editor that already completes it.
- *
- * ```text
- * ```sql :section-level 3 :allow-empty
- * ```
- *
- * **The language word stays first and stays plain.** `sql` is what GitHub,
- * Prettier and every other markdown reader match on to syntax-highlight the
- * block, so it leads and the header args follow; a reader that does not know
- * them sees an ordinary SQL block.
- *
- * The grammar, matching org's:
- *
- * - a key is `:name` **starting a word** — a colon inside or ending a word is
- *   text, so `:caption Gear: the tables` is one argument;
- * - a value runs to the next key or the end of the string, spaces included, and
- *   is trimmed;
- * - a key with no value is `true`, which is what a statement like
- *   `:allow-empty` is;
- * - a value may be `"quoted"` to hold a word that would otherwise read as a
- *   key — the one ambiguity org has too;
- * - a repeated key takes its last value.
- *
- * @param {string} info - The text after the fence marker.
- * @returns {{language: string, args: Record<string, string|true>}} The language,
- *   lowercased, and the header arguments in written order.
+ * Read a language name and optional braced attributes from a code fence.
+ * @param {string} info - Text after the fence marker.
+ * @returns {{language: string, args: Record<string, string>, problems: string[]}}
+ *   Parsed values and syntax findings.
  */
 export function parseHeaderArgs(info) {
     const text = String(info ?? "").trim();
-    if (!text) return { language: "", args: {} };
-
-    // The language is the first word; everything after it is header arguments.
-    const firstKey = text.search(/(?:^|\s):[A-Za-z][\w-]*/);
-    const head = (firstKey === -1 ? text : text.slice(0, firstKey)).trim();
-    const language = head.split(/\s+/)[0]?.toLowerCase() ?? "";
-    if (firstKey === -1) return { language, args: {} };
-
-    const args = {};
-    const rest = text.slice(firstKey);
-    // Split before each key: a colon that starts a word. A colon inside or at
-    // the end of a word is ordinary text, which is what keeps `Gear:` a value.
-    const quoted = quotedSpans(rest);
-    const re = /(?:^|\s):([A-Za-z][\w-]*)/g;
-    const keys = [];
-    let m;
-    while ((m = re.exec(rest)) !== null) {
-        // A key-like word inside a quoted value is part of the value — that is
-        // the whole reason quoting exists here.
-        if (quoted.some(([from, to]) => m.index >= from && m.index < to)) continue;
-        keys.push({ name: m[1], at: m.index, end: re.lastIndex });
-    }
-    for (let i = 0; i < keys.length; i += 1) {
-        const from = keys[i].end;
-        const to = i + 1 < keys.length ? keys[i + 1].at : rest.length;
-        const raw = rest.slice(from, to).trim();
-        args[keys[i].name] = raw === "" ? true : unquote(raw);
-    }
-    return { language, args };
-}
-
-/**
- * The `"…"` and `'…'` spans in a header-argument string, as [start, end) offsets.
- *
- * Scanned once before the keys are, so a key-like word inside a value is never
- * read as the next key.
- *
- * @param {string} text - The header-argument text.
- * @returns {Array<[number, number]>} The quoted spans.
- */
-function quotedSpans(text) {
-    const spans = [];
-    const re = /"[^"]*"|'[^']*'/g;
-    let m;
-    while ((m = re.exec(text)) !== null) spans.push([m.index, m.index + m[0].length]);
-    return spans;
-}
-
-/**
- * A header-argument value with its surrounding quotes removed.
- *
- * Quoting is how a value holds a word that would otherwise read as the next key
- * — the same escape hatch org offers, and the only one needed.
- *
- * @param {string} value - The raw value.
- * @returns {string} The value, unquoted.
- */
-function unquote(value) {
-    const m = /^"([^"]*)"$|^'([^']*)'$/.exec(value);
-    return m ? (m[1] ?? m[2]) : value;
+    if (!text) return { language: "", args: {}, problems: [] };
+    const match = /^([^\s{}]+)(?:\s+(.*))?$/.exec(text);
+    const language = match?.[1]?.toLowerCase() ?? "";
+    const rest = match?.[2]?.trim() ?? "";
+    if (!rest) return { language, args: {}, problems: [] };
+    if (!/^\{[\s\S]*\}$/.test(rest))
+        return { language, args: {}, problems: ["fence attributes need {key=value} syntax"] };
+    const parsed = parseExtensionAttributes(rest.slice(1, -1));
+    return {
+        language,
+        args: parsed.values,
+        problems: [
+            ...parsed.problems,
+            ...(parsed.id ? ["a code fence does not accept an id"] : []),
+            ...(parsed.classes.length ? ["a code fence does not accept classes"] : []),
+        ],
+    };
 }
 
 /** A list item's opening line, capturing the indent and the marker itself. */

package/engine/compile-corpus.mjs

@@ -39,7 +39,7 @@
  */
 
 import { indexRecordsFor } from "./content-index.mjs";
-import { buildContentLinkIndex, collectContentDocs } from "./helpers.mjs";
+import { buildContentLinkIndex } from "./helpers.mjs";
 import { loadPackConfig } from "./pack-config.mjs";
 import { prepareTreeSqlTables } from "./sql-tables.mjs";
 
@@ -60,8 +60,7 @@ import { prepareTreeSqlTables } from "./sql-tables.mjs";
  *   created when none is passed, and returned on the corpus either way — a note
  *   the index refuses is a note the compile must still *report*, exactly as the
  *   compile loop reported it when the loop was the first to see it.
- * @returns {Promise<{records: object[], linkIndex: object, contentDocs: object[],
- *   sqlTables: Map<string, object[]>|undefined, problems: object[]}>} The corpus,
+ * @returns {Promise<{records: object[], linkIndex: object, sqlTables: Map<string, object[]>|undefined, problems: object[]}>} The corpus,
  *   its indexes, and the notes it could not record.
  */
 export async function buildCompileCorpus({
@@ -81,12 +80,12 @@ export async function buildCompileCorpus({
         skipDirectories,
         problems: collected,
     });
-    const scope = { skipDirectories, config: resolved, records };
+    const corpusOptions = { config: resolved, records };
+    const sqlOptions = { ...corpusOptions, skipDirectories };
     return {
         records,
         problems: collected,
-        linkIndex: buildContentLinkIndex(contentBase, router, scope),
-        contentDocs: collectContentDocs(contentBase, scope),
-        sqlTables: await prepareTreeSqlTables(contentBase, scope),
+        linkIndex: buildContentLinkIndex(contentBase, router, corpusOptions),
+        sqlTables: await prepareTreeSqlTables(contentBase, sqlOptions),
     };
 }