@glw907/cairn-cms 0.60.1 → 0.62.2

package/dist/content/links.js

@@ -21,19 +21,25 @@ export function parseCairnToken(href) {
         return null;
     return { concept, id };
 }
-/** Write the `cairn:<concept>/<id>` token for a ref. The inverse of parseCairnToken, so the editor
- *  link picker and the autocomplete write exactly the form the resolver reads back. */
+/**
+ * Write the `cairn:<concept>/<id>` token for a ref. The inverse of parseCairnToken, so the editor
+ *  link picker and the autocomplete write exactly the form the resolver reads back.
+ */
 export function formatCairnToken(ref) {
     return `cairn:${ref.concept}/${ref.id}`;
 }
-/** Escape the characters that would break a markdown link's display text: a backslash and the
+/**
+ * Escape the characters that would break a markdown link's display text: a backslash and the
  *  square brackets that delimit the text. Used where a content title becomes link display text,
- *  so an unbalanced bracket in a title cannot truncate the generated link. */
+ *  so an unbalanced bracket in a title cannot truncate the generated link.
+ */
 export function escapeLinkText(text) {
     return text.replace(/[\\[\]]/g, (ch) => `\\${ch}`);
 }
-/** The cairn links a markdown body points at, in first-occurrence order, deduped by concept/id.
- *  Parses the body as mdast, so a token inside a code span or fence is never matched. */
+/**
+ * The cairn links a markdown body points at, in first-occurrence order, deduped by concept/id.
+ *  Parses the body as mdast, so a token inside a code span or fence is never matched.
+ */
 export function extractCairnLinks(body) {
     const tree = unified().use(remarkParse).use(remarkGfm).parse(body);
     const seen = new Set();

package/dist/content/manifest.d.ts

@@ -10,9 +10,11 @@ export interface ManifestEntry {
     summary?: string;
     draft: boolean;
     links: CairnRef[];
-    /** The content hashes of the media this entry references (its hero plus its body images). The
+    /**
+     * The content hashes of the media this entry references (its hero plus its body images). The
      *  main side of the media where-used index. Additive and optional: an entry with no media omits
-     *  the key, and a manifest committed before this field still parses (absent reads as no refs). */
+     *  the key, and a manifest committed before this field still parses (absent reads as no refs).
+     */
     mediaRefs?: string[];
 }
 /** The whole corpus as one committed file. `version` guards a future shape migration. */
@@ -29,22 +31,28 @@ export interface LinkTarget {
     date?: string;
     draft: boolean;
 }
-/** Build one manifest entry from a content file. Drafts are included and flagged. The id, date, and
+/**
+ * Build one manifest entry from a content file. Drafts are included and flagged. The id, date, and
  *  permalink come from entryIdentity, the same source content-index uses, so a cairn: link resolves to
- *  one URL whether the admin preview reads the manifest or the public build reads the content index. */
+ *  one URL whether the admin preview reads the manifest or the public build reads the content index.
+ */
 export declare function manifestEntryFromFile(descriptor: ConceptDescriptor, file: {
     path: string;
     raw: string;
 }): ManifestEntry;
 /** An empty manifest, the starting point when no committed file exists yet. */
 export declare function emptyManifest(): Manifest;
-/** Serialize canonically: entries sorted by concept then id, links sorted and deduped, a fixed key
- *  order, two-space pretty, and a trailing newline, so the committed file diffs cleanly in a PR. */
+/**
+ * Serialize canonically: entries sorted by concept then id, links sorted and deduped, a fixed key
+ *  order, two-space pretty, and a trailing newline, so the committed file diffs cleanly in a PR.
+ */
 export declare function serializeManifest(manifest: Manifest): string;
-/** Parse a committed manifest. Throws on malformed JSON, a wrong version, or a malformed entry, so
+/**
+ * Parse a committed manifest. Throws on malformed JSON, a wrong version, or a malformed entry, so
  *  every reader (the save guard, the delete path, the preview) sees a well-formed graph or a clear
  *  error. The build regenerates the manifest, so a real file is always canonical; this guards a
- *  hand-edited or truncated one. */
+ *  hand-edited or truncated one.
+ */
 export declare function parseManifest(raw: string): Manifest;
 /** A changed entry and the fields that differ between the built and committed manifests. */
 export interface ManifestEntryDiff {
@@ -58,17 +66,23 @@ export interface ManifestDiff {
     removed: ManifestEntry[];
     changed: ManifestEntryDiff[];
 }
-/** Compare a built manifest against a committed one, keyed by concept+id (the same identity
+/**
+ * Compare a built manifest against a committed one, keyed by concept+id (the same identity
  *  upsertEntry and removeEntry use). A changed entry names the fields that differ. Pure, so it is
- *  unit-tested apart from any build. */
+ *  unit-tested apart from any build.
+ */
 export declare function diffManifests(built: Manifest, committed: Manifest): ManifestDiff;
-/** Throw if the committed manifest drifts from what the corpus says. The canonical serialized form
+/**
+ * Throw if the committed manifest drifts from what the corpus says. The canonical serialized form
  *  is the fast-path equality guard, so semantic equality never spuriously fails. On a mismatch the
  *  error names the added, removed, and changed entries, so a raw-git content edit that leaves the
- *  committed manifest stale fails the build loudly with what drifted. */
+ *  committed manifest stale fails the build loudly with what drifted.
+ */
 export declare function verifyManifest(built: Manifest, committedRaw: string): void;
-/** Replace the entry with the same concept and id, or add it. Order does not matter, since
- *  serializeManifest sorts. This is the save path's incremental patch. */
+/**
+ * Replace the entry with the same concept and id, or add it. Order does not matter, since
+ *  serializeManifest sorts. This is the save path's incremental patch.
+ */
 export declare function upsertEntry(manifest: Manifest, entry: ManifestEntry): Manifest;
 /** Drop the entry with the given concept and id, if present. The delete path's patch. */
 export declare function removeEntry(manifest: Manifest, concept: string, id: string): Manifest;
@@ -79,12 +93,16 @@ export interface InboundLink {
     title: string;
     permalink: string;
 }
-/** Every entry whose outbound edges point at the target, excluding the target itself. The delete
+/**
+ * Every entry whose outbound edges point at the target, excluding the target itself. The delete
  *  guard reads this to name "what links here"; the backlinks panel will reuse it. Pure over the
- *  manifest, so the request-time delete path and a unit test call it the same way. */
+ *  manifest, so the request-time delete path and a unit test call it the same way.
+ */
 export declare function inboundLinks(manifest: Manifest, concept: string, id: string): InboundLink[];
-/** A resolver backed by manifest targets, for the admin preview. A miss returns undefined, so the
- *  render step marks the link broken rather than throwing. The build resolver throws instead. */
+/**
+ * A resolver backed by manifest targets, for the admin preview. A miss returns undefined, so the
+ *  render step marks the link broken rather than throwing. The build resolver throws instead.
+ */
 export declare function manifestLinkResolver(targets: {
     concept: string;
     id: string;

package/dist/content/manifest.js

@@ -8,9 +8,11 @@ import { deriveExcerpt } from './excerpt.js';
 import { entryIdentity, asString } from './identity.js';
 import { extractCairnLinks } from './links.js';
 import { extractMediaRefs } from './media-refs.js';
-/** Build one manifest entry from a content file. Drafts are included and flagged. The id, date, and
+/**
+ * Build one manifest entry from a content file. Drafts are included and flagged. The id, date, and
  *  permalink come from entryIdentity, the same source content-index uses, so a cairn: link resolves to
- *  one URL whether the admin preview reads the manifest or the public build reads the content index. */
+ *  one URL whether the admin preview reads the manifest or the public build reads the content index.
+ */
 export function manifestEntryFromFile(descriptor, file) {
     const { frontmatter, body } = parseMarkdown(file.raw);
     const { id, date, permalink } = entryIdentity(descriptor, file.path, frontmatter);
@@ -38,8 +40,10 @@ export function emptyManifest() {
 function compareRef(a, b) {
     return a.concept.localeCompare(b.concept) || a.id.localeCompare(b.id);
 }
-/** Serialize canonically: entries sorted by concept then id, links sorted and deduped, a fixed key
- *  order, two-space pretty, and a trailing newline, so the committed file diffs cleanly in a PR. */
+/**
+ * Serialize canonically: entries sorted by concept then id, links sorted and deduped, a fixed key
+ *  order, two-space pretty, and a trailing newline, so the committed file diffs cleanly in a PR.
+ */
 export function serializeManifest(manifest) {
     const entries = [...manifest.entries].sort(compareRef).map((e) => ({
         id: e.id,
@@ -54,10 +58,12 @@ export function serializeManifest(manifest) {
     }));
     return `${JSON.stringify({ version: 1, entries }, null, 2)}\n`;
 }
-/** Parse a committed manifest. Throws on malformed JSON, a wrong version, or a malformed entry, so
+/**
+ * Parse a committed manifest. Throws on malformed JSON, a wrong version, or a malformed entry, so
  *  every reader (the save guard, the delete path, the preview) sees a well-formed graph or a clear
  *  error. The build regenerates the manifest, so a real file is always canonical; this guards a
- *  hand-edited or truncated one. */
+ *  hand-edited or truncated one.
+ */
 export function parseManifest(raw) {
     const data = JSON.parse(raw);
     if (!data || typeof data !== 'object') {
@@ -108,9 +114,11 @@ export function parseManifest(raw) {
     return { version: 1, entries: obj.entries };
 }
 const keyOf = (e) => `${e.concept}/${e.id}`;
-/** Compare a built manifest against a committed one, keyed by concept+id (the same identity
+/**
+ * Compare a built manifest against a committed one, keyed by concept+id (the same identity
  *  upsertEntry and removeEntry use). A changed entry names the fields that differ. Pure, so it is
- *  unit-tested apart from any build. */
+ *  unit-tested apart from any build.
+ */
 export function diffManifests(built, committed) {
     const builtByKey = new Map(built.entries.map((e) => [keyOf(e), e]));
     const committedByKey = new Map(committed.entries.map((e) => [keyOf(e), e]));
@@ -141,10 +149,12 @@ function formatDiff(d) {
         lines.push(`  ~ ${e.concept}/${e.id} (${e.fields.join(', ')})`);
     return lines.join('\n');
 }
-/** Throw if the committed manifest drifts from what the corpus says. The canonical serialized form
+/**
+ * Throw if the committed manifest drifts from what the corpus says. The canonical serialized form
  *  is the fast-path equality guard, so semantic equality never spuriously fails. On a mismatch the
  *  error names the added, removed, and changed entries, so a raw-git content edit that leaves the
- *  committed manifest stale fails the build loudly with what drifted. */
+ *  committed manifest stale fails the build loudly with what drifted.
+ */
 export function verifyManifest(built, committedRaw) {
     const builtRaw = serializeManifest(built);
     if (committedRaw === builtRaw)
@@ -181,8 +191,10 @@ export function verifyManifest(built, committedRaw) {
         formatDiff(diff) +
         '\nRegenerate it (npm run cairn:manifest) and commit the result.');
 }
-/** Replace the entry with the same concept and id, or add it. Order does not matter, since
- *  serializeManifest sorts. This is the save path's incremental patch. */
+/**
+ * Replace the entry with the same concept and id, or add it. Order does not matter, since
+ *  serializeManifest sorts. This is the save path's incremental patch.
+ */
 export function upsertEntry(manifest, entry) {
     const entries = manifest.entries.filter((e) => !(e.concept === entry.concept && e.id === entry.id));
     entries.push(entry);
@@ -192,17 +204,21 @@ export function upsertEntry(manifest, entry) {
 export function removeEntry(manifest, concept, id) {
     return { version: 1, entries: manifest.entries.filter((e) => !(e.concept === concept && e.id === id)) };
 }
-/** Every entry whose outbound edges point at the target, excluding the target itself. The delete
+/**
+ * Every entry whose outbound edges point at the target, excluding the target itself. The delete
  *  guard reads this to name "what links here"; the backlinks panel will reuse it. Pure over the
- *  manifest, so the request-time delete path and a unit test call it the same way. */
+ *  manifest, so the request-time delete path and a unit test call it the same way.
+ */
 export function inboundLinks(manifest, concept, id) {
     return manifest.entries
         .filter((e) => !(e.concept === concept && e.id === id))
         .filter((e) => e.links.some((l) => l.concept === concept && l.id === id))
         .map((e) => ({ concept: e.concept, id: e.id, title: e.title, permalink: e.permalink }));
 }
-/** A resolver backed by manifest targets, for the admin preview. A miss returns undefined, so the
- *  render step marks the link broken rather than throwing. The build resolver throws instead. */
+/**
+ * A resolver backed by manifest targets, for the admin preview. A miss returns undefined, so the
+ *  render step marks the link broken rather than throwing. The build resolver throws instead.
+ */
 export function manifestLinkResolver(targets) {
     const byKey = new Map(targets.map((t) => [`${t.concept}/${t.id}`, t.permalink]));
     return (ref) => byKey.get(`${ref.concept}/${ref.id}`);

package/dist/content/media-refs.d.ts

@@ -1,7 +1,9 @@
 import type { FrontmatterField } from './types.js';
-/** The content hashes one entry references, in first-occurrence order, deduped by hash. Reads the
+/**
+ * The content hashes one entry references, in first-occurrence order, deduped by hash. Reads the
  *  frontmatter hero `image.src` for each `image`-typed field plus every body image node. A
  *  non-media or malformed token is skipped, never thrown, so a stray `![](/x.png)` does not break
  *  the manifest build. The body is parsed as mdast, so a `media:` token inside a code span or fence
- *  is never matched. */
+ *  is never matched.
+ */
 export declare function extractMediaRefs(frontmatter: Record<string, unknown>, body: string, fields: FrontmatterField[]): string[];

package/dist/content/media-refs.js

@@ -18,11 +18,13 @@ import remarkParse from 'remark-parse';
 import remarkGfm from 'remark-gfm';
 import { visit } from 'unist-util-visit';
 import { parseMediaToken } from '../media/reference.js';
-/** The content hashes one entry references, in first-occurrence order, deduped by hash. Reads the
+/**
+ * The content hashes one entry references, in first-occurrence order, deduped by hash. Reads the
  *  frontmatter hero `image.src` for each `image`-typed field plus every body image node. A
  *  non-media or malformed token is skipped, never thrown, so a stray `![](/x.png)` does not break
  *  the manifest build. The body is parsed as mdast, so a `media:` token inside a code span or fence
- *  is never matched. */
+ *  is never matched.
+ */
 export function extractMediaRefs(frontmatter, body, fields) {
     const seen = new Set();
     const hashes = [];

package/dist/content/media-rewrite.d.ts

@@ -24,12 +24,16 @@ export interface RepointResult {
  * untouched. Pure and node-safe.
  */
 export declare function repointMediaRef(markdown: string, oldHash: string, newToken: string): RepointResult;
-/** Which alt bucket a placement falls in: an empty alt always gets filled, a non-empty (custom) alt is
- *  reported and only overwritten on opt-in, and a decorative hero is never touched. */
+/**
+ * Which alt bucket a placement falls in: an empty alt always gets filled, a non-empty (custom) alt is
+ *  reported and only overwritten on opt-in, and a decorative hero is never touched.
+ */
 export type AltBucket = 'will-fill' | 'customized' | 'decorative-skipped';
-/** One placement of the target hash and what the alt-fill does to it: which surface it lives on, its
+/**
+ * One placement of the target hash and what the alt-fill does to it: which surface it lives on, its
  *  bucket, the existing alt, and the alt after the transform (unchanged for a customized alt left as
- *  is and for a decorative hero). */
+ *  is and for a decorative hero).
+ */
 export interface AltPlacement {
     kind: 'body' | 'figure' | 'hero';
     bucket: AltBucket;

package/dist/content/media-rewrite.js

@@ -23,10 +23,12 @@ import remarkDirective from 'remark-directive';
 import { visit } from 'unist-util-visit';
 import { parseMediaToken } from '../media/reference.js';
 import { escapeLinkText } from './links.js';
-/** Drop any span that overlaps a span already kept, in source order. A final safety net so two
+/**
+ * Drop any span that overlaps a span already kept, in source order. A final safety net so two
  *  splices can never target the same or overlapping bytes and clobber each other into a corrupt
  *  result, no matter how the locating arms behaved. A pure-insert span (`start === end`) overlaps
- *  another span only when it sits strictly inside it, so adjacent inserts and edits are kept. */
+ *  another span only when it sits strictly inside it, so adjacent inserts and edits are kept.
+ */
 function dropOverlappingEdits(edits) {
     const kept = [];
     for (const e of edits) {
@@ -36,29 +38,37 @@ function dropOverlappingEdits(edits) {
     }
     return kept;
 }
-/** A locating scan for candidate `media:` token substrings. Deliberately broad (it accepts
+/**
+ * A locating scan for candidate `media:` token substrings. Deliberately broad (it accepts
  *  uppercase and other out-of-grammar characters) so a malformed token is still found and then
  *  rejected by parseMediaToken, never silently skipped by the locator. The character class stops at
  *  whitespace, a quote, or any YAML or markdown delimiter, so a frontmatter value or an image
- *  destination ends the candidate. */
+ *  destination ends the candidate.
+ */
 const MEDIA_TOKEN_SCAN = /media:[A-Za-z0-9._-]+/g;
-/** Split a leading frontmatter block off the markdown. `fmBlock` is the `---` fenced block including
+/**
+ * Split a leading frontmatter block off the markdown. `fmBlock` is the `---` fenced block including
  *  both fences and the trailing newline (empty when there is none); `body` is everything after it.
  *  The block leads the document, so a frontmatter offset is already absolute and a body offset needs
- *  `fmBlock.length` added. Shared by every arm so they agree on the boundary. */
+ *  `fmBlock.length` added. Shared by every arm so they agree on the boundary.
+ */
 function splitFrontmatter(markdown) {
     const m = markdown.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
     const fmBlock = m ? m[0] : '';
     return { fmBlock, body: markdown.slice(fmBlock.length) };
 }
-/** Parse a doc with the figure-aware pipeline, so the body arm agrees with what remarkFigure renders
- *  and can see the enclosing `:::figure` container. Mirrors parseFigureDoc in markdown-format.ts. */
+/**
+ * Parse a doc with the figure-aware pipeline, so the body arm agrees with what remarkFigure renders
+ *  and can see the enclosing `:::figure` container. Mirrors parseFigureDoc in markdown-format.ts.
+ */
 function parseFigureDoc(doc) {
     return unified().use(remarkParse).use(remarkGfm).use(remarkDirective).parse(doc);
 }
-/** Whether `target` sits inside a `figure`-named container directive. Walks the tree to find the
+/**
+ * Whether `target` sits inside a `figure`-named container directive. Walks the tree to find the
  *  ancestor, since unist-util-visit's per-call ancestors are not retained across the traversal.
- *  Mirrors enclosingFigure in markdown-format.ts, reduced to a boolean. */
+ *  Mirrors enclosingFigure in markdown-format.ts, reduced to a boolean.
+ */
 function inFigure(tree, target) {
     let found = false;
     visit(tree, 'containerDirective', (dir) => {
@@ -71,8 +81,10 @@ function inFigure(tree, target) {
     });
     return found;
 }
-/** Split fmBlock into lines once, so the locator helpers walk a shared structure instead of
- *  re-scanning the block per call. */
+/**
+ * Split fmBlock into lines once, so the locator helpers walk a shared structure instead of
+ *  re-scanning the block per call.
+ */
 function fmLines(fmBlock) {
     const lines = [];
     let pos = 0;
@@ -86,12 +98,14 @@ function fmLines(fmBlock) {
     }
     return lines;
 }
-/** The inclusive line-index range `[lo, hi]` of the block-style mapping a top-level key opens: the
+/**
+ * The inclusive line-index range `[lo, hi]` of the block-style mapping a top-level key opens: the
  *  line `^<key>:` at indent 0 through the last line before the next top-level key (or the document
  *  end). A flow-style value (`key: { ... }` all on one line) yields a single-line range. Returns null
  *  when the key has no top-level line, which a malformed or non-canonical block can cause. Scoping the
  *  per-key search to this range is what lets two image fields that share one hash, or an image field
- *  whose hash also appears in a sibling text value, resolve to distinct, correct spans. */
+ *  whose hash also appears in a sibling text value, resolve to distinct, correct spans.
+ */
 function frontmatterKeyRange(lines, fmBlock, key) {
     const opener = new RegExp(`^${escapeForRegExp(key)}:`);
     const topLevelKey = /^[^\s#][^:]*:/;
@@ -118,10 +132,12 @@ function frontmatterKeyRange(lines, fmBlock, key) {
     }
     return [lo, hi];
 }
-/** Find the block-style `src:` line within `[lo, hi]` whose value token parses to `hash`. The token
+/**
+ * Find the block-style `src:` line within `[lo, hi]` whose value token parses to `hash`. The token
  *  is located by the broad scan and validated through parseMediaToken (matching on hash), so a
  *  malformed token is found then rejected. Returns null for a flow-style value (no own `src:` line),
- *  which leaves that shape unanchorable rather than splicing a guessed span. */
+ *  which leaves that shape unanchorable rather than splicing a guessed span.
+ */
 function findSrcLineInRange(lines, fmBlock, range, hash) {
     const srcKeyRe = /^(\s*)src:[ \t]?/;
     for (let i = range[0]; i <= range[1]; i += 1) {
@@ -149,11 +165,13 @@ function findSrcLineInRange(lines, fmBlock, range, hash) {
     }
     return null;
 }
-/** The image-like top-level frontmatter keys whose `src` parses to `hash`, in source order. A key is
+/**
+ * The image-like top-level frontmatter keys whose `src` parses to `hash`, in source order. A key is
  *  image-like when its value is an object carrying a string `src`; this is the same shape
  *  extractMediaRefs reads, so a token in a plain-text value (a `title:`/`note:`) is never treated as a
  *  reference. The bucket-classifying data comes from gray-matter (which handles every quoting form);
- *  the byte edit is located structurally by the caller, keyed back to this key name. */
+ *  the byte edit is located structurally by the caller, keyed back to this key name.
+ */
 function imageFieldKeys(data, hash) {
     const out = [];
     for (const [key, value] of Object.entries(data)) {
@@ -169,11 +187,13 @@ function imageFieldKeys(data, hash) {
     }
     return out;
 }
-/** Collect hero src-token edits inside the frontmatter block. Only an image-field `src:` line is
+/**
+ * Collect hero src-token edits inside the frontmatter block. Only an image-field `src:` line is
  *  rewritten: the structure is read via gray-matter (image-like keys), and each key's `src:` line is
  *  located structurally within that key's block. A `media:` token sitting in a plain-text value (a
  *  `title:` or `description:`) is on no `src:` line, so it is left untouched, keeping the byte-exact
- *  contract and agreeing with extractMediaRefs. A flow-style hero has no `src:` line and is skipped. */
+ *  contract and agreeing with extractMediaRefs. A flow-style hero has no `src:` line and is skipped.
+ */
 function frontmatterEdits(markdown, fmBlock, oldHash) {
     if (fmBlock === '')
         return [];
@@ -191,10 +211,12 @@ function frontmatterEdits(markdown, fmBlock, oldHash) {
     }
     return edits;
 }
-/** Locate the exact `media:` token substring inside one image node's source span. The destination
+/**
+ * Locate the exact `media:` token substring inside one image node's source span. The destination
  *  begins at the `](` that follows the alt text, so the search starts there to avoid a false match on
  *  a `media:`-like string inside the alt. Returns null when the token cannot be located, which leaves
- *  the image untouched rather than splicing a guessed range. */
+ *  the image untouched rather than splicing a guessed range.
+ */
 function locateImageToken(span, url) {
     const destStart = span.indexOf('](');
     const from = destStart === -1 ? 0 : destStart + 2;
@@ -203,9 +225,11 @@ function locateImageToken(span, url) {
         return null;
     return { start: at, end: at + url.length };
 }
-/** Find every body image whose url parses to `hash`, in source order, with absolute offsets. Parses
+/**
+ * Find every body image whose url parses to `hash`, in source order, with absolute offsets. Parses
  *  with the figure-aware pipeline, so a `media:` token inside a code span or fence is not an image
- *  node and is correctly skipped, matching extractMediaRefs. */
+ *  node and is correctly skipped, matching extractMediaRefs.
+ */
 function matchedBodyImages(body, blockLength, hash) {
     const tree = parseFigureDoc(body);
     const hits = [];
@@ -226,9 +250,11 @@ function matchedBodyImages(body, blockLength, hash) {
     });
     return hits;
 }
-/** Collect body edits over the body slice. Each matching image is located within its own source span
+/**
+ * Collect body edits over the body slice. Each matching image is located within its own source span
  *  and recorded with an absolute offset. The kind is 'figure' when the image is inside a `:::figure`,
- *  else 'body'. */
+ *  else 'body'.
+ */
 function bodyEdits(body, blockLength, oldHash) {
     const edits = [];
     for (const hit of matchedBodyImages(body, blockLength, oldHash)) {
@@ -276,14 +302,18 @@ export function repointMediaRef(markdown, oldHash, newToken) {
     }
     return { markdown: out, placements };
 }
-/** Classify an existing alt into its non-decorative bucket: an empty (or whitespace-only) alt is
+/**
+ * Classify an existing alt into its non-decorative bucket: an empty (or whitespace-only) alt is
  *  filled, a non-empty alt is a custom alt the caller may opt in to overwrite. Mirrors the empty-alt
- *  test findMediaImagesNeedingAlt uses. */
+ *  test findMediaImagesNeedingAlt uses.
+ */
 function classifyAlt(existing) {
     return existing.trim() === '' ? 'will-fill' : 'customized';
 }
-/** Whether a bucket plus the overwrite choice means the alt text is actually rewritten. A will-fill
- *  always writes; a customized alt writes only on opt-in; a decorative hero never writes. */
+/**
+ * Whether a bucket plus the overwrite choice means the alt text is actually rewritten. A will-fill
+ *  always writes; a customized alt writes only on opt-in; a decorative hero never writes.
+ */
 function altIsEdited(bucket, overwrite) {
     if (bucket === 'will-fill')
         return true;
@@ -291,10 +321,12 @@ function altIsEdited(bucket, overwrite) {
         return overwrite;
     return false;
 }
-/** Collect the body and figure alt edits over the body slice. The alt source span sits between `![`
+/**
+ * Collect the body and figure alt edits over the body slice. The alt source span sits between `![`
  *  and the `](` inside the image node's span, so the new alt (escaped the way insertImage escapes it,
  *  so a `]` cannot break the syntax) is spliced there. The existing alt is the parser's already
- *  unescaped `node.alt`. A body image has no decorative slot, so an empty alt is always will-fill. */
+ *  unescaped `node.alt`. A body image has no decorative slot, so an empty alt is always will-fill.
+ */
 function bodyAltEdits(body, blockLength, hash, defaultAlt, overwrite) {
     const edits = [];
     for (const hit of matchedBodyImages(body, blockLength, hash)) {
@@ -333,17 +365,21 @@ function bodyAltEdits(body, blockLength, hash, defaultAlt, overwrite) {
     }
     return edits;
 }
-/** Escape a literal string for safe interpolation into a RegExp source. A key name or an indent is
- *  matched literally, so its characters must not act as metacharacters. */
+/**
+ * Escape a literal string for safe interpolation into a RegExp source. A key name or an indent is
+ *  matched literally, so its characters must not act as metacharacters.
+ */
 function escapeForRegExp(literal) {
     return literal.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-/** Find a sibling key line (`alt:` or `decorative:`) at exactly `indent` within the inclusive
+/**
+ * Find a sibling key line (`alt:` or `decorative:`) at exactly `indent` within the inclusive
  *  line-index range `[lo, hi]` of one mapping. The range is the mapping's own block, so the search
  *  spans the whole mapping rather than a same-indent contiguous run: a blank line or a deeper-nested
  *  child between `src:` and `alt:` no longer hides the existing key (which would otherwise insert a
  *  duplicate key and break the YAML). Returns the key line's value span (after the key and its space,
- *  to end of line) or null when the mapping has no such key at that indent. */
+ *  to end of line) or null when the mapping has no such key at that indent.
+ */
 function findSiblingKeyValue(lines, fmBlock, range, indent, key) {
     const keyRe = new RegExp(`^${escapeForRegExp(indent)}${escapeForRegExp(key)}:[ \\t]?`);
     for (let i = range[0]; i <= range[1]; i += 1) {
@@ -354,7 +390,8 @@ function findSiblingKeyValue(lines, fmBlock, range, indent, key) {
     }
     return null;
 }
-/** Collect the hero alt edits inside the frontmatter block. The image-field objects (and their
+/**
+ * Collect the hero alt edits inside the frontmatter block. The image-field objects (and their
  *  decorative and alt values) are read via gray-matter to classify the bucket robustly across quoting
  *  forms; the byte edit is then located structurally, scoped to each field's own mapping block, keyed
  *  back by the top-level field name. Iterating the fields in source order keeps the hero placements in
@@ -363,7 +400,8 @@ function findSiblingKeyValue(lines, fmBlock, range, indent, key) {
  *  blank line or a nested child) has its value replaced; an absent one is inserted right after the
  *  `src:` line at the same indent. The new value is a JSON-quoted scalar, valid YAML that handles a
  *  colon, a quote, or an empty string. A flow-style hero (`image: { ... }`, no own `src:` line) is
- *  unanchorable, so it is reported from the gray-matter read but never spliced. */
+ *  unanchorable, so it is reported from the gray-matter read but never spliced.
+ */
 function heroAltEdits(markdown, fmBlock, hash, defaultAlt, overwrite) {
     if (fmBlock === '')
         return [];

package/dist/content/schema.d.ts

@@ -4,8 +4,10 @@ export interface StandardInput {
     frontmatter: Record<string, unknown>;
     body: string;
 }
-/** A minimal local copy of the Standard Schema v1 interface (https://standardschema.dev), so the
- *  schema is a drop-in where the ecosystem accepts a validator, with no runtime dependency. */
+/**
+ * A minimal local copy of the Standard Schema v1 interface (https://standardschema.dev), so the
+ *  schema is a drop-in where the ecosystem accepts a validator, with no runtime dependency.
+ */
 export interface StandardSchemaV1<Input = unknown, Output = Input> {
     readonly '~standard': {
         readonly version: 1;
@@ -26,9 +28,11 @@ type StandardResult<Output> = {
         readonly path?: ReadonlyArray<PropertyKey>;
     }>;
 };
-/** Map one field descriptor to the TS type of its normalized value. text, textarea, and date
+/**
+ * Map one field descriptor to the TS type of its normalized value. text, textarea, and date
  *  normalize to a string; a closed-vocabulary `tags` field to the option-union array; an `image`
- *  field to its nested object. */
+ *  field to its nested object.
+ */
 type FieldValue<K extends FrontmatterField> = K extends {
     type: 'boolean';
 } ? boolean : K extends {
@@ -43,8 +47,10 @@ type FieldValue<K extends FrontmatterField> = K extends {
 type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
-/** The normalized frontmatter type inferred from a field tuple. A field declared
- *  `required: true` is a required key; every other field is optional. */
+/**
+ * The normalized frontmatter type inferred from a field tuple. A field declared
+ *  `required: true` is a required key; every other field is optional.
+ */
 export type InferFields<F extends readonly FrontmatterField[]> = Prettify<{
     [K in F[number] as K extends {
         required: true;
@@ -54,8 +60,10 @@ export type InferFields<F extends readonly FrontmatterField[]> = Prettify<{
         required: true;
     } ? never : K['name']]?: FieldValue<K>;
 }>;
-/** A concept's schema: the plain-data field projection, the generated validator, and the
- *  Standard Schema conformance property. */
+/**
+ * A concept's schema: the plain-data field projection, the generated validator, and the
+ *  Standard Schema conformance property.
+ */
 export interface ConceptSchema<F extends readonly FrontmatterField[] = readonly FrontmatterField[]> {
     /** The declared fields as plain serializable data, for the editor form. */
     readonly fields: FrontmatterField[];
@@ -66,9 +74,11 @@ export interface ConceptSchema<F extends readonly FrontmatterField[] = readonly
 }
 /** Extract the inferred frontmatter type from a `ConceptSchema`. */
 export type Infer<S> = S extends ConceptSchema<infer F> ? InferFields<F> : never;
-/** Options for `defineFields`. `refine` runs after the per-field rules pass, for cross-field and
+/**
+ * Options for `defineFields`. `refine` runs after the per-field rules pass, for cross-field and
  *  body-dependent checks. It is validation-only: it returns field-keyed errors to merge, or
- *  nothing, and never transforms the data. */
+ *  nothing, and never transforms the data.
+ */
 export interface DefineFieldsOptions<F extends readonly FrontmatterField[]> {
     refine?: (data: InferFields<F>, body: string) => Record<string, string> | undefined;
 }

package/dist/content/site-dictionary.d.ts

@@ -1,8 +1,10 @@
-/** True when a word is a single valid dictionary line (no whitespace, no control characters, non-empty
+/**
+ * True when a word is a single valid dictionary line (no whitespace, no control characters, non-empty
  *  and within the length bound). A leading "#" is rejected: parseDictionary re-reads such a line as a
  *  comment, so committing it would silently drop the word on the next read. The action uses this to
  *  reject untrusted input before the merge, so a newline or a control byte can never inject an extra
- *  line into the committed file. */
+ *  line into the committed file.
+ */
 export declare function isValidDictionaryWord(word: string, maxLength?: number): boolean;
 /**
  * Parse the committed dictionary file text into its word list. Comment lines (a `#` after optional