@quillmark/wasm 0.109.1 → 0.110.0

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## v0.110.0 - 2026-08-26
+
+- **breaking** wasm: **the seam spells a container's `instance`, so the read
+  type can require it and every write lane reports an omission.** 0.109 gave
+  `Container` the discriminator that tells one container from an adjacent
+  sibling of identical shape, and left it an obligation no checker asked for;
+  the op lane got a requirement, the whole-`Content` lane — `overwrite`,
+  `CardInput.body`, the one a codec flattening a tree writes through — did not.
+  It could not: one encoder served storage and the bindings, writing the key
+  only where it was non-zero, and a field a read may omit is a field a write
+  cannot require. `serial::to_seam_value` is that encoder with every `instance`
+  spelled, and the bindings take it on every lane typed `Content`
+  (`reader.getContent{,At}`, `getStored` on a body, `importMarkdown`, `rebase`,
+  and the card wire behind `document.main` / `cards` / `card(i)` / `removeCard`
+  / `makeCard` / `seedMain` / `seedCard`). `ContentContainer.instance` becomes
+  required, `ContentContainerInput` is deleted, and `LineOp.setContainers` takes
+  `ContentContainer` — a net-smaller surface than 0.109's. The break is every
+  hand-built container literal, which is the one a type checker does report.
+  A checker still cannot report a `0` stamped on every run, which is the write
+  that welds them: `assignInstances` is the rule, not the type. Storage keeps
+  the omission and stored blobs re-encode byte for byte; so do the render lanes,
+  and so does what the seam types `unknown` (`getStored` on a field,
+  `PayloadItem.value`), which answers with the stored bytes verbatim. Content
+  parsed from a stored document is the one shape that needs a cast.
+  [Guide](docs/migrations/0.109-to-0.110.md)
+- fix(core): **`Quill::validate` refuses only what the render floor refuses.**
+  Validation ran its own read-side type dispatch over the authored value while
+  the render door validated the *coerced* one, so five of seven types had values
+  that rendered and were fatally `validation::type_mismatch` at once — a bare
+  scalar for an `array`, `"3"` for an `integer`, `1` for a `boolean`, a
+  length-1 array for a `string` or `date`. `airmark`'s `usaf_memo@0.2` declares
+  `letterhead_caption` as an `array`, and the bare scalar a starter template
+  spells it with — a valid spelling of a one-element list — audited as fatally
+  invalid across every document seeded from it, each rendering correctly.
+
+  `validate_value` now conforms each document value through `conform_value` at
+  `Leniency::Render` before judging it, so a type has one predicate and **a
+  fatal `validation::*` diagnostic means the document does not render**.
+  Conforming runs per node, so one refused element no longer mistypes its
+  siblings: `counts: [true, "abc"]` under `integer` items is one mismatch, at
+  `counts[1]`. Two consequences for a consumer routing on codes: a value the
+  floor adopts raises nothing where it previously raised
+  `validation::type_mismatch`, and a bare scalar the floor stringifies into an
+  `enum` field is now domain-checked on that string, so `grade: 5` against
+  `values: [alpha, beta]` is `validation::enum_violation` where it was
+  previously silent — the diagnostic the render door already raised. Schema
+  literals (`example:`, `default:`) stay strict.
+
 ## v0.109.1 - 2026-08-24
 
 - fix(typst): **a `field-region` claim around inline content no longer widens
@@ -11,17 +59,6 @@
   `form-field`'s marker carries the same shape and drops the space too, rather
   than keep depending on the `box` that follows it.
 
-<!-- seed: commits since v0.109.0, confirm the entries above cover them, then delete this comment
-- docs: dense-prose pass over the branch
-- fix(typst): a marker's label is not a space in the inline flow
-- refactor(wasm): keep the weld rule internal, and pin what states it
-- docs: dense-prose pass over the branch
-- docs: classify 0.109's container break by consumer role
-- feat(wasm)!: make a written container path spell its instance
-- feat(content): name the rule a container's discriminator is minted against
--->
-
-
 ## v0.109.0 - 2026-08-24
 
 - **breaking** content: **`Normalized` is the precondition the projections

