@quillmark/wasm 0.110.0 → 0.112.0

package/core/wasm.js

@@ -279,6 +279,10 @@ export class Document {
      * Throws on an out-of-range card, a field that is not richtext, a malformed
      * bundle, or an op that applies out of bounds; the value is unchanged on a
      * failed apply.
+     *
+     * Each text-moving channel rebases the marks already in the field, by the
+     * rule on `ChangeBundle`; `mapMarks` answers where they land, so a caller
+     * building `markOps` need not predict it.
      * @param {Addr | string} addr
      * @param {ChangeBundle} bundle
      */
@@ -1749,11 +1753,48 @@ export function importMarkdown(markdown) {
     }
 }
 
+/**
+ * Where `bundle`'s text-moving channels (`delta`, then `islandOps`, then
+ * `lineOps`) leave `content`'s marks: the final-text coordinates the bundle's
+ * `markOps` are written in, under the rebase rule stated on `ChangeBundle`.
+ * The document-free read an editor diffs against to decide which `markOps` to
+ * emit, rather than reproducing that rule in its own language.
+ *
+ * `bundle.markOps` are ignored. The answer is normalized, as the store's is:
+ * marks a text move drops (out of range, zero-width formatting) are absent,
+ * and same-kind runs a move left adjacent arrive already unioned, so a bundle
+ * carrying no `markOps` names the marks the field will hold.
+ * Throws on a non-content `content`, a malformed bundle, or an op that applies
+ * out of bounds: `applyChange`'s errors on the same ops.
+ * @param {Content} content
+ * @param {ChangeBundle} bundle
+ * @returns {ContentMark[]}
+ */
+export function mapMarks(content, bundle) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.mapMarks(retptr, addHeapObject(content), addHeapObject(bundle));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Map a base content position (a USV index into `Content.text`, not a UTF-16
  * offset) through a `delta` to its new position, holding a caret stable across
  * a `revise`. `assoc` decides the side of a same-position insertion (`"after"`
  * moves past it). Throws on a malformed `delta`.
+ *
+ * This maps a position the *caller* holds. For the marks already in a field,
+ * `mapMarks` applies the store's own assoc rule across every channel of a
+ * `ChangeBundle`.
  * @param {Delta} delta
  * @param {number} pos
  * @param {Assoc} assoc

package/core/wasm_bg.wasm.d.ts

@@ -61,6 +61,7 @@ export const document_warnings: (a: number, b: number) => void;
 export const exportMarkdown: (a: number, b: number) => void;
 export const formatDocPath: (a: number, b: number) => void;
 export const importMarkdown: (a: number, b: number, c: number) => void;
+export const mapMarks: (a: number, b: number, c: number) => void;
 export const mapPos: (a: number, b: number, c: number, d: number) => void;
 export const parseDocPath: (a: number, b: number, c: number) => void;
 export const quill_backendId: (a: number, b: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.110.0",
+  "version": "0.112.0",
   "description": "WebAssembly bindings for Quillmark, a schema-driven document engine",
   "type": "module",
   "license": "Apache-2.0",

package/runtime/runtime.d.ts

@@ -24,6 +24,7 @@ import type {
 	exportMarkdown,
 	rebase,
 	mapPos,
+	mapMarks,
 	parseDocPath,
 	formatDocPath
 } from '../core/wasm.js';
@@ -42,6 +43,7 @@ export interface CoreSurface {
 	exportMarkdown: typeof exportMarkdown;
 	rebase: typeof rebase;
 	mapPos: typeof mapPos;
+	mapMarks: typeof mapMarks;
 	parseDocPath: typeof parseDocPath;
 	formatDocPath: typeof formatDocPath;
 }
@@ -217,34 +219,32 @@ export declare function isImageIsland(
 	island: ContentIsland
 ): island is ContentIsland & { type: 'image'; props: ImageProps };
 
-/** Narrow a {@link ContentMark} to the `link` arm (carries `url`). */
+/** Narrow a {@link ContentMark} to the `link` arm (carries `attrs.url`). */
 export declare function isLinkMark(
 	mark: ContentMark
-): mark is ContentMark & { type: 'link'; url: string };
+): mark is ContentMark & { type: 'link'; attrs: { url: string } };
 
-/** Narrow a {@link ContentMark} to the `anchor` arm (carries `id`). */
+/** Narrow a {@link ContentMark} to the `anchor` arm (carries `attrs.id`). */
 export declare function isAnchorMark(
 	mark: ContentMark
-): mark is ContentMark & { type: 'anchor'; id: string };
+): mark is ContentMark & { type: 'anchor'; attrs: { id: string } };
 
-/** Narrow a {@link ContentLine} to the `heading` arm (carries `level`). */
+/** Narrow a {@link ContentLine} to the `heading` arm (carries `attrs.level`). */
 export declare function isHeadingLine(
 	line: ContentLine
-): line is ContentLine & { kind: 'heading'; level: number };
+): line is ContentLine & { kind: 'heading'; attrs: { level: number } };
 
