@quillmark/svelte 0.16.0 → 0.17.0

package/dist/visual/ObjectField.svelte

@@ -30,7 +30,9 @@
  member's id. So a cell reads at whatever depth it sits, which nothing here knows.
 
  `bare` is the table's row: the same cells with no labels and no figure of their own,
- laid onto the tracks the table's header names ({@link ArrayField}).
+ laid onto the tracks the table's header names ({@link ArrayField}). `flat` is
+ `ui.layout: flat`: the cells keep their labels and lose the figure, standing at the
+ depth of whatever holds the subform.
 -->
 <script lang="ts">
 	import type { Content, PathStep, QuillFieldSchema } from '@quillmark/wasm';
@@ -39,6 +41,7 @@
 		baseType,
 		controlKind,
 		declaredContent,
+		flatObject,
 		humanize,
 		isContainer,
 		mountKey,
@@ -93,6 +96,9 @@
 		/** A table's row: the cells alone, on the tracks the table's header names, with
 		 * no labels and no vertical of their own. */
 		bare?: boolean;
+		/** `ui.layout: flat`: no vertical and no rung, the properties at the depth of the
+		 * list the subform stands in. */
+		flat?: boolean;
 		/** Raw keydown off a text or prose cell, for a row whose own keys run through its
 		 * cells: the table's Enter and Backspace ({@link ArrayField}). */
 		onCellKey?: (e: KeyboardEvent, key: string) => void;
@@ -111,6 +117,7 @@
 		contentAt,
 		onCommit,
 		bare = false,
+		flat = false,
 		onCellKey,
 		diagnostics
 	}: Props = $props();
@@ -250,6 +257,7 @@
 	bind:this={rootEl}
 	class="qm-object"
 	class:qm-object-bare={bare}
+	class:qm-object-flat={flat}
 	role="group"
 	aria-labelledby={labelledBy}
 	aria-describedby={describedBy}
@@ -392,6 +400,7 @@
 						bind:this={nestedEls[key]}
 						value={obj[key] as Record<string, unknown> | undefined}
 						properties={sub.properties}
+						flat={flatObject(sub)}
 						label={ids ? undefined : fallbackName(key, sub)}
 						idBase={ids?.control}
 						labelledBy={ids?.label}
@@ -471,6 +480,8 @@
 	}
 	.qm-object:not(.qm-object-bare) {
 		container-type: inline-size;
+	}
+	.qm-object:not(.qm-object-bare, .qm-object-flat) {
 		border-inline-start: var(--_qm-vertical-width) solid var(--_qm-border);
 		padding-inline-start: var(--_qm-nest);
 		padding-block: var(--_qm-space);
@@ -481,7 +492,14 @@
 	.qm-object-grid {
 		display: grid;
 		grid-template-columns: repeat(var(--cols), 1fr);
-		gap: var(--_qm-space-2);
+		column-gap: var(--_qm-space-2);
+		--row-gap: var(--_qm-space-2);
+		row-gap: var(--row-gap);
+	}
+	/* Flat, the rows keep the rhythm of the list the subform stands in: a section's
+	   (`Card.svelte`) or an enclosing subform's, inherited rather than restated. */
+	.qm-object-flat > .qm-object-grid {
+		--row-gap: inherit;
 	}
 	/* A property measures like a field: two tracks over the subform's own rows, so a
 	   label wrapping in one column leaves its control on the row's baseline rather than a
@@ -546,10 +564,9 @@
 		grid-row: auto;
 		grid-template-rows: none;
 		row-gap: var(--_qm-space-half);
-		/* A row is one line of controls, so a cell shorter than the box beside it stands
-		   on that line: a switch held at the top of a row a text box set the height of
-		   reads as a cell that slipped its track. */
-		align-items: center;
+		/* A row reads along its first line: a prose cell that wraps grows downward, and
+		   the cells beside it stay on the line it started on. */
+		align-items: start;
 	}
 	/* What the row could not hand down stands across it: a diagnostic in the first
 	   column alone would read as that column's. */

package/dist/visual/ObjectField.svelte.d.ts

