@quillmark/svelte 0.20.1 → 0.22.0

package/dist/visual/motion.js

@@ -1,9 +1,9 @@
-// The card stack's reorder trip: a slot's position ↔ position in a
-// keyed list, the one row of the mechanism table no CSS rule can serve, because the
-// two frames belong to different elements. Svelte's `animate:` supplies the halves CSS
-// cannot see (the rects either side of the reconciliation) and WAAPI paints the trip,
-// the same seam `core/bloom.ts` takes to keep a duration in the derivation while a
-// script runs the animation.
+// The card stack's trips: a slot's position ↔ position in a keyed list, the one row of
+// the mechanism table no CSS rule can serve, because the two frames belong to different
+// elements, and a slot entering or leaving the list. Svelte's `animate:` and `in:`/`out:`
+// supply the halves CSS cannot see (the rects either side of the reconciliation, a node
+// the list no longer holds) and WAAPI paints the trip, the same seam `core/bloom.ts` takes
+// to keep a duration in the derivation while a script runs the animation.
 import { rungMs, rungStyle } from '../core/rungs.js';
 /** Marks this module's runs, so a second reorder cancels the first rather than layering
  *  a second transform over it. */
@@ -34,9 +34,11 @@ export function reorderArm() {
  * `armed` is why this is the reorder and not every reconcile: `animate:` fires wherever
  * a slot's rect moved, and a card growing under the caret moves every slot below it,
  * which is a layout change with no trip in it and one that would draw those slots over
- * the content that displaced them for the length of the run. So the reorder command
- * arms the gesture and the frame it lands in disarms it, which is the admission test
- * read off the endpoints: two positions in the list, not two positions on the page.
+ * the content that displaced them for the length of the run. So a command that moves
+ * slots in the list arms the gesture and the frame it lands in disarms it, which is the
+ * admission test read off the endpoints: two positions in the list, not two positions on
+ * the page. A move is one; so, in the card stack, are an insert and a removal, which move
+ * every slot past them by one.
  *
  * Both endpoints are rest states, so the curve is `--_qm-ease-reverse` (a second click
  * lands mid-slide) and the rung is `slow` (the trip moves the stack around it).
@@ -61,3 +63,50 @@ export function reorder(node, { from, to }, armed) {
     ], { duration, easing, id: RUN_ID });
     return {};
 }
+/**
+ * A slot entering or leaving the list fades where it stands, while the slots it displaces
+ * take the reorder trip: the stack is what slides, and a card is what appears or goes, under
+ * the slots crossing it. Opacity alone, because a leaving slot is held at its place by a
+ * transform `animate:` writes, which a keyframed transform would override.
+ *
+ * The returned duration is what keeps a leaving slot mounted until its fade has run, and
+ * the fill what keeps it from painting whole in the frame between the two.
+ */
+export function slot(node, _params, { direction }) {
+    if (typeof node.animate !== 'function')
+        return {};
+    const style = rungStyle(node);
+    const duration = rungMs(style, '--_qm-duration-slow');
+    const easing = style.getPropertyValue('--_qm-ease-reverse').trim();
+    if (duration === undefined || !easing)
+        return {};
+    const opacity = direction === 'out' ? [1, 0] : [0, 1];
+    node.animate({ opacity }, { duration, easing, fill: direction === 'out' ? 'forwards' : 'none' });
+    return { duration };
+}
+/** Frames nothing may scroll in before a scroll counts as over. More than one, because a
+ *  smooth scroll asked for in this frame takes its first step in a later one. */
+const STILL_FRAMES = 3;
+/** The wait's ceiling, in frames: a scroller a host keeps moving is not a trip that ends. */
+const MAX_FRAMES = 60;
+/**
+ * Resolves once nothing in the document has scrolled for {@link STILL_FRAMES} frames
+ * running. A smooth scroll moves its scroller on every frame until it lands, so stillness
+ * is its end on every engine, whether or not it reports one; a scroll with nowhere to go
+ * is still from the first frame.
+ */
+export function scrollSettled() {
+    return new Promise((resolve) => {
+        let still = 0;
+        let frames = 0;
+        const moved = () => void (still = 0);
+        document.addEventListener('scroll', moved, { capture: true, passive: true });
+        const frame = () => {
+            if (++still < STILL_FRAMES && ++frames < MAX_FRAMES)
+                return void requestAnimationFrame(frame);
+            document.removeEventListener('scroll', moved, { capture: true });
+            resolve();
+        };
+        requestAnimationFrame(frame);
+    });
+}

