@quillmark/svelte 0.10.1 → 0.11.0

package/dist/preview/bridge.d.ts

@@ -35,4 +35,11 @@ export interface VerticalSpan {
  * the port: no scroll shows more of it.
  */
 export declare function clearOfTheFold(target: VerticalSpan, port: VerticalSpan): boolean;
-export declare function createBridge(session: LiveSession, container: HTMLElement, slots: readonly PageSlot[], onPick: ((at: Landing) => void) | undefined): BridgeController;
+/** The trip a pane with no box could not run, held for the box coming back. One, and the
+ *  last one asked for: a caret hop supersedes the hop before it on a showing pane too.
+ *  A cell rather than closure state, so a bridge rebuilt under a changed page count
+ *  inherits what the one it replaced was holding (`controller.ts`). */
+export interface HeldTrip {
+    run?: () => void;
+}
+export declare function createBridge(session: LiveSession, container: HTMLElement, slots: readonly PageSlot[], onPick: ((at: Landing) => void) | undefined, held?: HeldTrip): BridgeController;

package/dist/preview/bridge.js

@@ -1,4 +1,4 @@
-import { boxesForField, rectToPercent, clickToPdfPt, applyPercentRect } from './geometry.js';
+import { boxesForField, rectToPercent, clickToPdfPt, pxToPt, applyPercentRect } from './geometry.js';
 /** A pane hidden by the shell's narrow switch (`preset/recipes.css`) measures 0×0, and so
  *  does every box on it: the clearance arithmetic reads that as a caret clear of both
  *  edges, and a centring computes its trip out of zeros. Neither is an answer about where
@@ -9,6 +9,11 @@ function hasBox(port) {
 /** What a rect reporting no height clears an edge by, in CSS px: a caret's own at the
  *  smallest zoom a page still reads at. */
 const MIN_CLEARANCE = 8;
+/** What a click may miss a field's ink by and still land on it, in CSS px of the page as
+ *  drawn, so it converts per click at the scale the slot is showing. Sized as the
+ *  pointer's imprecision and not as the leading it partly closes, which is a trade
+ *  PREVIEW.md §"Click bridge" carries. */
+const CLICK_SLACK_PX = 2;
 /**
  * Whether `target` sits clear of `port`'s edges by the fold's clearance, which is the
  * target's own height: a caret rect flush against an edge is visible and unusable, and
@@ -29,14 +34,15 @@ export function clearOfTheFold(target, port) {
     const clearance = Math.min(Math.max(target.height, MIN_CLEARANCE), (port.height - target.height) / 3);
     return target.top - clearance >= port.top && target.bottom + clearance <= port.bottom;
 }
-export function createBridge(session, container, slots, onPick) {
+export function createBridge(session, container, slots, onPick, held = {}) {
     const unlisten = [];
     // Two rungs: `positionAt` over span-tracked content, `fieldAt` over every placement
     // the compile tracks, a strict superset of it (PREVIEW.md §"Click bridge" carries
     // the measurement). The second fires where a field is placed without its content
     // being tracked, and the pick carries no `pos` there: a fabricated `0` would be an
     // invented offset wearing a real one's type. No third rung hit-tests `regions()`,
-    // whose rects bound ink the field does not fill.
+    // whose rects bound ink the field does not fill; the slack both rungs carry is what
+    // that rung would have been reached for.
     if (onPick) {
         for (const { page, el } of slots) {
             const handleClick = (ev) => {
@@ -50,10 +56,11 @@ export function createBridge(session, container, slots, onPick) {
                 const px = ev.clientX - box.left;
                 const py = ev.clientY - box.top;
                 const pt = clickToPdfPt(px, py, box.width, box.height, slot.size);
-                const hit = session.positionAt(slot.page, pt.x, pt.y);
+                const tol = pxToPt(CLICK_SLACK_PX, box.width, slot.size);
+                const hit = session.positionAt(slot.page, pt.x, pt.y, tol);
                 if (hit)
                     return void onPick(hit);
-                const field = session.fieldAt(slot.page, pt.x, pt.y);
+                const field = session.fieldAt(slot.page, pt.x, pt.y, tol);
                 if (field)
                     onPick({ field });
             };
@@ -72,52 +79,50 @@ export function createBridge(session, container, slots, onPick) {
         marker.remove();
         return rect;
     }
-    // Centre `target` vertically in the scrollport; the cross axis takes the minimum
-    // trip instead, since the container is a vertical scroller and only a page wider
-    // than the port has anything to move there.
-    function centre(target) {
-        const port = container.getBoundingClientRect();
+    // Centre `target` vertically in `port`, the scrollport's box; the cross axis takes the
+    // minimum trip instead, since the container is a vertical scroller and only a page
+    // wider than the port has anything to move there. `port` is the caller's own read: the
+    // marker `measure` places is absolute inside the slot, so nothing between that read
+    // and this one moves the container's box, and one forced layout serves the whole hop.
+    function centre(target, port) {
         container.scrollTop += target.top + target.height / 2 - (port.top + port.height / 2);
         if (target.left < port.left)
             container.scrollLeft += target.left - port.left;
         else if (target.right > port.right)
             container.scrollLeft += target.right - port.right;
     }
-    // The trip a pane with no box could not run, held for the box coming back. One, and
-    // the last one asked for: a caret hop supersedes the hop before it on a showing pane
-    // too.
-    let held;
     // The re-assert. Nothing else asks on the way back: `refresh` re-asks only on a
     // recompile, and the reader who has just tapped Preview is not typing, so the pane
     // would open where the caret was several edits ago. Guarded for jsdom, which ships no
     // ResizeObserver and lays out nothing for one to report.
     if (typeof ResizeObserver !== 'undefined') {
         const observer = new ResizeObserver(() => {
-            if (!held || !hasBox(container.getBoundingClientRect()))
+            if (!held.run || !hasBox(container.getBoundingClientRect()))
                 return;
-            const trip = held;
-            held = undefined;
+            const trip = held.run;
+            held.run = undefined;
             trip();
         });
         observer.observe(container);
         unlisten.push(() => observer.disconnect());
     }
     function scrollToField(field) {
-        const box = boxesForField(field, session.fieldBoxes(field), session.regions())[0];
+        const box = boxesForField(field, session.fieldBoxes(field), () => session.regions())[0];
         if (!box)
             return false;
         const slot = slots[box.page];
         if (!slot)
             return false;
+        const port = container.getBoundingClientRect();
         // The address is placed, which is the whole of what the `boolean` answers; a pane
         // with no box yet is not a second no.
-        if (!hasBox(container.getBoundingClientRect())) {
-            held = () => void scrollToField(field);
+        if (!hasBox(port)) {
+            held.run = () => void scrollToField(field);
             return true;
         }
         // A discrete act ("show me this field"), so it centres every time, unlike
         // the continuous hop below.
-        centre(measure(slot, rectToPercent(box.rect, slot.size)));
+        centre(measure(slot, rectToPercent(box.rect, slot.size)), port);
         return true;
     }
     function focusPosition(field, pos) {
@@ -131,8 +136,9 @@ export function createBridge(session, container, slots, onPick) {
         // for every keystroke of (`hasBox`): the follow would die silently for as long as
         // a track is hidden. What is held is the request, not the trip, so it re-locates
         // against whatever compile is current when the pane comes back.
-        if (!hasBox(container.getBoundingClientRect())) {
-            held = () => focusPosition(field, pos);
+        const port = container.getBoundingClientRect();
+        if (!hasBox(port)) {
+            held.run = () => focusPosition(field, pos);
             return;
         }
         // The continuous hop: one call per keystroke and per arrow key, so it moves
@@ -140,9 +146,9 @@ export function createBridge(session, container, slots, onPick) {
         // takes the scrollport back from the user on every one of them, including
         // the ones that changed nothing about where the caret already was.
         const target = measure(slot, rectToPercent(region.rect, slot.size));
-        if (clearOfTheFold(target, container.getBoundingClientRect()))
+        if (clearOfTheFold(target, port))
             return;
-        centre(target);
+        centre(target, port);
     }
     return {
         scrollToField,

package/dist/preview/controller.js

@@ -7,14 +7,13 @@ const CONTAINER_CLASS = 'qm-preview';
 // class, the hooks a consumer and the tests target.
 const MESSAGE_CLASS = 'qm-preview-message';
 const EMPTY_CLASS = 'qm-preview-empty';
-const UNSUPPORTED_CLASS = 'qm-preview-unsupported';
 const ERROR_CLASS = 'qm-preview-error';
 export function createPreview(session, opts) {
     const container = opts.container;
     const margin = opts.margin ?? 1;
     const t = mergePreviewStrings(opts.strings);
     container.classList.add(CONTAINER_CLASS);
-    // One element, restamped: the non-paint states (empty, unsupported, a paint that
+    // One element, restamped: the non-paint states (empty, a paint that
     // threw) are mutually exclusive.
     let message;
     function showMessage(text, state) {
@@ -33,8 +32,8 @@ export function createPreview(session, opts) {
     // slots and never calls the `paint`/`pageSize` verbs the boundary refuses
     // there. A paint that unexpectedly throws is caught per-slot and surfaced
     // through the shared message rather than aborting the observer callback
-    // mid-sweep (runtime.d.ts: even a `supportsCanvas` compile can hit a paint
-    // the boundary refuses; brittle to leave uncaught).
+    // mid-sweep (a paint is the one surface that can still refuse a counted page;
+    // brittle to leave uncaught).
     const paintLoop = createPaintLoop(session, container, margin, (page, err) => {
         reportError(opts.onError, {
             code: 'paint-failed',
@@ -50,24 +49,25 @@ export function createPreview(session, opts) {
     // slots array is a stable identity but its members are swapped on reconcile, and
     // the listeners are per slot.
     let bridge;
+    // Outlives that rebuild, so a trip held for a pane with no box crosses it. Only the
+    // follow is re-asserted after a recompile, and a `scrollToField` the pane could not
+    // run has nothing else that would ask again for it.
+    const held = {};
     function attach() {
-        bridge = createBridge(session, container, paintLoop.slots, opts.onPick);
+        bridge = createBridge(session, container, paintLoop.slots, opts.onPick, held);
     }
     function detach() {
         bridge?.destroy();
         bridge = undefined;
     }
-    // Called at construction and after every `apply`, so `supportsCanvas` is re-read
-    // per compile (runtime.d.ts: re-check after `open`) and a 0-page or non-canvas
-    // compile that later gains paintable pages recovers; the check spans the paint
-    // capability generally, not just the page count.
+    // Called at construction and after every `apply`, so a 0-page compile that later
+    // gains pages recovers. A counted page is the whole condition: every backend
+    // paints, and `paint`/`pageSize` refuse only a page the count excludes.
     function render(pageCount, dirtyPages) {
-        if (!session.supportsCanvas || pageCount === 0) {
-            // A 0-page compile is a recoverable empty; pages the boundary cannot
-            // raster are a genuine unsupported.
+        if (pageCount === 0) {
             paintLoop.refresh([], 0);
             detach();
-            showMessage(pageCount === 0 ? t.noPages : t.unsupported, pageCount === 0 ? EMPTY_CLASS : UNSUPPORTED_CLASS);
+            showMessage(t.noPages, EMPTY_CLASS);
             return;
         }
         // Read the count against the current slots before reconcile moves it, and

package/dist/preview/geometry.d.ts

@@ -27,8 +27,11 @@ export interface PdfPoint {
  * boundary character (`.` for a nested field, `[` for an array element) keeps the
  * prefix a path boundary: `main.keywords` matches `main.keywords[0]`, not
  * `main.keywords_note`.
+ *
+ * `regions` is a thunk because the first rung answers without it, and taking it
+ * marshals every placement in the compile across the WASM boundary.
  */
-export declare function boxesForField(field: string, boxes: readonly FieldRegion[], regions: readonly FieldRegion[]): readonly FieldRegion[];
+export declare function boxesForField(field: string, boxes: readonly FieldRegion[], regions: () => readonly FieldRegion[]): readonly FieldRegion[];
 /**
  * Forward: a PDF-pt rect -> CSS % of the page box. Percent positioning tracks
  * the page's displayed size across DPR and container resize for free, so the
@@ -41,6 +44,14 @@ export declare function rectToPercent(rect: PdfRect, pageSize: PageSize): Percen
  * the transform that produces it rather than at the caller placing a marker.
  */
 export declare function applyPercentRect(el: HTMLElement, pct: PercentRect): void;
+/**
+ * A CSS-px length on a page element of CSS width `cssW` -> the PDF-pt length it spans.
+ * Width alone, because that is the scale the slot is drawn at: `paint.ts` sizes a slot
+ * by width under a locked aspect ratio, so {@link clickToPdfPt}'s two ratios are one
+ * number and a length has one to convert through. What the click bridge reads its
+ * pointer slack in points through.
+ */
+export declare function pxToPt(px: number, cssW: number, pageSize: PageSize): number;
 /**
  * Inverse: a click at CSS px `(px, py)` within a page element of CSS size
  * `(cssW, cssH)` -> PDF-pt. The exact inverse of {@link rectToPercent}: the

package/dist/preview/geometry.js

@@ -12,11 +12,14 @@
  * boundary character (`.` for a nested field, `[` for an array element) keeps the
  * prefix a path boundary: `main.keywords` matches `main.keywords[0]`, not
  * `main.keywords_note`.
+ *
+ * `regions` is a thunk because the first rung answers without it, and taking it
+ * marshals every placement in the compile across the WASM boundary.
  */
 export function boxesForField(field, boxes, regions) {
     if (boxes.length)
         return boxes;
-    return regions.filter((r) => r.field === field || r.field.startsWith(`${field}.`) || r.field.startsWith(`${field}[`));
+    return regions().filter((r) => r.field === field || r.field.startsWith(`${field}.`) || r.field.startsWith(`${field}[`));
 }
 /**
  * Forward: a PDF-pt rect -> CSS % of the page box. Percent positioning tracks
@@ -47,6 +50,16 @@ export function applyPercentRect(el, pct) {
         height: `${pct.height}%`
     });
 }
+/**
+ * A CSS-px length on a page element of CSS width `cssW` -> the PDF-pt length it spans.
+ * Width alone, because that is the scale the slot is drawn at: `paint.ts` sizes a slot
+ * by width under a locked aspect ratio, so {@link clickToPdfPt}'s two ratios are one
+ * number and a length has one to convert through. What the click bridge reads its
+ * pointer slack in points through.
+ */
+export function pxToPt(px, cssW, pageSize) {
+    return (px / cssW) * pageSize.widthPt;
+}
 /**
  * Inverse: a click at CSS px `(px, py)` within a page element of CSS size
  * `(cssW, cssH)` -> PDF-pt. The exact inverse of {@link rectToPercent}: the

package/dist/preview/paint.js

@@ -41,7 +41,11 @@ onPaintError) {
         // responsibilities"). `border-box` costs nothing here and keeps a slot a
         // consumer insets from measuring wider than its paper.
         const el = document.createElement('div');
-        el.className = 'qm-page';
+        // Not `.qm-page`: that name is the preset's page baseline, an unlayered rule at
+        // ordinary specificity a host puts on `<body>`, and a slot wearing it takes that
+        // rule's `color-scheme` inside a mounted root, which the derivation leaves to the
+        // host (`core/theme.css`).
+        el.className = 'qm-page-slot';
         // The page's index, in the DOM. `pageByEl` is this module's and a consumer
         // drawing an overlay of its own needs the number: position among siblings is
         // the only handle without it, which is right today and is not a contract.
@@ -157,9 +161,7 @@ onPaintError) {
     }
     // Slots are built on the first `refresh` (the controller calls it immediately),
     // not here: reconcile → `session.pageSize` must run after the controller's
-    // `supportsCanvas`/`pageCount` gate, since a `supportsCanvas: false` compile with
-    // pages would throw on `pageSize` (runtime.d.ts: it succeeds iff `supportsCanvas`)
-    // before the controller can surface its "unsupported" message.
+    // `pageCount` gate, since `pageSize` throws for a page the count excludes.
     // ── Keep mounted rasters in step with the display ───────────────────────────
     // Every paint freezes `canvas.style.width/height` to the box width at that
     // paint (paintSlot). A page that stays mounted while the container's CSS width

package/dist/preview/strings.d.ts

@@ -3,8 +3,6 @@ export interface PreviewStrings {
     renderFailed: string;
     /** A compile with zero pages: recoverable, and the commonest state of a fresh seed. */
     noPages: string;
-    /** A compile whose pages this backend cannot raster at all. */
-    unsupported: string;
 }
 /** The package's English. Every key, so the merge below is total. */
 export declare const DEFAULT_PREVIEW_STRINGS: PreviewStrings;

