@quillmark/svelte 0.1.1 → 0.3.0

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

@@ -8,14 +8,18 @@ export declare const ALIGNS: readonly TableAlign[];
 /** The zero cell: empty text, no marks. */
 export declare function emptyCell(): TableCell;
 /**
- * The row index space the chrome and the ops share: **0 is the header**, 1…n the
- * body rows. A table always has a header (`header` is a separate field, and a
- * header-less table is not expressible), so the header is a row that never
- * deletes rather than a toggle.
+ * The row index space the chrome and the ops share: **0 is the header**, 1…n the body
+ * rows. The split is how a table is stored, not a rank the ops answer to: a row op
+ * works {@link allRows} and whichever row lands at index 0 is the header afterwards,
+ * so index 0 moves and deletes like any other. The one row the model refuses is the
+ * last, there being no table under it.
  */
 export declare function rowCount(props: TableProps): number;
 /** The cells of row `r` in that space. */
 export declare function rowCells(props: TableProps, r: number): TableCell[];
+/** Whether a row holds no text, which is what tells a row on offer from one taken up
+ *  (`table-view.ts` §`step`). Text alone: a mark over none is nothing a writer can see. */
+export declare function rowEmpty(props: TableProps, r: number): boolean;
 /** The cell at `(row, column)`, or the zero cell where the rectangle does not reach. */
 export declare function cellAt(props: TableProps, r: number, c: number): TableCell;
 /** The table's column count: the one number `header`, every row and `aligns` share. */
@@ -27,6 +31,13 @@ export declare function columnCount(props: TableProps): number;
  * back, and a table is never narrower than one column.
  */
 export declare function normalizeTable(props: TableProps): TableProps;
+/**
+ * The rows as one list, header first: the space a row op works in. `header` is a
+ * separate field because a table always has one and `header: []` is not a table — a
+ * storage shape, not a rank a row op has to know about. Reading it as one list is what
+ * lets move and delete treat every row alike, and {@link fromRows} splits it back.
+ */
+export declare function allRows(props: TableProps): TableCell[][];
 /** A fresh table: a header plus `bodyRows` empty rows, every column unaligned.
  *  Growth is cheap (Tab at the last cell appends a row), so the default is small. */
 export declare function newTable(cols?: number, bodyRows?: number): TableProps;
@@ -34,32 +45,48 @@ export declare function newTable(cols?: number, bodyRows?: number): TableProps;
 export declare function withCell(props: TableProps, r: number, c: number, cell: TableCell): TableProps;
 /** A new empty body row below row `r` (row 0, the header, opens the first body row). */
 export declare function insertRow(props: TableProps, r: number): TableProps;
-/** Drop body row `r`. The header (`r === 0`) has no delete: `header: []` is not a
- *  table, so the asymmetry is the model's rather than a guard's. */
+/** Drop row `r`, the header included: the row left at index 0 is the header, which is
+ *  how a table whose first row went still has one. A no-op at the last row, that being
+ *  the removal of the table rather than of a row, and the island's own to answer. */
 export declare function deleteRow(props: TableProps, r: number): TableProps;
 /** A new empty column after column `c`. */
 export declare function insertColumn(props: TableProps, c: number): TableProps;
 /** Drop column `c`; a no-op at one column (a table has at least one). */
 export declare function deleteColumn(props: TableProps, c: number): TableProps;
-/** Body row `r` moved by `by` places, clamped: a drag that leaves the rectangle is a
- *  no-op rather than an error, since the drop target is geometry and geometry runs
- *  past the last row. The header is refused because it has no destination: it is a
- *  separate field, not row 0 of one array. */
+/** Row `r` moved by `by` places, clamped: a drag that leaves the rectangle is a no-op
+ *  rather than an error, since the drop target is geometry and geometry runs past the
+ *  last row. The header travels like any other row, and so does the row that displaces
+ *  it: being the header is holding index 0, which a move is free to hand over. */
 export declare function moveRow(props: TableProps, r: number, by: number): TableProps;
 /** Column `c` moved by `by` places, clamped. `aligns` travels with the column: an
  *  alignment is the column's property, so a move that left it behind would retint the
  *  column that took the index. */
 export declare function moveColumn(props: TableProps, c: number, by: number): TableProps;
