@glw907/cairn-cms 0.54.0 → 0.56.0

package/dist/components/cairn-admin.css

@@ -3440,6 +3440,10 @@
     }
   }
 
+  :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .mt-0\.5 {
+    margin-top: calc(var(--spacing) * .5);
+  }
+
   :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .mt-1 {
     margin-top: calc(var(--spacing) * 1);
   }
@@ -3985,6 +3989,10 @@
     min-height: 50vh;
   }
 
+  :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .min-h-\[56vh\] {
+    min-height: 56vh;
+  }
+
   :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .min-h-full {
     min-height: 100%;
   }
@@ -4051,6 +4059,10 @@
     width: calc(var(--spacing) * 12);
   }
 
+  :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .w-28 {
+    width: calc(var(--spacing) * 28);
+  }
+
   :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .w-44 {
     width: calc(var(--spacing) * 44);
   }
@@ -4083,6 +4095,10 @@
     width: 1px;
   }
 
+  :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .max-w-0 {
+    max-width: calc(var(--spacing) * 0);
+  }
+
   :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .max-w-3xl {
     max-width: var(--container-3xl);
   }
@@ -4481,6 +4497,10 @@
     border-color: var(--color-base-300);
   }
 
+  :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .border-transparent {
+    border-color: #0000;
+  }
+
   @layer daisyui.l1.l2 {
     :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) :where(:not(ul, details, .menu-title, .btn)).menu-active {
       --tw-outline-style: none;
@@ -4712,6 +4732,10 @@
     padding-block: calc(var(--spacing) * 2);
   }
 
+  :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .py-3 {
+    padding-block: calc(var(--spacing) * 3);
+  }
+
   :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .py-3\.5 {
     padding-block: calc(var(--spacing) * 3.5);
   }
@@ -4886,6 +4910,11 @@
     letter-spacing: -.01em;
   }
 
+  :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .tracking-\[0\.02em\] {
+    --tw-tracking: .02em;
+    letter-spacing: .02em;
+  }
+
   :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .tracking-\[0\.08em\] {
     --tw-tracking: .08em;
     letter-spacing: .08em;
@@ -4987,6 +5016,11 @@
     font-variant-numeric: var(--tw-ordinal, ) var(--tw-slashed-zero, ) var(--tw-numeric-figure, ) var(--tw-numeric-spacing, ) var(--tw-numeric-fraction, );
   }
 
+  :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .tabular-nums {
+    --tw-numeric-spacing: tabular-nums;
+    font-variant-numeric: var(--tw-ordinal, ) var(--tw-slashed-zero, ) var(--tw-numeric-figure, ) var(--tw-numeric-spacing, ) var(--tw-numeric-fraction, );
+  }
+
   @layer daisyui.l1.l2 {
     :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .link-hover {
       text-decoration-line: none;
@@ -5053,6 +5087,10 @@
     opacity: .7;
   }
 
+  :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .opacity-\[0\.62\] {
+    opacity: .62;
+  }
+
   :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .shadow {
     --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, #0000001a), 0 1px 2px -1px var(--tw-shadow-color, #0000001a);
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
@@ -5306,6 +5344,18 @@
     }
   }
 