package/backends/pdfform/wasm.d.ts

@@ -100,33 +100,24 @@ export type ContentLineKind =
  * shape — two consecutive quotes, two consecutive lists — which contiguity
  * alone reads as one.
  *
- * **A writer owes it.** Give adjacent sibling runs of one shape distinct
- * values, or they arrive as one: a second list's items come back as
- * continuation paragraphs of the first, markers gone. Nothing reports that,
- * since the flat form cannot tell a boundary you meant from one you did not. A
- * codec flattening a tree stamps the field with `assignInstances` from
- * `@quillmark/wasm/runtime` rather than by hand. Any distinct pair of values
- * works; a write is canonicalized to `0`/`1`.
+ * **A writer owes a distinct value per adjacent sibling run**, not merely a
+ * value. Runs of one shape sharing one arrive as one: a second list's items come
+ * back as continuation paragraphs of the first, markers gone. The field is
+ * required, so a checker reports the omission; it cannot report a `0` stamped on
+ * both, which is the same write. A codec flattening a tree takes them from
+ * `assignInstances` in `@quillmark/wasm/runtime` rather than by hand. Any
+ * distinct pair works; a write is canonicalized to `0`/`1`.
  *
- * Reading is not the mirror of writing. The field is absent where it is `0`,
- * and it appears on pairs no writer had to spell. `1.` beside a list starting
- * at `3` differs by `start`, so those runs arrive apart with nothing written —
- * and the canonical form spends a discriminator anyway, because Markdown reads
- * only a list's first number. */
-export type ContentContainer =
-| { container: "list_item"; ordered: boolean; start: number; ordinal: number; instance?: number }
-| { container: "quote"; instance?: number }
-| { container: string; attrs: unknown; instance?: number };
-
-/** A container path on a lane that only ever carries host-built values:
- * `ContentContainer` with `instance` spelled out rather than defaulted. The
- * field that decides whether two adjacent runs weld cannot be omitted by
- * accident here. `assignInstances` returns this shape, and a path copied off a
- * line carries its own instance through — `{ ...c, instance: c.instance ?? 0 }`.
+ * Reading is not the mirror of writing. Every read spells the field, the `0` on
+ * a container with nothing to be told apart from included. A read also carries a
+ * discriminator on pairs no writer had to spell: `1.` beside a list starting at
+ * `3` differs by `start`, so those runs arrive apart with nothing written, and
+ * the canonical form spends one anyway because Markdown reads only a list's
+ * first number.
  *
- * `Content` itself keeps the optional field: it is a read shape as much as a
- * write one, and the wire omits a zero. */
-export type ContentContainerInput =
+ * Content parsed from a stored document is the one shape that arrives without
+ * it — storage omits a zero — and needs a cast. */
+export type ContentContainer =
 | { container: "list_item"; ordered: boolean; start: number; ordinal: number; instance: number }
 | { container: "quote"; instance: number }
 | { container: string; attrs: unknown; instance: number };
@@ -256,7 +247,7 @@ export type LineOp =
 | { op: "split"; at: number }
 | { op: "join"; line: number }
 | ({ op: "setKind"; line: number } & ContentLineKind)
-| { op: "setContainers"; line: number; containers: ContentContainerInput[] }
+| { op: "setContainers"; line: number; containers: ContentContainer[] }
 | { op: "setContinues"; line: number; continues: boolean };
 
 /**
@@ -818,6 +809,10 @@ export class Document {
      * is at rest; one from the transport door may rest as authored until it is
      * conformed, and this read reports what is there. For the `Content` either
      * way use `reader.getContent`.
+     *
+     * The body arm is typed `Content` and answers in the seam form, spelling
+     * every `ContentContainer.instance`. A field arm echoes the stored bytes,
+     * which omit a zero: verbatim is the contract, and is why it is `unknown`.
      */
     getStored(addr: Addr | string): unknown;
     /**

package/backends/pdfform/wasm.js

@@ -608,6 +608,10 @@ export class Document {
      * is at rest; one from the transport door may rest as authored until it is
      * conformed, and this read reports what is there. For the `Content` either
      * way use `reader.getContent`.
+     *
+     * The body arm is typed `Content` and answers in the seam form, spelling
+     * every `ContentContainer.instance`. A field arm echoes the stored bytes,
+     * which omit a zero: verbatim is the contract, and is why it is `unknown`.
      * @param {Addr | string} addr
      * @returns {unknown}
      */