package/dist/visual/strings.d.ts

@@ -15,15 +15,14 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     /** The card-title input's accessible name. */
     cardTitle: string;
     /** The trailing strip's visible words, which are also every strip's accessible
-     * name; the plus rides the wording. One string over
+     * name. One string over
      * one kind and many: the trigger seeds a card, and which kind is the menu's word
      * to say or the schema's to have already settled. */
     addCard: string;
     arrayAdd: string;
     arrayRemove: string;
-    /** The reorder pair on an `object` row, accessible names: the buttons are glyphs. */
-    arrayMoveUp: string;
-    arrayMoveDown: string;
+    /** The drag handle on an `object` row: its tooltip. */
+    arrayDrag: string;
     /**
      * A row control's accessible name, the action and the row it acts on: `Remove
      * Authors 2`. The action alone stays the tooltip. Parametric, so word order stays
@@ -42,9 +41,11 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
      * word order stays the translator's.
      */
     elementUntitled: (label: string, index: number) => string;
-    /** The tag on the unset sentinel's row, which is what tells it from the member it
-     *  ghosts ({@link EnumField}). */
+    /** The tag on the unset sentinel's row where it ghosts a member, which is what tells
+     *  it from that member ({@link EnumField}). */
     enumUnsetTag: string;
+    /** The same row's tag where it ghosts no member: no `default:`, or a blank one. */
+    enumUnsetTagNone: string;
     /** The count in the matrix's label row: how many of its items are held. */
     matrixHeld: (held: number, total: number) => string;
     /** An open matrix's add box at rest, naming the list it adds to: `Add to Staff…`. The box
@@ -58,8 +59,6 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     /** The date field's toggle, pressed while the field holds `today`: the render
      *  date rather than a written one. */
     dateToday: string;
-    /** The required marker's accessible name; the glyph itself is a `*`. */
-    fieldRequired: string;
     /** What an unset optional cell (`t?`) ghosts at rest: the `none` it prints
      *  unanswered, in the product's words. */
     optionalGhost: string;
@@ -74,7 +73,8 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     formatStrikethrough: string;
     formatCode: string;
     formatLink: string;
-    /** The anchor button's accessible name. */
+    /** The anchor button's accessible name. The popover withholds the button, so
+     *  nothing draws this or the title below. */
     formatAnchor: string;
     /** Its hover title, which says what an anchor is; the name above only says what. */
     formatAnchorTitle: string;
@@ -137,6 +137,12 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
  * diagnostic.
  */
 export type FormatDiagnostic = (d: Diagnostic) => string | undefined;
+/**
+ * A `Mod` chord as the writer's platform prints it: `⌘B` on Apple's, `Ctrl+B`
+ * elsewhere. The platform test is the one `prosemirror-keymap` resolves `Mod` by, so a
+ * tooltip names the chord the keymap binds.
+ */
+export declare function chord(key: string, platform?: string): string;
 /** The package's English. Every key, so the merge below is total. */
 export declare const DEFAULT_VISUAL_STRINGS: VisualStrings;
 /** A consumer's wording: any subset, the rest the package's. */

package/dist/visual/strings.js

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

package/dist/visual/structure.d.ts

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

package/dist/visual/structure.js

