@quillmark/svelte 0.11.0 → 0.13.0

package/dist/core/codec/islands.js

@@ -1,6 +1,6 @@
-// Islands: the `U+FFFC` slot + `ContentIsland` entry ↔ a PM leaf node. A slot
-// inside a `para` line is an inline island (an image); an `island`-kind line is a
-// block island (a table). The node carries `id`, `islandType` and `props` verbatim.
+// Islands: the `U+FFFC` slot + `ContentIsland` entry ↔ a PM leaf node. Every slot sits
+// in a `para` line; the island's type says which node it is, a `table` a block alone on
+// its line and an `image` inline. The node carries `id`, `islandType` and `props` verbatim.
 //
 // A props-aware consumer reads the shape straight off the boundary:
 // `ContentIsland.props` is the typed union (`TableProps` for `table`,
@@ -13,22 +13,17 @@ import { Plugin } from 'prosemirror-state';
 import { storableUrl } from './urls.js';
 /** The `U+FFFC` object-replacement char that occupies one island slot in `text`. */
 export const ISLAND_SLOT = '';
-// The four island node attributes carry the content entry verbatim: `id` is the
-// stable identity (rebases like an anchor), `islandType` the discriminator, `props`
-// the payload the codec preserves byte-for-byte across a round-trip, and `loss` how
-// faithfully markdown can carry it. `islandType` and `props` declare no default: a
-// node standing for an island holds one, so the pair is supplied at every `create`.
-// `loss` is authored, not derived: `applyChange` stores the class an island op gives
-// it and re-derives nothing, so an entry that did not carry its own would promote a
-// degraded table to lossless on the first cell edit. Its default is the weakest
-// claim; decode always supplies the stored value.
+// The three island node attributes carry the content entry verbatim: `id` is the
+// stable identity (rebases like an anchor), `islandType` the discriminator, and `props`
+// the payload the codec preserves byte-for-byte across a round-trip. `islandType` and
+// `props` declare no default: a node standing for an island holds one, so the pair is
+// supplied at every `create`.
 const islandAttrs = {
     id: { default: '' },
     islandType: {},
-    props: {},
-    loss: { default: 'unrepresentable' }
+    props: {}
 };
-// All four attributes cross the DOM: a copy and a paste inside one body run the document
+// All three attributes cross the DOM: a copy and a paste inside one body run the document
 // through `toDOM`/`parseDOM` (CODEC §"Markdown at the edges"), and an island is a leaf
 // whose tags alone say only `[table]`. `props` crosses as JSON, the form the payload has
 // at the boundary. The names are `data-qm-*` like every other carrier's, and the id is
@@ -39,21 +34,18 @@ function islandDOM(node) {
     return {
         'data-qm-island': node.attrs.islandType,
         'data-qm-island-id': node.attrs.id,
-        'data-qm-island-loss': node.attrs.loss,
         'data-qm-island-props': JSON.stringify(node.attrs.props ?? null)
     };
 }