@@ -31,6 +31,9 @@ interface Props {
     /** A table's row: the cells alone, on the tracks the table's header names, with
      * no labels and no vertical of their own. */
     bare?: boolean;
+    /** `ui.layout: flat`: no vertical and no rung, the properties at the depth of the
+     * list the subform stands in. */
+    flat?: boolean;
     /** Raw keydown off a text or prose cell, for a row whose own keys run through its
      * cells: the table's Enter and Backspace ({@link ArrayField}). */
     onCellKey?: (e: KeyboardEvent, key: string) => void;

package/dist/visual/VisualEditorInner.svelte

@@ -81,6 +81,7 @@
 	import { createLeafRegistry, type FieldControl } from './leaves.js';
 	import { reorder, reorderArm, reorderTrips } from './motion.js';
 	import { tipsChannel } from './tips.js';
+	import { cardChecklists, setChecklists } from './checklists.js';
 	import { patchEditorExt } from './ext.js';
 	import Card from './Card.svelte';
 	import TipsCard from './TipsCard.svelte';
@@ -661,6 +662,20 @@
 		};
 	});
 
+	// The document's checklists, which an open matrix's add box searches whole
+	// (`checklists.ts`): off the model, so a list in a closed group or another card is
+	// reached without being mounted.
+	const lists = $derived(
+		cardChecklists(
+			[model.main, ...model.cards],
+			(c) => c.titleOverride || c.titlePlaceholder,
+			(c, field) => pathFor(makeAddr(c.id, c.isMain, field)),
+			(c, field) => fieldKeyToString({ card: c.isMain ? undefined : c.id, field }),
+			(c, field, next) => commitScalar(c.id, c.isMain, field, next)
+		)
+	);
+	setChecklists({ list: () => lists, land: (path) => void focusField(path) });
+
 	// ── Public entry points ─────────────────────────────────────────────────────
 	/**
 	 * Resolve a preview {@link Landing} to a mounted leaf and land in it.

package/dist/visual/checklists.d.ts

@@ -0,0 +1,82 @@
+import type { QuillFieldSchema } from '@quillmark/wasm';
+import type { DocPath } from '../core/address.js';
+import { type CardModel, type MatrixMember } from './structure.js';
+/** One matrix of the document, as the add box reaches it. */
+export interface Checklist {
+    /** The field's leaf key: how a mounted matrix tells itself from the rest. */
+    key: string;
+    /** The field's path, the prefix a member's landing address extends. */
+    path: DocPath;
+    /** What a result from this list reads under: the field's label, and the card's
+     *  where the field is not the main card's. */
+    label: string;
+    schema: QuillFieldSchema;
+    /** The held set as it prints: the stored map, else the declared `default:`. */
+    value: Record<string, unknown> | undefined;
+    /** Commit the whole map, as the field's own control does. */
+    commit: (next: Record<string, unknown> | undefined) => void;
+}
+export interface ChecklistIndex {
+    list: () => readonly Checklist[];
+    /** Reveal and focus a member by its address. */
+    land: (path: DocPath) => void;
+}
+export declare function setChecklists(index: ChecklistIndex): void;
+/** The index under a mounted editor; `undefined` off-tree. */
+export declare function checklists(): ChecklistIndex | undefined;
+/** The value a matrix prints: the stored map, else a mapping `default:`. */
+export declare function matrixPrinted(value: unknown, schema: QuillFieldSchema): Record<string, unknown> | undefined;
+/** Every card-level matrix of the cards, in document order. */
+export declare function cardChecklists(cards: readonly CardModel[], cardLabel: (card: CardModel) => string, path: (card: CardModel, field: string) => DocPath | undefined, leafKey: (card: CardModel, field: string) => string, commit: (card: CardModel, field: string, next: Record<string, unknown> | undefined) => void): Checklist[];
+/** Every item a matrix can show: the roster in declaration order, then the items its
+ *  map adds, in id order. */
+export declare function checklistItems(schema: QuillFieldSchema, value: Record<string, unknown> | undefined): MatrixMember[];
+/** One option of an add box. */
+export interface AddOption {
+    /** Stable across one query's options: the option element's id suffix. */
+    key: string;
+    title: string;
+    /** Words after the title: the list a result stands in, its held state. */
+    note?: string;
+    /** The option that adds what was typed, rather than a result. */
+    add?: boolean;
+    /** A result the typed words name outright, which Enter takes unarrowed: an add box
+     *  whose best result is weaker takes its add option instead. */
+    strong?: boolean;
+    /** What the owner reads back off a chosen option. */
+    payload?: unknown;
+}
+/** One search result: an item of some checklist, `list` naming which. */
+export interface ChecklistHit<L> {
+    list: L;
+    id: string;
+    title: string;
+    held: boolean;
+    score: number;
+    /** Every query word claimed a title word whole or as its opening. */
+    strong: boolean;
+}
+/**
+ * How well `query` names `title`, or `undefined` for not at all. Each query word claims
+ * a title word — whole, as its opening, or as an abbreviation of it (`flt cc` names
+ * `Flight CC`) — the stronger claims taken first, so `c cc` names `CC Candidate`; a
+ * word left over may claim a run of words whose openings it spells (`fcc`, `jqo`). The
+ * title the query spells outright ranks first, then one it opens.
+ */
+export declare function matchTitle(query: string, title: string): {
+    score: number;
+    strong: boolean;
+} | undefined;
+/** {@link matchTitle}'s score, `0` for no match. */
+export declare function matchScore(query: string, title: string): number;
+/** What a search reads of one list: its items and their ticks. */
+export interface Searchable<L> {
+    list: L;
+    schema: QuillFieldSchema;
+    value: Record<string, unknown> | undefined;
+}
+/**
+ * The items across `lists` that `query` names, best first; a tie keeps the order of
+ * `lists`, then of each list's items.
+ */
+export declare function searchChecklists<L>(query: string, lists: readonly Searchable<L>[], limit?: number): ChecklistHit<L>[];

