flexdesk 0.17.0 → 0.17.2

package/editor.js

@@ -0,0 +1,20 @@
+/**
+ * @flexdesk/editor — A Monaco-backed multi-file editor: the loader, the editor factory, the
+ * tab bar, search, a split-pane container and an undo manager.
+ *
+ * Monaco is a PEER dependency — 14 MB this bundle deliberately does NOT
+ * contain, and whose location it refuses to guess. Call setMonacoBasePath()
+ * and setDefaultLanguage().
+ *
+ * GENERATED by scripts/gen_barrels.py. Do not hand-edit.
+ *
+ * 7 modules.
+ */
+
+export * from './src/editor/editor_pane.js';
+export * from './src/editor/monaco_editor_factory.js';
+export * from './src/editor/monaco_loader.js';
+export * from './src/editor/notebook_search.js';
+export * from './src/editor/notebook_tab_bar.js';
+export * from './src/editor/notebook_undo_manager.js';
+export * from './src/editor/split_pane_container.js';

package/flow.js

@@ -0,0 +1,21 @@
+/**
+ * @flexdesk/flow — flow editors: the shared kit (a step-type catalogue, a
+ * settings panel generated from a JSON-Schema subset, a widget registry,
+ * reference chips, the step and value pickers, findings, undo over whole
+ * snapshots, keys) and the three editors built on it — the canvas, the outline
+ * and the lanes.
+ *
+ * Every editor is domain-neutral: it never fetches, never saves and never
+ * names a consumer's vocabulary. The step types, the reference grammar, every
+ * finding and every byte of I/O are the consumer's, passed in.
+ *
+ * HAND-WRITTEN, not generated. The other barrels say "GENERATED by
+ * scripts/gen_barrels.py", and that script is not in this repository, so this
+ * one is kept by hand. Each line below is one owner's module (36 §2): the kit
+ * is laid down first, and each editor fills its own index.js.
+ */
+
+export * from './src/flow/kit/index.js';
+export * from './src/flow/canvas_editor/index.js';
+export * from './src/flow/outline/index.js';
+export * from './src/flow/lanes/index.js';

package/host.js

