@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/selection/table-endpoint-snap.d.ts

@@ -1,53 +1,29 @@
 /**
- * The cell-index space a selection endpoint inside a grid lives in. Offsets are INCLUSIVE cell
- * indices, the space SelectionPoint already uses. The whole-row snap and the two metadata reads
- * answer for a table alone; the coverage tenants answer for any `containerContract: 'grid'` kind.
- * An intra-table pair is deliberately left unsnapped, so rectangular sub-cell selection survives.
+ * The cell-index space a selection endpoint inside a grid lives in. Offsets are inclusive cell
+ * indices, and every endpoint on a table path carries `cellCoordinate`. The whole-row snap and
+ * the metadata reads are for tables only; the cell lists serve any `containerContract: 'grid'`
+ * kind. A pair inside one table is left unsnapped, so a rectangle of cells can be selected.
  */
 import type { DocumentView, NodeView } from '../core/node-views';
-import type { SelectionPoint } from './primitives';
-/**
- * The char→cell conversion funnel: a cross-block endpoint inside a table must address the table
- * block by row-major cell index, or a deep `[tableIdx, row, col]` path with a char offset routes
- * the delete down the generic branch and corrupts the grid. SelectionState applies this to every
- * incoming point, so entry paths never call it themselves. Non-table paths pass through.
- */
+import type { CellSelectionPoint, SelectionPoint } from './primitives';
+import { type CellRect } from '../cursor/coordinate-spaces';
+/** The one conversion into cell space, which `SelectionState` applies to every incoming point: an
+ *  endpoint on or inside a table becomes the table path plus a flagged row-major cell index. */
 export declare function normalizeTableEndpoint(doc: DocumentView, path: number[], offset: number): SelectionPoint;
-/**
- * How many cells a table's index space holds, the exclusive upper bound on any row-major cell
- * index. `node` must be a table block; the metadata read is unchecked, so other kinds give NaN.
- * Lives beside the bounds check below so a caller's clamp and the check cannot drift apart.
- */
-export declare function tableCellCount(node: NodeView): number;
+/** A table taken whole, as the cell on one side of it; null when `path` names no table. */
+export declare function wholeTableEndpoint(doc: DocumentView, path: number[], side: 'start' | 'end'): CellSelectionPoint | null;
 /** One cell of a grid, with the doc-absolute path that addresses it. */
 export interface GridCell {
     node: NodeView;
     path: number[];
 }