package/dist/visual/checklists.js

@@ -0,0 +1,171 @@
+/**
+ * The document's checklists, and the search an open matrix's add box runs over them
+ * (VISUAL_EDITOR §"The matrix"). The editor root publishes every card-level matrix off
+ * the model it derives, so a list in a collapsed group or another card is searched
+ * as surely as the one the author is typing in. A matrix mounted off-tree, or nested
+ * in a container, is not indexed and searches its own items alone.
+ */
+import { getContext, setContext } from 'svelte';
+import { addedItems, matrixHeld, matrixMembers, memberValue } from './structure.js';
+const KEY = Symbol('qm-checklists');
+export function setChecklists(index) {
+    setContext(KEY, index);
+}
+/** The index under a mounted editor; `undefined` off-tree. */
+export function checklists() {
+    return getContext(KEY);
+}
+/** The value a matrix prints: the stored map, else a mapping `default:`. */
+export function matrixPrinted(value, schema) {
+    const map = (v) => typeof v === 'object' && v !== null && !Array.isArray(v)
+        ? v
+        : undefined;
+    return value == null ? map(schema.default) : map(value);
+}
+/** Every card-level matrix of the cards, in document order. */
+export function cardChecklists(cards, cardLabel, path, leafKey, commit) {
+    const out = [];
+    for (const card of cards) {
+        if (card.unschemable)
+            continue;
+        for (const section of card.sections)
+            for (const f of section.fields) {
+                if (f.control !== 'matrix')
+                    continue;
+                const at = path(card, f.name);
+                if (at == null)
+                    continue;
+                out.push({
+                    key: leafKey(card, f.name),
+                    path: at,
+                    label: card.isMain ? f.label : `${f.label} · ${cardLabel(card)}`,
+                    schema: f.schema,
+                    value: matrixPrinted(card.values[f.name], f.schema),
+                    commit: (next) => commit(card, f.name, next)
+                });
+            }
+    }
+    return out;
+}
+/** Every item a matrix can show: the roster in declaration order, then the items its
+ *  map adds, in id order. */
+export function checklistItems(schema, value) {
+    return [...matrixMembers(schema.members), ...addedItems(schema, value)];
+}
+/** Lowercase, unaccented words, any script: `Exec / Aide / CAG` → `exec aide cag`. */
+function words(s) {
+    return s
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .split(/[^\p{L}\p{N}]+/u)
+        .filter(Boolean);
+}
+/** `flt` in `flight`: every letter in order, the first letters equal. */
+function abbreviates(token, word) {
+    if (token[0] !== word[0])
+        return false;
+    let i = 0;
+    for (const c of word)
+        if (c === token[i])
+            i++;
+    return i === token.length;
+}
+/** How a query word claims one title word: whole (3), as its opening (2), as an
+ *  abbreviation (1), or not (0). */
+function claim(token, word) {
+    return word === token ? 3 : word.startsWith(token) ? 2 : abbreviates(token, word) ? 1 : 0;
+}
+/** The end of the run of free words from `i` whose openings spell `token` in order —
+ *  `fcc` over `flight cc`, `jqo` over `joint qualified officer` — or `-1`. */
+function runFrom(token, w, free, i) {
+    if (i >= w.length || !free[i])
+        return -1;
+    for (let k = Math.min(token.length, w[i].length); k > 0; k--) {
+        if (!w[i].startsWith(token.slice(0, k)))
+            continue;
+        if (k === token.length)
+            return i + 1;
+        const end = runFrom(token.slice(k), w, free, i + 1);
+        if (end >= 0)
+            return end;
+    }
+    return -1;
+}
+/**
+ * How well `query` names `title`, or `undefined` for not at all. Each query word claims
+ * a title word — whole, as its opening, or as an abbreviation of it (`flt cc` names
+ * `Flight CC`) — the stronger claims taken first, so `c cc` names `CC Candidate`; a
+ * word left over may claim a run of words whose openings it spells (`fcc`, `jqo`). The
+ * title the query spells outright ranks first, then one it opens.
+ */
+export function matchTitle(query, title) {
+    const q = words(query);
+    const w = words(title);
+    if (!q.length || !w.length)
+        return undefined;
+    const free = w.map(() => true);
+    const left = q.map(() => true);
+    let score = 0;
+    let strong = true;
+    for (const level of [3, 2, 1])
+        q.forEach((token, t) => {
+            if (!left[t])
+                return;
+            const at = w.findIndex((word, i) => free[i] && claim(token, word) === level);
+            if (at < 0)
+                return;
+            free[at] = left[t] = false;
+            score += level;
+            if (level === 1)
+                strong = false;
+        });
+    for (let t = 0; t < q.length; t++) {
+        if (!left[t])
+            continue;
+        let found = false;
+        for (let i = 0; i < w.length && !found; i++) {
+            const end = runFrom(q[t], w, free, i);
+            if (end - i < 2)
+                continue;
+            for (let k = i; k < end; k++)
+                free[k] = false;
+            found = true;
+        }
+        if (!found)
+            return undefined;
+        score += 1;
+        strong = false;
+    }
+    const typed = q.join(' ');
+    const whole = w.join(' ');
+    return { score: score + (whole === typed ? 3 : whole.startsWith(typed) ? 1 : 0), strong };
+}
+/** {@link matchTitle}'s score, `0` for no match. */
+export function matchScore(query, title) {
+    return matchTitle(query, title)?.score ?? 0;
+}
+/**
+ * The items across `lists` that `query` names, best first; a tie keeps the order of
+ * `lists`, then of each list's items.
+ */
+export function searchChecklists(query, lists, limit = 8) {
+    const hits = [];
+    for (const { list, schema, value } of lists)
+        for (const item of checklistItems(schema, value)) {
+            const match = matchTitle(query, item.title);
+            if (match)
+                hits.push({
+                    list,
+                    id: item.id,
+                    title: item.title,
+                    held: matrixHeld(memberValue(value, item.id)),
+                    ...match
+                });
+        }
+    return hits
+        .map((h, i) => [h, i])
+        .sort(([a, i], [b, j]) => b.score - a.score || i - j)
+        .slice(0, limit)
+        .map(([h]) => h);
+}

