@quillmark/wasm 0.80.0 → 0.81.0-rc.1

package/README.md

@@ -67,6 +67,31 @@ byte-equal to the original source — YAML quoting, key ordering, and
 whitespace are normalised. Use `equals` (not string comparison) to test
 semantic equality.
 
+### `doc.toJson()`
+Serialize the document to a versioned storage DTO — a JSON **string**
+carrying a `schema` version tag. Use this (not `toMarkdown`) to persist a
+document across a process restart or crate upgrade: the wire format is
+frozen per `schema` version, whereas Markdown syntax evolves. Parse-time
+`warnings` are not part of the DTO.
+
+The string is produced inside the module by `serde_json`; the JS `JSON`
+global is not involved. It is standard JSON text, so callers may
+`JSON.parse` it to inspect it — but it is intended as an opaque blob you
+persist and hand back.
+
+### `Document.fromJson(json)`
+Reconstruct a `Document` from a storage DTO string produced by `toJson`.
+Round-trips losslessly:
+
+```ts
+const stored = doc.toJson();        // persist this string
+const restored = Document.fromJson(stored);
+restored.equals(doc);               // true
+```
+
+Throws a JS `Error` on malformed JSON, an unknown `schema` tag, or a
+malformed payload. The restored document has no parse-time `warnings`.
+
 ### `doc.equals(other)`
 Structural equality between two `Document` handles. Compares `main` and
 `cards` by value; parse-time `warnings` are intentionally excluded.

package/bundler/wasm.d.ts

@@ -280,6 +280,22 @@ export class Document {
      * `Document` and compare instead of re-parsing on every keystroke.
      */
     equals(other: Document): boolean;
+    /**
+     * Reconstruct a `Document` from its versioned storage DTO string.
+     *
+     * `json` must be a string produced by [`toJson`](Document::to_json) —
+     * the versioned storage DTO. Parsing and schema dispatch happen inside
+     * the module via `serde_json`; the JS `JSON` global is not involved.
+     * Unknown `schema` tags are rejected.
+     *
+     * The reconstructed document carries no parse-time warnings — the DTO
+     * describes content, not source text — so `.warnings` is always empty.
+     *
+     * Throws a JS `Error` if `json` is not a valid storage DTO (malformed
+     * JSON, unknown `schema`, missing fields, or an unparseable quill
+     * reference).
+     */
+    static fromJson(json: string): Document;
     /**
      * Parse markdown into a typed Document.
      *
@@ -393,6 +409,25 @@ export class Document {
      * Mutators never modify `warnings`.
      */
     setQuillRef(ref_str: string): void;
+    /**
+     * Serialize this document to a versioned storage DTO string.
+     *
+     * Returns the document as a JSON string carrying a `schema` version
+     * tag. The string is produced inside the module via `serde_json` and
+     * round-trips losslessly back to an equal `Document` via
+     * [`fromJson`](Document::from_json) — the JS `JSON` global is not
+     * involved in either direction.
+     *
+     * Use this — not [`toMarkdown`](Document::to_markdown) — to persist a
+     * document across a process restart or crate upgrade; the wire format
+     * is frozen per `schema` version, whereas Markdown syntax evolves.
+     * Parse-time `warnings` are not part of the DTO.
+     *
+     * The result is standard JSON text, so callers that want to inspect it
+     * may `JSON.parse` it — but treating it as an opaque blob is the
+     * intended use.
+     */
+    toJson(): string;
     /**
      * Emit canonical Quillmark Markdown.
      *

package/bundler/wasm_bg.js

@@ -78,6 +78,40 @@ export class Document {
         const ret = wasm.document_equals(this.__wbg_ptr, other.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Reconstruct a `Document` from its versioned storage DTO string.
+     *
+     * `json` must be a string produced by [`toJson`](Document::to_json) —
+     * the versioned storage DTO. Parsing and schema dispatch happen inside
+     * the module via `serde_json`; the JS `JSON` global is not involved.
+     * Unknown `schema` tags are rejected.
+     *
+     * The reconstructed document carries no parse-time warnings — the DTO
+     * describes content, not source text — so `.warnings` is always empty.
+     *
+     * Throws a JS `Error` if `json` is not a valid storage DTO (malformed
+     * JSON, unknown `schema`, missing fields, or an unparseable quill
+     * reference).
+     * @param {string} json
+     * @returns {Document}
+     */
+    static fromJson(json) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document_fromJson(retptr, 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 Document.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Parse markdown into a typed Document.
      *
@@ -394,6 +428,49 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Serialize this document to a versioned storage DTO string.
+     *
+     * Returns the document as a JSON string carrying a `schema` version
+     * tag. The string is produced inside the module via `serde_json` and
+     * round-trips losslessly back to an equal `Document` via
+     * [`fromJson`](Document::from_json) — the JS `JSON` global is not
+     * involved in either direction.
+     *
+     * Use this — not [`toMarkdown`](Document::to_markdown) — to persist a
+     * document across a process restart or crate upgrade; the wire format
+     * is frozen per `schema` version, whereas Markdown syntax evolves.
+     * Parse-time `warnings` are not part of the DTO.
+     *
+     * The result is standard JSON text, so callers that want to inspect it
+     * may `JSON.parse` it — but treating it as an opaque blob is the
+     * intended use.
+     * @returns {string}
+     */
+    toJson() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_toJson(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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Emit canonical Quillmark Markdown.
      *

package/bundler/wasm_bg.wasm.d.ts

@@ -9,6 +9,7 @@ export const document_cardCount: (a: number) => number;
 export const document_cards: (a: number) => number;
 export const document_clone: (a: number) => number;
 export const document_equals: (a: number, b: number) => number;
+export const document_fromJson: (a: number, b: number, c: number) => void;
 export const document_fromMarkdown: (a: number, b: number, c: number) => void;
 export const document_insertCard: (a: number, b: number, c: number, d: number) => void;
 export const document_main: (a: number) => number;
@@ -23,6 +24,7 @@ export const document_setCardTag: (a: number, b: number, c: number, d: number, e
 export const document_setField: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document_setFill: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document_setQuillRef: (a: number, b: number, c: number, d: number) => void;
+export const document_toJson: (a: number, b: number) => void;
 export const document_toMarkdown: (a: number, b: number) => void;
 export const document_updateCardBody: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document_updateCardField: (a: number, b: number, c: number, d: number, e: number, f: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.80.0",
+  "version": "0.81.0-rc.1",
   "description": "WebAssembly bindings for quillmark",
   "type": "module",
   "license": "MIT OR Apache-2.0",