-// The two closed sets an element claims a value from. A `Record` over the boundary's own
-// union rather than a literal check, so a member added upstream is a missing key here
-// rather than a silent refusal at the one door with no decode behind it.
-/** The island types the content model names. */
-const ISLAND_TYPES = { table: true, image: true };
-/** The loss classes it names, weakest last: an unrecognized claim takes that one. */
-const LOSS_CLASSES = {
-    lossless: true,
-    degraded: true,
-    unrepresentable: true
-};
+/** The island types the content model names, each with whether its markup is a block,
+ *  which decides the node its slot decodes to. A `Record` over the boundary's own union,
+ *  so a member added upstream is a missing key here rather than a silent refusal at the
+ *  one door with no decode behind it. */
+const BLOCK_ISLAND = { table: true, image: false };
+/** Whether an island of `type` is block markup: a `table` stands alone on its line. */
+export function isBlockIsland(type) {
+    return BLOCK_ISLAND[type];
+}
 /** An island node's attributes off that DOM, or `false` where the id is absent or the
  *  type is one the content vocabulary does not name — a name no read produces and no
  *  write takes, so the element's text arrives as text. A `props` that is not the JSON
@@ -64,7 +56,7 @@ function islandAttrsFromDOM(el) {
     const id = el.getAttribute('data-qm-island-id');
     // Asserted off an untrusted attribute and checked against the set on the next line.
     const type = el.getAttribute('data-qm-island');
-    if (id == null || type == null || !ISLAND_TYPES[type])
+    if (id == null || type == null || !Object.hasOwn(BLOCK_ISLAND, type))
         return false;
     const raw = el.getAttribute('data-qm-island-props');
     let props = null;
@@ -74,13 +66,7 @@ function islandAttrsFromDOM(el) {
     catch {
         props = null;
     }
-    return { id, islandType: type, props: storableProps(type, props), loss: lossFromDOM(el) };
-}
-/** The `loss` an element claims, or the weakest class for a claim outside the set:
- *  an under-claim keeps a degraded island from re-crossing as a lossless one. */
-function lossFromDOM(el) {
-    const raw = el.getAttribute('data-qm-island-loss');
-    return raw != null && LOSS_CLASSES[raw] ? raw : 'unrepresentable';
+    return { id, islandType: type, props: storableProps(type, props) };
 }
 /** `props` with the one key the authored lane refuses made storable: an `image`'s `url`
  *  carrying a line ending, which `IslandOp` and `overwrite` throw on. The rest crosses
@@ -91,7 +77,7 @@ function storableProps(type, props) {
     const url = props.url;
     return typeof url === 'string' ? { ...props, url: storableUrl(url) } : props;
 }
-/** Block island node (a table): one `island`-kind content line. Atom, unselectable content. */
+/** Block island node (a table): a `U+FFFC` slot alone on its `para` line. Atom, unselectable content. */
 export const islandBlockSpec = {
     group: 'block',
     atom: true,
@@ -119,8 +105,7 @@ export function islandEntryFromNode(attrs) {
     return {
         id: attrs.id,
         type: attrs.islandType,
-        props: attrs.props,
-        loss: attrs.loss
+        props: attrs.props
     };
 }
 /** The `TableProps` shape, over a value that reached the node off the DOM rather than

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

@@ -1,9 +1,10 @@
 import type { Schema } from 'prosemirror-model';
 import type { Command } from 'prosemirror-state';
-/** The block-schema body's structural keys: `{}` for the inline/plaintext schemas,
- * whose leaves declare neither lists nor code blocks. The argument list is the
- * precedence order VISUAL_EDITOR §Chrome states, so a new link is one more argument
- * at its place in that order rather than a nesting to read inside out.
+/** A multi-block leaf's structural keys, each link binding only what its schema
+ * declares: over `plainSchema`, which holds neither lists nor code blocks nor islands,
+ * the block link and the break link alone. The argument list is the precedence order
+ * VISUAL_EDITOR §Chrome states, so a new link is one more argument at its place in that
+ * order rather than a nesting to read inside out.
  *
  * The slash menu is innermost of the three, and it is conditional rather than
  * schema-gated: the keys exist only where a menu can be drawn (`slash`), because Enter

package/dist/core/codec/keymap.js

@@ -17,10 +17,11 @@ function chainKeymaps(...maps) {
     }
     return out;
 }
-/** The block-schema body's structural keys: `{}` for the inline/plaintext schemas,
- * whose leaves declare neither lists nor code blocks. The argument list is the
- * precedence order VISUAL_EDITOR §Chrome states, so a new link is one more argument
- * at its place in that order rather than a nesting to read inside out.
+/** A multi-block leaf's structural keys, each link binding only what its schema
+ * declares: over `plainSchema`, which holds neither lists nor code blocks nor islands,
+ * the block link and the break link alone. The argument list is the precedence order
+ * VISUAL_EDITOR §Chrome states, so a new link is one more argument at its place in that
+ * order rather than a nesting to read inside out.
  *
  * The slash menu is innermost of the three, and it is conditional rather than
  * schema-gated: the keys exist only where a menu can be drawn (`slash`), because Enter

package/dist/core/codec/prose.css

@@ -71,6 +71,14 @@ li.ProseMirror-selectednode::after {
 	margin-top: var(--_qm-space-3);
 }
 
+/* A plain leaf's paragraph is a line of literal text (`schema.ts` §`plainSchema`), and
+   a boundary between two stores the one `\n` a hard break does. So no rhythm: a gap
+   would draw a blank line the value does not hold, and the two spellings of one string
+   would read apart. */
+.ProseMirror > [data-qm-line] + [data-qm-line] {
+	margin-top: 0;
+}
+
 /* 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. */
@@ -187,6 +195,40 @@ li.ProseMirror-selectednode::after {
 	font-weight: var(--_qm-weight-strong);
 }
 
+/* The empty leaf's ghost (`field.ts`, `ghostPlugin`): a node decoration's data
+   attributes, so the text stays out of the document. At the rung every control's
+   placeholder takes; the italic is what a leaf with no written neighbour has instead
+   of the step to `ink`.
+
+   After the empty line rather than before it, and pulled up one line box onto it: the
+   caret keeps the start of that line, and a ghost's lines past the first grow the
+   leaf rather than hang over what follows it. A block leaf's ghost wraps and keeps the
+   breaks it was written with, a `body.example` being a document's worth; an inline
+   leaf's keeps to the one line the leaf is. The example is drawn at rest where there
+   is no placeholder, and stands in for the placeholder while the leaf holds the focus.
+
+   Drawn only where there is text to draw: an empty box pulled up a line would take
+   the empty line with it. */
+.ProseMirror .qm-prose-placeholder[data-placeholder]::after,
+.ProseMirror .qm-prose-placeholder[data-example]::after {
+	content: attr(data-placeholder);
+	display: block;
+	margin-top: -1lh;
+	white-space: pre-line;
+	color: var(--_qm-ink-label);
+	font-style: italic;
+	pointer-events: none;
+}
+.ProseMirror .qm-prose-placeholder[data-example]:not([data-placeholder])::after,
+.ProseMirror-focused .qm-prose-placeholder[data-example]::after {
+	content: attr(data-example);
+}
+.ProseMirror .qm-prose-placeholder.qm-prose-placeholder-line::after {
+	white-space: nowrap;
+	overflow: hidden;
+	text-overflow: ellipsis;
+}
+
 /* ── The table island ────────────────────────────────────────────────────────
 
    The one construct in this file with chrome in it. The rest of the stylesheet

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

@@ -7,8 +7,8 @@ export declare const blockSchema: Schema<string, string>;
  *  a table cell, which is the same content unit). */
 export declare const inlineSchema: Schema<string, string>;
 /**
- * The inline schema with no mark types at all: a `plaintext` field, whose value is
- * literal text the boundary refuses to coerce back once it carries a mark.
+ * The inline schema with no mark types at all: a `plaintext(inline)` field, whose
+ * value is literal text the boundary refuses to coerce back once it carries a mark.
  *
  * Declaring none is what makes that structural rather than a rule each path
  * restates: `toggleMark` has no type to apply, the mark input rules build nothing,
@@ -16,11 +16,30 @@ export declare const inlineSchema: Schema<string, string>;
  * carrying (CODEC §Inline mode).
  */
 export declare const plaintextSchema: Schema<string, never>;
-/** Whether `schema` can carry formatting at all: false for {@link plaintextSchema}
- *  alone. What a mark command asks before it offers itself. */
+/**
+ * A `plaintext` field without `inline`: paragraphs and hard breaks, no marks, no
+ * islands, no containers, which is the shape `Content::is_plain` admits. Mark-free
+ * for the reason {@link plaintextSchema} is.
+ *
+ * A paragraph and a break both store one `\n`, so a paragraph here is a line and
+ * says so (`data-qm-line`): `prose.css` draws a run of them at the leading, and a
+ * boundary reads as the one line down that a break does.
+ */
+export declare const plainSchema: Schema<"text" | "doc" | "paragraph" | "hard_break", never>;
+/** The schema a leaf of the declared type mounts: `inline` narrows either type to one
+ *  textblock, and `plaintext` takes its marks away. */
+export declare function leafSchema(opts: {
+    plaintext?: boolean;
+    inline?: boolean;
+}): Schema;
+/** Whether `schema` can carry formatting at all: false for the two plaintext schemas.
+ *  What a mark command asks before it offers itself. */
 export declare function hasMarks(schema: Schema): boolean;
-/** True for the constrained inline schema (no block containers); decode branches on it. */
+/** True for the one-line schemas, which declare no `hard_break`; decode branches on it. */
 export declare function isInlineSchema(schema: Schema): boolean;
+/** True for {@link blockSchema}, the one holding blocks past the paragraph: what a
+ *  leaf's island, gap-cursor and slash machinery mounts on. */
+export declare function isBlockSchema(schema: Schema): boolean;
 /** Whether `type` can hold a within-block line break, which a heading cannot (§`heading`).
  *  What a `\n` landing in a textblock is rewritten to turns on it (`breaks.ts`), and so
  *  does what decode puts between a block's continued segments. */

package/dist/core/codec/schema.js

@@ -4,9 +4,10 @@
 // Each set is closed upstream, so the schema names its whole vocabulary and carries
 // nothing inert. `blockSchema` is the full field; `inlineSchema` is the constrained
 // single-textblock form for `richtext(inline)` (one paragraph, no block split, no
-// containers, no islands) and `plaintextSchema` is that one without marks: same
-// decode/lower/position machinery, narrower shape. Anchors are not marks here
-// (decorations).
+// containers, no islands) and `plaintextSchema` is that one without marks, for
+// `plaintext(inline)`; `plainSchema` is a `plaintext` field without `inline`,
+// paragraphs and hard breaks and nothing else. Same decode/lower/position machinery,
+// narrower shapes. Anchors are not marks here (decorations).
 //
 // `toDOM` and `parseDOM` are one tier, not two halves of a rendering: a copy and a
 // paste inside one body run the whole document through them (CODEC §"Markdown at the
@@ -188,8 +189,8 @@ const inlineNodes = {
  *  a table cell, which is the same content unit). */
 export const inlineSchema = new Schema({ nodes: inlineNodes, marks });
 /**
- * The inline schema with no mark types at all: a `plaintext` field, whose value is
- * literal text the boundary refuses to coerce back once it carries a mark.
+ * The inline schema with no mark types at all: a `plaintext(inline)` field, whose
+ * value is literal text the boundary refuses to coerce back once it carries a mark.
  *
  * Declaring none is what makes that structural rather than a rule each path
  * restates: `toggleMark` has no type to apply, the mark input rules build nothing,
@@ -197,14 +198,44 @@ export const inlineSchema = new Schema({ nodes: inlineNodes, marks });
  * carrying (CODEC §Inline mode).
  */
 export const plaintextSchema = new Schema({ nodes: inlineNodes, marks: {} });
-/** Whether `schema` can carry formatting at all: false for {@link plaintextSchema}
- *  alone. What a mark command asks before it offers itself. */
+/**
+ * A `plaintext` field without `inline`: paragraphs and hard breaks, no marks, no
+ * islands, no containers, which is the shape `Content::is_plain` admits. Mark-free
+ * for the reason {@link plaintextSchema} is.
+ *
+ * A paragraph and a break both store one `\n`, so a paragraph here is a line and
+ * says so (`data-qm-line`): `prose.css` draws a run of them at the leading, and a
+ * boundary reads as the one line down that a break does.
+ */
+export const plainSchema = new Schema({
+    nodes: {
+        doc: { content: 'paragraph+' },
+        paragraph: { ...blockNodes.paragraph, toDOM: () => ['p', { 'data-qm-line': '' }, 0] },
+        text: inlineLeafNodes.text,
+        hard_break: inlineLeafNodes.hard_break
+    },
+    marks: {}
+});
+/** The schema a leaf of the declared type mounts: `inline` narrows either type to one
+ *  textblock, and `plaintext` takes its marks away. */
+export function leafSchema(opts) {
+    if (opts.plaintext)
+        return opts.inline ? plaintextSchema : plainSchema;
+    return opts.inline ? inlineSchema : blockSchema;
+}
+/** Whether `schema` can carry formatting at all: false for the two plaintext schemas.
+ *  What a mark command asks before it offers itself. */
 export function hasMarks(schema) {
     return Object.keys(schema.marks).length > 0;
 }
-/** True for the constrained inline schema (no block containers); decode branches on it. */
+/** True for the one-line schemas, which declare no `hard_break`; decode branches on it. */
 export function isInlineSchema(schema) {
-    return !schema.nodes.blockquote;
+    return !schema.nodes.hard_break;
+}
+/** True for {@link blockSchema}, the one holding blocks past the paragraph: what a
+ *  leaf's island, gap-cursor and slash machinery mounts on. */
+export function isBlockSchema(schema) {
+    return !!schema.nodes.blockquote;
 }
 /** Whether `type` can hold a within-block line break, which a heading cannot (§`heading`).
  *  What a `\n` landing in a textblock is rewritten to turns on it (`breaks.ts`), and so

package/dist/core/errors.d.ts

@@ -11,8 +11,9 @@ export type EditorErrorCode =
  *  the whole projection instead, so the store is correct and this field's
  *  identity anchors were paid. */
  | 'commit-fallback'
-/** The overwrite fallback also failed: the optimistic PM state stands and the
- *  store is stale for this field. The one code here that leaves damage. */
+/** The overwrite fallback also failed, or the typed writer refused a `plaintext`
+ *  leaf's text: the optimistic PM state stands and the store is stale for this
+ *  field. The one code here that leaves damage. */
  | 'commit-lost'
 /** A card operation (add, move, remove, retype) that threw. The document is
  *  unchanged; the boundary's mutators are transactional. */

package/dist/core/rungs.d.ts

@@ -0,0 +1,8 @@
+/** The element the scale is declared on, for `node`: its root, or `node` where it stands
+ *  outside one (a detached surface, a consumer's own mount). */
+export declare function rungStyle(node: Element): CSSStyleDeclaration;
+/** A duration rung off `style`, in ms; `undefined` where the derivation is out of reach
+ *  (an unstyled root, or jsdom, where `getComputedStyle` reports custom properties as
+ *  empty). No rung, no motion: a fallback here would be the scale restated in the one
+ *  place `check:style` cannot read. */
+export declare function rungMs(style: CSSStyleDeclaration, rung: string): number | undefined;

package/dist/core/rungs.js

@@ -0,0 +1,24 @@
+// Where a script reads the scale. The derivation declares every `--_qm-*` rung on
+// `[data-qm-root]` and nowhere else (`core/theme.css`), so a descendant's value is that
+// one inherited and the root is the element the question is about: asking a leaf three
+// containers deep is asking an arbitrary element what the surface is set to.
+//
+// The read is also the cost. `getComputedStyle` compounds with nesting depth under jsdom,
+// so a suite that resolves rungs off landed elements pays the depth of whatever it landed
+// on; resolving them off the root pays the root's.
+/** The element the scale is declared on, for `node`: its root, or `node` where it stands
+ *  outside one (a detached surface, a consumer's own mount). */
+export function rungStyle(node) {
+    return getComputedStyle(node.closest('[data-qm-root]') ?? node);
+}
+/** A duration rung off `style`, in ms; `undefined` where the derivation is out of reach
+ *  (an unstyled root, or jsdom, where `getComputedStyle` reports custom properties as
+ *  empty). No rung, no motion: a fallback here would be the scale restated in the one
+ *  place `check:style` cannot read. */
+export function rungMs(style, rung) {
+    const raw = style.getPropertyValue(rung).trim();
+    const n = Number.parseFloat(raw);
+    if (!Number.isFinite(n))
+        return undefined;
+    return raw.endsWith('ms') ? n : n * 1000;
+}

package/dist/core/theme.css

@@ -163,13 +163,16 @@
 	   relationship at any mix: a stroke against the surface behind it, not a fill
 	   stacked on one. */
 	--_qm-border-faint: color-mix(in oklab, var(--_qm-bg), var(--_qm-border) 50%);
-	/* Two rungs, and there is no third: a step below `label` lands under 3:1 on the
-	   well a field draws it against, and what would take it — a placeholder, an
-	   unset value, the resolved `default:` — is content a reader has to read
-	   (WCAG 1.4.3), not decoration. So tone carries hierarchy alone, and a leaf
-	   saying shown-never-written says it against the `ink` a written value takes,
-	   in italic where it has no written neighbour to be read against. */
+	/* Three rungs, and nothing under the last: a step below `label` lands under 3:1 on
+	   the well a field draws it against, and what would take it — an example, an unset
+	   value's word — is content a reader has to read (WCAG 1.4.3), not decoration.
+	   `ink` is written. `default` is the resolved `default:` drawn as the value it
+	   prints: near enough to `ink` to read as an answer, a step off it so it never
+	   reads as a written one. `label` is words about a value rather than the value — an
+	   `example:`, `None`, a format hint — and the chrome that names fields; in italic
+	   where it is a leaf's ghost, which has no written neighbour to be read against. */
 	--_qm-ink: var(--_qm-fg);
+	--_qm-ink-default: color-mix(in oklab, var(--_qm-fg), var(--_qm-bg) 20%);
 	--_qm-ink-label: color-mix(in oklab, var(--_qm-fg), var(--_qm-bg) 35%);
 	/* The arrival wash (`core/bloom.ts`). Its alpha is a peak, not a tint: the
 	   wash animates from and back to zero, never held, so it reads over the leaf it
@@ -336,6 +339,16 @@
 	   through the icon's `size`, so a stylesheet beats the SVG presentation attribute
 	   and one rung is the whole of what a control draws. */
 	--_qm-glyph-control: 14px;
+	/* The narrowest track a control that fills its width stays usable in: a table's
+	   column floors at it, rises no further than its content, and a row of them scrolls
+	   sideways rather than crushing a cell. A column drawing a mark takes no floor — a
+	   switch is one width at every width, so there is no width for it to be usable in
+	   (`ArrayField`). What the field has spare stands after the last column, an inner
+	   grid carrying its own rhythm rather than the card's. Under the field minimum the
+	   capacity ladder steps at (`.qm-tracks`), since a cell in a row has the header to
+	   name it and no label of its own to fit. A threshold rather than a rhythm choice,
+	   so it does not move with `--qm-space`. */
+	--_qm-track-min: 7rem;
 
 	/* ── Type ────────────────────────────────────────────────────────────────
 	   `--qm-font-size` anchors the chrome rung; 1.125 is the ratio between adjacent

package/dist/preview/paint.js

@@ -1,6 +1,11 @@
 // Vertical breathing room between stacked pages; cosmetic only, and a rung like
 // any other gap: the stack breathes on the same rhythm the cards do.
 const PAGE_GAP = 'var(--_qm-space-4)';
+// The least raster density, in device pixels per CSS pixel. Glyphs rasterize
+// unhinted, so a raster at a 1× or fractional ratio (1.25, 1.5; browser zoom)
+// is resampled nearly 1:1 and small text smears; a raster at least twice the
+// box is downsampled instead, which keeps body text legible.
+const MIN_DENSITY = 2;
 export function createPaintLoop(session, container, margin, 
 // Notified when a slot's `session.paint` throws: the loop swallows the throw
 // (see `paintSlot`) so one bad page never aborts the band sweep; the caller
@@ -65,16 +70,19 @@ onPaintError) {
         return { page, size, el };
     }
     // Rasterize `slot` into its canvas (creating the canvas if this is its first
-    // paint since mounting). `layoutScale` is derived from the slot's own current
-    // CSS width, so layout width tracks the container per the zoom settled
-    // decision; `canvas.style.*` is then set from the authoritative PaintResult,
-    // never guessed.
+    // paint since mounting), at the slot's own current CSS width.
     function paintSlot(slot) {
         let canvas = canvases.get(slot.page);
         if (!canvas) {
             canvas = document.createElement('canvas');
             canvas.className = 'qm-page-canvas';
-            Object.assign(canvas.style, { position: 'absolute', inset: '0', display: 'block' });
+            Object.assign(canvas.style, {
+                position: 'absolute',
+                inset: '0',
+                display: 'block',
+                width: '100%',
+                height: '100%'
+            });
         }
         // Contextless canvas: bail before registering, so `updateBand` still sees
         // the page as unmounted and retries instead of keeping a blank page.
@@ -86,11 +94,9 @@ onPaintError) {
             canvases.set(slot.page, canvas);
         }
         const layoutScale = (slot.el.clientWidth || slot.size.widthPt) / slot.size.widthPt;
-        const densityScale = (window.devicePixelRatio || 1) * zoom;
+        const densityScale = Math.max(window.devicePixelRatio || 1, MIN_DENSITY) * zoom;
         try {
-            const result = session.paint(ctx, slot.page, { layoutScale, densityScale });
-            canvas.style.width = `${result.layoutWidth}px`;
-            canvas.style.height = `${result.layoutHeight}px`;
+            session.paint(ctx, slot.page, layoutScale * densityScale);
         }
         catch (err) {
             // A paint that throws must not abort the band loop; `updateBand` runs in
@@ -162,14 +168,12 @@ onPaintError) {
     // Slots are built on the first `refresh` (the controller calls it immediately),
     // not here: reconcile → `session.pageSize` must run after the controller's
     // `pageCount` gate, since `pageSize` throws for a page the count excludes.
-    // ── Keep mounted rasters in step with the display ───────────────────────────
-    // Every paint freezes `canvas.style.width/height` to the box width at that
-    // paint (paintSlot). A page that stays mounted while the container's CSS width
-    // or `devicePixelRatio` shifts would otherwise keep a stale raster the %-space
-    // click/scroll math silently drifts off of: the box tracks the container, the
-    // ink does not. Two observers close the gap by repainting mounted pages from
-    // their current box; canvases are `position:absolute`, so a repaint can't feed
-    // back into layout (and thus can't re-trigger the resize observer).
+    // ── Keep mounted rasters sharp ──────────────────────────────────────────────
+    // A canvas stretches with its slot, so a page that stays mounted while the
+    // container's CSS width or `devicePixelRatio` shifts keeps its place and goes
+    // soft. Two observers repaint mounted pages from their current box; canvases
+    // are `position:absolute`, so a repaint can't feed back into layout (and thus
+    // can't re-trigger the resize observer).
     // Repaint mounted pages (all, or a given subset) from their live geometry: the
     // one path resize, DPR, and zoom share; each `paintSlot` re-reads the slot's
     // current `clientWidth`. A no-op for an unmounted page.