package/dist/visual/strings.d.ts

@@ -45,8 +45,22 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     /** The tag on the unset sentinel's row, which is what tells it from the member it
      *  ghosts ({@link EnumField}). */
     enumUnsetTag: string;
-    /** The count in the matrix's label row: how many of the roster are held. */
+    /** The count in the matrix's label row: how many of its items are held. */
     matrixHeld: (held: number, total: number) => string;
+    /** An open matrix's add box at rest, naming the list it adds to: `Add to Staff…`. The box
+     *  draws its own `+`. `list` is empty for a matrix mounted with no label. */
+    matrixAdd: (list: string) => string;
+    /** The add box's last option, which adds what was typed as an item of this list. */
+    matrixAddNew: (title: string) => string;
+    /** Beside a result from another list: the list it would be ticked in. */
+    matrixIn: (list: string) => string;
+    /** Beside a result already held: picking it lands on it and ticks nothing. */
+    matrixHeldTag: string;
+    /** An added item's title input, named for the list it stands in and its 1-based
+     *  place among the added items; also what an untitled item is called. */
+    matrixItemTitle: (list: string, index: number) => string;
+    /** An added item's remove control, named for the item. */
+    matrixRemove: (title: string) => string;
     /** The date field's toggle, pressed while the field holds `today`: the render
      *  date rather than a written one. */
     dateToday: string;

package/dist/visual/strings.js

