@voithos-labs/aragonite 0.10.1 → 0.10.3

package/docs/guide/plugin-guide.md

@@ -305,7 +305,7 @@ cNo.....................................oc
 			color: #3fd3d3;
 		}
 		85.714% {
-			color: var(--color-text-primary, #ffffff);
+			color: var(--color-text-primary, currentColor);
 		}
 	}
 	@media (prefers-reduced-motion: reduce) {
@@ -916,7 +916,9 @@ Pass the plugin to the editor's `plugins` prop. It installs before the seed pars
 	let editor = $state();
 </script>
 
-<Editor bind:this={editor} source={SEED} {plugins} theme="light" />
+<div class="aragonite-editor-theme" data-editor-theme="light">
+	<Editor bind:this={editor} source={SEED} {plugins} theme="light" />
+</div>
 ```
 
 The chords are live (a **chord** is a key combination, written `Mod+7` where `Mod` is Ctrl, or Cmd on a Mac). Focus the box, press `Mod+8` to debunk the theory (the string comes down and the stamp lands) and `Mod+7` to allege it again, then read `editor.getSource()` back and watch the opener line flip between the two names:
@@ -931,7 +933,7 @@ editor.getSource();
 
 The flip is one undoable edit, so undo un-debunks it, which is how conspiracies work anyway. And because the verdict lives in the bytes, a debunked conspiracy stays debunked across a reload.
 
-One thing that surprises people pasting this into a fresh app: `theme="light"` flips only the editor-owned colors, so the page still looks dark. The built-in light chrome wants the `aragonite-editor-theme` class on a wrapper element; [consumer-guide.md](consumer-guide.md)'s theming section explains the two tiers.
+The wrapper and the two `light`s are there because the editor paints no background of its own. A fresh app's page is white, so the built-in chrome (the wrapper's attribute) and the editor's own surfaces (the prop) both have to say so; on a dark page, both say `dark`, or nothing. [consumer-guide.md](consumer-guide.md)'s theming section explains the two tiers.
 
 Want a collapse toggle? Give `reservedChrome` an `isCollapsed` probe over the node, and every focus walk, merge, and windowing decision (a collapsed body stays unmounted) reads that one declaration. Add `expandPatch` beside it, returning the metadata patch that opens the node, and a reveal into the collapsed body (a table-of-contents entry, a search match) opens the container first and commits it as one undoable edit. Without it, such a reveal has nowhere to land and reports that it didn't.
 
@@ -1159,9 +1161,11 @@ leaf.getOptions(); // this editor's options for your plugin, typed unknown
 
 **Native parity is the tier's whole claim**: the editor's caret enters and leaves your block like any built-in text block (including keeping its column as it walks up or down lines), IME composition is respected, undo batches like prose, the clipboard is intercepted for plain-Markdown copy/cut/paste like every editable surface, and a cross-block selection sweeps through your text.
 
-**One spread wires the source surface.** Write `<div {...leaf.surfaceProps}>` on your source contenteditable and the nine DOM handlers, the `contenteditable` / `role` / `tabindex` / `spellcheck` attributes, and two view-lifecycle contracts all land at once, so a forgotten handler (a dropped `oncompositionend` that silently breaks IME) simply can't happen to you. The two contracts the spread owns are the ones every consumer used to hand-write: the source is populated as a **single text node** (so `textContent === source` and the walk that maps DOM positions to byte offsets stays exact), and focus is parked on the editor root when the source unmounts.
+**One spread wires the source surface.** Write `<div {...leaf.surfaceProps}>` on your source contenteditable and the DOM handlers, the `contenteditable` / `role` / `tabindex` / `spellcheck` attributes, and two view-lifecycle contracts all land at once, so a forgotten handler (a dropped `oncompositionend` that silently breaks IME) simply can't happen to you. The two contracts the spread owns are the ones every consumer used to hand-write: the source is populated so that **`textContent === source`** (the walk that maps DOM positions to byte offsets depends on it), and focus is parked on the editor root when the source unmounts.
+
+That text carries every newline your source holds, which makes **`white-space: pre-wrap` (or `pre`) on your source element part of the contract** for any leaf whose bytes can span lines. Without it the browser collapses the line breaks on screen while the offset walk goes on counting them, and the caret sits nowhere near where it looks.
 
-That single text node carries every newline your source holds, which makes **`white-space: pre-wrap` (or `pre`) on your source element part of the contract** for any leaf whose bytes can span lines. Without it the browser collapses the line breaks on screen while the offset walk goes on counting them, and the caret sits nowhere near where it looks.
+**A painted source.** By default the source is one text node. A `renderSource(text)` dep paints it as DOM instead (fence lines the marker-hiding modes collapse, highlight tokens; the `highlightCode` export is the code block's own tokenizer), and the factory asserts `textContent === text` on every paint, so a painter that drops a byte fails loudly in dev rather than corrupting a commit. A painted source takes its plain-text edits from the leaf, not the browser: typing, Enter, deletes and pastes splice the text and repaint, each reported through `onSourceEdit(text)` so a live preview can follow the draft, and undo inside the open reveal walks those edits back before it reaches the document's history. `repaintSource()` re-runs the painter after a native edit (an IME commit), and `completeBareSource(text)` lets a kind complete a chrome-only source (a `$$` straight over `$$`) to the shape a caret can sit in as it is revealed. Block math is the worked example.
 
 A leaf whose bytes are one line (the parrot's opener claims exactly one) declares `singleLine: true` and needs none of that. Enter in one of those ends the block: the text after the caret becomes a paragraph below and the caret goes with it, which is what Enter does in a heading. With the flag off, the default, Enter types a newline.
 
@@ -1186,7 +1190,7 @@ Editing past your own fence therefore re-splits the document instead of wedging
 
 **Per-instance configuration.** `leaf.getOptions()` returns this editor instance's options for the plugin owning your kind, typed `unknown` for you to narrow. It's the same route as the container factory's `getOptions()`, one tier down, and the same rule applies ([the options recipe](#recipe-per-instance-options-and-the-factory-closure-trap)). The bundled toc block resolves `maxDepth` this way and falls back to the factory argument, which then serves as the default for an instance declaring none.
 
-Block math (`$$…$$` in the bundled `@voithos-labs/aragonite/plugins/latex` plugin) is the worked example, and it's smaller than you'd expect: its component script is the factory call, one render effect (KaTeX), a `{...leaf.surfaceProps}` spread on the source, and one-line re-exports of the returned surface. Registration is the ordinary leaf recipe: `registerBlockKind` (no container group), `registerBlockOpener`, `registerBlockComponent`.
+Block math (`$$…$$` in the bundled `@voithos-labs/aragonite/plugins/latex` plugin) is the worked example, and it's smaller than you'd expect: its component script is the factory call, one render effect (KaTeX), a `{...leaf.surfaceProps}` spread on the source, and one-line re-exports of the returned surface. Registration is the ordinary leaf recipe: `registerBlockKind` (no container group), `registerBlockOpener`, `registerBlockComponent`. Its `caretTargetAtPoint` is the other half of the parrot's: where the parrot's caption is the source bytes minus a prefix, KaTeX paints glyphs no offset maps back to, so the render effect stamps the body's span on the rendered element and the hook walks that span in proportion to how far along the press fell.
 
 ## Presentation modes
 
@@ -1379,6 +1383,8 @@ If your `revealSource` widget takes a click of its own, declare `claimsActivatio
 
 If your widget derives from the whole document, read the version inside the same `$derived` and use it as your memo key. The document itself isn't a usable key: the editor mutates it in place, so its identity never changes, and an identity-keyed memo hits forever on a stale answer. Reading the version inside the derived is also what subscribes your widget to edits anywhere, so N widgets sharing one memoized walk stay as live as N widgets each walking the document.
 
+**A symmetric delimiter can close itself as it is typed.** Pass `autoPair: true` on a bare trigger whose construct opens and closes on the same byte, the way the bundled latex plugin does for `$…$`: typing the trigger lands its twin after the caret, typing it again over that twin steps past it, and a first body byte the recognizer rejects (a `$` followed by a digit is a price) drops the twin again. Without it a lone `$` typed ahead of an existing formula pairs with that formula's closer and wraps the prose between them. The built-in backtick, `*`, `_` and `~~` behave this way without registration.
+
 **A bare trigger must be a character no built-in scanner claims.** Registering a bare recognizer on a reserved trigger (`` ` ``, `&`, `<`, `*`, `_`, `~`, `[`, `]`, `!`, `\`, or newline) throws: built-in dispatch runs first, so a bare recognizer there would never fire, and a silent no-op is the one failure a public API must not have.
 
 The bundled **emoji** plugin (`@voithos-labs/aragonite/plugins/emoji`) is this bare-trigger recipe end to end and the worked reference for an inline kind on an unreserved trigger: `:shortcode:` recognizes on the bare `:` trigger, renders as an atomic glyph widget through `buildWidget` + `mintWidgetShell`, and carries the `{ deleteGranularity: 'atomic', onEdge: 'step-over' }` edge policy so a caret-adjacent Backspace removes the whole `:name:` in one press and a plain arrow steps over it. It shares the `:` trigger with the directive text tier, because disjoint grammars coexist happily on one trigger: a table-lookup miss declines and falls through with the bytes untouched. The literal `:name:` bytes stay in the raw, so an uninstalled document round-trips as ordinary prose.
@@ -1604,6 +1610,25 @@ registerGlobalCommand('mine.bold', handler, { chord: 'Mod+B' }); // fine: fires
 
 Chord strings follow the consumer guide's chord model: fixed-order `Mod` / `Alt` / `Shift` plus the key's own value. Shifted-symbol chords aren't modeled, so bind plain digits and letters.
 
+## Block context actions
+
+**`registerBlockContextActions(kind, provider)`**
+
+The right-click menu on a block of `kind` (a code block, a table, a plugin's own block) lists what its providers return, ahead of the editor's own rows (copy, replace with the clipboard, remove). Register from `setup`. The provider is consulted on every open, so it reads the block as it is then; several may stack on one kind, and `EVERY_KIND` (`'*'`) registers for every kind. Prose is the page's background: a paragraph or heading keeps the browser's own menu and consults no provider.
+
+```ts
+registerBlockContextActions(conspiracy, (node) => [
+	{
+		id: 'conspiracy.debunk',
+		label: 'Mark debunked',
+		icon: 'check',
+		run: (ctx) => ctx.replaceRaw(node.raw.replace(/^:::conspiracy/, ':::debunked'))
+	}
+]);
+```
+
+`run` receives a `BlockActionContext`: the node, its path, `deleteBlock()`, and `replaceRaw(raw)`, which rewrites the block's bytes wholesale and reparses them, the road the default replace row takes. Each is one undo entry. `icon` names a glyph the editor's menus already draw (the same set the code rail and the table menu use); a row without one shows none. `danger` paints the row in the error colour, for an action that is not one undo away.
+
 ## Paste transforms
 
 `registerPasteTransform` records a **content-keyed, pre-parse** rewrite of pasted plain text. Each transform is a `{ name, transform(text) }` unit: `transform` returns a replacement string, or `null` to decline ("not mine"). Transforms run at every paste site before the clipboard text is parsed, in **install order**, each one seeing the previous transform's output, so a plugin keys off the _content_ it recognizes rather than the block it lands in. The name is unique (register-once; a duplicate throws, naming the owning plugin) and scopes the transform for attribution.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@voithos-labs/aragonite",
-	"version": "0.10.1",
+	"version": "0.10.3",
 	"description": "Svelte 5 block editor for GFM Markdown with byte-for-byte lossless round-trip and a plugin platform",
 	"keywords": [
 		"markdown",
@@ -202,6 +202,8 @@
 	"devDependencies": {
 		"@axe-core/playwright": "^4.13.0",
 		"@eslint/js": "^10.0.1",
+		"@fontsource/inter": "^5.3.0",
+		"@fontsource/jetbrains-mono": "^5.3.0",
 		"@playwright/test": "^1.62.0",
 		"@sveltejs/adapter-static": "^3.0.0",
 		"@sveltejs/kit": "^2.70.3",
@@ -227,7 +229,7 @@
 		"typescript-eslint": "^8.67.0",
 		"vite": "^8.2.2",
 		"vitest": "^4.1.0",
-		"wrangler": "4.125.0"
+		"wrangler": "4.131.0"
 	},
 	"overrides": {
 		"cookie": "^0.7.2"

package/dist/components/blocks/code/CodeLanguageChip.svelte

@@ -1,127 +0,0 @@
-<script lang="ts">
-	import { tick } from 'svelte';
-	import { CODE_LANGUAGE_FIELD, codeLanguageLabel } from '../../../a11y-strings';
-
-	// The fence-info door for the modes that paint no fence. The draft lives here and only a
-	// commit reaches the tree.
-	let {
-		info,
-		editable,
-		onCommit,
-		onCancel
-	}: {
-		/** The opener's full info string; the button shows its first token. */
-		info: string;
-		/** False in reading mode, which writes no bytes — the chip is then a label. */
-		editable: boolean;
-		/** Only Enter calls this, and it owns the caret's landing afterwards. */
-		onCommit: (info: string) => void;
-		/** Nothing written. Escape asks for the caret back; a blur must not yank it from
-		 *  wherever the user just clicked, so it does not. */
-		onCancel: (returnCaret: boolean) => void;
-	} = $props();
-
-	const language = $derived(info.split(/\s+/)[0] || 'text');
-
-	let editing = $state(false);
-	let draft = $state('');
-	let inputEl: HTMLInputElement | undefined = $state();
-
-	function open(): void {
-		if (!editable) return;
-		draft = info;
-		editing = true;
-		void tick().then(() => {
-			inputEl?.focus();
-			inputEl?.select();
-		});
-	}
-
-	function onFieldKeyDown(e: KeyboardEvent): void {
-		// The field owns its keys while open: no Escape of this state may reach whatever else
-		// listens for one. A composing Enter/Escape is the IME's, never the field's.
-		e.stopPropagation();
-		if (e.isComposing) return;
-		if (e.key === 'Enter') {
-			e.preventDefault();
-			const committed = draft;
-			editing = false;
-			onCommit(committed);
-		} else if (e.key === 'Escape') {
-			e.preventDefault();
-			editing = false;
-			onCancel(true);
-		}
-	}
-
-	function onFieldBlur(): void {
-		if (!editing) return;
-		editing = false;
-		onCancel(false);
-	}
-</script>
-
-<span class="code-lang-chip">
-	{#if editing}
-		<input
-			bind:this={inputEl}
-			bind:value={draft}
-			type="text"
-			spellcheck="false"
-			aria-label={CODE_LANGUAGE_FIELD}
-			onkeydown={onFieldKeyDown}
-			onfocusout={onFieldBlur}
-		/>
-	{:else}
-		<button type="button" aria-label={codeLanguageLabel(language)} onclick={open}>{language}</button
-		>
-	{/if}
-</span>
-
-<style>
-	/* Positioned against the block host, whose box the code box fills, and out of the code
-	   box's own scroller so a horizontal scroll leaves it where it is. */
-	.code-lang-chip {
-		position: absolute;
-		top: 5px;
-		right: 5px;
-		z-index: 1;
-		display: flex;
-		font-family: var(--font-editor, ui-monospace, monospace);
-		font-size: 0.75em;
-		line-height: 1;
-		opacity: 0;
-		pointer-events: none;
-	}
-
-	/* Transient, like the drag handle: the pointer over the block or the caret inside it, plus
-	   the open field, which outlives both. Child and sibling combinators, so an outer container's
-	   hover never reveals a nested block's chip. */
-	:global(.block-host:hover) > .code-lang-chip,
-	:global(.code-block:focus) ~ .code-lang-chip,
-	.code-lang-chip:focus-within {
-		opacity: 1;
-		pointer-events: auto;
-	}
-
-	button,
-	input {
-		padding: 2px 6px;
-		border: 1px solid var(--color-ui-muted, #a4a4a4);
-		border-radius: var(--radius-ui, 3px);
-		background: var(--color-bg-elevated, #2a2a2a);
-		color: var(--color-accent, #567b67);
-		font: inherit;
-		cursor: pointer;
-	}
-
-	button:hover {
-		background: var(--color-ui-faint, rgba(255, 255, 255, 0.07));
-	}
-
-	input {
-		width: 9ch;
-		color: var(--color-text-secondary, #eee);
-		cursor: text;
-	}
-</style>

package/dist/components/blocks/code/CodeLanguageChip.svelte.d.ts

@@ -1,14 +0,0 @@
-type $$ComponentProps = {
-    /** The opener's full info string; the button shows its first token. */
-    info: string;
-    /** False in reading mode, which writes no bytes — the chip is then a label. */
-    editable: boolean;
-    /** Only Enter calls this, and it owns the caret's landing afterwards. */
-    onCommit: (info: string) => void;
-    /** Nothing written. Escape asks for the caret back; a blur must not yank it from
-     *  wherever the user just clicked, so it does not. */
-    onCancel: (returnCaret: boolean) => void;
-};
-declare const CodeLanguageChip: import("svelte").Component<$$ComponentProps, {}, "">;
-type CodeLanguageChip = ReturnType<typeof CodeLanguageChip>;
-export default CodeLanguageChip;

package/dist/components/blocks/table/TableGrip.svelte

@@ -1,91 +0,0 @@
-<script lang="ts">
-	let {
-		axis,
-		onActivate,
-		onpointerdown
-	}: {
-		axis: 'row' | 'column';
-		onActivate: (e: MouseEvent) => void;
-		onpointerdown?: (e: PointerEvent) => void;
-	} = $props();
-
-	function handlePointerDown(e: PointerEvent): void {
-		// The affordance opens a menu, it doesn't place a caret, so the grip's pointer
-		// stream stays off the editor's selection/focus handlers.
-		e.stopPropagation();
-		onpointerdown?.(e);
-	}
-</script>
-
-<!-- Pointer-only affordance: the cell chords are the operable, screen-reader path, so the
-	grip stays out of the tab/SR flow. Reveal is pure CSS: hover in editor.css, touch below. -->
-<span class="table-grip-anchor table-grip-anchor-{axis}">
-	<span
-		class="table-grip table-grip-{axis}"
-		data-table-col-grip={axis === 'column' ? '' : undefined}
-		data-table-row-grip={axis === 'row' ? '' : undefined}
-		aria-hidden="true"
-		onclick={onActivate}
-		onpointerdown={handlePointerDown}
-	></span>
-</span>
-
-<style>
-	/* Zero-height so it never adds a visible band or shifts caret-measured layout;
-	   z-index lifts the dots above the DOM-later header cell, which would eat the click. */
-	.table-grip-anchor-column {
-		position: relative;
-		z-index: 2;
-		height: 0;
-	}
-
-	/* The dotted bar shared by both axes; the axis rules add only the geometry. */
-	.table-grip {
-		position: absolute;
-		color: var(--color-ui-muted, #a4a4a4);
-		background-image: radial-gradient(currentColor 40%, transparent 45%);
-		background-position: center;
-		cursor: pointer;
-		opacity: 0;
-		pointer-events: none;
-	}
-
-	/* Sits within the header cell's top padding so it never overlaps the caret-click target. */
-	.table-grip-column {
-		top: 0;
-		left: 50%;
-		transform: translateX(-50%);
-		width: 1.75rem;
-		height: 0.35rem;
-		background-size: 0.25rem 0.35rem;
-		background-repeat: repeat-x;
-	}
-
-	/* Zero-width gutter item, stretched to the row height. z-index lifts the dots above
-	   cell A, which renders DOM-later and would otherwise paint over them. */
-	.table-grip-anchor-row {
-		position: relative;
-		z-index: 2;
-	}
-
-	/* Overflows out of the zero-width gutter into cell A's left padding, clear of the text. */
-	.table-grip-row {
-		top: 50%;
-		left: 0.15rem;
-		transform: translateY(-50%);
-		width: 0.35rem;
-		height: 1rem;
-		background-size: 0.35rem 0.25rem;
-		background-repeat: repeat-y;
-	}
-
-	/* Touch fires no hover, so the editor.css reveal never runs and an opted-in host's grips
-	   would be unreachable. `touch-action` keeps a reorder drag off the table's own scroll. */
-	@media (hover: none) {
-		.table-grip {
-			opacity: 1;
-			pointer-events: auto;
-			touch-action: none;
-		}
-	}
-</style>

package/dist/components/blocks/table/TableGrip.svelte.d.ts

@@ -1,8 +0,0 @@
-type $$ComponentProps = {
-    axis: 'row' | 'column';
-    onActivate: (e: MouseEvent) => void;
-    onpointerdown?: (e: PointerEvent) => void;
-};
-declare const TableGrip: import("svelte").Component<$$ComponentProps, {}, "">;
-type TableGrip = ReturnType<typeof TableGrip>;
-export default TableGrip;

package/dist/components/blocks/table/table-drop-target.d.ts

@@ -1 +0,0 @@
-export declare function dropGapIndex(pointer: number, edges: number[]): number;

package/dist/components/blocks/table/table-drop-target.js

@@ -1,16 +0,0 @@
-// Map a reorder drag's pointer to the insertion gap it sits nearest. `edges` are the
-// row/column boundaries in pointer space, so N tracks yield N+1 edges. The result is a
-// gap index, not the occupied cell `table-drag-hit-test` returns.
-export function dropGapIndex(pointer, edges) {
-    let nearest = 0;
-    let nearestDistance = Infinity;
-    for (let i = 0; i < edges.length; i++) {
-        const distance = Math.abs(pointer - edges[i]);
-        // Strict `<` keeps the lower gap when the pointer is exactly equidistant.
-        if (distance < nearestDistance) {
-            nearest = i;
-            nearestDistance = distance;
-        }
-    }
-    return nearest;
-}

package/dist/components/blocks/table/table-reorder-drag.d.ts

@@ -1,78 +0,0 @@
-/**
- * Pointer drag-to-reorder for table rows and columns: a shared drag session paints a single
- * insertion line (no tree mutation, no reflow) and commits ONE move on release. The axes diverge
- * only in geometry — rows are windowed under a fixed header, so their indices are absolute and
- * off-window targets need autoscroll to mount; columns are neither.
- */
-import type { UserScrollport } from '../../../cursor/scroll-ancestors';
-import { type PointerPosition } from '../../../selection/pointer-session';
-/** Members every reorder-axis context shares; the row/column contexts extend it. */
-interface AxisReorderDragContext<TLine> {
-    /** The editor's scrollport, which in host mode may be an ancestor or the window. */
-    getScrollContainer(): UserScrollport | null;
-    setLine(line: TLine | null): void;
-    /** Marks the gesture a drag (not a click) so the grip's menu stays closed. */
-    onDragRecognized(): void;
-    commit(from: number, to: number): void;
-    /** Aborted on editor unmount — tears down a drag whose pointerup can't fire. */
-    lifetimeSignal?: AbortSignal;
-}
-export interface TableReorderDragContext<TLine> extends AxisReorderDragContext<TLine> {
-    from: number;
-    /**
-     * Pure per-axis map from the live pointer to the insertion line and clamped drop
-     * index (null when geometry is unavailable). Returns rather than sets, so the axis
-     * clamps stay unit-testable in isolation.
-     */
-    process(pointer: PointerPosition): {
-        line: TLine;
-        dropTo: number;
-    } | null;
-    /** The autoscroll axis only — rows scroll both ways, a wide table's columns horizontally. */
-    autoScrollAxis: 'horizontal' | 'vertical' | 'both';
-}
-export declare function startTableReorderDrag<TLine>(down: PointerEvent, ctx: TableReorderDragContext<TLine>): void;
-export interface RowReorderLine {
-    left: number;
-    top: number;
-    width: number;
-}
-export interface RowReorderGeometry {
-    /** Viewport-Y boundaries of the mounted rows: each row's top, plus the last row's bottom. */
-    rowEdges: number[];
-    /**
-     * Absolute gap index for each `rowEdges` entry, so a drop maps a local edge to a
-     * body position even once the window has scrolled past row 0.
-     */
-    gapIndices: number[];
-    /** Viewport-left and width of the table, for the insertion line's horizontal span. */
-    left: number;
-    width: number;
-}
-export interface RowReorderDragContext extends AxisReorderDragContext<RowReorderLine> {
-    fromRowIdx: number;
-    /** Live total row count — read each move so the header clamp tracks edits/re-slices. */
-    getRowCount(): number;
-    getGeometry(): RowReorderGeometry | null;
-}
-export declare function startRowReorderDrag(down: PointerEvent, ctx: RowReorderDragContext): void;
-export interface ColumnReorderLine {
-    left: number;
-    top: number;
-    height: number;
-}
-export interface ColumnReorderGeometry {
-    /** Viewport-X boundaries of the columns: each column's left, plus the last column's right. */
-    colEdges: number[];
-    /** Viewport-top and height of the table, for the insertion line's vertical span. */
-    top: number;
-    height: number;
-}
-export interface ColumnReorderDragContext extends AxisReorderDragContext<ColumnReorderLine> {
-    fromColIdx: number;
-    /** Live total column count — read each move so the clamp tracks edits. */
-    getColCount(): number;
-    getGeometry(): ColumnReorderGeometry | null;
-}
-export declare function startColumnReorderDrag(down: PointerEvent, ctx: ColumnReorderDragContext): void;
-export {};

package/dist/components/blocks/table/table-reorder-drag.js

@@ -1,97 +0,0 @@
-/**
- * Pointer drag-to-reorder for table rows and columns: a shared drag session paints a single
- * insertion line (no tree mutation, no reflow) and commits ONE move on release. The axes diverge
- * only in geometry — rows are windowed under a fixed header, so their indices are absolute and
- * off-window targets need autoscroll to mount; columns are neither.
- */
-import { dropGapIndex } from './table-drop-target';
-import { createPointerDragSession } from '../../../selection/pointer-session';
-// Past this much pointer travel the gesture is a drag, not a menu-opening click.
-const DRAG_THRESHOLD_PX = 4;
-export function startTableReorderDrag(down, ctx) {
-    let dragging = false;
-    let dropTo = null;
-    createPointerDragSession(down, {
-        threshold: DRAG_THRESHOLD_PX,
-        onDragRecognized: () => {
-            dragging = true;
-            ctx.onDragRecognized();
-        },
-        onMove: (pointer) => {
-            const result = ctx.process(pointer);
-            if (!result)
-                return;
-            dropTo = result.dropTo;
-            ctx.setLine(result.line);
-        },
-        // A sub-threshold press is a menu-opening click, not a reorder.
-        onEnd: (reason) => {
-            if (reason === 'up' && dragging && dropTo !== null && dropTo !== ctx.from) {
-                ctx.commit(ctx.from, dropTo);
-            }
-        },
-        onTeardown: () => ctx.setLine(null),
-        autoScroll: {
-            axis: ctx.autoScrollAxis,
-            getTargets: () => {
-                const sc = ctx.getScrollContainer();
-                return sc ? [sc] : [];
-            }
-        },
-        escape: true,
-        // Up front, not at threshold: a native text selection can begin from the empty
-        // grip before the first qualifying move and survive the drag.
-        disableUserSelect: true,
-        lifetimeSignal: ctx.lifetimeSignal
-    });
-}
-export function startRowReorderDrag(down, ctx) {
-    startTableReorderDrag(down, {
-        from: ctx.fromRowIdx,
-        autoScrollAxis: 'both',
-        getScrollContainer: ctx.getScrollContainer,
-        setLine: ctx.setLine,
-        onDragRecognized: ctx.onDragRecognized,
-        commit: ctx.commit,
-        lifetimeSignal: ctx.lifetimeSignal,
-        process(pointer) {
-            const geom = ctx.getGeometry();
-            if (!geom)
-                return null;
-            // The LOCAL edge among mounted rows; gapIndices maps it to the absolute gap.
-            let edge = dropGapIndex(pointer.clientY, geom.rowEdges);
-            // Never land above the fixed header (gap 0); reachable only while row 0 is mounted.
-            if (geom.gapIndices[edge] < 1)
-                edge = Math.min(edge + 1, geom.gapIndices.length - 1);
-            const gap = geom.gapIndices[edge];
-            // Insert semantics: removing the dragged row shifts later slots down by one.
-            const target = gap <= ctx.fromRowIdx ? gap : gap - 1;
-            const dropTo = Math.max(1, Math.min(target, ctx.getRowCount() - 1));
-            return { line: { left: geom.left, top: geom.rowEdges[edge], width: geom.width }, dropTo };
-        }
-    });
-}
-export function startColumnReorderDrag(down, ctx) {
-    startTableReorderDrag(down, {
-        from: ctx.fromColIdx,
-        // Pinned in the table's top band; vertical evaluation would spin the loop on a
-        // `.table-block` that only scrolls horizontally (autoscroll.ts § axis).
-        autoScrollAxis: 'horizontal',
-        getScrollContainer: ctx.getScrollContainer,
-        setLine: ctx.setLine,
-        onDragRecognized: ctx.onDragRecognized,
-        commit: ctx.commit,
-        lifetimeSignal: ctx.lifetimeSignal,
-        process(pointer) {
-            const geom = ctx.getGeometry();
-            if (!geom)
-                return null;
-            // Columns aren't windowed and have no header, so the edge index IS the drop gap.
-            const gap = dropGapIndex(pointer.clientX, geom.colEdges);
-            // Insert semantics: removing the dragged column shifts later slots left by one.
-            const target = gap <= ctx.fromColIdx ? gap : gap - 1;
-            const dropTo = Math.max(0, Math.min(target, ctx.getColCount() - 1));
-            return { line: { left: geom.colEdges[gap], top: geom.top, height: geom.height }, dropTo };
-        }
-    });
-}