@quillmark/svelte 0.12.0 → 0.14.0

package/dist/visual/ProseValue.svelte

@@ -4,12 +4,12 @@
  `object`'s property, a variant's cell ({@link ObjectField}). None of them is
  `applyChange`-addressable: `Addr.field` is a flat name, so `keywords[0]` and
  `contact.note` have no op address. So this is not a `createField` leaf: it mounts a
- minimal PM view over the codec's decode/encode + inline schema, and on every edit
+ minimal PM view over the codec's decode/encode and a leaf schema, and on every edit
  hands the re-encoded `Content` up to the parent — {@link ArrayField}, which commits
  the whole array, or {@link ObjectField}, which commits the whole container
- (`writer.set(field, next)`). Anchors inside a value are dropped on that write:
- acceptable for inline refs. Mounts once per stable key (an element's session id, a
- property's name), so the parent's re-derive leaves the caret where it is.
+ (`writer.set(field, next)`). Anchors inside a value are dropped on that write.
+ Mounts once per stable key (an element's session id, a property's name), so the
+ parent's re-derive leaves the caret where it is.
 
  The content is read, not passed: `reader.getContentAt(addr, path)` decodes through
  the codec the leaf's own declared type names, so what it rests as — the content
@@ -17,37 +17,55 @@
  being the row's or the cell's business. Read once, at mount, since that is when this
  leaf takes its state.
 
- One textblock wherever it mounts, no islands and no slash menu. `plaintext` is
- inline at the codec, so that is the declared shape for every plaintext leaf; a block
- `richtext` is held one rung narrower than it declares, having no room for a second
- paragraph in the figure a repeater row and a subform cell draw.
+ The schema is the declared type's where the parent has room for it: a subform cell
+ declaring no `inline` takes the full row ({@link ObjectField}), a `richtext` one on the
+ block schema and a `plaintext` one on the plain schema, paragraphs and hard breaks.
+ An array element is one textblock whatever it declares, since Enter there is the
+ repeater's. There is no slash menu at either width, and an island draws as its
+ placeholder: an atom a keystroke can delete and no view edits.
+
+ A leaf over content its schema cannot hold is held: a narrowed one over anything but
+ one plain paragraph (`fitsInline`), a plain one over anything but plain lines
+ (`fitsPlain`). Its decode would join or drop what is left over, and the first
+ keystroke would write that loss back, so a held leaf draws its content on the block
+ schema, read-only, with a note inside its box, and commits nothing.
 -->
 <script lang="ts">
 	import { onMount } from 'svelte';
 	import { EditorState, Selection } from 'prosemirror-state';
 	import { EditorView } from 'prosemirror-view';
 	import {
+		blockSchema,
 		decode,
+		emptyContent,
+		fitsLeaf,
+		heldAttributes,
+		leafSchema,
 		pmToContent,
-		inlineSchema,
-		plaintextSchema,
 		proseAttributes,
 		proseLeafPlugins,
 		buildLineIndex,
 		usvToPM
 	} from '../core/codec/index.js';
+	import { wording } from './strings.js';
 	import './controls.css';
 	import type { Content } from '@quillmark/wasm';
 
 	interface Props {
-		/** This leaf's content, read at mount (the parent's boundary read). A thunk
-		 * rather than a value: the parent re-derives per revision and this leaf takes
-		 * its state once, so a value prop would be a boundary read per leaf per render,
-		 * all but one of them discarded. */
-		content: () => Content;
+		/** This leaf's content, read at mount (the parent's boundary read), `undefined`
+		 * where nothing is stored. A thunk rather than a value: the parent re-derives
+		 * per revision and this leaf takes its state once, so a value prop would be a
+		 * boundary read per leaf per render, all but one of them discarded. */
+		content: () => Content | undefined;
+		/** The default an unset leaf holds, where it prints: drawn at the default rung,
+		 * and handed up whole with the first edit in it, as `createField` takes one. */
+		fallback?: Content;
 		/** The mark-free schema (a `plaintext` leaf): literal text, no formatting,
 		 * exactly as the scalar field of that type mounts. */
 		plaintext?: boolean;
+		/** A multi-block schema, for a cell the parent draws at full width: the block
+		 * schema, or the plain one with `plaintext`. Absent, the leaf is one textblock. */
+		block?: boolean;
 		/** Accessible name for the editable region, where nothing else names it: an
 		 * array has no per-element label. A cell with a label element takes
 		 * `labelledBy`. */
@@ -58,6 +76,12 @@
 		labelledBy?: string;
 		/** The parked `description` (FieldLabel) → `aria-describedby`. */
 		describedBy?: string;
+		/** The empty leaf's ghosts, a subform cell's, until the leaf's first edit: the
+		 *  `none` an optional cell prints unset, and the `example:` drawn where there is no
+		 *  placeholder and in its stead while the leaf holds the focus (`createField`'s
+		 *  pair). Read per decoration pass. */
+		placeholder?: string;
+		example?: string;
 		onChange: (rt: Content) => void;
 		/** Raw keydown, for a container whose own keys run through this leaf: the
 		 * array repeater's Enter/Backspace (`ArrayField`). Fires before the view's own
@@ -66,15 +90,23 @@
 	}
 	let {
 		content,
+		fallback,
 		plaintext = false,
+		block = false,
 		label,
 		labelledBy,
 		describedBy,
+		placeholder,
+		example,
 		onChange,
 		onKey
 	}: Props = $props();
 
-	let containerEl: HTMLDivElement | undefined = $state();
+	const t = wording();
+	const uid = $props.id();
+	const heldId = `${uid}-held`;
+	let editorEl: HTMLDivElement | undefined = $state();
+	let held = $state(false);
 	let view: EditorView | undefined;
 	/** Take the caret: what a parent placing focus on this leaf calls. The view's
 	 * focus, not the element's: a PM view restores its selection, where a bare DOM
@@ -107,39 +139,55 @@
 	}
 
 	onMount(() => {
-		if (!containerEl) return;
-		// An inline, value-by-value leaf: the same keymap and plugin stack a
-		// `createField` leaf mounts (shared `proseLeafPlugins`), minus the
-		// anchor-position plugin (anchors are dropped on the parent's value write, per
-		// the header). Its own `dispatchTransaction` hands `Content` up.
-		//
-		// The schema is the declared type's, as `createField` picks it: `plaintext`
-		// declares no mark types, so there is nothing to toggle, to paste in, or to
-		// mint a shorthand with.
-		const schema = plaintext ? plaintextSchema : inlineSchema;
-		const pmDoc = decode(content(), schema);
+		if (!editorEl) return;
+		// The same keymap and plugin stack a `createField` leaf mounts (shared
+		// `proseLeafPlugins`), minus the anchor-position plugin: anchors are dropped on
+		// the parent's value write, per the header.
+		const inline = !block;
+		const stored = content();
+		const rt = stored ?? fallback ?? emptyContent();
+		let defaulted = stored === undefined && !!fallback;
+		held = !fitsLeaf(rt, { inline, plaintext });
+		const named = held
+			? heldAttributes({ label, labelledBy, describedBy }, heldId)
+			: (proseAttributes({ label, labelledBy, describedBy }) ?? {});
+		const defaultNamed = { ...named, 'data-default': '' };
+		const schema = held ? blockSchema : leafSchema({ plaintext, inline });
 		const state = EditorState.create({
-			doc: pmDoc,
-			plugins: proseLeafPlugins(schema, { inline: true })
+			doc: decode(rt, schema),
+			plugins: held
+				? []
+				: proseLeafPlugins(schema, {
+						inline,
+						placeholder: () => placeholder,
+						placeholderUntilEdit: true,
+						example: () => example
+					})
 		});
-		const mounted = new EditorView(containerEl, {
-			state,
-			// Which of `aria-label` / `aria-labelledby` wins is the codec's one answer
-			// (`proseAttributes`), so a cell carrying a label element and a row carrying
-			// none cannot name their regions by different rules.
-			attributes: proseAttributes({ label, labelledBy, describedBy }),
-			dispatchTransaction(tr) {
-				const next = mounted.state.apply(tr);
-				mounted.updateState(next);
-				if (tr.docChanged) onChange(pmToContent(next.doc));
-			},
-			handleDOMEvents: {
-				keydown: (_v, e) => {
-					onKey?.(e);
-					return false;
+		const mounted = new EditorView(
+			{ mount: editorEl },
+			{
+				state,
+				editable: () => !held,
+				// Which of `aria-label` / `aria-labelledby` wins is the codec's one answer
+				// (`proseAttributes`), so a cell carrying a label element and a row carrying
+				// none cannot name their regions by different rules.
+				attributes: () => (defaulted ? defaultNamed : named),
+				dispatchTransaction(tr) {
+					const next = mounted.state.apply(tr);
+					const edit = tr.docChanged && !held;
+					if (edit) defaulted = false;
+					mounted.updateState(next);
+					if (edit) onChange(pmToContent(next.doc));
+				},
+				handleDOMEvents: {
+					keydown: (_v, e) => {
+						onKey?.(e);
+						return false;
+					}
 				}
 			}
-		});
+		);
 		view = mounted;
 		return () => {
 			view = undefined;
@@ -153,7 +201,15 @@
  like the text cell beside it. No floor: the reset in `core/codec/prose.css` makes one
  line of prose measure one line. Width is the row's or the cell's to give: the leaf
  fills the track it is placed in. -->
-<div bind:this={containerEl} class="qm-prose-value qm-control-box qm-focus-ring-within"></div>
+<div class="qm-prose-value qm-control-box qm-focus-ring-within">
+	<div bind:this={editorEl}></div>
+	<!-- Inside the box, so the cell or row holds one child either way: a subform cell's
+	     subgrid has a row for the label and one for the box, and an array row's slabs
+	     stand the box's height. -->
+	{#if held}
+		<span id={heldId} class="qm-prose-held-note">{t.strings.proseHeld}</span>
+	{/if}
+</div>
 
 <style>
 	/* Caret-primary, matching ProseField: the contenteditable's own outline is

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

@@ -1,14 +1,20 @@
 import './controls.css';
 import type { Content } from '@quillmark/wasm';
 interface Props {
-    /** This leaf's content, read at mount (the parent's boundary read). A thunk
-     * rather than a value: the parent re-derives per revision and this leaf takes
-     * its state once, so a value prop would be a boundary read per leaf per render,
-     * all but one of them discarded. */
-    content: () => Content;
+    /** This leaf's content, read at mount (the parent's boundary read), `undefined`
+     * where nothing is stored. A thunk rather than a value: the parent re-derives
+     * per revision and this leaf takes its state once, so a value prop would be a
+     * boundary read per leaf per render, all but one of them discarded. */
+    content: () => Content | undefined;
+    /** The default an unset leaf holds, where it prints: drawn at the default rung,
+     * and handed up whole with the first edit in it, as `createField` takes one. */
+    fallback?: Content;
     /** The mark-free schema (a `plaintext` leaf): literal text, no formatting,
      * exactly as the scalar field of that type mounts. */
     plaintext?: boolean;
+    /** A multi-block schema, for a cell the parent draws at full width: the block
+     * schema, or the plain one with `plaintext`. Absent, the leaf is one textblock. */
+    block?: boolean;
     /** Accessible name for the editable region, where nothing else names it: an
      * array has no per-element label. A cell with a label element takes
      * `labelledBy`. */
@@ -19,6 +25,12 @@ interface Props {
     labelledBy?: string;
     /** The parked `description` (FieldLabel) → `aria-describedby`. */
     describedBy?: string;
+    /** The empty leaf's ghosts, a subform cell's, until the leaf's first edit: the
+     *  `none` an optional cell prints unset, and the `example:` drawn where there is no
+     *  placeholder and in its stead while the leaf holds the focus (`createField`'s
+     *  pair). Read per decoration pass. */
+    placeholder?: string;
+    example?: string;
     onChange: (rt: Content) => void;
     /** Raw keydown, for a container whose own keys run through this leaf: the
      * array repeater's Enter/Backspace (`ArrayField`). Fires before the view's own

package/dist/visual/TextField.svelte

@@ -1,12 +1,17 @@
 <!--
- A `string` field → text input. Commits a non-empty edit live (on input) via the
- parent's typed `writer.set`, so the preview tracks typing. A cleared field is the
- unset rung of the commitment ladder (VISUAL_EDITOR §"Structure mirrors the schema"): it
- commits `undefined` (the parent removes the field, ghosted `default:` renders):
- but at `change` (blur), not per keystroke, so select-all-and-retype doesn't flash
- the field through its default between the delete and the first typed char.
- Trade-off (recorded in VISUAL_EDITOR): an explicit empty string over a non-empty
- default is inexpressible from the UI: clear and unset collapse to one gesture.
+ A `string` field → text input. Commits every edit live (on input) via the parent's
+ typed `writer.set`, so the preview tracks typing.
+
+ An unset field whose `default:` prints holds that default as its text, at the
+ default rung (theme.css): the value it prints, drawn as one and a step off a written
+ one. Nothing is written until an edit, which writes the whole text as authored: the
+ default taken, whatever the edit left of it. Tabbing through writes nothing; a
+ keystroke typed and removed pins the default.
+
+ An emptied input writes what empty means for this field (VISUAL_EDITOR §"The
+ commitment ladder"): `""` over a default that prints, the only answer that prints empty there;
+ the unset rung elsewhere, where unset already prints nothing and the field stays
+ unanswered, and an optional cell returns to `none`.
 -->
 <script lang="ts">
 	import { syncedLocal } from './synced.svelte.js';
@@ -14,7 +19,14 @@
 
 	interface Props {
 		value: string | undefined;
+		/** The resolved `default:` where it prints: the text an unset field holds. */
+		fallback?: string;
+		/** Words at rest about an unset field that holds no text: the `None` an optional
+		 * cell prints. */
 		placeholder?: string;
+		/** An unset field's `example:` (`exampleGhost`): drawn wherever the field holds no
+		 * text, and in `placeholder`'s stead while the input holds the focus. */
+		example?: string;
 		/** Accessible name for an input nothing else names: an array element, whose
 		 * name is the field label plus its 1-based index. A field's own input takes
 		 * `id` instead and is named by the `<label for>` beside it. */
@@ -29,11 +41,17 @@
 		 * array repeater's Enter/Backspace (`ArrayField`). */
 		onKey?: (e: KeyboardEvent) => void;
 	}
-	let { value, placeholder, label, id, describedBy, onCommit, onKey }: Props = $props();
+	let { value, fallback, placeholder, example, label, id, describedBy, onCommit, onKey }: Props =
+		$props();
 
-	// Local input state synced to `value`: own-typing stays local, only an external
-	// change reconciles back in (see `syncedLocal`).
-	const local = syncedLocal(() => value ?? '');
+	// Local input state synced to `value`, or to the default an unset field holds:
+	// own-typing stays local, only an external change reconciles back in (see
+	// `syncedLocal`).
+	const local = syncedLocal(() => value ?? fallback ?? '');
+	const defaulted = $derived(value == null && !!fallback && local.value === fallback);
+
+	let focused = $state(false);
+	const ghost = $derived(focused ? (example ?? placeholder) : (placeholder ?? example));
 
 	let inputEl: HTMLInputElement | undefined = $state();
 	/** Take the caret: what a parent placing focus on this control calls. */
@@ -48,16 +66,15 @@
 	type="text"
 	value={local.value}
 	{id}
-	{placeholder}
+	placeholder={ghost}
+	data-default={defaulted ? '' : undefined}
 	aria-label={id ? undefined : label}
 	aria-describedby={describedBy}
 	onkeydown={onKey}
+	onfocus={() => (focused = true)}
+	onblur={() => (focused = false)}
 	oninput={(e) => {
 		local.value = (e.currentTarget as HTMLInputElement).value;
-		// Live-commit a non-empty edit; defer a cleared field to `change` (see header).
-		if (local.value !== '') onCommit(local.value);
-	}}
-	onchange={() => {
-		if (local.value === '') onCommit(undefined);
+		onCommit(local.value !== '' ? local.value : fallback ? '' : undefined);
 	}}
 />

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

@@ -1,7 +1,14 @@
 import './controls.css';
 interface Props {
     value: string | undefined;
+    /** The resolved `default:` where it prints: the text an unset field holds. */
+    fallback?: string;
+    /** Words at rest about an unset field that holds no text: the `None` an optional
+     * cell prints. */
     placeholder?: string;
+    /** An unset field's `example:` (`exampleGhost`): drawn wherever the field holds no
+     * text, and in `placeholder`'s stead while the input holds the focus. */
+    example?: string;
     /** Accessible name for an input nothing else names: an array element, whose
      * name is the field label plus its 1-based index. A field's own input takes
      * `id` instead and is named by the `<label for>` beside it. */

package/dist/visual/VariantField.svelte

@@ -116,6 +116,7 @@
 		value={discriminant}
 		values={schema.values ?? []}
 		fallback={ghostMember}
+		blankTitle={schema.ui?.blank_title}
 		{id}
 		{describedBy}
 		onCommit={(v) => onCommit(commitDiscriminant(value, v))}

package/dist/visual/VisualEditorInner.svelte

@@ -50,20 +50,21 @@
 		IdSeq,
 		controlKind,
 		isContainer,
+		shortCell,
 		schemaAt,
 		fieldModels,
 		groupOrder,
 		groupSections,
 		groupLabel,
 		cardTitle,
-		titleFields,
+		kindTitle,
 		fieldValues,
 		bodyEnabled,
-		humanize,
 		provenanceMap,
 		resolvedByCardIndex,
 		ghostDefault,
-		stringifyGhost,
+		declaredGhost,
+		titleText,
 		resolveBodyGhost,
 		NO_RESOLVED_ROWS,
 		type CardModel,
@@ -286,24 +287,22 @@
 		onChange?.({ source: 'prose', cardId, path: pathFor(plain) });
 	}
 
-	/** A card's header after a prose commit to a field its `{field}` title names: the
-	 *  one piece of the model that lane changes, held beside the model and dropped on
-	 *  the next bump, which rebuilds it from the document. The kind is the derived
-	 *  tree's ({@link liveKinds}), so the document is read only for a title that
-	 *  names the field. */
+	/** A header named by the card's own values, after a prose commit to one that can name
+	 *  it: the one piece of the model that lane moves, held beside the model and dropped
+	 *  on the next bump, which rebuilds it from the document. The card is read only for a
+	 *  one-line prose field of a kind declaring no `title` (`cardTitle`). */
 	let liveTitles = $state<Record<CardId, string>>({});
 	function refreshTitle(addr: Addr, cardId: CardId): void {
 		const { card: at, field } = addr;
-		if (field == null) return;
-		const shown = at == null ? model.main : model.cards[at];
-		if (!shown) return;
-		const cardSchema = at == null ? quill.schema.main : quill.schema.card_kinds?.[shown.kind];
-		if (!titleFields(cardSchema?.ui?.title).includes(field)) return;
-		const live = at == null ? doc.main : doc.cards[at];
-		if (!live) return;
+		if (at == null || field == null) return;
+		const shown = model.cards[at];
+		const cardSchema = shown && quill.schema.card_kinds?.[shown.kind];
+		if (!cardSchema || cardSchema.title?.trim()) return;
+		const sub = Object.hasOwn(cardSchema.fields, field) ? cardSchema.fields[field] : undefined;
+		if (!sub || !shortCell(sub)) return;
 		liveTitles = {
 			...liveTitles,
-			[cardId]: cardTitle(cardSchema, shown.kind, fieldValues(live.payloadItems), undefined)
+			[cardId]: cardTitle(cardSchema, shown.kind, fieldValues(doc.card(at).payloadItems), undefined)
 		};
 	}
 	function titled(c: CardModel): CardModel {
@@ -328,11 +327,11 @@
 		const keyStr = fieldKeyToString(key);
 		try {
 			if (value === undefined) {
-				// The unset rung of the commitment ladder (VISUAL_EDITOR §"Structure mirrors
-				// the schema"): removing the field leaves the engine's authored › `default:`
-				// › blank-fill resolve to render the default, where writing one bakes a
-				// snapshot the schema cannot track (canon SCHEMAS.md: the engine never
-				// persists a default; nor do we). Removal writes no value, so there is
+				// The unset rung (VISUAL_EDITOR §"The commitment ladder"): removing the field
+				// leaves the engine's authored › `default:` › blank-fill resolve to render the
+				// default, where writing one bakes a snapshot the schema cannot track (canon
+				// SCHEMAS.md: the engine never writes a default; the editor writes one only
+				// as the edit that takes it). Removal writes no value, so there is
 				// nothing for a schema to conform and the lane is the quill-free one.
 				if (isMain) {
 					doc.removeField(name);
@@ -612,7 +611,8 @@
 			// still across a re-derive because the function does.
 			bodyGhost: hasBody
 				? resolveBodyGhost(
-						stringifyGhost(ghostDefault(rows.body ?? undefined)),
+						titleText(ghostDefault(rows.body ?? undefined)) || undefined,
+						declaredGhost(cardSchema?.body?.example, true),
 						merged.bodyPlaceholder?.({ cardId: id, kind, isMain }),
 						merged.bodyGhost
 					)
@@ -858,7 +858,7 @@
 	<div class="qm-primary">
 		<Card
 			bind:this={mainCard}
-			card={titled(model.main)}
+			card={model.main}
 			{doc}
 			{quill}
 			isFirst={true}
@@ -957,7 +957,7 @@
 							<div class="qm-menu-surface" data-qm-root>
 								{#each kinds as k (k)}
 									<DropdownMenu.Item class="qm-menu-item" onSelect={() => addCard(atIndex, k)}
-										>{humanize(k)}</DropdownMenu.Item
+										>{kindTitle(quill.schema.card_kinds?.[k], k)}</DropdownMenu.Item
 									>
 								{/each}
 							</div>

package/dist/visual/controls.css

@@ -105,14 +105,25 @@
 	width: 100%;
 	box-sizing: border-box;
 }
-/* The native placeholder is the label rung, not the UA's own grey: a text or
-   number control's placeholder is the resolved `default:` (Field's `defaultStr`),
-   which is content and reads at a content's contrast. What says shown-never-written
-   is the step from the `ink` a written value takes, the same step the prose leaf's
-   empty state reads (`ProseField`). */
+/* An unset field's text where its `default:` prints (`TextField`, `NumberField`, a
+   prose leaf): the value, at the default rung, so it reads as an answer and never as a
+   written one. The first edit writes it and the rung goes with the attribute. */
+:where(.qm-input[data-default], .ProseMirror[data-default]) {
+	color: var(--_qm-ink-default);
+}
+/* The native placeholder is the label rung, not the UA's own grey: what an input
+   ghosts is words about a value it does not hold — an `example:`, `None` — which is
+   content and reads at a content's contrast, the same step the prose leaf's ghost
+   reads (`prose.css`). */
 :where(.qm-input)::placeholder {
 	color: var(--_qm-ink-label);
 }
+/* The note a held prose leaf draws inside its box, under the text it is about. */
+:where(.qm-prose-held-note) {
+	display: block;
+	font-size: var(--_qm-text-label);
+	color: var(--_qm-ink-label);
+}
 
 /* The second recipe, and it is not the box above: a field is a box because you
  type into it. A button rests with no fill; the surface arrives on hover, off the

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

@@ -119,6 +119,34 @@ export declare const ICONS: {
     readonly check: readonly [readonly ["path", {
         readonly d: "M20 6 9 17l-5-5";
     }]];
+    readonly calendar: readonly [readonly ["path", {
+        readonly d: "M8 2v3";
+    }], readonly ["path", {
+        readonly d: "M16 2v3";
+    }], readonly ["rect", {
+        readonly x: "3";
+        readonly y: "3";
+        readonly width: "18";
+        readonly height: "18";
+        readonly rx: "2";
+    }], readonly ["path", {
+        readonly d: "M3 9h18";
+    }]];
+    readonly 'calendar-check': readonly [readonly ["path", {
+        readonly d: "M8 2v3";
+    }], readonly ["path", {
+        readonly d: "M16 2v3";
+    }], readonly ["rect", {
+        readonly x: "3";
+        readonly y: "3";
+        readonly width: "18";
+        readonly height: "18";
+        readonly rx: "2";
+    }], readonly ["path", {
+        readonly d: "M3 9h18";
+    }], readonly ["path", {
+        readonly d: "m9 15 2 2 4-4";
+    }]];
 };
 /** The closed set. A name that is not here is a compile error at the call site,
  *  which is what a string key buys over thirteen imported components. */

package/dist/visual/icons/nodes.js

@@ -64,5 +64,18 @@ export const ICONS = {
         ['path', { d: 'M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2' }]
     ],
     minus: [['path', { d: 'M5 12h14' }]],
-    check: [['path', { d: 'M20 6 9 17l-5-5' }]]
+    check: [['path', { d: 'M20 6 9 17l-5-5' }]],
+    calendar: [
+        ['path', { d: 'M8 2v3' }],
+        ['path', { d: 'M16 2v3' }],
+        ['rect', { x: '3', y: '3', width: '18', height: '18', rx: '2' }],
+        ['path', { d: 'M3 9h18' }]
+    ],
+    'calendar-check': [
+        ['path', { d: 'M8 2v3' }],
+        ['path', { d: 'M16 2v3' }],
+        ['rect', { x: '3', y: '3', width: '18', height: '18', rx: '2' }],
+        ['path', { d: 'M3 9h18' }],
+        ['path', { d: 'm9 15 2 2 4-4' }]
+    ]
 };

package/dist/visual/strings.d.ts

@@ -47,8 +47,17 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     enumUnsetTag: string;
     /** The count in the matrix's label row: how many of the roster are held. */
     matrixHeld: (held: number, total: number) => string;
+    /** 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;
+    /** Under a prose leaf holding more structure than it can edit (paragraphs, a list,
+     *  an island in a one-line cell), which it draws read-only rather than flatten. */
+    proseHeld: string;
     formatGroup: string;
     formatBold: string;
     formatEmphasis: string;
@@ -84,7 +93,8 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     bodyGhost: string;
     /**
      * Per-CARD wording, in place of {@link VisualStrings.bodyGhost}; `undefined`
-     * takes it. Pure and uncached ({@link BodyPlaceholder}).
+     * takes it. A body `default:` and the kind's `body.example` both outrank it
+     * (`resolveBodyGhost`). Pure and uncached ({@link BodyPlaceholder}).
      */
     bodyPlaceholder: BodyPlaceholder;
 }

package/dist/visual/strings.js

@@ -37,7 +37,10 @@ export const DEFAULT_VISUAL_STRINGS = {
     elementUntitled: (label, index) => `${label} ${index}`,
     enumUnsetTag: 'default',
     matrixHeld: (held, total) => `${held} of ${total} held`,
+    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)',