@@ -37,6 +37,12 @@ export const DEFAULT_VISUAL_STRINGS = {
     elementUntitled: (label, index) => `${label} ${index}`,
     enumUnsetTag: 'default',
     matrixHeld: (held, total) => `${held} of ${total} held`,
+    matrixAdd: (list) => (list ? `Add to ${list}…` : 'Add…'),
+    matrixAddNew: (title) => `Add “${title}”`,
+    matrixIn: (list) => `in ${list}`,
+    matrixHeldTag: 'held',
+    matrixItemTitle: (list, index) => `${list ? `${list} item` : 'Item'} ${index}`,
+    matrixRemove: (title) => `Remove ${title}`,
     dateToday: 'Today',
     fieldRequired: 'required',
     optionalGhost: 'None',

package/dist/visual/structure.d.ts

@@ -35,7 +35,13 @@ export interface GroupSection {
     group: string | undefined;
     label: string;
     fields: FieldModel[];
+    /** The field the section's header names in place of a label of its own: the one
+     * field of a group section, where that field is {@link flatObject}. */
+    head?: FieldModel;
 }
+/** `ui.layout: flat` on a typed dictionary: no frame of its own, its properties
+ *  standing at the depth of the fields around it rather than a rung in. */
+export declare function flatObject(schema: QuillFieldSchema): boolean;
 /**
  * One card instance projected for rendering: the schema × payload join result
  * the VisualEditor's `$derived` produces and hands to `<Card>`. Positional
@@ -177,11 +183,11 @@ export declare function controlKind(f: QuillFieldSchema): ControlKind;
  *  crosses inside untyped container data with no type to read it off, so a literal here
  *  would be a second spelling of a reserved key. No variant may declare it. */
 export declare const VARIANT_DISCRIMINANT: "value";
-/** The tick cell of a matrix member, the second reserved key beside the discriminant.
- *  The boundary synthesizes it on every member and exports no constant for it, so this
- *  is where the package spells it once (canon `SCHEMAS.md` §Matrix). */
-export declare const MATRIX_HELD = "held";
-/** One member of the roster: its id and its title. */
+/** The label key of an open matrix's added item, the one cell a roster member never
+ *  stores. The boundary exports no constant for it, so the package spells it once
+ *  (canon `SCHEMAS.md` §Matrix). */
+export declare const MATRIX_TITLE = "title";
+/** One item of a matrix: its id and its title. */
 export interface MatrixMember {
     id: string;
     title: string;
@@ -193,39 +199,60 @@ export declare function matrixMembers(roster: Record<string, string> | undefined
  *  spelled `constructor`. */
 export declare function memberValue(map: Record<string, unknown> | undefined, id: string): unknown;
 /**
- * Whether a stored member is held. A bare scalar is the tick and a mapping is the member
- * object, whose `held` cell resolves as every absent cell does, to its `default:` of
- * `false` (canon `SCHEMAS.md` §Matrix): an absent key is unheld, a bare `true` is held,
- * and a member object is held only where its `held` cell says so. The spellings the
- * engine coerces to false — `false`, `0`, `"false"`, `null` — read false here; every other
- * present scalar reads held, so a document the engine would refuse still draws the tick
- * its spelling claims.
+ * Whether a stored member is held: by being present. A mapping is held whatever it
+ * carries, `{}` included, and a bare scalar is the tick itself, read as the engine's
+ * coercion reads it: `false`, `0`, `"false"` and `null` unheld, every other present
+ * scalar held, so a spelling the engine would refuse still draws the tick it claims.
  */
 export declare function matrixHeld(stored: unknown): boolean;
-/** A member's columns: the member object with its `held` cell taken out, `{}` for the
- *  bare and absent spellings. What the columns subform takes as its value. */
+/** A member's columns: its mapping without the reserved keys, `{}` for a bare tick or an
+ *  absent member. What the columns subform takes as its value, so an edit writes back
+ *  no `held` a document stored (`validation::held_stored`). */
 export declare function matrixColumns(stored: unknown): Record<string, unknown>;
+/** What a matrix holding nothing commits: the unset field where unset prints nothing
+ *  held, and the authored `{}` where it would print a `default:` or `none` instead. */
+export declare function matrixEmpty(matrix: QuillFieldSchema): Record<string, unknown> | undefined;
 /**
  * The map after one member moves: `next` written under `id`, or the key dropped where
  * `next` is `undefined`; a map left holding nothing is an unset field. Every other
- * member rides through in the spelling the document had, so a stored `cyber_200: true`
- * stays `true` while its neighbour is edited.
+ * member rides through in the spelling the document had.
  */
-export declare function commitMember(map: Record<string, unknown> | undefined, id: string, next: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+export declare function commitMember(map: Record<string, unknown> | undefined, id: string, next: unknown): Record<string, unknown> | undefined;
 /**
- * The member a tick or an edit writes. Held with columns is the member object with an
- * explicit `held: true`; unheld keeps the columns under `held: false`, so tick, type,
- * untick, retick loses nothing; unheld with no columns is `undefined`, the key dropped.
- * Which columns are blank is the engine's rule and not restated here: a column control
- * that clears drops its key (`ObjectField`), so a member emptied by hand arrives with no
- * columns and only then leaves the map.
+ * The held member a tick or an edit writes: its columns, the bare tick `true` where
+ * it answers none, and an added item's `title` beside them. Unticking is removal
+ * ({@link commitMember} with `undefined`), never a write.
  */
-export declare function memberWrite(held: boolean, columns: Record<string, unknown>): Record<string, unknown> | undefined;
-/** The `object` a matrix member desugars to, for the schema walk: `held` beside the
- *  declared columns. Composed here because the boundary serializes the roster alone. */
-export declare function matrixMemberSchema(matrix: QuillFieldSchema): QuillFieldSchema;
+export declare function memberWrite(columns: Record<string, unknown>, title?: string): unknown;
+/** Whether `id` is spelled as a matrix id: snake_case, the rule the roster's ids and
+ *  an added item's key share. */
+export declare function matrixId(id: string): boolean;
 /** Whether `id` is on the roster. */
+export declare function onRoster(matrix: QuillFieldSchema, id: string): boolean;
+/**
+ * Whether a step under the matrix names a member, judged on the schema alone as an
+ * index step is: a roster id, or on an open matrix any key spelled as an id, the added
+ * item it would be. So an unheld member's address resolves.
+ */
 export declare function matrixDeclares(matrix: QuillFieldSchema, id: string): boolean;
+/**
+ * The added items a stored map holds, sorted by id as the plate orders them: on an
+ * open matrix, each key off the roster spelled as an id whose mapping carries a
+ * `title`. Any other key off the roster is the engine's refusal, drawn nowhere and
+ * ridden through.
+ */
+export declare function addedItems(matrix: QuillFieldSchema, map: Record<string, unknown> | undefined): MatrixMember[];
+/**
+ * The id an item added under `title` takes: the title folded to snake_case, prefixed
+ * where it opens on no letter, and suffixed past every id `taken` names, the roster's
+ * and the document's alike. The id is the wire's and never drawn, so a later retitle
+ * leaves it where it is.
+ */
+export declare function addedId(title: string, taken: (id: string) => boolean): string;
+/** The `object` a matrix member is, for the schema walk: the declared columns, and an
+ *  added item's `title` beside them. Composed here because the boundary serializes the
+ *  roster and the columns alone. */
+export declare function matrixMemberSchema(matrix: QuillFieldSchema, id: string): QuillFieldSchema;
 /**
  * The schema at `steps` under `field`, or `undefined` where the schema declares no such
  * place: an index under an `array`, a key under an `object`'s properties, a member id
@@ -248,7 +275,7 @@ export type ArrayLayout = 'list' | 'table';
  * The layout an array takes: `'table'` where the array's own `ui.layout` asks for it
  * and every cell of the row is short (a block prose cell declines it, at load width and
  * every width after), else `'list'`. That every column is a leaf is the loader's
- * contract (`quill::table_column_not_flat`); whether a leaf fits a cell is the surface's
+ * contract (`quill::table_column_not_leaf`); whether a leaf fits a cell is the surface's
  * answer (canon `SCHEMAS.md`): a table composes by position, so a row that would stack
  * inside a cell is not one.
  */
@@ -273,9 +300,10 @@ export declare function commitDiscriminant(value: Record<string, unknown> | unde
 /**
  * Whether the schema obliges a cell: `default:`'s absence, which is the whole of the
  * obligation (DOCUMENT_MODEL). Exempt are the cells whose absence of one says nothing:
- * a typed dictionary and a matrix, since a namespace declares no `default:` at all and
- * `validate` anchors obligation on the leaves under it; and an optional cell, which can
- * declare none, its unanswered render being `none`.
+ * a typed dictionary, since a namespace declares no `default:` at all and `validate`
+ * anchors obligation on the leaves under it; a matrix, whose blank is nothing held, a
+ * whole answer; and an optional cell, which can declare none, its unanswered render
+ * being `none`.
  */
 export declare function obliged(schema: QuillFieldSchema): boolean;
 /** `foo_bar` → `Foo bar`: the label fallback when a field declares no `title`. */