@quillmark/svelte 0.5.1 → 0.7.0

package/dist/visual/diagnostics.d.ts

@@ -1,9 +1,9 @@
 import type { Diagnostic } from '@quillmark/wasm';
 /** A field's routing address, and `/core`'s `Addr` structurally: an `Addr` is a
- * positional `FieldKey`, so `addrForFieldPath` is the path→key walk and routing
- * carries no second copy of the grammar. `card` is `undefined` for the main card; a
- * composable card slot is a stable session id (the editor's own bookkeeping) once
- * resolved, or an absolute document-array index straight off a parsed `DocPath`
+ * positional `FieldKey`, so `nearestAddrForFieldPath` is the path→key walk and
+ * routing carries no second copy of the grammar. `card` is `undefined` for the main
+ * card; a composable card slot is a stable session id (the editor's own bookkeeping)
+ * once resolved, or an absolute document-array index straight off a parsed `DocPath`
  * (resolve via {@link resolveCardKey} before merging with id-keyed sources). `field`
  * `undefined` addresses the body (the field-less leaf). */
 export interface FieldKey {
@@ -29,13 +29,15 @@ export interface RoutedDiagnostic {
 }
 /**
  * Route a path-keyed producer's raw `Diagnostic[]` (validate / external) to the
- * editor's stable-id keying: the one door producers #1/#3 take, `addrForFieldPath`
- * and `resolveCardKey` in a single pass. Warnings do not draw (VISUAL_EDITOR
- * §Diagnostics): obligation, completeness, a render note — none of them is a value
- * the field cannot hold. An entry also drops rather than mis-routes when it carries
- * no `path`, when the path names no single commit address (a nested / array-element
- * one), or when its absolute card index is out of the live `cardIds`. Completeness
- * stays a read the host makes on `quill.validate(doc)`.
+ * editor's stable-id keying: the one door producers #1/#3 take,
+ * `nearestAddrForFieldPath` and `resolveCardKey` in a single pass. Warnings do not
+ * draw (VISUAL_EDITOR §Diagnostics): obligation, completeness, a render note — none
+ * of them is a value the field cannot hold. An anchor deeper than a commit address
+ * (`main.contact.email`, `main.keywords[0]`) draws at the nearest field holding it,
+ * whose subform or repeater draws that leaf. An entry drops rather than mis-routes
+ * when it carries no `path`, when no prefix of the path is addressable, or when its
+ * absolute card index is out of the live `cardIds`.
+ * Completeness stays a read the host makes on `quill.validate(doc)`.
  */
 export declare function routeAndResolve(diagnostics: Diagnostic[] | undefined, cardIds: readonly string[]): RoutedDiagnostic[];
 /**

package/dist/visual/diagnostics.js

@@ -1,4 +1,4 @@
-import { addrForFieldPath } from '../core/address.js';
+import { nearestAddrForFieldPath } from '../core/address.js';
 /** Canonical string key for a `FieldKey`: the routing `Map`'s key space. */
 export function fieldKeyToString(k) {
     return `${k.card ?? 'main'}:${k.field ?? '$body'}`;
@@ -20,20 +20,22 @@ export function resolveCardKey(key, cardIds) {
 }
 /**
  * Route a path-keyed producer's raw `Diagnostic[]` (validate / external) to the
- * editor's stable-id keying: the one door producers #1/#3 take, `addrForFieldPath`
- * and `resolveCardKey` in a single pass. Warnings do not draw (VISUAL_EDITOR
- * §Diagnostics): obligation, completeness, a render note — none of them is a value
- * the field cannot hold. An entry also drops rather than mis-routes when it carries
- * no `path`, when the path names no single commit address (a nested / array-element
- * one), or when its absolute card index is out of the live `cardIds`. Completeness
- * stays a read the host makes on `quill.validate(doc)`.
+ * editor's stable-id keying: the one door producers #1/#3 take,
+ * `nearestAddrForFieldPath` and `resolveCardKey` in a single pass. Warnings do not
+ * draw (VISUAL_EDITOR §Diagnostics): obligation, completeness, a render note — none
+ * of them is a value the field cannot hold. An anchor deeper than a commit address
+ * (`main.contact.email`, `main.keywords[0]`) draws at the nearest field holding it,
+ * whose subform or repeater draws that leaf. An entry drops rather than mis-routes
+ * when it carries no `path`, when no prefix of the path is addressable, or when its
+ * absolute card index is out of the live `cardIds`.
+ * Completeness stays a read the host makes on `quill.validate(doc)`.
  */
 export function routeAndResolve(diagnostics, cardIds) {
     const out = [];
     for (const d of diagnostics ?? []) {
         if (d.severity !== 'error' || !d.path)
             continue;
-        const key = addrForFieldPath(d.path);
+        const key = nearestAddrForFieldPath(d.path);
         const resolved = key && resolveCardKey(key, cardIds);
         if (resolved)
             out.push({ key: resolved, diagnostic: d });

package/dist/visual/domid.d.ts

@@ -8,6 +8,19 @@ export interface FieldDomIds {
     description: string;
 }
 export declare function fieldDomIds(uid: string, leafKey: string): FieldDomIds;
+/**
+ * A subform property's three names, derived from the field's own control id. A
+ * property is not a field — it has no leaf key, `Addr` reaching a root and one field
+ * and no deeper — so it borrows its parent's id space rather than minting a second:
+ * the same escape, one `-p-` segment down. That is what lets a property's label be a
+ * real `<label for>` like every other label on the surface, instead of a `<span>`
+ * folding its text into the control's composed name.
+ *
+ * The `-p-` infix cannot collide with a sibling field's id: an id is the escaped
+ * `card:field` and `-` only ever introduces an escape, so `-p-` decodes as nothing a
+ * key can spell.
+ */
+export declare function propertyDomIds(controlId: string, key: string): FieldDomIds;
 /**
  * A group panel's own id: what its header's `aria-controls` names, and the only
  * name in the DOM that is a card's rather than a field's. `card` follows the leaf

package/dist/visual/domid.js

@@ -21,6 +21,22 @@ export function fieldDomIds(uid, leafKey) {
     const base = `qm-${uid}-${escapeId(leafKey)}`;
     return { control: base, label: `${base}-label`, description: `${base}-desc` };
 }
+/**
+ * A subform property's three names, derived from the field's own control id. A
+ * property is not a field — it has no leaf key, `Addr` reaching a root and one field
+ * and no deeper — so it borrows its parent's id space rather than minting a second:
+ * the same escape, one `-p-` segment down. That is what lets a property's label be a
+ * real `<label for>` like every other label on the surface, instead of a `<span>`
+ * folding its text into the control's composed name.
+ *
+ * The `-p-` infix cannot collide with a sibling field's id: an id is the escaped
+ * `card:field` and `-` only ever introduces an escape, so `-p-` decodes as nothing a
+ * key can spell.
+ */
+export function propertyDomIds(controlId, key) {
+    const base = `${controlId}-p-${escapeId(key)}`;
+    return { control: base, label: `${base}-label`, description: `${base}-desc` };
+}
 /**
  * A group panel's own id: what its header's `aria-controls` names, and the only
  * name in the DOM that is a card's rather than a field's. `card` follows the leaf

package/dist/visual/hold.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Run `change` and keep `anchor` inside the fold for the length of the move.
+ *
+ * A section closing above the pressed control carries that control off the fold with it,
+ * and what answers that is the trip every landing here already takes: the minimum, to the
+ * nearest edge, never a centring (VISUAL_EDITOR §"Focus and the preview bridge"). So a
+ * control the collapse never carries out of view costs no scroll at all, and one it would
+ * rides up and parks at the edge, which is where a section just opened wants its header:
+ * the fold below it is the room its fields unfold into, where a control held on the line
+ * it was pressed on opens its section into the screen it sits on the edge of.
+ *
+ * Per frame, because both panels move over the motion rung: a trip taken once is taken
+ * against a track that has not moved yet, the same flush a reveal's landing measures in
+ * (`Card.revealLeaf`). `instant`, because a host's `scroll-behavior: smooth` would
+ * otherwise animate each frame's correction toward the one before it.
+ */
+export declare function holdInView(anchor: HTMLElement | undefined, change: () => void): void;

package/dist/visual/hold.js

@@ -0,0 +1,39 @@
+// The gesture's anchor, which scroll anchoring is not: the platform picks its anchor off
+// the layout, and what fills the viewport as a section collapses is that section's own
+// content, whose top never moves.
+import { flushSync } from 'svelte';
+import { rungMs } from './motion.js';
+/**
+ * Run `change` and keep `anchor` inside the fold for the length of the move.
+ *
+ * A section closing above the pressed control carries that control off the fold with it,
+ * and what answers that is the trip every landing here already takes: the minimum, to the
+ * nearest edge, never a centring (VISUAL_EDITOR §"Focus and the preview bridge"). So a
+ * control the collapse never carries out of view costs no scroll at all, and one it would
+ * rides up and parks at the edge, which is where a section just opened wants its header:
+ * the fold below it is the room its fields unfold into, where a control held on the line
+ * it was pressed on opens its section into the screen it sits on the edge of.
+ *
+ * Per frame, because both panels move over the motion rung: a trip taken once is taken
+ * against a track that has not moved yet, the same flush a reveal's landing measures in
+ * (`Card.revealLeaf`). `instant`, because a host's `scroll-behavior: smooth` would
+ * otherwise animate each frame's correction toward the one before it.
+ */
+export function holdInView(anchor, change) {
+    if (!anchor)
+        return void change();
+    change();
+    flushSync();
+    const reveal = () => anchor.scrollIntoView({ block: 'nearest', behavior: 'instant' });
+    reveal();
+    const rung = rungMs(getComputedStyle(anchor), '--_qm-duration-slow');
+    if (rung === undefined)
+        return;
+    const until = performance.now() + rung;
+    const step = (now) => {
+        reveal();
+        if (now < until)
+            requestAnimationFrame(step);
+    };
+    requestAnimationFrame(step);
+}

package/dist/visual/index.js

@@ -13,7 +13,7 @@
 // reaches modules inside `core/` and never its entry, so a sheet hanging off that
 // entry arrives only for a consumer importing `/core` for some other reason. The
 // sheet rather than the entry, because the barrel needs the derivation and not
-// `init`. `check:deps` (rule 4) walks this file's own graph and holds the reach.
+// `init`. `check:deps` holds the reach.
 import '../core/theme.css';
 export { default as VisualEditor } from './VisualEditor.svelte';
 // The prose leaf: the vanilla mount API a non-Svelte consumer (or a custom

package/dist/visual/leaves.d.ts

@@ -10,15 +10,17 @@ import type { FieldController } from '../core/codec/index.js';
 export interface FieldControl {
     focus(): void;
     /**
-     * Focus element `index` of a control that has elements, resolving the index to the
-     * element's session id at the call; {@link focus}'s own answer for an index past
-     * the live list. Absent on every control without elements.
+     * Land in element `index` of a control that has elements, at USV `pos` where the
+     * row's control can take one; resolving the index to the element's session id at
+     * the call, with {@link focus}'s own answer for an index past the live list. Absent
+     * on every control without elements.
      *
-     * The granularity rides the call because the registry stays parent-keyed: a
-     * per-element key is positional, in a registry whose doctrine is dodging
-     * positional churn.
+     * A landing, not a focus: an absent `pos` is the placement rung, exactly as on
+     * `Landing`, and what a `pos` means is the row control's, the same way focusing is.
+     * The place rides the call because the registry stays parent-keyed: a per-element
+     * key is positional, in a registry whose doctrine is dodging positional churn.
      */
-    focusElement?(index: number): void;
+    focusElement?(index: number, pos?: number): void;
     readonly el: HTMLElement;
 }
 /**

package/dist/visual/links.d.ts

@@ -7,8 +7,11 @@ import type { Command, EditorState } from 'prosemirror-state';
  * userinfo — a wrong destination this normalization would itself have minted.
  *
  * A rooted value is left alone, being the spelling that asks for the embedding
- * page, and so is anything already carrying a scheme. `''` for a blank value, which
- * is nothing to apply.
+ * page, and so is anything already carrying a scheme the link mark renders.
+ *
+ * `''` for a blank value and for a scheme the mark renders inert, both being nothing
+ * to apply: `setLink` declines an empty href, so the refusal lands at the prompt's
+ * own exit rather than storing a link that draws as plain text.
  */
 export declare function normalizeHref(raw: string): string;
 /**

package/dist/visual/links.js

@@ -1,3 +1,4 @@
+import { rendersHref } from '../core/codec/index.js';
 /** A scheme: a letter, then letters, digits, `+`, `-` or `.`, then `:` (RFC 3986). */
 const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
 /** Rooted at the page rather than at a host: an absolute path, a query, a fragment,
@@ -13,12 +14,17 @@ const ADDRESS = /^[^\s/@]+@[^\s/@]+$/;
  * userinfo — a wrong destination this normalization would itself have minted.
  *
  * A rooted value is left alone, being the spelling that asks for the embedding
- * page, and so is anything already carrying a scheme. `''` for a blank value, which
- * is nothing to apply.
+ * page, and so is anything already carrying a scheme the link mark renders.
+ *
+ * `''` for a blank value and for a scheme the mark renders inert, both being nothing
+ * to apply: `setLink` declines an empty href, so the refusal lands at the prompt's
+ * own exit rather than storing a link that draws as plain text.
  */
 export function normalizeHref(raw) {
     const value = raw.trim();
-    if (!value || SCHEME.test(value) || ROOTED.test(value))
+    if (!value || !rendersHref(value))
+        return '';
+    if (SCHEME.test(value) || ROOTED.test(value))
         return value;
     return ADDRESS.test(value) ? `mailto:${value}` : `https://${value}`;
 }

package/dist/visual/motion.d.ts

@@ -1,4 +1,13 @@
 import type { AnimationConfig } from 'svelte/animate';
+/** The trips this module is running on `node`. A run holds the slot at its pre-move
+ *  position for its whole length, so anything that measures the node's box waits on
+ *  these rather than reading the one a transform is holding. */
+export declare function reorderTrips(node: HTMLElement): Animation[];
+/** A duration rung off `style`, in ms; `undefined` where the derivation is out of reach
+ *  (an unstyled root, or jsdom, where `getComputedStyle` reports custom properties as
+ *  empty). No rung, no motion: a fallback here would be the scale restated in the one
+ *  place `check:style` cannot read. */
+export declare function rungMs(style: CSSStyleDeclaration, rung: string): number | undefined;
 /**
  * Slide a keyed slot from where it was to where it now is.
  *

package/dist/visual/motion.js

@@ -7,11 +7,19 @@
 /** Marks this module's runs, so a second reorder cancels the first rather than layering
  *  a second transform over it. */
 const RUN_ID = 'qm-reorder';
+/** The trips this module is running on `node`. A run holds the slot at its pre-move
+ *  position for its whole length, so anything that measures the node's box waits on
+ *  these rather than reading the one a transform is holding. */
+export function reorderTrips(node) {
+    if (typeof node.getAnimations !== 'function')
+        return [];
+    return node.getAnimations().filter((run) => run.id === RUN_ID);
+}
 /** A duration rung off `style`, in ms; `undefined` where the derivation is out of reach
  *  (an unstyled root, or jsdom, where `getComputedStyle` reports custom properties as
  *  empty). No rung, no motion: a fallback here would be the scale restated in the one
  *  place `check:style` cannot read. */
-function rungMs(style, rung) {
+export function rungMs(style, rung) {
     const raw = style.getPropertyValue(rung).trim();
     const n = Number.parseFloat(raw);
     if (!Number.isFinite(n))
@@ -34,7 +42,7 @@ function rungMs(style, rung) {
 export function reorder(node, { from, to }, armed) {
     // The returned config is empty by design, in both exits and the run below: Svelte
     // samples a config's keyframes through a JS easing function, and this curve is a
-    // rung the derivation mints and `check:style` holds.
+    // rung the derivation mints.
     if (!armed() || typeof node.animate !== 'function')
         return {};
     const style = getComputedStyle(node);

package/dist/visual/strings.d.ts

@@ -21,6 +21,21 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     addCard: string;
     arrayAdd: string;
     arrayRemove: string;
+    /** The tag on the unset sentinel's row, which is what tells it from the member it
+     *  ghosts ({@link EnumField}). */
+    enumUnsetTag: string;
+    /**
+     * What stands where a subform declines to recurse (a nested prose / array /
+     * object property), and where to edit that property instead. The whole sentence,
+     * since a translator orders the kind within it.
+     */
+    nestedUnsupported: (kind: string) => string;
+    /**
+     * A collapsed array element whose first text property is empty: the label and the
+     * 1-based index, which is what its accessible name already says. Parametric, so
+     * word order stays the translator's.
+     */
+    elementUntitled: (label: string, index: number) => string;
     /** The required marker's accessible name; the glyph itself is a `*`. */
     fieldRequired: string;
     formatGroup: string;

package/dist/visual/strings.js

@@ -30,6 +30,9 @@ export const DEFAULT_VISUAL_STRINGS = {
     addCard: '+ Add Card',
     arrayAdd: '+ Add',
     arrayRemove: 'Remove',
+    enumUnsetTag: 'default',
+    nestedUnsupported: (kind) => `A nested ${kind} — edit this field in the source view.`,
+    elementUntitled: (label, index) => `${label} ${index}`,
     fieldRequired: 'required',
     formatGroup: 'Formatting',
     formatBold: 'Bold (Mod-B)',

package/dist/visual/structure.d.ts

@@ -1,6 +1,6 @@
 import type { QuillCardSchema, QuillFieldSchema, ResolvedField, Resolved } from '@quillmark/wasm';
 /** The control a field type maps to (VISUAL_EDITOR §"Structure mirrors the schema"). */
-export type ControlKind = 'prose' | 'text' | 'enum' | 'number' | 'boolean' | 'date' | 'array' | 'object';
+export type ControlKind = 'prose' | 'text' | 'enum' | 'variant' | 'number' | 'boolean' | 'date' | 'array' | 'object';
 /** One field, projected: its schema, the control it renders as, and its layout hints. */
 export interface FieldModel {
     name: string;
@@ -17,11 +17,10 @@ export interface FieldModel {
      * undefined when the field declares none. Chrome-only; never gates. */
     description: string | undefined;
     /**
-     * Required-ness: the schema's `must_fill` obligation, which derives from
-     * `default:`'s absence when the field declares none (DOCUMENT_MODEL). Drives a
-     * persistent label `*`; a field can carry both it and a ghosted `default:`,
-     * since the two axes are independent. Persistent (schema-derived, survives
-     * filling). Label chrome only; never gates.
+     * 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). */
@@ -149,6 +148,33 @@ 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 discriminant cell of a variant container (`VARIANT_DISCRIMINANT_KEY` upstream,
+ *  which the boundary does not export). Reserved: no variant may declare it. */
+export declare const VARIANT_DISCRIMINANT = "value";
+/**
+ * Which world's cells to draw: the authored discriminant when the container carries
+ * one, else the ghosted default's member — an unset field renders its `default:`, so a
+ * defaulted world whose cells were hidden would print answers the form never asked
+ * for. The blank owns no world, and neither does a member declaring no cells.
+ */
+export declare function variantMember(value: Record<string, unknown> | undefined, ghostMember: string | undefined): string | undefined;
+/** The cells a member declares, or `undefined` where that world has none. */
+export declare function variantCells(schema: QuillFieldSchema, member: string | undefined): Record<string, QuillFieldSchema> | undefined;
+/**
+ * The container a discriminant pick commits, and the discriminant cell alone the unset
+ * sentinel clears: sibling cells are **kept** either way, since the boundary carries an
+ * answer its world does not select rather than dropping it (VISUAL_EDITOR §"Enum
+ * variants"). A container left holding nothing is an unset field, which commits
+ * `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). A typed dictionary is exempt — a namespace declares no
+ * `default:` at all, and `validate` anchors obligation on the leaves under it, so
+ * reading one off the container would mark every subform required.
+ */
+export declare function obliged(schema: QuillFieldSchema): boolean;
 /** `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

@@ -55,7 +55,9 @@ export function controlKind(f) {
         case 'plaintext':
             return 'prose';
         case 'enum':
-            return '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':
@@ -74,6 +76,46 @@ export function controlKind(f) {
             return 'text';
     }
 }
+/** The discriminant cell of a variant container (`VARIANT_DISCRIMINANT_KEY` upstream,
+ *  which the boundary does not export). Reserved: no variant may declare it. */
+export const VARIANT_DISCRIMINANT = 'value';
+/**
+ * Which world's cells to draw: the authored discriminant when the container carries
+ * one, else the ghosted default's member — an unset field renders its `default:`, so a
+ * defaulted world whose cells were hidden would print answers the form never asked
+ * for. The blank owns no world, and neither does a member declaring no cells.
+ */
+export function variantMember(value, ghostMember) {
+    const authored = value?.[VARIANT_DISCRIMINANT];
+    return (typeof authored === 'string' ? authored : ghostMember) || undefined;
+}
+/** The cells a member declares, or `undefined` where that world has none. */
+export function variantCells(schema, member) {
+    return member ? schema.variants?.[member] : undefined;
+}
+/**
+ * The container a discriminant pick commits, and the discriminant cell alone the unset
+ * sentinel clears: sibling cells are **kept** either way, since the boundary carries an
+ * answer its world does not select rather than dropping it (VISUAL_EDITOR §"Enum
+ * variants"). A container left holding nothing is an unset field, which commits
+ * `undefined`.
+ */
+export function commitDiscriminant(value, member) {
+    const next = { ...(value ?? {}) };
+    if (member !== undefined)
+        return { ...next, [VARIANT_DISCRIMINANT]: 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). A typed dictionary is exempt — a namespace declares no
+ * `default:` at all, and `validate` anchors obligation on the leaves under it, so
+ * reading one off the container would mark every subform required.
+ */
+export function obliged(schema) {
+    return schema.type !== 'object' && schema.default === undefined;
+}
 /** `foo_bar` → `Foo bar`: the label fallback when a field declares no `ui.title`. */
 export function humanize(name) {
     const spaced = name.replace(/_/g, ' ').trim();
@@ -89,7 +131,7 @@ export function fieldModels(cardSchema) {
         compact: !!schema.ui?.compact,
         label: schema.ui?.title ?? humanize(name),
         description: schema.description,
-        required: schema.must_fill ?? schema.default === undefined,
+        required: obliged(schema),
         inline: !!schema.inline,
         plaintext: schema.type === 'plaintext'
     }));
@@ -174,6 +216,10 @@ export function initialExpandedGroup(sections) {
  * 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.
  *
+ * 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
+ * packed neighbour would reflow every time the discriminant moves.
+ *
  * An array declines whatever its items are: one-line elements make a one-line step,
  * but nothing holds two arrays to the same number of them, so the shorter of a packed
  * pair pays a cell of whitespace for every element the taller one has past it, and
@@ -182,7 +228,7 @@ export function initialExpandedGroup(sections) {
 function packable(f) {
     if (!f.compact)
         return false;
-    if (f.control === 'object' || f.control === 'array')
+    if (f.control === 'object' || f.control === 'array' || f.control === 'variant')
         return false;
     return f.control !== 'prose' || f.inline;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.5.1",
+	"version": "0.7.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.105.0-0",
+		"@quillmark/wasm": ">=0.108.0-0",
 		"svelte": "^5.0.0"
 	},
 	"dependencies": {

package/dist/core/codec/clipboard.d.ts

@@ -1,59 +0,0 @@
-import { DOMParser as PMDOMParser, Slice } from 'prosemirror-model';
-import type { Node as PMNode, Schema } from 'prosemirror-model';
-import { Plugin } from 'prosemirror-state';
-import type { TableCell, TableProps } from '@quillmark/wasm';
-import { type TableAlign } from './table.js';
-/** What a clipboard event hands over, which is all either arm needs of it: jsdom has no
- *  `DataTransfer`, and the suite drives these paths with the two methods themselves. */
-interface Clipboard {
-    getData: (type: string) => string;
-    setData: (type: string, data: string) => void;
-}
-/**
- * A `<table>` element as props. `rowspan` is not carried — a merged cell is not a
- * rectangle, so a table with one arrives with the rows below it short and
- * {@link normalizeTable} pads them at the end. `colspan` is, as the empty cells it
- * covers, so the columns after it keep their index.
- *
- * Only the table's own rows: a `<tr>` inside a nested table belongs to a cell this
- * reader is about to flatten, not to a rank of this one.
- */
-export declare function tableFromDOM(dom: Element): TableProps;
-/** The table a paste is carrying, or `undefined` for a paste that holds none. The first
- *  one: a clipboard holding a table among other blocks is a document paste, and only a
- *  surface that takes nothing but a table (a cell) reads it this way. */
-export declare function tableFromClipboard(data: Clipboard | null | undefined): TableProps | undefined;
-/**
- * A rectangle as a `<table>`: the wire the HTML arm writes and reads. Its first row is
- * a `<th>` row whatever row of the source it came from, that being the row index 0 a
- * paste lands it at.
- */
-export declare function tableToDOM(block: TableCell[][], aligns: TableAlign[], owner: Document): Element;
-/**
- * A rectangle as pipe rows, delimiter row included: what a plain-text target reads as a
- * table and what markdown carries. The delimiter follows the first row for the reason
- * that row serializes as `<th>` — a pasted rectangle's row 0 is a header.
- */
-export declare function tableToPipe(block: TableCell[][], aligns: TableAlign[]): string;
-/** Put a rectangle on the clipboard, both arms. The caller is a `copy` / `cut` handler
- *  over a selection its own surface holds, so the rectangle arrives already cut out and
- *  claiming the event is the caller's. */
-export declare function writeRectangle(data: Clipboard, block: TableCell[][], aligns: TableAlign[], owner: Document): void;
-/** The clipboard's parser: the schema's own rules with the table rule ahead of them.
- *  Ahead, because a `<table>` otherwise matches nothing and its cells' text falls
- *  through to the enclosing block. */
-export declare function tableClipboardParser(schema: Schema): PMDOMParser;
-/** Mint an id for every island a paste is carrying. An id is part of the document's
- *  canonical bytes and the channel that addresses an island (CODEC §Islands), so a
- *  pasted island with none reaches the store as an insert nothing can name afterwards.
- *  One minter for the whole slice, or a paste placing two tables hands them one id. */
-export declare function stampIslandIds(slice: Slice, doc: PMNode): Slice;
-/**
- * The block leaf's clipboard plugin: the table rule on the way in, and the id mint over
- * what it produced. A `clipboardParser` rather than the schema's own `parseDOM`,
- * because what a `<table>` in the DOM means is a question only the clipboard asks — the
- * schema's parse rules are also what a re-parse of the editor's own DOM runs through,
- * where an island is already a node and a `<table>` is the chrome drawing one.
- */
-export declare function tableClipboardPlugin(schema: Schema): Plugin;
-export {};