@voithos-labs/aragonite 0.10.3 → 0.10.4

package/dist/components/blocks/text/edge-policy-dispatch.js

@@ -18,7 +18,7 @@ import { createMarkerCompletion } from './marker-completion';
 import { resolveEdgeDeletion } from './construct-edge-delete';
 import { hidesStructuralSuffix } from './hidden-suffix';
 import { resolveEdgeSeat } from './edge-seat';
-import { deleteRangeRaw } from './live-selection-edit';
+import { replaceRangeRaw } from './live-selection-edit';
 import { resolveMarkedInsertion } from './pending-mark-insert';
 import { widgetAtCursor } from './widget-adjacency';
 import { resolveDelimiterAutoPair } from './delimiter-autopair';
@@ -112,6 +112,12 @@ export function createEdgePolicyDispatch(deps) {
         const d = display();
         writeDisplay(d.slice(0, start) + insert + d.slice(end), start + insert.length, source, caretBefore);
     }
+    /** The range this surface holds, or null at a caret. A key aimed at one edits the RANGE: the
+     *  caret the arms read is only its start. */
+    function heldRange() {
+        const selection = deps.getRawSelection();
+        return selection && selection.start < selection.end ? selection : null;
+    }
     // ── The seams the arms below defer to ────────────────────────────────────
     /**
      * The rung a range rewrite can be asked about. Past the reading cut a surface revealing no
@@ -150,6 +156,20 @@ export function createEdgePolicyDispatch(deps) {
             return null;
         return resolveEdgeSeat(caret, inlinesOf(deps.node), deps.getEdgeAffinity(), deps.node.raw, screenVisibilityOf(el), typed);
     }
+    /** A printable byte an arm claimed because the engine drops it at an element-level caret. Over
+     *  a held range it REPLACES through the join seam, the road a mid-block range takes; at a caret
+     *  the seat answers which side of an unpainted run it lands on. */
+    function writeTypedByte(el, caretOffset, typed, source) {
+        const range = heldRange();
+        if (range) {
+            const edit = replaceRangeRaw(deps.node, range, typed, joinSeamMode(el), deps.linkRef, deps.getAmbientPrefix?.() ?? '');
+            void deps.blockEdit.updateBlockContent(deps.index, edit.raw, range.start, edit.caret);
+            deps.setPendingCursor(edit.caret, source, edit.raw);
+            return;
+        }
+        const seatedAt = typingSeatAt(el, caretOffset, typed)?.offset ?? caretOffset;
+        editDisplay(seatedAt, seatedAt, typed, source, caretOffset);
+    }
     // ── CST inline widget ────────────────────────────────────────────────────
     function handleCstWidget(e, caretOffset) {
         if (deps.isRevealing())
@@ -163,9 +183,11 @@ export function createEdgePolicyDispatch(deps) {
         const widgetAt = widgetAtCursor(caretOffset, inlinesOf(node), node.raw, direction);
         if (!widgetAt)
             return false;
-        // Unchorded only: a modifier makes the key a word-scoped platform command, and
-        // entering here would swap that word-step for the modal widget-selected state.
-        const plainEdgeKey = !e.shiftKey && !hasModifier(e);
+        // Below the bail: every keystroke in every prose block reaches the line above.
+        const range = heldRange();
+        // Unchorded, and at a CARET: a modifier makes the key a word-scoped platform command, and
+        // a held range is an edit of the range, not an entry into the construct beside its start.
+        const plainEdgeKey = !e.shiftKey && !hasModifier(e) && !range;
         const enterFromRight = plainEdgeKey && widgetAt.atRight && (e.key === 'ArrowLeft' || e.key === 'Backspace');
         const enterFromLeft = plainEdgeKey && !widgetAt.atRight && (e.key === 'ArrowRight' || e.key === 'Delete');
         if (enterFromRight || enterFromLeft) {
@@ -200,14 +222,7 @@ export function createEdgePolicyDispatch(deps) {
             !deps.isReading()) {
             e.preventDefault();
             deps.setSnapTarget(null);
-            const typed = e.key;
-            // This branch owns only the fact that the engine drops the key beside a widget; which
-            // side of an unpainted run the byte belongs on is still the seat's answer.
-            const seatedAt = typingSeatAt(el, caretOffset, typed)?.offset ?? caretOffset;
-            const newRaw = node.raw.slice(0, seatedAt) + typed + node.raw.slice(seatedAt);
-            const postEdit = seatedAt + typed.length;
-            void deps.blockEdit.updateBlockContent(deps.index, newRaw, caretOffset, postEdit);
-            deps.setPendingCursor(postEdit, 'widget', newRaw);
+            writeTypedByte(el, caretOffset, e.key, 'widget');
             return true;
         }
         return false;
@@ -254,8 +269,8 @@ export function createEdgePolicyDispatch(deps) {
         // Second press: the native selection already wraps a replace island, so delete its
         // whole hidden range through the CST as one undo entry.
         if (isDestructive) {
-            const selection = deps.getRawSelection();
-            if (selection && selection.start < selection.end) {
+            const selection = heldRange();
+            if (selection) {
                 const selected = islands.find((i) => islandPolicy(i).onEdge === 'select' &&
                     i.start === selection.start &&
                     i.end === selection.end);
@@ -312,7 +327,7 @@ export function createEdgePolicyDispatch(deps) {
         // branch in e2e, so it is unit-pinned instead.
         if (isTyping && !caretIsInTextContent(el, window.getSelection())) {
             e.preventDefault();
-            editDisplay(caretOffset, caretOffset, e.key);
+            writeTypedByte(el, caretOffset, e.key, 'island');
             return true;
         }
         return false;
@@ -337,11 +352,11 @@ export function createEdgePolicyDispatch(deps) {
         if (!touchesAmbient)
             return false;
         e.preventDefault();
-        const range = deps.getRawSelection();
-        if (range && range.start < range.end) {
+        const range = heldRange();
+        if (range) {
             // Consumed at KEYDOWN, so no `beforeinput` carries this range to the shared seam: the arm
             // asks it here, or a literal splice prints the runs the cut stranded (live-mode.md § 4.5).
-            const edit = deleteRangeRaw(deps.node, range, joinSeamMode(el), deps.linkRef, deps.getAmbientPrefix?.() ?? '');
+            const edit = replaceRangeRaw(deps.node, range, '', joinSeamMode(el), deps.linkRef, deps.getAmbientPrefix?.() ?? '');
             void deps.blockEdit.updateBlockContent(deps.index, edit.raw, range.start, edit.caret);
             deps.setPendingCursor(edit.caret, 'ambient-delete');
         }

package/dist/components/blocks/text/live-selection-edit.d.ts

@@ -59,10 +59,10 @@ export declare function resolveSelectionEdit(node: NodeView, selection: {
     start: number;
     end: number;
 }, typed: string, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix?: string): SelectionEdit | null;
-/** The delete of `[start, end)` a destructive gesture installs: the seam's cleaned rewrite where
- *  it has one, else the literal display splice with the caret at the cut — the fallback's one
- *  home, so no arm carrying it can drift. */
-export declare function deleteRangeRaw(node: NodeView, range: {
+/** The rewrite of `[start, end)` to `typed` a gesture the surface consumed installs, where a
+ *  delete is the empty one. The seam's cleaned bytes where it has them, else the literal display
+ *  splice with the caret past the insert: the fallback's one home, so no arm can drift. */
+export declare function replaceRangeRaw(node: NodeView, range: {
     start: number;
     end: number;
-}, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix: string): SelectionEdit;
+}, typed: string, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix: string): SelectionEdit;

package/dist/components/blocks/text/live-selection-edit.js

@@ -102,17 +102,20 @@ export function resolveSelectionEdit(node, selection, typed, presentationMode, l
         caret: joined.seam + typed.length
     };
 }
-/** The delete of `[start, end)` a destructive gesture installs: the seam's cleaned rewrite where
- *  it has one, else the literal display splice with the caret at the cut — the fallback's one
- *  home, so no arm carrying it can drift. */
-export function deleteRangeRaw(node, range, presentationMode, linkRef, ambientPrefix) {
-    const cleaned = resolveSelectionEdit(node, range, '', presentationMode, linkRef, ambientPrefix);
+/** The rewrite of `[start, end)` to `typed` a gesture the surface consumed installs, where a
+ *  delete is the empty one. The seam's cleaned bytes where it has them, else the literal display
+ *  splice with the caret past the insert: the fallback's one home, so no arm can drift. */
+export function replaceRangeRaw(node, range, typed, presentationMode, linkRef, ambientPrefix) {
+    const cleaned = resolveSelectionEdit(node, range, typed, presentationMode, linkRef, ambientPrefix);
     if (cleaned)
         return cleaned;
     const display = trimTrailingLineEnding(node.raw);
     return {
-        raw: display.slice(0, range.start) + display.slice(range.end) + trailingLineEnding(node.raw),
-        caret: range.start
+        raw: display.slice(0, range.start) +
+            typed +
+            display.slice(range.end) +
+            trailingLineEnding(node.raw),
+        caret: range.start + typed.length
     };
 }
 // ── Reading the event ────────────────────────────────────────────────────────

package/dist/components/blocks/text/text-clipboard.js

@@ -6,7 +6,7 @@ import { resolvedInlineContent } from '../../../core/inline/inline-cache';
 import { isInlineWidget } from '../../../core/inline/inline-widgets';
 import { createClipboardHandlers } from '../editable-surface';
 import { pasteDispatch } from '../../../tree-operations/paste/dispatch';
-import { deleteRangeRaw } from './live-selection-edit';
+import { replaceRangeRaw } from './live-selection-edit';
 export function createTextClipboard(deps) {
     function getSelectedTextFromRaw() {
         const offsets = deps.cursor.getRawSelection();
@@ -77,7 +77,7 @@ export function createTextClipboard(deps) {
                 return;
             // A cut is a delete, so it crosses the same join seam: in live the range can span
             // delimiter runs the reader never saw, and a raw splice would print them.
-            const edit = deleteRangeRaw(deps.node, selOffsets, deps.getPresentationMode(), deps.linkRef, deps.getAmbientPrefix());
+            const edit = replaceRangeRaw(deps.node, selOffsets, '', deps.getPresentationMode(), deps.linkRef, deps.getAmbientPrefix());
             void deps.blockEdit.updateBlockContent(deps.index, edit.raw, selOffsets.start);
             deps.setPendingCursor(edit.caret);
         },

package/dist/components/blocks/text/widget-interaction.js

@@ -5,15 +5,16 @@
  */
 import { tick } from 'svelte';
 import { resolvedInlineContent } from '../../../core/inline/inline-cache';
-import { flattenInlineWidgets, getInlineWidgetEditing, isWidgetActivationClick } from '../../../core/inline/inline-widgets';
+import { flattenInlineWidgets, getInlineWidgetEditing, isCharacterLikeWidget, isWidgetActivationClick } from '../../../core/inline/inline-widgets';
 import { isVerticallyTransparentNode } from '../../../core/inline/transparency';
 import { trimTrailingLineEnding, trailingLineEnding } from '../../../core/lines';
 import { asRawOffset, toClampedRawOffset, toDomTextOffset } from '../../../cursor/coordinate-spaces';
 import { domTextOffsetAtNode, createRangeAtDomTextOffsets, selectionFocusWalkOffset } from '../../../cursor/widget-offset';
 import { createSourceReveal } from '../../../cursor/reveal-source';
+import { nearestWidgetEdgeSeat } from '../../../cursor/widget-edge-snap';
 import { traceRevealOpen, traceRevealFold } from '../../../debug/interaction-trace';
 import { assertInvariant } from '../../../assert';
-import { caretIsInTextContent, hasModifier, isPlainTypingKey } from './click-snap-guard';
+import { caretIsInTextContent, hasModifier, isPlainTypingKey, surfaceHoldsRange } from './click-snap-guard';
 import { findWidgetNodeByStart, findFirstEdgeWidget, findLastEdgeWidget, rawHasNoTextBefore, rawHasNoTextAfter, widgetElByStart } from './widget-adjacency';
 /**
  * The inline-code wash over a revealed source, painted through the CSS Custom Highlight API
@@ -323,16 +324,27 @@ export function createWidgetInteraction(deps) {
         return inline ? { inline } : null;
     }
     /**
-     * The caret a click on a rendered widget wants: the END of the content a kind names, INSIDE
-     * its delimiters, so typing continues the construct rather than escaping it. A kind naming no
-     * span keeps the leading edge: guessing an end from its parsed text put a footnote's caret
-     * past its bracket.
+     * Where a click on a rendered widget seats the caret when its kind maps no point: the END of
+     * the content a kind names, INSIDE its delimiters, so typing continues the construct rather
+     * than escaping it. A kind naming no span keeps the leading edge — guessing an end from its
+     * parsed text put a footnote's caret past its bracket.
      */
     function insideEndOffset(inline) {
         const source = deps.node.raw.slice(inline.start, inline.end);
         const span = getInlineWidgetEditing(inline.kind)?.revealContentSpan?.(source);
         return span && span.end >= 0 && span.end <= source.length ? span.end : 0;
     }
+    /** The offset a press names inside a widget's source. Read against the PRE-fold geometry:
+     *  a fold reflows the line and the point stops meaning anything the moment it runs. */
+    function seatFromPoint(el, inline, x, y) {
+        const widget = widgetElByStart(el, inline.start);
+        const atPoint = getInlineWidgetEditing(inline.kind)?.revealOffsetAtPoint;
+        if (!widget || !atPoint)
+            return null;
+        const source = deps.node.raw.slice(inline.start, inline.end);
+        const seat = atPoint(widget, source, x, y);
+        return seat === null ? null : Math.max(0, Math.min(seat, source.length));
+    }
     function hitTestRevealWidget(el, x, y) {
         const painted = revealWidgetFromDom(el, x, y);
         if (painted)
@@ -370,6 +382,7 @@ export function createWidgetInteraction(deps) {
         const hit = hitTestRevealWidget(el, clickX, clickY);
         if (!hit)
             return;
+        const seat = seatFromPoint(el, hit.inline, clickX, clickY);
         let targetStart = hit.inline.start;
         if (revealState) {
             const active = revealState;
@@ -391,9 +404,7 @@ export function createWidgetInteraction(deps) {
             return;
         el.focus();
         revealOpenedByLastClick = true;
-        // A click can't map to a source glyph, so it lands at the end of the content rather
-        // than guessing: the caret sits inside the delimiters, ready to type.
-        void startReveal(target, target.start, insideEndOffset(target));
+        void startReveal(target, target.start, seat ?? insideEndOffset(target));
     }
     /**
      * Take the whole revealed token; declines unless the double-click landed on it. Keyed off the
@@ -645,24 +656,35 @@ export function createWidgetInteraction(deps) {
         // text and the browser's word rule takes `[` or `$` as a word of its own.
         if (doubleClick && revealOpenedByLastClick && selectRevealedSource(clickX, clickY))
             return;
-        // A click in a real text node keeps the native caret; a synthetic overlay would compete.
-        if (caretIsInTextContent(el, window.getSelection()))
+        // The snap below seats a CARET, so it stands down for a range this surface paints, which it
+        // would collapse; the rule `clampOutOfAmbient` already carries.
+        const live = window.getSelection();
+        if (surfaceHoldsRange(el, live))
             return;
+        const seat = nearestWidgetEdgeSeat(measuredWidgets(el), clickX, clickY);
+        if (seat === null)
+            return;
+        // A press BESIDE an island stands down for a visible caret; a press ON one cannot, since the
+        // engine answers that hit test with a position in the neighbouring text.
+        if (!seat.inside && caretIsInTextContent(el, live))
+            return;
+        el.focus();
+        deps.cursor.setRaw(asRawOffset(seat.offset));
+        // `setRaw`'s walker may have landed in a trailing text node, where native renders.
+        if (!caretIsInTextContent(el, window.getSelection()))
+            deps.setSnapTarget(seat.offset);
+    }
+    function* measuredWidgets(el) {
         for (const inline of widgetsOf()) {
             const widget = widgetElByStart(el, inline.start);
-            if (!widget)
-                continue;
-            const rect = widget.getBoundingClientRect();
-            const snapTo = clickX > rect.right ? inline.end : clickX < rect.left ? inline.start : null;
-            if (snapTo === null)
-                continue;
-            el.focus();
-            deps.cursor.setRaw(asRawOffset(snapTo));
-            // `setRaw`'s walker may have landed in a trailing text node, where native renders.
-            if (!caretIsInTextContent(el, window.getSelection())) {
-                deps.setSnapTarget(snapTo);
+            if (widget) {
+                yield {
+                    start: inline.start,
+                    end: inline.end,
+                    rect: widget.getBoundingClientRect(),
+                    seatsInside: isCharacterLikeWidget(inline.kind)
+                };
             }
-            return;
         }
     }
     function widgetExtensionTarget(key) {

package/dist/components/drag-handle.d.ts

@@ -16,6 +16,12 @@ export declare function isImageOnlyParagraph(node: NodeView): boolean;
  * caller still gates reading mode, which shows no affordances at all.
  */
 export declare function showsDragHandle(node: NodeView, handlesEnabled: boolean): boolean;
+/**
+ * A list item's grip reorders it among its SIBLINGS and nowhere else: the drag is scoped to
+ * the enclosing list, so a lone item has nothing to trade places with and its grip is a
+ * promise the drop can't keep. It reappears the moment a second item joins the list.
+ */
+export declare function showsListItemDragHandle(itemCount: number, handlesEnabled: boolean): boolean;
 /**
  * Vertical centre of the grip. A one-line block centres on its row. A taller one takes the
  * first line-height of its OWN box — not its first line of text, since a card pads above that

package/dist/components/drag-handle.js

@@ -41,6 +41,14 @@ export function showsDragHandle(node, handlesEnabled) {
         return true;
     return handlesEnabled && !GRIPLESS_KINDS.has(node.kind);
 }
+/**
+ * A list item's grip reorders it among its SIBLINGS and nowhere else: the drag is scoped to
+ * the enclosing list, so a lone item has nothing to trade places with and its grip is a
+ * promise the drop can't keep. It reappears the moment a second item joins the list.
+ */
+export function showsListItemDragHandle(itemCount, handlesEnabled) {
+    return handlesEnabled && itemCount > 1;
+}
 /** A box within this many line-heights holds one row of content, margins included. */
 const SINGLE_LINE = 1.5;
 /**

package/dist/components/editor-root-geometry.d.ts

@@ -26,7 +26,7 @@ export interface TypeScaleProbeDeps {
 export declare function installTypeScaleProbe(el: HTMLElement, deps: TypeScaleProbeDeps): () => void;
 export interface HeaderSlotCompensationDeps {
     el: HTMLElement;
-    port: Pick<Scrollport, 'scrollTop' | 'setScrollTop'>;
+    port: Pick<Scrollport, 'scrollTop' | 'scrollBy'>;
     ownsScrollCorrection(): boolean;
     revealHoldsScroll(): boolean;
 }

package/dist/components/editor-root-geometry.js

@@ -84,7 +84,7 @@ export function installHeaderSlotCompensation(deps) {
         if (delta === 0 || !deps.ownsScrollCorrection() || port.scrollTop() === 0)
             return;
         if (!deps.revealHoldsScroll())
-            port.setScrollTop(port.scrollTop() + delta);
+            port.scrollBy(delta);
     });
     observer.observe(el);
     return () => observer.disconnect();

package/dist/components/editor-root-listeners.d.ts

@@ -39,10 +39,3 @@ export declare function installEditorBlurAnnouncer(deps: {
     root: HTMLElement;
     emit: () => void;
 }): () => void;
-/**
- * Windows Chromium's double-click takes the space after the word, so the word is selected on
- * the SECOND press, trimmed, with the native selection suppressed; the dblclick trim is the
- * fallback. A press on an inline widget is that widget's own gesture (a footnote's double-click
- * takes its whole token), so the root leaves it to the widget.
- */
-export declare function installDoubleClickWordSelect(root: HTMLElement): () => void;

package/dist/components/editor-root-listeners.js

@@ -5,8 +5,6 @@
  * call, returning the teardown. `onRoot`/`removeAll` capture that add/remove pair once.
  */
 import { tick } from 'svelte';
-import { isEditableEventTarget } from '../editor-actions/whole-block-focus-surface';
-import { selectWordAtPoint, trimDoubleClickSelection } from '../selection/double-click-trim';
 // ── Listener plumbing ───────────────────────────────────────────────
 // Typed off `Event`, not the per-target event maps: those names are type-only,
 // and `target` ranges over every EventTarget the root effects listen on.
@@ -91,23 +89,3 @@ export function installEditorBlurAnnouncer(deps) {
     };
     return onRoot(deps.root, 'focusout', handler);
 }
-/**
- * Windows Chromium's double-click takes the space after the word, so the word is selected on
- * the SECOND press, trimmed, with the native selection suppressed; the dblclick trim is the
- * fallback. A press on an inline widget is that widget's own gesture (a footnote's double-click
- * takes its whole token), so the root leaves it to the widget.
- */
-export function installDoubleClickWordSelect(root) {
-    const onSecondPress = (e) => {
-        if (e.detail !== 2 || e.button !== 0 || e.shiftKey || e.ctrlKey || e.metaKey)
-            return;
-        if (!isEditableEventTarget(e.target) || pressesInlineWidget(e.target))
-            return;
-        if (selectWordAtPoint(root.ownerDocument, e.clientX, e.clientY))
-            e.preventDefault();
-    };
-    return removeAll(onRoot(root, 'mousedown', onSecondPress), onRoot(root, 'dblclick', () => trimDoubleClickSelection(root.ownerDocument)));
-}
-function pressesInlineWidget(target) {
-    return target instanceof Element && target.closest('[data-inline-widget]') !== null;
-}

package/dist/components/image/ImageResizeHandles.svelte

@@ -187,24 +187,32 @@
 {/if}
 
 <style>
-	/* An accent pill straddling the edge with a white rim, so it reads on any picture. The hit
-	   strip is wider than the paint. */
+	/* A neutral grip sitting inside the picture's right edge: the selection ring owns the edge
+	   itself, and the accent is the ring's, so a second accent shape beside it reads as decoration
+	   rather than as a control. White over a hairline rim so it carries on a dark picture and a
+	   pale one alike. The hit strip is wider than the paint, so on a picture too narrow to hold
+	   both the strip and a clickable middle (an icon-sized image) the grip steps back outside
+	   the edge, where it stood before. */
 	.md-resize-handle {
 		position: absolute;
-		right: -3px;
+		right: clamp(-3px, calc(50% - 20px), 7px);
 		top: 50%;
-		width: 6px;
-		height: 44px;
-		max-height: 60%;
+		width: 4px;
+		height: 36px;
+		max-height: 40%;
 		transform: translateY(-50%);
-		border-radius: 3px;
-		background: var(--color-accent, #567b67);
+		border-radius: 999px;
+		background: rgba(255, 255, 255, 0.92);
 		box-shadow:
-			0 0 0 1.5px rgba(255, 255, 255, 0.9),
-			0 1px 3px rgba(0, 0, 0, 0.3);
+			0 0 0 0.5px rgba(0, 0, 0, 0.35),
+			0 1px 3px rgba(0, 0, 0, 0.35);
+		opacity: 0.85;
 		z-index: 10;
 		cursor: ew-resize;
 	}
+	.md-resize-handle:hover {
+		opacity: 1;
+	}
 	.md-resize-handle::before {
 		content: '';
 		position: absolute;