@@ -84,6 +84,15 @@ export function optionalCell(f) {
 export function baseType(f) {
     return (optionalCell(f) ? f.type.slice(0, -1) : f.type);
 }
+/** Whether a content field is one line: one paragraph, no container, no island. A `text`
+ *  or `richtext` field is one line unless it declares `multiline: true`. */
+export function oneLine(f) {
+    return f.multiline !== true;
+}
+/** Whether a content field's codec is the literal one, its value text with no marks: `text`. */
+export function literalText(f) {
+    return baseType(f) === 'text';
+}
 /**
  * A scalar `default:` as the text an unset control holds, where it prints: as
  * declared, `undefined` for none, a blank or a non-scalar. A default of spaces prints
@@ -95,7 +104,7 @@ export function printedText(v) {
 }
 /**
  * A declared content literal as the `Content` it holds: a `richtext` one's markdown
- * imported, a `plaintext` one's text taken literally, one paragraph whose later lines
+ * imported, a `text` one's text taken literally, one paragraph whose later lines
  * continue it, as the literal codec reads a stored one. What a cell's static
  * `default:` stands in its leaf as, where no resolved row reaches it. `undefined` for
  * a blank or a non-scalar.
@@ -118,25 +127,23 @@ export function declaredContent(v, markdown) {
     };
 }
 /** A field's `{#each}` key: its name and what a mounted leaf reads once, its type and
- *  `inline` and its elements'. A retype or a quill swap that changes any of them under a
- *  name remounts the field, where a kept leaf would commit on the old schema. */
+ *  {@link oneLine} and its elements'. A retype or a quill swap that changes any of them
+ *  under a name remounts the field, where a kept leaf would commit on the old schema. */
 export function mountKey(name, f) {
-    return `${name}\u0000${f.type}\u0000${f.inline === true}\u0000${f.items?.type ?? ''}\u0000${f.items?.inline === true}`;
+    const items = f.items;
+    return `${name}\u0000${f.type}\u0000${oneLine(f)}\u0000${items?.type ?? ''}\u0000${items ? oneLine(items) : ''}`;
 }
-/** Map a field schema to its control (precedence: prose › enum › text › …).
- * An array's element control is this over `items`: a missing `items` is a text
- * element. */
+/** Map a field schema to its control. An array's element control is this over `items`;
+ *  a type this build does not know takes the text input. */
 export function controlKind(f) {
     switch (baseType(f)) {
         case 'richtext':
-        case 'plaintext':
+        case 'text':
             return 'prose';
         case 'enum':
             // `variants:` is the one key that changes a field's resting shape (canon
             // `SCHEMAS.md`): with it the field rests as a container, without it a bare string.
             return f.variants ? 'variant' : 'enum';
-        case 'string':
-            return 'text';
         case 'number':
         case 'integer':
             return 'number';
@@ -300,13 +307,13 @@ export function addedId(title, taken) {
     return `${base}_${n}`;
 }
 /** The `object` a matrix member is, for the schema walk: the declared columns, and an
- *  added item's `title` beside them. Composed here because the boundary serializes the
- *  roster and the columns alone. */
+ *  added item's `title`, a one-line `text` cell, beside them. Composed here because the
+ *  boundary serializes the roster and the columns alone. */
 export function matrixMemberSchema(matrix, id) {
     const columns = matrix.properties ?? {};
     return {
         type: 'object',
-        properties: onRoster(matrix, id) ? columns : { [MATRIX_TITLE]: { type: 'string' }, ...columns }
+        properties: onRoster(matrix, id) ? columns : { [MATRIX_TITLE]: { type: 'text' }, ...columns }
     };
 }
 // ── The schema walk ──────────────────────────────────────────────────────────
@@ -330,7 +337,7 @@ export function schemaAt(field, steps) {
 /** What an array declaring no `items` holds, the walk's copy of the element control
  *  {@link controlKind} names for one: a text element, so an index into such an array is
  *  a place and not a refusal. */
-const UNDECLARED_ELEMENT = { type: 'string' };
+const UNDECLARED_ELEMENT = { type: 'text' };
 function stepInto(schema, step) {
     switch (controlKind(schema)) {
         case 'array':
@@ -361,17 +368,16 @@ function stepInto(schema, step) {
 }
 // ── Row summaries and layouts ────────────────────────────────────────────────
 /** Whether a cell is one line tall by declaration: the shape a table column and a row
- *  summary can hold. A prose cell is one where it declares `inline`, `richtext` or
- *  `plaintext` alike. */
+ *  summary can hold. A prose cell is one where it is {@link oneLine}. */
 export function shortCell(sub) {
     const kind = controlKind(sub);
     if (kind === 'prose')
-        return !!sub.inline;
+        return oneLine(sub);
     return (kind === 'text' || kind === 'enum' || kind === 'number' || kind === 'boolean' || kind === 'date');
 }
 /**
- * The first short text cell's words — the first `string`, or inline `richtext` /
- * `plaintext`, in declaration order — read through {@link titleText}; `undefined` where
+ * The first short text cell's words — the first one-line `text` or `richtext`, in
+ * declaration order — read through {@link titleText}; `undefined` where
  * there is no such cell or it is empty. The cell is picked by the schema alone, so an
  * instance is named by one cell whatever the others hold. What names an instance from
  * its own values: a collapsed row, and a card whose kind declares no `title`.
@@ -435,39 +441,36 @@ export function commitDiscriminant(value, member) {
     delete next[VARIANT_DISCRIMINANT];
     return Object.keys(next).length ? next : undefined;
 }
-/**
- * Whether the schema obliges a cell: `default:`'s absence, which is the whole of the
- * obligation (DOCUMENT_MODEL). Exempt are the cells whose absence of one says nothing:
- * a typed dictionary, since a namespace declares no `default:` at all and `validate`
- * anchors obligation on the leaves under it; a matrix, whose blank is nothing held, a
- * whole answer; and an optional cell, which can declare none, its unanswered render
- * being `none`.
- */
-export function obliged(schema) {
-    return (schema.type !== 'object' &&
-        schema.type !== 'matrix' &&
-        !optionalCell(schema) &&
-        schema.default === undefined);
-}
 /** `foo_bar` → `Foo bar`: the label fallback when a field declares no `title`. */
 export function humanize(name) {
     const spaced = name.replace(/_/g, ' ').trim();
     return spaced ? spaced[0].toUpperCase() + spaced.slice(1) : spaced;
 }
-/** Project a card schema's `fields` map (declaration = key order) into models. */
+/**
+ * Whether a field asks to share a row when its `ui.compact` is undeclared: a control
+ * whose type bounds its width. Text never does, its type saying nothing of whether a
+ * value is a rank or a subject line, so a short text field asks with `compact: true`.
+ */
+function packsByDefault(control) {
+    return control === 'date' || control === 'enum' || control === 'number' || control === 'boolean';
+}
+/** Project a card schema's `fields` map (declaration = key order) into models. A
+ *  card-level object's `properties` project the same way. */
 export function fieldModels(cardSchema) {
-    return Object.entries(cardSchema.fields).map(([name, schema]) => ({
-        name,
-        schema,
-        control: controlKind(schema),
-        group: schema.ui?.group,
-        compact: !!schema.ui?.compact,
-        label: schema.title ?? humanize(name),
-        description: schema.description,
-        required: obliged(schema),
-        inline: !!schema.inline,
-        plaintext: baseType(schema) === 'plaintext'
-    }));
+    return Object.entries(cardSchema.fields).map(([name, schema]) => {
+        const control = controlKind(schema);
+        return {
+            name,
+            schema,
+            control,
+            group: schema.ui?.group,
+            compact: schema.ui?.compact ?? packsByDefault(control),
+            label: schema.title ?? humanize(name),
+            description: schema.description,
+            inline: oneLine(schema),
+            plaintext: literalText(schema)
+        };
+    });
 }
 /**
  * Group-section order (VISUAL_EDITOR §"Structure mirrors the schema"): the schema's `ui.groups` registry
@@ -543,12 +546,12 @@ export function initialExpandedGroup(sections) {
     return sections.find((s) => s.group != null)?.group ?? null;
 }
 /**
- * Whether a field can share a row. `ui.compact` asks; a shape declines when the
+ * Whether a field can share a row. `compact` asks; a shape declines when the
  * document sets its height, because a row is as tall as its tallest cell and the cell
- * beside it does not grow in step: an object nests a whole field set, block richtext
- * (`inline` absent) holds paragraphs, and an array holds however many elements the
- * document carries. Any of them stands its neighbour in a column of whitespace. An
- * inline prose leaf is one line tall and packs like any scalar.
+ * beside it does not grow in step: an object nests a whole field set, a multiline prose
+ * leaf holds paragraphs or lines, and an array holds however many elements the
+ * document carries. Any of them stands its neighbour in a column of whitespace. A
+ * one-line prose leaf packs like any scalar.
  *
  * A variant declines for the same reason one step further in: its height is the live
  * world's cell count, so it is set by a pick rather than only by the document, and a

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.20.1",
+	"version": "0.22.0",
 	"description": "Editor, live-preview and source surfaces over a Quillmark WASM session.",
 	"repository": {
 		"type": "git",
@@ -23,7 +23,7 @@
 	"author": "Quillmark Contributors",
 	"type": "module",
 	"engines": {
-		"node": ">=24"
+		"node": ">=22"
 	},
 	"svelte": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -69,7 +69,7 @@
 		"check": "svelte-check --tsconfig ./tsconfig.json --fail-on-warnings"
 	},
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.124.0-0",
+		"@quillmark/wasm": ">=0.126.0-0",
 		"svelte": "^5.33.0"
 	},
 	"dependencies": {