package/backends/typst/wasm.d.ts

@@ -100,33 +100,24 @@ export type ContentLineKind =
  * shape — two consecutive quotes, two consecutive lists — which contiguity
  * alone reads as one.
  *
- * **A writer owes it.** Give adjacent sibling runs of one shape distinct
- * values, or they arrive as one: a second list's items come back as
- * continuation paragraphs of the first, markers gone. Nothing reports that,
- * since the flat form cannot tell a boundary you meant from one you did not. A
- * codec flattening a tree stamps the field with `assignInstances` from
- * `@quillmark/wasm/runtime` rather than by hand. Any distinct pair of values
- * works; a write is canonicalized to `0`/`1`.
+ * **A writer owes a distinct value per adjacent sibling run**, not merely a
+ * value. Runs of one shape sharing one arrive as one: a second list's items come
+ * back as continuation paragraphs of the first, markers gone. The field is
+ * required, so a checker reports the omission; it cannot report a `0` stamped on
+ * both, which is the same write. A codec flattening a tree takes them from
+ * `assignInstances` in `@quillmark/wasm/runtime` rather than by hand. Any
+ * distinct pair works; a write is canonicalized to `0`/`1`.
  *
- * Reading is not the mirror of writing. The field is absent where it is `0`,
- * and it appears on pairs no writer had to spell. `1.` beside a list starting
- * at `3` differs by `start`, so those runs arrive apart with nothing written —
- * and the canonical form spends a discriminator anyway, because Markdown reads
- * only a list's first number. */
-export type ContentContainer =
-| { container: "list_item"; ordered: boolean; start: number; ordinal: number; instance?: number }
-| { container: "quote"; instance?: number }
-| { container: string; attrs: unknown; instance?: number };
-
-/** A container path on a lane that only ever carries host-built values:
- * `ContentContainer` with `instance` spelled out rather than defaulted. The
- * field that decides whether two adjacent runs weld cannot be omitted by
- * accident here. `assignInstances` returns this shape, and a path copied off a
- * line carries its own instance through — `{ ...c, instance: c.instance ?? 0 }`.
+ * Reading is not the mirror of writing. Every read spells the field, the `0` on
+ * a container with nothing to be told apart from included. A read also carries a
+ * discriminator on pairs no writer had to spell: `1.` beside a list starting at
+ * `3` differs by `start`, so those runs arrive apart with nothing written, and
+ * the canonical form spends one anyway because Markdown reads only a list's
+ * first number.
  *
- * `Content` itself keeps the optional field: it is a read shape as much as a
- * write one, and the wire omits a zero. */
-export type ContentContainerInput =
+ * Content parsed from a stored document is the one shape that arrives without
+ * it — storage omits a zero — and needs a cast. */
+export type ContentContainer =
 | { container: "list_item"; ordered: boolean; start: number; ordinal: number; instance: number }
 | { container: "quote"; instance: number }
 | { container: string; attrs: unknown; instance: number };
@@ -256,7 +247,7 @@ export type LineOp =
 | { op: "split"; at: number }
 | { op: "join"; line: number }
 | ({ op: "setKind"; line: number } & ContentLineKind)
