@glw907/cairn-cms 0.60.0 → 0.62.1

package/src/lib/components/media-upload-outcome.ts

@@ -11,22 +11,28 @@ import type { UploadResult } from '../sveltekit/content-routes.js';
 import type { IngestFailureKind } from './client-ingest.js';
 import { mediaToken } from '../media/reference.js';
 
-/** A failure the card surfaces. The ingest taxonomy plus a `generic` catch-all for a refuse reason
- *  with no specific author-facing card (a binding-missing, a length-required, a parse miss). */
+/**
+ * A failure the card surfaces. The ingest taxonomy plus a `generic` catch-all for a refuse reason
+ *  with no specific author-facing card (a binding-missing, a length-required, a parse miss).
+ */
 export type UploadFailureKind = IngestFailureKind | 'generic';
 
-/** The outcome the popover acts on. `inserted` swaps the placeholder for the reference and records
+/**
+ * The outcome the popover acts on. `inserted` swaps the placeholder for the reference and records
  *  the entry; `failed` cancels the placeholder and shows the typed card; `session-expired` cancels
- *  the placeholder and tells the author to sign in again. */
+ *  the placeholder and tells the author to sign in again.
+ */
 export type UploadOutcome =
   | { kind: 'inserted'; reference: string; record: MediaEntry; reused: boolean }
   | { kind: 'failed'; failure: UploadFailureKind }
   | { kind: 'session-expired' };
 
-/** The shape the popover hands in: either a parsed SvelteKit action result (success or failure) or a
+/**
+ * The shape the popover hands in: either a parsed SvelteKit action result (success or failure) or a
  *  bare response signal for the redirect and network-error cases. The popover deserializes the body
  *  for the success and failure cases and passes the raw `response.type`/`response.status` for the
- *  redirect case, so this one mapper covers every branch. */
+ *  redirect case, so this one mapper covers every branch.
+ */
 export type UploadEnvelope =
   | { type: 'success'; status?: number; data: UploadResult }
   | { type: 'failure'; status?: number; data?: { error?: string } }

package/src/lib/components/objective-errors.ts

@@ -12,16 +12,20 @@ import type { Range } from './spellcheck.js';
 /** The three objective-error kinds, each its own check. */
 export type ObjectiveErrorKind = 'doubled-word' | 'double-space' | 'repeated-punct';
 
-/** A single deterministic edit that resolves one finding: replace [from, to) with `insert`. The lint
- *  source turns this into the diagnostic's quick-fix action. */
+/**
+ * A single deterministic edit that resolves one finding: replace [from, to) with `insert`. The lint
+ *  source turns this into the diagnostic's quick-fix action.
+ */
 export interface ObjectiveFix {
   from: number;
   to: number;
   insert: string;
 }
 
