@quillmark/wasm 0.123.1 → 0.125.0

package/core/wasm.js

@@ -26,11 +26,14 @@ export class Document {
      * leaves the document untouched. Field errors throw the same per-field
      * bundle as [`commitFields`](Self::commit_fields); an invalid kind or body,
      * or a bad position, throws a single-entry bundle keyed `$kind` / `$body`.
+     * Returns the fields' `parse::dropped_construct` warnings, then the body
+     * import's, anchored under the placed card.
      * @param {Quill} quill
      * @param {string} kind
      * @param {Record<string, unknown>} [fields]
      * @param {string} [body]
      * @param {number} [at]
+     * @returns {Diagnostic[]}
      */
     _addCard(quill, kind, fields, body, at) {
         try {
@@ -43,9 +46,11 @@ export class Document {
             wasm.document__addCard(retptr, this.__wbg_ptr, quill.__wbg_ptr, ptr0, len0, isLikeNone(fields) ? 0 : addHeapObject(fields), ptr1, len1, isLikeNone(at) ? Number.MAX_SAFE_INTEGER : (at) >>> 0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -68,9 +73,13 @@ export class Document {
      *
      * The `quill` handle is passed per call because a `Document` carries only a
      * `$quill` reference, not the resolved schema.
+     *
+     * Returns a `parse::dropped_construct` warning per construct a `richtext`
+     * markdown string in the value dropped, at the string's path.
      * @param {Quill} quill
      * @param {Addr | string} addr
      * @param {any} value
+     * @returns {Diagnostic[]}
      */
     _commitField(quill, addr, value) {
         try {
@@ -79,9 +88,11 @@ export class Document {
             wasm.document__commitField(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), addHeapObject(value));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -93,10 +104,12 @@ export class Document {
      * diagnostic contract as [`storeFields`](Document::store_fields) — nothing
      * applied on error, one `diagnostics` entry per offending field, including
      * `edit::unknown_field` for undeclared names. Throws on an out-of-range
-     * card.
+     * card. Returns [`commitField`](Document::commit_field)'s warnings for
+     * every field, in batch order.
      * @param {Quill} quill
      * @param {CardAddr} addr
      * @param {Record<string, unknown>} fields
+     * @returns {Diagnostic[]}
      */
     _commitFields(quill, addr, fields) {
         try {
@@ -105,9 +118,11 @@ export class Document {
             wasm.document__commitFields(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), addHeapObject(fields));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -228,14 +243,40 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * The ABI under `writer.reviseDocument`: a whole-document revise, then
+     * conform against `quill`. Throws when `markdown` declares a `$quill` this quill
+     * does not answer to, before any mutation.
+     * @param {Quill} quill
+     * @param {string} markdown
+     * @returns {DocumentRevised}
+     */
+    _reviseDocument(quill, markdown) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(quill, Quill);
+            const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document__reviseDocument(retptr, this.__wbg_ptr, quill.__wbg_ptr, ptr0, len0);
+            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);
+        }
+    }
     /**
      * Revise the content field at `addr` from authored text, typed *and*
      * anchor-preserving: the ABI under `writer.reviseField`. Surviving anchors
      * rebase as in [`revise`](Self::revise), then the diffed result is
      * schema-conformed, so a `richtext(inline)` field rejects a multi-block
-     * result with `edit::field_not_inline`. Returns the text `Delta`. The codec
-     * is the declared type's: `richtext` diffs markdown, `plaintext` literal
-     * text.
+     * result with `edit::field_not_inline`. Returns the `Revised` receipt, its
+     * warnings anchored at the field. The codec is the declared type's:
+     * `richtext` diffs markdown, `plaintext` literal text, which drops nothing.
      *
      * `addr` must name a field; a body address throws, since a body carries no
      * field schema (use [`revise`](Self::revise)). An undeclared name throws
@@ -243,7 +284,7 @@ export class Document {
      * @param {Quill} quill
      * @param {Addr | string} addr
      * @param {string} text
-     * @returns {Delta}
+     * @returns {Revised}
      */
     _reviseField(quill, addr, text) {
         try {
@@ -861,16 +902,18 @@ export class Document {
     /**
      * **Revise** the richtext value at `addr` from a markdown string: the
      * default write path. Imports the markdown, diffs it against the current
-     * value, rebases surviving identity anchors, and returns the text `Delta` an
-     * editor bridge maps its own positions through (`mapPos`). An absent
-     * `addr.field` targets the body, an absent `addr.card` the main card; an
-     * absent field cold-imports from empty.
+     * value, rebases surviving identity anchors, and returns the `Revised`
+     * receipt: the text `delta` an editor bridge maps its own positions through
+     * (`mapPos`), and a `parse::dropped_construct` warning per construct the
+     * import dropped, its `path` the address written. An absent `addr.field`
+     * targets the body, an absent `addr.card` the main card; an absent field
+     * cold-imports from empty.
      *
      * Throws on an out-of-range card, a malformed field name, a present
      * non-content field value, or an over-nested markdown input.
      * @param {Addr | string} addr
      * @param {string} markdown
-     * @returns {Delta}
+     * @returns {Revised}
      */
     revise(addr, markdown) {
         try {
@@ -1051,8 +1094,33 @@ export class Document {
         }
     }
     /**
-     * Emit canonical Quillmark Markdown. Round-trip safe: re-parsing the
-     * result produces a `Document` equal to `self` by value and by type.
+     * `toMarkdown` with each prose anchor of every body and content field
+     * spelled read-only at its start where its line can hold the tag, and
+     * listed with its field's path and line either way. An import drops every
+     * tag, so `writer.reviseDocument` with the markdown keeps the anchors it keeps
+     * with `toMarkdown`'s.
+     * @returns {AnnotatedMarkdown}
+     */
+    toAnnotatedMarkdown() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_toAnnotatedMarkdown(retptr, this.__wbg_ptr);
+            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);
+        }
+    }
+    /**
+     * Emit canonical Quillmark Markdown. Re-parsing the result produces a
+     * `Document` equal to `self` by value and by type, but for content: a body
+     * or content field holds what its markdown spells, so its anchors drop and
+     * its island ids re-mint. `toStored` keeps both.
      * @returns {string}
      */
     toMarkdown() {
@@ -1098,7 +1166,7 @@ export class Document {
      * The non-fatal diagnostics of the load that produced this document: parse
      * warnings, plus `conform::*` warnings when it came through `quill.parse`.
      * Session state, not document value: `equals` and the storage DTO exclude
-     * it, and `fromStored` / `loadStored` clear it.
+     * it, and `fromStored` / `loadStored` / `writer.reviseDocument` clear it.
      * @returns {Diagnostic[]}
      */
     get warnings() {
@@ -1441,9 +1509,10 @@ export class Quill {
         return takeObject(ret);
     }
     /**
-     * Validate `doc` against this quill's schema, returning every diagnostic
-     * (empty when the document is valid). Forwards the canonical
-     * `validation::*` diagnostics the engine emits.
+     * Validate `doc` against this quill's schema, returning every diagnostic:
+     * an error blocks a render, a warning does not. Forwards the engine's
+     * `validation::*`, a markdown string's `parse::dropped_construct` and the
+     * backend's `backend::declined_construct`.
      * @param {Document} doc
      * @returns {Diagnostic[]}
      */
@@ -1557,7 +1626,7 @@ export function formatDiagnostic(diagnostic) {
 }
 
 /**
- * Serialize structured [`DocPathSeg`] segments back to the canonical path
+ * Serialize structured `DocPathSeg` segments back to the canonical path
  * string: the inverse of `parseDocPath`. Throws on a segment array the
  * deserializer rejects, and on an empty one.
  * @param {DocPathSeg[]} segs
@@ -1589,11 +1658,13 @@ export function formatDocPath(segs) {
 }
 
 /**
- * Import a markdown string to canonical `Content`: the pure, document-free
- * codec. `overwrite(addr, importMarkdown(md))` spells the cold, anchor-losing
- * write; prefer `revise` for edit semantics. Throws on an over-nested input.
+ * Import a markdown string: the pure, document-free codec. Returns the
+ * canonical `content` and a `parse::dropped_construct` warning per construct
+ * the import dropped, with no `path`. `overwrite(addr, importMarkdown(md).content)`
+ * spells the cold, anchor-losing write; prefer `revise` for edit semantics.
+ * Throws on an over-nested input.
  * @param {string} markdown
- * @returns {Content}
+ * @returns {Imported}
  */
 export function importMarkdown(markdown) {
     try {
@@ -1726,7 +1797,7 @@ export function mapPos(delta, pos, assoc) {
 
 /**
  * Parse a canonical document-model `Diagnostic.path` (`cards.<kind>[<i>].<field>`,
- * `main.body`, `recipients[0].name`) into structured [`DocPathSeg`] segments, so
+ * `main.body`, `recipients[0].name`) into structured `DocPathSeg` segments, so
  * a consumer routes on segments instead of regexing the string. Throws on a
  * malformed path.
  * @param {string} path
@@ -1752,12 +1823,13 @@ export function parseDocPath(path) {
 
 /**
  * Rebase `markdown` onto a `base` content: the document-free twin of `revise`,
- * returning the new `content` and the text `delta` (offsets are USV indices into
- * `Content.text`, surviving anchors rebased). Throws on an over-nested markdown
- * input or a non-content `base`.
+ * returning the new `content`, the text `delta` (offsets are USV indices into
+ * `Content.text`, surviving anchors rebased), and the import's
+ * `parse::dropped_construct` warnings, with no `path`. Throws on an
+ * over-nested markdown input or a non-content `base`.
  * @param {Content} base
  * @param {string} markdown
- * @returns {{ content: Content; delta: Delta }}
+ * @returns {{ content: Content; delta: Delta; warnings: Diagnostic[] }}
  */
 export function rebase(base, markdown) {
     try {
@@ -1918,10 +1990,6 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).getMonth();
             return ret;
         },
-        __wbg_getOwnPropertyNames_f8299644de14134c: function(arg0) {
-            const ret = Object.getOwnPropertyNames(getObject(arg0));
-            return addHeapObject(ret);
-        },
         __wbg_getPrototypeOf_4e7d85b5bf38d546: function() { return handleError(function (arg0) {
             const ret = Reflect.getPrototypeOf(getObject(arg0));
             return addHeapObject(ret);
@@ -1952,6 +2020,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Error_80a725f81f2e102d: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Error;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Map_b2611749102d7ba3: function(arg0) {
             let result;
             try {
@@ -1992,6 +2070,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).length;
             return ret;
         },
+        __wbg_message_5f8387f0c32b90a7: function(arg0) {
+            const ret = getObject(arg0).message;
+            return addHeapObject(ret);
+        },
         __wbg_new_0_72d020f0c63443d4: function() {
             const ret = new Date();
             return addHeapObject(ret);
@@ -2032,6 +2114,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).next();
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_ownKeys_7f46b96dc7311fe8: function() { return handleError(function (arg0) {
+            const ret = Reflect.ownKeys(getObject(arg0));
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },

package/core/wasm_bg.wasm.d.ts

@@ -9,6 +9,7 @@ export const document__commitFields: (a: number, b: number, c: number, d: number
 export const document__readerGet: (a: number, b: number, c: number, d: number) => void;
 export const document__readerGetContent: (a: number, b: number, c: number, d: number) => void;
 export const document__readerGetContentAt: (a: number, b: number, c: number, d: number, e: number) => void;
+export const document__reviseDocument: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document__reviseField: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const document_applyChange: (a: number, b: number, c: number, d: number) => void;
 export const document_bodyMarkdown: (a: number, b: number, c: number) => void;
@@ -45,6 +46,7 @@ export const document_storeExt: (a: number, b: number, c: number, d: number) =>
 export const document_storeField: (a: number, b: number, c: number, d: number) => void;
 export const document_storeFields: (a: number, b: number, c: number, d: number) => void;
 export const document_storeSeedOverlay: (a: number, b: number, c: number, d: number, e: number) => void;
+export const document_toAnnotatedMarkdown: (a: number, b: number) => void;
 export const document_toMarkdown: (a: number, b: number) => void;
 export const document_toStored: (a: number, b: number) => void;
 export const document_warnings: (a: number, b: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.123.1",
+  "version": "0.125.0",
   "description": "WebAssembly bindings for Quillmark, a schema-driven document engine",
   "type": "module",
   "license": "Apache-2.0",
@@ -15,7 +15,8 @@
     "core",
     "render",
     "runtime",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "sbom.cdx.json"
   ],
   "main": "./runtime/runtime.js",
   "module": "./runtime/runtime.js",