@quillmark/svelte 0.16.0 → 0.18.0

package/dist/visual/VisualEditorInner.svelte

@@ -19,6 +19,7 @@
 -->
 <script lang="ts">
 	import { onDestroy, tick } from 'svelte';
+	import { SvelteMap } from 'svelte/reactivity';
 	import { DropdownMenu } from 'bits-ui';
 	import { isQuillmarkError, MAIN_CARD_ADDR } from '@quillmark/wasm';
 	import {
@@ -81,6 +82,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';
@@ -134,14 +136,7 @@
 	// Local commit-error diagnostics (VISUAL_EDITOR §Diagnostics, producer #2),
 	// id-keyed rather than positional so an error stays pinned to its field across a
 	// card reorder.
-	let commitErrors = $state(new Map<string, RoutedDiagnostic>());
-	/** Edit the commit-error map copy-on-write: a `$state` Map is not deeply
-	 * reactive, so a mutation in place re-derives nothing. */
-	function editCommitErrors(edit: (m: Map<string, RoutedDiagnostic>) => void): void {
-		const next = new Map(commitErrors);
-		edit(next);
-		commitErrors = next;
-	}
+	const commitErrors = new SvelteMap<string, RoutedDiagnostic>();
 
 	const kinds = $derived(Object.keys(quill.schema.card_kinds ?? {}));
 
@@ -349,14 +344,14 @@
 					w.card(i).set(name, value);
 				}
 			}
-			if (commitErrors.has(keyStr)) editCommitErrors((m) => m.delete(keyStr));
+			commitErrors.delete(keyStr);
 			bump('field', id, makeAddr(id, isMain, name));
 		} catch (e) {
 			const diagnostic: Diagnostic = (isQuillmarkError(e) ? e.diagnostics[0] : undefined) ?? {
 				severity: 'error',
 				message: errorMessage(e)
 			};
-			editCommitErrors((m) => m.set(keyStr, { key, diagnostic }));
+			commitErrors.set(keyStr, { key, diagnostic });
 			// Both channels, deliberately: the diagnostic pins to the field on
 			// screen, the error reaches the app's sink (core/errors.ts).
 			reportError(onError, {
@@ -461,9 +456,7 @@
 		// because nothing else will ever clear it.
 		const prefix = `${id}:`;
 		const stale = [...commitErrors.keys()].filter((k) => k.startsWith(prefix));
-		// Guarded: `editCommitErrors` clones the map, and a removal matching nothing has
-		// nothing to re-derive.
-		if (stale.length) editCommitErrors((m) => stale.forEach((k) => m.delete(k)));
+		for (const k of stale) commitErrors.delete(k);
 		// No addr: the removed card has none left and every survivor's shifted. The
 		// stack changed, not a leaf, and the id is the only handle the removal leaves.
 		bump('structure', id);
@@ -661,6 +654,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.
@@ -922,7 +929,7 @@
 		 gaps between cards stay bare: the strip is the gap, and the pill each fills on
 		 hover draws what a label would state, the space the new card takes. -->
 		{@const marked = atIndex === model.cards.length}
-		<div class="qm-add-card" class:qm-add-card-marked={marked}>
+		<div class={['qm-add-card', { 'qm-add-card-marked': marked }]}>
 			<!-- Marked, the words are the accessible name and no `aria-label` doubles
 			 them; bare, the same words land as the label, the strip having no
 			 geometry to carry them. -->

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

@@ -2,7 +2,6 @@ import { type DocPath, type Landing } from '../core/address.js';
 import type { VisualEditorProps } from './props.js';
 import type { CardId } from './signals.js';
 import type { FieldController } from '../core/codec/index.js';
-import './controls.css';
 declare const VisualEditorInner: import("svelte").Component<VisualEditorProps, {
     setCaret: (at: Landing) => Promise<void>;
     getActiveLeaf: () => FieldController | undefined;

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/index.d.ts

@@ -1,4 +1,3 @@
-import '../core/theme.css';
 export { default as VisualEditor } from './VisualEditor.svelte';
 export type { VisualEditorProps } from './props.js';
 export { createField } from '../core/codec/index.js';

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
@@ -108,6 +114,10 @@ export declare function resolvedByCardIndex(resolved: Resolved | undefined): Map
  * use (`source === 'default'`), else undefined: an `authored` field shows its value,
  * a `blank` field has no default to show. */
 export declare function ghostDefault(row: ResolvedField | undefined): unknown;
+/** A stored `boolean` cell as the render reads it: a boolean, `true` or `false` in any
+ * case, or a number by whether it is non-zero; undefined where the render refuses the
+ * value. The engine's coercion, restated, so the suite holds it to `reader.resolve()`. */
+export declare function renderedBoolean(value: unknown): boolean | undefined;
 /** A ghost value's string form, or undefined for null/object (only text ghosts
  * render a placeholder). A scalar's resolved default reads through it; a content
  * field's resolves as `Content`, which a prose leaf reads by its text instead
@@ -177,11 +187,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 +203,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 +279,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 +304,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`. */