-| { op: "setContainers"; line: number; containers: ContentContainerInput[] }
+| { op: "setContainers"; line: number; containers: ContentContainer[] }
 | { op: "setContinues"; line: number; continues: boolean };
 
 /**
@@ -818,6 +809,10 @@ export class Document {
      * is at rest; one from the transport door may rest as authored until it is
      * conformed, and this read reports what is there. For the `Content` either
      * way use `reader.getContent`.
+     *
+     * The body arm is typed `Content` and answers in the seam form, spelling
+     * every `ContentContainer.instance`. A field arm echoes the stored bytes,
+     * which omit a zero: verbatim is the contract, and is why it is `unknown`.
      */
     getStored(addr: Addr | string): unknown;
     /**

package/backends/typst/wasm.js

@@ -608,6 +608,10 @@ export class Document {
      * is at rest; one from the transport door may rest as authored until it is
      * conformed, and this read reports what is there. For the `Content` either
      * way use `reader.getContent`.
+     *
+     * The body arm is typed `Content` and answers in the seam form, spelling
+     * every `ContentContainer.instance`. A field arm echoes the stored bytes,
+     * which omit a zero: verbatim is the contract, and is why it is `unknown`.
      * @param {Addr | string} addr
      * @returns {unknown}
      */

package/core/wasm.d.ts

@@ -100,33 +100,24 @@ export type ContentLineKind =
  * shape — two consecutive quotes, two consecutive lists — which contiguity
  * alone reads as one.
  *
- * **A writer owes it.** Give adjacent sibling runs of one shape distinct
- * values, or they arrive as one: a second list's items come back as
- * continuation paragraphs of the first, markers gone. Nothing reports that,
- * since the flat form cannot tell a boundary you meant from one you did not. A
- * codec flattening a tree stamps the field with `assignInstances` from
- * `@quillmark/wasm/runtime` rather than by hand. Any distinct pair of values
- * works; a write is canonicalized to `0`/`1`.
+ * **A writer owes a distinct value per adjacent sibling run**, not merely a
+ * value. Runs of one shape sharing one arrive as one: a second list's items come
+ * back as continuation paragraphs of the first, markers gone. The field is
+ * required, so a checker reports the omission; it cannot report a `0` stamped on
+ * both, which is the same write. A codec flattening a tree takes them from
+ * `assignInstances` in `@quillmark/wasm/runtime` rather than by hand. Any
+ * distinct pair works; a write is canonicalized to `0`/`1`.
  *
- * Reading is not the mirror of writing. The field is absent where it is `0`,
- * and it appears on pairs no writer had to spell. `1.` beside a list starting
- * at `3` differs by `start`, so those runs arrive apart with nothing written —
- * and the canonical form spends a discriminator anyway, because Markdown reads
- * only a list's first number. */
-export type ContentContainer =
-| { container: "list_item"; ordered: boolean; start: number; ordinal: number; instance?: number }
-| { container: "quote"; instance?: number }
-| { container: string; attrs: unknown; instance?: number };
-
-/** A container path on a lane that only ever carries host-built values:
- * `ContentContainer` with `instance` spelled out rather than defaulted. The
- * field that decides whether two adjacent runs weld cannot be omitted by
- * accident here. `assignInstances` returns this shape, and a path copied off a
- * line carries its own instance through — `{ ...c, instance: c.instance ?? 0 }`.
+ * Reading is not the mirror of writing. Every read spells the field, the `0` on
+ * a container with nothing to be told apart from included. A read also carries a
+ * discriminator on pairs no writer had to spell: `1.` beside a list starting at
+ * `3` differs by `start`, so those runs arrive apart with nothing written, and
+ * the canonical form spends one anyway because Markdown reads only a list's
+ * first number.
  *
- * `Content` itself keeps the optional field: it is a read shape as much as a
- * write one, and the wire omits a zero. */
-export type ContentContainerInput =
+ * Content parsed from a stored document is the one shape that arrives without
+ * it — storage omits a zero — and needs a cast. */
+export type ContentContainer =
 | { container: "list_item"; ordered: boolean; start: number; ordinal: number; instance: number }
 | { container: "quote"; instance: number }
 | { container: string; attrs: unknown; instance: number };
@@ -256,7 +247,7 @@ export type LineOp =
 | { op: "split"; at: number }
 | { op: "join"; line: number }
 | ({ op: "setKind"; line: number } & ContentLineKind)