-/**
- * `point`'s index in `grid`'s cell space, null where it addresses no cell of it — the side the
- * range runs past, which reads as the grid's own edge. A table's endpoint arrives on the grid path
- * already carrying the index; a plugin grid's keeps the deep `[grid, row, col]` path G1.29 permits,
- * and resolves through the same width {@link coveredGridCells} decodes with.
- */
-export declare function gridEndpointCellIndex(grid: NodeView, gridPath: number[], point: SelectionPoint): number | null;
-/**
- * The cells a range covers inside one grid, in document order. `from`/`to` are the range's own cell
- * indices IN DOCUMENT ORDER (`from <= to`; unordered inputs answer with fewer cells or none), null
- * on a side the range runs past. Both inside is the RECTANGLE they span — what the overlay paints
- * and `range-delete-table` clears; one inside is a run to that cell inclusive. Rows of cells is the
- * whole shape asked: children that are not rows of cells answer with no cells, rows of unequal
- * width with the wrong cells or none, every index being row 0's width.
- */
-export declare function coveredGridCells(grid: NodeView, gridPath: number[], from: number | null, to: number | null): GridCell[];
-/**
- * Inverse of {@link normalizeTableEndpoint}: expand an endpoint addressing a table block to its
- * deep `[tableIdx, row, col]` leaf path so reveal/caret placement reaches an off-window cell.
- * Null when the path is already a leaf or the index lands outside the grid. Resolution is on the
- * NODE KIND, not the `cellCoordinate` flag: an intra-table focus is unflagged (see
- * {@link SelectionPoint}) yet still a cell index. Callers reach it through
- * `SelectionState.cellLandingFor`, which is where the landing rule lives.
- */
+/** The cells of `rect` inside one grid, row by row. */
+export declare function gridCellsInRect(grid: NodeView, gridPath: number[], rect: CellRect): GridCell[];
+/** The cells a run covers inside one grid, in row-major order, a null side running to the grid's
+ *  edge. Rows must share row 0's width. */
+export declare function gridCellsInRun(grid: NodeView, gridPath: number[], from: number | null, to: number | null): GridCell[];
+/** The inverse of {@link normalizeTableEndpoint}: a cell endpoint's `[tableIdx, row, col]` leaf
+ *  path, or null. Reach it through `SelectionState.cellLandingFor`. */
 export declare function cellEndpointDeepPath(doc: DocumentView, point: SelectionPoint): number[] | null;
 export declare function snapCrossBlockTableEndpoints(doc: DocumentView, start: SelectionPoint, end: SelectionPoint): {
     start: SelectionPoint;

package/dist/selection/table-endpoint-snap.js

@@ -1,77 +1,60 @@
 /**
- * The cell-index space a selection endpoint inside a grid lives in. Offsets are INCLUSIVE cell
- * indices, the space SelectionPoint already uses. The whole-row snap and the two metadata reads
- * answer for a table alone; the coverage tenants answer for any `containerContract: 'grid'` kind.
- * An intra-table pair is deliberately left unsnapped, so rectangular sub-cell selection survives.
+ * The cell-index space a selection endpoint inside a grid lives in. Offsets are inclusive cell
+ * indices, and every endpoint on a table path carries `cellCoordinate`. The whole-row snap and
+ * the metadata reads are for tables only; the cell lists serve any `containerContract: 'grid'`
+ * kind. A pair inside one table is left unsnapped, so a rectangle of cells can be selected.
  */
 import { metadataOf } from '../core/nodes';
-import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
-import { cellIndexOf } from './primitives';
-import { asCellIndex, cellRowCol } from '../cursor/coordinate-spaces';
-import { comparePaths, pathHasPrefix } from './path-math';
+import { nodeAt } from '../tree-operations/node-primitives';
+import { clampCellIndex, countsCells, tableCellCount } from '../schema/block-kind-descriptor';
+import { cellIndexOf, cellPoint } from './primitives';
+import { asCellIndex, rowMajorCellIndex, cellRowCol } from '../cursor/coordinate-spaces';
+import { comparePaths } from './path-math';
 import { devWarn } from '../dev-warn';
-/**
- * The char→cell conversion funnel: a cross-block endpoint inside a table must address the table
- * block by row-major cell index, or a deep `[tableIdx, row, col]` path with a char offset routes
- * the delete down the generic branch and corrupts the grid. SelectionState applies this to every
- * incoming point, so entry paths never call it themselves. Non-table paths pass through.
- */
+/** The one conversion into cell space, which `SelectionState` applies to every incoming point: an
+ *  endpoint on or inside a table becomes the table path plus a flagged row-major cell index. */
 export function normalizeTableEndpoint(doc, path, offset) {
-    for (let d = 0; d < path.length - 1; d++) {
-        const node = nodeAt(doc, path.slice(0, d + 1));
-        if (node && isBlockNode(node) && node.kind === 'table') {
-            const colCount = metadataOf(node, 'table').columnCount;
-            const rowIdx = path[d + 1];
-            const colIdx = path[d + 2] ?? 0;
-            return {
-                path: path.slice(0, d + 1),
-                offset: asCellIndex(rowIdx * colCount + colIdx),
-                cellCoordinate: true
-            };
-        }
+    for (let d = 0; d < path.length; d++) {
+        const tablePath = path.slice(0, d + 1);
+        const node = nodeAt(doc, tablePath);
+        if (!node || !countsCells(node))
+            continue;
+        // On the table's own path the offset is already the cell index.
+        if (d === path.length - 1)
+            return cellPoint(tablePath, clampCellIndex(node, offset));
+        const colCount = metadataOf(node, 'table').columnCount;
+        return cellPoint(tablePath, rowMajorCellIndex(path[d + 1], path[d + 2] ?? 0, colCount));
     }
     return { path: path.slice(), offset };
 }
-/**
- * How many cells a table's index space holds, the exclusive upper bound on any row-major cell
- * index. `node` must be a table block; the metadata read is unchecked, so other kinds give NaN.
- * Lives beside the bounds check below so a caller's clamp and the check cannot drift apart.
- */
-export function tableCellCount(node) {
-    return (node.children?.length ?? 0) * metadataOf(node, 'table').columnCount;
+/** A table taken whole, as the cell on one side of it; null when `path` names no table. */
+export function wholeTableEndpoint(doc, path, side) {
+    const node = nodeAt(doc, path);
+    if (!node || !countsCells(node))
+        return null;
+    const offset = side === 'end' ? clampCellIndex(node, Infinity) : 0;
+    return cellPoint(path, offset);
 }
-/** A grid's own width, row 0's cell count — not `metadata.columnCount`: `containerContract: 'grid'`
- *  is a plugin contract, and a kind with no table metadata reaches here. A column mutation splices
- *  each row and the count together, so the two agree on a table. */
+/** A grid's width as row 0's cell count, not `metadata.columnCount`: a plugin grid kind has no
+ *  table metadata. On a table the two agree, since a column edit changes both together. */
 function gridColumnCount(grid) {
     return grid.children?.[0]?.children?.length ?? 0;
 }
-/**
- * `point`'s index in `grid`'s cell space, null where it addresses no cell of it — the side the
- * range runs past, which reads as the grid's own edge. A table's endpoint arrives on the grid path
- * already carrying the index; a plugin grid's keeps the deep `[grid, row, col]` path G1.29 permits,
- * and resolves through the same width {@link coveredGridCells} decodes with.
- */
-export function gridEndpointCellIndex(grid, gridPath, point) {
-    if (!pathHasPrefix(point.path, gridPath))
-        return null;
-    // On the grid's own path, resolution is the NODE KIND's, not the flag's ({@link
-    // cellEndpointDeepPath}): a table path IS cell space, so an intra-table rectangle's unflagged
-    // corner counts cells, while any other grid holds a char offset addressing no cell.
-    if (point.path.length === gridPath.length)
-        return point.cellCoordinate || grid.kind === 'table' ? point.offset : null;
-    const [row, col = 0] = point.path.slice(gridPath.length);
-    return row * gridColumnCount(grid) + col;
+/** The cells of `rect` inside one grid, row by row. */
+export function gridCellsInRect(grid, gridPath, rect) {
+    const cells = [];
+    for (let row = rect.top; row < rect.top + rect.rows; row++) {
+        for (let col = rect.left; col < rect.left + rect.cols; col++) {
+            const node = grid.children?.[row]?.children?.[col];
+            if (node)
+                cells.push({ node, path: [...gridPath, row, col] });
+        }
+    }
+    return cells;
 }
-/**
- * The cells a range covers inside one grid, in document order. `from`/`to` are the range's own cell
- * indices IN DOCUMENT ORDER (`from <= to`; unordered inputs answer with fewer cells or none), null
- * on a side the range runs past. Both inside is the RECTANGLE they span — what the overlay paints
- * and `range-delete-table` clears; one inside is a run to that cell inclusive. Rows of cells is the
- * whole shape asked: children that are not rows of cells answer with no cells, rows of unequal
- * width with the wrong cells or none, every index being row 0's width.
- */
-export function coveredGridCells(grid, gridPath, from, to) {
+/** The cells a run covers inside one grid, in row-major order, a null side running to the grid's
+ *  edge. Rows must share row 0's width. */
+export function gridCellsInRun(grid, gridPath, from, to) {
     const rows = grid.children ?? [];
     const colCount = gridColumnCount(grid);
     if (rows.length === 0 || colCount < 1)
@@ -80,15 +63,10 @@ export function coveredGridCells(grid, gridPath, from, to) {
     const clamp = (index) => Math.min(Math.max(index, 0), lastIndex);
     const first = cellRowCol(asCellIndex(clamp(from ?? 0)), colCount);
     const last = cellRowCol(asCellIndex(clamp(to ?? lastIndex)), colCount);
-    const rectangle = from !== null && to !== null;
     const cells = [];
     for (let row = first.row; row <= last.row; row++) {
-        const startCol = rectangle ? Math.min(first.col, last.col) : row === first.row ? first.col : 0;
-        const endCol = rectangle
-            ? Math.max(first.col, last.col)
-            : row === last.row
-                ? last.col
-                : colCount - 1;
+        const startCol = row === first.row ? first.col : 0;
+        const endCol = row === last.row ? last.col : colCount - 1;
         for (let col = startCol; col <= endCol; col++) {
             const node = rows[row]?.children?.[col];
             if (node)
@@ -97,17 +75,13 @@ export function coveredGridCells(grid, gridPath, from, to) {
     }
     return cells;
 }
-/**
- * Inverse of {@link normalizeTableEndpoint}: expand an endpoint addressing a table block to its
- * deep `[tableIdx, row, col]` leaf path so reveal/caret placement reaches an off-window cell.
- * Null when the path is already a leaf or the index lands outside the grid. Resolution is on the
- * NODE KIND, not the `cellCoordinate` flag: an intra-table focus is unflagged (see
- * {@link SelectionPoint}) yet still a cell index. Callers reach it through
- * `SelectionState.cellLandingFor`, which is where the landing rule lives.
- */
+/** The inverse of {@link normalizeTableEndpoint}: a cell endpoint's `[tableIdx, row, col]` leaf
+ *  path, or null. Reach it through `SelectionState.cellLandingFor`. */
 export function cellEndpointDeepPath(doc, point) {
+    if (!point.cellCoordinate)
+        return null;
     const node = nodeAt(doc, point.path);
-    if (!node || !isBlockNode(node) || node.kind !== 'table')
+    if (!node || !countsCells(node))
         return null;
     const colCount = metadataOf(node, 'table').columnCount;
     const cellIdx = asCellIndex(point.offset);
@@ -131,13 +105,13 @@ function snapEndpoint(doc, point, side) {
     if (!point.cellCoordinate)
         return point;
     const node = nodeAt(doc, point.path);
-    if (!node || !isBlockNode(node) || node.kind !== 'table')
+    if (!node || !countsCells(node))
         return point;
     const colCount = metadataOf(node, 'table').columnCount;
     const cellIdx = cellIndexOf(point, 'snapCrossBlockTableEndpoints');
     const { row } = cellRowCol(cellIdx, colCount);
-    const snappedOffset = side === 'start' ? row * colCount : row * colCount + colCount - 1;
+    const snappedOffset = rowMajorCellIndex(row, side === 'start' ? 0 : colCount - 1, colCount);
     if (snappedOffset === cellIdx)
         return point;
-    return { ...point, offset: snappedOffset };
+    return cellPoint(point.path, snappedOffset);
 }

package/dist/selection/table-rect-extend.d.ts

@@ -5,7 +5,7 @@
  * horizontal extension clamps at the column edges, since a rectangle has no sideways exit.
  */
 import type { DocumentView } from '../core/node-views';
-import type { SelectionPoint } from './primitives';
+import { type SelectionPoint } from './primitives';
 export type ArrowKey = 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight';
 export type TableRectExtension = {
     kind: 'cell';
@@ -15,9 +15,6 @@ export type TableRectExtension = {
     direction: 'forward' | 'backward';
     fromCellPath: number[];
 };
-/**
- * The extension a Shift+Arrow produces for an intra-table rectangle, or null when the selection
- * is not a same-table rectangle. `anchor === focus` is a valid one-cell rectangle, so the first
- * Shift+Arrow starts here too. Offsets are cell indices, context-established by the shared path.
- */
+/** The extension a Shift+Arrow produces for an intra-table rectangle, or null unless the selection
+ *  is a same-table pair of cell endpoints (`anchor === focus` is a one-cell rectangle). */
 export declare function intraTableRectExtension(doc: DocumentView, anchor: SelectionPoint | null, focus: SelectionPoint | null, key: ArrowKey): TableRectExtension | null;

package/dist/selection/table-rect-extend.js

@@ -5,30 +5,35 @@
  * horizontal extension clamps at the column edges, since a rectangle has no sideways exit.
  */
 import { metadataOf } from '../core/nodes';
-import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
-import { cellRowCol } from '../cursor/coordinate-spaces';
+import { nodeAt } from '../tree-operations/node-primitives';
+import { countsCells } from '../schema/block-kind-descriptor';
+import { rowMajorCellIndex, cellRowCol } from '../cursor/coordinate-spaces';
+import { cellIndexOf } from './primitives';
 import { pathsEqual } from './path-math';
-/**
- * The extension a Shift+Arrow produces for an intra-table rectangle, or null when the selection
- * is not a same-table rectangle. `anchor === focus` is a valid one-cell rectangle, so the first
- * Shift+Arrow starts here too. Offsets are cell indices, context-established by the shared path.
- */
+/** The extension a Shift+Arrow produces for an intra-table rectangle, or null unless the selection
+ *  is a same-table pair of cell endpoints (`anchor === focus` is a one-cell rectangle). */
 export function intraTableRectExtension(doc, anchor, focus, key) {
-    if (!anchor || !focus || !pathsEqual(anchor.path, focus.path))
+    if (!anchor?.cellCoordinate || !focus?.cellCoordinate)
+        return null;
+    if (!pathsEqual(anchor.path, focus.path))
         return null;
     const node = nodeAt(doc, focus.path);
-    if (!node || !isBlockNode(node) || node.kind !== 'table')
+    if (!node || !countsCells(node))
         return null;
     const colCount = metadataOf(node, 'table').columnCount;
     const rowCount = node.children?.length ?? 0;
     if (colCount === 0 || rowCount === 0)
         return null;
     const path = focus.path;
-    const { row, col } = cellRowCol(focus.offset, colCount);
+    const { row, col } = cellRowCol(cellIndexOf(focus, 'intraTableRectExtension'), colCount);
+    const at = (r, c) => ({
+        kind: 'cell',
+        offset: rowMajorCellIndex(r, c, colCount)
+    });
     switch (key) {
         case 'ArrowDown':
             return row < rowCount - 1
-                ? { kind: 'cell', offset: (row + 1) * colCount + col }
+                ? at(row + 1, col)
                 : {
                     kind: 'exit',
                     direction: 'forward',
@@ -36,11 +41,11 @@ export function intraTableRectExtension(doc, anchor, focus, key) {
                 };
         case 'ArrowUp':
             return row > 0
-                ? { kind: 'cell', offset: (row - 1) * colCount + col }
+                ? at(row - 1, col)
                 : { kind: 'exit', direction: 'backward', fromCellPath: [...path, 0, 0] };
         case 'ArrowRight':
-            return { kind: 'cell', offset: row * colCount + Math.min(col + 1, colCount - 1) };
+            return at(row, Math.min(col + 1, colCount - 1));
         case 'ArrowLeft':
-            return { kind: 'cell', offset: row * colCount + Math.max(col - 1, 0) };
+            return at(row, Math.max(col - 1, 0));
     }
 }

package/dist/styles/editor-theme.css

@@ -1,44 +1,40 @@
 /**
- * Editor default theme, in two tiers (consumer-guide.md § Theming). Host-chrome tokens
- * default behind the opt-in `.aragonite-editor-theme` class ALONE, so a themed host's own
- * cascade reaches the editor unbridged (G4.6d); editor-owned tokens — and the host-family
- * names a host vocabulary does not carry — default on `.editor` too. `:where()` keeps
- * specificity at 0 so `.editor { --x: … }` wins. Light keys on `data-editor-theme='light'`.
+ * The editor's default theme, in two tiers (consumer-guide.md § Theming). Host-chrome tokens
+ * default only behind the opt-in `.aragonite-editor-theme` class, so a themed host's own cascade
+ * reaches the editor with nothing in between (G4.6d); editor-owned tokens, and the host-family
+ * ones a host theme rarely names, default on `.editor` too. `:where()` holds specificity at 0 so
+ * `.editor { --x: … }` wins, and the light theme keys on `data-editor-theme='light'`.
  */
 
-/* ── Host-chrome tier: the consumer's vocabulary, defaults behind the class ── */
+/* ── Host-chrome tokens: the consumer's names, defaults behind the class ── */
 
 :where(.aragonite-editor-theme) {
-	/* Two faces, because they answer different questions. `--font-editor` is the SURFACE
-	   face — prose, headings, markers — and a host may legitimately set it proportional.
-	   `--font-code` is what must stay monospace whatever that choice is: code blocks, code
-	   spans, raw HTML, revealed source. Defaulted to the same stack, so a consumer that
-	   never names the second one sees exactly what it saw before. */
+	/* `--font-editor` is the text's own face and a host may set it proportional; `--font-code` is
+	   what stays monospace whatever that choice (code, raw HTML, revealed source). */
 	--font-editor: 'Cascadia Code', 'Cascadia Mono', 'Consolas', ui-monospace, monospace;
 	--font-code: 'Cascadia Code', 'Cascadia Mono', 'Consolas', ui-monospace, monospace;
 	/* The menus' and popovers' face: the host's own UI font where it names one. */
 	--font-ui: 'Inter', system-ui, sans-serif;
 	/* Type-scale root: headings, code and markers are all `em`-relative, so one override
-	   scales the surface. A themed host sets it on any ancestor instead. */
+	   scales the whole editor. A themed host sets it on any ancestor instead. */
 	--editor-font-size: 1rem;
 
-	/* Corner radii by role: small controls (buttons, inputs, chips) and elevated surfaces
-	   (overlays, popovers). Chrome whose corner is neither keeps its own literal. */
+	/* Corner radii by role: small controls (buttons, inputs, chips) and raised surfaces
+	   (overlays, popovers). A part whose corner is neither keeps its own value. */
 	--radius-ui: 4px;
 	--radius-surface: 8px;
 
-	/* The page ground, which the menus and the image toolbar paint on. */
+	/* The page background the menus and the image toolbar paint on. */
 	--color-bg: #2c2c2a;
 	--color-surface: #1a1a19;
 	--color-text-secondary: #cfcfca;
 	--color-text-primary: #e8e8e5;
 	--color-border: #3e3e3b;
-	--color-ui-muted: #8f8f89;
+	--color-ui-muted: #93938d;
 	--color-ui-dulled: #a3a39d;
 	--color-accent: #567b67;
-	/* Base the selection, search-match and reorder washes derive from, so one declaration
-	   moves all of them; the washes themselves stay editor-owned. Tracking the accent means
-	   a host that recolors one recolors all four. */
+	/* The base the selection, search-match and reorder tints derive from, following the accent,
+	   so one declaration recolors them all; the tints themselves stay editor-owned. */
 	--color-selection: var(--color-accent, #567b67);
 	--color-error: #ff5f57;
 }
@@ -49,29 +45,32 @@
 	--color-text-secondary: #4a4a45;
 	--color-text-primary: #2a2a27;
 	--color-border: #c9c7c0;
-	--color-ui-muted: #83837b;
-	--color-ui-dulled: #71716a;
+	--color-ui-muted: #62625c;
+	--color-ui-dulled: #5c5c56;
 	--color-accent: #567b67;
 	--color-selection: var(--color-accent, #567b67);
 	--color-error: #d03025;
 }
 
-/* ── Editor-owned tier: defaults on `.editor`, so they hold with or without the class ── */
+/* ── Editor-owned tokens: defaults on `.editor`, so they hold with or without the class ── */
 
 :where(.editor, .aragonite-editor-theme) {
-	/* Host-family surfaces a host theme rarely names, so the editor supplies both modes
-	   rather than falling back to a fixed veil over the host's palette. */
+	/* Host-family backgrounds a host theme rarely names, so the editor supplies both modes
+	   rather than falling back to one fixed tint over the host's palette. */
 	--color-bg-secondary: rgba(128, 128, 128, 0.12);
 	--color-bg-elevated: #2a2c33;
 	--color-bg-muted: #2a2a2a;
 	--color-text-muted: #aaaaaa;
-	/* Hover veil over an ALREADY-elevated surface, so it cannot reuse
-	   --color-bg-secondary, which is measured against the base bg. */
+	/* Hover tint over a surface that is already raised, so it cannot reuse
+	   --color-bg-secondary, which is measured against the page background. */
 	--color-ui-faint: rgba(255, 255, 255, 0.07);
 
-	/* Markdown syntax override points, deliberately neutral so the default rendering carries no
-	   extra palette. Mode-independent: the chrome tokens they chain to carry the light/dark
-	   split. */
+	/* One radius for a picture, the crop frame that clips it and the selection ring on the
+	   overlay above it: half the surface radius, enough to soften a photo without a card look. */
+	--md-image-radius: 4px;
+
+	/* Markdown syntax override points, neutral so the default rendering adds no palette of its own;
+	   most chain to a host-chrome token that holds the light and dark split. */
 	--syntax-heading: currentColor;
 	--syntax-emphasis: currentColor;
 	--syntax-link: var(--color-accent, #567b67);
@@ -80,14 +79,15 @@
 	--syntax-code: currentColor;
 	--syntax-comment: currentColor;
 	--syntax-list: currentColor;
-	/* The rendered rule's colour, and its ONLY consumer. A divider separates rather than
-	   announces, so it defaults to the border token; mid-grey at this weight competed with
-	   the text either side. A host that wants a louder rule still names this token. */
+	/* The rendered horizontal rule's colour: a rule separates rather than announces, so it
+	   defaults to the border token. */
 	--syntax-separator: var(--color-border, #3e3e3b);
 	--syntax-task: currentColor;
-	--syntax-task-done: rgba(128, 128, 128, 0.7);
+	--syntax-task-done: #8f8f89;
+	--syntax-task-checked: var(--color-text-primary, currentColor);
+	--syntax-task-checked-tick: var(--color-bg, #2c2c2a);
 
-	/* Code block syntax highlighting — monokai-inspired palette */
+	/* Code block syntax highlighting: a monokai-inspired palette. */
 	--code-tok-keyword: #ff79a8;
 	--code-tok-string: #e6db74;
 	--code-tok-number: #ae81ff;
@@ -109,28 +109,34 @@
 	--code-tok-link: #66d9ef;
 	--code-tok-unknown: inherit;
 
-	/* Presentational tokens (mode-independent). */
-	/* Washes over the host-declarable selection base, alpha apart, so a host that names one
-	   base moves the selection, the search matches and the reorder chrome together. */
-	--selection-overlay-bg: color-mix(in srgb, var(--color-selection, #6496ff) 30%, transparent);
-	--search-match-bg: color-mix(in srgb, var(--color-selection, #6496ff) 22%, transparent);
+	/* Tints over the selection base a host can declare, differing only in alpha, so naming that
+	   one base moves the selection, the search matches and the reorder highlight together. */
+	--selection-overlay-bg: rgba(100, 150, 255, 0.3);
+	--search-match-bg: rgba(100, 150, 255, 0.22);
 	/* Painted on top of the match text, so it must keep an alpha channel or it hides it. */
 	--search-match-active-bg: rgba(216, 166, 87, 0.55);
-	--md-ref-label-color: rgba(128, 128, 128, 0.45);
-	--md-link-blocked-color: rgba(128, 128, 128, 0.7);
+	/* Greys for text set apart as metadata or inert: the faintest that clear AA, set per mode. */
+	--md-ref-label-color: #8f8f89;
+	--md-link-blocked-color: #8f8f89;
 	--md-unresolved-color: #c0392b;
 	--md-unresolved-image-bg: rgba(192, 57, 43, 0.08);
-	--md-raw-html-color: rgba(120, 120, 120, 0.85);
+	--md-raw-html-color: #8f8f89;
 	--md-marker-hover-bg: rgba(128, 128, 128, 0.15);
+	/* The hanging indent a task item reserves for its marker: the width the visible `- [ ] `
+	   draws, which editor.css overrides where the box is drawn instead. */
+	--md-task-indent: 2.1em;
 	--md-reorder-indicator: var(--color-selection, #6496ff);
-	/* Wash on the container being reordered within during a nested drag. Tinted with the reorder
-	   accent, not neutral grey, so the shift stays perceptible for low-contrast vision. */
-	--reorder-scope-bg: color-mix(in srgb, var(--color-selection, #6496ff) 14%, transparent);
+	/* The name a typed kind change leaves on its block, and how long it stays before it fades. */
+	--md-kind-cue-color: var(--color-ui-muted, #8f8f89);
+	--md-kind-cue-duration: 1.2s;
+	/* Tint on the container a nested drag is reordering inside. It uses the reorder accent rather
+	   than neutral grey, so the change stays visible to low-contrast vision. */
+	--reorder-scope-bg: rgba(100, 150, 255, 0.14);
+	/* The light theme sets its own dim. */
 	--syntax-marker-dim: 0.65;
 
-	/* Menu/popout elevation, per mode: a shadow tuned for a near-black surface is invisible
-	   over a white one. Editor-owned rather than host-family, since a host palette names
-	   colors, not elevation. */
+	/* Menu elevation, per mode, since a shadow tuned for a near-black surface vanishes over a white
+	   one; editor-owned because a host palette names colors, not elevation. */
 	--menu-shadow: 0 12px 32px rgba(0, 0, 0, 0.5), 0 2px 8px rgba(0, 0, 0, 0.35);
 	/* The rest of the host app's menu family, so a menu here is the host's menu to the pixel. */
 	--menu-item-hover: rgba(255, 255, 255, 0.07);
@@ -138,11 +144,21 @@
 	--menu-scrollbar-thumb: rgba(255, 255, 255, 0.18);
 	--menu-scrollbar-thumb-hover: rgba(255, 255, 255, 0.3);
 
-	/* Placeholder tint behind off-window content (VR-8), so a spacer that outruns the
-	   window recompute reads as "loading" rather than a white tear. */
+	/* Tint behind the blocks windowing has not mounted, so a spacer that outruns the recompute
+	   reads as "loading" rather than a white tear (VR-8). */
 	--vr-spacer-bg: rgba(255, 255, 255, 0.025);
 }
 
+/* The tints follow a host's `--color-selection` where the browser has `color-mix`; the fixed
+   values above are the default base's tints for a browser without it. */
+@supports (color: color-mix(in srgb, red, blue)) {
+	:where(.editor, .aragonite-editor-theme) {
+		--selection-overlay-bg: color-mix(in srgb, var(--color-selection, #6496ff) 30%, transparent);
+		--search-match-bg: color-mix(in srgb, var(--color-selection, #6496ff) 22%, transparent);
+		--reorder-scope-bg: color-mix(in srgb, var(--color-selection, #6496ff) 14%, transparent);
+	}
+}
+
 :where(.editor, .aragonite-editor-theme)[data-editor-theme='light'] {
 	--color-bg-secondary: rgba(0, 0, 0, 0.035);
 	--color-bg-elevated: #f5f6f8;
@@ -155,9 +171,15 @@
 	--menu-scrollbar-thumb: rgba(0, 0, 0, 0.2);
 	--menu-scrollbar-thumb-hover: rgba(0, 0, 0, 0.32);
 
-	/* --syntax-* tokens are mode-independent — no light overrides. */
+	/* At the dark theme's 0.65 marker dim, light prose falls under AA on the light surface. */
+	--syntax-marker-dim: 0.68;
+	/* Done and inert text greys: the faintest that clear AA on the light surface and fence. */
+	--syntax-task-done: #666660;
+	--md-ref-label-color: #666660;
+	--md-link-blocked-color: #666660;
+	--md-raw-html-color: #666660;
 
-	/* Code block syntax highlighting — GitHub Light-inspired palette */
+	/* Code block syntax highlighting: a GitHub Light-inspired palette. */
 	--code-tok-keyword: #c1202b;
 	--code-tok-string: #0a3069;
 	--code-tok-number: #0550ae;
@@ -175,6 +197,6 @@
 	--code-tok-heading: #0550ae;
 	--code-tok-link: #0550ae;
 
-	/* Dark tint for a light bg (VR-8). */
+	/* Dark tint for a light background (VR-8). */
 	--vr-spacer-bg: rgba(0, 0, 0, 0.03);
 }