@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/components/blocks/text/TextEditableBlock.svelte.d.ts

@@ -24,9 +24,10 @@ declare const TextEditableBlock: import("svelte").Component<$$ComponentProps, {
     isVerticallyTransparent: () => boolean;
     enterEdgeWidget: (side: "start" | "end") => boolean;
     claimRootClipboard: (event: ClipboardEvent) => void;
-    insertMarkdown: (md: string) => boolean;
+    insertMarkdown: (md: string) => Promise<boolean>;
     snapCaretToPoint: (clientX: number, clientY: number) => void;
     runCommand: (id: CommandId, arg?: unknown) => boolean;
+    afterSourceCommit: (run: () => void, offset?: number | import("../../../cursor/coordinate-spaces").RawOffset) => void;
     isCommandActive: (id: CommandId) => boolean;
 }, "">;
 type TextEditableBlock = ReturnType<typeof TextEditableBlock>;

package/dist/components/blocks/text/auto-pair-record.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The empty delimiter pair the auto-pair last wrote, one record per editor: only that pair is its
+ * to step over, collapse or delete, since the same bytes typed by hand are the user's. It holds
+ * while the pair and the text either side are the bytes the write left, so typing inside keeps
+ * it; an edit outside it, or a key with the caret elsewhere or in another block, ends it.
+ */
+import type { ContentRange } from '../../../core/inline';
+export interface AutoPairRecord {
+    /** A view of the record for one block; each call is a new block identity. */
+    forBlock(): BlockAutoPairs;
+}
+export interface BlockAutoPairs {
+    /**
+     * The pair the auto-pair wrote, when it is still empty and `caret` sits between its runs or
+     * just past it (a stepped-over partner). A caret anywhere else ends the record.
+     */
+    consult(text: string, caret: number): ContentRange | null;
+    /** Record the empty pair a write left at `pair` in `text`. */
+    remember(text: string, pair: ContentRange): void;
+    /** The key closed, deleted or dropped the pair. */
+    forget(): void;
+}
+export declare function createAutoPairRecord(): AutoPairRecord;

package/dist/components/blocks/text/auto-pair-record.js

@@ -0,0 +1,51 @@
+/**
+ * The empty delimiter pair the auto-pair last wrote, one record per editor: only that pair is its
+ * to step over, collapse or delete, since the same bytes typed by hand are the user's. It holds
+ * while the pair and the text either side are the bytes the write left, so typing inside keeps
+ * it; an edit outside it, or a key with the caret elsewhere or in another block, ends it.
+ */
+export function createAutoPairRecord() {
+    let written = null;
+    return {
+        forBlock() {
+            const block = {};
+            return {
+                consult(text, caret) {
+                    const pair = written?.block === block ? pairIn(written, text) : null;
+                    const k = written?.run.length ?? 0;
+                    const inBody = pair !== null && caret >= pair.start + k && caret <= pair.end - k;
+                    const empty = pair !== null && pair.end - pair.start === 2 * k;
+                    if (!pair || !(inBody || (empty && caret === pair.end))) {
+                        written = null;
+                        return null;
+                    }
+                    return empty ? pair : null;
+                },
+                remember(text, pair) {
+                    const k = (pair.end - pair.start) / 2;
+                    written = {
+                        block,
+                        before: text.slice(0, pair.start),
+                        run: text.slice(pair.start, pair.start + k),
+                        after: text.slice(pair.end)
+                    };
+                },
+                forget() {
+                    written = null;
+                }
+            };
+        }
+    };
+}
+// Where the written pair sits in `text` now, body included, or null once the bytes differ.
+function pairIn({ before, run, after }, text) {
+    const start = before.length;
+    const end = text.length - after.length;
+    if (end - start < 2 * run.length)
+        return null;
+    if (!text.startsWith(before) || !text.endsWith(after))
+        return null;
+    if (!text.startsWith(run, start) || !text.startsWith(run, end - run.length))
+        return null;
+    return { start, end };
+}

package/dist/components/blocks/text/click-snap-guard.d.ts