package/dist/preview/strings.js

@@ -1,5 +1,5 @@
-// Every word the preview says. Three, because the surface is a canvas and its
-// only prose is the message states that stand in when there is nothing to paint.
+// Every word the preview says: the surface is a canvas, and its only prose is the
+// message states that stand in when there is nothing to paint.
 //
 // Separate from the visual surface's set rather than pooled with it: `/preview`
 // reaches `/core` and nothing editor-side, which is what lets it promote to its own
@@ -8,13 +8,12 @@
 // twice rather than learning two idioms.
 //
 // A plain options field rather than a context channel, unlike the visual surface's:
-// these three are read in one module by one function, so there is no tree to make
-// them ambient for.
+// they are read in one module by one function, so there is no tree to make them
+// ambient for.
 /** The package's English. Every key, so the merge below is total. */
 export const DEFAULT_PREVIEW_STRINGS = {
     renderFailed: 'Preview failed to render.',
-    noPages: 'No pages to preview.',
-    unsupported: 'Preview is not available for this document.'
+    noPages: 'No pages to preview.'
 };
 /** Fill a partial override to the whole key set. */
 export function mergePreviewStrings(custom) {

package/dist/visual/ArrayField.svelte

@@ -147,7 +147,6 @@
 	// element shapes register alike.
 	const rowEls: Record<string, HTMLElement | undefined> = $state({});
 	let addEl: HTMLButtonElement | undefined = $state();
-	let rootEl: HTMLElement | undefined = $state();
 	let rowsEl: HTMLElement | undefined = $state();
 
 	// ── Object elements: one open at a time ──────────────────────────────────────
@@ -268,8 +267,8 @@
 	 * compile the document has moved past.
 	 *
 	 * An absent `pos` is the placement rung, exactly as on `Landing`. A row that takes
-	 * no offset gets the bare focus: the JSON element, whose textarea has no coordinate
-	 * to spend one in, and a `string` element, which the compile never addresses.
+	 * no offset gets the bare focus: a `string` element, whose input has no coordinate
+	 * to spend one in and which the compile never addresses.
 	 *
 	 * The row's box comes back with the landing: the arrival wash is the address's own
 	 * granularity, and one row is what an element address named. A fallback to the
@@ -325,8 +324,8 @@
 	/**
 	 * The element keyboard contract. Both keys ride the element control's own keydown
 	 * (the input's, or the PM view's through `handleDOMEvents`) since neither
-	 * surface is a place a keymap of this component's could sit. The JSON element is
-	 * out: Enter is a newline in a textarea.
+	 * surface is a place a keymap of this component's could sit. An `object` element
+	 * wires neither: its row is a summary button, whose Enter is the disclosure's.
 	 */
 	function onElementKey(e: KeyboardEvent, k: number): void {
 		if (control === 'object' || e.isComposing) return;
@@ -345,7 +344,6 @@
 </script>
 
 <div
-	bind:this={rootEl}
 	class="qm-array"
 	class:empty={ids.length === 0}
 	role="group"
@@ -484,10 +482,10 @@
 	.qm-array-rows.empty {
 		display: none;
 	}
-	/* A grid rather than a block: an `<input>` and a `<textarea>` are inline-level and
-	 would sit on a baseline, standing the row a descender taller than the box the slab
-	 measures itself against. `minmax(0, …)` because a long unbroken value grows an `auto`
-	 track, and the edge with it. */
+	/* A grid rather than a block: an `<input>` is inline-level and would sit on a
+	 baseline, standing the row a descender taller than the box the slab measures itself
+	 against. `minmax(0, …)` because a long unbroken value grows an `auto` track, and the
+	 edge with it. */
 	.qm-array-row {
 		position: relative;
 		display: grid;
@@ -498,9 +496,9 @@
 		border-radius: var(--_qm-radius-inner);
 	}
 	/* The end inset the slab stands in, taken off whichever box the element drew:
-	 `.qm-input` is the text element and the JSON textarea, `.qm-control-box` the prose
-	 one. `:global`, because the box belongs to the child component's markup and the scope
-	 class stops at this component's. The longhand beats the family's `padding` shorthand
+	 `.qm-input` is the text element, `.qm-control-box` the prose one and an object row's
+	 summary. `:global`, because the box belongs to the child component's markup and the
+	 scope class stops at this component's. The longhand beats the family's `padding` shorthand
 	 without a specificity fight: this block is unlayered and `controls.css` is not. */
 	.qm-array-row :global(.qm-input),
 	.qm-array-row :global(.qm-control-box) {

package/dist/visual/Card.svelte

@@ -315,7 +315,7 @@
 						{quill}
 						addr={ops.makeAddr(undefined)}
 						unframed
-						label="Body"
+						label={t.strings.bodyLabel}
 						placeholder={card.bodyGhost}
 						leafKey={ops.leafKey(undefined)}
 						{onFocus}
@@ -359,9 +359,9 @@
 {/snippet}
 
 <!-- A card whose `kind` has no schema stays visible and removable, its fields, body and
- `$ext` intact in the Document, so it is never a data trap. `setCardKind` swaps the kind
- and leaves payload and body untouched, so retyping drops no field; with no kinds to
- offer, delete is the only exit. -->
+ `$ext` intact in the Document, so it is never a data trap. A retype swaps the kind and
+ leaves payload and body untouched, so it drops no field; with no kinds to offer, delete
+ is the only exit. -->
 {#snippet recoveryShell()}
 	<header class="qm-card-header">
 		<span class="qm-card-title-static">{humanize(card.kind)}</span>
@@ -393,7 +393,7 @@
 				</select>
 			</label>
 		{:else}
-			<p class="qm-recovery-note qm-recovery-muted">
+			<p class="qm-recovery-note">
 				{t.strings.noCardKinds}
 			</p>
 		{/if}
@@ -780,9 +780,6 @@
 		font-size: var(--_qm-text-label);
 		color: var(--_qm-ink-label);
 	}
-	.qm-recovery-muted {
-		color: var(--_qm-ink-label);
-	}
 	.qm-recovery-retype {
 		display: inline-flex;
 		align-items: center;

package/dist/visual/DateField.svelte

@@ -11,7 +11,7 @@
  calendar) rather than `DatePicker`: the segments are the entry affordance, and a
  calendar is a second surface this field does not need.
 
- The boundary is A string, and the local is too. The primitive speaks
+ The boundary is a string, and the local is too. The primitive speaks
  `CalendarDate`; the document speaks `YYYY-MM-DD`. `CalendarDate` carries no time
  and no zone, so the round-trip is lossless and no local-midnight shift can occur:
  the hazard that makes `new Date('2026-07-25')` the wrong tool here. Authored
@@ -22,7 +22,7 @@
  parsed value: a fresh `CalendarDate` is never `===` the last one, which would
  make every reconcile fire and re-render all seven segments on each commit.
 
- The ghost is the default'S digits, not A format hint. An unset field
+ The ghost is the default's digits, not a format hint. An unset field
  carrying a `default:` prints the default's digits in the segments, ghost-toned,
  instead of the primitive's `mm`/`dd`/`yyyy` hints, which say "empty" where the
  rung says "will render 2026-01-01". The ghost is painted in the segment snippet,

package/dist/visual/Field.svelte

@@ -128,10 +128,13 @@
 	 * array's elements, an object's properties, a variant's cells, and a subform's cells
 	 * under an open element. One door rather than one per depth, since `getContentAt`
 	 * takes the whole path and the walk down is each container prefixing its own step.
-	 * Read per call and never held: a leaf takes its state at mount, and a control asks
-	 * once. */
+	 *
+	 * The reader is held, as the codec's is (`field.ts`): a `{quill, doc}` pair reads
+	 * live, so every call through it sees the commit before it, and an array of prose
+	 * elements is one handle across the boundary rather than one per element. */
+	const reader = $derived(quill.reader(doc));
 	function contentAt(path: PathStep[]): Content | undefined {
-		return quill.reader(doc).getContentAt(addr, path);
+		return reader.getContentAt(addr, path);
 	}
 
 	// ── Focus: one answer, two callers (`leaves.ts`) ─────────────────────────────
@@ -239,6 +242,7 @@
 					{addr}
 					inline={field.inline}
 					plaintext={field.plaintext}
+					placeholder={defaultStr}
 					labelledBy={domIds.label}
 					{describedBy}
 					{leafKey}

package/dist/visual/FieldHint.svelte

@@ -131,7 +131,7 @@
 	}}><Icon name="info" size={13} /></button
 >
 
-<!-- Placement is the description'S height. One line rides the label rung beside its own
+<!-- Placement is the description's height. One line rides the label rung beside its own
  glyph, where the overhang past the rung's line box falls in the label-to-control gaps.
  Anything taller stands over the field: beside the glyph it would hang onto the control
  it describes, the one overlap a reader cannot clear by reaching for what is hidden,

package/dist/visual/ObjectField.svelte

@@ -122,7 +122,11 @@
 			prose.focus();
 			return true;
 		}