-| { op: "setContainers"; line: number; containers: ContentContainerInput[] }
+| { op: "setContainers"; line: number; containers: ContentContainer[] }
 | { op: "setContinues"; line: number; continues: boolean };
 
 /**
@@ -634,6 +625,10 @@ export class Document {
      * is at rest; one from the transport door may rest as authored until it is
      * conformed, and this read reports what is there. For the `Content` either
      * way use `reader.getContent`.
+     *
+     * The body arm is typed `Content` and answers in the seam form, spelling
+     * every `ContentContainer.instance`. A field arm echoes the stored bytes,
+     * which omit a zero: verbatim is the contract, and is why it is `unknown`.
      */
     getStored(addr: Addr | string): unknown;
     /**

package/core/wasm.js

@@ -608,6 +608,10 @@ export class Document {
      * is at rest; one from the transport door may rest as authored until it is
      * conformed, and this read reports what is there. For the `Content` either
      * way use `reader.getContent`.
+     *
+     * The body arm is typed `Content` and answers in the seam form, spelling
+     * every `ContentContainer.instance`. A field arm echoes the stored bytes,
+     * which omit a zero: verbatim is the contract, and is why it is `unknown`.
      * @param {Addr | string} addr
      * @returns {unknown}
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.109.1",
+  "version": "0.110.0",
   "description": "WebAssembly bindings for Quillmark, a schema-driven document engine",
   "type": "module",
   "license": "Apache-2.0",

package/runtime/runtime.d.ts

@@ -130,7 +130,6 @@ export type {
 	ContentLine,
 	ContentLineKind,
 	ContentContainer,
-	ContentContainerInput,
 	ContentMark,
 	ContentIsland,
 	TableProps,
@@ -205,8 +204,7 @@ import type {
 	ImageProps,
 	ContentMark,
 	ContentLine,
-	ContentContainer,
-	ContentContainerInput
+	ContentContainer
 } from '../core/wasm.js';
 
 /** Narrow a {@link ContentIsland} to the pinned `table` arm (`props: TableProps`). */
@@ -247,7 +245,7 @@ export declare function isListItemContainer(
 	ordered: boolean;
 	start: number;
 	ordinal: number;
-	instance?: number;
+	instance: number;
 };
 
 // The guards above answer "is this arm X". These four answer "is this a value
@@ -280,11 +278,11 @@ export declare function isUnknownIsland(
 	island: ContentIsland
 ): island is ContentIsland & { type: string; props: unknown };
 
-// `ContentContainer.instance` is a field a writer owes and, outside
-// `ContentContainerInput`, no checker asks for. Adjacent runs of one shape that
-// share it arrive welded. Nothing reports that: the flat `containers` form
-// cannot tell it from one container spanning two paragraphs. This carries the
-// rule a codec would otherwise re-derive.
+// `ContentContainer.instance` is required, so a checker reports an omission; it
+// cannot report a `0` stamped on every run, which is the same write. Adjacent
+// runs of one shape sharing a value arrive welded, and nothing reports that
+// either: the flat `containers` form cannot tell it from one container spanning
+// two paragraphs. This carries the rule a codec would otherwise re-derive.
 
 /**
  * Stamp `instance` across one parent's blocks at one depth, in document order,
@@ -313,7 +311,7 @@ export declare function isUnknownIsland(
  */
 export declare function assignInstances(
 	runs: (ContentContainer | null)[]
-): (ContentContainerInput | null)[];
+): (ContentContainer | null)[];
 
 // The backend-neutral render contract, defined here rather than re-exported from
 // one private backend because no single backend owns the canonical API's types.

package/runtime/runtime.js

@@ -553,7 +553,7 @@ function weldsWith(a, b) {
 
 /**
  * @param {(import('../core/wasm.js').ContentContainer | null)[]} runs
- * @returns {(import('../core/wasm.js').ContentContainerInput | null)[]}
+ * @returns {(import('../core/wasm.js').ContentContainer | null)[]}
  */
 export function assignInstances(runs) {
 	let prev = null;