+  @media (hover: hover) {
+    :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .hover\:bg-primary\/\[0\.06\]:hover {
+      background-color: var(--color-primary);
+    }
+
+    @supports (color: color-mix(in lab, red, red)) {
+      :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .hover\:bg-primary\/\[0\.06\]:hover {
+        background-color: color-mix(in oklab, var(--color-primary) 6%, transparent);
+      }
+    }
+  }
+
   @media (hover: hover) {
     :where([data-theme='cairn-admin'], [data-theme='cairn-admin-dark']) .hover\:text-\[var\(--color-primary\)\]:hover {
       color: var(--color-primary);

package/dist/components/editor-folding.d.ts

@@ -1,7 +1,8 @@
 import { type Extension } from '@codemirror/state';
 /**
- * The cairn fold extension: the CodeMirror fold system with the pill placeholder, the chevron and
- * wash affordance, the safety invariant, and the Ctrl+Shift+[ / ] keymap. Session-local and never
- * persisted: the fold state lives in CodeMirror's foldState field, which this never serializes.
+ * The cairn fold extension: the CodeMirror fold system with the pill placeholder, the gutter chevron
+ * and folded-row wash affordance, the safety invariant, and the Ctrl+Shift+[ / ] keymap.
+ * Session-local and never persisted: the fold state lives in CodeMirror's foldState field, which
+ * this never serializes.
  */
 export declare function cairnFolding(): Extension;

package/dist/components/editor-folding.js

@@ -1,29 +1,25 @@
-// Container folding: CodeMirror's fold system driven by cairn's directive grammar, with the rail
-// band as the affordance. Client-only like editor-highlight and editor-modes; MarkdownEditor
+// Container folding: CodeMirror's fold system driven by cairn's directive grammar, with a real
+// gutter column as the affordance. Client-only like editor-highlight and editor-modes; MarkdownEditor
 // reaches this module through a dynamic import, so the static @codemirror imports here never enter
 // a server bundle (guarded by the editor-boundary test).
 //
-// The architecture (plan decision 4): @codemirror/language's codeFolding plus foldEffect/
+// The architecture (spec 2026-06-14): @codemirror/language's codeFolding plus foldEffect/
 // unfoldEffect, never a custom fold store. Fold ranges come only from containerRanges, the pure
 // pairing helper beside fenceScan. The safety invariant lives in one transactionExtender that
-// appends unfold effects when a change or selection touches a folded range. The chevrons are
-// widget decorations from this module's own ViewPlugin (the rails are box-shadows, there is no CM
-// gutter element to hang a foldGutter on).
+// appends unfold effects when a change or selection touches a folded range. The control is a custom
+// gutter() whose GutterMarker is a focusable button on each paired-opener row; a lower-level
+// gutter (not foldGutter) is what lets the caret-inside state stay live, since its lineMarkerChange
+// recomputes on selection changes.
 //
 // The safety invariant: an author never edits, deletes, or fails to see hidden text.
-import { Decoration, EditorView, ViewPlugin, WidgetType, keymap, } from '@codemirror/view';
+import { Decoration, EditorView, GutterMarker, ViewPlugin, gutter, keymap, } from '@codemirror/view';
 import { EditorState, Prec, RangeSetBuilder, StateEffect, StateField } from '@codemirror/state';
 import { codeFolding, foldEffect, foldedRanges, unfoldEffect } from '@codemirror/language';
 import { caretContainerRange, containerRanges, fenceScan } from './markdown-directives.js';
-// Deeper nesting shares the third visual step, matching the rail stepping in editor-highlight.
-const DEPTH_STEPS = 3;
-// The chevron sits over the container's own innermost bar: depth 1 at x0, depth 2 at x8, depth 3
-// at x16, so indentation telegraphs the nesting and depth 3 never collides with depth 2.
-const chevronX = (depth) => (Math.min(depth, DEPTH_STEPS) - 1) * 8;
-// The two chevron glyphs from the gold-standard mockup: down (caret inside) and right (folded).
+// One chevron glyph; CSS rotates it (down open, right folded) and reveals it on gutter hover. The
+// gutter is the fixed-x home, so the chevron no longer encodes depth by position.
 const CHEVRON_DOWN = 'm6 9 6 6 6-6';
-const CHEVRON_RIGHT = 'm9 6 6 6-6 6';
-function chevronSvg(direction) {
+function chevronSvg() {
     const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
     svg.setAttribute('viewBox', '0 0 24 24');
     svg.setAttribute('fill', 'none');
@@ -33,55 +29,10 @@ function chevronSvg(direction) {
     svg.setAttribute('stroke-linejoin', 'round');
     svg.setAttribute('aria-hidden', 'true');
     const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-    path.setAttribute('d', direction === 'down' ? CHEVRON_DOWN : CHEVRON_RIGHT);
+    path.setAttribute('d', CHEVRON_DOWN);
     svg.appendChild(path);
     return svg;
 }
-// The opener-row band: the whole 28px gutter is the click target (cursor pointer over the band
-// only, the opener text never folds), and the chevron lives inside it at the container's bar x.
-// The widget knows its own container and whether it is folded, so the click toggles the right
-// range; the depth class lets the theme step the chevron ink.
-class FoldBandWidget extends WidgetType {
-    range;
-    folded;
-    caretInside;
-    constructor(range, folded, caretInside) {
-        super();
-        this.range = range;
-        this.folded = folded;
-        this.caretInside = caretInside;
-    }
-    eq(other) {
-        return (other.range.fromLine === this.range.fromLine &&
-            other.range.toLine === this.range.toLine &&
-            other.range.depth === this.range.depth &&
-            other.folded === this.folded &&
-            other.caretInside === this.caretInside);
-    }
-    toDOM(view) {
-        const band = document.createElement('span');
-        const depth = Math.min(this.range.depth, DEPTH_STEPS);
-        // Folded rows always show the chevron (right); an open container shows it down while the caret
-        // is inside; otherwise it fades in on rail-band hover (the band's own :hover, in the theme).
-        // The depth class carries the stepped ink.
-        const state = this.folded ? ' cm-cairn-fold-folded' : this.caretInside ? ' cm-cairn-fold-active' : '';
-        band.className = `cm-cairn-fold-band cm-cairn-fold-depth-${depth}${state}`;
-        const chevron = chevronSvg(this.folded ? 'right' : 'down');
-        chevron.style.left = `${chevronX(this.range.depth)}px`;
-        band.appendChild(chevron);
-        band.addEventListener('mousedown', (e) => {
-            // mousedown, not click: a click would first move the caret into the line. preventDefault
-            // keeps the caret where it is and stops the band from stealing focus from the editor.
-            e.preventDefault();
-            e.stopPropagation();
-            toggleFold(view, this.range);
-        });
-        return band;
-    }
-    ignoreEvent() {
-        return false;
-    }
-}
 // The pill placeholder: a real focusable button counting the hidden lines, the screen-reader story
 // for a fold. preparePlaceholder computes the count off the folded char range so placeholderDOM
 // renders it without re-deriving. Clicking unfolds through CodeMirror's own onclick handler.
@@ -99,8 +50,7 @@ function placeholderDOM(view, onclick, lines) {
 }
 // The char range a container folds: end-of-opener-line to end-of-closer-line, so the bare closer
 // never dangles. Null when the opener and closer share a line (nothing to hide). The one place
-// that turns a line range into the fold range, shared by the toggle, the keymap, and the
-// decoration build.
+// that turns a line range into the fold range, shared by the toggle, the keymap, and the gutter.
 function foldCharRange(state, range) {
     const opener = state.doc.line(range.fromLine + 1);
     const closer = state.doc.line(range.toLine + 1);
@@ -129,20 +79,44 @@ function foldExists(state, from, to) {
 // returns the nearest enclosing container, but a container that never closes (an unbalanced
 // opener) must not fold, so the result is only honored when containerRanges actually pairs it.
 function caretFoldRange(view) {
-    const scan = fenceScan(docLines(view));
+    const { scan, ranges } = foldScanFor(view.state);
     const caretLine = view.state.doc.lineAt(view.state.selection.main.head).number - 1;
     const inner = caretContainerRange(scan, caretLine);
     if (!inner)
         return null;
-    return (containerRanges(scan).find((r) => r.fromLine === inner.fromLine && r.toLine === inner.toLine) ?? null);
+    return ranges.find((r) => r.fromLine === inner.fromLine && r.toLine === inner.toLine) ?? null;
 }
-function docLines(view) {
-    const doc = view.state.doc;
+function docLines(state) {
     const lines = [];
-    for (let n = 1; n <= doc.lines; n++)
-        lines.push(doc.line(n).text);
+    for (let n = 1; n <= state.doc.lines; n++)
+        lines.push(state.doc.line(n).text);
     return lines;
 }
+// The scan and its paired ranges, memoized per state so the gutter's per-line lookups stay linear
+// rather than rescanning the whole document on every line.
+const scanCache = new WeakMap();
+function foldScanFor(state) {
+    let cached = scanCache.get(state);
+    if (!cached) {
+        const scan = fenceScan(docLines(state));
+        cached = { scan, ranges: containerRanges(scan) };
+        scanCache.set(state, cached);
+    }
+    return cached;
+}
+// The paired container whose opener sits at this line start, or null (a closer, a prose line, or an
+// unbalanced opener gets nothing). The sole source of which rows carry a fold control.
+function openerRangeAt(state, lineFrom) {
+    const lineIndex = state.doc.lineAt(lineFrom).number - 1;
+    return foldScanFor(state).ranges.find((r) => r.fromLine === lineIndex) ?? null;
+}
+// Whether the caret's innermost container is exactly this one, the caret-inside active state.
+function caretInside(state, range) {
+    const { scan } = foldScanFor(state);
+    const caretLine = state.doc.lineAt(state.selection.main.head).number - 1;
+    const inner = caretContainerRange(scan, caretLine);
+    return !!inner && inner.fromLine === range.fromLine && inner.toLine === range.toLine;
+}
 // The keymap: Ctrl+Shift+[ folds, Ctrl+Shift+] unfolds, the innermost container at the caret. No
 // fold-all, no chords. (CodeMirror's own foldKeymap binds the same keys to its tree-folding
 // commands; this module replaces them with the container-aware versions and never adds foldKeymap.)
@@ -242,31 +216,23 @@ function safetyExtender() {
         return effects.length ? { effects } : null;
     });
 }
-// The chevron-and-wash plugin: a widget on each opener row of a paired container (the band with
-// the chevron) and the folded-row wash line decoration. Rebuilds on doc change (the container set
-// moves), selection change (the caret-inside chevron state), viewport change, and any fold change
-// (a fold flips a chevron and adds a wash). The hover reveal is the band's own CSS :hover in the
-// theme, so it costs no rebuild.
-function foldDecorations(view, scan, ranges) {
+// The folded-row wash plugin: a line decoration on each folded opener row, square and full-row so
+// folded spots read in a scan. Rebuilds on doc change (the container set moves), viewport change,
+// and any fold change (a fold adds a wash, an unfold removes it). The chevron lives in the gutter
+// now, not here; this plugin carries only the wash and the unfold flash scheduling.
+function foldDecorations(view, ranges) {
     const builder = new RangeSetBuilder();
-    const caretLine = view.state.doc.lineAt(view.state.selection.main.head).number - 1;
-    const inner = caretContainerRange(scan, caretLine);
-    // One opener row may host several enclosing containers' bars, but only its OWN container opens
-    // there, so a single band per opener row. Sort by opener line so the builder receives ascending
-    // positions; equal openers cannot happen (one open per line).
+    // Sort by opener line so the builder receives ascending positions; equal openers cannot happen
+    // (one open per line).
     const byOpener = [...ranges].sort((a, b) => a.fromLine - b.fromLine);
     for (const range of byOpener) {
         const span = foldCharRange(view.state, range);
         if (!span)
             continue;
         const opener = view.state.doc.line(range.fromLine + 1);
-        const folded = foldExists(view.state, span.from, span.to);
-        // The folded opener row carries the wash; a line decoration so the rails (box-shadows on the
-        // same element) run through it unbroken.
-        if (folded)
+        // A line decoration so the rails (box-shadows on the same element) run through it unbroken.
+        if (foldExists(view.state, span.from, span.to))
             builder.add(opener.from, opener.from, washLine);
-        const caretInside = !!inner && inner.fromLine === range.fromLine && inner.toLine === range.toLine;
-        builder.add(opener.from, opener.from, Decoration.widget({ widget: new FoldBandWidget(range, folded, caretInside), side: -1 }));
     }
     return builder.finish();
 }
@@ -274,21 +240,18 @@ const washLine = Decoration.line({ class: 'cm-cairn-folded-row' });
 function foldPlugin() {
     return ViewPlugin.fromClass(class {
         decorations;
-        scan;
         ranges;
         constructor(view) {
-            this.scan = fenceScan(docLines(view));
-            this.ranges = containerRanges(this.scan);
-            this.decorations = foldDecorations(view, this.scan, this.ranges);
+            this.ranges = foldScanFor(view.state).ranges;
+            this.decorations = foldDecorations(view, this.ranges);
         }
         update(update) {
             if (update.docChanged) {
-                this.scan = fenceScan(docLines(update.view));
-                this.ranges = containerRanges(this.scan);
+                this.ranges = foldScanFor(update.view.state).ranges;
             }
             const foldChanged = update.transactions.some((tr) => tr.effects.some((e) => e.is(foldEffect) || e.is(unfoldEffect)));
-            if (update.docChanged || update.viewportChanged || update.selectionSet || foldChanged) {
-                this.decorations = foldDecorations(update.view, this.scan, this.ranges);
+            if (update.docChanged || update.viewportChanged || foldChanged) {
+                this.decorations = foldDecorations(update.view, this.ranges);
             }
             // Flash the revealed lines on an unfold, then schedule the clear. Folding adds no flash.
             for (const tr of update.transactions) {
@@ -311,14 +274,82 @@ function foldPlugin() {
         }
     }, { decorations: (v) => v.decorations });
 }
+const FOLD_KEY_HINT = ' (Ctrl+Shift+[)';
+const UNFOLD_KEY_HINT = ' (Ctrl+Shift+])';
+// The gutter control: a real focusable button per paired-opener row, holding one chevron that CSS
+// rotates (down open, right folded) and reveals on gutter hover. mousedown keeps the caret and
+// focus where they are; click toggles, so one handler serves a mouse click and a keyboard
+// activation (Enter/Space) with no double-toggle. The folded and caret-active classes carry the
+// state the theme reads.
+class FoldMarker extends GutterMarker {
+    container;
+    folded;
+    active;
+    constructor(container, folded, active) {
+        super();
+        this.container = container;
+        this.folded = folded;
+        this.active = active;
+    }
+    eq(other) {
+        return (other instanceof FoldMarker &&
+            other.container.fromLine === this.container.fromLine &&
+            other.container.toLine === this.container.toLine &&
+            other.folded === this.folded &&
+            other.active === this.active);
+    }
+    toDOM(view) {
+        const btn = document.createElement('button');
+        btn.type = 'button';
+        const label = this.folded ? 'Unfold this section' : 'Fold this section';
+        btn.className =
+            'cm-cairn-fold-btn' +
+                (this.folded ? ' cm-cairn-fold-folded' : '') +
+                (this.active ? ' cm-cairn-fold-active' : '');
+        btn.setAttribute('aria-label', label);
+        btn.title = label + (this.folded ? UNFOLD_KEY_HINT : FOLD_KEY_HINT);
+        btn.appendChild(chevronSvg());
+        btn.addEventListener('mousedown', (e) => e.preventDefault());
+        btn.addEventListener('click', (e) => {
+            e.preventDefault();
+            toggleFold(view, this.container);
+        });
+        return btn;
+    }
+}
+// The fold gutter: a fixed-x column (width from the theme) carrying one FoldMarker per paired
+// opener. lineMarker returns null for every other row, so the column is empty whitespace down the
+// rest of the surface. lineMarkerChange recomputes the markers on a doc change, a selection change
+// (the caret-inside state follows the cursor), and any fold effect (a fold flips the chevron).
+function foldGutterColumn() {
+    return gutter({
+        class: 'cm-cairn-fold-gutter',
+        lineMarker(view, line) {
+            const range = openerRangeAt(view.state, line.from);
+            if (!range)
+                return null;
+            const span = foldCharRange(view.state, range);
+            if (!span)
+                return null;
+            const folded = foldExists(view.state, span.from, span.to);
+            return new FoldMarker(range, folded, caretInside(view.state, range));
+        },
+        lineMarkerChange(update) {
+            return (update.docChanged ||
+                update.selectionSet ||
+                update.transactions.some((tr) => tr.effects.some((e) => e.is(foldEffect) || e.is(unfoldEffect))));
+        },
+    });
+}
 // The design notes' diagnostics rules (a deliberately refolded erroring container keeps its fold
 // and tints the pill warning ink instead of re-springing on every lint) have no trigger today: the
 // editor carries no lint source, so there is nothing to refold around or to tint. Deliberately not
 // built; do not invent a lint system to satisfy a rule with no input.
 /**
- * The cairn fold extension: the CodeMirror fold system with the pill placeholder, the chevron and
- * wash affordance, the safety invariant, and the Ctrl+Shift+[ / ] keymap. Session-local and never
- * persisted: the fold state lives in CodeMirror's foldState field, which this never serializes.
+ * The cairn fold extension: the CodeMirror fold system with the pill placeholder, the gutter chevron
+ * and folded-row wash affordance, the safety invariant, and the Ctrl+Shift+[ / ] keymap.
+ * Session-local and never persisted: the fold state lives in CodeMirror's foldState field, which
+ * this never serializes.
  */
 export function cairnFolding() {
     return [
@@ -326,6 +357,7 @@ export function cairnFolding() {
         flashField,
         safetyExtender(),
         foldPlugin(),
+        foldGutterColumn(),
         foldKeymap,
     ];
 }

package/dist/components/editor-highlight.js

@@ -5,7 +5,7 @@ import { HighlightStyle } from '@codemirror/language';
 import { tags } from '@lezer/highlight';
 import { Decoration, ViewPlugin } from '@codemirror/view';
 import { RangeSetBuilder } from '@codemirror/state';
-import { caretContainerRange, containerRanges, directiveLineKind, fenceScan, fenceTokens, findInlineDirectives, markerPrefix, } from './markdown-directives.js';
+import { caretContainerRange, directiveLineKind, fenceScan, fenceTokens, findInlineDirectives, markerPrefix, } from './markdown-directives.js';
 /** Markdown token colors over the admin theme variables. */
 export function cairnHighlightStyle() {
     // Rule order is load-bearing. HighlightStyle emits its CSS in spec order, so on a span that
@@ -48,11 +48,6 @@ const DEPTH_STEPS = [1, 2, 3];
 const fenceLines = DEPTH_STEPS.map((d) => Decoration.line({ class: `cm-cairn-directive-fence cm-cairn-depth-${d}`, attributes: { title: MACHINERY_HINT } }));
 const contentLines = DEPTH_STEPS.map((d) => Decoration.line({ class: `cm-cairn-directive-content cm-cairn-depth-${d}` }));
 const leafLine = Decoration.line({ class: 'cm-cairn-directive-leaf', attributes: { title: MACHINERY_HINT } });
-// A paired container's opener row, where the fold chevron replaces the container's own innermost
-// rail bar. The class is additive over the fence depth class, so the theme drops only the deepest
-// bar on this row while the outer bars stay; an unbalanced opener never gets it (no chevron, bar
-// intact). Added just after the fence depth line decoration so the row carries both classes.
-const openerLine = Decoration.line({ class: 'cm-cairn-directive-opener' });
 const inlineMark = Decoration.mark({ class: 'cm-cairn-directive-inline' });
 // Within a fence line, machinery (colons, brackets, braces) dims to the marker tone while the
 // directive name and label keep a depth-stepped ink: meaning over machinery.
@@ -101,9 +96,6 @@ function buildDirectiveDecorations(view, scan) {
     // as its own line decoration just ahead of the row's depth decoration.
     const caretLine = view.state.doc.lineAt(view.state.selection.main.head).number - 1;
     const caret = caretContainerRange(scan, caretLine);
-    // The opener rows that carry a fold chevron, so the rail rule drops their innermost bar. Only
-    // paired containers fold, so an unbalanced opener is absent here and keeps its full rail.
-    const openerLines = new Set(containerRanges(scan).map((r) => r.fromLine));
     for (const { from, to } of view.visibleRanges) {
         for (let pos = from; pos <= to;) {
             const line = view.state.doc.lineAt(pos);
@@ -116,10 +108,6 @@ function buildDirectiveDecorations(view, scan) {
             // inside a code block, outside any container); it gets no machinery treatment.
             if (kind === 'fence' && depth > 0) {
                 builder.add(line.from, line.from, fenceLines[depth - 1]);
-                // A paired opener row gets the opener class just after its fence depth class, so the rail
-                // rule below drops the innermost bar where the chevron renders.
-                if (openerLines.has(line.number - 1))
-                    builder.add(line.from, line.from, openerLine);
             }
             else if (kind === 'leaf') {
                 builder.add(line.from, line.from, leafLine);

package/dist/content/concepts.js

@@ -76,9 +76,11 @@ export function normalizeConcepts(content, urlPolicy = {}, routing = CONCEPT_ROU
         const conceptRouting = routing[id] ?? DEFAULT_ROUTING;
         const policy = urlPolicy[id] ?? {};
         validateUrlPolicy(id, policy, conceptRouting.dated);
+        const label = config.label ?? defaultLabel(id);
         descriptors.push({
             id,
-            label: config.label ?? defaultLabel(id),
+            label,
+            singular: config.singular ?? label,
             dir: config.dir,
             routing: conceptRouting,
             permalink: policy.permalink ?? defaultPermalink(id),

package/dist/content/manifest.d.ts

@@ -7,6 +7,7 @@ export interface ManifestEntry {
     title: string;
     date?: string;
     permalink: string;
+    summary?: string;
     draft: boolean;
     links: CairnRef[];
 }

package/dist/content/manifest.js

@@ -4,6 +4,7 @@
 // it; the save path patches one entry and commits it with the content in one commit. Each entry
 // carries its identity and its outbound cairn: edges, so the manifest is the link graph.
 import { parseMarkdown } from './frontmatter.js';
+import { deriveExcerpt } from './excerpt.js';
 import { entryIdentity, asString } from './identity.js';
 import { extractCairnLinks } from './links.js';
 /** Build one manifest entry from a content file. Drafts are included and flagged. The id, date, and
@@ -18,6 +19,9 @@ export function manifestEntryFromFile(descriptor, file) {
         title: asString(frontmatter.title) ?? id,
         date,
         permalink,
+        // Coalesce an empty excerpt to undefined, so an empty-body entry carries no summary key at all
+        // (matching serialize's optional-spread) and the in-memory and serialized shapes agree.
+        summary: deriveExcerpt(body, { description: asString(frontmatter.description) }) || undefined,
         draft: frontmatter.draft === true,
         links: extractCairnLinks(body),
     };
@@ -38,6 +42,7 @@ export function serializeManifest(manifest) {
         title: e.title,
         ...(e.date ? { date: e.date } : {}),
         permalink: e.permalink,
+        ...(e.summary ? { summary: e.summary } : {}),
         draft: e.draft,
         links: [...e.links].sort(compareRef).map((r) => ({ concept: r.concept, id: r.id })),
     }));
@@ -68,6 +73,7 @@ export function parseManifest(raw) {
             typeof e.permalink === 'string' &&
             typeof e.draft === 'boolean' &&
             (e.date === undefined || typeof e.date === 'string') &&
+            (e.summary === undefined || typeof e.summary === 'string') &&
             Array.isArray(e.links);
         if (!ok) {
             throw new Error(`content manifest: malformed entry ${JSON.stringify(e)}`);

package/dist/content/types.d.ts

@@ -92,6 +92,8 @@ export interface ConceptConfig<S extends ConceptSchema = ConceptSchema> {
     dir: string;
     /** Sidebar label; defaults from the concept id when omitted. */
     label?: string;
+    /** The singular noun for the create affordances ("New post"); defaults to `label` when omitted. */
+    singular?: string;
     /** The concept's schema: the form projection, the generated validator, and the inferred type. */
     schema: S;
     /** Frontmatter keys to surface on each `ContentSummary.fields`, so a list card reads an authored
@@ -221,6 +223,9 @@ export interface ConceptDescriptor {
     /** Concept id, the key under `content`, e.g. "posts". */
     id: string;
     label: string;
+    /** The singular noun for the create affordances ("New post"); resolved from `ConceptConfig.singular`,
+     *  defaulting to `label` when the config omits it. */
+    singular: string;
     dir: string;
     routing: RoutingRule;
     /** The resolved permalink pattern, defaulted by `normalizeConcepts`. */

package/dist/delivery/content-index.js

@@ -4,7 +4,7 @@
 // every operation reads the descriptor and its routing rule, never a hardcoded concept id.
 import { parseMarkdown } from '../content/frontmatter.js';
 import { entryId, entryIdentity, asDate, asString, asTags } from '../content/identity.js';
-import { deriveExcerpt, wordCount } from './excerpt.js';
+import { deriveExcerpt, wordCount } from '../content/excerpt.js';
 /** Map a Vite eager `?raw` glob record (`{ path: raw }`) to `RawFile[]`. */
 export function fromGlob(record) {
     return Object.entries(record).map(([path, raw]) => ({ path, raw }));

package/dist/delivery/data.d.ts

@@ -5,7 +5,7 @@ export type { SiteResolver, ConceptIndex } from './site-resolver.js';
 export { createSiteIndexes } from './site-indexes.js';
 export type { SiteIndexes, SiteGlobs } from './site-indexes.js';
 export { siteDescriptors } from './site-descriptors.js';
-export { deriveExcerpt, wordCount } from './excerpt.js';
+export { deriveExcerpt, wordCount } from '../content/excerpt.js';
 export { buildRssFeed, buildJsonFeed } from './feeds.js';
 export type { FeedChannel, FeedItem } from './feeds.js';
 export { buildSitemap } from './sitemap.js';

package/dist/delivery/data.js

@@ -5,7 +5,7 @@ export { createContentIndex, fromGlob } from './content-index.js';
 export { createSiteResolver, buildLinkResolver } from './site-resolver.js';
 export { createSiteIndexes } from './site-indexes.js';
 export { siteDescriptors } from './site-descriptors.js';
-export { deriveExcerpt, wordCount } from './excerpt.js';
+export { deriveExcerpt, wordCount } from '../content/excerpt.js';
 export { buildRssFeed, buildJsonFeed } from './feeds.js';
 export { buildSitemap } from './sitemap.js';
 export { buildRobots } from './robots.js';

package/dist/sveltekit/content-routes.d.ts

@@ -44,11 +44,17 @@ export interface EntrySummary {
     draft: boolean;
     /** Publish state derived from the ref set: live as-is, live with pending edits, or branch-only. */
     status: 'published' | 'edited' | 'new';
+    /** The row's one-line summary: the manifest's indexed excerpt for a published row, the branch
+     *  frontmatter/body excerpt for a pending one, and null when neither yields text. */
+    summary: string | null;
 }
 /** The concept list view's data. */
 export interface ListData {
     conceptId: string;
     label: string;
+    /** The singular noun for the create affordances ("New post"); from the descriptor, which defaults
+     *  it to `label`. */
+    singular: string;
     /** Posts carry a date in the new-entry form; pages do not (concept routing, spec §7.2). */
     dated: boolean;
     entries: EntrySummary[];