@quillmark/svelte 0.0.0

package/dist/core/codec/positions.js

@@ -0,0 +1,108 @@
+import { scanDoc } from './encode.js';
+/** Build the position index for `doc` (walks it once via the shared scanner). */
+export function buildLineIndex(doc) {
+    const s = scanDoc(doc);
+    const runs = s.runs;
+    let pmEndContent = 1;
+    let firstContentStart = 1;
+    if (runs.length) {
+        const first = runs[0];
+        firstContentStart = first.pmStart;
+        const last = runs[runs.length - 1];
+        pmEndContent = runEndPm(last);
+    }
+    return { runs, usvEnd: s.usvEnd, pmEndContent, firstContentStart };
+}
+/** PM position just past a run (its exclusive end). */
+function runEndPm(run) {
+    if (run.kind === 'text')
+        return run.pmStart + run.s.length;
+    if (run.kind === 'nl')
+        return run.pmEnd;
+    return run.pmStart + 1;
+}
+const usvStartOf = (run) => run.usvStart;
+const pmStartOf = (run) => run.pmStart;
+/**
+ * Index of the last run whose `coord` is ≤ `pos`, or `-1` when `pos` precedes the
+ * first run. The walk emits runs in document order and every run owns at least one
+ * position in each space, so both coordinates increase strictly across the list and
+ * the lookup bisects. Bulk conversion is what wants it: `readAnchorsUsv` converts
+ * once per anchor on every commit, and a scan would make that O(anchors × runs).
+ */
+function lastRunAtOrBefore(runs, pos, coord) {
+    let lo = 0;
+    let hi = runs.length - 1;
+    let found = -1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        if (coord(runs[mid]) <= pos) {
+            found = mid;
+            lo = mid + 1;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    return found;
+}
+/** USV content offset → PM position. */
+export function usvToPM(index, usvPos) {
+    const usv = clamp(usvPos, 0, index.usvEnd);
+    if (usv >= index.usvEnd)
+        return index.usvEnd === 0 ? index.firstContentStart : index.pmEndContent;
+    // The runs TILE the USV space from 0 (every text the walk appends pushes its run
+    // first), so below `usvEnd` the run at or before `usv` is the run that owns it.
+    const run = index.runs[lastRunAtOrBefore(index.runs, usv, usvStartOf)];
+    if (run.kind === 'text')
+        return run.pmStart + utf16OfCodePoints(run.s, usv - run.usvStart);
+    return run.pmStart; // nl / atom: the run's single owned position
+}
+/** PM position → USV content offset. */
+export function pmToUsv(index, pmPos) {
+    const i = lastRunAtOrBefore(index.runs, pmPos, pmStartOf);
+    if (i < 0)
+        return 0; // before the first run's PM position (or no runs at all)
+    const run = index.runs[i];
+    // PM coverage, unlike USV, has gaps no run owns (a rule's own token). A position
+    // in one is past every run that could answer it → the end of the content text.
+    if (pmPos >= runEndPm(run))
+        return index.usvEnd;
+    if (run.kind === 'text')
+        return run.usvStart + codePointsOfUtf16(run.s, pmPos - run.pmStart);
+    return run.usvStart;
+}
+// ── UTF-16 ↔ USV conversions within one text run ────────────────────────────
+/** UTF-16 length of the first `n` code points of `s`. */
+function utf16OfCodePoints(s, n) {
+    let cp = 0;
+    let i = 0;
+    while (cp < n && i < s.length) {
+        i += charUnitLen(s, i);
+        cp++;
+    }
+    return i;
+}
+/** Number of whole code points within the first `k` UTF-16 units of `s`. */
+function codePointsOfUtf16(s, k) {
+    let cp = 0;
+    let i = 0;
+    while (i < k && i < s.length) {
+        i += charUnitLen(s, i);
+        cp++;
+    }
+    return cp;
+}
+/** UTF-16 unit length (1 or 2) of the code point starting at `i`. */
+function charUnitLen(s, i) {
+    const code = s.charCodeAt(i);
+    if (code >= 0xd800 && code <= 0xdbff && i + 1 < s.length) {
+        const next = s.charCodeAt(i + 1);
+        if (next >= 0xdc00 && next <= 0xdfff)
+            return 2;
+    }
+    return 1;
+}
+function clamp(n, lo, hi) {
+    return n < lo ? lo : n > hi ? hi : n;
+}

package/dist/core/codec/prose.css

@@ -0,0 +1,458 @@
+/* ProseMirror's own base stylesheet is imported beside this one (`codec/index.ts`):
+   the structural rules a view needs to render at all: `white-space:
+   break-spaces`, `li { position: relative }` for list markers, the
+   hidden-selection and separator-image guards. It is imported whole; the rules are
+   interdependent and which ones a given schema needs is not visible from here.
+
+   What it does NOT carry is a block reset, so without the rules below every leaf
+   inherits the UA `p { margin: 1em 0 }` (32px of margin in a box drawn to hold one
+   line), which is enough on its own to make an inline richtext field twice the height
+   of the input beside it. The reset lives here rather than per component because every
+   prose leaf in the package mounts through the codec (a field, the body, an array
+   element) and picks it up without restating it, and a leaf that carries the
+   control recipe (`visual/ProseField.svelte`) can then match `.qm-input` by
+   construction instead of by a tuned `min-height`. The source view is NOT one of
+   them: it is a `<pre>` holding `textContent` (`source/view.ts`), outside
+   `.ProseMirror` and so outside every rule in this file.
+
+   It also carries hard-coded VALUES that answer to no rung: a `#8cf` node-selection
+   outline, twice, and the `-32px` placing a selected list item's. Retinted and
+   re-measured here rather than in `theme.css` because a layered rule loses to that
+   unlayered stylesheet: equal specificity and a later import is what wins. */
+.ProseMirror-selectednode {
+	outline: var(--_qm-ring-width) solid var(--_qm-accent);
+}
+/* Upstream's `-32px` is measured against the UA's 40px list indent, which the list
+   rule below replaces with a rung. The offset moves with it, or a selected item's
+   outline hangs into the margin by the difference. */
+li.ProseMirror-selectednode::after {
+	border: var(--_qm-ring-width) solid var(--_qm-accent);
+	left: calc(var(--_qm-space-4) * -1);
+}
+
+/* The GAP CURSOR (`prosemirror-gapcursor`, imported beside this file): a caret
+   between two blocks, where the document holds no text position for an ordinary one.
+   It is what a press beside an island lands, so it is drawn in the surface's ink
+   rather than the upstream sheet's `black`, which is the `#8cf` defect again. */
+.ProseMirror-gapcursor::after {
+	border-top-color: var(--_qm-ink);
+}
+
+/* Everything starts flush. Not a list of the block tags: the subtree is entirely
+   what the codec emits, a paragraph-only reset leaves headings and lists on UA
+   margins (two rhythms in one leaf), and an enumeration silently lags the schema:
+   `island_block` renders a bare `div` (`islands.ts`) and would match no such list. */
+.ProseMirror * {
+	margin: 0;
+}
+
+/* One rhythm between sibling blocks, in place of the UA's collapsed pair. Scoped by
+   PARENT rather than by tag, which is what keeps it true as the schema grows: the
+   four containers below are every node whose content is `block+` (`schema.ts`), so
+   their children are blocks by definition, whatever kinds exist. `ul`/`ol` are
+   deliberately absent: a run of list items is tight, and the gap before a list is
+   the list's, not each item's. */
+.ProseMirror > * + *,
+.ProseMirror :is(blockquote, li, [data-qm-unknown-container]) > * + * {
+	margin-top: var(--_qm-space-4);
+}
+
+/* A blockquote's UA indent was its only mark, and the reset above takes it. The rule
+   and the inset carry it instead: the same hairline every surface reads, so a quote
+   reads as set apart without a fill or a second box. */
+.ProseMirror blockquote {
+	padding-left: var(--_qm-space-3);
+	border-left: var(--_qm-border-width) solid var(--_qm-border);
+}
+
+/* ── The positive half ───────────────────────────────────────────────────────
+   What the reset leaves bare, and the whole of it: every mark and node `schema.ts`
+   emits, minus the four the UA already renders correctly (`strong`, `em`, `u`, `s`)
+   and the blockquote above.
+
+   Each rule answers to the REFERENCE QUILL rather than to a browser default or to a
+   web editor's chrome, because the leaf sits beside a live preview of the same
+   content. `usaf_memo` sets `raw` in a monospace face and adds nothing; it renders a
+   heading as a bold RUN-IN prepended to the following paragraph, with the level
+   never read; it gives a link no decoration at all. So a leaf shows that a span IS
+   code and a line IS a heading: never a prediction of the size paper will set it
+   at, which the package cannot know for a quill it has not seen.
+
+   Scoping is by TAG, and the schema does the rest: `h1`–`h6`, `hr` and the lists
+   cannot exist under the inline schema, so no rule for them can land on a `subject`
+   field however that field is mounted. The two MARKS are the exception: `code` and
+   `link` are in both schemas, and a `plaintext` leaf strips them at DECODE while
+   mounting a schema that still carries them, so a paste can put either in one. The
+   rules stand there too, and correctly: they say the leaf holds code, or a link,
+   which is exactly what it then holds.
+
+   `visual/TipsCard.svelte` restates the two mark rules by hand, over the same
+   `toDOM` output injected outside any view. */
+
+/* Code is a FACE: no chip, no fill, no inset, no size step. The blockquote above
+   already argues the general form: a span reads as set apart without a fill or a
+   second box, on the one surface in the card with no edge of its own. A chip has
+   nowhere to come from in any case: the card is
+   `--_qm-surface-raised` and the only rung over it is `--_qm-surface-hover`, the
+   hover lane, so a chip at rest would read as a hovered button.
+
+   ONE selector for the mark and the block: a `code_block` renders `pre > code`
+   (`schema.ts`), so every character of it is inside a `code` element and the `pre`
+   needs no face of its own. `pre` takes no `overflow-x` either, because there is no
+   overflow: ProseMirror's own stylesheet sets `white-space: pre-wrap` there, so a
+   long line wraps. A scroller means overriding that to `pre` inside an editable
+   `code` textblock, which is an editing change, not a display rule. */
+.ProseMirror code {
+	font-family: var(--_qm-font-mono);
+}
+
+/* A link takes the surface's ink (the UA's blue is the `#8cf` defect again) and a
+   DOTTED underline. Dotted rather than solid because `underline` is a mark in the
+   same schema, and a solid rule renders an authored `<u>` and a link identically in a
+   paragraph that can hold both. An underline at all, where the tips card's link takes
+   none, because this leaf is EDITABLE: the `href` is otherwise imperceptible, so
+   removing the rule loses an answer rather than ornament. No hue:
+   `--_qm-accent` already means focus, and a body of accent-coloured links collides
+   with the ring and with the correlation wash. */
+.ProseMirror a {
+	color: inherit;
+	text-decoration: underline dotted;
+}
+
+/* The UA draws a rule as an inset border in the browser's own grey. It is the same
+   hairline every other surface reads instead. Spacing is already the sibling gap's,
+   above and below, so the rule carries none of its own. */
+.ProseMirror hr {
+	border: none;
+	border-top: var(--_qm-border-width) solid var(--_qm-border);
+}
+
+/* The UA's 40px list indent is the one box the reset above does not take (it is
+   padding, not margin), and it is a length nothing chose. A rung replaces it. The
+   MARKERS stay the UA's: `disc` and `decimal` are already right, and restating them
+   buys nothing. Per-item spacing is untouched, which is the point of putting this on
+   the list rather than the item: the sibling-gap rule deliberately omits `ul`/`ol`,
+   and padding on the container cannot reintroduce what it withholds. */
+.ProseMirror :is(ul, ol) {
+	padding-left: var(--_qm-space-4);
+}
+
+/* Six levels, one weight, no size step. The quill reads no level at all, so a size
+   ramp here would be the editor predicting a hierarchy the paper does not set; the
+   level stays in the model, which is where the codec round-trips it. It is also all
+   the ramp could carry: `--_qm-text-title` is one 1.125 step over the body, the
+   body sits on `--_qm-text-body` by decision, and leading alone is what separates
+   paper from chrome. Six levels do not fit in one step, and
+   minting five more is the drift the scale exists to prevent. */
+.ProseMirror :is(h1, h2, h3, h4, h5, h6) {
+	font-size: inherit;
+	font-weight: var(--_qm-weight-label);
+}
+
+/* ── The table island ────────────────────────────────────────────────────────
+
+   The one construct in this file with CHROME in it. The rest of the stylesheet
+   states what a block is and lets paper set its size; a table island is edited
+   through controls that do not print, so it also has a recede ladder, a target
+   floor and a reveal. Those live here rather than in `visual/controls.css` for the
+   same reason the NodeView is vanilla: the island is inside the leaf, and the leaf
+   is the codec's. What it does NOT restate is the surface's dials: every value
+   below is a `--_qm-*` rung, so the island retints with everything else.
+
+   THE CHROME IS IN NO TRACK. Every control is absolutely positioned inside a real
+   data cell, hanging into a band the scroller carries as PADDING. So the grid holds
+   the box a paragraph would, the accessibility tree is the data's shape, and a
+   handle still lines up with its line by CONSTRUCTION rather than by a measured
+   overlay: it is inside the cell it names. */
+
+/* The band, and the whole of what it costs. `padding` opens it; the island's
+   negative `margin` spends the card's own inset buying it back, so the grid sits one
+   inset from the prose edge instead of a tap target plus one.
+
+   `margin-top: 0` overrides the sibling-gap rule rather than going negative: the band
+   ABSORBS the gap. A negative top margin would hang the band over the block above,
+   and an `opacity: 0` control is still hit-tested, so it would take that block's last
+   presses. */
+.qm-table-island {
+	margin-top: 0;
+	margin-left: calc(var(--_qm-space-3) * -1);
+}
+.qm-table-scroller {
+	/* The one horizontally scrolling box in a leaf: a table is as wide as its
+	   columns, and a wide one must not push the card's own layout. `overflow-y` is
+	   `hidden` rather than left alone, because a non-`visible` axis computes the other
+	   to `auto` and a table has nothing to scroll vertically. */
+	position: relative;
+	overflow-x: auto;
+	overflow-y: hidden;
+	padding: var(--_qm-tap-min) 0 0 var(--_qm-tap-min);
+	width: max-content;
+	max-width: 100%;
+}
+.qm-table {
+	border-collapse: separate;
+	border-spacing: 0;
+	border: var(--_qm-border-width) solid var(--_qm-border);
+	border-radius: var(--_qm-radius-inner);
+}
+/* Two tiers of rule, because a table draws two different things. The FRAME and the
+   header's rule are structure and keep the full hairline; the lines between cells are
+   rhythm and drop to the faint rung, so the grid reads as one object with divisions
+   rather than as a stack of boxes. `separate` with zero spacing rather than
+   `collapse`: a collapsed border cannot be rounded, and the two tiers would fight
+   over which one wins an edge. */
+.qm-table-cell {
+	position: relative;
+	border-right: var(--_qm-border-width) solid var(--_qm-border-faint);
+	border-bottom: var(--_qm-border-width) solid var(--_qm-border-faint);
+	padding: var(--_qm-space) var(--_qm-space-2);
+	vertical-align: top;
+	font-weight: inherit;
+	text-align: inherit;
+}
+.qm-table tr > .qm-table-cell:last-child {
+	border-right: none;
+}
+.qm-table tbody tr:last-child > .qm-table-cell {
+	border-bottom: none;
+}
+/* The header row is the ONE weight distinction the island draws: `header` is a
+   separate field in the model rather than a flag on a row, so the surface says so.
+   It takes a tone with it, which is the same elevation move the cards make: a rung,
+   never a shadow. The rest of a table's type is paper's. */
+.qm-table-header-row .qm-table-cell {
+	font-weight: var(--_qm-weight-label);
+	background: var(--_qm-surface-raised);
+	border-bottom: var(--_qm-border-width) solid var(--_qm-border);
+}
+/* A cell holds a whole nested view. Its measure floor keeps an empty table from
+   collapsing to a row of hairlines with nothing to aim at, and the caret is the
+   focus indicator here exactly as it is in the leaf: no ring.
+
+   The HEIGHT floor is one line box, named as size times leading so both factors move
+   with the type ramp (`.qm-prose-block` states the same expression for three). An
+   empty row is then the height it will be once typed, so the first keystroke changes
+   no geometry. */
+.qm-table-cell-host {
+	min-width: 4rem;
+	min-height: calc(var(--_qm-text-body) * var(--_qm-leading-body));
+}
+.qm-table-cell-host .ProseMirror {
+	outline: none;
+}
+/* A selected island takes the node outline every leaf block does
+   (`.ProseMirror-selectednode`, above), and that is the state the corner and Escape
+   leave a line FOR: the caret is out, the island is what is selected, and Backspace
+   deletes it. A caret inside a cell is not that state and does not paint it. */
+
+/* A SELECTED LINE, washed across its cells: what Backspace deletes and Alt+arrow
+   moves. The hover rung, because it makes a hover's claim (this line, the one the next
+   command is about) held rather than passing. */
+.qm-table-cell.qm-table-line {
+	background: var(--_qm-surface-hover);
+}
+
+/* Every control in the band is a flat centred button hung out of flow; what differs
+   is where it hangs and what it draws. */
+:is(.qm-table-handle, .qm-table-seam, .qm-table-align-item) {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	border: none;
+	background: none;
+	cursor: pointer;
+}
+:is(.qm-table-seam, .qm-table-align-item) svg {
+	width: var(--_qm-glyph-control);
+	height: var(--_qm-glyph-control);
+}
+
+/* ONE control per line, and it is a bar rather than a glyph: what a handle acts on
+   is the row or column it sits against, and position says that better than an icon
+   would.
+
+   The TARGET is the band and the MARK is drawn small inside it, which is the rule
+   the tips card's dots already state: the handle spans its line on one axis and the
+   tap minimum on the other, and the bar in the middle of it is 3px. A handle sized to
+   the bar would be a 3px target on a control a pointer has to find. */
+.qm-table-handle {
+	position: absolute;
+	padding: var(--_qm-space-half);
+	/* The pointer owns this gesture, not the page's scroll: a handle drags. */
+	touch-action: none;
+}
+.qm-table-handle[data-axis='column'] {
+	inset-inline: 0;
+	bottom: 100%;
+	height: var(--_qm-tap-min);
+}
+.qm-table-handle[data-axis='row'] {
+	inset-block: 0;
+	right: 100%;
+	width: var(--_qm-tap-min);
+}
+.qm-table-handle-bar {
+	display: block;
+	border-radius: var(--_qm-radius-pill);
+	background: var(--_qm-border);
+}
+.qm-table-handle[data-axis='column'] .qm-table-handle-bar {
+	width: 100%;
+	height: 0.1875rem;
+}
+.qm-table-handle[data-axis='row'] .qm-table-handle-bar {
+	width: 0.1875rem;
+	height: 100%;
+	min-height: 0.75rem;
+}
+/* A selected handle carries the line's ink, so the bar and the wash say the same
+   thing at both ends of the gesture. */
+.qm-table-handle[aria-pressed='true'] .qm-table-handle-bar {
+	background: var(--_qm-ink-label);
+}
+
+/* The corner is the ISLAND's handle: the grid origin, where the two bands converge,
+   and the one gesture that selects the whole table. Its mark is a square because what
+   it acts on is the rectangle and not a line of it. */
+.qm-table-corner-handle {
+	right: 100%;
+	bottom: 100%;
+	width: var(--_qm-tap-min);
+	height: var(--_qm-tap-min);
+}
+.qm-table-corner-mark {
+	display: block;
+	width: 0.4375rem;
+	height: 0.4375rem;
+	border-radius: var(--_qm-radius-pill);
+	background: var(--_qm-border);
+}
+
+/* A SEAM: the boundary between two lines, and the whole of how a table grows. One per
+   boundary including the leading and trailing ones, so an append and an interior
+   insert are one gesture at different places.
+
+   It sits OVER the handles in the band, and it is narrow, so the two share the band
+   without a dead zone: the handle owns the line's length and the seam owns its ends. */
+.qm-table-seam {
+	position: absolute;
+	z-index: 1;
+	width: var(--_qm-tap-min);
+	height: var(--_qm-tap-min);
+	border-radius: var(--_qm-radius-pill);
+	color: var(--_qm-accent);
+}
+.qm-table-seam[data-axis='column'] {
+	bottom: 100%;
+	left: calc(var(--_qm-tap-min) / -2);
+}
+/* The TRAILING seams sit flush inside their edge rather than centred on it: the last
+   boundary is the grid's own edge, and a seam centred on it would hang half outside
+   the scroller, where the padding does not reach and the clip does, making the append
+   affordance the one control that could not be pressed. */
+.qm-table-seam[data-axis='column'][data-side='trail'] {
+	left: auto;
+	right: 0;
+}
+.qm-table-seam[data-axis='row'] {
+	right: 100%;
+	top: calc(var(--_qm-tap-min) / -2);
+}
+.qm-table-seam[data-axis='row'][data-side='trail'] {
+	top: auto;
+	bottom: 0;
+}
+
+/* The alignment cluster: the one op with no gesture, so the one surface the chrome
+   still raises. It rides the column's SELECTION rather than a hover, so it costs
+   nothing at rest, and it sits in the band beside the handle rather than portalled:
+   four glyphs in a row is not a list to read. */
+.qm-table-align {
+	position: absolute;
+	z-index: 2;
+	display: flex;
+	bottom: 100%;
+	left: 0;
+	height: var(--_qm-tap-min);
+	background: var(--_qm-surface-raised);
+	border: var(--_qm-border-width) solid var(--_qm-border);
+	border-radius: var(--_qm-radius-pill);
+}
+/* The LAST column anchors right instead: a cluster is wider than a narrow column, and
+   one hung off the right edge would be the only chrome the scroller could clip. */
+.qm-table-cell:last-child .qm-table-align {
+	left: auto;
+	right: 0;
+}
+.qm-table-align-item {
+	width: var(--_qm-tap-min);
+	height: 100%;
+	padding: 0;
+	border-radius: var(--_qm-radius-pill);
+	color: var(--_qm-ink-label);
+}
+.qm-table-align-item:hover {
+	background: var(--_qm-surface-hover);
+	color: var(--_qm-ink);
+}
+.qm-table-align-item[aria-pressed='true'] {
+	color: var(--_qm-accent);
+}
+
+/* Pointer OR focus, the card stack's rule unchanged: opacity rather than absence, so
+   the controls stay in the tab order, and `:focus-within` on the ISLAND, so a caret
+   in a cell holds the reveal as a focused control does.
+
+   The reveal is per LINE: the island's hover arms the band, and `qm-hot` (the line the
+   pointer is actually over) is what reaches the idle rung, so a hover answers about
+   one line rather than about every one at once. */
+.qm-table-handle,
+.qm-table-seam {
+	opacity: 0;
+	transition: opacity var(--_qm-duration-fast) var(--_qm-ease-reverse);
+}
+.qm-table-island:is(:hover, :focus-within)
+	:is(.qm-table-handle.qm-hot, .qm-table-corner-handle, .qm-table-seam) {
+	opacity: var(--_qm-opacity-idle);
+}
+.qm-table-handle:hover,
+.qm-table-handle:focus-visible,
+.qm-table-handle[aria-pressed='true'],
+.qm-table-seam:hover,
+.qm-table-seam:focus-visible {
+	opacity: 1;
+}
+
+/* The ring, on the chrome and nowhere else in this file. A prose leaf's focus
+   indicator is its CARET and a cell's is too, so the outline is dropped there; a
+   handle is a button, and a button that takes focus to hold a selection has to show
+   it. Declared here rather than reached for as `.qm-focus-ring`: that recipe is the
+   visual tier's stylesheet, and the island is inside the leaf, which is the codec's. */
+.qm-table-handle:focus-visible,
+.qm-table-seam:focus-visible,
+.qm-table-align-item:focus-visible {
+	outline: var(--_qm-ring-focus);
+	outline-offset: var(--_qm-ring-offset);
+}
+
+/* A DRAG in flight. The lifted line reads as picked up by TONE, never a shadow:
+   elevation is a surface rung here, which says the same thing at both poles. The drop
+   rule is the accent, the surface's one saturated ink, spent where a change is about
+   to land. */
+.qm-table-dragging .qm-table-cell.qm-table-lifted {
+	background: var(--_qm-surface-raised);
+	opacity: var(--_qm-opacity-muted);
+}
+.qm-table-drop {
+	position: absolute;
+	z-index: 3;
+	background: var(--_qm-accent);
+	border-radius: var(--_qm-radius-pill);
+	pointer-events: none;
+}
+.qm-table-drop[data-axis='row'] {
+	height: var(--_qm-ring-width);
+}
+.qm-table-drop[data-axis='column'] {
+	width: var(--_qm-ring-width);
+}

package/dist/core/codec/reconcile.d.ts

@@ -0,0 +1,26 @@
+import type { Content } from '@quillmark/wasm';
+/** Tracks the last content the codec knows for a leaf, to distinguish foreign edits. */
+export interface Reconciler {
+    /** Should `current` (a fresh read of the leaf) trigger a re-hydrate? */
+    shouldRehydrate(current: Content): boolean;
+    /** Record `rt` as the codec's known state (after its own edit or a re-hydrate). */
+    commit(rt: Content): void;
+    /** The last known content. Seeded at construction and only ever replaced, so it
+     * is never absent: the field reads it directly rather than through a cast. */
+    readonly last: Content;
+}
+/** A reconciler seeded with the leaf's initial content. */
+export declare function createReconciler(initial: Content): Reconciler;
+/**
+ * Canonical content equality: a structural deep-equal, key-order-insensitive so a
+ * WASM read (`doc.get`) and a codec projection (`pmToContent`) compare by value.
+ * This is the per-field twin of `Document.equals`.
+ */
+export declare function contentEqual(a: Content, b: Content): boolean;
+/**
+ * The same structural equality over any boundary value: what the island diff
+ * compares two `ContentIsland` entries with (`encode.ts`). Key order is the reason
+ * it is not `JSON.stringify`: an island's opaque `props` crosses from a WASM read
+ * on one side and a PM node attribute on the other.
+ */
+export declare function valueEqual(a: unknown, b: unknown): boolean;

package/dist/core/codec/reconcile.js

@@ -0,0 +1,64 @@
+/** A reconciler seeded with the leaf's initial content. */
+export function createReconciler(initial) {
+    let known = initial;
+    return {
+        shouldRehydrate(current) {
+            return !contentEqual(current, known);
+        },
+        commit(rt) {
+            known = rt;
+        },
+        get last() {
+            return known;
+        }
+    };
+}
+/**
+ * Canonical content equality: a structural deep-equal, key-order-insensitive so a
+ * WASM read (`doc.get`) and a codec projection (`pmToContent`) compare by value.
+ * This is the per-field twin of `Document.equals`.
+ */
+export function contentEqual(a, b) {
+    return deepEqual(a, b);
+}
+/**
+ * The same structural equality over any boundary value: what the island diff
+ * compares two `ContentIsland` entries with (`encode.ts`). Key order is the reason
+ * it is not `JSON.stringify`: an island's opaque `props` crosses from a WASM read
+ * on one side and a PM node attribute on the other.
+ */
+export function valueEqual(a, b) {
+    return deepEqual(a, b);
+}
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (a === null || b === null)
+        return a === b;
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++)
+            if (!deepEqual(a[i], b[i]))
+                return false;
+        return true;
+    }
+    if (typeof a === 'object' && typeof b === 'object') {
+        const ao = a;
+        const bo = b;
+        const ak = Object.keys(ao);
+        const bk = Object.keys(bo);
+        if (ak.length !== bk.length)
+            return false;
+        for (const k of ak) {
+            if (!Object.prototype.hasOwnProperty.call(bo, k))
+                return false;
+            if (!deepEqual(ao[k], bo[k]))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}

package/dist/core/codec/schema.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from 'prosemirror-model';
+/** The full field schema: every block kind, container, mark, and island. */
+export declare const blockSchema: Schema<string, string>;
+/**
+ * The constrained inline schema: one paragraph, no block splitting, no
+ * containers, no islands. `doc: "paragraph"` (exactly one child) is what makes an
+ * Enter a no-op at the model level: there is no second block for a split to land.
+ * Marks are present; `plaintext` fields strip them at decode and mount no
+ * mark input (a schema-level distinction the field draws, per CODEC §Inline mode).
+ */
+export declare const inlineSchema: Schema<"text" | "doc" | "paragraph", string>;
+/** True for the constrained inline schema (no block containers); decode branches on it. */
+export declare function isInlineSchema(schema: Schema): boolean;