@@ -1,11 +1,13 @@
-/** Native-vs-synthetic caret and plain-key guards shared across the text surface. */
-/** Caret in a real text node the reader can see: the native caret renders there, so the
- *  synthetic indicator stands down. Hidden marker text renders nothing, so it does not count. */
+/** Shared checks about the caret and the key, used across a text block's editable element. */
+/** Caret in a text node the user can see: the browser draws a caret there, so the editor's own
+ *  caret indicator is not needed. Hidden marker text renders nothing, so it does not count. */
 export declare function caretIsInTextContent(el: HTMLElement, sel: Selection | null): boolean;
-/** A ranged selection this surface holds — the click ladder's rungs, a shift-click, a
- *  drag-select. It is the gesture's own paint, so a click-time caret seat stands down for it. */
+/** The same read for a caret position given as a node: the one a press is about to make. */
+export declare function seatIsInTextContent(el: HTMLElement, node: Node): boolean;
+/** Whether this element holds a selected range: a double or triple click, a shift-click, a
+ *  drag-select. The gesture drew that range, so click-time caret placement leaves it alone. */
 export declare function surfaceHoldsRange(el: HTMLElement, sel: Selection | null): boolean;
-/** Ctrl/meta/alt held — a platform command, never an edit of the byte beside the caret. */
+/** Ctrl, meta or alt held: a platform command, never an edit of the byte beside the caret. */
 export declare function hasModifier(e: KeyboardEvent): boolean;
 /** A typed character: no modifier chord, one code point. A chord is a command instead. */
 export declare function isPlainTypingKey(e: KeyboardEvent): boolean;

package/dist/components/blocks/text/click-snap-guard.js

@@ -1,23 +1,26 @@
-/** Native-vs-synthetic caret and plain-key guards shared across the text surface. */
+/** Shared checks about the caret and the key, used across a text block's editable element. */
 import { isCharacterKey } from '../../../schema/keybindings';
 import { isHiddenMarkerText } from '../../../cursor/widget-offset';
-/** Caret in a real text node the reader can see: the native caret renders there, so the
- *  synthetic indicator stands down. Hidden marker text renders nothing, so it does not count. */
+/** Caret in a text node the user can see: the browser draws a caret there, so the editor's own
+ *  caret indicator is not needed. Hidden marker text renders nothing, so it does not count. */
 export function caretIsInTextContent(el, sel) {
     if (!sel || sel.rangeCount === 0)
         return false;
-    const node = sel.getRangeAt(0).startContainer;
+    return seatIsInTextContent(el, sel.getRangeAt(0).startContainer);
+}
+/** The same read for a caret position given as a node: the one a press is about to make. */
+export function seatIsInTextContent(el, node) {
     return node.nodeType === Node.TEXT_NODE && el.contains(node) && !isHiddenMarkerText(node, el);
 }
-/** A ranged selection this surface holds — the click ladder's rungs, a shift-click, a
- *  drag-select. It is the gesture's own paint, so a click-time caret seat stands down for it. */
+/** Whether this element holds a selected range: a double or triple click, a shift-click, a
+ *  drag-select. The gesture drew that range, so click-time caret placement leaves it alone. */
 export function surfaceHoldsRange(el, sel) {
     if (!sel || sel.isCollapsed || sel.rangeCount === 0)
         return false;
     const range = sel.getRangeAt(0);
     return el.contains(range.startContainer) || el.contains(range.endContainer);
 }
-/** Ctrl/meta/alt held — a platform command, never an edit of the byte beside the caret. */
+/** Ctrl, meta or alt held: a platform command, never an edit of the byte beside the caret. */
 export function hasModifier(e) {
     return e.ctrlKey || e.metaKey || e.altKey;
 }

package/dist/components/blocks/text/composition-seat.d.ts

