edytor 1.0.0-rc.3 → 2.0.0

package/dist/session/props.js

@@ -1,162 +1,65 @@
-/**
- * Properties: the deep proxy behind `block.data`, `atom.data` and
- * `edytor.data` (syncrostate's feel, one small module).
- *
- * A read goes to `read()` every time (the view's live, reactive source), so
- * a template that reads `block.data.title` re-renders when anyone changes
- * it. Plain objects read as nested proxies, arrays as array proxies,
- * everything else as the raw value; a proxy is cached per path, so its
- * identity is stable. An object or array held in an array item is that
- * item's (its path names the item by id, from `ids`): it stays on its item
- * wherever peers move it, so `{#each list as item (item)}` keeps a row, and
- * the focused field in it, on its item; once the item is removed, or its
- * array is, its writes are refused. A key is a path segment as
- * `keySegment` writes it (`~abc` as `~0abc`: never an item's id). A write
- * is one data patch through `write` (a
- * command): `obj.key = v`, `arr[i] = v` (by index) and `delete obj.key`
- * patch that path (a write inside an item, that item);
- * `push`, `pop`, `shift`, `unshift`, `splice` and `length` are one
- * `splice`, `sort` and `reverse` one `order` (the items move), `fill` and
- * `copyWithin` writes of the items they change.
- * `JSON.stringify` and `$state.snapshot` read plain JSON through it.
- */
-import { keySegment, segmentKey } from '../crdt/data.js';
-const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
-/** A plain JSON copy (proxies included), or `undefined`. */
-const plain = (v) => (v === undefined ? v : JSON.parse(JSON.stringify(v)));
-/** The items of `now` that differ from `was`, as writes of those items. */
-const changed = (_, __, was, now) => now.flatMap((value, i) => JSON.stringify(value) === JSON.stringify(was[i]) ? [] : [{ at: `${i}`, value }]);
-/**
- * Each array mutator as the patches of the array (or of its items `at`),
- * from its length `n`, the call's `args`, the array `was` and the result `out`.
- */
-const MUTATORS = {
-    push: (n, args) => ({ splice: [n, 0, ...args] }),
-    pop: (n) => ({ splice: [Math.max(n - 1, 0), n && 1] }),
-    shift: () => ({ splice: [0, 1] }),
-    unshift: (_, args) => ({ splice: [0, 0, ...args] }),
-    // The start and count `splice` resolved (negative, fractional, past the end).
-    splice: (n, [start, , ...items], _, out) => {
-        const s = Math.trunc(Number(start)) || 0;
-        return { splice: [s < 0 ? Math.max(n + s, 0) : Math.min(s, n), out.length, ...items] };
-    },
-    sort: (n, [compare], was) => ({ order: sorted(n, was, compare) }),
-    reverse: (n) => ({ order: Array.from({ length: n }, (_, i) => n - 1 - i) }),
-    fill: changed,
-    copyWithin: changed
-};
-/** The indexes `Array.prototype.sort` puts `values` in (stable, `undefined` compare: by string). */
-const sorted = (n, values, compare) => {
-    const by = typeof compare === 'function'
-        ? compare
-        : (a, b) => (`${a}` < `${b}` ? -1 : `${a}` > `${b}` ? 1 : 0);
-    return Array.from({ length: n }, (_, i) => i).sort((a, b) => by(values[a], values[b]));
-};
-export const propsProxy = (read, write, 
-/** The ids of the items of the array at a path (`facade.dataItemIds`). */
-ids = () => []) => {
-    const cache = new Map();
-    // Item ids per array path, for the value `read()` last gave.
-    let seen;
-    const known = new Map();
-    const idsOf = (path) => {
-        const now = read();
-        if (now !== seen) {
-            seen = now;
-            known.clear();
-        }
-        const key = JSON.stringify(path);
-        return known.get(key) ?? known.set(key, ids(path)).get(key);
-    };
-    const at = (path) => path.reduce((v, k, n) => /^~[a-z]/.test(k)
-        ? Array.isArray(v)
-            ? v[idsOf(path.slice(0, n)).indexOf(k)]
-            : undefined // its array is gone
-        : v !== null && typeof v === 'object'
-            ? v[segmentKey(k)]
-            : undefined, read());
-    const put = (path, value) => write([{ path, ...(value !== undefined && { value: plain(value) }) }]);
-    const wrap = (path, v) => Array.isArray(v) || isObject(v) ? proxy(path, Array.isArray(v)) : v;
-    const proxy = (path, array) => {
-        const key = `${array ? '[' : '{'}${JSON.stringify(path)}`;
-        const cached = cache.get(key);
-        if (cached)
-            return cached;
+import { propsProxy } from '../crdt/props.js';
+const keyOf = (target) => JSON.stringify(target);
+export class DataWrites {
+    edytor;
+    #pending = new Map();
+    #scheduled = false;
+    constructor(edytor) {
+        this.edytor = edytor;
+    }
+    /** The live proxy over `target`'s data; `read` is its reactive, committed source. */
+    proxy(target, read) {
+        let preview;
+        const pending = () => this.#pending.get(keyOf(target));
         const current = () => {
-            const v = at(path);
-            return array ? (Array.isArray(v) ? v : []) : isObject(v) ? v : {};
-        };
-        /** The path of child `k`: an item by its id, a key as its segment. */
-        const child = (k) => [...path, (array && idsOf(path)[Number(k)]) || keySegment(k)];
-        const items = () => current().map((v, i) => wrap(child(`${i}`), v));
-        const own = (k) => Object.prototype.hasOwnProperty.call(current(), k);
-        const made = new Proxy(array ? [] : {}, {
-            get(target, k) {
-                if (typeof k === 'symbol')
-                    return array && k === Symbol.iterator
-                        ? () => items()[Symbol.iterator]()
-                        : Reflect.get(target, k);
-                if (array && k === 'length')
-                    return current().length;
-                if (own(k))
-                    return wrap(child(k), current()[k]);
-                if (array && Object.hasOwn(MUTATORS, k))
-                    return (...args) => {
-                        const was = plain(current());
-                        const next = [...was];
-                        const fn = Array.prototype[k];
-                        args = args.map((a) => (a !== null && typeof a === 'object' ? plain(a) : a));
-                        const out = fn.apply(next, args);
-                        const ops = [MUTATORS[k](was.length, args, was, out)].flat();
-                        write(ops.map(({ at, ...op }) => ({ ...op, path: at ? [...path, at] : path })));
-                        return out === next ? made : out;
-                    };
-                const method = array ? Array.prototype[k] : undefined;
-                if (typeof method === 'function')
-                    return (...args) => method.apply(items(), args);
-                return Reflect.get(target, k);
-            },
-            set(_, k, value) {
-                if (typeof k === 'symbol')
-                    return false;
-                if (array && k === 'length') {
-                    const n = current().length;
-                    const nulls = Array.from({ length: Math.max(value - n, 0) }, () => null);
-                    write([{ path, splice: [Math.min(value, n), Math.max(n - value, 0), ...nulls] }]);
-                }
-                else
-                    put([...path, keySegment(k)], value);
-                return true;
-            },
-            deleteProperty(_, k) {
-                if (typeof k === 'symbol')
-                    return false;
-                if (own(k))
-                    put([...path, keySegment(k)], undefined);
-                return true;
-            },
-            has: (target, k) => (typeof k === 'string' && own(k)) || Reflect.has(target, k),
-            ownKeys: () => [...Object.keys(current()), ...(array ? ['length'] : [])],
-            getOwnPropertyDescriptor(target, k) {
-                if (array && k === 'length')
-                    return (Reflect.getOwnPropertyDescriptor(target, k) && {
-                        value: current().length,
-                        writable: true,
-                        enumerable: false,
-                        configurable: false
-                    });
-                if (typeof k !== 'string' || !own(k))
-                    return undefined;
-                return {
-                    value: wrap(child(k), current()[k]),
-                    writable: true,
-                    enumerable: true,
-                    configurable: true
-                };
+            const base = read();
+            const queued = pending();
+            if (!queued)
+                return base;
+            const { version } = this.edytor.facade;
+            const count = queued.patches.length;
+            if (preview?.version !== version || preview.count !== count) {
+                const seen = this.edytor.facade.dataPreview(target, queued.patches);
+                preview = { version, count, data: seen?.data ?? null };
             }
+            return preview.data ?? base;
+        };
+        return propsProxy(current, (patches) => this.write(target, patches), (path) => {
+            const queued = pending();
+            return queued
+                ? (this.edytor.facade.dataPreview(target, queued.patches)?.ids(path) ?? [])
+                : this.edytor.facade.dataItemIds(target, path);
+        });
+    }
+    /** Queue `patches` on `target` for this task's dispatch (refused at once when the view refuses writes). */
+    write(target, patches) {
+        const { edytor } = this;
+        if (!edytor.dispatcher.permits())
+            return void edytor.patchData(target, patches);
+        const key = keyOf(target);
+        const queued = this.#pending.get(key);
+        if (queued)
+            queued.patches.push(...patches);
+        else
+            this.#pending.set(key, { target, patches: [...patches] });
+        if (this.#scheduled)
+            return;
+        this.#scheduled = true;
+        queueMicrotask(() => {
+            this.#scheduled = false;
+            if (!edytor.destroyed)
+                this.flush();
         });
-        cache.set(key, made);
-        return made;
-    };
-    return proxy([], false);
-};
+    }
+    /** Dispatch the queued writes now: before any other operation of this view, and at the end of the task. */
+    flush() {
+        if (this.#pending.size === 0)
+            return;
+        const all = [...this.#pending.values()];
+        this.#pending.clear();
+        const { edytor } = this;
+        if (all.length === 1)
+            return void edytor.patchData(all[0].target, all[0].patches);
+        edytor.dispatcher.run('patchData', () => edytor.transact(() => all.forEach(({ target, patches }) => edytor.patchData(target, patches))));
+    }
+}

package/dist/session/selection.d.ts

@@ -10,8 +10,7 @@
  * lazily the marks at the caret and the selected string — is `project(value,
  * doc)`, a pure function memoized per (value, index version).
  *
- * The view's `commit(value, cause)` (public: `select(value)`) is the only writer; its
- * `selection.state` is a compatibility getter over the projection, and the
+ * The view's `commit(value, cause)` (public: `select(value)`) is the only writer; the
  * presence payload is `serialize(value)`.
  */
 import type { BlockId, ContentItem } from '../crdt/index.js';
@@ -94,7 +93,9 @@ export type ProjectionDoc = Pick<EdytorDoc, 'version' | 'resolveAnchor' | 'compa
 export declare const segmentsOf: (doc: ProjectionDoc, block: BlockId) => SelectionSegment[];
 /** The projection of `value` at the document's current version, memoized per (value, version). */
 export declare const project: (value: SelectionValue, doc: ProjectionDoc) => SelectionProjection;
-/** Why a selection was written (the view keeps the last cause with the value). */
+/** Two projections show the same endpoints (block and offset; two unresolved ones count as the same). */
+export declare const sameEnds: (a: SelectionProjection, b: SelectionProjection) => boolean;
+/** Why a selection was written. */
 export type SelectCause = 'dom' | 'model' | 'repair' | 'history';
 /** Value equality: kind, anchors (item + side), ids, pending marks. */
 export declare const sameValue: (a: SelectionValue, b: SelectionValue) => boolean;

package/dist/session/selection.js

@@ -186,6 +186,11 @@ export const project = (value, doc) => {
     memo.set(value, { doc, version, projection });
     return projection;
 };
+/** Two projections show the same endpoints (block and offset; two unresolved ones count as the same). */
+export const sameEnds = (a, b) => [a.start, a.end].every((p, i) => {
+    const q = i ? b.end : b.start;
+    return p?.block === q?.block && p?.offset === q?.offset;
+});
 const sameAnchor = (a, b) => a === b ||
     (a.b === b.b &&
         a.a.a === b.a.a &&

package/dist/session/suggestions.svelte.d.ts

@@ -41,7 +41,7 @@ export type SuggestionOptions = {
     id?: string;
     /** Default `ready` with content, `streaming` without. */
     status?: SuggestionStatus;
-    /** A name for the UI (the default bar shows it). */
+    /** A name for the UI (an app's suggestion bar shows it). */
     label?: string;
     /** Offer "Try again": called by `retry()` once the content is emptied. */
     onRetry?: (suggestion: Suggestion) => void;

package/dist/session/suggestions.svelte.js

@@ -1,13 +1,12 @@
-import { applyAt, caretOf } from '../edytor.utils.js';
+import { REFUSED } from '../crdt/doc/plan.js';
 import { textToBlocks } from '../clipboard/textBlocks.js';
 import { selectedMembers, viewOf } from '../selection/visibility.js';
 import { project, textSelection } from './selection.js';
 import { cloneJson, jsonBlockToSpec } from '../utils/json.js';
 import { id as mint } from '../utils.js';
-const REFUSED = Object.freeze({ status: 'refused', ids: [] });
 /** The block's `data-edytor-suggestion-replaced` (`empty`: folded, the preview stands in its place). */
 export const replacedMark = ({ replaced, inPlace }) => replaced ? (inPlace ? 'empty' : '') : null;
-const NONE = Object.freeze({
+const place = () => ({
     before: [],
     after: [],
     inside: [],
@@ -15,6 +14,14 @@ const NONE = Object.freeze({
     replaced: false,
     inPlace: false
 });
+const NONE = Object.freeze(place());
+/** The block positions, in the order a position names its side. */
+const SIDES = ['after', 'before', 'inside', 'end'];
+/** The side and block a block position names (none: a `replace`). */
+const sideOf = (at) => {
+    const side = SIDES.find((side) => side in at);
+    return side && [side, at[side]];
+};
 export class Suggestion {
     id;
     /** The position, resolved: `replace: 'selection'` is the selection's blocks or text range. */
@@ -169,33 +176,18 @@ export class Suggestions {
         if (!this.#list.length)
             return places;
         void this.edytor.valueRevision;
-        const at = (id) => {
-            if (!places.has(id))
-                places.set(id, {
-                    before: [],
-                    after: [],
-                    inside: [],
-                    end: [],
-                    replaced: false,
-                    inPlace: false
-                });
-            return places.get(id);
-        };
+        const at = (id) => places.get(id) ?? places.set(id, place()).get(id);
         for (const s of this.#list) {
             const { at: where } = s;
-            if ('after' in where)
-                at(where.after).after.push(s);
-            else if ('before' in where)
-                at(where.before).before.push(s);
-            else if ('inside' in where)
-                at(where.inside).inside.push(s);
-            else if ('end' in where) {
-                at(where.end).end.push(s);
+            const named = sideOf(where);
+            if (named) {
+                const [side, id] = named;
+                at(id)[side].push(s);
                 // Blocks past the first follow the block, as accepting places them.
-                if (s.content.length > 1)
-                    at(where.end).after.push(s);
+                if (side === 'end' && s.content.length > 1)
+                    at(id).after.push(s);
             }
-            else {
+            else if ('replace' in where) {
                 const ids = this.#blocks(where);
                 if (Array.isArray(where.replace)) {
                     const inPlace = ids.every((id) => this.edytor.idToBlock.get(id)?.isEmpty);
@@ -265,36 +257,43 @@ export class Suggestions {
         const block = (target && edytor.idToBlock.get(target)) || edytor.root;
         const payload = { suggestion: { id: suggestion.id, at, content: suggestion.content } };
         const out = edytor.dispatcher.dispatch('acceptSuggestion', payload, { block }, (_payload, plan = prepare()) => {
-            const caret = applyAt(edytor, plan);
-            return range && caret ? applyAt(edytor, place(caret)) : caret;
+            /** Write a stage in the command; answers the caret it decides. */
+            const write = (plan) => {
+                if (!('writes' in plan) || !plan.at)
+                    return null;
+                edytor.dispatcher.write(plan);
+                return plan.at;
+            };
+            const caret = write(plan);
+            return range && caret ? write(place(caret)) : caret;
         }, prepare);
         if (out === undefined || (out === null && edytor.dispatcher.last?.status === 'refused'))
             return REFUSED;
         this.drop(suggestion);
         if (out)
-            edytor.dispatcher.caret(...caretOf.call(edytor, out));
+            edytor.dispatcher.caret(out);
         const status = edytor.dispatcher.last?.status === 'applied' ? 'applied' : 'noop';
         return { status, ids: status === 'applied' ? ids : [] };
     };
     /** The flow target of a block position (at an `end`, the first block's content joins the text). */
     #target = (at, flow) => {
         const { facade } = this.edytor;
-        if ('end' in at) {
+        const [side, id] = sideOf(at) ?? [];
+        if (side === 'end') {
             const [first, ...rest] = flow.lines;
             if (first)
                 flow.lines = [
                     { id: first.id, content: first.content, children: first.children },
                     ...rest
                 ];
-            return { block: at.end, offset: facade.displayLength(at.end) };
+            return { block: id, offset: facade.displayLength(id) };
         }
-        if ('replace' in at)
+        if (!id)
             return { replace: at.replace };
-        if ('inside' in at)
-            return { slot: { parent: at.inside, index: facade.childrenIds(at.inside).length } };
-        const id = 'after' in at ? at.after : at.before;
+        if (side === 'inside')
+            return { slot: { parent: id, index: facade.childrenIds(id).length } };
         const { parent, index } = facade.positionOf(id) ?? { parent: null, index: 0 };
-        return { slot: { parent, index: index + ('after' in at ? 1 : 0) } };
+        return { slot: { parent, index: index + (side === 'after' ? 1 : 0) } };
     };
     /** A range's endpoints in document order, or null when one no longer resolves. */
     #range = ({ anchor, focus }) => {
@@ -303,17 +302,13 @@ export class Suggestions {
     };
     /** The blocks a position names (a range: its endpoints' blocks). */
     #blocks = (at) => {
-        if ('after' in at)
-            return [at.after];
-        if ('before' in at)
-            return [at.before];
-        if ('inside' in at)
-            return [at.inside];
-        if ('end' in at)
-            return [at.end];
-        if (Array.isArray(at.replace))
-            return [...at.replace];
-        const range = this.#range(at.replace);
+        const named = sideOf(at);
+        if (named)
+            return [named[1]];
+        const { replace } = at;
+        if (Array.isArray(replace))
+            return [...replace];
+        const range = this.#range(replace);
         return range ? [range.start.block, range.end.block] : [];
     };
     #alive = (at) => {

package/dist/session/uploads.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The view's uploads as the other layers see them: the one per view the
+ * first media plugin given an `upload` claims (`uploadHooks`), and whether it takes a
+ * file (a kind's `upload` accepts it). A file dragged over the view shows
+ * where it lands only when its uploads take it (`drop`, the plugin layer's
+ * `plugins/fileDrop.ts`); a view without uploads ignores dropped files.
+ */
+import type { Edytor } from '../edytor.svelte.js';
+import type { DropAt } from './attempt.js';
+/** Files dragged from outside over the view: where they land, shown. */
+export interface FileDropPort {
+    /** A `dragover` of files: show where they land; `false` where none does (nothing shows). */
+    over(event: DragEvent): boolean;
+    /** The drop: the placement shown, re-resolved at the drop point, and nothing shows any more. */
+    at(event: DragEvent): DropAt | null;
+    /** The drag left the view, or ended: nothing shows. */
+    end(): void;
+}
+/** What the view's uploads answer about a file. */
+export interface ViewUploads {
+    /** The kind that takes `file` (its record's `upload`), so a paste or a drop places it. */
+    kindOf(file: File): string | undefined;
+    /** Where dropped files land (the plugin layer's indicator). */
+    readonly drop: FileDropPort;
+}
+/** The view's uploads, when a plugin claimed them. */
+export declare const viewUploads: (edytor: Edytor | undefined) => ViewUploads | undefined;
+/** Claim the view's uploads for `uploads`: the first claim wins (`false` after it). */
+export declare const claimUploads: (edytor: Edytor, uploads: ViewUploads) => boolean;

package/dist/session/uploads.js

@@ -0,0 +1,10 @@
+const views = new WeakMap();
+/** The view's uploads, when a plugin claimed them. */
+export const viewUploads = (edytor) => edytor && views.get(edytor);
+/** Claim the view's uploads for `uploads`: the first claim wins (`false` after it). */
+export const claimUploads = (edytor, uploads) => {
+    if (views.has(edytor))
+        return false;
+    views.set(edytor, uploads);
+    return true;
+};

package/dist/session/virtual.d.ts

@@ -14,14 +14,14 @@
  * through to the document; its JSON never shows the virtual paragraph.
  */
 import type { BlockId } from '../crdt/index.js';
-import type { EdytorDoc } from '../crdt/edytor-doc.js';
+import type { DocFacade } from '../crdt/edytor-doc.js';
 /** A virtual paragraph's id (materialized blocks keep theirs): what a peer's caret names. */
 export declare const isVirtualId: (value: string) => boolean;
 /** The document as a view reads it: `virtual()` names the shown virtual paragraph, if any. */
-export type ViewDoc = EdytorDoc & {
+export type ViewDoc = DocFacade & {
     virtual: () => BlockId | null;
 };
-export declare const virtualLens: (base: EdytorDoc, 
+export declare const virtualLens: (base: DocFacade, 
 /** The document decided its content (a pending document shows nothing). */
 ready: () => boolean, 
 /** The root's default child type. */

package/dist/session/virtual.js

@@ -1,11 +1,10 @@
 import { placedEnd } from '../crdt/flow.js';
-import { bindNodes } from '../crdt/nodes.js';
 import { applyPatch } from '../crdt/data.js';
+import { REFUSED } from '../crdt/doc/plan.js';
 import { id } from '../utils.js';
 import { asBlockSpec } from '../utils/json.js';
 /** A virtual paragraph's id (materialized blocks keep theirs): what a peer's caret names. */
 export const isVirtualId = (value) => value.startsWith('v_');
-const REFUSED = Object.freeze({ status: 'refused', ids: [] });
 export const virtualLens = (base, 
 /** The document decided its content (a pending document shows nothing). */
 ready, 
@@ -61,33 +60,24 @@ roleOf) => {
         const own = base.prepare[name];
         prepare[name] = (...args) => when(...args) ?? own(...args);
     };
-    over('insertText', (b, _o, text, marks) => on(b)
-        ? text
-            ? create([spec({ content: [{ kind: 'text', text, marks }] })])
-            : noop()
-        : undefined);
-    over('insertInline', (b, _o, atom) => on(b) ? create([spec({ content: [{ kind: 'inline', ...atom }] })]) : undefined);
-    over('splitBlock', (b, _o, newId, tail) => on(b)
-        ? create([spec(), { id: newId, type: tail?.type ?? type(), data: tail?.data }])
-        : undefined);
-    over('setBlockType', (b, t) => (on(b) ? create([spec({ type: t })]) : undefined));
-    over('setBlockData', (b, data) => (on(b) ? create([spec({ data })]) : undefined));
-    over('patchData', (t, ops) => {
-        if (typeof t !== 'string' || !on(t))
-            return undefined;
+    const onIt = (name, when) => {
+        const plan = when;
+        over(name, (b, ...rest) => (on(b) ? plan(...rest) : undefined));
+    };
+    onIt('insertText', (_o, text, marks) => text ? create([spec({ content: [{ kind: 'text', text, marks }] })]) : noop());
+    onIt('insertInline', (_o, atom) => create([spec({ content: [{ kind: 'inline', ...atom, id: atom.id ?? id('i') }] })]));
+    onIt('splitBlock', (_o, newId, tail) => create([spec(), { id: newId, type: tail?.type ?? type(), data: tail?.data }]));
+    onIt('setBlockType', (t) => create([spec({ type: t })]));
+    onIt('patchData', (ops) => {
         const data = applyPatch({}, ops);
         return data ? create([spec({ data })]) : REFUSED;
     });
-    over('setBlock', (b, value) => on(b)
-        ? create([spec({ ...value, type: value.type ?? type() })])
-        : undefined);
-    // Enter at its end builds after it: the line is kept. What goes before it replaces it.
+    onIt('setBlock', (value) => create([spec({ ...value, type: value.type ?? type() })]));
     over('insertBlocks', (dest, specs) => {
         if (specs.length > 0 && dest.parent === null && dest.index > 0 && active())
             return create([spec(), ...specs.map(asBlockSpec)]);
         return on(dest.parent) ? create([spec({ children: specs.map(asBlockSpec) })]) : undefined;
     });
-    over('insertBlock', (dest, s) => prepare.insertBlocks(dest, [s]));
     over('insertFlow', (target, flow) => {
         if ('replace' in target)
             return target.replace.some(on) ? flowInto(flow, false) : undefined;
@@ -103,53 +93,41 @@ roleOf) => {
     for (const name of [
         'deleteText',
         'formatRange',
-        'setMark',
-        'unsetMark',
         'clearMarks',
         'removeInline',
-        'setInlineData',
         'mergeBackward',
         'mergeForward',
         'deleteBlock'
     ])
-        over(name, (b, ..._) => (on(b) ? noop() : undefined));
+        onIt(name, noop);
     over('deleteBlocks', (ids) => ids.some(on) ? prepare.deleteBlocks(ids.filter((i) => !on(i))) : undefined);
-    for (const name of ['moveBlock', 'nestBlock', 'unNestBlock', 'duplicateBlock'])
-        over(name, (b, ..._) => (on(b) ? REFUSED : undefined));
+    // A move, nest, outdent or duplicate of it is refused: the document holds no such block.
     const lens = Object.create(base);
     const ops = Object.fromEntries(Object.keys(base.prepare).map((name) => [
         name,
         (...args) => base.apply(prepare[name](...args))
     ]));
-    let nodes;
     Object.assign(lens, ops, {
         prepare,
         virtual: () => (active() ? vid : null),
-        block: (b) => (nodes ??= bindNodes(lens)).block(b),
         // ── reads ────────────────────────────────────────────────────────
+        // The document answers an id it does not hold as a block with no
+        // parent, ancestors, neighbours, children, content, data items or
+        // place to move to or merge with: those reads pass through.
         project: () => (active() ? { children: [projected()] } : base.project()),
-        childrenIds: (p) => p === null && active() ? [vid] : on(p) ? [] : base.childrenIds(p),
+        childrenIds: (p) => (p === null && active() ? [vid] : base.childrenIds(p)),
         childSlots: (p) => p === null && active() ? [{ id: vid, rank: '' }] : base.childSlots(p),
         order: () => (active() ? [vid] : base.order()),
         slotOf: (b) => (on(b) ? { parent: null, rank: '' } : base.slotOf(b)),
         positionOf: (b) => (on(b) ? { parent: null, index: 0 } : base.positionOf(b)),
         pathOf: (b) => (on(b) ? [0] : base.pathOf(b)),
-        parentOf: (b) => (on(b) ? null : base.parentOf(b)),
-        ancestorsOf: (b) => (on(b) ? [] : base.ancestorsOf(b)),
         isVisibleBlock: (b) => on(b) || base.isVisibleBlock(b),
-        compare: (a, b) => (on(a) && on(b) ? 0 : base.compare(a, b)),
-        next: (b, ...rest) => (on(b) ? null : base.next(b, ...rest)),
-        previous: (b, ...rest) => on(b) ? null : base.previous(b, ...rest),
         blockTypeOf: (b) => (on(b) ? type() : base.blockTypeOf(b)),
         blockDataOf: (b) => (on(b) ? {} : base.blockDataOf(b)),
-        dataItemIds: (t, path) => typeof t === 'string' && on(t) ? [] : base.dataItemIds(t, path),
         blockJSON: (b) => (on(b) ? { id: vid, type: type(), data: {} } : base.blockJSON(b)),
         blockText: (b) => (on(b) ? '' : base.blockText(b)),
-        displayLength: (b) => (on(b) ? 0 : base.displayLength(b)),
-        contentItems: (b) => (on(b) ? [] : base.contentItems(b)),
+        // Never computed (and cached) by the index for an id it does not hold.
         runs: (b) => (on(b) ? [] : base.runs(b)),
-        canPlace: (ids, parent) => !ids.some(on) && !on(parent) && base.canPlace(ids, parent),
-        canMerge: (from, into) => !on(from) && !on(into) && base.canMerge(from, into),
         anchorAt: (b, offset, affinity = 'left') => on(b)
             ? { b: vid, a: { i: null, a: affinity === 'left' ? -1 : 0 } }
             : base.anchorAt(b, offset, affinity),

package/dist/surface/attributes.d.ts

@@ -41,6 +41,7 @@ export declare const ownedOf: (edytor: Edytor, element: Element, entry: {
     kind: Kind;
     block: string;
     name?: string;
+    owned?: () => Owned;
 } | null) => Owned | null;
 /** Heal `element` against `table`; answers whether anything was written. */
 export declare const heal: (element: HTMLElement, table: Owned) => boolean;