@quillmark/svelte 0.3.2 → 0.4.1

package/dist/core/theme.css

@@ -89,8 +89,16 @@
 		/* Neutral: the surface spends no hue on a state it can draw in grey. The pair
 		   clears WCAG 2.4.11's 3:1 against the card at both poles, at 4.8:1 and 5.8:1. */
 		--_qm-accent: var(--qm-accent, light-dark(#71717a, #a1a1aa));
-		--_qm-danger: var(--qm-danger, #c5221f);
-		--_qm-warning: var(--qm-warning, #b25000);
+		/* The two hues the surface does spend, and it spends them on a state. Each pole
+		   is its own figure rather than one ink shown twice: a hue calibrated against
+		   white reads as a stain on a dark card. All four clear WCAG 1.4.3's 4.5:1
+		   against the card, which is the bar the label rung asks for and the one the
+		   glyphs drawn in these hues clear on the way past 1.4.11's 3:1 — 5.8:1 and
+		   5.2:1 light, 7.4:1 and 7.7:1 dark. The figures are the host scale's
+		   (`preset/scale.css`), so a page's status line and a card's diagnostic carry
+		   one colour meaning error and one meaning warning. */
+		--_qm-danger: var(--qm-danger, light-dark(#c5221f, #ff9c94));
+		--_qm-warning: var(--qm-warning, light-dark(#b25000, #e0b44c));
 		--_qm-font: var(--qm-font, ui-sans-serif, system-ui, sans-serif);
 		--_qm-font-mono: var(--qm-font-mono, ui-monospace, monospace);
 
@@ -118,46 +126,45 @@
 		   a channel of each other, which is where a card with little light left to
 		   give up leaves them.
 
-		   Each takes two arms, because one figure cannot serve both poles: a dark
-		   surface has to spend more of what little it has before the card above it
-		   reads as lifted. Pinning a dark palette under a light `color-scheme` takes
-		   the light arm with it
-		   (THEMING §"The surface follows your colour scheme"), which is a step you
-		   can barely see, so a host that pins declares the scheme with it.
+		   How far each sinks is a function of the card's own L, not of the scheme the
+		   host declared: a dark surface has to spend more of what little it has
+		   before the card above it reads as lifted, so the two calibrated distances
+		   — 0.0214 off white, 0.0553 off the dark default — interpolate linearly
+		   between. A card pinned at neither pole takes a proportionate step whatever
+		   `color-scheme` says, which is the half of the derivation that reads a
+		   colour rather than a declaration.
 
-		   The ground steps by subtraction where every other rung mixes: a mix toward
-		   black is a ratio, so it scales what it takes and pulls the result toward
-		   neutral, and a ground is a fixed distance that keeps the pole's hue. Its
-		   arms are 0.0214 of oklab L in light and 0.0553 in dark, with a/b terms
-		   carrying a cool cast a mix toward black would strip, so the default lands
-		   on `#f7f8f9` and `#1a1a1b` exactly and a turned `--qm-bg` tints the plane
-		   under it.
-
-		   `raised` is a no-op at the light pole, where the card is already white
-		   and there is nowhere further to go, so a floating surface separates on
-		   its hairline in light and on the step in dark. */
+		   Both sink by subtraction where every other rung mixes: a mix toward black
+		   is a ratio, so it scales what it takes and pulls the result toward
+		   neutral, and a ground is a fixed distance. `a b` pass through, so the
+		   plane keeps the pole's hue and a turned `--qm-bg` tints it. The defaults
+		   land within a channel of `#f7f8f9` and `#1a1a1b`. Below L ≈ 0.065 the
+		   ground clamps to black, which is where a near-black card leaves no room
+		   for a ground of its own. */
 		--_qm-surface: var(--_qm-bg);
-		--_qm-surface-sunken: light-dark(
-			oklab(from var(--_qm-bg) calc(l - 0.0214) calc(a - 0.00065) calc(b - 0.00158)),
-			oklab(from var(--_qm-bg) calc(l - 0.0553) calc(a - 0.00048) calc(b + 0.00165))
-		);
-		--_qm-surface-well: light-dark(
-			color-mix(in oklab, var(--_qm-bg), #000 4%),
-			color-mix(in oklab, var(--_qm-bg), #000 20%)
-		);
+		--_qm-surface-sunken: oklab(from var(--_qm-bg) calc(l - (0.0214 + 0.0467 * (1 - l))) a b);
+		--_qm-surface-well: oklab(from var(--_qm-bg) calc(l - (0.04 + 0.0202 * (1 - l))) a b);
+		/* `raised` is the same ramp spelled as a mix, its step 0.08 × (1 − l): the light
+		   arm is zero, a white card having nowhere further to go, so a floating surface
+		   separates on its hairline and `--_qm-lift` there and the step joins them in
+		   dark. */
 		--_qm-surface-raised: color-mix(in oklab, var(--_qm-bg), #fff 8%);
 		--_qm-surface-hover: color-mix(in oklab, var(--_qm-bg), var(--_qm-fg) 8%);
 		--_qm-border: color-mix(in oklab, var(--_qm-bg), var(--_qm-fg) 17%);
 		/* A rule that separates without structuring: the lines between a table's cells,
-		   where the frame around them is the structure. Half the border's mix rather
-		   than a surface rung of its own, because it is a stroke and reads against the
-		   surface behind it, not a fill stacked on one. */
-		--_qm-border-faint: color-mix(in oklab, var(--_qm-bg), var(--_qm-fg) 9%);
-		/* A fourth step between `label` and `ghost` is a number with no fourth kind of
-		   text under it. */
+		   where the frame around them is the structure. Half the border, and read off
+		   it rather than restated as a percentage of its own, so the two hold their
+		   relationship at any mix: a stroke against the surface behind it, not a fill
+		   stacked on one. */
+		--_qm-border-faint: color-mix(in oklab, var(--_qm-bg), var(--_qm-border) 50%);
+		/* Two rungs, and there is no third: a step below `label` lands under 3:1 on the
+		   well a field draws it against, and what would take it — a placeholder, an
+		   unset value, the resolved `default:` — is content a reader has to read
+		   (WCAG 1.4.3), not decoration. So tone carries hierarchy alone, and a leaf
+		   saying shown-never-written says it against the `ink` a written value takes,
+		   in italic where it has no written neighbour to be read against. */
 		--_qm-ink: var(--_qm-fg);
 		--_qm-ink-label: color-mix(in oklab, var(--_qm-fg), var(--_qm-bg) 35%);
-		--_qm-ink-ghost: color-mix(in oklab, var(--_qm-fg), var(--_qm-bg) 60%);
 		/* The arrival wash (`core/bloom.ts`). Its alpha is a peak, not a tint: the
 		   wash animates from and back to zero, never held, so it reads over the leaf it
 		   lands on while the leaf rests clean. */
@@ -208,16 +215,21 @@
 		--_qm-tips-font: 'Courier Prime', 'Courier New', Courier, ui-monospace, monospace;
 
 		/* ── Ratios and effects ──────────────────────────────────────────────────
-		   No palette fixes these, so they are their own rungs. There is no shadow
-		   rung: elevation is a tone rung and a hairline, which say the same thing at
-		   both poles, where a shadow's offset states a light source the poles do not
-		   carry. `check:style` forbids the property outright,
-		   here as well as over the surfaces, so the absence is gated rather than
-		   remembered. */
+		   No palette fixes these, so they are their own rungs. */
 		--_qm-blur: 8px;
 		/* The popover's translucency: the raised surface mixed toward transparent, so
 		   the page reads faintly through the pill. */
 		--_qm-surface-popover: color-mix(in oklab, var(--_qm-surface-raised) 82%, transparent);
+		/* What a surface with no plane under it lifts on. A tone rung cannot carry that at
+		   both poles: `raised` is a no-op against a white card (§Colour), so in light the
+		   hairline is otherwise the whole separation over the body prose these float on.
+		   Offset-free is the whole of it: an offset states where the light is and no pole
+		   carries that, where a halo states occlusion. Toward black at both poles for the
+		   same reason — a crevice is darker than what surrounds it in a dark room too — so
+		   the cue means one thing whichever way the scale runs. Spent only on what portals;
+		   `check:style` holds the offsets at zero here and the rung as the only shadow
+		   anywhere. */
+		--_qm-lift: 0 0 12px color-mix(in oklab, #000 16%, transparent);
 		/* The recede ladder: a hover-revealed or disabled affordance at rest, and a
 		   muted one. Opacity recedes toward whatever is behind, so these invert
 		   correctly given the element's own colour is a rung. */

package/dist/preset/recipes.css

@@ -183,7 +183,7 @@ html:has(.qm-workspace) {
 /* ── Type ──────────────────────────────────────────────────────────────────── */
 
 /* A run of chrome type: a section's label, a panel's caption, the name over a readout.
-   Uppercase and tracked, which is what keeps a run this small legible at the ghost
+   Uppercase and tracked, which is what keeps a run this small legible at the meta
    rung. */
 .qm-label {
 	font-family: var(--qmh-font-mono);
@@ -191,7 +191,7 @@ html:has(.qm-workspace) {
 	line-height: var(--qmh-leading-tight);
 	letter-spacing: var(--qmh-track-label);
 	text-transform: uppercase;
-	color: var(--qmh-ghost);
+	color: var(--qmh-ink-meta);
 	margin: 0;
 }
 
@@ -232,7 +232,7 @@ pre.qm-readout {
 	line-height: var(--qmh-leading-tight);
 	letter-spacing: var(--qmh-track-label);
 	text-transform: uppercase;
-	color: var(--qmh-ghost);
+	color: var(--qmh-ink-meta);
 	margin: 0;
 }
 

package/dist/preset/scale.css

@@ -1,12 +1,12 @@
 /* The host'S derivation: the same public dials in, a closed `--qmh-*` scale for the
    page around the surfaces out. `core/theme.css` is the same shape one level down
    (dials in, `--_qm-*` out), and the two are calibrated against each other: the
-   figures here are the figures there (the ground step's two arms, 8% hover, 17%
-   border, 45% and 60% ink, the ring's width) and the dial means the same plane in
-   both, so a host plate and a card on it land on the same tone at both poles and a
-   host page meets an editor's own column exactly. The well under the ground has no counterpart here: a
-   host's own controls are boxed and carry a hairline, so nothing on a page needs the
-   step an edgeless field does.
+   figures here are the figures there (the ground step's ramp, 8% hover, 17%
+   border, 45% ink, the ring's width, the status hues at both poles) and the
+   dial means the same plane in both, so a host plate and a card on it land on the same
+   tone at both poles and a host page meets an editor's own column exactly. The well
+   under the ground has no counterpart here: a host's own controls are boxed and carry a
+   hairline, so nothing on a page needs the step an edgeless field does.
 
    Two scales rather than one because they answer to different roots. `--_qm-*` is
    declared on each mounted root, out of reach from an ancestor, so a surface holds its
@@ -26,30 +26,32 @@
 	/* ── Colour ──────────────────────────────────────────────────────────────── */
 	/* The dial is the plate, exactly as it is the card one level down: a plate beside
 	   a mounted editor is the same plane as a card in it, so both read the pole and
-	   the page sinks from it by the same two arms. That is what puts a host page and
+	   the page sinks from it by the same ramp. That is what puts a host page and
 	   an editor's own column on one tone rather than a plane apart. Planes step by
 	   light and everything else by ink, which is the package's own split
-	   (ARCHITECTURE §Styling); the figures are its figures. */
+	   (ARCHITECTURE §Styling); the figures are its figures. `Canvas` flips with the
+	   declared scheme on its own, so the ramp reads whichever plane it resolved to
+	   rather than trusting an arm to match. */
 	--qmh-surface: var(--qm-bg, Canvas);
-	--qmh-page: light-dark(
-		oklab(from var(--qmh-surface) calc(l - 0.0214) calc(a - 0.00065) calc(b - 0.00158)),
-		oklab(from var(--qmh-surface) calc(l - 0.0553) calc(a - 0.00048) calc(b + 0.00165))
-	);
+	--qmh-page: oklab(from var(--qmh-surface) calc(l - (0.0214 + 0.0467 * (1 - l))) a b);
 	--qmh-ink: var(--qm-fg, CanvasText);
+	/* One step off the ink and no second: a page's chrome type is small, tracked and
+	   uppercase, so a rung below this reads under 4.5:1 against the plate and the
+	   label and status lines that would take it are text (WCAG 1.4.3). */
 	--qmh-ink-meta: color-mix(in oklab, var(--qmh-ink), var(--qmh-surface) 45%);
-	--qmh-ghost: color-mix(in oklab, var(--qmh-ink), var(--qmh-surface) 60%);
 	--qmh-surface-hover: color-mix(in oklab, var(--qmh-surface), var(--qmh-ink) 8%);
 	--qmh-border: color-mix(in oklab, var(--qmh-surface), var(--qmh-ink) 17%);
 	/* The edge that says "engaged" where the hairline says "edge": a pressed switch,
 	   the underline under a link. */
 	--qmh-border-strong: color-mix(in oklab, var(--qmh-surface), var(--qmh-ink) 40%);
 
-	/* The two hues a host spends, and it spends them on a message. Both read the dial,
-	   so a page carries one colour meaning error and one meaning warning rather than a
-	   second pair beside the surfaces'. The dark half is a lift the dials do not carry:
-	   a hue calibrated against white reads as a stain on a dark page. */
-	--qmh-alert: light-dark(var(--qm-danger, #c5221f), #ff9c94);
-	--qmh-warn: light-dark(var(--qm-warning, #b25000), #e0b44c);
+	/* The two hues a host spends, and it spends them on a message. The figures are the
+	   surfaces' own, so a page carries one colour meaning error and one meaning warning
+	   rather than a second pair beside the surfaces'. Each pole is its own figure: a hue
+	   calibrated against white reads as a stain on a dark page. The dial sits in front
+	   of the pair, as every pole's does, so a host that turns one owns both schemes. */
+	--qmh-alert: var(--qm-danger, light-dark(#c5221f, #ff9c94));
+	--qmh-warn: var(--qm-warning, light-dark(#b25000, #e0b44c));
 
 	/* ── Rhythm ──────────────────────────────────────────────────────────────── */
 	/* One base and its multiples, the same four steps the surfaces derive. A host

package/dist/preview/geometry.d.ts

@@ -22,9 +22,10 @@ export interface PdfPoint {
  * its content and for a `richtext[]` element; runtime.d.ts says what such a field's
  * box is, a single `regions()` rect. The third rung is that sentence one granularity
  * down — an array's ink is its elements' — and is a fallback, not a union, so an
- * address with rects of its own never also draws its children's. The `.` keeps the
- * prefix a path boundary: `main.references` matches `main.references.0`, not
- * `main.references_note`.
+ * address with rects of its own never also draws its children's. The 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`.
  */
 export declare function boxesForField(field: string, boxes: readonly FieldRegion[], regions: readonly FieldRegion[]): readonly FieldRegion[];
 /**

package/dist/preview/geometry.js

@@ -7,15 +7,18 @@
  * its content and for a `richtext[]` element; runtime.d.ts says what such a field's
  * box is, a single `regions()` rect. The third rung is that sentence one granularity
  * down — an array's ink is its elements' — and is a fallback, not a union, so an
- * address with rects of its own never also draws its children's. The `.` keeps the
- * prefix a path boundary: `main.references` matches `main.references.0`, not
- * `main.references_note`.
+ * address with rects of its own never also draws its children's. The 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`.
  */
 export function boxesForField(field, boxes, regions) {
     if (boxes.length)
         return boxes;
     const own = regions.filter((r) => r.field === field);
-    return own.length ? own : regions.filter((r) => r.field.startsWith(`${field}.`));
+    if (own.length)
+        return own;
+    return regions.filter((r) => r.field.startsWith(`${field}.`) || r.field.startsWith(`${field}[`));
 }
 /**
  * Forward: a PDF-pt rect -> CSS % of the page box. Percent positioning tracks

package/dist/visual/ArrayField.svelte

@@ -2,7 +2,7 @@
  An `array` field → an add/remove repeater. Elements commit by value: every
  edit / add / remove rebuilds the whole array and hands it to the parent's typed
  `writer.set(field, wholeArray)` (arrays are not op-addressed). Element control
- by `items.type`: `string` → text input, `richtext` → a prose element
+ by `items.type`: `string` / `plaintext` → text input, `richtext` → a prose element
  ({@link ProseArrayElement}), `object` → a minimal JSON editor, keeping the prior
  element value on an entry that does not parse. The add affordance sits in the
  label header row (space-between with the field label); {@link Field} skips its
@@ -59,10 +59,16 @@
 	let { value, items, label, required, description, labelId, descriptionId, onCommit }: Props =
 		$props();
 
-	// The element control is the item schema's own; an array declaring no `items`
-	// has text elements.
-	const control = $derived(items ? controlKind(items) : 'text');
-	const plaintext = $derived(items?.type === 'plaintext');
+	// The element control is the item schema's own, with one departure: a `plaintext`
+	// element is a text input where the scalar field of that type is a prose leaf. A
+	// `plaintext` value rests as its literal string (canon SCHEMAS.md §"Content fields
+	// rest per codec"), and the read that decodes a resting value to `Content` addresses
+	// a field, never an element (`getContent`; borb-sh/quillmark#1243), so a string is
+	// what the row is handed and a string is what it commits. The prose element stays
+	// the `richtext` arm, whose elements rest as `Content` and have one.
+	//
+	// An array declaring no `items` has text elements.
+	const control = $derived(items && items.type !== 'plaintext' ? controlKind(items) : 'text');
 	const arr = $derived((value ?? []) as unknown[]);
 
 	// Parallel stable ids, one per element, kept in lockstep with the data below.
@@ -243,7 +249,6 @@
 				<ProseArrayElement
 					bind:this={els[id]}
 					value={(arr[k] ?? emptyElement()) as Content}
-					{plaintext}
 					label={label != null ? `${label} ${k + 1}` : undefined}
 					onChange={(rt) => commitElement(k, rt)}
 					onKey={(e) => onElementKey(e, k)}

package/dist/visual/Card.svelte

@@ -185,9 +185,13 @@
 	}
 </script>
 
+<!-- `data-qm-card` names the island for a floating surface that has to stay inside one
+ ({@link FieldHint}). A surface portals to `[data-qm-root]`, so the card is not its
+ ancestor and nothing else marks the box its guidance belongs in. -->
 <section
 	bind:this={el}
 	class="qm-card"
+	data-qm-card
 	class:qm-main={card.isMain}
 	class:qm-unschemable={card.unschemable}
 >
@@ -662,7 +666,7 @@
 		color: var(--_qm-ink-label);
 	}
 	.qm-recovery-muted {
-		color: var(--_qm-ink-ghost);
+		color: var(--_qm-ink-label);
 	}
 	.qm-recovery-retype {
 		display: inline-flex;

package/dist/visual/DateField.svelte

@@ -198,6 +198,6 @@
 	 never written, either way. The marker is the component's own (see the snippet):
 	 the date primitive emits no placeholder attribute of its own. */
 	.qm-date-wrap :global(.qm-date-segment[data-ghosted]) {
-		color: var(--_qm-ink-ghost);
+		color: var(--_qm-ink-label);
 	}
 </style>

package/dist/visual/EnumField.svelte

@@ -1,6 +1,6 @@
 <!--
- A `string`+`enum` (or `type: 'enum'`) field → a styled listbox over `enum ??
- values`, on bits-ui. When nothing is authored the list shows a distinct unset
+ A `type: enum` field → a styled listbox over its `values`, on bits-ui. When
+ nothing is authored the list shows a distinct unset
  sentinel that ghosts the `default:` (muted, shown-never-written), distinguishable
  from an authored pick and re-selectable; so re-picking the default fires a
  change. The sentinel commits nothing; any real pick: including the
@@ -164,7 +164,7 @@
 	/* Shown-never-written: the closed control reads muted while unset, matching the
 	   ghosted placeholder the text/number controls show. */
 	.qm-select-wrap :global(.qm-select[data-ghosted]) {
-		color: var(--_qm-ink-ghost);
+		color: var(--_qm-ink-label);
 	}
 	/* The open list is `.qm-menu-surface` and its rows `.qm-menu-item` (controls.css):
 	 the lift, the inset and the highlight are the shared menu recipe. What a listbox
@@ -184,6 +184,6 @@
 		cursor: default;
 	}
 	.qm-select-ghost {
-		color: var(--_qm-ink-ghost);
+		color: var(--_qm-ink-label);
 	}
 </style>

package/dist/visual/Field.svelte

@@ -18,7 +18,7 @@
 	import type { EditorErrorHandler } from '../core/errors.js';
 	import type { LeafRegistry } from './leaves.js';
 	import type { FieldModel, FieldSpan } from './structure.js';
-	import { enumValues, ghostDefault, stringifyGhost } from './structure.js';
+	import { ghostDefault, stringifyGhost } from './structure.js';
 	import type { FieldDomIds } from './domid.js';
 	import ProseField from './ProseField.svelte';
 	import TextField from './TextField.svelte';
@@ -207,7 +207,7 @@
 			{:else if field.control === 'enum'}
 				<EnumField
 					value={value as string | undefined}
-					values={enumValues(field.schema) ?? []}
+					values={field.schema.values ?? []}
 					fallback={ghost as string | undefined}
 					id={domIds.control}
 					{describedBy}

package/dist/visual/FieldHint.svelte

@@ -46,6 +46,13 @@
 	 * along with the editor's subtree. `undefined` falls back to bits-ui's default. */
 	const portalTarget = $derived(triggerEl?.closest<HTMLElement>('[data-qm-root]') ?? undefined);
 
+	/** What the surface stays inside: the field's own card and the root it portals into.
+	 * floating-ui intersects the two, so a flip answers to whichever is tighter. Empty
+	 * falls back to the primitive's default, the surface's own clipping ancestors. */
+	const bounds = $derived(
+		[triggerEl?.closest<HTMLElement>('[data-qm-card]'), portalTarget].filter((el) => el != null)
+	);
+
 	/** Placement, re-measured on each opening: the surface rides the label rung beside
 	 * the glyph, or stands over the field. */
 	let beside = $state(false);
@@ -132,11 +139,18 @@
  neighbour's control instead, which reaching for it dismisses. -->
 <!-- `align="center"` for the rung, `"start"` over the field: centred, a surface taller
  than the glyph's line box would hang half its height onto the field's own control. -->
+<!-- Both are preferences, and the card is what refuses them: its first field has no room
+ above its label inside one, so standing over that field puts the surface on the ground
+ above the card, reading as the neighbour's rather than as this field's. Refused, the
+ placement reverses and the surface goes under the field, over the control it describes:
+ the overlap the fork above spends a probe to avoid, and the only one left where there is
+ nothing above to stand over. -->
 
 <Popover.Root bind:open>
 	<Popover.Portal to={portalTarget}>
 		<Popover.Content
 			customAnchor={triggerEl ?? null}
+			collisionBoundary={bounds}
 			side={beside ? 'right' : 'top'}
 			align={beside ? 'center' : 'start'}
 			sideOffset={6}
@@ -186,8 +200,8 @@
 	 It takes no fill either: the ink step below says hover, and the surface itself
 	 opens on it. */
 	.qm-field-hint {
-		/* The marker recedes to the label's ghost tone; the surface carries the text. */
-		color: var(--_qm-ink-ghost);
+		/* The marker recedes to the label rung; the surface carries the text. */
+		color: var(--_qm-ink-label);
 		/* Not the family's `pointer`: the glyph raises guidance, it does not act. */
 		cursor: help;
 		padding: 0;

package/dist/visual/FormatPopover.svelte

@@ -65,6 +65,7 @@
 	import Icon from './icons/Icon.svelte';
 	import type { IconName } from './icons/nodes.js';
 	import {
+		hasMarks,
 		rangeAnchor,
 		type FieldController,
 		type LeafViews,
@@ -140,7 +141,17 @@
 		// Escape out of a table cell lands.
 		const selection = view?.state.selection;
 		const formattable = selection instanceof TextSelection && !selection.empty;
-		if (!view || !view.hasFocus() || !formattable || !hasText(view)) {
+		// …in a leaf that has formatting at all. A `plaintext` leaf declares no mark
+		// types (`plaintextSchema`), so this surface withholds itself over one entirely,
+		// the way it never rises over the text input a `string` field draws: the value is
+		// literal text, and a mark on it is a value the boundary refuses to coerce back.
+		if (
+			!view ||
+			!view.hasFocus() ||
+			!formattable ||
+			!hasMarks(view.state.schema) ||
+			!hasText(view)
+		) {
 			open = false;
 			linkPromptOpen = false;
 			return;

package/dist/visual/ObjectField.svelte

@@ -11,7 +11,7 @@
 -->
 <script lang="ts">
 	import type { QuillFieldSchema } from '@quillmark/wasm';
-	import { controlKind, enumValues, humanize } from './structure.js';
+	import { controlKind, humanize } from './structure.js';
 	import TextField from './TextField.svelte';
 	import EnumField from './EnumField.svelte';
 	import NumberField from './NumberField.svelte';
@@ -79,7 +79,7 @@
 				<EnumField
 					label={propLabel}
 					value={obj[key] as string | undefined}
-					values={enumValues(sub) ?? []}
+					values={sub.values ?? []}
 					fallback={sub.default as string | undefined}
 					onCommit={(v) => commitProp(key, v)}
 				/>
@@ -144,7 +144,7 @@
 	}
 	.qm-unsupported {
 		font-size: var(--_qm-text-body);
-		color: var(--_qm-ink-ghost);
+		color: var(--_qm-ink-label);
 		font-style: italic;
 	}
 </style>

package/dist/visual/ProseArrayElement.svelte

@@ -1,7 +1,7 @@
 <!--
- One element of an array-of-`richtext` field (fixture `references`). Array
+ One element of an array-of-`richtext` field (fixture `keywords`). Array
  elements are not `applyChange`-addressable: `Addr.field` is a flat name, so
- `references.0` has no op address. So
+ `keywords[0]` has 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 hands the re-encoded
  `Content` up to the parent {@link ArrayField}, which commits the whole array
@@ -19,7 +19,6 @@
 
 	interface Props {
 		value: Content;
-		plaintext?: boolean;
 		/** Accessible name for the editable region (the array has no per-element label). */
 		label?: string;
 		onChange: (rt: Content) => void;
@@ -28,7 +27,7 @@
 		 * keymap, so the state it reads is the one this keystroke has yet to change. */
 		onKey?: (e: KeyboardEvent) => void;
 	}
-	let { value, plaintext, label, onChange, onKey }: Props = $props();
+	let { value, label, onChange, onKey }: Props = $props();
 
 	let containerEl: HTMLDivElement | undefined = $state();
 	let view: EditorView | undefined;
@@ -45,10 +44,10 @@
 		// plugin stack a `createField` leaf mounts (shared `proseLeafPlugins`), minus
 		// the anchor-position plugin (element anchors are dropped on the array's value
 		// write, per the header). Its own `dispatchTransaction` hands `Content` up.
-		const pmDoc = decode(value, inlineSchema, { plaintext: !!plaintext });
+		const pmDoc = decode(value, inlineSchema);
 		const state = EditorState.create({
 			doc: pmDoc,
-			plugins: proseLeafPlugins(inlineSchema, { inline: true, plaintext: !!plaintext })
+			plugins: proseLeafPlugins(inlineSchema, { inline: true })
 		});
 		const mounted = new EditorView(containerEl, {
 			state,

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

@@ -2,7 +2,6 @@ import './controls.css';
 import type { Content } from '@quillmark/wasm';
 interface Props {
     value: Content;
-    plaintext?: boolean;
     /** Accessible name for the editable region (the array has no per-element label). */
     label?: string;
     onChange: (rt: Content) => void;

package/dist/visual/ProseField.svelte

@@ -179,11 +179,13 @@
 	.qm-prose :global(.ProseMirror) {
 		outline: none;
 	}
-	/* Empty-leaf ghost, at the scalar ghost rung: a node decoration's data attr, so it
-	 stays out of the document; `float`/`height: 0` keep it from displacing the caret. */
+	/* Empty-leaf ghost, at the rung every scalar's placeholder takes: a node decoration's
+	 data attr, so it stays out of the document; `float`/`height: 0` keep it from
+	 displacing the caret. The italic is what a leaf with no written neighbour has
+	 instead of the step to `ink`. */
 	.qm-prose :global(.ProseMirror .qm-prose-placeholder::before) {
 		content: attr(data-placeholder);
-		color: var(--_qm-ink-ghost);
+		color: var(--_qm-ink-label);
 		font-style: italic;
 		float: left;
 		height: 0;

package/dist/visual/VisualEditorInner.svelte

@@ -736,12 +736,11 @@
 	 * diagnostics take.
 	 *
 	 * Two rungs, because the boundary mints addresses at a finer granularity than
-	 * `Addr` can name: a `richtext[]` element surfaces as `main.references.0`, which
-	 * the grammar reads as a field literally named `"0"`. The second rung reads that
-	 * trailing segment as an index, under a field the schema declares an array — which
-	 * is why the ladder is the editor's (VISUAL_EDITOR.md §Surface): the preview
-	 * carries no schema, and truncating the address there is worse than guessing, since
-	 * `pos` is an offset into the element's own content.
+	 * `Addr` can name: a `richtext[]` element surfaces as `main.keywords[0]`. The
+	 * second rung reads that trailing index segment under a field the schema declares
+	 * an array — which is why the ladder is the editor's (VISUAL_EDITOR.md §Surface):
+	 * the preview carries no schema, and truncating the address there is worse than
+	 * guessing, since `pos` is an offset into the element's own content.
 	 */
 	function leafTargetFor(field: DocPath): LeafTarget | undefined {
 		const direct = addrForFieldPath(field);

package/dist/visual/controls.css

@@ -106,12 +106,13 @@
 		width: 100%;
 		box-sizing: border-box;
 	}
-	/* The native placeholder is the ghost rung, not the UA's own grey: a text or
-	   number control's placeholder is the resolved `default:` (Field's `defaultStr`)
-	   and reads as shown-never-written the same way the prose leaf's empty-state
-	   ghost does (`ProseField`). */
+	/* 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`). */
 	.qm-input::placeholder {
-		color: var(--_qm-ink-ghost);
+		color: var(--_qm-ink-label);
 	}
 
 	/* The second recipe, and it is not the box above: a field is a box because you
@@ -242,13 +243,15 @@
 
 	 A floating surface is the one place a hairline is still load-bearing: it hangs
 	 over content the surface did not choose, so there is no plane under it for a
-	 tone to step off (ARCHITECTURE §Styling). It takes the raised rung as well, which
-	 is a real step in dark and nothing in light, where the edge is the whole of it. */
+	 tone to step off (ARCHITECTURE §Styling). The edge and `--_qm-lift` carry it
+	 there, and the raised rung joins them in dark, where a tone still has somewhere
+	 to go. */
 	.qm-menu-surface {
 		padding: var(--_qm-space-half);
 		border: var(--_qm-border-width) solid var(--_qm-border);
 		border-radius: var(--_qm-radius);
 		background: var(--_qm-surface-raised);
+		box-shadow: var(--_qm-lift);
 		font-size: var(--_qm-text-body);
 		color: var(--_qm-ink);
 	}
@@ -291,6 +294,7 @@
 		-webkit-backdrop-filter: blur(var(--_qm-blur));
 		border: var(--_qm-border-width) solid var(--_qm-border);
 		border-radius: var(--_qm-radius);
+		box-shadow: var(--_qm-lift);
 		animation: qm-pop-in var(--_qm-duration-fast) var(--_qm-ease-reverse);
 	}
 	.qm-popover-surface[data-ending-style] {

package/dist/visual/structure.d.ts

@@ -150,8 +150,6 @@ export declare function resolveBodyGhost(resolvedDefault: string | undefined, cu
  * An array's element control is this over `items`: a missing `items` is a text
  * element. */
 export declare function controlKind(f: QuillFieldSchema): ControlKind;
-/** The closed value domain of an enum/enum-string field, or undefined. */
-export declare function enumValues(f: QuillFieldSchema): string[] | undefined;
 /** `foo_bar` → `Foo bar`: the label fallback when a field declares no `ui.title`. */
 export declare function humanize(name: string): string;
 /** Project a card schema's `fields` map (declaration = key order) into models. */