@glw907/cairn-cms 0.60.1 → 0.62.1

package/dist/components/markdown-format.js

@@ -27,8 +27,10 @@ const LINE = {
     task: { prefix: () => '- [ ] ', exact: /^- \[[ xX]\] /, strip: /^- \[[ xX]\] / },
 };
 const TABLE_GRID = '| Column 1 | Column 2 |\n| -------- | -------- |\n|          |          |\n|          |          |';
-/** Wrap the selection in `marker`, or unwrap when the markers are already there (inside or just
- *  outside the selection). The returned range covers the text without its markers either way. */
+/**
+ * Wrap the selection in `marker`, or unwrap when the markers are already there (inside or just
+ *  outside the selection). The returned range covers the text without its markers either way.
+ */
 function toggleWrap(doc, from, to, marker) {
     const m = marker.length;
     const sel = doc.slice(from, to);
@@ -42,10 +44,12 @@ function toggleWrap(doc, from, to, marker) {
     const next = doc.slice(0, from) + marker + sel + marker + doc.slice(to);
     return { doc: next, from: from + m, to: to + m };
 }
-/** Apply a line-prefix kind to every selected line. When the kind toggles and every line already
+/**
+ * Apply a line-prefix kind to every selected line. When the kind toggles and every line already
  *  carries its marker, the markers come off; otherwise competing markers are replaced and each
  *  line gains the kind's prefix. The selection shifts with the first line's edit and stretches
- *  by the total length change, the same mechanics the original single-prefix version had. */
+ *  by the total length change, the same mechanics the original single-prefix version had.
+ */
 function applyLinePrefix(doc, from, to, kind) {
     const { prefix, exact, strip } = LINE[kind];
     const lineStart = doc.lastIndexOf('\n', from - 1) + 1; // 0 when the selection is on the first line
@@ -62,8 +66,10 @@ function applyLinePrefix(doc, from, to, kind) {
         to: to + totalDelta,
     };
 }
-/** Fence the selected lines in triple backticks on their own lines, or remove the fences when the
- *  lines just above and below the selection already are fences. */
+/**
+ * Fence the selected lines in triple backticks on their own lines, or remove the fences when the
+ *  lines just above and below the selection already are fences.
+ */
 function toggleCodeFence(doc, from, to) {
     const lineStart = doc.lastIndexOf('\n', from - 1) + 1;
     const lineEndRaw = doc.indexOf('\n', to);
@@ -82,6 +88,9 @@ function toggleCodeFence(doc, from, to) {
     const next = doc.slice(0, lineStart) + open + doc.slice(lineStart, lineEnd) + '\n```' + doc.slice(lineEnd);
     return { doc: next, from: from + open.length, to: to + open.length };
 }
+/**
+ *
+ */
 export function applyMarkdownFormat(doc, from, to, kind) {
     if (kind === 'bold' || kind === 'italic' || kind === 'code' || kind === 'strike') {
         return toggleWrap(doc, from, to, WRAP[kind]);
@@ -165,10 +174,12 @@ export function findMediaImagesNeedingAlt(doc) {
     hits.sort((a, b) => a.from - b.from);
     return hits;
 }
-/** Concatenate a link node's text-child values. The parser has already unescaped them, so a source
+/**
+ * Concatenate a link node's text-child values. The parser has already unescaped them, so a source
  *  `Notes \[draft\]` yields `Notes [draft]`. Used instead of mdast-util-to-string, which is not a
  *  direct dependency. Non-text children (a nested emphasis, say) contribute no value, which is fine
- *  for the picker-produced links this fix targets. */
+ *  for the picker-produced links this fix targets.
+ */
 function linkText(node) {
     return node.children.map((c) => ('value' in c ? c.value : '')).join('');
 }
@@ -201,14 +212,18 @@ export function unwrapCairnLink(doc, href) {
     return out;
 }
 const FIGURE_ROLES = new Set(['center', 'wide', 'full']);
-/** Parse a doc with the figure-aware pipeline (the render step's grammar), so the editor transforms
- *  agree with what renders. Container directives need remark-directive on top of the markdown base. */
+/**
+ * Parse a doc with the figure-aware pipeline (the render step's grammar), so the editor transforms
+ *  agree with what renders. Container directives need remark-directive on top of the markdown base.
+ */
 function parseFigureDoc(doc) {
     return unified().use(remarkParse).use(remarkGfm).use(remarkDirective).parse(doc);
 }
-/** Find the media `image` node whose source range contains `pos`, or whose enclosing figure contains
+/**
+ * Find the media `image` node whose source range contains `pos`, or whose enclosing figure contains
  *  `pos`, along with its enclosing `figure` directive when there is one. Returns null when `pos` is
- *  not on a media image nor inside a figure that wraps one. */
+ *  not on a media image nor inside a figure that wraps one.
+ */
 function locateMediaImage(tree, pos) {
     let bareHit = null;
     let figureHit = null;
@@ -241,8 +256,10 @@ function locateMediaImage(tree, pos) {
     // A figure hit (the caret on the image or anywhere in its block) wins over a bare hit.
     return figureHit ?? bareHit;
 }
-/** The `figure`-named container directive that encloses `node`, or null. Walks the tree to find the
- *  ancestor, since unist-util-visit's per-call ancestors are not retained across the traversal. */
+/**
+ * The `figure`-named container directive that encloses `node`, or null. Walks the tree to find the
+ *  ancestor, since unist-util-visit's per-call ancestors are not retained across the traversal.
+ */
 function enclosingFigure(tree, target) {
     let found = null;
     visit(tree, 'containerDirective', (dir) => {
@@ -258,24 +275,30 @@ function enclosingFigure(tree, target) {
     });
     return found;
 }
-/** Strip one leading backslash sitting immediately before a colon, the inverse of the fence-escape
+/**
+ * Strip one leading backslash sitting immediately before a colon, the inverse of the fence-escape
  *  wrapImageInFigure/updateFigure apply, so a caption that began with a directive-opening colon run
- *  round-trips to the author's original text. */
+ *  round-trips to the author's original text.
+ */
 function unescapeCaption(raw) {
     return raw.replace(/^\\(?=:)/, '');
 }
-/** Collapse a raw caption source span to the single-line value the control edits: internal newlines
- *  to single spaces, trimmed, with the leading-colon fence escape stripped. */
+/**
+ * Collapse a raw caption source span to the single-line value the control edits: internal newlines
+ *  to single spaces, trimmed, with the leading-colon fence escape stripped.
+ */
 function finishCaption(raw) {
     return unescapeCaption(raw.replace(/\s*\n\s*/g, ' ').trim());
 }
-/** Read the raw caption source from a figure directive, mirroring the render step's caption: the first
+/**
+ * Read the raw caption source from a figure directive, mirroring the render step's caption: the first
  *  text-bearing content after the image. The render step (remark-figure.ts) handles both caption
  *  forms, so the read must too. In the no-blank-line form the caption shares the image's paragraph,
  *  trailing the token, so it is read from the token end to that block's end; in the blank-line form it
  *  is the first text-bearing block after the image's paragraph. Only the first such content is the
  *  caption (a later block is a stray paragraph the render leaves outside the figcaption). Empty when
- *  the figure has no caption. */
+ *  the figure has no caption.
+ */
 function readCaption(doc, figure, image) {
     const imageStart = image.position?.start?.offset;
     const imageEnd = image.position?.end?.offset;
@@ -307,8 +330,10 @@ function readCaption(doc, figure, image) {
     }
     return '';
 }
-/** Whether a block's subtree carries any non-whitespace text, the caption-candidate test the render
- *  step uses (a bare image paragraph has no text node, so it is never read as a caption). */
+/**
+ * Whether a block's subtree carries any non-whitespace text, the caption-candidate test the render
+ *  step uses (a bare image paragraph has no text node, so it is never read as a caption).
+ */
 function blockHasText(node) {
     let found = false;
     visit(node, 'text', (text) => {
@@ -343,18 +368,22 @@ export function figureAtImage(doc, pos) {
     const role = className && FIGURE_ROLES.has(className) ? className : null;
     return { imageFrom, imageTo, figure: { from, to, caption: readCaption(doc, dir, hit.image), role } };
 }
-/** Sanitize a caption into a single safe body line: collapse internal newlines to single spaces,
+/**
+ * Sanitize a caption into a single safe body line: collapse internal newlines to single spaces,
  *  trim, and neutralize ONLY the directive-fence hazard (a leading colon would open a directive at
  *  line start) by prefixing one backslash. The author's inline markdown is preserved otherwise, so
- *  emphasis and links survive. figureAtImage strips the backslash on read for a clean round-trip. */
+ *  emphasis and links survive. figureAtImage strips the backslash on read for a clean round-trip.
+ */
 function sanitizeCaption(caption) {
     const line = caption.replace(/\s*\n\s*/g, ' ').trim();
     return line.startsWith(':') ? '\\' + line : line;
 }
-/** Build the canonical figure block source: the opener (with the role brace only for a non-null
+/**
+ * Build the canonical figure block source: the opener (with the role brace only for a non-null
  *  role), the image token verbatim on its own line, then a blank line and the sanitized caption when
  *  the caption is non-empty, and the closing fence. This is the blank-line form remarkFigure reads as
- *  its primary path, and it reads cleanly when hand-edited. */
+ *  its primary path, and it reads cleanly when hand-edited.
+ */
 function buildFigureBlock(imageSrc, caption, role) {
     const opener = role ? `:::figure{.${role}}` : ':::figure';
     const cap = sanitizeCaption(caption);
@@ -382,9 +411,11 @@ export function wrapImageInFigure(doc, imageFrom, imageTo, caption, role) {
     const end = blockStart + block.length;
     return { doc: before + inserted + after, from: end, to: end };
 }
-/** The inner image token of the figure at `figureRange.from`, sliced verbatim from the source so it
+/**
+ * The inner image token of the figure at `figureRange.from`, sliced verbatim from the source so it
  *  is reused byte-for-byte (open risk 3). Empty when no media image is found there, which leaves the
- *  rebuild image-less rather than throwing. Shared by updateFigure and unwrapFigure. */
+ *  rebuild image-less rather than throwing. Shared by updateFigure and unwrapFigure.
+ */
 function figureImageSrc(doc, figureRange) {
     const info = figureAtImage(doc, figureRange.from);
     return info ? doc.slice(info.imageFrom, info.imageTo) : '';

package/dist/components/markdown-reference.d.ts

@@ -0,0 +1,8 @@
+/** One cheat-sheet row: the literal syntax, a plain gloss, and the group it belongs to. */
+export interface MarkdownReferenceRow {
+    syntax: string;
+    makes: string;
+    group: 'text' | 'links' | 'blocks';
+}
+/** The cheat-sheet vocabulary, everyday rows first: the five text, the four links, then the blocks. */
+export declare const markdownReference: MarkdownReferenceRow[];

package/dist/components/markdown-reference.js

@@ -0,0 +1,22 @@
+// The one Markdown cheat-sheet table, the single source the editor's Markdown help dialog and the
+// Help home both render, so the two surfaces cannot drift. Each row pairs the literal syntax an
+// author types with a plain gloss of what it makes, grouped so the Help home can show the everyday
+// rows (text and links) and the dialog can show every group. Mirrors editor-shortcuts.ts.
+/** The cheat-sheet vocabulary, everyday rows first: the five text, the four links, then the blocks. */
+export const markdownReference = [
+    { syntax: '## Heading', makes: 'A heading', group: 'text' },
+    { syntax: '**bold**', makes: 'Bold text', group: 'text' },
+    { syntax: '*italic*', makes: 'Italic text', group: 'text' },
+    { syntax: '> quote', makes: 'A quote', group: 'text' },
+    { syntax: '`code`', makes: 'Inline code', group: 'text' },
+    { syntax: '[text](url)', makes: 'A link', group: 'links' },
+    { syntax: '[[page-name]]', makes: 'A link to one of your pages', group: 'links' },
+    { syntax: '- item', makes: 'A bulleted list', group: 'links' },
+    { syntax: '1. item', makes: 'A numbered list', group: 'links' },
+    { syntax: '### Heading', makes: 'A smaller heading', group: 'blocks' },
+    { syntax: '#### Heading', makes: 'A fourth-level heading', group: 'blocks' },
+    { syntax: '~~text~~', makes: 'Crossed-out text', group: 'blocks' },
+    { syntax: '- [ ] item', makes: 'A checklist', group: 'blocks' },
+    { syntax: 'Table', makes: 'The Table button in the toolbar inserts one', group: 'blocks' },
+    { syntax: '---', makes: 'A horizontal rule', group: 'blocks' },
+];

package/dist/components/media-upload-outcome.d.ts

@@ -1,12 +1,16 @@
 import type { MediaEntry } from '../media/manifest.js';
 import type { UploadResult } from '../sveltekit/content-routes.js';
 import type { IngestFailureKind } from './client-ingest.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;
@@ -18,10 +22,12 @@ export type UploadOutcome = {
 } | {
     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;

package/dist/components/objective-errors.d.ts

@@ -1,15 +1,19 @@
 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. */

package/dist/components/objective-errors.js

@@ -20,14 +20,18 @@ const DOUBLE_SPACE = /[^\s] ( +)/g;
 // a single mark is correct, two or more of these three is plainly a typo. A mixed run ("?!") is not
 // 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, b) {
     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, from, to) {
     const out = [];
     const slice = text.slice(from, to);

package/dist/components/preview-doc.d.ts

@@ -13,8 +13,10 @@ export type PreviewDeviceId = PreviewDevice['id'];
 export declare const previewDevices: PreviewDevice[];
 /** The table row for a device id. The id type makes a miss impossible; the fallback satisfies find. */
 export declare function previewDevice(id: PreviewDeviceId): PreviewDevice;
-/** 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 declare function deviceLabel(d: PreviewDevice): string;
 /**
  * Build the preview iframe's srcdoc: a complete document linking the site's stylesheets around

package/dist/components/preview-doc.js

@@ -15,8 +15,10 @@ export const previewDevices = [
 export function previewDevice(id) {
     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) {
     return d.width === null ? d.label : `${d.label} · ${d.width} px`;
 }

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,60 +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
+/**
+ * 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 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');
@@ -135,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