-/** Narrow a {@link ContentLine} to the `code` arm (carries `lang`). */
+/** Narrow a {@link ContentLine} to the `code` arm (carries `attrs.lang`). */
 export declare function isCodeLine(
 	line: ContentLine
-): line is ContentLine & { kind: 'code'; lang?: string };
+): line is ContentLine & { kind: 'code'; attrs?: { lang?: string } };
 
 /** Narrow a {@link ContentContainer} to the `list_item` arm (carries its shape). */
 export declare function isListItemContainer(
 	container: ContentContainer
 ): container is ContentContainer & {
 	container: 'list_item';
-	ordered: boolean;
-	start: number;
-	ordinal: number;
+	attrs: { ordered: boolean; start: number; ordinal: number };
 	instance: number;
 };
 
@@ -255,8 +255,9 @@ export declare function isListItemContainer(
 // built-in names by hand re-couples to a closed set.
 //
 // They classify unknown TAGS, not unknown payloads on known tags: a future
-// `kind: "footnote"` carrying a sibling `ref` loses `ref` at any consumer that
-// predates it, with or without these.
+// `kind: "footnote"` carrying an `attrs.ref` loses `ref` at any consumer that
+// predates it, with or without these. The spelling needs no classifying: a
+// payload rides `attrs` whether or not this build knows the name.
 
 /** True when this build does not know `line.kind`: the open arm, carrying opaque `attrs`. */
 export declare function isUnknownLine(
@@ -610,13 +611,24 @@ export declare class LiveSession {
 	 * transform documented there: `x = clickPx.x / renderScale`,
 	 * `y = pageHeightPt - clickPx.y / renderScale`. Unlike {@link regions},
 	 * *every* placement answers, not just the first.
+	 *
+	 * `tolPt` is how far off the ink a click still counts, in the same points,
+	 * and defaults to `0` — exact. It is pointer slack, so derive it from the
+	 * scale the page was drawn at (`slackPx / renderScale`) rather than fixing a
+	 * value in points, which shrinks under the cursor as the page zooms out. The
+	 * nearest placement answers and containment is distance zero, so raising
+	 * `tolPt` only ever fills a miss.
 	 */
-	fieldAt(page: number, x: number, y: number): string | undefined;
+	fieldAt(page: number, x: number, y: number, tolPt?: number): string | undefined;
 	/**
 	 * Fine-grained click → content position (caret placement). Same PDF-point
-	 * space as {@link fieldAt}; `undefined` off all content ink.
+	 * space as {@link fieldAt}; `undefined` past `tolPt` from all content ink.
+	 *
+	 * `tolPt` buys the most here: the leading between two lines lies inside a
+	 * paragraph and on no glyph, and under `tolPt` a point there takes the line
+	 * it is nearer.
 	 */
-	positionAt(page: number, x: number, y: number): ContentHit | undefined;
+	positionAt(page: number, x: number, y: number, tolPt?: number): ContentHit | undefined;
 	/**
 	 * Content position → caret rect: reverse of {@link positionAt}. `field` is a
 	 * canonical `DocPath` address (`parseDocPath`-routable), as {@link regions} keys.

package/runtime/runtime.js

@@ -40,7 +40,7 @@ import initCore, { Quill, Document } from '../core/wasm.js';
 // itself), a `node:fs` read under Node, whose `fetch` rejects `file:` URLs.
 // Resolution-time, so `node:fs` never enters a browser graph.
 import { toModuleSource } from '#quillmark-env';
-import { importMarkdown, exportMarkdown, rebase, mapPos } from '../core/wasm.js';
+import { importMarkdown, exportMarkdown, rebase, mapPos, mapMarks } from '../core/wasm.js';
 import { parseDocPath, formatDocPath } from '../core/wasm.js';
 
 // ── Initialization ──────────────────────────────────────────────────────────
@@ -90,6 +90,7 @@ const CORE_SURFACE = Object.freeze({
 	exportMarkdown,
 	rebase,
 	mapPos,
+	mapMarks,
 	parseDocPath,
 	formatDocPath
 });
@@ -397,12 +398,12 @@ for (const name of /** @type {const} */ (['validate', 'resolve', 'conform'])) {
 // leaving `props` / the mark payload / `level` opaque at every consumer. These
 // are the checked narrowing path: on the true branch the payload's pinned shape
 // is asserted. Only the payload-carrying arms get a guard: an island always
-// carries `props`, a `link` mark carries `url`, an `anchor` mark carries `id`, a
-// `heading` line carries `level` and a `code` line `lang`, a `list_item`
-// container its shape; the payload-free arms (`strong`/`emph`/`underline`/
-// `strike`/`code` marks, `para`/`island`/`rule` lines, `quote`) narrow to
-// nothing. An unrecognized discriminant fails every guard and keeps its opaque
-// `attrs`/`props`.
+// carries `props`, and a `link`/`anchor` mark, a `heading`/`code` line and a
+// `list_item` container each carry their payload in `attrs`; the payload-free
+// arms (`strong`/`emph`/`underline`/`strike`/`code` marks, `para`/`island`/
+// `rule` lines, `quote`) omit `attrs` and narrow to nothing. An unrecognized
+// discriminant fails every guard and carries the same `attrs` a known one
+// would.
 
 /**
  * @param {import('../core/wasm.js').ContentIsland} island
@@ -422,7 +423,7 @@ export function isImageIsland(island) {
 
 /**
  * @param {import('../core/wasm.js').ContentMark} mark
- * @returns {mark is import('../core/wasm.js').ContentMark & { type: 'link'; url: string }}
+ * @returns {mark is import('../core/wasm.js').ContentMark & { type: 'link'; attrs: { url: string } }}
  */
 export function isLinkMark(mark) {
 	return mark.type === 'link';
@@ -430,7 +431,7 @@ export function isLinkMark(mark) {
 
 /**
  * @param {import('../core/wasm.js').ContentMark} mark
- * @returns {mark is import('../core/wasm.js').ContentMark & { type: 'anchor'; id: string }}
+ * @returns {mark is import('../core/wasm.js').ContentMark & { type: 'anchor'; attrs: { id: string } }}
  */
 export function isAnchorMark(mark) {
 	return mark.type === 'anchor';
@@ -438,7 +439,7 @@ export function isAnchorMark(mark) {
 
 /**
  * @param {import('../core/wasm.js').ContentLine} line
- * @returns {line is import('../core/wasm.js').ContentLine & { kind: 'heading'; level: number }}
+ * @returns {line is import('../core/wasm.js').ContentLine & { kind: 'heading'; attrs: { level: number } }}
  */
 export function isHeadingLine(line) {
 	return line.kind === 'heading';
@@ -446,7 +447,7 @@ export function isHeadingLine(line) {
 
 /**
  * @param {import('../core/wasm.js').ContentLine} line
- * @returns {line is import('../core/wasm.js').ContentLine & { kind: 'code'; lang?: string }}
+ * @returns {line is import('../core/wasm.js').ContentLine & { kind: 'code'; attrs?: { lang?: string } }}
  */
 export function isCodeLine(line) {
 	return line.kind === 'code';
@@ -454,7 +455,7 @@ export function isCodeLine(line) {
 
 /**
  * @param {import('../core/wasm.js').ContentContainer} container
- * @returns {container is import('../core/wasm.js').ContentContainer & { container: 'list_item'; ordered: boolean; start: number; ordinal: number; instance?: number }}
+ * @returns {container is import('../core/wasm.js').ContentContainer & { container: 'list_item'; attrs: { ordered: boolean; start: number; ordinal: number }; instance?: number }}
  */
 export function isListItemContainer(container) {
 	return container.container === 'list_item';
@@ -516,12 +517,13 @@ export function isUnknownIsland(island) {
 // form cannot tell a list ending beside another from one list of two items, so
 // an omitted discriminator welds them and nothing reports it.
 //
-// WELD_KEYS is the rule `Container::same_weld` owns upstream: which fields two
-// adjacent runs must share for the markdown projection to read them as one, and
-// therefore for the canonical form to have to spend a discriminator. `start` is
-// not among them, since CommonMark reads only a list's first number. A table
-// rather than a switch, so `tests/known_names_drift.rs` can pin it against the
-// Rust predicate.
+// WELD_KEYS is the rule `Container::same_weld` owns upstream: which `attrs`
+// entries two adjacent runs must share for the markdown projection to read them
+// as one, and therefore for the canonical form to have to spend a
+// discriminator. `start` is not among them, since CommonMark reads only a
+// list's first number — a subset, which is why a built-in needs an entry rather
+// than the unknown branch's whole-bag compare. A table rather than a switch, so
+// `tests/known_names_drift.rs` can pin it against the Rust predicate.
 
 const WELD_KEYS = { list_item: ['ordered'], quote: [] };
 
@@ -548,7 +550,7 @@ function weldsWith(a, b) {
 	// `hasOwn`, so a tag colliding with an `Object.prototype` member reaches the
 	// unknown branch rather than a function.
 	if (!Object.hasOwn(WELD_KEYS, a.container)) return sameJson(a.attrs, b.attrs);
-	return WELD_KEYS[a.container].every((k) => a[k] === b[k]);
+	return WELD_KEYS[a.container].every((k) => a.attrs?.[k] === b.attrs?.[k]);
 }
 
 /**
@@ -961,20 +963,22 @@ export class LiveSession {
 	 * @param {number} page
 	 * @param {number} x
 	 * @param {number} y
+	 * @param {number} [tolPt]
 	 * @returns {string | undefined}
 	 */
-	fieldAt(page, x, y) {
-		return this.#inner.fieldAt(page, x, y);
+	fieldAt(page, x, y, tolPt) {
+		return this.#inner.fieldAt(page, x, y, tolPt);
 	}
 
 	/**
 	 * @param {number} page
 	 * @param {number} x
 	 * @param {number} y
+	 * @param {number} [tolPt]
 	 * @returns {import('./runtime.d.ts').ContentHit | undefined}
 	 */
-	positionAt(page, x, y) {
-		return this.#inner.positionAt(page, x, y);
+	positionAt(page, x, y, tolPt) {
+		return this.#inner.positionAt(page, x, y, tolPt);
 	}
 
 	/**