@glw907/cairn-cms 0.60.1 → 0.62.2

package/dist/components/spellcheck.js

@@ -40,8 +40,10 @@ const SKIP_NODES = new Set([
 // surrounding whitespace). A token inside an image is already caught by the URL skip; this catches
 // the form authors type directly in prose, so it is never split into "media" plus a flagged hash.
 const MEDIA_TOKEN = /media:[\w.-]+/g;
-/** Merge overlapping or touching ranges into a sorted, disjoint set, so the keep-span computation
- *  subtracts one clean list of skip regions. */
+/**
+ * Merge overlapping or touching ranges into a sorted, disjoint set, so the keep-span computation
+ *  subtracts one clean list of skip regions.
+ */
 function mergeRanges(ranges) {
     if (ranges.length === 0)
         return [];
@@ -57,9 +59,11 @@ function mergeRanges(ranges) {
     }
     return out;
 }
-/** Every absolute skip range in the document, from all three mechanisms, merged. This is the single
+/**
+ * Every absolute skip range in the document, from all three mechanisms, merged. This is the single
  *  skip authority the spec calls for: the tree decides node kind, frontmatterSpan covers the `---`
- *  region, and fenceTokens covers the directive machinery the tree parses as plain text. */
+ *  region, and fenceTokens covers the directive machinery the tree parses as plain text.
+ */
 function skipRanges(text, tree) {
     const skips = [];
     // 1. The Lezer tree: the single authority for node-kind skips.
@@ -131,8 +135,10 @@ export function classifyProse(text, tree, from, to) {
         out.push({ from: cursor, to });
     return out;
 }
-/** The prose ranges worth checking across the whole document. The lint source narrows this to the
- *  visible window; the unit test reads the whole-document set. */
+/**
+ * The prose ranges worth checking across the whole document. The lint source narrows this to the
+ *  visible window; the unit test reads the whole-document set.
+ */
 export function spellcheckRanges(text, tree) {
     return classifyProse(text, tree, 0, text.length);
 }
@@ -141,8 +147,10 @@ export function spellcheckRanges(text, tree) {
 // with the inner apostrophe (straight or curly) and hyphen allowed only between word characters.
 const WORD = /[\p{L}\p{N}]+(?:[-'’][\p{L}\p{N}]+)*/gu;
 const ALL_DIGITS = /^\p{N}+$/u;
-/** Whether a word is worth a lookup. Words under three characters, pure numbers, and all-caps tokens
- *  are skipped to cut false positives (the conservative posture VSCode's spell checker takes). */
+/**
+ * Whether a word is worth a lookup. Words under three characters, pure numbers, and all-caps tokens
+ *  are skipped to cut false positives (the conservative posture VSCode's spell checker takes).
+ */
 function isCheckable(word) {
     if (word.length < 3)
         return false;
@@ -175,7 +183,7 @@ export function extractWords(text, from, to) {
 // wall of near-ties.
 const MAX_SUGGESTIONS = 5;
 /**
- * Build the correction popover for one misspelled word, as a @codemirror/lint Diagnostic whose
+ * Build the correction popover for one misspelled word, as a `@codemirror/lint` Diagnostic whose
  * `actions` CodeMirror renders as tooltip buttons (no custom popover code). The actions, in order:
  * up to five ranked suggestions (each replaces the word's range with one transaction), then "Add to
  * dictionary", then "Ignore". The severity is `info` so the underline is quiet, and the message names
@@ -227,7 +235,7 @@ export function arbitrateChecked() {
     };
 }
 /**
- * Build the quick-fix popover for one objective-error finding, as a @codemirror/lint Diagnostic whose
+ * Build the quick-fix popover for one objective-error finding, as a `@codemirror/lint` Diagnostic whose
  * one `actions` entry applies the finding's deterministic fix. The severity is `info` so the underline
  * shares the spellcheck surface and the locked amber color (an editor reads spelling and these
  * mechanical errors as one "spellcheck" layer). The fix range is recomputed from the live diagnostic
@@ -271,8 +279,10 @@ let lintMod = null;
 let langMod = null;
 let viewMod = null;
 let stateMod = null;
-/** Construct the real spellcheck Worker, the spike's delivery shape. Kept behind the seam so the
- *  lint source never references `Worker` at module scope and a test can swap it. */
+/**
+ * Construct the real spellcheck Worker, the spike's delivery shape. Kept behind the seam so the
+ *  lint source never references `Worker` at module scope and a test can swap it.
+ */
 export function createSpellWorker() {
     return new Worker(new URL('./spellcheck-worker.js', import.meta.url), {
         type: 'module',
@@ -290,19 +300,23 @@ export function createSpellWorker() {
 export function resolveWasmUrl() {
     return new URL('./spellcheck-assets/spellchecker-wasm.wasm', import.meta.url).href;
 }
-/** Each shipped dictionary, mapped to a resolver that builds its asset URL with a LITERAL
+/**
+ * Each shipped dictionary, mapped to a resolver that builds its asset URL with a LITERAL
  *  `new URL(..., import.meta.url)`. The literal path is load-bearing. A templated `new URL` makes Vite
  *  and rolldown treat the directory as a glob and parse every sibling module to build it, including the
  *  `.svelte` components that still carry `lang="ts"` in `dist`, and the glob parser chokes on the TS
  *  syntax and breaks the consumer build. This set mirrors the dialect map in `nav/site-config.ts`; add
- *  one line per new shipped dialect dictionary. */
+ *  one line per new shipped dialect dictionary.
+ */
 const DICTIONARY_URLS = {
     'dictionary-en-us.txt': () => new URL('./spellcheck-assets/dictionary-en-us.txt', import.meta.url).href,
 };
-/** The real dictionary asset URL for a dictionary filename, resolved module-relative. The caller
+/**
+ * The real dictionary asset URL for a dictionary filename, resolved module-relative. The caller
  *  passes the dialect-resolved filename (default `dictionary-en-us.txt`). `dictionaryFileForDialect`
  *  already collapses an unknown dialect to the default, so an unmapped name falls back the same way
- *  rather than pointing at an asset that does not ship. */
+ *  rather than pointing at an asset that does not ship.
+ */
 export function resolveDictionaryUrl(dictionaryFile) {
     const resolve = DICTIONARY_URLS[dictionaryFile] ?? DICTIONARY_URLS['dictionary-en-us.txt'];
     return resolve();
@@ -345,7 +359,7 @@ function lockedUnderlineTheme(EditorViewMod) {
     });
 }
 /**
- * The @codemirror/lint linter() source, made markdown-aware by the Lezer tree. It runs over the
+ * The `@codemirror/lint` linter() source, made markdown-aware by the Lezer tree. It runs over the
  * visible viewport plus a margin (not the whole document), extracts the checkable words via the pure
  * classifier, posts them to the Worker keyed by a monotonic latest-wins seq, and maps the
  * `correct: false` answers back to ranges. Each wrong word becomes a correction popover: the source
@@ -457,10 +471,12 @@ export async function cairnSpellcheck(options = {}) {
             worker.postMessage({ type: 'addWord', words: siteWords });
         return worker;
     }
-    /** Fetch a single word's ranked suggestions over the Worker, a one-shot listener removed on the
+    /**
+     * Fetch a single word's ranked suggestions over the Worker, a one-shot listener removed on the
      *  answer. The suggest path is independent of the check seq, so a slow suggest never blocks a fresh
      *  check; an empty list (the engine returned nothing) still yields a popover with the two
-     *  management actions. */
+     *  management actions.
+     */
     function fetchSuggestions(w, word) {
         suggestSeq += 1;
         const seq = suggestSeq;
@@ -476,8 +492,10 @@ export async function cairnSpellcheck(options = {}) {
             w.postMessage({ type: 'suggest', seq, word });
         });
     }
-    /** Turn the wrong words into correction popovers, each carrying its ranked suggestions and the two
-     *  management actions. */
+    /**
+     * Turn the wrong words into correction popovers, each carrying its ranked suggestions and the two
+     *  management actions.
+     */
     async function buildDiagnostics(wrong) {
         const w = ensureWorker();
         const callbacks = {

package/dist/components/tidy-categorize.d.ts

@@ -1,8 +1,10 @@
 import type { Change } from './tidy-diff.js';
 import type { TidyConventions } from '../nav/site-config.js';
-/** A change's locally-inferred category. The first four are objective (safe to sweep); `normalization`
+/**
+ * A change's locally-inferred category. The first four are objective (safe to sweep); `normalization`
  *  and `grammar` are judgment (held undecided, never swept by Accept-fixes). `normalization` carries
- *  the convention key that authorized it, so the surface can name the setting and label the badge. */
+ *  the convention key that authorized it, so the surface can name the setting and label the badge.
+ */
 export type TidyCategory = {
     kind: 'spelling';
 } | {
@@ -17,13 +19,17 @@ export type TidyCategory = {
 } | {
     kind: 'grammar';
 };
-/** True for the objective categories: the safe, pre-kept, Accept-fixes-swept rank. A judgment
+/**
+ * True for the objective categories: the safe, pre-kept, Accept-fixes-swept rank. A judgment
  *  category (`normalization` or `grammar`) returns false. The bulk action and the surface both read
- *  this, so the safety rank is one source of truth. */
+ *  this, so the safety rank is one source of truth.
+ */
 export declare function isObjective(category: TidyCategory): boolean;
-/** The enabled-convention keys a normalization can be attributed to. Each maps to one config field on
+/**
+ * The enabled-convention keys a normalization can be attributed to. Each maps to one config field on
  *  TidyConventions and to a because-line. A change is only ever labelled a normalization when it matches
- *  one of these AND the config has the matching variant enabled; otherwise it is never a normalization. */
+ *  one of these AND the config has the matching variant enabled; otherwise it is never a normalization.
+ */
 export type NormalizationKey = 'oxfordComma' | 'numberStyle' | 'measurements' | 'percent' | 'emDash' | 'enDashRanges' | 'ellipsis' | 'timeFormat' | 'smartQuotes';
 /**
  * Categorize one change against the captured original and the resolved conventions. The rules are
@@ -39,11 +45,13 @@ export type NormalizationKey = 'oxfordComma' | 'numberStyle' | 'measurements' |
  * offers a normalization that cannot cite an enabled setting.
  */
 export declare function categorize(change: Change, original: string, conventions: TidyConventions): TidyCategory;
-/** The because-line data for a hunk: the convention's display name and the variant phrasing, both pure
+/**
+ * The because-line data for a hunk: the convention's display name and the variant phrasing, both pure
  *  strings derived from the config. The surface renders "Your <label> setting is <variant>, ..." from
  *  these. Only a normalization carries a because-line; an objective or grammar hunk returns null (a
  *  grammar hunk's rationale, when shown, is the local subject-verb note the surface composes, not a
- *  config citation). */
+ *  config citation).
+ */
 export interface BecauseLine {
     /** The convention's display label, e.g. "Oxford-comma". */
     label: string;
@@ -61,7 +69,9 @@ export interface BecauseLine {
  * null when the convention is somehow not enabled (defensive: categorize never produces such a hunk).
  */
 export declare function buildBecause(key: NormalizationKey, conventions: TidyConventions): BecauseLine | null;
-/** The human badge label for a category, the word shown in the hunk's category pill. A normalization's
+/**
+ * The human badge label for a category, the word shown in the hunk's category pill. A normalization's
  *  label is the convention's display name (its comma style, its time format), never "consistency" and
- *  never a count. */
+ *  never a count.
+ */
 export declare function categoryLabel(category: TidyCategory): string;

package/dist/components/tidy-categorize.js

@@ -9,9 +9,11 @@
 // quiet and are swept by Accept-fixes. Judgment categories (a declared normalization, or a grammar fix
 // that reworded more than one token) carry the review-this treatment and are never swept until the
 // author confirms each. The category alone decides the rank, so the surface and the bulk action agree.
-/** True for the objective categories: the safe, pre-kept, Accept-fixes-swept rank. A judgment
+/**
+ * True for the objective categories: the safe, pre-kept, Accept-fixes-swept rank. A judgment
  *  category (`normalization` or `grammar`) returns false. The bulk action and the surface both read
- *  this, so the safety rank is one source of truth. */
+ *  this, so the safety rank is one source of truth.
+ */
 export function isObjective(category) {
     return (category.kind === 'spelling' ||
         category.kind === 'typo' ||
@@ -94,9 +96,11 @@ function isWhitespaceOnly(text) {
 function isPunctuationOnly(text) {
     return text.length > 0 && /^[^A-Za-z0-9_\s]+$/.test(text);
 }
-/** The word ending immediately before `offset` in `text`, skipping any whitespace just before the
+/**
+ * The word ending immediately before `offset` in `text`, skipping any whitespace just before the
  *  offset, or null when none. The doubled-word rule reads it to confirm the deleted word repeats the
- *  one before it. Pure text inspection, never a count. */
+ *  one before it. Pure text inspection, never a count.
+ */
 function precedingWord(text, offset) {
     let i = offset;
     while (i > 0 && /\s/.test(text[i - 1]))
@@ -106,8 +110,10 @@ function precedingWord(text, offset) {
         j--;
     return j < i ? text.slice(j, i) : null;
 }
-/** The word starting immediately after `offset` in `text`, skipping any whitespace just after the
- *  offset, or null when none. The doubled-word rule reads it as the other half of the look-around. */
+/**
+ * The word starting immediately after `offset` in `text`, skipping any whitespace just after the
+ *  offset, or null when none. The doubled-word rule reads it as the other half of the look-around.
+ */
 function followingWord(text, offset) {
     let i = offset;
     while (i < text.length && /\s/.test(text[i]))
@@ -349,9 +355,11 @@ export function buildBecause(key, conventions) {
         }
     }
 }
-/** The human badge label for a category, the word shown in the hunk's category pill. A normalization's
+/**
+ * The human badge label for a category, the word shown in the hunk's category pill. A normalization's
  *  label is the convention's display name (its comma style, its time format), never "consistency" and
- *  never a count. */
+ *  never a count.
+ */
 export function categoryLabel(category) {
     switch (category.kind) {
         case 'spelling':

package/dist/components/tidy-validate.d.ts

@@ -1,19 +1,25 @@
 import type { Change } from './tidy-diff.js';
-/** The reason a tidy result was rejected. Task 14 branches on this; every value maps to the one
+/**
+ * The reason a tidy result was rejected. Task 14 branches on this; every value maps to the one
  *  honest author-facing message, so the reason is for logging and tests, not the user surface.
  *  - `structure`: a directive opener/closer sequence, a heading count or level, or a fenced-code
  *    count diverged (the result restructured the document).
  *  - `frontmatter`: the frontmatter block is not byte-for-byte equal.
  *  - `media`: the multiset of `media:` hashes differs (a hash was altered, dropped, or invented).
  *  - `code`: a code span or fenced code block was edited.
- *  - `divergence`: the changed-token amount exceeds the length-aware bound (a wholesale rewrite). */
+ *  - `divergence`: the changed-token amount exceeds the length-aware bound (a wholesale rewrite).
+ */
 export type TidyRejectionReason = 'structure' | 'frontmatter' | 'media' | 'code' | 'divergence';
-/** The honest author-facing message a rejection maps to. The same message for every reason, by
+/**
+ * The honest author-facing message a rejection maps to. The same message for every reason, by
  *  design: an author does not need the validator's internal taxonomy, only that the result was
- *  discarded and their text is safe. */
+ *  discarded and their text is safe.
+ */
 export declare const TIDY_REJECTION_MESSAGE = "Tidy returned a result that changed more than the wording, so it was discarded. Your text is unchanged.";
-/** The outcome of validating a tidy result. On success it carries the Task 12 change set the review
- *  surface accepts and rejects against; on failure it carries the typed reason and the message. */
+/**
+ * The outcome of validating a tidy result. On success it carries the Task 12 change set the review
+ *  surface accepts and rejects against; on failure it carries the typed reason and the message.
+ */
 export type TidyValidation = {
     ok: true;
     changes: Change[];

package/dist/components/tidy-validate.js

@@ -16,9 +16,11 @@ import { visit } from 'unist-util-visit';
 import { fenceScan, frontmatterSpan } from './markdown-directives.js';
 import { parseMediaToken } from '../media/reference.js';
 import { diffTokens, diffChanges } from './tidy-diff.js';
-/** The honest author-facing message a rejection maps to. The same message for every reason, by
+/**
+ * The honest author-facing message a rejection maps to. The same message for every reason, by
  *  design: an author does not need the validator's internal taxonomy, only that the result was
- *  discarded and their text is safe. */
+ *  discarded and their text is safe.
+ */
 export const TIDY_REJECTION_MESSAGE = 'Tidy returned a result that changed more than the wording, so it was discarded. Your text is unchanged.';
 // The divergence bound. The floor allows a fixed number of changed tokens regardless of fraction so
 // a legitimate heavy proofread of a SHORT input is not penalized: a short paragraph with a typo in
@@ -38,10 +40,12 @@ const DIVERGENCE_FRACTION = 0.5;
 // site, which the validator otherwise has no reason to know. A token mangled inside a code fence is
 // caught here too, redundantly with the code check, which is the right posture for a backstop.
 const MEDIA_TOKEN = /media:[A-Za-z0-9.-]+/g;
-/** The sorted multiset of valid media hashes in the text. Each `media:` occurrence is parsed; a
+/**
+ * The sorted multiset of valid media hashes in the text. Each `media:` occurrence is parsed; a
  *  malformed token (a broken hash, an illegal slug) parses to null and is dropped, so a tidy that
  *  CORRUPTED a hash drops it from the multiset and the comparison fails. Sorted so two multisets
- *  compare by value, order-independent. */
+ *  compare by value, order-independent.
+ */
 function mediaHashes(text) {
     const hashes = [];
     for (const m of text.matchAll(MEDIA_TOKEN)) {
@@ -51,11 +55,13 @@ function mediaHashes(text) {
     }
     return hashes.sort();
 }
-/** The directive structure signature: each opener or closer in document order, paired with the depth
+/**
+ * The directive structure signature: each opener or closer in document order, paired with the depth
  *  the fence scan assigned it. Two texts share a directive structure when these signatures are equal,
  *  so an added, removed, or relevelled container fails the comparison. A fence-shaped line inside a
  *  code block is already disowned by the scan (its role is null), so a documented `:::` example does
- *  not enter the signature. */
+ *  not enter the signature.
+ */
 function directiveSignature(text) {
     const { depths, roles } = fenceScan(text.split('\n'));
     const parts = [];
@@ -65,10 +71,12 @@ function directiveSignature(text) {
     }
     return parts.join(',');
 }
-/** The heading signature: every ATX heading's level in document order. Parsed as mdast so a `#`
+/**
+ * The heading signature: every ATX heading's level in document order. Parsed as mdast so a `#`
  *  inside a code block or an escaped one is never counted, and the level is the parser's own depth.
  *  Two texts share a heading structure when these are equal, so an added, removed, or relevelled
- *  heading fails the comparison. */
+ *  heading fails the comparison.
+ */
 function headingSignature(text) {
     const tree = unified().use(remarkParse).use(remarkGfm).parse(text);
     const levels = [];
@@ -78,11 +86,13 @@ function headingSignature(text) {
     });
     return levels.join(',');
 }
-/** Every code span and fenced or indented code block in the text, as a sorted multiset of values.
+/**
+ * Every code span and fenced or indented code block in the text, as a sorted multiset of values.
  *  Parsed as mdast so the comparison sees exactly what the parser treats as code, the same authority
  *  the media body scan uses. Sorted so the comparison is order-independent: the divergence and
  *  structure checks own ordering, this check owns the contents. A `code` node is a block, an
- *  `inlineCode` node is a span. */
+ *  `inlineCode` node is a span.
+ */
 function codeContents(text) {
     const tree = unified().use(remarkParse).use(remarkGfm).parse(text);
     const values = [];

package/dist/components/topbar-context.d.ts

@@ -2,9 +2,11 @@ import { type Snippet } from 'svelte';
 /** The shared holder: the desk snippet a document registers, or null on the office routes. */
 export interface TopbarHolder {
     desk: Snippet | null;
-    /** True while the document is in zen: AdminLayout drops the whole topbar element so the band
+    /**
+     * True while the document is in zen: AdminLayout drops the whole topbar element so the band
      *  slides away (the desk's three clusters include AdminLayout-owned chrome, the drawer toggle and
-     *  breadcrumb, that must vanish with it). EditPage sets this; the office routes leave it false. */
+     *  breadcrumb, that must vanish with it). EditPage sets this; the office routes leave it false.
+     */
     zen: boolean;
 }
 /** Called by AdminLayout once: creates the holder, provides it on context, returns it to render. */

package/dist/content/advisories.d.ts

@@ -0,0 +1,56 @@
+import type { ConceptDescriptor } from './types.js';
+import type { RepoRef } from '../github/types.js';
+import type { Manifest } from './manifest.js';
+/** One action an advisory offers, as a label and an optional link target. */
+export interface AdvisoryAction {
+    /** The action's button or link label. */
+    label: string;
+    /** The link target, when the action navigates. */
+    href?: string;
+}
+/** A non-blocking editor notice, serializable so it can ride EditData across the SSR boundary. */
+export interface AdvisoryNotice {
+    /** The notice kind, e.g. "address-collision". */
+    kind: string;
+    /** The advisory severity; warn-and-allow, never a gate. */
+    severity: 'warn';
+    /** The notice text shown to the editor. */
+    message: string;
+    /** The notice's offered actions, when any. */
+    actions?: AdvisoryAction[];
+}
+/** One entry that resolves to an address, in a shape the collision check and the message read. */
+export interface AddressEntry {
+    /** The concept id, e.g. "pages". */
+    concept: string;
+    /** The entry id (its filename stem). */
+    id: string;
+    /** The entry title for display, from the manifest (main) or frontmatter (branch). */
+    title: string;
+    /** The published corpus on main, or an open cairn/* edit branch. */
+    source: 'main' | 'branch';
+}
+/** Permalink to the distinct entries that resolve to it, across main and every open branch. */
+export type AddressIndex = Map<string, AddressEntry[]>;
+/**
+ * The address index over main only: a synchronous reverse map of each manifest entry's resolved
+ * permalink. No backend read, so an edit-load can build it for free from the manifest it already holds.
+ */
+export declare function mainAddressIndex(manifest: Manifest): AddressIndex;
+/**
+ * Build the permalink-keyed address index over main (from each manifest entry's resolved permalink)
+ * plus every open cairn/* branch (resolved from its edited markdown).
+ *
+ * The build fails open: a branch read that throws and a permalink that cannot resolve are both caught
+ * and skipped, so a transient failure degrades to a thinner index, never a thrown editor or a blocked
+ * publish. The branches are read in one Promise.all, the way buildUsageIndex reads them.
+ */
+export declare function buildAddressIndex(repo: RepoRef, token: string, concepts: ConceptDescriptor[], manifest: Manifest): Promise<AddressIndex>;
+/**
+ * Find the first other entry that already resolves to an address, or null when the address is free
+ * or holds only the entry itself. The self entry is identified by its concept and id together.
+ */
+export declare function addressCollision(index: AddressIndex, self: {
+    concept: string;
+    id: string;
+}, address: string): AddressEntry | null;

package/dist/content/advisories.js

@@ -0,0 +1,87 @@
+import { listBranches } from '../github/branches.js';
+import { readRaw } from '../github/repo.js';
+import { PENDING_PREFIX, parsePendingBranch } from './pending.js';
+import { findConcept } from './concepts.js';
+import { isValidId, filenameFromId } from './ids.js';
+import { parseMarkdown } from './frontmatter.js';
+import { entryIdentity } from './identity.js';
+/** Append a row under its permalink, creating the bucket on first use. */
+function push(index, permalink, entry) {
+    const rows = index.get(permalink);
+    if (rows)
+        rows.push(entry);
+    else
+        index.set(permalink, [entry]);
+}
+/**
+ * The address index over main only: a synchronous reverse map of each manifest entry's resolved
+ * permalink. No backend read, so an edit-load can build it for free from the manifest it already holds.
+ */
+export function mainAddressIndex(manifest) {
+    const index = new Map();
+    for (const entry of manifest.entries) {
+        push(index, entry.permalink, {
+            concept: entry.concept,
+            id: entry.id,
+            title: entry.title,
+            source: 'main',
+        });
+    }
+    return index;
+}
+/**
+ * Build the permalink-keyed address index over main (from each manifest entry's resolved permalink)
+ * plus every open cairn/* branch (resolved from its edited markdown).
+ *
+ * The build fails open: a branch read that throws and a permalink that cannot resolve are both caught
+ * and skipped, so a transient failure degrades to a thinner index, never a thrown editor or a blocked
+ * publish. The branches are read in one Promise.all, the way buildUsageIndex reads them.
+ */
+export async function buildAddressIndex(repo, token, concepts, manifest) {
+    // The main arm: the manifest already carries each entry's resolved permalink, so seed from the
+    // synchronous main-only index and union the branch arm on top.
+    const index = mainAddressIndex(manifest);
+    // The branch arm: read each open cairn/* branch's one edited file and resolve its permalink. The
+    // path is derivable from the branch name, so no tree-listing is needed.
+    const names = await listBranches(repo, PENDING_PREFIX, token);
+    const perBranch = await Promise.all(names.map(async (name) => {
+        // Resolve the branch name with the branch tooling's guard: a malformed name, an id that fails
+        // the slug rule, or an unconfigured concept is skipped with no read attempted.
+        const ref = parsePendingBranch(name);
+        if (!ref || !isValidId(ref.id))
+            return null;
+        const concept = findConcept(concepts, ref.concept);
+        if (!concept)
+            return null;
+        const path = `${concept.dir}/${filenameFromId(ref.id)}`;
+        try {
+            const raw = await readRaw({ ...repo, branch: name }, path, token);
+            if (raw === null)
+                return null; // The file is absent on the branch: nothing to resolve.
+            const { frontmatter } = parseMarkdown(raw);
+            const fmTitle = frontmatter.title;
+            const title = typeof fmTitle === 'string' && fmTitle.trim() ? fmTitle : ref.id;
+            // entryIdentity throws for a dated entry with no date; that branch is caught and skipped.
+            const { permalink } = entryIdentity(concept, path, frontmatter);
+            return { permalink, entry: { concept: concept.id, id: ref.id, title, source: 'branch' } };
+        }
+        catch {
+            // A failed branch read or an unresolvable permalink degrades this one branch, fail open.
+            return null;
+        }
+    }));
+    // Fold the per-branch rows back in, preserving the branch order so the index reads stably.
+    for (const row of perBranch) {
+        if (row)
+            push(index, row.permalink, row.entry);
+    }
+    return index;
+}
+/**
+ * Find the first other entry that already resolves to an address, or null when the address is free
+ * or holds only the entry itself. The self entry is identified by its concept and id together.
+ */
+export function addressCollision(index, self, address) {
+    const rows = index.get(address) ?? [];
+    return rows.find((row) => row.concept !== self.concept || row.id !== self.id) ?? null;
+}

package/dist/content/compose.d.ts

@@ -1,8 +1,10 @@
 import type { CairnAdapter, CairnExtension, CairnRuntime } from './types.js';
 import { type SiteConfig } from '../nav/site-config.js';
-/** The input to {@link composeRuntime}. `siteConfig` is required so the per-concept URL policy is
+/**
+ * The input to {@link composeRuntime}. `siteConfig` is required so the per-concept URL policy is
  *  always derived from one source and can never be silently dropped. `extensions` fold in after the
- *  adapter's concepts. */
+ *  adapter's concepts.
+ */
 export interface ComposeInput {
     adapter: CairnAdapter;
     siteConfig: SiteConfig;

package/dist/content/compose.js

@@ -28,6 +28,7 @@ export function composeRuntime({ adapter, siteConfig, extensions = [] }) {
         concepts: resolveConcepts(content, siteConfig),
         backend: adapter.backend,
         sender: adapter.sender,
+        supportContact: adapter.supportContact,
         render: adapter.render,
         manifestPath: adapter.manifestPath ?? 'src/content/.cairn/index.json',
         registry: adapter.registry,

package/dist/content/excerpt.js

@@ -1,8 +1,10 @@
 // cairn-cms: excerpt and word count for content summaries (public-delivery design, decision
 // 5). A light markdown strip keeps summaries cheap, so a list card, an og:description, and a
 // summary-mode feed read one derived excerpt without a full render.
-/** Reduce markdown to readable plain text: drop fenced code, images, and markup; unwrap inline
- * code and links to their text; collapse whitespace. */
+/**
+ * Reduce markdown to readable plain text: drop fenced code, images, and markup; unwrap inline
+ * code and links to their text; collapse whitespace.
+ */
 function toPlainText(md) {
     return md
         .replace(/```[\s\S]*?```/g, ' ')

package/dist/content/getting-started.d.ts

@@ -0,0 +1,18 @@
+import type { Manifest } from './manifest.js';
+/** The three getting-started steps, their completion count, and the fixed step total. */
+export interface GettingStarted {
+    wrotePost: boolean;
+    publishedPost: boolean;
+    createdPage: boolean;
+    doneCount: number;
+    total: 3;
+}
+/**
+ * Map the manifest and the pending-branch list to the three getting-started step states. Writing a
+ *  post (published or pending) completes the first step; publishing one completes the second; a page
+ *  (published or pending) completes the third.
+ */
+export declare function deriveGettingStarted(manifest: Manifest, pending: {
+    concept: string;
+    id: string;
+}[]): GettingStarted;

package/dist/content/getting-started.js

@@ -0,0 +1,12 @@
+/**
+ * Map the manifest and the pending-branch list to the three getting-started step states. Writing a
+ *  post (published or pending) completes the first step; publishing one completes the second; a page
+ *  (published or pending) completes the third.
+ */
+export function deriveGettingStarted(manifest, pending) {
+    const publishedPost = manifest.entries.some((e) => e.concept === 'posts');
+    const wrotePost = publishedPost || pending.some((p) => p.concept === 'posts');
+    const createdPage = manifest.entries.some((e) => e.concept === 'pages') || pending.some((p) => p.concept === 'pages');
+    const doneCount = Number(wrotePost) + Number(publishedPost) + Number(createdPage);
+    return { wrotePost, publishedPost, createdPage, doneCount, total: 3 };
+}

package/dist/content/links.d.ts

@@ -3,20 +3,28 @@ export interface CairnRef {
     concept: string;
     id: string;
 }
-/** Resolve a reference to its live permalink. Returns undefined when the target is missing (the
- *  preview marks it); the build resolver throws instead, so a dangling token fails the build. */
+/**
+ * Resolve a reference to its live permalink. Returns undefined when the target is missing (the
+ *  preview marks it); the build resolver throws instead, so a dangling token fails the build.
+ */
 export type LinkResolve = (ref: CairnRef) => string | undefined;
 /** Parse a `cairn:<concept>/<id>` href, or null for any other href or a malformed token. */
 export declare function parseCairnToken(href: string): CairnRef | null;
-/** 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 declare function formatCairnToken(ref: CairnRef): string;
-/** 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 declare function escapeLinkText(text: string): string;
-/** 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 declare function extractCairnLinks(body: string): CairnRef[];
 /**
  * Rewrite every cairn: link whose href is exactly `oldHref` so its href becomes `newHref`, keeping