@quillmark/svelte 0.11.0 → 0.12.0

package/dist/core/address.d.ts

@@ -1,4 +1,4 @@
-import type { Addr, HitGranularity } from '@quillmark/wasm';
+import type { Addr, HitGranularity, PathStep } from '@quillmark/wasm';
 /**
  * A canonical field address: `main.<field>` / `main.body` /
  * `cards.<kind>[<i>].<field>`, cards keyed by absolute document index.
@@ -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.keywords[0]`, which {@link elementAddrForFieldPath} and
+ * array-element path (`main.keywords[0]`, which {@link nestedAddrForFieldPath} and
  * {@link nearestAddrForFieldPath} take 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.
@@ -86,14 +86,21 @@ export declare function addrForFieldPath(path: DocPath): Addr | undefined;
  */
 export declare function nearestAddrForFieldPath(path: DocPath): Addr | undefined;
 /**
- * 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.
+ * A nested address, split: the field's `Addr`, and the steps from it to the leaf.
+ * `main.keywords[0]` is `{field: keywords, steps: [0]}`,
+ * `main.vectors[0].tours[2].title` is `[0, 'tours', 2, 'title']`, and
+ * `main.contact.email` is `['email']`: an index segment reads as a number and a key as
+ * a string, the `PathStep` grammar `reader.getContentAt` walks. Anything
+ * {@link addrForFieldPath} can name — a field, a body, a card — has no steps and lands
+ * here as `undefined`; so does a body with something after it, a body holding no
+ * cells. Whether the schema declares each step is the caller's to check: this module
+ * holds the grammar and no schema. `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. */
-export interface ElementAddr {
+export declare function nestedAddrForFieldPath(path: DocPath): NestedAddr | undefined;
+/** A nested address: the field's `Addr`, and the steps from it to the leaf. */
+export interface NestedAddr {
     field: Addr;
-    index: number;
+    steps: PathStep[];
 }

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.keywords[0]`, which {@link elementAddrForFieldPath} and
+ * array-element path (`main.keywords[0]`, which {@link nestedAddrForFieldPath} and
  * {@link nearestAddrForFieldPath} take 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.
@@ -66,21 +66,35 @@ export function nearestAddrForFieldPath(path) {
     return segs && addrForSegs(segs.slice(0, 2));
 }
 /**
- * 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.
+ * A nested address, split: the field's `Addr`, and the steps from it to the leaf.
+ * `main.keywords[0]` is `{field: keywords, steps: [0]}`,
+ * `main.vectors[0].tours[2].title` is `[0, 'tours', 2, 'title']`, and
+ * `main.contact.email` is `['email']`: an index segment reads as a number and a key as
+ * a string, the `PathStep` grammar `reader.getContentAt` walks. Anything
+ * {@link addrForFieldPath} can name — a field, a body, a card — has no steps and lands
+ * here as `undefined`; so does a body with something after it, a body holding no
+ * cells. Whether the schema declares each step is the caller's to check: this module
+ * holds the grammar and no schema. `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) {
+export function nestedAddrForFieldPath(path) {
     const segs = segsOf(path);
-    if (!segs)
+    if (!segs || segs.length < 3)
         return undefined;
-    const last = segs[segs.length - 1];
-    if (last?.seg !== 'index')
+    const field = addrForSegs(segs.slice(0, 2));
+    if (field?.field == null)
         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: last.index } : undefined;
+    const steps = [];
+    for (const seg of segs.slice(2)) {
+        if (seg.seg === 'index')
+            steps.push(seg.index);
+        else if (seg.seg === 'field')
+            steps.push(seg.name);
+        else
+            return undefined;
+    }
+    return { field, steps };
 }
 /** `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/bloom.js

@@ -6,6 +6,7 @@
 // fixed by `--_qm-accent-wash`, so interpolating 0→1→0 keeps the scale in CSS where
 // `color-mix` resolves, instead of in keyframe values a script would have to
 // pre-resolve and re-resolve on a theme change.
+import { rungStyle } from './rungs.js';
 const BLOOM_CLASS = 'qm-bloom';
 const WASH = 'var(--_qm-accent-wash)';
 /** The dwell used when the derivation is out of reach (an unstyled root, or jsdom,
@@ -24,8 +25,8 @@ const FRAMES = [
 ];
 const FRAMES_REDUCED = [{ opacity: 1 }, { opacity: 1 }];
 /**
- * Run one wash on `el`, resolving the dwell off it so the number is single-sourced
- * in CSS.
+ * Run one wash on `el`, resolving the dwell off its root so the number is
+ * single-sourced in CSS (`core/rungs.ts`).
  *
  * One property, both motion preferences: `--_qm-bloom-dwell` already shortens under
  * `prefers-reduced-motion` in the derivation, so what is left to `matchMedia` here is
@@ -36,7 +37,7 @@ function bloom(el) {
     if (typeof el.animate !== 'function')
         return undefined;
     const reduced = typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches;
-    const raw = getComputedStyle(el).getPropertyValue('--_qm-bloom-dwell').trim();
+    const raw = rungStyle(el).getPropertyValue('--_qm-bloom-dwell').trim();
     const n = Number.parseFloat(raw);
     const duration = !Number.isFinite(n) ? FALLBACK_MS : raw.endsWith('ms') ? n : n * 1000;
     return el.animate(reduced ? FRAMES_REDUCED : FRAMES, { duration });

package/dist/core/codec/decode.js

@@ -3,12 +3,12 @@
 // nodes; a code fence's lines → one `code_block`), nest by shared `containers`
 // prefix (`list_item`/`quote` → lists/blockquote), select the block node by
 // `kind`, apply marks over their `[start,end)` USV ranges (PM splits inline nodes
-// at mark boundaries), and lower island slots to leaf nodes (inline in a `para`
-// line, block on an `island` line). Anchors are not applied here; they are
-// decorations (field.ts). Positions throughout are USV; `Array.from` iterates by
+// at mark boundaries), and lower island slots to leaf nodes (block where a block
+// island's slot stands alone on its line, inline otherwise). Anchors are not
+// applied here; they are decorations (field.ts). Positions throughout are USV; `Array.from` iterates by
 // code point so an astral char is one unit, never a surrogate half.
 import { DOMSerializer } from 'prosemirror-model';
-import { ISLAND_SLOT } from './islands.js';
+import { ISLAND_SLOT, isBlockIsland } from './islands.js';
 import { descriptorOf, markKey, pmMarkFromContent } from './marks.js';
 import { hasMarks, isInlineSchema, takesLineBreak } from './schema.js';
 /** Code points of `s` (USV units): the iteration granularity the content speaks. */
