@quillmark/wasm 0.125.0 → 0.126.0

package/README.md

@@ -2,7 +2,7 @@
 
 WebAssembly bindings for Quillmark.
 
-Maintained by [TTQ](https://tonguetoquill.com).
+Maintained by [borb-sh](https://github.com/borb-sh).
 
 ## Overview
 
@@ -21,25 +21,10 @@ own linear memory, lazily loaded on the first render. The Engine clones a
 `Quill` / `Document` into that memory as data and frees the clones: you never
 hold a backend object or cross a memory boundary yourself.
 
-## Build
+## Installation
 
 ```bash
-bash scripts/build-wasm.sh
-```
-
-The script builds two variants, the core (no backend) and the render build
-(default features, both backends), each with `--target web` and `--weak-refs`
-enabled (see
-[Initialization](#initialization) and [Lifecycle](#lifecycle)). It then asserts
-none of them carries a `.wasm` ESM import or a top-level await.
-
-## Test
-
-```bash
-bash scripts/build-wasm.sh
-cd crates/bindings/wasm
-npm install
-npm test
+npm install @quillmark/wasm
 ```
 
 ## Usage
@@ -147,6 +132,10 @@ const session = await engine.open(quill, doc); // one compile, current document
 `load` reads only `quill.backendId` and clones nothing. A failed load rejects
 with `runtime::backend_load_failed`, and the next call retries.
 
+A render that traps (out of memory, a panic) rejects with
+`runtime::backend_trapped`, the `WebAssembly.RuntimeError` on `cause`. The
+build's state is then undefined: terminate the Worker or restart the process.
+
 ### The two doors: `Document.fromMarkdown` vs `quill.parse` / `quill.conform`
 
 `Document.fromMarkdown` is the quill-free **transport door** (migrations, `$ext`
@@ -157,7 +146,7 @@ as authored.
 `quill.parse` is the **bound door**, and the primary ingestion path. It is
 `Document.fromMarkdown` followed by `conform`: the returned document's declared
 content fields rest at one form per codec (a `richtext` field as the canonical
-content object, a `plaintext` field as its literal string), so `getStored`
+content object, a `text` field as its literal string), so `getStored`
 answers "content object or string?" by the field's declared codec rather than by how the
 document was built. Parse warnings and the `conform::*` warnings both ride
 `doc.warnings`.
@@ -205,7 +194,9 @@ and writes that same value.
   mark `type` or island `type` outside the vocabulary. Those are refused from
   0.113 on; see that release's migration guide. An island `loss` is not one of
   them: 0.115 drops the key, so a row spelling one opens whatever the class and
-  comes back without it.
+  comes back without it. From 0.126 on, a row whose `$quill` is a lone major,
+  `memo@1`, or whose body nests past 12 levels is refused too; rewrite it
+  before upgrading, as that release's migration guide shows.
 - **Downgrading is not.** `fromStored` rejects an *unknown* (i.e. newer)
   `schema` version rather than guessing at a format it predates. Don't feed
   documents written by a newer build back into an older one.
@@ -236,8 +227,8 @@ values from the `Document` payload: there is no separate form-view projection.
 `quill.validate(doc)` scores it without invoking the backend.
 
 `quill.exampleDocument()` returns the quill's example, a filled-in page whose
-values are made up, pinned to the quill's `name@version`; `undefined` when
-the quill has no `example.md` at its root.
+values are made up, pinned to the quill's `name@MAJOR.MINOR`; `undefined`
+when the quill has no `example.md` at its root.
 
 `quill.seedDocument()` returns a starter document: one card per kind, each
 carrying the kind's `seed` from `Quill.yaml` and no other field;
@@ -274,7 +265,7 @@ address. `getStored` is the verbatim transport read, distinct from the interpret
 `quill.reader(doc).get`; `bodyMarkdown` is the body markdown read (a `CardAddr`; a field's
 markdown is read through `quill.reader(doc).get(field)`). A content field's stored
 form rests per its declared codec through the bound door (a `richtext` field as
-the content object, a `plaintext` field as its literal string), and as authored
+the content object, a `text` field as its literal string), and as authored
 through the transport door. For the `Content` either way read
 `quill.reader(doc).getContent(addr)`, which decodes through the codec the
 field's declared type names. Card-scoped verbs take a
@@ -334,7 +325,7 @@ ed.set("subject", "Q3 results");                    // strict-committed to the s
 ed.setAll({ qty: "3", subject: "Q3" });             // all-or-nothing batch
 ed.reviseField("subject", "Q3 **results**");        // typed AND anchor-preserving; returns { delta, warnings }
 ed.set("titel", "x");                               // throws UnknownField: a typo, not a fallback
-ed.card(2).set("body", "**note**");                 // composable card, resolved by its $kind
+ed.card(2).reviseBody("**note**");                  // a composable card's body; its fields take set / setAll
 ```
 
 `DocumentWriter` / `CardWriter` are pure JS holding references to your existing
@@ -351,7 +342,7 @@ const v = quill.reader(doc);
 v.get("subject");                                   // the values form: every content leaf as its codec's text, else as stored
 v.getContent("subject");                            // the same read as a `Content`, whichever lane stored it
 v.bodyMarkdown();                                   // the main body markdown (quill-free)
-v.card(0).get("body");                              // a card field, resolved by its $kind
+v.card(0).bodyMarkdown();                           // a card's body markdown; its fields read through get
 v.resolve();                                        // the render view: blank-filled, coerced, each field tagged with its rung
 ```
 
@@ -544,11 +535,11 @@ call returns: `try { return engine.render(quill, doc); } finally
 { doc.free(); }`: is safe even on the first render, while the backend
 binary is still loading.
 
-The package floor is Node 24+ (`engines: { node: ">=24" }`) and current
+The package floor is Node 22+ (`engines: { node: ">=22" }`) and current
 evergreen browsers; `--weak-refs` itself only needs Node 14.6+. The `using`
-sugar ([explicit resource management][erm]) is on that floor and optional;
+sugar ([explicit resource management][erm]) needs Node 24 and is optional;
 an explicit `try` / `finally` is the equivalent, and the form that also runs
-in a browser that hasn't shipped it:
+on Node 22 and in a browser that hasn't shipped it:
 
 ```ts
 const session = await engine.open(quill, doc);
@@ -563,6 +554,27 @@ try {
 
 [erm]: https://github.com/tc39/proposal-explicit-resource-management
 
+## Build
+
+```bash
+bash scripts/build-wasm.sh
+```
+
+The script builds two variants, the core (no backend) and the render build
+(default features, both backends), each with `--target web` and `--weak-refs`
+enabled (see
+[Initialization](#initialization) and [Lifecycle](#lifecycle)). It then asserts
+none of them carries a `.wasm` ESM import or a top-level await.
+
+## Test
+
+```bash
+bash scripts/build-wasm.sh
+cd crates/bindings/wasm
+npm ci
+npm test
+```
+
 ## Changelog
 
 See the [changelog](https://github.com/borb-sh/quillmark/blob/main/CHANGELOG.md)