@quillmark/wasm 0.131.0 → 0.133.0

package/render/wasm.js

@@ -444,8 +444,9 @@ export class Document {
      * The newest storage version this build writes via
      * [`toStored`](Document::to_stored): a document spelling a font mark, a
      * `table` element, a merged table cell or a table head 0.130 cannot draw
-     * carries it, every other the tag before it, which a 0.130 build reads. The tag advances only when the wire format changes, not on
-     * every release.
+     * carries it, every other the tag before it, which a 0.130 build reads.
+     * The tag advances only when the wire format changes, not on every
+     * release.
      * @returns {string}
      */
     static currentStorageVersion() {
@@ -713,8 +714,9 @@ export class Document {
     /**
      * **Overwrite** the content value at `addr` with exactly `rt`: value
      * semantics, so the identity anchors of any previous value are gone. By
-     * anchor fate `overwrite` destroys, [`revise`](Document::revise) rebases,
-     * and [`applyChange`](Document::apply_change) preserves. An absent
+     * anchor fate `overwrite` destroys, [`revise`](Document::revise) and
+     * [`reviseContent`](Document::revise_content) rebase, and
+     * [`applyChange`](Document::apply_change) preserves. An absent
      * `addr.field` targets the body, an absent `addr.card` the main card.
      *
      * Throws on an out-of-range card, a malformed field name, or an `rt` that is
@@ -903,6 +905,40 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * **Revise** the richtext value at `addr` to `rt`, keeping each stored prose
+     * anchor whose id `rt` does not hold: the content twin of
+     * [`revise`](Document::revise), for a value built elsewhere such as a
+     * merge's projection. Diffs `rt` against the current value, carries those
+     * anchors through the diff, and returns the
+     * `Revised` receipt, whose `delta` an editor bridge maps its own positions
+     * through and whose `warnings` is empty. `rt`'s own anchors and island ids
+     * land as they are. An absent `addr.field` targets the body, an absent
+     * `addr.card` the main card; an absent field diffs from empty. Richtext
+     * only: a `text` field takes `overwrite`.
+     *
+     * Throws on an out-of-range card, a malformed field name, a present
+     * non-content field value, or an `rt` that is not a canonical content
+     * object.
+     * @param {Addr | string} addr
+     * @param {Content} rt
+     * @returns {Revised}
+     */
+    reviseContent(addr, rt) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_reviseContent(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(rt));
+            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 richtext value at `addr` from a markdown string: the
      * default write path. Imports the markdown, diffs it against the current
@@ -1727,35 +1763,38 @@ export class Quill {
         }
     }
     /**
-     * The *declared* backend identifier (e.g. `"typst"`): intent, not a
-     * resolved capability. Capability is read from the engine.
-     * @returns {string}
+     * JSON Schema (draft 2020-12) of the quill's authoring document: the
+     * shape `fromAuthoring` takes and `toAuthoring` returns, every content
+     * leaf a Markdown or literal string, each card kind under `$defs`
+     * selected by `kind`.
+     * @returns {Record<string, unknown>}
      */
-    get backendId() {
-        let deferred1_0;
-        let deferred1_1;
+    get authoringSchema() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quill_backendId(retptr, this.__wbg_ptr);
+            wasm.quill_authoringSchema(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
     /**
+     * The *declared* backend identifier (e.g. `"typst"`): intent, not a
+     * resolved capability. Capability is read from the engine.
      * @returns {string}
      */
-    get blueprint() {
+    get backendId() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quill_blueprint(retptr, this.__wbg_ptr);
+            wasm.quill_backendId(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             deferred1_0 = r0;
@@ -1799,7 +1838,7 @@ export class Quill {
      * The empty document: a main card carrying this quill's `$quill` and
      * `$kind: main`, no field committed, no composable card, no body. The
      * type-minimal valid input, and the document a plate is bound to render
-     * (the quill authoring contract). `new Document(ref)` is the same document
+     * (the plate contract). `new Document(ref)` is the same document
      * reached by spelling the reference.
      * @returns {Document}
      */
@@ -1808,25 +1847,63 @@ export class Quill {
         return Document.__wrap(ret);
     }
     /**
-     * The quill's example document, `undefined` when the quill has no
-     * `example.md` at its root: a filled-in page whose values are made up to show the
-     * quill in use, never kept. It comes back pinned to this quill's
-     * `name@MAJOR.MINOR` and conformed as `parse` conforms, its parse and
-     * `conform::*` warnings on `doc.warnings`. Throws when the file does not
-     * parse or its `$quill` is not this quill's bare name.
+     * The quill's example document, `undefined` when no slot or body declares
+     * an example: the seeded document with every declared `example` committed
+     * as its cell's value and each kind's `body.example` as its body. A
+     * filled-in page whose values are made up to show the quill in use, never
+     * kept.
      * @returns {Document | undefined}
      */
     exampleDocument() {
+        const ret = wasm.quill_exampleDocument(this.__wbg_ptr);
+        return ret === 0 ? undefined : Document.__wrap(ret);
+    }
+    /**
+     * A document from an authoring document, conformed against this quill:
+     * the JSON twin of `parse`. A `null` is absent; the document carries this
+     * quill's `$quill`. A value the schema refuses lands with a `conform::*`
+     * warning on `doc.warnings`, and `validate` reports the rest at document
+     * paths. Throws, with every error found, on a value that is not the
+     * authoring document's shape (`authoring::invalid_shape`) or a name or
+     * kind no card can store (`edit::*`).
+     * @param {AuthoringDocument} value
+     * @returns {Document}
+     */
+    fromAuthoring(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.quill_fromAuthoring(retptr, this.__wbg_ptr, addHeapObject(value));
+            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);
+        }
+    }
+    /**
+     * Read a `.quill` bundle, the zip archive holding one quill's file tree.
+     * Pure, as [`fromTree`](Self::from_tree) is. A bundle outside the format
+     * throws one `quill::bundle_*` diagnostic.
+     * @param {Uint8Array} bytes
+     * @returns {Quill}
+     */
+    static fromBundle(bytes) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quill_exampleDocument(retptr, this.__wbg_ptr);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.quill_fromBundle(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 r0 === 0 ? undefined : Document.__wrap(r0);
+            return Quill.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -1987,6 +2064,53 @@ export class Quill {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * `doc` as an authoring document: every field in the values form (each
+     * content leaf its codec's text), every body as Markdown, each card
+     * `{kind, fields, body}`. Sparse: an absent or `null` field stays absent. A
+     * content leaf that decodes under neither encoding exports as stored.
+     * @param {Document} doc
+     * @returns {AuthoringDocument}
+     */
+    toAuthoring(doc) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(doc, Document);
+            wasm.quill_toAuthoring(retptr, this.__wbg_ptr, doc.__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);
+        }
+    }
+    /**
+     * This quill's file tree as a `.quill` bundle, the bytes
+     * [`fromBundle`](Self::from_bundle) reads.
+     * @returns {Uint8Array}
+     */
+    toBundle() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.quill_toBundle(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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Flatten this quill back into its canonical file tree, the inverse of
      * [`fromTree`](Self::from_tree). Keys are `"/"`-joined relative paths.
@@ -2288,6 +2412,30 @@ export function mapPos(delta, pos, assoc) {
     }
 }
 
+/**
+ * The canonical form of `rt`: the content `overwrite` stores from it, read
+ * without a document. Normalizing rewrites structure, never the text, so the
+ * answer's `text` is `rt.text`. Throws where `overwrite` would, with the same
+ * error under this verb's name.
+ * @param {Content} rt
+ * @returns {Content}
+ */
+export function normalize(rt) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.normalize(retptr, addHeapObject(rt));
+        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);
+    }
+}
+
 /**
  * Parse a canonical document-model `Diagnostic.path` (`cards.<kind>[<i>].<field>`,
  * `main.body`, `recipients[0].name`) into structured `DocPathSeg` segments, so
@@ -2899,6 +3047,13 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/render/wasm_bg.wasm.d.ts

@@ -41,6 +41,7 @@ export const document_removeExt: (a: number, b: number, c: number) => void;
 export const document_removeField: (a: number, b: number, c: number) => void;
 export const document_removeSeedOverlay: (a: number, b: number, c: number, d: number) => void;
 export const document_revise: (a: number, b: number, c: number, d: number, e: number) => void;
+export const document_reviseContent: (a: number, b: number, c: number, d: number) => void;
 export const document_seedOverlay: (a: number, b: number, c: number, d: number) => void;
 export const document_setQuillRef: (a: number, b: number, c: number, d: number) => void;
 export const document_storageVersionOf: (a: number, b: number, c: number) => void;
@@ -78,13 +79,16 @@ export const livesession_update: (a: number, b: number, c: number) => void;
 export const livesession_warnings: (a: number, b: 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 normalize: (a: number, b: number) => void;
 export const parseDocPath: (a: number, b: number, c: number) => void;
 export const quill__resolve: (a: number, b: number, c: number, d: number, e: number) => void;
+export const quill_authoringSchema: (a: number, b: number) => void;
 export const quill_backendId: (a: number, b: number) => void;
-export const quill_blueprint: (a: number, b: number) => void;
 export const quill_conform: (a: number, b: number, c: number) => void;
 export const quill_emptyDocument: (a: number) => number;
-export const quill_exampleDocument: (a: number, b: number) => void;
+export const quill_exampleDocument: (a: number) => number;
+export const quill_fromAuthoring: (a: number, b: number, c: number) => void;
+export const quill_fromBundle: (a: number, b: number, c: number) => void;
 export const quill_fromTree: (a: number, b: number) => void;
 export const quill_metadata: (a: number, b: number) => void;
 export const quill_parse: (a: number, b: number, c: number, d: number) => void;
@@ -92,6 +96,8 @@ export const quill_schema: (a: number, b: number) => void;
 export const quill_seedCard: (a: number, b: number, c: number, d: number, e: number) => void;
 export const quill_seedDocument: (a: number) => number;
 export const quill_seedMain: (a: number, b: number) => void;
+export const quill_toAuthoring: (a: number, b: number, c: number) => void;
+export const quill_toBundle: (a: number, b: number) => void;
 export const quill_toTree: (a: number) => number;
 export const quill_validate: (a: number, b: number, c: number) => void;
 export const quill_warnings: (a: number, b: number) => void;

package/runtime/runtime.d.ts

@@ -18,6 +18,7 @@ import type {
 	Document as CoreDocument,
 	importMarkdown,
 	exportMarkdown,
+	normalize,
 	rebase,
 	mapPos,
 	mapMarks,
@@ -40,6 +41,7 @@ export interface CoreSurface {
 	Document: typeof CoreDocument;
 	importMarkdown: typeof importMarkdown;
 	exportMarkdown: typeof exportMarkdown;
+	normalize: typeof normalize;
 	rebase: typeof rebase;
 	mapPos: typeof mapPos;
 	mapMarks: typeof mapMarks;
@@ -113,7 +115,9 @@ export type {
 	QuillFieldUi,
 	QuillCardUi,
 	QuillGroupUi,
-	QuillMetadata
+	QuillMetadata,
+	AuthoringDocument,
+	AuthoringCard
 } from '../core/wasm.js';
 
 // Content edit vocabulary: the op-grained content model `Document`'s methods
@@ -267,6 +271,12 @@ export interface RenderOptions {
 	 * consumers without a live session. Defaults to `false`.
 	 */
 	regions?: boolean;
+	/**
+	 * The PDF document title, over the plate's own `set document(title: ..)`
+	 * and then the quill's `description`. A blank title counts as absent;
+	 * ignored by PNG and SVG.
+	 */
+	title?: string;
 }
 
 /**

package/runtime/runtime.js

@@ -19,7 +19,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, mapMarks } from '../core/wasm.js';
+import { importMarkdown, exportMarkdown, normalize, rebase, mapPos, mapMarks } from '../core/wasm.js';
 import { isInline, isPlain } from '../core/wasm.js';
 import { parseDocPath, formatDocPath, formatDiagnostic } from '../core/wasm.js';
 
@@ -47,6 +47,7 @@ const CORE_SURFACE = Object.freeze({
 	Document,
 	importMarkdown,
 	exportMarkdown,
+	normalize,
 	rebase,
 	mapPos,
 	mapMarks,
@@ -278,7 +279,7 @@ const HANDLE_KINDS = {
 	},
 	Document: {
 		code: 'runtime::not_a_document',
-		hint: 'Pass a Document built by Document.fromMarkdown / fromStored or quill.seedDocument / emptyDocument. A Document from another copy of @quillmark/wasm is refused too — each copy is its own WASM linear memory and its own class — so run `npm ls @quillmark/wasm` and dedupe to one.'
+		hint: 'Pass a Document built by Document.fromMarkdown / fromStored or quill.seedDocument / emptyDocument / fromAuthoring. A Document from another copy of @quillmark/wasm is refused too — each copy is its own WASM linear memory and its own class — so run `npm ls @quillmark/wasm` and dedupe to one.'
 	}
 };
 
@@ -331,10 +332,9 @@ function requireLocalQuill(quill, method) {
 // `runtime.test.js` § "container run boundaries" stamps a pair and re-imports
 // it, where `Content::normalize` re-mints against the Rust predicate. A tag the
 // table omits welds with nothing, so `tests/known_names_drift.rs` pins that
-// every container has an entry. An entry of `'*'` welds on the whole bag: an
-// element's attributes are open, its name among them.
+// every container has an entry.
 
-const WELD_KEYS = { list_item: ['ordered'], quote: [], description: [], element: '*' };
+const WELD_KEYS = { list_item: ['ordered'], quote: [] };
 
 /**
  * @param {import('../core/wasm.js').ContentContainer} a
@@ -347,20 +347,7 @@ function weldsWith(a, b) {
 	// `hasOwn`, so a tag colliding with an `Object.prototype` member answers
 	// `false` rather than reaching a function.
 	if (!Object.hasOwn(WELD_KEYS, a.container)) return false;
-	const keys = WELD_KEYS[a.container];
-	if (keys === '*') return sameBag(a.attrs, b.attrs);
-	return keys.every((k) => a.attrs?.[k] === b.attrs?.[k]);
-}
-
-/**
- * @param {Record<string, unknown> | undefined} a
- * @param {Record<string, unknown> | undefined} b
- * @returns {boolean}
- */
-function sameBag(a, b) {
-	const [x, y] = [a ?? {}, b ?? {}];
-	const keys = Object.keys(x);
-	return keys.length === Object.keys(y).length && keys.every((k) => Object.hasOwn(y, k) && x[k] === y[k]);
+	return WELD_KEYS[a.container].every((k) => a.attrs?.[k] === b.attrs?.[k]);
 }
 
 /**
@@ -654,7 +641,7 @@ export class Engine {
 	/**
 	 * @param {Quill} quill
 	 * @param {Document} doc
-	 * @param {object} [options] render options (`{ format, ppi, pages, regions }`)
+	 * @param {object} [options] render options (`{ format, ppi, pages, regions, title }`)
 	 * @param {string} [today] the render date, `YYYY-MM-DD`
 	 * @returns {Promise<import('./runtime.js').RenderResult>}
 	 */