-/** Column `c` with every cell emptied, alignment kept: what a delete gesture means at
- *  the LAST column, which the model keeps. There is no row analogue: the header is the
- *  only row a delete is refused for, and it carries no handle to select it from. */
-export declare function clearColumn(props: TableProps, c: number): TableProps;
+/**
+ * Every cell in the inclusive rectangle emptied, alignment kept: what a delete gesture
+ * means over a block of cells that covers no whole rank. A rectangle spanning one axis
+ * covers ranks and deletes them, and one spanning both is the table itself, so what
+ * reaches here is a proper sub-rectangle and the shape it leaves is the shape it found.
+ *
+ * Alignment is the column's rather than the cells', so it survives a clear that spans one.
+ */
+export declare function clearCells(props: TableProps, r0: number, c0: number, r1: number, c1: number): TableProps;
+/**
+ * A rectangle written in at `(r, c)`, the table growing to hold whatever runs past its
+ * edges: what a paste into a cell means (`clipboard.ts`). The alternative is clipping
+ * to the rectangle that is there, which silently drops the tail of what the author
+ * copied; growth drops nothing and every added rank is one the ops already remove.
+ *
+ * `aligns` is the table's own throughout: a column keeps its alignment under a paste,
+ * and a column the paste added arrives `none` like any other fresh one.
+ */
+export declare function pasteCells(props: TableProps, r: number, c: number, block: TableCell[][]): TableProps;
 /** Set column `c`'s alignment: the one table capability the content round-trips
  *  today and nothing in the editor could reach. */
 export declare function setAlign(props: TableProps, c: number, align: TableAlign): TableProps;
 /**
  * A cell as a one-line `Content`: what `decode` takes under the inline schema. The
- * cell's marks ARE that content's marks, because both are offsets into the same
+ * cell's marks are that content's marks, because both are offsets into the same
  * text: the cell-local coordinate space is a `Content`'s coordinate space with
  * one line in it.
  */

package/dist/core/codec/table.js

@@ -2,9 +2,9 @@
 // doc) and the rectangularizing constructors every row and column op goes through
 // (CODEC §Islands, §"The table island").
 //
-// `TableProps` normalizes to ONE column count shared by `header`, every row, and
+// `TableProps` normalizes to one column count shared by `header`, every row, and
 // `aligns`, so a ragged table is not a state the content can hold. The editor keeps
-// its optimistic PM and re-hydrates only on an EXTERNAL change (CODEC
+// its optimistic PM and re-hydrates only on an external change (CODEC
 // §Reconciliation), so an op that emitted a ragged table would leave the store
 // rectangularized and PM ragged with no error channel and no repair. Every
 // constructor here therefore ends in {@link normalizeTable}, and a caller reaches
@@ -15,7 +15,8 @@
 // the codec already runs (one paragraph, no containers, no islands) is exactly its
 // shape, so a cell decodes and projects through the same machinery a
 // `richtext(inline)` field does.
-import { isAnchorMark, mapPos } from '@quillmark/wasm';
+import { isAnchorMark } from '@quillmark/wasm';
+import { core } from '../lifecycle.js';
 import { contentEdit, pmToContent } from './encode.js';
 /** The alignments a column can take: the four the content declares, `none` first
  *  because it is what a column arrives at and what a set is cleared back to. */