@@ -0,0 +1,14 @@
+/**
+ * @flexdesk/host — The host port. The library never touches pywebview, fetch or localStorage
+ * directly — it asks a Host, and the application supplies one.
+ *
+ * GENERATED by scripts/gen_barrels.py. Do not hand-edit.
+ *
+ * 5 modules.
+ */
+
+export * from './src/host/host.js';
+export * from './src/host/pywebview_host.js';
+export * from './src/host/photino_host.js';
+export * from './src/host/external_links.js';
+export * from './src/host/file_picker.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "flexdesk",
-    "version": "0.17.0",
+    "version": "0.17.2",
     "description": "A tiling window manager and widget set for desktop-class web applications. Zero runtime dependencies.",
     "license": "MIT",
     "repository": {
@@ -18,6 +18,15 @@
     "files": [
         "dist",
         "src",
+        "core.js",
+        "host.js",
+        "wm.js",
+        "widgets.js",
+        "charts.js",
+        "tiles.js",
+        "editor.js",
+        "canvas.js",
+        "flow.js",
         "css",
         "README.md",
         "CHANGELOG.md",

package/src/flow/canvas_editor/editor.js

@@ -2888,7 +2888,7 @@ export function createCanvasEditor(host, options = {}) {
         for (const c of g.connections) {
             const source = idOf.get(c.source);
             const target = idOf.get(c.target);
-            if (source && target) connect(graph, catalogue, { ...c, source, target }, { strings: S });
+            if (source && target) connect(graph, catalogue, { ...c, source, target }, { strings: S, dataPorts: dataConnect });
         }
         const noteIds = [];
         for (const from of noting ? g.notes || [] : []) {

package/src/tiling/command_palette.js

@@ -72,6 +72,17 @@
  *   drillLabel the Tab hint ("search rows"); Tab is offered only with it
  *   shortcut   a key binding drawn on the right
  *   verb       the Enter hint ('open' by default, 'run' for a command)
+ *   enabled    `() => boolean` (0.17.2). False: the row is still listed and
+ *              the arrows still reach it, but it is drawn greyed
+ *              (`twm-cmdpal__item--disabled`, aria-disabled="true") and
+ *              picking it — click, Enter, Ctrl/Shift+Enter — does nothing and
+ *              leaves the palette open. Asked on every draw and every pick.
+ *   disabledReason  the disabled row's tooltip (its `title`)
+ *
+ * A catalog source with `scopedOnly: true` (0.17.2) contributes no rows to a
+ * plain typed query, in either layout: its rows are listed only once its
+ * prefix has made the type chip (`help: solver`).
+ *
  * `hint` keeps its old meaning — drawn AND searched — for a row that sets
  * neither `context` nor `keywords`. A group's header is the taxonomy's
  * `plural` for the kind, else its `label`.
@@ -281,8 +292,7 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
         const render = () => {
             if (grouped) { renderGrouped(); return; }
             list.innerHTML = filtered.slice(0, MAX_ROWS).map((e, i) => `
-                <div class="twm-cmdpal__item${i === active ? ' twm-cmdpal__item--active' : ''}"
-                     data-idx="${i}">
+                ${_itemOpen(e, i === active ? ' twm-cmdpal__item--active' : '', `data-idx="${i}"`)}
                     <span class="material-symbols-outlined twm-cmdpal__icon">${e.icon || 'arrow_right'}</span>
                     <span class="twm-cmdpal__label">${_esc(e.label || e.id)}</span>
                     <span class="twm-cmdpal__kind">${e.kind}</span>
@@ -343,7 +353,7 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
             const side = r.shortcut
                 ? `<kbd class="twm-cmdpal__shortcut">${_esc(r.shortcut)}</kbd>`
                 : `<span class="twm-cmdpal__kind">${_esc(kindLabel(r))}</span>`;
-            return `<div class="twm-cmdpal__item${on}" data-idx="${i}" role="option">
+            return `${_itemOpen(r, on, `data-idx="${i}" role="option"`)}
                 <span class="material-symbols-outlined twm-cmdpal__icon">${_esc(r.icon || 'arrow_right')}</span>
                 <span class="twm-cmdpal__main"><span class="twm-cmdpal__label">${_mark(r.label || r.id, r._hits)}</span>${ctx}</span>
                 <span class="twm-cmdpal__side">${side}<span class="twm-cmdpal__acts">${acts.join('')}</span></span>
@@ -453,6 +463,9 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
             const picked = filtered[i];
             if (!picked) return;
             if (picked.more) { showAll(picked.more); return; }
+            // A disabled row is listed so it can say why; picking it runs
+            // nothing and the palette stays open on it.
+            if (_isDisabled(picked)) return;
             // Split and window open a COPY; a single kind refuses both, and the
             // palette stays open on the row whose hints say why.
             if (mode !== 'open' && isSingle(picked)) return;
@@ -585,6 +598,7 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
                 return;
             }
             let pool = entities;
+            if (!filterSet) pool = pool.filter((e) => !e._scopedOnly);
             if (commandsOnly) pool = pool.filter((e) => e.kind === 'command');
             else if (filterSet) pool = pool.filter((e) => filterSet.has(_groupOf(e)) || filterSet.has(e.kind));
             else if (q.length < commandMinChars) pool = pool.filter((e) => e.kind !== 'command');
@@ -649,7 +663,7 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
             const filterSet = typeFilter ? new Set(typeFilter) : null;
             const pool = filterSet
                 ? entities.filter((e) => filterSet.has(e.kind))
-                : entities;
+                : entities.filter((e) => !e._scopedOnly);
             if (!q) {
                 // Scoped + empty query → list every entity of that
                 // kind so the user sees what's available. Unscoped +
@@ -715,10 +729,18 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
             }
             return [...staticCommands, ...extra];
         };
+        // A `scopedOnly` source's rows are marked here, from the catalog's
+        // own source list, so only the rows the catalog produced are held
+        // back — a command or a Recent row of the same kind is not.
+        const scopedKinds = new Set((catalog?.sources || [])
+            .filter((s) => s?.scopedOnly === true).map((s) => s.navKind));
+        const tagScoped = (rows) => (scopedKinds.size
+            ? rows.map((r) => (scopedKinds.has(r.kind) ? { ...r, _scopedOnly: true } : r))
+            : rows);
         // Objects before commands in the grouped layout, so that a tie that
         // survives every rule goes to the object (first seen wins).
         const withCommands = (rows) => (grouped ? [...rows, ...commandRows()] : [...commandRows(), ...rows]);
-        entities = _decorateIcons(withCommands(cache && cached ? cached : []), taxonomy);
+        entities = _decorateIcons(withCommands(tagScoped(cache && cached ? cached : [])), taxonomy);
         if (grouped) {
             refilter();
             if (typeof empty === 'function') {
@@ -735,7 +757,7 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
                 const loaded = await catalog.loadAll(api);
                 if (cache) cached = loaded;
                 if (overlay !== mine) return;
-                entities = _decorateIcons(withCommands(loaded), taxonomy);
+                entities = _decorateIcons(withCommands(tagScoped(loaded)), taxonomy);
                 if (grouped ? (!scope && (input.value || typeFilter)) : input.value) refilter();
             } catch (err) {
                 console.warn('[cmdpal] entity load failed', err);
@@ -859,9 +881,26 @@ function _searched(r) {
 }
 function _groupOf(r) { return r.group || r.kind; }
 
+/** 0.17.2. `enabled` is asked each time; one that throws counts as no. */
+function _isDisabled(r) {
+    if (!r || typeof r.enabled !== 'function') return false;
+    try { return !r.enabled(); }
+    catch (err) { console.warn('[cmdpal] enabled() threw', err); return true; }
+}
+/** A row's opening `<div>` with its classes (`twm-cmdpal__item` plus `extra`)
+ *  and attributes. A disabled row adds its class, `aria-disabled` and, given a
+ *  `disabledReason`, the reason as its `title`. */
+function _itemOpen(r, extra, attrs) {
+    const off = _isDisabled(r);
+    const cls = 'twm-cmdpal__item' + extra + (off ? ' twm-cmdpal__item--disabled' : '');
+    const refused = !off ? ''
+        : ' aria-disabled="true"' + (r.disabledReason ? ` title="${_esc(r.disabledReason)}"` : '');
+    return `<div class="${cls}"${refused} ${attrs}>`;
+}
+
 /** Strip the palette's private fields before a row leaves it. */
 function _public(r) {
-    const { _hits, _score, ...rest } = r;
+    const { _hits, _score, _scopedOnly, ...rest } = r;
     return rest;
 }
 

package/src/tiling/content_registry.js

@@ -8,6 +8,9 @@
  *
  * The tile renderer calls the factory once when the leaf is first
  * mounted with a given (kind, props) pair, and `destroy()` on unmount.
+ * A content of a `single` kind may return `navigate(props)`: an open path
+ * that reveals the instance instead of mounting it hands it the new props
+ * (`wm.revealInstance`, 0.17.2).
  *
  * `ctx` is the shell's ctx plus, per leaf, `leafId` and `setTitle(text)` —
  * rename the pane's chrome title from inside the content, at mount or any

package/src/tiling/entity_sources.js

@@ -27,6 +27,12 @@
  *             row to the record shape every search surface consumes.
  *             Return `null` to skip the row.
  *
+ *   scopedOnly? `true` keeps the source's rows out of a plain typed query:
+ *             the command palette lists them only behind the source's
+ *             prefix (`<navKind>:` or an alias that resolves to it). For a
+ *             source too broad to compete with everything else — help
+ *             topics, say. Absent or `false`: searched as always (0.17.2).
+ *
  * ## Aggregation
  *
  * An embedder whose backend can answer for every source in ONE call
@@ -48,6 +54,10 @@ export function createEntityCatalog({ sources, aliases = {}, aggregate = null }
             throw new TypeError(
                 `createEntityCatalog: source '${s?.navKind ?? '?'}' needs navKind + list() + shape()`);
         }
+        if (s.scopedOnly != null && typeof s.scopedOnly !== 'boolean') {
+            throw new TypeError(
+                `createEntityCatalog: source '${s.navKind}' \`scopedOnly\` must be a boolean when present`);
+        }
     }
     if (aggregate != null && typeof aggregate !== 'function') {
         throw new TypeError('createEntityCatalog: `aggregate` must be a function when present');

package/src/tiling/wm.js

@@ -348,10 +348,57 @@ export class WindowManager {
     }
 
     /** Reveal the instance of a single kind that is open: answers whether
-     *  there was one. Every open path asks this first. */
+     *  there was one. Every open path asks this first.
+     *
+     *  An open path names props too, and revealing alone would drop them: the
+     *  instance keeps showing what it was opened with. So a revealed content
+     *  that returned a `navigate(props)` hook from its mount is handed the new
+     *  props — once per open, the same props twice are two calls — and they
+     *  are recorded on its tab, so a page restore or a reload mounts it with
+     *  the latest. A content without the hook is revealed as it is: its tab
+     *  keeps its props and nothing is called. So is every content when the
+     *  open names no props at all — a top-nav button, `openInPrimary(kind)` —
+     *  which asks to SEE the instance, not to empty it. */
     revealInstance(kind, props = {}) {
         const loc = this.findInstance(kind, props);
-        return loc ? this._revealAt(loc) : false;
+        if (!loc || !this._revealAt(loc)) return false;
+        if (props && Object.keys(props).length) this._deliverProps(kind, props);
+        return true;
+    }
+
+    /** Hand a revealed instance the props it was opened with, and record them
+     *  on its tab (and the tile's `content` mirror of it, re-baselining the
+     *  tile so the write does not rebuild it). Looks
+     *  the instance up again: a reveal from a page archive moved it into the
+     *  tile's tabs. A throwing hook is a warning, never a crash. */
+    _deliverProps(kind, props) {
+        const loc = this.findInstance(kind, props);
+        if (!loc || loc.where === 'archive') return;
+        const scope = loc.where === 'window' ? { windowId: loc.windowId } : { leafId: loc.leafId };
+        const content = this._scopeContent(scope);
+        if (typeof content?.navigate !== 'function') return;
+        const next = { ...(props || {}) };
+        if (loc.where === 'window') {
+            const rec = this._windowToLeaf.get(loc.windowId);
+            const tab = Array.isArray(rec.tabs) ? rec.tabs[loc.idx] : null;
+            if (tab) tab.props = { ...next };
+            if (rec.original) rec.original = { ...rec.original, props: { ...next } };
+        } else {
+            const leaf = this._tree().get(loc.leafId);
+            const expected = this.renderer?.leafKey?.(loc.leafId) ?? undefined;
+            leaf.tabs[loc.idx].props = { ...next };
+            // The tab is the active one now, and `content` mirrors it: the
+            // next tab activation re-mirrors it anyway, and a mirror left
+            // behind would change the tile's key then and rebuild it.
+            if (leaf.content?.kind === kind) leaf.content = { ...leaf.content, props: { ...next } };
+            this.renderer?.rebaselineLeaf?.(loc.leafId, expected);
+        }
+        this._persist();
+        try {
+            content.navigate({ ...next });
+        } catch (err) {
+            console.warn('[wm] content navigate threw', err);
+        }
     }
 
     /** A leaf's archived pages that can come back — every `pageTabs` entry
@@ -4106,8 +4153,23 @@ export class WindowManager {
      *
      *  The lower-level primitives (`openFromContext`,
      *  `openInTabFromContext`, `openInTabInPrimary`, `openInPrimary`,
-     *  `openInWindow`) stay internal; callers prefer `wm.navigate(...)`. */
+     *  `openInWindow`) stay internal; callers prefer `wm.navigate(...)`.
+     *
+     *  Returns `true` once the navigation is routed. A kind the shell's
+     *  content registry has no factory for is refused instead: one
+     *  `console.warn` naming it, no tile, tab, window or history touched, and
+     *  `false` — never a placeholder tile, never a throw. */
     navigate(kind, props = {}, opts = {}) {
+        if (!this.content.has(kind)) {
+            console.warn(`[wm] navigate: no content registered for kind "${String(kind)}"`);
+            return false;
+        }
+        this._route(kind, props, opts);
+        return true;
+    }
+
+    /** The routing behind `navigate`, for a kind known to be registered. */
+    _route(kind, props, opts) {
         const { ctx = null, transient = false } = opts;
         // Append the tab but stay where you are. Only meaningful with `newTab`.
         const background = !!opts.background;

package/src/ui/components/cell_editor_host.js

@@ -6,10 +6,11 @@
  * it likes (DataTable's `editors` option); the plain text box below is the
  * default. A factory is called with
  *
- *     { value, row, rowIdx, colIdx, column: {index, header, type},
- *       initialText, commit(value), cancel() }
+ *     { ...args, value, row, rowIdx, colIdx, column: {index, header, type},
+ *       initialText, commit(value, move?), cancel() }
  *
- * and returns either an element, or `{ el, getValue?, focus?, destroy? }`.
+ * and returns either an element, or
+ * `{ el, getValue?, parse?, multiline?, focus?, destroy? }`.
  * `initialText` is the character typed to open the editor (null when it was
  * opened by F2, Enter or a double-click): the editor starts with it in place
  * of the value, as a spreadsheet does.
@@ -29,6 +30,20 @@
  * pressed in the editor stops there: the table's own keys (the arrows, Ctrl+A,
  * Ctrl+C) are not the editor's.
  *
+ * ══ A VALUE THAT DOES NOT PARSE (STORY-0087) ═══════════════════════════
+ *
+ * An editor with a `parse()` — `() => {ok: true, value} | {ok: false, error}`
+ * — commits what `parse()` reads, not `getValue()`. A refusal on Enter or Tab
+ * keeps the editor open, and its cell carries the message
+ * (`twm-dt-cell--error`, `title`, `data-error`) until the next keystroke in
+ * it; nothing is committed. A refusal when the focus leaves, or on `commit()`
+ * from outside, closes the editor and hands `onRefuse` the message and the
+ * text (`getValue()`); still nothing is committed. A `multiline` editor
+ * keeps Enter for a new line: Ctrl/Cmd+Enter commits it.
+ *
+ * `commit(value, move?)` takes an optional move ('down', 'up', 'right',
+ * 'left'), for an editor that commits on a key of its own.
+ *
  * ══ EXACTLY ONCE ═════════════════════════════════════════════════════════
  *
  * A session closes once. Escape's own repaint takes the focused input out of
@@ -73,14 +88,29 @@ function normalise(made) {
     let getValue = typeof own.getValue === 'function' ? own.getValue : null;
     // A form field's value is the editor's; any other element says for itself.
     if (!getValue && el.matches?.('input, select, textarea')) getValue = () => el.value;
+    const parse = typeof own.parse === 'function' ? own.parse : null;
+    // What a commit reads: the parse, else the value as it is.
+    let read = null;
+    if (parse) {
+        read = () => {
+            let r;
+            try { r = parse(); } catch (err) { r = { ok: false, error: err?.message || String(err) }; }
+            return r && r.ok === false ? { ok: false, error: String(r.error ?? 'Not valid') }
+                : { ok: true, value: r ? r.value : undefined };
+        };
+    } else if (getValue) read = () => ({ ok: true, value: getValue() });
     return {
         el,
         getValue,
+        read,
+        multiline: !!own.multiline,
         focus: typeof own.focus === 'function' ? own.focus : null,
         destroy: typeof own.destroy === 'function' ? own.destroy : null,
     };
 }
 
+const MOVES = new Set(['down', 'up', 'right', 'left']);
+
 export class CellEditorHost {
     /**
      * @param {object} o
@@ -88,19 +118,24 @@ export class CellEditorHost {
      *   cell is drawn as it was again; `move` is 'down', 'up', 'right', 'left'
      *   or null; `reason` is 'key', 'blur', 'editor' or 'scroll'.
      * @param {(session, reason) => void} o.onCancel
+     * @param {(session, error, text, reason) => void} [o.onRefuse]  a value
+     *   that did not parse, when the editor closed with it (the focus left,
+     *   `commit()` from outside); without it such a close is a cancel.
      */
-    constructor({ onCommit, onCancel }) {
+    constructor({ onCommit, onCancel, onRefuse = null }) {
         this._onCommit = onCommit;
         this._onCancel = onCancel;
+        this._onRefuse = onRefuse;
         /** The open session, or null. */
         this.session = null;
     }
 
     /**
-     * Open an editor in `td`. Returns whether one opened (a factory that
+     * Open an editor in `td`; `args` go to the factory beside the cell's own
+     * (DataTable's `locale`, `utc`, `messages`). Returns whether one opened (a factory that
      * throws or returns nothing opens none, and the cell is untouched).
      */
-    open({ td, factory, value, row, rowIdx, colIdx, column, initialText = null, ...extra }) {
+    open({ td, factory, value, row, rowIdx, colIdx, column, initialText = null, args = {}, ...extra }) {
         if (this.session) return false;
         const s = {
             ...extra, td, value, row, rowIdx, colIdx, column,
@@ -109,8 +144,8 @@ export class CellEditorHost {
         let made = null;
         try {
             made = factory({
-                value, row, rowIdx, colIdx, column, initialText,
-                commit: (v) => this._finish(s, v, null, 'editor'),
+                ...args, value, row, rowIdx, colIdx, column, initialText,
+                commit: (v, move = null) => this._finish(s, v, MOVES.has(move) ? move : null, 'editor'),
                 cancel: () => this._cancel(s, 'editor'),
             });
         } catch (err) {
@@ -122,6 +157,10 @@ export class CellEditorHost {
         s.editor = editor;
         s.saved = [...td.childNodes];
         s.savedTitle = td.getAttribute('title');
+        s.savedError = {
+            on: td.classList.contains('twm-dt-cell--error'),
+            message: td.getAttribute('data-error'),
+        };
         this.session = s;
         td.classList.add('twm-dt-cell--editing');
         td.replaceChildren(editor.el);
@@ -136,26 +175,29 @@ export class CellEditorHost {
             if (ev.key === 'Escape') {
                 ev.preventDefault();
                 this._cancel(s, 'key');
-            } else if (ev.key === 'Enter' && !ev.altKey && !ev.ctrlKey && !ev.metaKey && editor.getValue) {
+            } else if (ev.key === 'Enter' && !ev.altKey && editor.read
+                       && (editor.multiline ? (ev.ctrlKey || ev.metaKey) : !(ev.ctrlKey || ev.metaKey))) {
                 ev.preventDefault();
-                this._finish(s, editor.getValue(), ev.shiftKey ? 'up' : 'down', 'key');
-            } else if (ev.key === 'Tab' && !ev.altKey && !ev.ctrlKey && !ev.metaKey && editor.getValue) {
+                this._tryKey(s, ev.shiftKey ? 'up' : 'down');
+            } else if (ev.key === 'Tab' && !ev.altKey && !ev.ctrlKey && !ev.metaKey && editor.read) {
                 ev.preventDefault();
-                this._finish(s, editor.getValue(), ev.shiftKey ? 'left' : 'right', 'key');
+                this._tryKey(s, ev.shiftKey ? 'left' : 'right');
             }
         });
+        // A refusal's message stands until the text changes.
+        on('input', () => this._unmark(s));
         // A press inside the editor is the editor's, not a click on the cell.
         for (const type of ['click', 'dblclick', 'mousedown', 'contextmenu']) {
             on(type, (ev) => ev.stopPropagation());
         }
         on('focusout', (ev) => {
-            if (s.closed || !editor.getValue) return;
+            if (s.closed || !editor.read) return;
             const to = ev.relatedTarget;
             if (to && editor.el.contains(to)) return;
             // The window losing focus (another app) is not a click elsewhere.
             const doc = editor.el.ownerDocument;
             if (!to && doc && typeof doc.hasFocus === 'function' && !doc.hasFocus()) return;
-            this._finish(s, editor.getValue(), null, 'blur');
+            this._settle(s, null, 'blur');
         });
 
         try {
@@ -169,8 +211,49 @@ export class CellEditorHost {
     commit(move = null, reason = 'editor') {
         const s = this.session;
         if (!s) return false;
-        if (!s.editor.getValue) { this._cancel(s, reason); return false; }
-        return this._finish(s, s.editor.getValue(), move, reason);
+        if (!s.editor.read) { this._cancel(s, reason); return false; }
+        return this._settle(s, move, reason);
+    }
+
+    /** Enter or Tab: commit what parses; a refusal keeps the editor open,
+     *  the message on its cell. */
+    _tryKey(s, move) {
+        const r = s.editor.read();
+        if (r.ok) return this._finish(s, r.value, move, 'key');
+        s.td.classList.add('twm-dt-cell--error');
+        s.td.setAttribute('data-error', r.error);
+        s.td.setAttribute('title', r.error);
+        s.marked = true;
+        return false;
+    }
+
+    _unmark(s) {
+        if (!s.marked) return;
+        s.marked = false;
+        this._restoreMark(s);
+    }
+
+    _restoreMark(s) {
+        const { on, message } = s.savedError;
+        s.td.classList.toggle('twm-dt-cell--error', on);
+        if (message == null) s.td.removeAttribute('data-error');
+        else s.td.setAttribute('data-error', message);
+        if (s.savedTitle == null) s.td.removeAttribute('title');
+        else s.td.setAttribute('title', s.savedTitle);
+    }
+
+    /** The editor closing with what it holds (the focus left, `commit()`):
+     *  committed when it parses, else handed to `onRefuse`. */
+    _settle(s, move, reason) {
+        const r = s.editor.read();
+        if (r.ok) return this._finish(s, r.value, move, reason);
+        if (s.closed) return false;
+        let text = '';
+        try { text = s.editor.getValue ? s.editor.getValue() : ''; } catch (_) { /* gone */ }
+        this._close(s);
+        if (this._onRefuse) this._onRefuse(s, r.error, text, reason);
+        else this._onCancel?.(s, reason);
+        return true;
     }
 
     /** Cancel the open session: the cell is drawn as it was. */
@@ -191,8 +274,7 @@ export class CellEditorHost {
         }
         s.td.classList.remove('twm-dt-cell--editing');
         s.td.replaceChildren(...s.saved);
-        if (s.savedTitle == null) s.td.removeAttribute('title');
-        else s.td.setAttribute('title', s.savedTitle);
+        this._restoreMark(s);
     }
 
     _finish(s, value, move, reason) {