@quillmark/svelte 0.3.2 → 0.4.0

package/README.md

@@ -200,7 +200,7 @@ onPick: (at) => visualEditor.setCaret(at);
 onCaretMove: preview.focusPosition;
 ```
 
-A pick carries a caret where the compile tracks the content under the point, and the field alone where it tracks only the placement — a scalar the plate prints without tracking. `setCaret` takes both: an absent `pos` reveals and focuses the field, which is the whole of what a click on plate-placed ink can mean. The address may name an array element (`main.references.0`), which lands on that row.
+A pick carries a caret where the compile tracks the content under the point, and the field alone where it tracks only the placement — a scalar the plate prints without tracking. `setCaret` takes both: an absent `pos` reveals and focuses the field, which is the whole of what a click on plate-placed ink can mean. The address may name an array element (`main.keywords[0]`), which lands on that row.
 
 A consumer holding an `Addr` of its own maps it with `fieldPathForAddr` (from `@quillmark/svelte/core`). The playground app's split-pane route is the full reference shell: one session, both bridge directions, the preview following edits, and diagnostics routed inline.
 

package/THEMING.md

@@ -54,8 +54,8 @@ The poles take a colour, not `transparent` or `inherit`: the raised surfaces, th
 | `--qm-bg`        | `#fff` / `#272729`                     | Base surface: a card, and the preview's sheet. Fields, the popover and the column behind the cards each step off it.                                           |
 | `--qm-fg`        | `#1c1c1c` / `#d7dadc`                  | Base ink. Body text, labels, and borders step off it.                                                                                                          |
 | `--qm-accent`    | `#71717a` / `#a1a1aa`                  | Focus rings, active marks, the preview's active field box. The surface spends no hue of its own, so this is the one it wears.                                  |
-| `--qm-danger`    | `#c5221f`                              | Error diagnostics, the required marker, the delete glyph.                                                                                                      |
-| `--qm-warning`   | `#b25000`                              | Warning diagnostics.                                                                                                                                           |
+| `--qm-danger`    | `#c5221f` / `#ff9c94`                  | Error diagnostics, the required marker, the delete glyph.                                                                                                      |
+| `--qm-warning`   | `#b25000` / `#e0b44c`                  | Warning diagnostics.                                                                                                                                           |
 | `--qm-font`      | `ui-sans-serif, system-ui, sans-serif` | The editor surface's font family. Controls and buttons take it too, in place of the UA face.                                                                   |
 | `--qm-font-mono` | `ui-monospace, monospace`              | The monospace face: the JSON array control, the tips card.                                                                                                     |
 | `--qm-font-size` | `0.875rem`                             | Chrome text: every control's size, the anchor the ramp derives up (title) and down (label/meta) from, and the anchor a document body sits one small step over. |
@@ -80,7 +80,7 @@ Declared before our sheet it fixes the order outright; declared after, `qm` is a
 
 Ink steps `fg → bg` and the borders and hover fills step `bg → fg`, mixed in **oklab**, so inverting the two poles inverts all of them together.
 
-**Planes are the exception**, and deliberately: the raised plane is the brighter one in both schemes, which is what makes a card read as a card rather than as a differently-tinted page. So the column under the cards sinks from `--qm-bg` toward shadow and a floating surface rises from it toward light, and neither reads the ink pole. Each direction takes a step sized to the scheme it is in, which is why pinning a dark palette while your `color-scheme` still says light leaves the column barely off its cards — the one case §"Make it yours" tells you to pin the scheme alongside the poles.
+**Planes are the exception**, and deliberately: the raised plane is the brighter one in both schemes, which is what makes a card read as a card rather than as a differently-tinted page. So the column under the cards sinks from `--qm-bg` toward shadow and a floating surface rises from it toward light, and neither reads the ink pole. How far each steps is a function of the card's own lightness — a dark card has to spend more before the plane above it reads as lifted — so a palette pinned at neither pole takes a proportionate step without being told which scheme it is in.
 
 Which way the poles default is **your `color-scheme`**, not the operating system's. Declare the scheme your app is in and the surface lands on it, along with native chrome, which reads the same property:
 
@@ -106,7 +106,11 @@ Setting the poles yourself wins over the default in both schemes, so a fixed pal
 }
 ```
 
-A palette **pinned against** your own scheme is the one case needing a second line: the surfaces follow your dials, but native chrome follows `color-scheme`, so pin it with them (`.my-editor { color-scheme: dark }`). Skip that line and what the browser paints — the selection highlight, the scrollbar, the spinner — stays on whichever scheme the host inherits.
+That cuts both ways for the status hues: `--qm-danger` and `--qm-warning` each default to a pair calibrated against the card at both poles, and one pinned value replaces both arms, so a red measured against white carries into the dark scheme unmeasured. Pin them under your own scheme rule (`.dark { --qm-danger: … }`) where the colour your app means by error is itself scheme-aware.
+
+A palette **pinned against** your own scheme still wants a second line, for a smaller reason than it used to be: the planes read your card's lightness, so the surface itself lands right either way, but the poles' own defaults, the status hues and native chrome all still read `color-scheme`. Pin it with them (`.my-editor { color-scheme: dark }`). Skip that line and what the browser paints — the selection highlight, the scrollbar, the spinner — stays on whichever scheme the host inherits, and a status hue you left to us is measured against the wrong card.
+
+Pinning **one mount** rather than a page is the `style` prop, which lands on the same root: `<Preview style="color-scheme: dark" />`. There is no `scheme` prop, and deliberately — an inline declaration of ours would be the one thing your own CSS could not beat.
 
 No JS runs and no media query: the derivation resolves through the cascade at paint time, so there is no `dark` prop and no mode toggle. The consumer's palette decides.
 
@@ -121,7 +125,7 @@ import '@quillmark/svelte/preset';
 ```html
 <body class="qm-page">
 	<p class="qm-label">quill</p>