@@ -25,10 +26,11 @@ export function emptyCell() {
     return { text: '', marks: [] };
 }
 /**
- * The row index space the chrome and the ops share: **0 is the header**, 1…n the
- * body rows. A table always has a header (`header` is a separate field, and a
- * header-less table is not expressible), so the header is a row that never
- * deletes rather than a toggle.
+ * The row index space the chrome and the ops share: **0 is the header**, 1…n the body
+ * rows. The split is how a table is stored, not a rank the ops answer to: a row op
+ * works {@link allRows} and whichever row lands at index 0 is the header afterwards,
+ * so index 0 moves and deletes like any other. The one row the model refuses is the
+ * last, there being no table under it.
  */
 export function rowCount(props) {
     return props.rows.length + 1;
@@ -37,6 +39,11 @@ export function rowCount(props) {
 export function rowCells(props, r) {
     return r === 0 ? props.header : (props.rows[r - 1] ?? []);
 }
+/** Whether a row holds no text, which is what tells a row on offer from one taken up
+ *  (`table-view.ts` §`step`). Text alone: a mark over none is nothing a writer can see. */
+export function rowEmpty(props, r) {
+    return rowCells(props, r).every((cell) => cell.text === '');
+}
 /** The cell at `(row, column)`, or the zero cell where the rectangle does not reach. */
 export function cellAt(props, r, c) {
     return rowCells(props, r)[c] ?? emptyCell();
@@ -60,6 +67,22 @@ export function normalizeTable(props) {
         aligns: Array.from({ length: cols }, (_, c) => props.aligns[c] ?? 'none')
     };
 }
+/**
+ * The rows as one list, header first: the space a row op works in. `header` is a
+ * separate field because a table always has one and `header: []` is not a table — a
+ * storage shape, not a rank a row op has to know about. Reading it as one list is what
+ * lets move and delete treat every row alike, and {@link fromRows} splits it back.
+ */
+export function allRows(props) {
+    return [props.header, ...props.rows];
+}
+/** A flat list back into the stored shape: whatever sits at index 0 is the header, by
+ *  position rather than by having been one. No caller passes an empty list — every op
+ *  that could reach one refuses the last row first. */
+function fromRows(rows, aligns) {
+    const [header = [], ...rest] = rows;
+    return normalizeTable({ header, rows: rest, aligns });
+}
 /** A fresh table: a header plus `bodyRows` empty rows, every column unaligned.
  *  Growth is cheap (Tab at the last cell appends a row), so the default is small. */
 export function newTable(cols = 3, bodyRows = 2) {
@@ -87,12 +110,14 @@ export function insertRow(props, r) {
         rows: [...props.rows.slice(0, at), fresh, ...props.rows.slice(at)]
     });
 }
-/** Drop body row `r`. The header (`r === 0`) has no delete: `header: []` is not a
- *  table, so the asymmetry is the model's rather than a guard's. */
+/** Drop row `r`, the header included: the row left at index 0 is the header, which is
+ *  how a table whose first row went still has one. A no-op at the last row, that being
+ *  the removal of the table rather than of a row, and the island's own to answer. */
 export function deleteRow(props, r) {
-    if (r === 0)
+    const rows = allRows(props);
+    if (rows.length <= 1 || r < 0 || r >= rows.length)
         return normalizeTable(props);
-    return normalizeTable({ ...props, rows: props.rows.filter((_, i) => i !== r - 1) });
+    return fromRows(rows.filter((_, i) => i !== r), props.aligns);
 }
 /** A new empty column after column `c`. */
 export function insertColumn(props, c) {
@@ -123,16 +148,16 @@ function move(xs, from, to) {
     next.splice(to, 0, moved);
     return next;
 }
-/** Body row `r` moved by `by` places, clamped: a drag that leaves the rectangle is a
- *  no-op rather than an error, since the drop target is geometry and geometry runs
- *  past the last row. The header is refused because it has no destination: it is a
- *  separate field, not row 0 of one array. */
+/** Row `r` moved by `by` places, clamped: a drag that leaves the rectangle is a no-op
+ *  rather than an error, since the drop target is geometry and geometry runs past the
+ *  last row. The header travels like any other row, and so does the row that displaces
+ *  it: being the header is holding index 0, which a move is free to hand over. */
 export function moveRow(props, r, by) {
-    const from = r - 1;
-    const to = Math.max(0, Math.min(from + by, props.rows.length - 1));
-    if (r === 0 || from === to || from >= props.rows.length)
+    const rows = allRows(props);
+    const to = Math.max(0, Math.min(r + by, rows.length - 1));
+    if (r === to || r < 0 || r >= rows.length)
         return normalizeTable(props);
-    return normalizeTable({ ...props, rows: move(props.rows, from, to) });
+    return fromRows(move(rows, r, to), props.aligns);
 }
 /** Column `c` moved by `by` places, clamped. `aligns` travels with the column: an
  *  alignment is the column's property, so a move that left it behind would retint the
@@ -148,17 +173,37 @@ export function moveColumn(props, c, by) {
         aligns: shift(props.aligns)
     });
 }
-/** Column `c` with every cell emptied, alignment kept: what a delete gesture means at
- *  the LAST column, which the model keeps. There is no row analogue: the header is the
- *  only row a delete is refused for, and it carries no handle to select it from. */
-export function clearColumn(props, c) {
-    const blank = (cells) => cells.map((cell, i) => (i === c ? emptyCell() : cell));
+/**
+ * Every cell in the inclusive rectangle emptied, alignment kept: what a delete gesture
+ * means over a block of cells that covers no whole rank. A rectangle spanning one axis
+ * covers ranks and deletes them, and one spanning both is the table itself, so what
+ * reaches here is a proper sub-rectangle and the shape it leaves is the shape it found.
+ *
+ * Alignment is the column's rather than the cells', so it survives a clear that spans one.
+ */
+export function clearCells(props, r0, c0, r1, c1) {
+    const blank = (cells, r) => cells.map((cell, c) => (r >= r0 && r <= r1 && c >= c0 && c <= c1 ? emptyCell() : cell));
     return normalizeTable({
-        header: blank(props.header),
-        rows: props.rows.map(blank),
+        header: blank(props.header, 0),
+        rows: props.rows.map((row, i) => blank(row, i + 1)),
         aligns: props.aligns
     });
 }
+/**
+ * A rectangle written in at `(r, c)`, the table growing to hold whatever runs past its
+ * edges: what a paste into a cell means (`clipboard.ts`). The alternative is clipping
+ * to the rectangle that is there, which silently drops the tail of what the author
+ * copied; growth drops nothing and every added rank is one the ops already remove.
+ *
+ * `aligns` is the table's own throughout: a column keeps its alignment under a paste,
+ * and a column the paste added arrives `none` like any other fresh one.
+ */
+export function pasteCells(props, r, c, block) {
+    const rows = allRows(props);
+    const height = Math.max(rows.length, r + block.length);
+    const width = Math.max(columnCount(props), ...block.map((row) => c + row.length));
+    return fromRows(Array.from({ length: height }, (_, i) => Array.from({ length: width }, (_, j) => block[i - r]?.[j - c] ?? rows[i]?.[j] ?? emptyCell())), props.aligns);
+}
 /** Set column `c`'s alignment: the one table capability the content round-trips
  *  today and nothing in the editor could reach. */
 export function setAlign(props, c, align) {
@@ -170,7 +215,7 @@ export function setAlign(props, c, align) {
 // ── The cell codec ──────────────────────────────────────────────────────────
 /**
  * A cell as a one-line `Content`: what `decode` takes under the inline schema. The
- * cell's marks ARE that content's marks, because both are offsets into the same
+ * cell's marks are that content's marks, because both are offsets into the same
  * text: the cell-local coordinate space is a `Content`'s coordinate space with
  * one line in it.
  */
@@ -201,6 +246,7 @@ export function cellFromDoc(doc, prior) {
     if (!anchors.length)
         return { text, marks: projected.marks };
     const delta = contentEdit(cellContent(prior), cellContent({ text, marks: [] })).delta;
+    const { mapPos } = core();
     const rebased = anchors.map((a) => {
         const pos = delta ? mapPos(delta, a.start, 'after') : a.start;
         return { ...a, start: pos, end: pos };

package/dist/core/errors.d.ts

@@ -11,7 +11,7 @@ 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
+/** 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. */
  | 'commit-lost'
 /** A card operation (add, move, remove, retype) that threw. The document is
@@ -26,18 +26,28 @@ export type EditorErrorCode =
 /** A tip's markdown did not render: the tip shows as literal text. */
  | 'tip-render-failed'
 /**
- * A prop a surface binds ONCE was swapped in place, and the surface neither
+ * A prop a surface binds once was swapped in place, and the surface neither
  * re-keyed on it nor observed it. The mounted surface still names the previous
  * handle. `dev` throughout: the fix is a remount at the call site, so this is
  * aimed at whoever wired it and never at a running app's telemetry.
+ *
+ * The one code that is also thrown, in a dev build, once reported: a swapped
+ * `onError` is itself a rebind, so the handler this arrives at may be the one the
+ * consumer just replaced (`rebind.svelte.ts`).
  */
  | 'rebind-ignored'
 /**
- * An instance verb named a card or a field the surface does not hold: a `cardId`
- * from a previous session or an already-removed card, a `DocPath` naming no
- * mounted leaf. The call is a no-op and the document is untouched. `dev`: the
- * editor's own chrome cannot mint a bad target, so this only ever reports a host
- * driving the verbs from outside.
+ * A landing named a card or a field the surface does not hold: a `cardId` from a
+ * previous session or an already-removed card, or a `DocPath` naming no declared
+ * field — an array element path included, where the array itself is undeclared or
+ * unmounted. The call is a no-op and the document is untouched.
+ *
+ * `dev`, because the fix is at the call site: a host driving the instance verbs
+ * from outside, or a preview pick the editor has no field to route to. Every
+ * mounted field is a target, prose leaf and form control alike, and an array's
+ * elements are targets through it, so this is not how a scalar or an element
+ * reports. The preview never reports it at all: a field it places nothing for is
+ * `scrollToField` returning `false`.
  */
  | 'target-unknown';
 /** A failure a surface recovered from. */

package/dist/core/index.d.ts

@@ -1,5 +1,5 @@
 import './theme.css';
 export { init } from './lifecycle.js';
-export type { DocPath, Place } from './address.js';
+export type { DocPath, Landing, Place } from './address.js';
 export { fieldPathForAddr, addrForFieldPath } from './address.js';
 export type { EditorError, EditorErrorCode, EditorErrorHandler } from './errors.js';

package/dist/core/index.js

@@ -1,10 +1,11 @@
 // The theme derivation: the public dials → the private `--_qm-*` scale, applied
-// to every `data-qm-root` element. Imported HERE because `core/` is the one module
-// both `preview/` and `visual/` already pull, so a consumer cannot forget it and
-// the derivation is minted once rather than re-declared per detached root
-// (THEMING.md).
+// to every `data-qm-root` element (THEMING.md). Imported at every barrel a
+// consumer can enter through — here, `/visual`, `/preview` — because a subpath is
+// what a consumer gets, and a surface reaching a module inside `core/` reaches
+// nothing this file imports. One sheet however many barrels name it: the
+// derivation is minted once rather than re-declared per detached root.
 import './theme.css';
-// `@quillmark/svelte/core`: what this package OWNS at the substrate seam.
+// `@quillmark/svelte/core`: what this package owns at the substrate seam.
 //
 // The `@quillmark/wasm` API is not re-exported: import it straight from the peer
 // dependency, the single source of truth (quiver states the same rule). The

package/dist/core/lifecycle.d.ts

@@ -1,7 +1,23 @@
+import { type CoreSurface } from '@quillmark/wasm';
 /**
- * Instantiate the core WASM build. Await once before any other boundary verb,
- * from any surface's setup path; the promise is memoized, so concurrent callers
- * share one instantiation and repeat calls are free. A failed init clears the
- * memo, leaving a retry possible.
+ * Instantiate the core WASM build and resolve to its surface. Await once before
+ * any other boundary verb, from any surface's setup path; the promise is memoized,
+ * so concurrent callers share one instantiation and repeat calls are free. A failed
+ * init clears the memo, leaving a retry possible.
+ *
+ * The surface is the artifact's own, handed back unchanged: `const { Quill, Document }
+ * = await init()` is the whole of a host's access to the classes, and this package
+ * re-declares none of it.
  */
-export declare function init(): Promise<void>;
+export declare function init(): Promise<CoreSurface>;
+/**
+ * The surface synchronously, for this package's pure verbs: the `DocPath` formatter
+ * on the public API and the codec inside a ProseMirror transaction, neither of which
+ * can await. Package-internal, and read at the call rather than destructured at
+ * module scope, so no module's import graph carries an ordering constraint.
+ *
+ * Reaching one before {@link init} resolves throws, naming the fix. This is the seam
+ * that turns an awaited surface back into sync verbs, so it is the one place the
+ * precondition the gate made structural has to be stated again.
+ */
+export declare function core(): CoreSurface;

package/dist/core/lifecycle.js

@@ -1,21 +1,47 @@
 // `@quillmark/wasm` ships wasm-bindgen's web target: the core build is
-// instantiated by an explicit `await init()`, and every export throws
-// `runtime::not_initialized` until it resolves. Instantiation carries the panic
-// hook on its start section, so a Rust panic reaches JS as a stack trace.
+// instantiated by an explicit `await init()`, which resolves to the classes and
+// free functions — the artifact exports none of them statically, so awaiting is
+// the only way to hold one. Instantiation carries the panic hook on its start
+// section, so a Rust panic reaches JS as a stack trace.
 import { init as initWasm } from '@quillmark/wasm';
 let started;
+/** The resolved surface, for the sync verbs below that cannot await one. */
+let latched;
 /**
- * Instantiate the core WASM build. Await once before any other boundary verb,
- * from any surface's setup path; the promise is memoized, so concurrent callers
- * share one instantiation and repeat calls are free. A failed init clears the
- * memo, leaving a retry possible.
+ * Instantiate the core WASM build and resolve to its surface. Await once before
+ * any other boundary verb, from any surface's setup path; the promise is memoized,
+ * so concurrent callers share one instantiation and repeat calls are free. A failed
+ * init clears the memo, leaving a retry possible.
+ *
+ * The surface is the artifact's own, handed back unchanged: `const { Quill, Document }
+ * = await init()` is the whole of a host's access to the classes, and this package
+ * re-declares none of it.
  */
 export function init() {
     if (started)
         return started;
-    started = initWasm().catch((err) => {
+    started = initWasm().then((surface) => {
+        latched = surface;
+        return surface;
+    }, (err) => {
         started = undefined;
         throw err;
     });
     return started;
 }
+/**
+ * The surface synchronously, for this package's pure verbs: the `DocPath` formatter
+ * on the public API and the codec inside a ProseMirror transaction, neither of which
+ * can await. Package-internal, and read at the call rather than destructured at
+ * module scope, so no module's import graph carries an ordering constraint.
+ *
+ * Reaching one before {@link init} resolves throws, naming the fix. This is the seam
+ * that turns an awaited surface back into sync verbs, so it is the one place the
+ * precondition the gate made structural has to be stated again.
+ */
+export function core() {
+    if (!latched) {
+        throw new Error('@quillmark/svelte: the WASM core is not initialized. Await `init()` from `@quillmark/svelte/core` before mounting a surface or calling a boundary verb.');
+    }
+    return latched;
+}

package/dist/core/rebind.svelte.d.ts

@@ -3,15 +3,29 @@ import { type EditorErrorHandler } from './errors.js';
 export type Bound = Record<string, unknown> & {
     onError?: EditorErrorHandler;
 };
+/**
+ * Report the violation, then throw it in a dev build. Both surfaces raise it here; the
+ * guards themselves stay separate, since the preview snapshots its props once and the
+ * editor re-reads its pair on every re-key.
+ *
+ * The report alone reaches whoever bound `onError` at mount, and a consumer swapping
+ * that handler beside the handle it belongs to is the case this exists for: they are
+ * told through the sink they just abandoned. A throw needs no handler to arrive.
+ *
+ * It costs the surface nothing: an effect that throws neither unmounts its tree nor
+ * stops the ones beside it, so the surface goes on serving what it bound, which is the
+ * very state being reported.
+ */
+export declare function reportRebindIgnored(onError: EditorErrorHandler | undefined, message: string): void;
 /**
  * Report `rebind-ignored` once, at `dev`, when any prop `snapshot` names is swapped
- * in place. `remount` closes the message with the surface's own remount spelling
- * (`Remount the preview ({#key session}) to rebind.`).
+ * in place, and in a dev build throw it after. `remount` closes the message with the
+ * surface's own remount spelling (`Remount the preview ({#key session}) to rebind.`).
  *
- * Mounted identities are recorded on the effect's FIRST run, the flush the surface
+ * Mounted identities are recorded on the effect's first run, the flush the surface
  * binds in; every later comparison reads them through the same `snapshot`.
  *
- * The report goes to the SNAPSHOT's `onError`: every other error these surfaces
+ * The report goes to the snapshot's `onError`: every other error these surfaces
  * report reaches the handler they bound, and a swapped `onError` is itself one of
  * the reports.
  */

package/dist/core/rebind.svelte.js

@@ -1,21 +1,43 @@
-// The remount contract, enforced. `Preview` binds its props ONCE, in `onMount`, and
+// The remount contract, enforced. `Preview` binds its props once, in `onMount`, and
 // observes nothing after: the vanilla core below it owns scroll position, mounted
 // slots and observer sets that a remount would discard on every apply. So a prop
-// swapped in place is reported, not dropped in silence.
+// swapped in place is reported, not dropped in silence, and thrown in a dev build.
 //
-// A guard over ONE prop of a set is worse than none: a consumer who learns the
+// A guard over one prop of a set is worse than none: a consumer who learns the
 // surface complains when it ignores a prop reads silence on the rest as reactivity.
 // The snapshot is every once-bound prop, and one report names whichever went stale.
 import { reportError } from './errors.js';
+// True in a dev build whose bundler injects `import.meta.env`. Cast, since the package
+// declares no bundler's ambient types; false where nothing injects it, so a toolchain
+// that does not answer gets the report alone.
+const DEV = import.meta.env?.DEV === true;
+/**
+ * Report the violation, then throw it in a dev build. Both surfaces raise it here; the
+ * guards themselves stay separate, since the preview snapshots its props once and the
+ * editor re-reads its pair on every re-key.
+ *
+ * The report alone reaches whoever bound `onError` at mount, and a consumer swapping
+ * that handler beside the handle it belongs to is the case this exists for: they are
+ * told through the sink they just abandoned. A throw needs no handler to arrive.
+ *
+ * It costs the surface nothing: an effect that throws neither unmounts its tree nor
+ * stops the ones beside it, so the surface goes on serving what it bound, which is the
+ * very state being reported.
+ */
+export function reportRebindIgnored(onError, message) {
+    reportError(onError, { code: 'rebind-ignored', severity: 'dev', message });
+    if (DEV)
+        throw new Error(`[quillmark/ui] rebind-ignored: ${message}`);
+}
 /**
  * Report `rebind-ignored` once, at `dev`, when any prop `snapshot` names is swapped
- * in place. `remount` closes the message with the surface's own remount spelling
- * (`Remount the preview ({#key session}) to rebind.`).
+ * in place, and in a dev build throw it after. `remount` closes the message with the
+ * surface's own remount spelling (`Remount the preview ({#key session}) to rebind.`).
  *
- * Mounted identities are recorded on the effect's FIRST run, the flush the surface
+ * Mounted identities are recorded on the effect's first run, the flush the surface
  * binds in; every later comparison reads them through the same `snapshot`.
  *
- * The report goes to the SNAPSHOT's `onError`: every other error these surfaces
+ * The report goes to the snapshot's `onError`: every other error these surfaces
  * report reaches the handler they bound, and a swapped `onError` is itself one of
  * the reports.
  */
@@ -35,10 +57,6 @@ export function guardRebind(snapshot, remount) {
         if (stale.length === 0)
             return;
         reported = true;
-        reportError(bound.onError, {
-            code: 'rebind-ignored',
-            severity: 'dev',
-            message: `${stale.join(', ')} swapped in place; the mounted surface still holds what it bound at mount. ${remount}`
-        });
+        reportRebindIgnored(bound.onError, `${stale.join(', ')} swapped in place; the mounted surface still holds what it bound at mount. ${remount}`);
     });
 }

package/dist/core/teardown.d.ts

@@ -4,7 +4,7 @@ export interface Lifespan {
     readonly alive: boolean;
     /**
      * Register work to undo at the end: a registry entry to drop, a timer or frame
-     * to cancel, a handle to free. Cancellers run in REGISTRATION order, which is
+     * to cancel, a handle to free. Cancellers run in registration order, which is
      * where the order lives. Registering on an ended span runs the canceller at
      * once: there is no later run to hold it for.
      */

package/dist/core/teardown.js

@@ -26,7 +26,7 @@ export function createLifespan() {
         end() {
             if (!alive)
                 return;
-            // Dead BEFORE the cancellers run: one of them may synchronously reach
+            // Dead before the cancellers run: one of them may synchronously reach
             // something that asks, and a span mid-teardown is not alive.
             alive = false;
             for (const cancel of cancels)