-		const el = cell.querySelector<HTMLElement>(FOCUSABLE);
+		// Past the label row: a property carrying a `description` opens with the hint
+		// trigger, which is focusable and stands before the control it describes.
+		const el = [...cell.querySelectorAll<HTMLElement>(FOCUSABLE)].find(
+			(n) => !n.closest('.qm-field-label-row')
+		);
 		el?.focus();
 		return !!el;
 	}
@@ -205,6 +209,7 @@
 					labelledBy={ids?.label}
 					describedBy={describes}
 					value={obj[key] as string | undefined}
+					fallback={sub.default != null ? String(sub.default) : undefined}
 					onCommit={(v) => commitProp(key, v)}
 				/>
 			{:else if kind === 'text'}

package/dist/visual/VisualEditor.svelte

@@ -3,7 +3,7 @@
  `doc` prop remounts the editor under it, so a consumer holding one mount across
  two documents gets a surface that names the live handle.
 
- It is A `{#key}`, not A reseed. The state a swap invalidates is not one field:
+ It is a `{#key}`, not a reseed. The state a swap invalidates is not one field:
  composable cards key on session id, the main card is keyed on nothing, and each
  prose leaf mounts once per stable leaf key with `createField` closing over the
  `doc` it mounted against — so after an in-place swap the main card's leaves