@@ -1,32 +1,36 @@
 /**
- * One composition's worth of seat inputs, captured at `compositionstart`. Both inputs the commit's
- * relocation needs — the arrival side and the pending marks — belong to the caret the composition
- * OPENED at, and the affinity re-arm has spent them by the time the composed run arrives.
+ * What an IME composition needs remembered, captured at `compositionstart`. The arrival side and
+ * the pending marks both belong to the caret the composition opened at, and by the time the
+ * composed run arrives the arrival side has been overwritten, so they are captured up front.
  */
 import type { InlineNode } from '../../../core/nodes';
 import type { VisibilityContext } from '../../../core/inline/visibility';
 import type { EdgeAffinity } from '../../../cursor/edge-affinity';
+import type { Reading } from '../../../schema/reading';
 import type { InlineMarkKind } from '../../../schema/inline-construct-policy';
 export interface CompositionSeatDeps {
-    /** The block's display bytes — what a commit's read is compared against. */
+    /** The block's displayed text, which a commit's reading is compared against. */
     getDisplayText: () => string;
     getInlines: () => readonly InlineNode[];
+    /** The reading `getInlines` reads with, so a candidate keeps the reference links it shows and
+     *  reads back as the syntax the editor draws. */
+    reading: Reading;
     getAffinity: () => EdgeAffinity | null;
-    /** How the surface reads on screen, for the seat's own painted-range question. */
+    /** How the block reads on screen, for deciding which ranges are actually drawn. */
     getScreen: () => VisibilityContext;
     /** Spend the pending marks: a composition is the one insertion they were promised to. */
     consumePendingMarks: () => ReadonlySet<InlineMarkKind> | null;
-    /** Give them back when the composition committed nothing — an IME cancel inserts no run, so
-     *  the promise is still owed. Required, so both surfaces answer for it alike. */
+    /** Give them back when the composition wrote nothing: a cancelled IME run inserts nothing, so
+     *  the marks are still pending. Required, so every block answers the same way. */
     restorePendingMarks: (marks: ReadonlySet<InlineMarkKind>) => void;
-    /** The block's live selection, read at compositionstart: composing over one is a range op no
-     *  plain-insertion arm claims, so it routes to `resolveRangeEdit`. Omit to keep ranges verbatim. */
+    /** The block's selection, read at `compositionstart`: composing over one goes to
+     *  `resolveRangeEdit`. Omit to keep ranges as the browser wrote them. */
     getRawSelection?: () => {
         start: number;
         end: number;
     } | null;
-    /** The surface's join-seam resolution for a range replace, in display bytes; null keeps the
-     *  engine's own edit — the same decline contract as the keydown selection-edit arm. */
+    /** How this block resolves a range replace, in displayed bytes; null keeps the browser's own
+     *  edit, the same refusal the keydown selection-edit path makes. */
     resolveRangeEdit?: (range: {
         start: number;
         end: number;
@@ -36,9 +40,8 @@ export interface CompositionSeatDeps {
     } | null;
 }
 export interface CompositionSeat {
-    /** Capture the window the composition opened in. Call BEFORE the surface's own
-     *  `compositionstart`, whose cross-block half clears the affinity, and before the first
-     *  mid-composition `input`, which re-arms it to the typed side. */
+    /** Capture the state the composition opened in. Call it before the block's own
+     *  `compositionstart` and the first `input`, which both overwrite the arrival side. */
     noteStart(): void;
     /** The bytes the commit should write, or null to keep the DOM read verbatim. */
     relocate(after: string, composedAt: number): {

package/dist/components/blocks/text/composition-seat.js

@@ -1,13 +1,13 @@
 /**
- * One composition's worth of seat inputs, captured at `compositionstart`. Both inputs the commit's
- * relocation needs — the arrival side and the pending marks — belong to the caret the composition
- * OPENED at, and the affinity re-arm has spent them by the time the composed run arrives.
+ * What an IME composition needs remembered, captured at `compositionstart`. The arrival side and
+ * the pending marks both belong to the caret the composition opened at, and by the time the
+ * composed run arrives the arrival side has been overwritten, so they are captured up front.
  */
 import { plainInsertionAt, relocateComposedRun } from './edge-seat';
 import { resolveMarkedInsertion } from './pending-mark-insert';
 export function createCompositionSeat(deps) {
-    // A single nullable capture rather than a stack: the window is compositionstart → the one
-    // commit compositionend drives.
+    // One nullable capture rather than a stack: a composition runs from `compositionstart` to the
+    // single commit `compositionend` drives.
     let started = null;
     return {
         noteStart: () => {
@@ -23,8 +23,8 @@ export function createCompositionSeat(deps) {
             if (started === null)
                 return null;
             started.committed = true;
-            // A selection at the window's open makes this a range replace: the plain arms below
-            // cannot claim it, and the engine's literal replace strands the runs the range crossed.
+            // A selection open at the start makes this a range replace, which the browser would do
+            // literally, stranding the delimiter runs the range crossed.
             if (started.range && started.range.start < started.range.end) {
                 const typed = replacedRangeInsertion(started.before, after, started.range);
                 if (typed === null)
@@ -37,11 +37,11 @@ export function createCompositionSeat(deps) {
                 const composed = plainInsertionAt(started.before, after, composedAt);
                 const marked = composed === null
                     ? null
-                    : resolveMarkedInsertion(started.before, composedAt, composed, started.marks, deps.getInlines());
+                    : resolveMarkedInsertion(started.before, composedAt, composed, started.marks, deps.getInlines(), deps.reading);
                 if (marked)
                     return marked;
             }
-            return relocateComposedRun(started.before, after, composedAt, deps.getInlines(), started.affinity, deps.getScreen());
+            return relocateComposedRun(started.before, after, composedAt, deps.getInlines(), started.affinity, deps.getScreen(), deps.reading);
         },
         noteEnd: () => {
             if (started && !started.committed && started.marks) {
@@ -51,8 +51,8 @@ export function createCompositionSeat(deps) {
         }
     };
 }
-/** The run the commit's read put over `range`, or null when the read is not a replacement of
- *  exactly that span — then nothing here knows what the engine did, and verbatim is honest. */
+/** The run the commit's reading put over `range`, or null when that reading is not a replacement
+ *  of exactly that span: nothing here can tell what the browser did, so verbatim is honest. */
 function replacedRangeInsertion(before, after, range) {
     const length = after.length - before.length + (range.end - range.start);
     if (length < 0 || range.end > before.length)

package/dist/components/blocks/text/construct-edge-delete.d.ts

@@ -1,47 +1,47 @@
 /**
- * What a destructive key takes at an inline construct's unpainted delimiter run: the adjacent
- * CONTENT character, plus the delimiters the cut leaves enclosing nothing (live-mode.md § 4.4
- * `autoUnwrapOnEmpty`). Bytes that read right can parse wrong, so a candidate is written only once
- * a re-parse says the reader lost exactly what the cut aimed at.
+ * What a destructive key takes at an inline construct's hidden delimiter run: the neighbouring
+ * content character, plus the delimiters the cut leaves enclosing nothing (live-mode.md § 4.4
+ * `autoUnwrapOnEmpty`). Bytes that read right can parse wrong, so a candidate is written only when,
+ * read back where it is stored, it shows the user lost exactly what the cut aimed at.
  */
 import { type ContentRange } from '../../../core/inline';
 import { type VisibilityContext } from '../../../core/inline/visibility';
-import type { InlineNode } from '../../../core/nodes';
+import type { AnyInlineKind, InlineNode } from '../../../core/nodes';
+import type { StoredAs } from '../../../schema/stored-as';
 export type DeleteDirection = 'backward' | 'forward';
 /** Named fields rather than a positional row: `display`, the two ranges and the caret are all
  *  offsets into the same string, and a swapped pair would type-check. */
 export interface EdgeDeletionQuery {
-    /** The block's display bytes — its raw without the trailing line ending. */
+    /** The block's displayed text: its raw without the trailing line ending. */
     display: string;
     /** The bytes the block's own kind calls content; a cut never reaches past them. */
     content: ContentRange;
     caret: number;
     direction: DeleteDirection;
-    /** How the block reads on screen. Required, so a second caller cannot inherit the hiding
-     *  assumption by silence. */
+    /** How the block reads on screen. Required, so a second caller cannot inherit an assumption
+     *  about what is hidden by saying nothing. */
     screen: VisibilityContext;
-    /** The inline tree the render painted from, so the runs skipped here are the runs hidden. */
+    /** The inline tree the render drew from, so the runs skipped here are the runs really hidden. */
     inlines: readonly InlineNode[];
-    /** What the caller installs the rewrite as, which is what the candidate is read back as.
-     *  Required for the same reason `screen` is: a cell's text is never a block. */
-    installedAs: EdgeDeletionSurface;
+    /** Where the block's bytes are stored, with the reading `inlines` was read in: a candidate is
+     *  read back there, so a cell's text stays text and a list item's reads behind its marker. */
+    store: StoredAs;
 }
-/** A prose surface installs a block; a table cell installs cell text, whose bytes read as a list or
- *  a quote the moment they open with `- ` or `> ` though the cell paints neither. */
-export type EdgeDeletionSurface = 'block' | 'cell';
 export interface EdgeDeletionWrite {
-    /** The block's whole display bytes after the cut. */
+    /** The block's whole displayed text after the cut. */
     raw: string;
     caret: number;
+    /** The marks of the constructs the cut emptied and unwrapped, for the caller to hold pending. */
+    unwrappedMarks: readonly AnyInlineKind[];
 }
-/** The press is this arm's but no rewrite parses back: taking nothing is the only answer that
- *  keeps the markers off screen, since the engine's version paints them. */
+/** The key belongs here but no rewrite parses back: taking nothing is the only answer that keeps
+ *  the markers off screen, since the browser's version would show them. */
 export interface EdgeDeletionSwallow {
     swallow: true;
 }
 export type EdgeDeletion = EdgeDeletionWrite | EdgeDeletionSwallow;
 /**
- * What a destructive key at `caret` does, or null when the press is not this arm's — nothing
- * content-side of the caret, or a cut with no hidden run beside it, which the engine gets right.
+ * What a destructive key at `caret` does, or null when it does not belong here: nothing on the
+ * content side of the caret, or a cut with no hidden run beside it, which the browser gets right.
  */
 export declare function resolveEdgeDeletion(query: EdgeDeletionQuery): EdgeDeletion | null;

package/dist/components/blocks/text/construct-edge-delete.js

@@ -1,21 +1,22 @@
 /**
- * What a destructive key takes at an inline construct's unpainted delimiter run: the adjacent
- * CONTENT character, plus the delimiters the cut leaves enclosing nothing (live-mode.md § 4.4
- * `autoUnwrapOnEmpty`). Bytes that read right can parse wrong, so a candidate is written only once
- * a re-parse says the reader lost exactly what the cut aimed at.
+ * What a destructive key takes at an inline construct's hidden delimiter run: the neighbouring
+ * content character, plus the delimiters the cut leaves enclosing nothing (live-mode.md § 4.4
+ * `autoUnwrapOnEmpty`). Bytes that read right can parse wrong, so a candidate is written only when,
+ * read back where it is stored, it shows the user lost exactly what the cut aimed at.
  */
-import { constructContentRange, inlineDescendants, parseInline } from '../../../core/inline';
+import { constructContentRange, inlineDescendants } from '../../../core/inline';
 import { CONTENT_VISIBILITY, renderedText } from '../../../core/inline/visibility';
+import { readBack, shownOf } from '../../../core/inline/live-edit/read-back';
 import { getInlineConstructPolicy } from '../../../schema/inline-construct-policy';
-import { removesExactly, soleProseReparse } from './screen-diff';
+import { removesExactly } from './screen-diff';
+import { isHighSurrogate, isLowSurrogate } from '../../../core/lines';
 /**
- * What a destructive key at `caret` does, or null when the press is not this arm's — nothing
- * content-side of the caret, or a cut with no hidden run beside it, which the engine gets right.
+ * What a destructive key at `caret` does, or null when it does not belong here: nothing on the
+ * content side of the caret, or a cut with no hidden run beside it, which the browser gets right.
  */
 export function resolveEdgeDeletion(query) {
-    // Painted delimiters are bytes the reader saw, so no run here is this arm's to protect and the
-    // license to drop one (live-mode.md § 2) does not reach: the press is the engine's. Every
-    // oracle call below is past this gate, which is why they can all take the content reading.
+    // Visible delimiters are bytes the user saw, so the key stays with the browser; everything
+    // below can therefore use the content reading.
     if (query.screen.chromePaints)
         return null;
     const { display, content, caret, direction } = query;
@@ -23,28 +24,33 @@ export function resolveEdgeDeletion(query) {
     const target = deletionTarget(display, constructs, content, caret, direction);
     if (!target)
         return null;
-    // The adjacency that decides is the deleted SPAN's, not the caret's: the engine deletes from
-    // where the byte is. With no run beside the cut the press stays with the engine, which owns
-    // grapheme and IME behavior.
+    // Decided beside the deleted span, not the caret. With no hidden run beside the cut the key
+    // stays with the browser, which handles graphemes and IME.
     const plain = expandThroughEmptied(constructs, target);
     const native = nativeCut(caret, direction);
     const touchesHiddenRun = isDelimiterByte(constructs, target.start - 1) || isDelimiterByte(constructs, target.end);
     if (!touchesHiddenRun && plain.start === native.start && plain.end === native.end)
         return null;
-    const before = visibleText(display, query.installedAs);
+    const before = visibleText(display, query);
     if (before === null)
         return null;
     const removed = target.atomic
-        ? renderedText([target.atomic], display, CONTENT_VISIBILITY)
+        ? renderedText([target.atomic], display, CONTENT_VISIBILITY, {
+            grammar: query.store.reading.grammar
+        })
         : display.slice(target.start, target.end);
     for (const cut of [plain, widenThroughRuns(constructs, plain)]) {
         const raw = display.slice(0, cut.start) + display.slice(cut.end);
-        const after = visibleText(raw, query.installedAs);
+        const after = visibleText(raw, query);
         if (after === null || !removesExactly(before, after, removed))
             continue;
         // Backward lands where the cut opened; forward keeps the caret where it was, which the cut
         // only moves when it swallowed delimiters ahead of it.
-        return { raw, caret: direction === 'backward' ? cut.start : Math.min(caret, cut.start) };
+        return {
+            raw,
+            caret: direction === 'backward' ? cut.start : Math.min(caret, cut.start),
+            unwrappedMarks: plain.unwrappedMarks
+        };
     }
     return { swallow: true };
 }
@@ -53,11 +59,8 @@ function nativeCut(caret, direction) {
         ? { start: caret - 1, end: caret }
         : { start: caret, end: caret + 1 };
 }
-/**
- * The first thing the reader can see on `direction`'s side of the caret: delimiter bytes are
- * stepped over, an atomic run is taken whole, and the walk stops at the content range because the
- * block's own structural bytes are not this arm's to touch.
- */
+/** The first thing the user can see on `direction`'s side of the caret. The scan stops at the
+ *  content range, since the block's own structural bytes are never deleted here. */
 function deletionTarget(display, constructs, content, caret, direction) {
     const step = direction === 'backward' ? -1 : 1;
     for (let at = direction === 'backward' ? caret - 1 : caret; at >= content.start && at < content.end; at += step) {
@@ -69,25 +72,16 @@ function deletionTarget(display, constructs, content, caret, direction) {
     }
     return null;
 }
-/** The whole code point `at` belongs to. Half a surrogate pair is not a character, and this arm
- *  claims presses beside a hidden run wherever they land — emoji included. */
+/** The whole code point `at` belongs to. Half a surrogate pair is not a character, and this module
+ *  handles keys beside a hidden run wherever they land, emoji included. */
 function codePointAt(display, at) {
-    const start = isLowSurrogate(display, at) && isHighSurrogate(display, at - 1) ? at - 1 : at;
-    return { start, end: isHighSurrogate(display, start) ? start + 2 : start + 1 };
-}
-function isHighSurrogate(display, at) {
-    const code = display.charCodeAt(at);
-    return code >= 0xd800 && code <= 0xdbff;
+    const start = isLowSurrogate(display.charCodeAt(at)) && isHighSurrogate(display.charCodeAt(at - 1))
+        ? at - 1
+        : at;
+    return { start, end: isHighSurrogate(display.charCodeAt(start)) ? start + 2 : start + 1 };
 }
-function isLowSurrogate(display, at) {
-    const code = display.charCodeAt(at);
-    return code >= 0xdc00 && code <= 0xdfff;
-}
-/**
- * The second reading of a press whose plain cut does not parse back: take the delimiter runs the
- * cut now sits between with it, the "these two constructs become one" a reader sees when the
- * character between them goes. Verified against the SCREEN, not the structure.
- */
+/** The second try when the plain cut does not parse back: also take the delimiter runs the cut sits
+ *  between, so the two constructs become one as the user sees it. */
 function widenThroughRuns(constructs, cut) {
     let { start, end } = cut;
     while (isDelimiterByte(constructs, start - 1))
@@ -96,14 +90,14 @@ function widenThroughRuns(constructs, cut) {
         end++;
     return { start, end };
 }
-/** A pair left around nothing is invisible residue, so a construct the cut empties goes with it —
- *  repeatedly, since dropping the inner pair can empty its parent. */
+/** A delimiter pair left around nothing is invisible leftovers, so a construct the cut empties
+ *  goes with it, repeatedly, since dropping the inner pair can empty its parent. */
 function expandThroughEmptied(constructs, target) {
-    const cut = { start: target.start, end: target.end };
+    const cut = { start: target.start, end: target.end, unwrappedMarks: [] };
     let grew = true;
     while (grew) {
         grew = false;
-        for (const { node, content, autoUnwrapOnEmpty } of constructs) {
+        for (const { node, content, autoUnwrapOnEmpty, markable } of constructs) {
             if (!autoUnwrapOnEmpty || !content)
                 continue;
             if (content.start < cut.start || content.end > cut.end)
@@ -112,13 +106,15 @@ function expandThroughEmptied(constructs, target) {
                 continue;
             cut.start = Math.min(cut.start, node.start);
             cut.end = Math.max(cut.end, node.end);
+            if (markable)
+                cut.unwrappedMarks.push(node.kind);
             grew = true;
         }
     }
     return cut;
 }
-/** Only kinds the policy table names take part: an unpolicied construct's bytes are read as
- *  ordinary content, which is what native already treats them as. */
+/** Only kinds the policy table names take part: a construct with no policy has its bytes read as
+ *  ordinary content, which is what the browser already treats them as. */
 function policyConstructs(inlines) {
     const found = [];
     for (const node of inlineDescendants(inlines)) {
@@ -128,7 +124,8 @@ function policyConstructs(inlines) {
         found.push({
             node,
             content: constructContentRange(node),
-            autoUnwrapOnEmpty: policy.autoUnwrapOnEmpty
+            autoUnwrapOnEmpty: policy.autoUnwrapOnEmpty,
+            markable: policy.mark !== undefined
         });
     }
     return found;
@@ -141,24 +138,12 @@ function isDelimiterByte(constructs, at) {
         ((at >= node.start && at < content.start) || (at >= content.end && at < node.end)));
 }
 // ── Verification ─────────────────────────────────────────────────────────────
-/**
- * What a reader sees, asked of the thing that paints it, over the bytes read back the way `surface`
- * installs them — null where they do not read back at all. The content reading, not the block's
- * own: a cut that empties a construct folds its chrome into view, and the diff would read that
- * arrival as bytes lost; sound because the painting-chrome case returned at the door.
- */
-function visibleText(raw, surface) {
-    // Cell text is never a block, so it reads as its inline content and nothing else can refuse it.
-    if (surface === 'cell')
-        return renderedText(parseInline(raw, 0, raw.length), raw, CONTENT_VISIBILITY);
-    // A cut that empties the block is the one candidate with no block to read: emptied is a shape
-    // the reload keeps, so it answers for itself rather than through the parser.
+/** What the user sees of the bytes read back where they are stored, or null where they do not
+ *  read back as one prose block: a cut can push two runs together into a fence opener. */
+function visibleText(raw, { store }) {
+    // A cut that empties the block leaves no block to read, and empty shows nothing wherever it is.
     if (raw === '')
         return '';
-    // A candidate that re-reads as another block is not what the caller is about to install: a cut
-    // can abut two literal runs into a fence opener, which on reload swallows every block below.
-    const sole = soleProseReparse(raw);
-    if (sole === null)
-        return null;
-    return renderedText(sole.nodes, sole.block.raw, CONTENT_VISIBILITY);
+    const read = readBack(raw, store);
+    return read && shownOf(read, store);
 }

package/dist/components/blocks/text/construct-reveal.d.ts

@@ -1,39 +1,34 @@
 /**
- * preview-inline's construct-reveal trigger: an inline construct's markers stay CSS-hidden until
- * the caret enters its INCLUSIVE `[start, end]`, revealing the whole enclosing chain. Reveal is a
- * class flip on `data-construct-*` spans, so the DOM text never changes and raw offsets survive it
- * (spec: the preview-inline-affinity e2e requirement).
+ * What shows an inline construct's markers in preview-inline mode: they stay hidden by CSS until
+ * the caret enters the construct's `[start, end]`, bounds included, and then the whole enclosing
+ * chain shows. Showing them only toggles a class on `data-construct-*` spans, so the DOM text
+ * never changes and raw offsets survive it (the preview-inline-affinity e2e requirement).
  */
 import type { InlineNode } from '../../../core/nodes';
 import type { NodeView } from '../../../core/node-views';
-import type { PresentationMode } from '../../../presentation-mode';
-import type { LinkReferenceResolverRef } from '../../../editor-keys';
+import type { Reading } from '../../../schema/reading';
 /**
- * Every revealable construct whose inclusive `[start, end]` contains `offset`, outermost
- * first; at a boundary shared by adjacent siblings both are collected.
+ * Every construct that can show its markers whose `[start, end]` contains `offset`, bounds
+ * included, outermost first; at a boundary two siblings share, both are collected.
  */
 export declare function constructChainAtOffset(nodes: InlineNode[], offset: number): InlineNode[];
 export interface ConstructRevealDeps {
     get node(): NodeView;
-    get linkRef(): LinkReferenceResolverRef | undefined;
+    get reading(): Reading;
     getEl: () => HTMLElement | null;
-    getAmbientLength: () => number;
-    getPresentationMode: () => PresentationMode;
-    /** Cross-block selections freeze the reveal state, so a sweep anchored in revealed
-     *  marker text keeps its layout. */
+    /** A cross-block selection freezes what is shown, so a drag anchored in visible marker
+     *  text keeps its layout. */
     isCrossBlock: () => boolean;
 }
 export interface ConstructReveal {
-    /** Re-evaluate the caret chain and flip marker classes to match. `force` after a
-     *  rebuild: fresh spans carry no reveal class even on an unchanged chain key. */
+    /** Work out the caret's chain again and set the marker classes to match. Pass `force`
+     *  after a rebuild: new spans carry no class even when the chain is unchanged. */
     update(force?: boolean): void;
-    /** Synchronous keydown backstop, reveal-only: Chromium prioritizes input events over
-     *  normal tasks, so rapid arrows outrun the selectionchange reveal and would step
-     *  against still-folded markers. Reveals the caret's chain plus `delta`'s (0 = neither). */
+    /** Show (never hide) the caret's chain plus `delta`'s on keydown: fast arrow keys outrun the
+     *  `selectionchange` update and would step against markers still hidden. */
     prepareStep(delta: -1 | 0 | 1): void;
-    /** Keydown wiring for `prepareStep`. Owns the key vocabulary so the component stays
-     *  free of destructive-key literals, which G4.12 scans for as interceptor shape;
-     *  this module holds no preventDefault and consumes nothing. */
+    /** Keydown wiring for `prepareStep`, holding the key names so the component carries no
+     *  destructive-key literals for the interceptor scan to flag (G4.12). Consumes no event. */
     prepareForKeydown(e: KeyboardEvent): void;
 }
 export declare function createConstructReveal(deps: ConstructRevealDeps): ConstructReveal;