@quillmark/wasm 0.99.0 → 0.101.0

package/backends/typst/wasm_bg.js

@@ -169,7 +169,48 @@ export class Document {
         }
     }
     /**
-     * Revise the richtext field at `addr` from markdown, typed *and*
+     * Interpreted **corpus** read at `addr`: the stable ABI under the runtime
+     * `reader.getContent` / `reader.card(i).getContent`. The corpus twin of
+     * [`reader.get`](Self::reader_get), which projects; this decodes the stored
+     * value through the codec the field's declared type names (`richtext` as
+     * markdown, `plaintext` as literal text) and returns the canonical `Content`.
+     *
+     * Total over the storage form: a committed field holds a content object and
+     * a parsed one holds the authored string, and both read back as a corpus
+     * here, so a consumer mounting a corpus editor stops branching on how the
+     * document was built.
+     *
+     * A bare string is `Addr` shorthand for `{ field }`; `{ card, field }`
+     * targets a composable card. Returns `undefined` for an **absent** field. An
+     * absent `addr.field` reads the **body** corpus, quill-free, mirroring
+     * [`getStored`](Self::get_stored). Throws `edit::unknown_field` for a name
+     * the schema does not declare, `edit::field_not_content` for a declared type
+     * that is not a content leaf (`array<richtext>` carries content and still has
+     * no one corpus), `edit::field_richtext_decode` for a stored value
+     * that decodes under neither encoding, and `edit::index_out_of_range` for a
+     * bad `addr.card`.
+     * @param {Quill} quill
+     * @param {Addr | string} addr
+     * @returns {Content | undefined}
+     */
+    _readerGetContent(quill, addr) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(quill, Quill);
+            wasm.document__readerGetContent(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr));
+            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`. Resolves the
      * field's schema from `quill` (main card, or the addressed card's `$kind`)
      * and defers to [`TypedWriter::revise_field`](quillmark_core::TypedWriter::revise_field):
@@ -178,6 +219,9 @@ export class Document {
      * multi-block result with `edit::field_richtext_not_inline`. Returns the
      * text `Delta`.
      *
+     * The codec is the declared type's: `richtext` diffs markdown, `plaintext`
+     * the literal text.
+     *
      * `addr` must name a field (a bare string is `{ field }`); a body address
      * throws (a body carries no field schema: use [`revise`](Self::revise)). A
      * name the schema does not declare throws `edit::unknown_field`. Throws
@@ -185,14 +229,14 @@ export class Document {
      * `writer.reviseField` in the runtime layer.
      * @param {Quill} quill
      * @param {Addr | string} addr
-     * @param {string} markdown
+     * @param {string} text
      * @returns {Delta}
      */
-    _reviseField(quill, addr, markdown) {
+    _reviseField(quill, addr, text) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(quill, Quill);
-            const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
             wasm.document__reviseField(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
@@ -207,11 +251,16 @@ export class Document {
         }
     }
     /**
-     * **Apply** a committed content edit `bundle` (`{ delta?, lineOps?, markOps? }`)
-     * at `addr`, the editor splice: text delta first, then line ops, then mark
-     * ops (mark ranges in final-text coordinates), each all-or-nothing. An absent
+     * **Apply** a committed content edit `bundle`
+     * (`{ delta?, islandOps?, lineOps?, markOps? }`) at `addr`, the editor
+     * splice: text delta first, then island ops, then line ops, then mark ops
+     * (mark ranges in final-text coordinates), each all-or-nothing. An absent
      * `addr.field` targets the body, an absent `addr.card` the main card.
      *
+     * The island channel keeps a table or image edit on the op path: it moves
+     * the island alone, so the anchors elsewhere in the field survive an edit
+     * `install` would clear.
+     *
      * 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).
@@ -289,20 +338,6 @@ export class Document {
         const ret = wasm.document_cardCount(this.__wbg_ptr);
         return ret >>> 0;
     }
-    /**
-     * The index of the composable card whose `$id` equals `id`, or
-     * `undefined` when none carries it. Resolves the durable card handle
-     * without a hand-rolled scan over [`cards`](Self::cards); `$id` is
-     * unique per document, so at most one card matches.
-     * @param {string} id
-     * @returns {number | undefined}
-     */
-    cardIndexById(id) {
-        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.document_cardIndexById(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
     /**
      * @returns {Card[]}
      */
@@ -536,8 +571,7 @@ export class Document {
     }
     /**
      * Read the **verbatim stored value** at `addr`: the raw payload value of a
-     * field (a content object for a richtext field, a scalar/array/object
-     * otherwise), or the **body content** when `addr.field` is absent. A bare
+     * field, or the **body content** when `addr.field` is absent. A bare
      * string is `Addr` shorthand for `{ field }`. Reads are total over the field
      * axis: an absent field is `undefined`; only an out-of-range `addr.card`
      * throws `edit::index_out_of_range`. Needs no schema, so it lives on
@@ -545,6 +579,16 @@ export class Document {
      * the interpreted schema-plane [`reader.get`](Self::reader_get). For the
      * markdown projection use [`getMarkdown`](Self::get_markdown) (body) or
      * `reader.get` (a field's declared type).
+     *
+     * **A content field at rest has one stored form per codec**: a `richtext`
+     * field holds the canonical content object, a `plaintext` field its literal
+     * string. A document that came through the bound door (`quill.parse` /
+     * `quill.conform`) is at rest, so this read no longer depends on which lane
+     * built it. A document that came through the transport door
+     * (`Document.fromMarkdown`, a legacy stored row) may rest as authored until
+     * it is conformed, and this read reports what is there. For the corpus
+     * either way, use the schema-plane `reader.getContent`, which decodes
+     * through the codec the field's declared type names.
      * @param {Addr | string} addr
      * @returns {unknown}
      */
@@ -1254,6 +1298,10 @@ export class Document {
         return ret === 0 ? undefined : Document.__wrap(ret);
     }
     /**
+     * The non-fatal diagnostics of the load that produced this document: parse
+     * warnings, plus the `conform::*` warnings when it came through
+     * `quill.parse`. Session state, not document value: `equals` and the
+     * storage DTO exclude it, and `fromJson` / `loadJson` clear it.
      * @returns {Diagnostic[]}
      */
     get warnings() {
@@ -1649,6 +1697,40 @@ export class Quill {
             wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Land `doc`'s declared content fields at their canonical rest **in
+     * place**, returning the `conform::*` diagnostics for the values that would
+     * not commit (an empty array when everything rested).
+     *
+     * The read-repair verb: a document that arrived through the transport door
+     * (`fromMarkdown`, `fromJson`, a stored row) converges here, and is then
+     * eligible for rewrite under its current schema tag. Idempotent, and a
+     * no-op on an already-canonical document: an equal value is not rewritten,
+     * so YAML comments and stored bytes survive.
+     *
+     * A `!must_fill` marker anywhere in a field's value skips that field (the
+     * marker is the state), and a value the strict write refuses stays as
+     * authored with a diagnostic. Throws when `doc` declares a different
+     * `$quill`, before any mutation.
+     * @param {Document} doc
+     * @returns {Diagnostic[]}
+     */
+    conform(doc) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(doc, Document);
+            wasm.quill_conform(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);
+        }
+    }
     /**
      * Build a quill from a file tree. Pure: no backend, no engine; the
      * declared backend is resolved later, at render time.
@@ -1697,6 +1779,39 @@ export class Quill {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Parse `markdown` and conform it against this quill: the **primary
+     * ingestion path**, and the bound twin of the schema-free
+     * `Document.fromMarkdown`. The returned document rests at its canonical
+     * form (a `richtext` field as a content object, a `plaintext` field as its
+     * literal string), so `getStored` no longer answers "corpus or string?"
+     * with "depends how this document was built".
+     *
+     * Parse warnings and the `conform::*` diagnostics both land on
+     * `doc.warnings`. Throws on a parse failure, or when `markdown` declares a
+     * `$quill` this quill does not answer to: nothing conforms under the wrong
+     * schema. To open a document whose `$quill` is stale, use the transport
+     * door (`Document.fromMarkdown`, `setQuillRef`, then `quill.conform`).
+     * @param {string} markdown
+     * @returns {Document}
+     */
+    parse(markdown) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.quill_parse(retptr, this.__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 Document.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * The resolved-value view of `doc` against this quill's schema: for every
      * declared field the value the render projection would use and the

package/backends/typst/wasm_bg.wasm.d.ts

@@ -9,12 +9,12 @@ export const document__addCard: (a: number, b: number, c: number, d: number, e:
 export const document__commitField: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document__commitFields: (a: number, b: number, c: number, d: number, e: number) => void;
 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__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_blueprintInstruction: (a: number, b: number, c: number) => void;
 export const document_card: (a: number, b: number, c: number) => void;
 export const document_cardCount: (a: number) => number;
-export const document_cardIndexById: (a: number, b: number, c: number) => number;
 export const document_cards: (a: number, b: number) => void;
 export const document_clone: (a: number) => number;
 export const document_currentSchemaVersion: (a: number) => void;
@@ -78,8 +78,10 @@ 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;
 export const quill_blueprint: (a: number, b: number) => void;
+export const quill_conform: (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;
 export const quill_resolve: (a: number, b: number, c: number) => void;
 export const quill_schema: (a: number, b: number) => void;
 export const quill_seedCard: (a: number, b: number, c: number, d: number, e: number) => void;

package/core/wasm.d.ts

@@ -32,14 +32,13 @@ export type PayloadItem =
  *
  * `$` system entries are hoisted to named fields: `kind` (the `$kind`, empty
  * string when none), optional `quill` (the `$quill` `name@version`, main card
- * only), optional `id` (`$id`), optional `ext` (`$ext`), and optional `seed`
+ * only), optional `ext` (`$ext`), and optional `seed`
  * (the `$seed` per-kind overlay map, main card only). `payloadItems` carries
  * user fields and comments in order.
  */
 export interface Card {
     kind: string;
     quill?: string;
-    id?: string;
     ext?: Record<string, unknown>;
     seed?: Record<string, unknown>;
     payloadItems: PayloadItem[];
@@ -63,7 +62,6 @@ export interface Card {
 export interface CardInput {
     kind: string;
     quill?: string;
-    id?: string;
     ext?: Record<string, unknown>;
     seed?: Record<string, unknown>;
     payloadItems?: PayloadItem[];
@@ -242,13 +240,42 @@ export type LineOp =
 | { op: "setContainers"; line: number; containers: ContentContainer[] }
 | { op: "setContinues"; line: number; continues: boolean };
 
+/**
+ * An island edit: the only channel that reaches an island's payload, a table's
+ * cells or an image's url.
+ *
+ * Both ops move one island entry and leave the field's text and marks alone, so
+ * an island edit keeps every identity anchor in the field. That is why a table
+ * edit lowers to `applyChange` rather than `install`, which drops them all.
+ *
+ * `set` addresses an existing island by `id`; an `id` no island carries throws
+ * rather than passing silently. `insert` places a new island's slot at `at` (a
+ * post-delta USV position) together with its entry, so a slot never exists
+ * without an island behind it; its `id` must be non-empty and unused. Deleting
+ * an island needs no op: a `delta` that removes its slot drops the island.
+ *
+ * A `set` stores the `loss` it is given: nothing re-derives the class from the
+ * new `props`, so a write that changes what markdown can carry must say so.
+ *
+ * An island is *inline* (a slot inside a paragraph) unless its line says
+ * otherwise. A **block** island is one bundle of all three channels, in the
+ * order they apply: `delta` inserts the `\n` that opens the line, `islandOps`
+ * inserts the slot, `lineOps` tags the line `{ op: "setKind", kind: "island" }`.
+ * `{ op: "split" }` cannot open that line, since line ops run after island ops.
+ */
+export type IslandOp =
+| ({ op: "set" } & ContentIsland)
+| ({ op: "insert"; at: number } & ContentIsland);
+
 /**
  * A committed content edit bundle for `applyChange`: a text `delta` (default no
- * text change), then `lineOps`, then `markOps` (mark ranges are in post-delta
- * coordinates). Every field is optional.
+ * text change), then `islandOps`, then `lineOps`, then `markOps` (mark ranges
+ * are in final-text coordinates: every earlier channel applied). Every field is
+ * optional.
  */
 export interface ChangeBundle {
     delta?: Delta;
+    islandOps?: IslandOp[];
     lineOps?: LineOp[];
     markOps?: MarkOp[];
 }
@@ -437,6 +464,16 @@ export interface Diagnostic {
      */
     path?: string;
     hint?: string;
+    /**
+     * The facts `message` interpolates, keyed by name. With `code`, the
+     * substitution unit needed to word this diagnostic in another language;
+     * `prose/canon/ERROR.md` § \"Diagnostic args\" tabulates the keys per code.
+     *
+     * Declared optional explicitly because `tsify` does not read
+     * `skip_serializing_if`: without this, a field the runtime omits is
+     * declared required. `sourceChain` carries that mismatch.
+     */
+    args?: Record<string, unknown>;
     sourceChain?: string[];
 }
 
@@ -462,11 +499,16 @@ export class Document {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * **Apply** a committed content edit `bundle` (`{ delta?, lineOps?, markOps? }`)
-     * at `addr`, the editor splice: text delta first, then line ops, then mark
-     * ops (mark ranges in final-text coordinates), each all-or-nothing. An absent
+     * **Apply** a committed content edit `bundle`
+     * (`{ delta?, islandOps?, lineOps?, markOps? }`) at `addr`, the editor
+     * splice: text delta first, then island ops, then line ops, then mark ops
+     * (mark ranges in final-text coordinates), each all-or-nothing. An absent
      * `addr.field` targets the body, an absent `addr.card` the main card.
      *
+     * The island channel keeps a table or image edit on the op path: it moves
+     * the island alone, so the anchors elsewhere in the field survive an edit
+     * `install` would clear.
+     *
      * 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).
@@ -487,13 +529,6 @@ export class Document {
      * verbs.
      */
     card(index: number): Card;
-    /**
-     * The index of the composable card whose `$id` equals `id`, or
-     * `undefined` when none carries it. Resolves the durable card handle
-     * without a hand-rolled scan over [`cards`](Self::cards); `$id` is
-     * unique per document, so at most one card matches.
-     */
-    cardIndexById(id: string): number | undefined;
     clone(): Document;
     /**
      * Schema version this build writes via [`toJson`](Document::to_json).
@@ -561,8 +596,7 @@ export class Document {
     getMarkdown(addr?: CardAddr): string;
     /**
      * Read the **verbatim stored value** at `addr`: the raw payload value of a
-     * field (a content object for a richtext field, a scalar/array/object
-     * otherwise), or the **body content** when `addr.field` is absent. A bare
+     * field, or the **body content** when `addr.field` is absent. A bare
      * string is `Addr` shorthand for `{ field }`. Reads are total over the field
      * axis: an absent field is `undefined`; only an out-of-range `addr.card`
      * throws `edit::index_out_of_range`. Needs no schema, so it lives on
@@ -570,6 +604,16 @@ export class Document {
      * the interpreted schema-plane [`reader.get`](Self::reader_get). For the
      * markdown projection use [`getMarkdown`](Self::get_markdown) (body) or
      * `reader.get` (a field's declared type).
+     *
+     * **A content field at rest has one stored form per codec**: a `richtext`
+     * field holds the canonical content object, a `plaintext` field its literal
+     * string. A document that came through the bound door (`quill.parse` /
+     * `quill.conform`) is at rest, so this read no longer depends on which lane
+     * built it. A document that came through the transport door
+     * (`Document.fromMarkdown`, a legacy stored row) may rest as authored until
+     * it is conformed, and this read reports what is there. For the corpus
+     * either way, use the schema-plane `reader.getContent`, which decodes
+     * through the codec the field's declared type names.
      */
     getStored(addr: Addr | string): unknown;
     /**
@@ -802,6 +846,12 @@ export class Document {
      */
     readonly main: Card;
     readonly quillRef: string;
+    /**
+     * The non-fatal diagnostics of the load that produced this document: parse
+     * warnings, plus the `conform::*` warnings when it came through
+     * `quill.parse`. Session state, not document value: `equals` and the
+     * storage DTO exclude it, and `fromJson` / `loadJson` clear it.
+     */
     readonly warnings: Diagnostic[];
 }
 
@@ -809,6 +859,23 @@ export class Quill {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Land `doc`'s declared content fields at their canonical rest **in
+     * place**, returning the `conform::*` diagnostics for the values that would
+     * not commit (an empty array when everything rested).
+     *
+     * The read-repair verb: a document that arrived through the transport door
+     * (`fromMarkdown`, `fromJson`, a stored row) converges here, and is then
+     * eligible for rewrite under its current schema tag. Idempotent, and a
+     * no-op on an already-canonical document: an equal value is not rewritten,
+     * so YAML comments and stored bytes survive.
+     *
+     * A `!must_fill` marker anywhere in a field's value skips that field (the
+     * marker is the state), and a value the strict write refuses stays as
+     * authored with a diagnostic. Throws when `doc` declares a different
+     * `$quill`, before any mutation.
+     */
+    conform(doc: Document): Diagnostic[];
     /**
      * Build a quill from a file tree. Pure: no backend, no engine; the
      * declared backend is resolved later, at render time.
@@ -819,6 +886,21 @@ export class Quill {
      * canonical shape.
      */
     static fromTree(tree: Map<string, Uint8Array>): Quill;
+    /**
+     * Parse `markdown` and conform it against this quill: the **primary
+     * ingestion path**, and the bound twin of the schema-free
+     * `Document.fromMarkdown`. The returned document rests at its canonical
+     * form (a `richtext` field as a content object, a `plaintext` field as its
+     * literal string), so `getStored` no longer answers "corpus or string?"
+     * with "depends how this document was built".
+     *
+     * Parse warnings and the `conform::*` diagnostics both land on
+     * `doc.warnings`. Throws on a parse failure, or when `markdown` declares a
+     * `$quill` this quill does not answer to: nothing conforms under the wrong
+     * schema. To open a document whose `$quill` is stale, use the transport
+     * door (`Document.fromMarkdown`, `setQuillRef`, then `quill.conform`).
+     */
+    parse(markdown: string): Document;
     /**
      * The resolved-value view of `doc` against this quill's schema: for every
      * declared field the value the render projection would use and the