-/** One objective-error finding: the flagged range a reader sees underlined, the error kind, a plain
- *  message, and the one-edit fix. */
+/**
+ * One objective-error finding: the flagged range a reader sees underlined, the error kind, a plain
+ *  message, and the one-edit fix.
+ */
 export interface ObjectiveError {
   kind: ObjectiveErrorKind;
   /** The flagged range (absolute document offsets), the span the underline covers. */
@@ -59,15 +63,19 @@ const DOUBLE_SPACE = /[^\s] ( +)/g;
 // flagged because it is a legitimate construction; only a run of one identical mark counts.
 const REPEATED_PUNCT = /([!?,])\1+/g;
 
-/** Whether two matched word strings are the same word, case-insensitively. Both are already plain
- *  word runs from the same WORD pattern, so a locale-insensitive lowercase compare is enough. */
+/**
+ * Whether two matched word strings are the same word, case-insensitively. Both are already plain
+ *  word runs from the same WORD pattern, so a locale-insensitive lowercase compare is enough.
+ */
 function sameWord(a: string, b: string): boolean {
   return a.toLowerCase() === b.toLowerCase();
 }
 
-/** Run the three objective checks over one prose span [from, to), returning every finding with an
+/**
+ * Run the three objective checks over one prose span [from, to), returning every finding with an
  *  absolute range and fix. The doubled-word check is bounded to this span so a repeat that straddles
- *  a skipped region is never matched. */
+ *  a skipped region is never matched.
+ */
 function checkSpan(text: string, from: number, to: number): ObjectiveError[] {
   const out: ObjectiveError[] = [];
   const slice = text.slice(from, to);

package/src/lib/components/preview-doc.ts

@@ -32,8 +32,10 @@ export function previewDevice(id: PreviewDeviceId): PreviewDevice {
   return previewDevices.find((d) => d.id === id) ?? previewDevices[0];
 }
 
-/** A device's user-facing text, shared by the toolbar's menu items and the frame caption: the
- *  label with its width when one is fixed, so the value reaches assistive tech at pick time. */
+/**
+ * A device's user-facing text, shared by the toolbar's menu items and the frame caption: the
+ *  label with its width when one is fixed, so the value reaches assistive tech at pick time.
+ */
 export function deviceLabel(d: PreviewDevice): string {
   return d.width === null ? d.label : `${d.label} · ${d.width} px`;
 }

package/src/lib/components/spellcheck.ts

@@ -23,8 +23,10 @@ export interface Range {
   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;
@@ -73,8 +75,10 @@ const SKIP_NODES = new Set<string>([
 // 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: Range[]): Range[] {
   if (ranges.length === 0) return [];
   const sorted = [...ranges].sort((a, b) => a.from - b.from || a.to - b.to);
@@ -88,9 +92,11 @@ function mergeRanges(ranges: Range[]): Range[] {
   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: string, tree: Tree): Range[] {
   const skips: Range[] = [];
 
@@ -163,8 +169,10 @@ export function classifyProse(text: string, tree: Tree, from: number, to: number
   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: string, tree: Tree): Range[] {
   return classifyProse(text, tree, 0, text.length);
 }
@@ -175,8 +183,10 @@ export function spellcheckRanges(text: string, tree: Tree): Range[] {
 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: string): boolean {
   if (word.length < 3) return false;
   if (ALL_DIGITS.test(word)) return false;
@@ -207,8 +217,10 @@ export function extractWords(text: string, from: number, to: number): ExtractedW
 // wall of near-ties.
 const MAX_SUGGESTIONS = 5;
 
-/** 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;
@@ -217,7 +229,7 @@ export interface SpellDiagnosticActions {
 }
 
 /**
- * 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
@@ -290,7 +302,7 @@ export 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
@@ -337,17 +349,21 @@ let langMod: typeof import('@codemirror/language') | null = null;
 let viewMod: typeof import('@codemirror/view') | null = null;
 let stateMod: typeof import('@codemirror/state') | null = null;
 
-/** 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 function createSpellWorker(): SpellWorker {
   return new Worker(new URL('./spellcheck-worker.js', import.meta.url), {
     type: 'module',
@@ -368,48 +384,80 @@ export function resolveWasmUrl(): string {
   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: Record<string, () => string> = {
+  '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: string): string {
-  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;
 
-/** 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');
@@ -455,7 +503,7 @@ function lockedUnderlineTheme(EditorViewMod: typeof import('@codemirror/view').E
 }
 
 /**
- * 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
@@ -576,10 +624,12 @@ export async function cairnSpellcheck(options: SpellcheckOptions = {}): Promise<
     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: SpellWorker, word: string): Promise<string[]> {
     suggestSeq += 1;
     const seq = suggestSeq;
@@ -595,8 +645,10 @@ export async function cairnSpellcheck(options: SpellcheckOptions = {}): Promise<
     });
   }
 
-  /** 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: ExtractedWord[]): Promise<Diagnostic[]> {
     const w = ensureWorker();
     const callbacks: SpellDiagnosticActions = {

package/src/lib/components/tidy-categorize.ts

@@ -13,9 +13,11 @@
 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' }
 	| { kind: 'typo' }
@@ -24,9 +26,11 @@ export type TidyCategory =
 	| { kind: 'normalization'; convention: NormalizationKey }
 	| { 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 function isObjective(category: TidyCategory): boolean {
 	return (
 		category.kind === 'spelling' ||
@@ -36,9 +40,11 @@ export 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'
@@ -133,9 +139,11 @@ function isPunctuationOnly(text: string): boolean {
 	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: string, offset: number): string | null {
 	let i = offset;
 	while (i > 0 && /\s/.test(text[i - 1])) i--;
@@ -144,8 +152,10 @@ function precedingWord(text: string, offset: number): string | null {
 	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: string, offset: number): string | null {
 	let i = offset;
 	while (i < text.length && /\s/.test(text[i])) i++;
@@ -335,11 +345,13 @@ function matchNormalization(
 	return null;
 }
 
-/** 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;
@@ -416,9 +428,11 @@ export function buildBecause(key: NormalizationKey, conventions: TidyConventions
 	}
 }
 
-/** 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: TidyCategory): string {
 	switch (category.kind) {
 		case 'spelling':

package/src/lib/components/tidy-validate.ts

@@ -19,24 +19,30 @@ import { parseMediaToken } from '../media/reference.js';
 import { diffTokens, diffChanges } from './tidy-diff.js';
 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 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[] }
 	| { ok: false; reason: TidyRejectionReason; message: string };
@@ -61,10 +67,12 @@ const DIVERGENCE_FRACTION = 0.5;
 // 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: string): string[] {
 	const hashes: string[] = [];
 	for (const m of text.matchAll(MEDIA_TOKEN)) {
@@ -74,11 +82,13 @@ function mediaHashes(text: string): string[] {
 	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: string): string {
 	const { depths, roles } = fenceScan(text.split('\n'));
 	const parts: string[] = [];
@@ -88,10 +98,12 @@ function directiveSignature(text: string): string {
 	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: string): string {
 	const tree = unified().use(remarkParse).use(remarkGfm).parse(text);
 	const levels: number[] = [];
@@ -101,11 +113,13 @@ function headingSignature(text: string): string {
 	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: string): string[] {
 	const tree = unified().use(remarkParse).use(remarkGfm).parse(text);
 	const values: string[] = [];

package/src/lib/components/topbar-context.ts

@@ -12,9 +12,11 @@ const TOPBAR_CONTEXT_KEY = Symbol('cairn-topbar');
 /** 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;
 }