@glw907/cairn-cms 0.60.0 → 0.62.1

package/dist/components/spellcheck.d.ts

@@ -7,8 +7,10 @@ export interface Range {
     from: number;
     to: number;
 }
-/** A word extracted for lookup: the lowercased form the Worker checks, and its absolute range so a
- *  verdict maps straight back to an underline. */
+/**
+ * A word extracted for lookup: the lowercased form the Worker checks, and its absolute range so a
+ *  verdict maps straight back to an underline.
+ */
 export interface ExtractedWord {
     /** The lowercased word, as the engine's case-insensitive lookup expects. */
     text: string;
@@ -22,8 +24,10 @@ export interface ExtractedWord {
  * precedence live in {@link skipRanges}.
  */
 export declare function classifyProse(text: string, tree: Tree, from: number, to: number): Range[];
-/** 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 declare function spellcheckRanges(text: string, tree: Tree): Range[];
 /**
  * The checkable words inside [from, to), each lowercased for lookup with its absolute range recorded
@@ -31,8 +35,10 @@ export declare function spellcheckRanges(text: string, tree: Tree): Range[];
  * all-caps tokens are dropped.
  */
 export declare function extractWords(text: string, from: number, to: number): ExtractedWord[];
-/** The callbacks the management actions invoke. The lint source supplies these so the pure builder
- *  never touches the Worker or the re-lint mechanism: it only wires the buttons to these handlers. */
+/**
+ * The callbacks the management actions invoke. The lint source supplies these so the pure builder
+ *  never touches the Worker or the re-lint mechanism: it only wires the buttons to these handlers.
+ */
 export interface SpellDiagnosticActions {
     /** Add the word to the personal dictionary (posts addWord, records the pending addition, re-lints). */
     onAddWord(word: string): void;
@@ -40,7 +46,7 @@ export interface SpellDiagnosticActions {
     onIgnoreWord(word: string): void;
 }
 /**
- * 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
@@ -64,7 +70,7 @@ export interface SeqArbiter {
 /** Build a fresh {@link SeqArbiter}. */
 export declare function arbitrateChecked(): SeqArbiter;
 /**
- * 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
@@ -73,58 +79,80 @@ export declare function arbitrateChecked(): SeqArbiter;
  * diagnostic without a browser.
  */
 export declare function buildObjectiveDiagnostic(error: ObjectiveError): Diagnostic;
-/** The narrow Worker surface the lint source drives: it posts check, suggest, addWord, and ignoreWord
+/**
+ * The narrow Worker surface the lint source drives: it posts check, suggest, addWord, and ignoreWord
  *  messages and listens for the answers. A `suggest` answer is a one-shot, so the source removes its
- *  own listener once it lands. A test injects a fake; production injects a real Worker. */
+ *  own listener once it lands. A test injects a fake; production injects a real Worker.
+ */
 export interface SpellWorker {
     postMessage(message: unknown): void;
     addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
     removeEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
 }
-/** 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 declare function createSpellWorker(): SpellWorker;
 /** The real wasm asset URL, resolved module-relative the same way the worker is. */
 export declare function resolveWasmUrl(): string;
-/** The real dictionary asset URL for a dictionary filename, resolved module-relative. The caller
- *  passes the dialect-resolved filename (default `dictionary-en-us.txt`). */
+/**
+ * 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.
+ */
 export declare function resolveDictionaryUrl(dictionaryFile: string): string;
-/** Options for {@link cairnSpellcheck}, so the unit and component layers can inject a fake Worker
- *  factory in place of the real `new Worker(...)`. */
+/**
+ * Options for {@link cairnSpellcheck}, so the unit and component layers can inject a fake Worker
+ *  factory in place of the real `new Worker(...)`.
+ */
 export interface SpellcheckOptions {
     /** The Worker factory; defaults to {@link createSpellWorker}. Created lazily on the first lint. */
     createWorker?: () => SpellWorker;
-    /** The pending personal-dictionary additions, owned by the caller. When an author chooses "Add to
+    /**
+     * The pending personal-dictionary additions, owned by the caller. When an author chooses "Add to
      *  dictionary" the source posts addWord to the Worker (the underline clears at once) and records the
      *  word here. The set is the seam Task 9 commits to the git-backed dictionary file; this source only
-     *  fills it and never persists. A caller that does not pass one gets a fresh internal set. */
+     *  fills it and never persists. A caller that does not pass one gets a fresh internal set.
+     */
     pendingAdditions?: Set<string>;
-    /** The committed personal-dictionary words (spec 1.6) the source seeds the Worker's personal layer
+    /**
+     * The committed personal-dictionary words (spec 1.6) the source seeds the Worker's personal layer
      *  with, posted as one batch `addWord` right after `init`. The git-backed site dictionary is the
      *  durable layer; the editor reads it at load (EditData.siteDictionary) and hands it here, so a word
-     *  another editor committed answers correct from the first lint. Empty by default (dialect-only). */
+     *  another editor committed answers correct from the first lint. Empty by default (dialect-only).
+     */
     siteWords?: ReadonlyArray<string>;
-    /** The dialect-resolved dictionary filename, e.g. "dictionary-en-us.txt". The source resolves it to
-     *  a real asset URL and posts it in the Worker's `init`. Defaults to US English. */
+    /**
+     * The dialect-resolved dictionary filename, e.g. "dictionary-en-us.txt". The source resolves it to
+     *  a real asset URL and posts it in the Worker's `init`. Defaults to US English.
+     */
     dictionaryFile?: string;
-    /** Override the resolved wasm and dictionary URLs the source posts in `init`. The real resolution
+    /**
+     * Override the resolved wasm and dictionary URLs the source posts in `init`. The real resolution
      *  uses {@link resolveWasmUrl}/{@link resolveDictionaryUrl} (module-relative `import.meta.url`); a
      *  component test that injects a fake Worker can pass canned URLs so it never touches the asset
-     *  resolver. */
+     *  resolver.
+     */
     assetUrls?: {
         wasmUrl: string;
         dictionaryUrl: string;
     };
-    /** Treat the Worker as ready without waiting for a `ready` message. The production path is strict
+    /**
+     * Treat the Worker as ready without waiting for a `ready` message. The production path is strict
      *  (it posts `init` and waits for `ready` before painting); a fake Worker in a test that does not
-     *  answer `ready` can set this so a lint run is not held back. Defaults to false. */
+     *  answer `ready` can set this so a lint run is not held back. Defaults to false.
+     */
     assumeReady?: boolean;
-    /** The already-loaded CodeMirror modules to reuse instead of importing them again. The editor
+    /**
+     * The already-loaded CodeMirror modules to reuse instead of importing them again. The editor
      *  component loads `@codemirror/view`/`@codemirror/language` for its own extensions, so passing them
      *  here keeps the lint source on the SAME module instances; a second dynamic import can resolve to a
      *  separate copy (the test bundler's dedup quirk), and CodeMirror's instanceof checks then reject the
      *  extension. When omitted, the source imports them itself (the standalone path). `@codemirror/lint`
-     *  is loaded here when not supplied, since the editor does not otherwise need it. */
+     *  is loaded here when not supplied, since the editor does not otherwise need it.
+     */
     modules?: {
         lint?: typeof import('@codemirror/lint');
         language?: typeof import('@codemirror/language');
@@ -133,7 +161,7 @@ export interface SpellcheckOptions {
     };
 }
 /**
- * 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

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,10 +300,26 @@ export function createSpellWorker() {
 export function resolveWasmUrl() {
     return new URL('./spellcheck-assets/spellchecker-wasm.wasm', import.meta.url).href;
 }
-/** The real dictionary asset URL for a dictionary filename, resolved module-relative. The caller
- *  passes the dialect-resolved filename (default `dictionary-en-us.txt`). */
+/**
+ * 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.
+ */
+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
+ *  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.
+ */
 export function resolveDictionaryUrl(dictionaryFile) {
-    return new URL(`./spellcheck-assets/${dictionaryFile}`, import.meta.url).href;
+    const resolve = DICTIONARY_URLS[dictionaryFile] ?? DICTIONARY_URLS['dictionary-en-us.txt'];
+    return resolve();
 }
 /** How far past the visible viewport to lint, so a small scroll does not re-lint from scratch. */
 const VIEWPORT_MARGIN = 1000;
@@ -333,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
@@ -445,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;
@@ -464,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,51 @@
+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[]>;
+/**
+ * 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;