@quillmark/svelte 0.21.0 → 0.23.0

package/dist/visual/VisualEditorInner.svelte

@@ -31,7 +31,7 @@
 		type Landing
 	} from '../core/address.js';
 	import { errorMessage, reportError } from '../core/errors.js';
-	import { bloomInside } from '../core/bloom.js';
+	import { bloom } from '../core/bloom.js';
 	import { createLifespan } from '../core/teardown.js';
 	import { spacePx } from '../core/rungs.js';
 	import type {
@@ -220,7 +220,7 @@
 		const card = addr.card;
 		return card != null ? { card, field: addr.field } : { field: addr.field };
 	}
-	function handleFocus(addr: Addr): void {
+	function handleFocus(addr: Addr, steps: readonly PathStep[] = []): void {
 		const plain = normalize(addr);
 		activeAddr = plain;
 		activeCardId = cardIdOf(plain);
@@ -228,7 +228,7 @@
 		// to at the offset it still names has to report again.
 		lastCaretField = undefined;
 		lastCaretPos = undefined;
-		const field = pathFor(plain);
+		const field = pathFor(plain, steps);
 		// Both halves or neither: a stale addr names no path and no live card.
 		if (field != null && activeCardId != null)
 			onActiveLeafChange?.({ field, cardId: activeCardId });
@@ -245,11 +245,11 @@
 		return model.cards.map((c) => c.kind);
 	}
 	/**
-	 * A leaf's canonical `DocPath`. `undefined` for an address outside the live card
-	 * array (a stale addr: drop rather than mis-target).
+	 * A leaf's canonical `DocPath`, `steps` down from the field. `undefined` for an
+	 * address outside the live card array (a stale addr: drop rather than mis-target).
 	 */
-	function pathFor(addr: Addr): DocPath | undefined {
-		return fieldPathForAddr(addr, addr.card == null ? NO_KINDS : liveKinds());
+	function pathFor(addr: Addr, steps: readonly PathStep[] = []): DocPath | undefined {
+		return fieldPathForAddr(addr, addr.card == null ? NO_KINDS : liveKinds(), steps);
 	}
 	// The last place reported, so a caret that did not move is not news. A leaf fires
 	// one caret signal per transaction, and a transaction need not have moved the
@@ -736,10 +736,10 @@
 		// (where landing a caret changes nothing on screen) or one off-screen, where the
 		// browser's focus-scroll moves the page and leaves the caret to be hunted for.
 		const box = await land(found, at.granularity === 'segment' ? undefined : at.pos);
-		if (span.alive) bloomInside(box);
+		if (span.alive) bloom(box);
 	}
 	/** The active prose leaf: the formatting popover's observation seam. The active
-	 *  field's controller where it registered one, else the by-value leaf focused last
+	 *  field's own leaf where it registered one, else the by-value leaf focused last
 	 *  under it (`leaves.ts`); `undefined` for a form control, which holds no marks to
 	 *  toggle. */
 	export function getActiveLeaf(): ActiveProse | undefined {
@@ -747,7 +747,7 @@
 		const card = activeAddr.card != null ? activeCardId : undefined;
 		const key = fieldKeyToString({ card, field: activeAddr.field });
 		const controller = leaves.prose(key);
-		if (controller) return { views: controller as FieldController & LeafViews, controller };
+		if (controller) return { views: controller as FieldController & LeafViews };
 		const views = leaves.value(key);
 		return views && { views };
 	}
@@ -826,7 +826,7 @@
 		const found = await revealLeaf(field);
 		if (!found) return missed(`no mounted field at ${field}`, field);
 		const box = await land(found, undefined);
-		if (span.alive) bloomInside(box);
+		if (span.alive) bloom(box);
 	}
 	/** Seed a card of `kind` and insert it at `at` (default: the end). Returns the new
 	 *  card's session key, or `undefined` when the quill seeds no card of that kind. */