-	<pre class="qm-readout">usaf_memo@0.2.0</pre>
+	<pre class="qm-readout">specimen@1.0.0</pre>
 </body>
 ```
 
@@ -198,4 +202,4 @@ The derived surface scale (surface / border / ink rungs, the blur radius, the po
 
 ## Requirements
 
-`@layer`, `color-mix()` and `light-dark()`: Baseline since 2022, 2023 and 2024 respectively. `@property` is the one feature the surface does not require: where it is missing, an invalid length dial collapses the surface rather than falling back.
+`@layer`, `color-mix()`, `light-dark()` and relative colour syntax (`oklab(from …)`): Baseline since 2022, 2023, 2024 and 2024 respectively — the last is what lets a plane step by the card's own lightness. `@property` is the one feature the surface does not require: where it is missing, an invalid length dial collapses the surface rather than falling back.

package/dist/core/address.d.ts

@@ -63,7 +63,7 @@ export declare function cardPath(index: number, kinds: readonly string[]): DocPa
 /**
  * The inverse: a canonical `DocPath` back to the `Addr` the document verbs take, or
  * `undefined` for a path that names no single commit address — a nested or
- * array-element path (`main.references.0`, which {@link elementAddrForFieldPath}
+ * array-element path (`main.keywords[0]`, which {@link elementAddrForFieldPath}
  * takes instead), a field-rooted one, or a malformed one. A bare card and a `.body`
  * terminal both land on the field-less `{card: i}` the body leaf answers to.
  *
@@ -72,16 +72,10 @@ export declare function cardPath(index: number, kinds: readonly string[]): DocPa
  */
 export declare function addrForFieldPath(path: DocPath): Addr | undefined;
 /**
- * An array element's address, split. `main.references.0` and `main.references[0]`
- * both land here; anything {@link addrForFieldPath} can name, and anything whose
- * trailing segment is not an index, does not.
- *
- * Both spellings, because the boundary mints one and formats the other: `regions()`
- * and `positionAt` emit `main.references.0`, which `parseDocPath` reads as a field
- * literally named `"0"`, while `formatDocPath` spells the index segment
- * `main.references[0]`. A trailing all-digits field name is therefore an index that
- * lost its brackets — but only under a field the schema declares an array, the
- * caller's guard to apply: this module holds the grammar and no schema.
+ * An array element's address, split: `main.keywords[0]` lands here, and anything
+ * {@link addrForFieldPath} can name — or whose trailing segment is not an index —
+ * does not. `regions()`, `positionAt` and `formatDocPath` all spell the index
+ * segment bracketed, so there is one spelling to read and none to bridge.
  */
 export declare function elementAddrForFieldPath(path: DocPath): ElementAddr | undefined;
 /** An array element's address: the array's `Addr`, and which element of it. */

package/dist/core/address.js

@@ -37,7 +37,7 @@ export function cardPath(index, kinds) {
 /**
  * The inverse: a canonical `DocPath` back to the `Addr` the document verbs take, or
  * `undefined` for a path that names no single commit address — a nested or
- * array-element path (`main.references.0`, which {@link elementAddrForFieldPath}
+ * array-element path (`main.keywords[0]`, which {@link elementAddrForFieldPath}
  * takes instead), a field-rooted one, or a malformed one. A bare card and a `.body`
  * terminal both land on the field-less `{card: i}` the body leaf answers to.
  *
@@ -49,32 +49,21 @@ export function addrForFieldPath(path) {
     return segs && addrForSegs(segs);
 }
 /**
- * An array element's address, split. `main.references.0` and `main.references[0]`
- * both land here; anything {@link addrForFieldPath} can name, and anything whose
- * trailing segment is not an index, does not.
- *
- * Both spellings, because the boundary mints one and formats the other: `regions()`
- * and `positionAt` emit `main.references.0`, which `parseDocPath` reads as a field
- * literally named `"0"`, while `formatDocPath` spells the index segment
- * `main.references[0]`. A trailing all-digits field name is therefore an index that
- * lost its brackets — but only under a field the schema declares an array, the
- * caller's guard to apply: this module holds the grammar and no schema.
+ * An array element's address, split: `main.keywords[0]` lands here, and anything
+ * {@link addrForFieldPath} can name — or whose trailing segment is not an index —
+ * does not. `regions()`, `positionAt` and `formatDocPath` all spell the index
+ * segment bracketed, so there is one spelling to read and none to bridge.
  */
 export function elementAddrForFieldPath(path) {
     const segs = segsOf(path);
     if (!segs)
         return undefined;
     const last = segs[segs.length - 1];
-    const index = last?.seg === 'index'
-        ? last.index
-        : last?.seg === 'field' && /^\d+$/.test(last.name)
-            ? Number(last.name)
-            : undefined;
-    if (index == null)
+    if (last?.seg !== 'index')
         return undefined;
     const field = addrForSegs(segs.slice(0, -1));
     // A body has no elements: the parent must name a field.
-    return field?.field != null ? { field, index } : undefined;
+    return field?.field != null ? { field, index: last.index } : undefined;
 }
 /** `parseDocPath`, with a malformed path as `undefined` rather than a throw. The gate
  *  is read outside the try: an uninitialized core is not a malformed path, and would

package/dist/core/codec/inputrules.js

@@ -44,11 +44,10 @@ function markInputRule(regexp, markType, delimLen) {
  * `heading` being wrapped becomes a `paragraph` first.
  *
  * `list_item` is `block+`, so `list_item > heading` is *representable* and a bare
- * wrap mints it (a shape no quill renders): the reference quill derives an item's
- * numbering and indent from the container path and typesets the item's blocks as
- * body paragraphs (`usaf_memo`'s `render-body`), where a heading resolves to
- * nothing. This is the wrap-side route into that shape; the `# ` rule guards the
- * other, in {@link markdownInputRules}.
+ * wrap mints it — a shape markdown has no spelling for, so nothing downstream is
+ * obliged to typeset it and the gesture that made it cannot be read back. This is
+ * the wrap-side route into it; the `# ` rule guards the other, in
+ * {@link markdownInputRules}.
  *
  * `item` is the second guard, and it is about the gesture rather than the shape: the
  * rule declines at the start of an item's own first block ({@link openingAnItem}).