@@ -177,10 +177,6 @@ function makeLeaf(schema, leaf, marks, cursor) {
     switch (line.kind) {
         case 'rule':
             return schema.nodes.horizontal_rule.create();
-        case 'island': {
-            const attrs = islandAttrs(cursor);
-            return attrs ? schema.nodes.island_block.create(attrs) : schema.nodes.paragraph.create();
-        }
         case 'code': {
             // One code_block: the segments' texts joined by literal `\n`, no marks.
             const text = leaf.segments.map((s) => s.text).join('\n');
@@ -189,6 +185,8 @@ function makeLeaf(schema, leaf, marks, cursor) {
         }
         case 'para':
         case 'heading': {
+            if (line.kind === 'para' && blockIslandLine(leaf, cursor))
+                return schema.nodes.island_block.create(islandAttrs(cursor));
             // Inline content, the segment boundary a `hard_break` in a paragraph and a space
             // in a heading, which takes none (`schema.ts` §`takesLineBreak`). A stored heading
             // carries no continuation — the store clears one after a block of a single line —
@@ -210,15 +208,23 @@ function makeLeaf(schema, leaf, marks, cursor) {
         }
     }
 }
-/** Consume the next island entry as PM node attrs (text-order matched to slots):
- *  the whole entry, `loss` included, which an island edit has to write back
- *  (`islands.ts`). `null` where a slot has no entry behind it, which is a malformed
- *  content: the slot draws an empty paragraph or nothing at all, so the decode stays
- *  total without minting a node whose `type` the vocabulary would refuse on the way
- *  back. */
+/** Whether a `para` leaf is one block island: a single line holding its slot alone,
+ *  backed by an island whose markup is a block. The island is the one fact; the line
+ *  carries no kind of its own for it. */
+function blockIslandLine(leaf, cursor) {
+    if (leaf.segments.length !== 1 || leaf.segments[0].text !== ISLAND_SLOT)
+        return false;
+    const isl = cursor.rt.islands[cursor.i];
+    return isl != null && isBlockIsland(isl.type);
+}
+/** Consume the next island entry as PM node attrs (text-order matched to slots): the
+ *  whole entry, which an island edit has to write back (`islands.ts`). `null` where a
+ *  slot has no entry behind it, which is a malformed content: the slot draws nothing
+ *  and its line an empty paragraph, so the decode stays total without minting a node
+ *  whose `type` the vocabulary would refuse on the way back. */
 function islandAttrs(cursor) {
     const isl = cursor.rt.islands[cursor.i++];
-    return isl ? { id: isl.id, islandType: isl.type, props: isl.props, loss: isl.loss } : null;
+    return isl ? { id: isl.id, islandType: isl.type, props: isl.props } : null;
 }
 /**
  * Inline nodes for one segment: split text into maximal runs of a constant mark

package/dist/core/codec/encode.js

@@ -104,7 +104,7 @@ function scanBlock(acc, node, nodePos, containers, instance) {
             acc.lastContentEndPm = nodePos + 1;
             break;
         case 'island_block':
-            beginLine(acc, nodePos, containers, { kind: 'island' });
+            beginLine(acc, nodePos, containers, { kind: 'para' });
             acc.runs.push({ kind: 'atom', pmStart: nodePos, usvStart: acc.usvEnd });
             appendText(acc, ISLAND_SLOT);
             acc.islands.push(islandEntryFromNode(node.attrs));

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

@@ -3,19 +3,20 @@ import { Plugin } from 'prosemirror-state';
 import type { ContentIsland, TableProps } from '@quillmark/wasm';
 /** The `U+FFFC` object-replacement char that occupies one island slot in `text`. */
 export declare const ISLAND_SLOT = "\uFFFC";
-/** Block island node (a table): one `island`-kind content line. Atom, unselectable content. */
+/** Whether an island of `type` is block markup: a `table` stands alone on its line. */
+export declare function isBlockIsland(type: ContentIsland['type']): boolean;
+/** Block island node (a table): a `U+FFFC` slot alone on its `para` line. Atom, unselectable content. */
 export declare const islandBlockSpec: NodeSpec;
 /** Inline island node (an image): a `U+FFFC` slot inside a `para` line. */
 export declare const islandInlineSpec: NodeSpec;
 /** A PM island node's attributes: the content entry, spelled the way a node spec
  *  spells it (`islandType`, because `type` on a PM node is the node type). `islandType`
- *  and `loss` read their sets off the entry rather than restating them, the public entry
- *  point naming neither (DOCUMENT_MODEL §Stability seams). */
+ *  reads its set off the entry rather than restating it (DOCUMENT_MODEL §Stability
+ *  seams). */
 export interface IslandNodeAttrs {
     id: string;
     islandType: ContentIsland['type'];
     props: unknown;
-    loss: ContentIsland['loss'];
 }
 /** Build a content island entry from a PM island node's attrs (block or inline). The
  *  cast pairs a closed `type` with a `props` that crossed the DOM as opaque JSON. The

package/dist/core/codec/islands.js

@@ -1,6 +1,6 @@
-// Islands: the `U+FFFC` slot + `ContentIsland` entry ↔ a PM leaf node. A slot
-// inside a `para` line is an inline island (an image); an `island`-kind line is a
-// block island (a table). The node carries `id`, `islandType` and `props` verbatim.
+// Islands: the `U+FFFC` slot + `ContentIsland` entry ↔ a PM leaf node. Every slot sits
+// in a `para` line; the island's type says which node it is, a `table` a block alone on
+// its line and an `image` inline. The node carries `id`, `islandType` and `props` verbatim.
 //
 // A props-aware consumer reads the shape straight off the boundary:
 // `ContentIsland.props` is the typed union (`TableProps` for `table`,
@@ -13,22 +13,17 @@ import { Plugin } from 'prosemirror-state';
 import { storableUrl } from './urls.js';
 /** The `U+FFFC` object-replacement char that occupies one island slot in `text`. */
 export const ISLAND_SLOT = '';
-// The four island node attributes carry the content entry verbatim: `id` is the
-// stable identity (rebases like an anchor), `islandType` the discriminator, `props`
-// the payload the codec preserves byte-for-byte across a round-trip, and `loss` how
-// faithfully markdown can carry it. `islandType` and `props` declare no default: a
-// node standing for an island holds one, so the pair is supplied at every `create`.
-// `loss` is authored, not derived: `applyChange` stores the class an island op gives
-// it and re-derives nothing, so an entry that did not carry its own would promote a
-// degraded table to lossless on the first cell edit. Its default is the weakest
-// claim; decode always supplies the stored value.
+// The three island node attributes carry the content entry verbatim: `id` is the
+// stable identity (rebases like an anchor), `islandType` the discriminator, and `props`
+// the payload the codec preserves byte-for-byte across a round-trip. `islandType` and
+// `props` declare no default: a node standing for an island holds one, so the pair is
+// supplied at every `create`.
 const islandAttrs = {
     id: { default: '' },
     islandType: {},
-    props: {},
-    loss: { default: 'unrepresentable' }
+    props: {}
 };
-// All four attributes cross the DOM: a copy and a paste inside one body run the document
+// All three attributes cross the DOM: a copy and a paste inside one body run the document
 // through `toDOM`/`parseDOM` (CODEC §"Markdown at the edges"), and an island is a leaf
 // whose tags alone say only `[table]`. `props` crosses as JSON, the form the payload has
 // at the boundary. The names are `data-qm-*` like every other carrier's, and the id is
@@ -39,21 +34,18 @@ function islandDOM(node) {
     return {
         'data-qm-island': node.attrs.islandType,
         'data-qm-island-id': node.attrs.id,
-        'data-qm-island-loss': node.attrs.loss,
         'data-qm-island-props': JSON.stringify(node.attrs.props ?? null)
     };
 }
-// The two closed sets an element claims a value from. A `Record` over the boundary's own
-// union rather than a literal check, so a member added upstream is a missing key here
-// rather than a silent refusal at the one door with no decode behind it.
-/** The island types the content model names. */
-const ISLAND_TYPES = { table: true, image: true };
-/** The loss classes it names, weakest last: an unrecognized claim takes that one. */
-const LOSS_CLASSES = {
-    lossless: true,
-    degraded: true,
-    unrepresentable: true
-};
+/** The island types the content model names, each with whether its markup is a block,
+ *  which decides the node its slot decodes to. A `Record` over the boundary's own union,
+ *  so a member added upstream is a missing key here rather than a silent refusal at the
+ *  one door with no decode behind it. */
+const BLOCK_ISLAND = { table: true, image: false };
+/** Whether an island of `type` is block markup: a `table` stands alone on its line. */
+export function isBlockIsland(type) {
+    return BLOCK_ISLAND[type];
+}
 /** An island node's attributes off that DOM, or `false` where the id is absent or the
  *  type is one the content vocabulary does not name — a name no read produces and no
  *  write takes, so the element's text arrives as text. A `props` that is not the JSON
@@ -64,7 +56,7 @@ function islandAttrsFromDOM(el) {
     const id = el.getAttribute('data-qm-island-id');
     // Asserted off an untrusted attribute and checked against the set on the next line.
     const type = el.getAttribute('data-qm-island');
-    if (id == null || type == null || !ISLAND_TYPES[type])
+    if (id == null || type == null || !Object.hasOwn(BLOCK_ISLAND, type))
         return false;
     const raw = el.getAttribute('data-qm-island-props');
     let props = null;
@@ -74,13 +66,7 @@ function islandAttrsFromDOM(el) {
     catch {
         props = null;
     }
-    return { id, islandType: type, props: storableProps(type, props), loss: lossFromDOM(el) };
-}
-/** The `loss` an element claims, or the weakest class for a claim outside the set:
- *  an under-claim keeps a degraded island from re-crossing as a lossless one. */
-function lossFromDOM(el) {
-    const raw = el.getAttribute('data-qm-island-loss');
-    return raw != null && LOSS_CLASSES[raw] ? raw : 'unrepresentable';
+    return { id, islandType: type, props: storableProps(type, props) };
 }
 /** `props` with the one key the authored lane refuses made storable: an `image`'s `url`
  *  carrying a line ending, which `IslandOp` and `overwrite` throw on. The rest crosses
@@ -91,7 +77,7 @@ function storableProps(type, props) {
     const url = props.url;
     return typeof url === 'string' ? { ...props, url: storableUrl(url) } : props;
 }
-/** Block island node (a table): one `island`-kind content line. Atom, unselectable content. */
+/** Block island node (a table): a `U+FFFC` slot alone on its `para` line. Atom, unselectable content. */
 export const islandBlockSpec = {
     group: 'block',
     atom: true,
@@ -119,8 +105,7 @@ export function islandEntryFromNode(attrs) {
     return {
         id: attrs.id,
         type: attrs.islandType,
-        props: attrs.props,
-        loss: attrs.loss
+        props: attrs.props
     };
 }
 /** The `TableProps` shape, over a value that reached the node off the DOM rather than

package/dist/core/rungs.d.ts

@@ -0,0 +1,8 @@
+/** The element the scale is declared on, for `node`: its root, or `node` where it stands
+ *  outside one (a detached surface, a consumer's own mount). */
+export declare function rungStyle(node: Element): CSSStyleDeclaration;
+/** 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;

package/dist/core/rungs.js

@@ -0,0 +1,24 @@
+// Where a script reads the scale. The derivation declares every `--_qm-*` rung on
+// `[data-qm-root]` and nowhere else (`core/theme.css`), so a descendant's value is that
+// one inherited and the root is the element the question is about: asking a leaf three
+// containers deep is asking an arbitrary element what the surface is set to.
+//
+// The read is also the cost. `getComputedStyle` compounds with nesting depth under jsdom,
+// so a suite that resolves rungs off landed elements pays the depth of whatever it landed
+// on; resolving them off the root pays the root's.
+/** The element the scale is declared on, for `node`: its root, or `node` where it stands
+ *  outside one (a detached surface, a consumer's own mount). */
+export function rungStyle(node) {
+    return getComputedStyle(node.closest('[data-qm-root]') ?? node);
+}
+/** 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 function rungMs(style, rung) {
+    const raw = style.getPropertyValue(rung).trim();
+    const n = Number.parseFloat(raw);
+    if (!Number.isFinite(n))
+        return undefined;
+    return raw.endsWith('ms') ? n : n * 1000;
+}

package/dist/core/theme.css

@@ -336,6 +336,16 @@
 	   through the icon's `size`, so a stylesheet beats the SVG presentation attribute
 	   and one rung is the whole of what a control draws. */
 	--_qm-glyph-control: 14px;
+	/* The narrowest track a control that fills its width stays usable in: a table's
+	   column floors at it, rises no further than its content, and a row of them scrolls
+	   sideways rather than crushing a cell. A column drawing a mark takes no floor — a
+	   switch is one width at every width, so there is no width for it to be usable in
+	   (`ArrayField`). What the field has spare stands after the last column, an inner
+	   grid carrying its own rhythm rather than the card's. Under the field minimum the
+	   capacity ladder steps at (`.qm-tracks`), since a cell in a row has the header to
+	   name it and no label of its own to fit. A threshold rather than a rhythm choice,
+	   so it does not move with `--qm-space`. */
+	--_qm-track-min: 7rem;
 
 	/* ── Type ────────────────────────────────────────────────────────────────
 	   `--qm-font-size` anchors the chrome rung; 1.125 is the ratio between adjacent