@@ -995,7 +995,7 @@
 			{#if kinds.length === 1}
 				<button
 					type="button"
-					class="qm-add-btn qm-add-affordance qm-tap-floor"
+					class="qm-add-btn qm-add-affordance qm-tap-floor qm-focus-ring"
 					aria-label={marked ? undefined : merged.addCard}
 					onclick={() => addCard(atIndex, kinds[0], true)}
 					>{#if marked}{merged.addCard}{:else}<Icon name="plus" class="qm-add-glyph" />{/if}</button
@@ -1008,7 +1008,7 @@
 			 rules below reach it through `:global`. -->
 				<DropdownMenu.Root>
 					<DropdownMenu.Trigger
-						class="qm-add-btn qm-add-affordance qm-tap-floor"
+						class="qm-add-btn qm-add-affordance qm-tap-floor qm-focus-ring"
 						aria-label={marked ? undefined : merged.addCard}
 						>{#if marked}{merged.addCard}{:else}<Icon
 								name="plus"

package/dist/visual/controls.css

@@ -267,6 +267,22 @@
 	transform: translate(-50%, -50%);
 }
 
+/* The arrival wash: a plane over the host's box at rest, which a landing plays
+ (`core/bloom.ts`). On the host from mount, because WebKit resizes a laid-out subgrid's
+ tracks when an out-of-flow box is added to it. */
+:where(.qm-wash) {
+	position: relative;
+}
+:where(.qm-wash)::after {
+	content: '';
+	position: absolute;
+	inset: 0;
+	border-radius: inherit;
+	background: var(--_qm-accent-wash);
+	opacity: 0;
+	pointer-events: none;
+}
+
 /* The capacity ladder: how many tracks a grid of fields steps to, off the width of
  the query container it stands in. One recipe, because three grids read it — a section's
  fields (`Card.svelte`), a subform's properties (`ObjectField`), each over its own
@@ -311,7 +327,8 @@
  highlight the keyboard cannot reach. It fills with the accent held rather than
  the hover rung: the mark is a cursor a keyboard drives, so it has to read at a
  glance from across the list, where a hover only has to confirm the pointer
- already under it.
+ already under it. So the mark is the item's whole focus indicator, and the
+ outline a focused item would draw beside it is taken off.
 
  The resting fill is the recipe's too: an item drawn on a `<button>` carries a UA
  fill to take back, and a scoped block outranks this file, so a caller taking it
@@ -338,6 +355,7 @@
 	background: transparent;
 	cursor: pointer;
 	user-select: none;
+	outline: none;
 }
 :where(.qm-menu-item[data-highlighted]) {
 	background: var(--_qm-accent-tint);

package/dist/visual/icons/nodes.d.ts

@@ -87,27 +87,6 @@ export declare const ICONS: {
     }], readonly ["path", {
         readonly d: "M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71";
     }]];
-    readonly hash: readonly [readonly ["line", {
-        readonly x1: "4";
-        readonly x2: "20";
-        readonly y1: "9";
-        readonly y2: "9";
-    }], readonly ["line", {
-        readonly x1: "4";
-        readonly x2: "20";
-        readonly y1: "15";
-        readonly y2: "15";
-    }], readonly ["line", {
-        readonly x1: "10";
-        readonly x2: "8";
-        readonly y1: "3";
-        readonly y2: "21";
-    }], readonly ["line", {
-        readonly x1: "16";
-        readonly x2: "14";
-        readonly y1: "3";
-        readonly y2: "21";
-    }]];
     readonly info: readonly [readonly ["circle", {
         readonly cx: "12";
         readonly cy: "12";

package/dist/visual/icons/nodes.js

@@ -5,7 +5,7 @@
 //
 // Verbatim from lucide 1.28.0 — the version is stated because a glyph that drifts
 // from upstream is otherwise invisible, and because the notices in `NOTICE` are the
-// ones that release carries (ISC, and MIT for the Feather-derived ten).
+// ones that release carries (ISC, and MIT for the Feather-derived glyphs).
 export const ICONS = {
     'chevron-right': [['path', { d: 'm9 18 6-6-6-6' }]],
     'arrow-right': [
@@ -45,12 +45,6 @@ export const ICONS = {
         ['path', { d: 'M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71' }],
         ['path', { d: 'M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71' }]
     ],
-    hash: [
-        ['line', { x1: '4', x2: '20', y1: '9', y2: '9' }],
-        ['line', { x1: '4', x2: '20', y1: '15', y2: '15' }],
-        ['line', { x1: '10', x2: '8', y1: '3', y2: '21' }],
-        ['line', { x1: '16', x2: '14', y1: '3', y2: '21' }]
-    ],
     info: [
         ['circle', { cx: '12', cy: '12', r: '10' }],
         ['path', { d: 'M12 16v-4' }],

package/dist/visual/leaves.d.ts

@@ -8,8 +8,8 @@ import type { FieldController, LeafViews } from '../core/codec/index.js';
  */
 export type LandingBox = HTMLElement | undefined | Promise<HTMLElement | undefined>;
 /**
- * A mounted field's landing handle: focus it, and the element the arrival wash blooms
- * inside ({@link import('../core/bloom.js').bloomInside}).
+ * A mounted field's landing handle: focus it, and the `.qm-wash` box the arrival wash
+ * plays over ({@link import('../core/bloom.js').bloom}).
  *
  * A `FieldController` is one, which is what lets the two lanes share a lookup; `Field`
  * builds the same shape over a form control off the handoff a label click already
@@ -71,16 +71,19 @@ export interface LeafRegistry {
     clear(): void;
 }
 export declare function createLeafRegistry(): LeafRegistry;
-/**
- * The active prose leaf as the formatting popover reaches it: the views a selection is
- * read from and a mark toggled at, and the controller where the leaf is a field's. A
- * by-value leaf has none, its anchors being dropped on the parent's value write, so the
- * anchor verbs the controller carries have nothing to act on there.
- */
+/** The active prose leaf as the formatting popover reaches it: the views a selection is
+ *  read from and a mark toggled at. */
 export interface ActiveProse {
     views: LeafViews;
-    controller?: FieldController;
 }
+/**
+ * The steps from a field's control box `root` down to the cell holding `target`, the
+ * reverse of {@link FieldControl.focusPath}: read off the marker each container rung
+ * stamps on the cell it draws, `data-qm-index` on an array's row and `data-qm-prop` on a
+ * key step (an object's property, a variant's cell, a matrix's member and an added
+ * item's title). `[]` for a target on the field's own control.
+ */
+export declare function stepsTo(target: EventTarget | null, root: Element): PathStep[];
 /** The by-value lane with a field's key bound: what a leaf under that field announces
  *  itself through, knowing no key of its own. */
 export interface ValueLeafSeat {

package/dist/visual/leaves.js

@@ -66,6 +66,25 @@ export function createLeafRegistry() {
         }
     };
 }
+/**
+ * The steps from a field's control box `root` down to the cell holding `target`, the
+ * reverse of {@link FieldControl.focusPath}: read off the marker each container rung
+ * stamps on the cell it draws, `data-qm-index` on an array's row and `data-qm-prop` on a
+ * key step (an object's property, a variant's cell, a matrix's member and an added
+ * item's title). `[]` for a target on the field's own control.
+ */
+export function stepsTo(target, root) {
+    const steps = [];
+    for (let el = target instanceof Element ? target : null; el && el !== root; el = el.parentElement) {
+        const index = el.getAttribute('data-qm-index');
+        const key = el.getAttribute('data-qm-prop');
+        if (index != null)
+            steps.push(Number(index));
+        else if (key != null)
+            steps.push(key);
+    }
+    return steps.reverse();
+}
 const SEAT = Symbol('qm-value-leaf');
 /** Seat every by-value leaf under the calling field, at any depth of its containers. */
 export function seatValueLeaves(seat) {

package/dist/visual/strings.d.ts

@@ -15,13 +15,13 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     /** The card-title input's accessible name. */
     cardTitle: string;
     /** The trailing strip's visible words, which are also every strip's accessible
-     * name; the plus rides the wording. One string over
+     * name. One string over
      * one kind and many: the trigger seeds a card, and which kind is the menu's word
      * to say or the schema's to have already settled. */
     addCard: string;
     arrayAdd: string;
     arrayRemove: string;
-    /** The drag handle on an `object` row: its tooltip and, with the row, its name. */
+    /** The drag handle on an `object` row: its tooltip. */
     arrayDrag: string;
     /**
      * A row control's accessible name, the action and the row it acts on: `Remove
@@ -35,6 +35,12 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
      * spells the separator.
      */
     arrayCount: (count: number, max: number) => string;
+    /**
+     * The count beside the label of a `text` or `richtext` field declaring `max:`, the
+     * carrier of a keystroke the cap refuses: `12 / 40`. Parametric, so a translator
+     * spells the separator.
+     */
+    textCount: (count: number, max: number) => string;
     /**
      * A collapsed array element with nothing to summarize itself by: the label and the
      * 1-based index, which is what its accessible name already says. Parametric, so
@@ -59,8 +65,6 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     /** The date field's toggle, pressed while the field holds `today`: the render
      *  date rather than a written one. */
     dateToday: string;
-    /** The required marker's accessible name; the glyph itself is a `*`. */
-    fieldRequired: string;
     /** What an unset optional cell (`t?`) ghosts at rest: the `none` it prints
      *  unanswered, in the product's words. */
     optionalGhost: string;
@@ -75,7 +79,8 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     formatStrikethrough: string;
     formatCode: string;
     formatLink: string;
-    /** The anchor button's accessible name. */
+    /** The anchor button's accessible name. The popover withholds the button, so
+     *  nothing draws this or the title below. */
     formatAnchor: string;
     /** Its hover title, which says what an anchor is; the name above only says what. */
     formatAnchorTitle: string;
@@ -138,6 +143,12 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
  * diagnostic.
  */
 export type FormatDiagnostic = (d: Diagnostic) => string | undefined;
+/**
+ * A `Mod` chord as the writer's platform prints it: `⌘B` on Apple's, `Ctrl+B`
+ * elsewhere. The platform test is the one `prosemirror-keymap` resolves `Mod` by, so a
+ * tooltip names the chord the keymap binds.
+ */
+export declare function chord(key: string, platform?: string): string;
 /** The package's English. Every key, so the merge below is total. */
 export declare const DEFAULT_VISUAL_STRINGS: VisualStrings;
 /** A consumer's wording: any subset, the rest the package's. */

package/dist/visual/strings.js

@@ -4,7 +4,7 @@
 // makes wording an override rather than a fork.
 //
 // Several of these are accessible names rather than decoration — the card
-// controls, the add trigger, the required marker — so an untranslated surface is
+// controls, the add trigger — so an untranslated surface is
 // not merely inconsistent, it reads the wrong language to a screen reader. That is
 // why this exists as a seam and not as a list of literals to grep for.
 //
@@ -14,11 +14,19 @@
 //
 // The strings reach the tree through context, not props. They are ambient,
 // read-only, and wanted eight components deep (a card's controls, a field's
-// required marker, the formatting popover, the tips card); threading them by hand
+// optional ghost, the formatting popover, the tips card); threading them by hand
 // would put a `strings` prop on every component between the root and each leaf,
 // which is a prop that means nothing to any of them.
 import { getContext, setContext } from 'svelte';
 import { DEFAULT_SLASH_STRINGS, DEFAULT_TABLE_STRINGS } from '../core/codec/index.js';
+/**
+ * A `Mod` chord as the writer's platform prints it: `⌘B` on Apple's, `Ctrl+B`
+ * elsewhere. The platform test is the one `prosemirror-keymap` resolves `Mod` by, so a
+ * tooltip names the chord the keymap binds.
+ */
+export function chord(key, platform = typeof navigator === 'undefined' ? '' : navigator.platform) {
+    return /Mac|iP(hone|[oa]d)/.test(platform) ? `⌘${key}` : `Ctrl+${key}`;
+}
 /** The package's English. Every key, so the merge below is total. */
 export const DEFAULT_VISUAL_STRINGS = {
     ...DEFAULT_TABLE_STRINGS,
@@ -27,12 +35,13 @@ export const DEFAULT_VISUAL_STRINGS = {
     cardMoveDown: 'Move down',
     cardDelete: 'Delete card',
     cardTitle: 'Card title',
-    addCard: '+ Add Card',
+    addCard: 'Add card',
     arrayAdd: '+ Add',
     arrayRemove: 'Remove',
     arrayDrag: 'Drag to move',
     arrayRowAction: (action, row) => `${action} ${row}`,
     arrayCount: (count, max) => `${count} / ${max}`,
+    textCount: (count, max) => `${count} / ${max}`,
     elementUntitled: (label, index) => `${label} ${index}`,
     enumUnsetTag: 'Default',
     enumUnsetTagNone: 'Unset',
@@ -41,16 +50,15 @@ export const DEFAULT_VISUAL_STRINGS = {
     matrixItemTitle: (list, index) => `${list ? `${list} item` : 'Item'} ${index}`,
     matrixRemove: (title) => `Remove ${title}`,
     dateToday: 'Today',
-    fieldRequired: 'required',
     optionalGhost: 'None',
     proseHeld: 'Holds more than this field can edit here.',
     formatGroup: 'Formatting',
-    formatBold: 'Bold (Mod-B)',
-    formatEmphasis: 'Emphasis (Mod-I)',
-    formatUnderline: 'Underline (Mod-U)',
+    formatBold: `Bold (${chord('B')})`,
+    formatEmphasis: `Italic (${chord('I')})`,
+    formatUnderline: `Underline (${chord('U')})`,
     formatStrikethrough: 'Strikethrough',
     formatCode: 'Code',
-    formatLink: 'Link',
+    formatLink: `Link (${chord('K')})`,
     formatAnchor: 'Anchor',
     formatAnchorTitle: 'Anchor — an identity handle over the selection',
     linkPlaceholder: 'https://…',
@@ -61,7 +69,7 @@ export const DEFAULT_VISUAL_STRINGS = {
     tipsDismiss: 'Dismiss',
     tipsNext: 'Next',
     tipsDot: (index, count) => `Tip ${index} of ${count}`,
-    unknownKind: (kind) => `Unrecognized card type ${kind}. Its content is preserved.`,
+    unknownKind: (kind) => `Unknown card type ${kind}. Its content is kept.`,
     retypeLabel: 'Change to',
     retypePlaceholder: 'Choose a type…',
     noCardKinds: 'This document declares no card types — delete this card to remove it.',

package/dist/visual/structure.d.ts

@@ -1,4 +1,5 @@
 import { type Content, type PathStep, type PayloadItem, type QuillCardSchema, type QuillFieldSchema, type QuillFieldType, type ResolvedField, type Resolved } from '@quillmark/wasm';
+import type { TextCap } from '../core/codec/index.js';
 /** The control a field type maps to (VISUAL_EDITOR §"Structure mirrors the schema"). */
 export type ControlKind = 'prose' | 'text' | 'enum' | 'variant' | 'number' | 'boolean' | 'date' | 'array' | 'object' | 'matrix';
 /** The container controls: the ones a nested address walks into and a deep
@@ -11,22 +12,17 @@ export interface FieldModel {
     control: ControlKind;
     /** `ui.group` (undefined = ungrouped). */
     group: string | undefined;
-    /** `ui.compact`: asks to share a row with adjacent compacts. A request, not a
-     * guarantee: `placeFields` declines it for the shapes that grow (see `packable`). */
+    /** Asks to share a row with adjacent compacts: `ui.compact` when declared, else
+     * {@link packsByDefault}. A request, not a guarantee: `placeFields` declines it for
+     * the shapes that grow (see `packable`). */
     compact: boolean;
     /** Display label: `title` when set, else the humanized field name. */
     label: string;
     /** Schema `description`: authoring help rendered beside the label,
      * undefined when the field declares none. Chrome-only; never gates. */
     description: string | undefined;
-    /**
-     * Required-ness: {@link obliged}. Drives a persistent label `*`; a field never
-     * carries both it and a ghosted `default:`, that default being the whole of what
-     * retires the obligation. Persistent (schema-derived, survives filling). Label
-     * chrome only; never gates.
-     */
-    required: boolean;
-    /** Prose-leaf flags (only meaningful when `control === 'prose'` / array items). */
+    /** Prose-leaf flags (only meaningful when `control === 'prose'` / array items):
+     * one line (`oneLine`), and the literal codec (`literalText`). */
     inline: boolean;
     plaintext: boolean;
 }
@@ -161,6 +157,13 @@ export declare function optionalCell(f: QuillFieldSchema): boolean;
 /** The type a cell's control reads: the declared one, an optional cell's `?` stripped.
  *  The `?` moves the render floor and nothing else, so every read of a type is this. */
 export declare function baseType(f: QuillFieldSchema): QuillFieldType;
+/** Whether a content field is one line: one paragraph, no container, no island. A `text`
+ *  or `richtext` field is one line unless it declares `multiline: true`. */
+export declare function oneLine(f: QuillFieldSchema): boolean;
+/** Whether a content field's codec is the literal one, its value text with no marks: `text`. */
+export declare function literalText(f: QuillFieldSchema): boolean;
+/** The character cap a content field's `max:` declares, `undefined` on any other. */
+export declare function textCap(f: QuillFieldSchema | undefined): TextCap | undefined;
 /**
  * A scalar `default:` as the text an unset control holds, where it prints: as
  * declared, `undefined` for none, a blank or a non-scalar. A default of spaces prints
@@ -169,19 +172,19 @@ export declare function baseType(f: QuillFieldSchema): QuillFieldType;
 export declare function printedText(v: unknown): string | undefined;
 /**
  * A declared content literal as the `Content` it holds: a `richtext` one's markdown
- * imported, a `plaintext` one's text taken literally, one paragraph whose later lines
+ * imported, a `text` one's text taken literally, one paragraph whose later lines
  * continue it, as the literal codec reads a stored one. What a cell's static
  * `default:` stands in its leaf as, where no resolved row reaches it. `undefined` for
  * a blank or a non-scalar.
  */
 export declare function declaredContent(v: unknown, markdown: boolean): Content | undefined;
-/** A field's `{#each}` key: its name and what a mounted leaf reads once, its type and
- *  `inline` and its elements'. A retype or a quill swap that changes any of them under a
- *  name remounts the field, where a kept leaf would commit on the old schema. */
+/** A field's `{#each}` key: its name and what a mounted leaf reads once, its type,
+ *  {@link oneLine} and `max:`, and its elements'. A retype or a quill swap that changes
+ *  any of them under a name remounts the field, where a kept leaf would commit on the old
+ *  schema. */
 export declare function mountKey(name: string, f: QuillFieldSchema): string;
-/** Map a field schema to its control (precedence: prose › enum › text › …).
- * An array's element control is this over `items`: a missing `items` is a text
- * element. */
+/** Map a field schema to its control. An array's element control is this over `items`;
+ *  a type this build does not know takes the text input. */
 export declare function controlKind(f: QuillFieldSchema): ControlKind;
 /** The discriminant cell of a variant container, off the boundary's own constant: it
  *  crosses inside untyped container data with no type to read it off, so a literal here
@@ -254,8 +257,8 @@ export declare function addedItems(matrix: QuillFieldSchema, map: Record<string,
  */
 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. */
+ *  added item's `title`, a one-line `text` cell, 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
@@ -267,8 +270,7 @@ export declare function matrixMemberSchema(matrix: QuillFieldSchema, id: string)
  */
 export declare function schemaAt(field: QuillFieldSchema, steps: readonly PathStep[]): QuillFieldSchema | undefined;
 /** Whether a cell is one line tall by declaration: the shape a table column and a row
- *  summary can hold. A prose cell is one where it declares `inline`, `richtext` or
- *  `plaintext` alike. */
+ *  summary can hold. A prose cell is one where it is {@link oneLine}. */
 export declare function shortCell(sub: QuillFieldSchema): boolean;
 /** A collapsed row's own words ({@link firstShortText}); `undefined` while the row has
  *  nothing to say for itself. */
@@ -301,19 +303,11 @@ export declare function variantCells(schema: QuillFieldSchema, member: string |
  * `undefined`.
  */
 export declare function commitDiscriminant(value: Record<string, unknown> | undefined, member: string | undefined): Record<string, unknown> | undefined;
-/**
- * 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, 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`. */
 export declare function humanize(name: string): string;
-/** Project a card schema's `fields` map (declaration = key order) into models. */
-export declare function fieldModels(cardSchema: QuillCardSchema): FieldModel[];
+/** Project a card schema's `fields` map (declaration = key order) into models. A
+ *  card-level object's `properties` project the same way. */
+export declare function fieldModels(cardSchema: Pick<QuillCardSchema, 'fields'>): FieldModel[];
 /**
  * Group-section order (VISUAL_EDITOR §"Structure mirrors the schema"): the schema's `ui.groups` registry
  * key order when present: `QuillCardUi.groups` is a typed `Record` at the