package/dist/core/codec/prose.css

@@ -84,16 +84,17 @@ li.ProseMirror-selectednode::after {
    emits, minus the four the UA already renders correctly (`strong`, `em`, `u`, `s`)
    and the blockquote above.
 
-   Each rule answers to the reference quill rather than to a browser default or to a
+   Each rule answers to the leaf's own job rather than to a browser default or to a
    web editor's chrome, because the leaf sits beside a live preview of the same
-   content. `usaf_memo` sets `raw` in a monospace face and adds nothing; it renders a
-   heading as a bold run-in prepended to the following paragraph, with the level
-   never read; it gives a link no decoration at all. So a leaf shows that a span is
-   code and a line is a heading: never a prediction of the size paper will set it
-   at, which the package cannot know for a quill it has not seen.
+   content. A leaf shows *that* a span is code and a line is a heading: never a
+   prediction of the size paper will set it at, which the package cannot know for a
+   quill it has not seen. The reference quill is the case in point — it sets `raw` in
+   the face it bundles, scales a heading by its level and colours it, and gives a link
+   no decoration at all — and mirroring any of that here would be a guess about the
+   next quill.
 
    Scoping is by tag, and the schema does the rest: `h1`–`h6`, `hr` and the lists
-   cannot exist under the inline schema, so no rule for them can land on a `subject`
+   cannot exist under the inline schema, so no rule for them can land on an inline
    field however that field is mounted. The two marks are the exception: `code` and
    `link` are in both schemas, and a `plaintext` leaf strips them at decode while
    mounting a schema that still carries them, so a paste can put either in one. The

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

@@ -662,7 +662,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

@@ -186,8 +186,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/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, plaintext: false })
 		});
 		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. */

package/dist/visual/structure.js

@@ -57,9 +57,7 @@ export function controlKind(f) {
         case 'enum':
             return 'enum';
         case 'string':
-            // Either spelling of a closed domain (the `enum` modifier or `values`)
-            // promotes a string to a select; a bare string is a text input.
-            return enumValues(f) ? 'enum' : 'text';
+            return 'text';
         case 'number':
         case 'integer':
             return 'number';
@@ -76,10 +74,6 @@ export function controlKind(f) {
             return 'text';
     }
 }
-/** The closed value domain of an enum/enum-string field, or undefined. */
-export function enumValues(f) {
-    return f.enum ?? f.values;
-}
 /** `foo_bar` → `Foo bar`: the label fallback when a field declares no `ui.title`. */
 export function humanize(name) {
     const spaced = name.replace(/_/g, ' ').trim();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.3.2",
+	"version": "0.4.0",
 	"description": "Editor, live-preview and source surfaces over a Quillmark WASM session.",
 	"repository": {
 		"type": "git",
@@ -66,7 +66,7 @@
 		"check": "svelte-check --tsconfig ./tsconfig.json"
 	},
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.103.0-0",
+		"@quillmark/wasm": ">=0.104.0-0",
 		"svelte": "^5.0.0"
 	},
 	"dependencies": {