@next-buildr/editor 0.0.0-stage → 2.0.0

package/dist/canvas-host/host.test.js

@@ -0,0 +1,398 @@
+import { createRegistryMeta, createSeededIdGenerator, p, s, } from '@next-buildr/core';
+import { createChildTransport, createParentTransport, } from '@next-buildr/core/protocol';
+import { describe, expect, it, vi } from 'vitest';
+import { DEFAULT_BREAKPOINTS } from '../app/config.js';
+import { createEditorStore } from '../store/index.js';
+import { createCanvasHost } from './host.js';
+const SESSION = 'abcDEF0123456789_-xyz';
+const EDITOR = 'https://editor.example.com';
+const CANVAS = 'https://canvas.example.com';
+const HASH = 'manifest-hash';
+const mods = { shift: false, alt: false, ctrl: false, meta: false };
+/** A window with an origin: posting to it delivers to its own listeners, from the peer. */
+class FakeWindow {
+    origin;
+    listeners = new Set();
+    peer;
+    handle = {
+        postMessage: (message, targetOrigin) => {
+            if (targetOrigin !== this.origin || this.peer === undefined)
+                return;
+            const event = {
+                data: structuredClone(message),
+                origin: this.peer.origin,
+                source: this.peer.handle,
+            };
+            for (const listener of [...this.listeners])
+                listener(event);
+        },
+    };
+    constructor(origin) {
+        this.origin = origin;
+    }
+    addEventListener(_type, listener) {
+        this.listeners.add(listener);
+    }
+    removeEventListener(_type, listener) {
+        this.listeners.delete(listener);
+    }
+}
+const node = (id, type, extra = {}) => ({
+    id,
+    type,
+    ...extra,
+});
+const fixture = () => ({
+    schemaVersion: 1,
+    root: 'root',
+    nodes: {
+        root: node('root', 'buildr/page', { slots: { default: ['boxNode001'] } }),
+        boxNode001: node('boxNode001', 'buildr/box', {
+            slots: { default: ['textNodeA1', 'textNodeB1'] },
+        }),
+        textNodeA1: node('textNodeA1', 'buildr/text', { props: { text: s('A') } }),
+        textNodeB1: node('textNodeB1', 'buildr/text', { props: { text: s('B') } }),
+    },
+    components: {},
+});
+const meta = (type, overrides = {}) => ({
+    type,
+    version: 1,
+    label: type,
+    category: 'content',
+    props: {},
+    contentCategories: ['flow'],
+    styles: { groups: [] },
+    runtime: 'shared',
+    ...overrides,
+});
+const registry = createRegistryMeta({
+    components: [
+        meta('buildr/page', { capabilities: { root: true }, slots: { default: {} } }),
+        meta('buildr/box', { slots: { default: {} } }),
+        meta('buildr/text', { props: { text: p.text({ default: '' }) } }),
+    ],
+});
+const locales = { locales: ['en', 'pl'], default: 'en', fallback: true, intl: {} };
+/** Frames that run when the test says so. */
+function manualFrames() {
+    const callbacks = [];
+    const frames = {
+        request: (cb) => callbacks.push(cb),
+        cancel: () => { },
+    };
+    return {
+        frames,
+        pending: () => callbacks.length,
+        run() {
+            for (const cb of callbacks.splice(0))
+                cb();
+        },
+    };
+}
+function manualTimers() {
+    const tasks = new Map();
+    let next = 1;
+    return {
+        timers: {
+            setTimeout: (cb) => {
+                tasks.set(next, cb);
+                return next++;
+            },
+            clearTimeout: (handle) => void tasks.delete(handle),
+        },
+        fire: () => {
+            for (const [id, cb] of [...tasks]) {
+                tasks.delete(id);
+                cb();
+            }
+        },
+    };
+}
+function setup(overrides = {}, canvasHash = HASH) {
+    const editorWindow = new FakeWindow(EDITOR);
+    const canvasWindow = new FakeWindow(CANVAS);
+    editorWindow.peer = canvasWindow;
+    canvasWindow.peer = editorWindow;
+    const store = createEditorStore({
+        doc: fixture(),
+        registry,
+        generateId: createSeededIdGenerator(5),
+        validationDelayMs: null,
+    });
+    const frames = manualFrames();
+    const clock = manualTimers();
+    const rejections = [];
+    let host;
+    const transport = createParentTransport({
+        iframe: { contentWindow: canvasWindow.handle },
+        canvasOrigin: CANVAS,
+        session: SESSION,
+        host: editorWindow,
+        onReject: (r) => {
+            rejections.push(r);
+            host?.handleReject(r);
+        },
+    });
+    host = createCanvasHost({
+        store,
+        transport,
+        manifestHash: HASH,
+        locales,
+        breakpoints: DEFAULT_BREAKPOINTS,
+        frames: frames.frames,
+        timers: clock.timers,
+        ...overrides,
+    });
+    const received = [];
+    const connect = (hash = canvasHash) => {
+        const child = createChildTransport({
+            allowedOrigins: [EDITOR],
+            session: SESSION,
+            host: canvasWindow,
+            parent: editorWindow.handle,
+        });
+        for (const type of [
+            'editor:init',
+            'doc:patch',
+            'doc:set',
+            'selection:set',
+            'hover:set',
+            'viewport:set',
+            'locale:set',
+            'mode:set',
+        ]) {
+            child.on(type, (payload) => received.push({ type, payload }));
+        }
+        child.send('canvas:hello', { protocol: 1, rendererVersion: '1.0.0', manifestHash: hash });
+        return child;
+    };
+    return { store, host, connect, frames, clock, received, rejections, editorWindow, canvasWindow };
+}
+const types = (received) => received.map((m) => m.type);
+const click = (id, extra = {}) => ({
+    id,
+    modifiers: { ...mods, ...extra },
+});
+describe('the handshake', () => {
+    it('answers a hello with the store as it is, and is ready when the canvas says so', () => {
+        const { store, host, connect, received } = setup();
+        store.select('textNodeA1');
+        expect(host.state.getState().status).toBe('connecting');
+        const child = connect();
+        expect(host.state.getState().status).toBe('initializing');
+        const [init] = received;
+        expect(init?.type).toBe('editor:init');
+        expect(init?.payload).toMatchObject({
+            docVersion: 0,
+            selection: ['textNodeA1'],
+            viewport: { breakpoint: 'desktop', width: 1280 },
+            locale: 'en',
+            mode: 'edit',
+        });
+        child.send('canvas:ready', {});
+        expect(host.state.getState().status).toBe('ready');
+        host.destroy();
+    });
+    it('shows an error for a canvas of other components, and recovers with a right one', () => {
+        const { host, connect } = setup({}, 'other-hash');
+        const wrong = connect();
+        expect(host.state.getState().status).toBe('error');
+        expect(host.state.getState().error).toMatchObject({ kind: 'manifest' });
+        wrong.close();
+        connect(HASH);
+        expect(host.state.getState().status).toBe('initializing');
+        expect(host.state.getState().error).toBeUndefined();
+        host.destroy();
+    });
+    it('shows a timeout when no canvas answers', () => {
+        const { host, clock } = setup();
+        clock.fire();
+        expect(host.state.getState().error?.kind).toBe('timeout');
+        host.destroy();
+    });
+    it('names a canvas of another protocol version', () => {
+        const { host, editorWindow, canvasWindow } = setup();
+        for (const listener of [...editorWindow.listeners]) {
+            listener({
+                origin: CANVAS,
+                source: canvasWindow.handle,
+                data: {
+                    source: 'buildr',
+                    protocol: 2,
+                    session: SESSION,
+                    type: 'canvas:hello',
+                    payload: { protocol: 2, rendererVersion: '1', manifestHash: HASH },
+                },
+            });
+        }
+        expect(host.state.getState().error).toMatchObject({
+            kind: 'protocol',
+            details: { editor: 1, canvas: 2 },
+        });
+        host.destroy();
+    });
+});
+describe('sending changes', () => {
+    it('batches the patches of one frame into a single doc:patch', () => {
+        const { store, host, connect, frames, received } = setup();
+        connect().send('canvas:ready', {});
+        received.length = 0;
+        store.dispatch({
+            type: 'node.setProp',
+            payload: { id: 'textNodeA1', prop: 'text', value: s('One') },
+        });
+        store.dispatch({
+            type: 'node.setProp',
+            payload: { id: 'textNodeB1', prop: 'text', value: s('Two') },
+        });
+        expect(received).toHaveLength(0);
+        expect(frames.pending()).toBe(1);
+        frames.run();
+        expect(types(received)).toEqual(['doc:patch']);
+        expect(received[0]?.payload).toMatchObject({ from: 0, to: 2 });
+        host.destroy();
+    });
+    it('sends the whole document after a replacement, and on a resync request', () => {
+        const { store, host, connect, frames, received } = setup();
+        const child = connect();
+        child.send('canvas:ready', {});
+        received.length = 0;
+        store.dispatch({
+            type: 'node.setProp',
+            payload: { id: 'textNodeA1', prop: 'text', value: s('One') },
+        });
+        store.replaceDocument(fixture());
+        frames.run();
+        expect(types(received)).toEqual(['doc:set']);
+        expect(received[0]?.payload).toMatchObject({ docVersion: 2 });
+        received.length = 0;
+        child.send('doc:resync-request', { have: 1 });
+        expect(types(received)).toEqual(['doc:set']);
+        host.destroy();
+    });
+    it('sends selection and hover at once, and only when they change', () => {
+        const { store, host, connect, received } = setup();
+        connect().send('canvas:ready', {});
+        received.length = 0;
+        store.select('textNodeA1');
+        store.setHovered('textNodeB1');
+        store.setHovered('textNodeB1');
+        expect(received.map((m) => [m.type, m.payload])).toEqual([
+            ['selection:set', { ids: ['textNodeA1'] }],
+            ['hover:set', { id: 'textNodeB1' }],
+        ]);
+        host.destroy();
+    });
+    it('does not send anything to a canvas that is not there yet, and inits it with the latest', () => {
+        const { store, host, connect, frames, received } = setup();
+        store.dispatch({
+            type: 'node.setProp',
+            payload: { id: 'textNodeA1', prop: 'text', value: s('Early') },
+        });
+        frames.run();
+        connect();
+        expect(types(received)).toEqual(['editor:init']);
+        expect(received[0]?.payload).toMatchObject({ docVersion: 1 });
+        host.destroy();
+    });
+    it('a canvas that reloads is initialized again, with nothing lost', () => {
+        const { store, host, connect, received } = setup();
+        const first = connect();
+        first.send('canvas:ready', {});
+        store.select('textNodeB1');
+        first.close();
+        received.length = 0;
+        connect();
+        expect(received[0]?.type).toBe('editor:init');
+        expect(received[0]?.payload).toMatchObject({ selection: ['textNodeB1'] });
+        expect(host.state.getState().connections).toBe(2);
+        host.destroy();
+    });
+    it('sends the viewport, locale, mode and context when they change', () => {
+        const { host, connect, received } = setup();
+        connect().send('canvas:ready', {});
+        received.length = 0;
+        host.setBreakpoint('mobile');
+        host.setLocale('pl');
+        host.setLocale('xx');
+        host.setMode('interact');
+        expect(received.map((m) => [m.type, m.payload])).toEqual([
+            ['viewport:set', { breakpoint: 'mobile', width: 390 }],
+            ['locale:set', { locale: 'pl' }],
+            ['mode:set', { mode: 'interact' }],
+        ]);
+        host.destroy();
+    });
+});
+describe('what the canvas reports', () => {
+    it('a click selects, with Shift adding and Ctrl toggling', () => {
+        const { store, host, connect } = setup();
+        const child = connect();
+        child.send('node:click', { ...click('textNodeA1'), instance: 'loop:1' });
+        expect(store.getState().selectedIds).toEqual(['textNodeA1']);
+        expect(store.getState().selectedInstance).toBe('loop:1');
+        child.send('node:click', click('textNodeB1', { shift: true }));
+        expect(store.getState().selectedIds).toEqual(['textNodeA1', 'textNodeB1']);
+        child.send('node:click', click('textNodeA1', { ctrl: true }));
+        expect(store.getState().selectedIds).toEqual(['textNodeB1']);
+        child.send('node:hover', click('boxNode001'));
+        expect(store.getState().hoveredId).toBe('boxNode001');
+        host.destroy();
+    });
+    it('an inline edit becomes node.setProp, in the current locale', () => {
+        const { store, host, connect } = setup();
+        const child = connect();
+        child.send('inline:commit', { id: 'textNodeA1', prop: 'text', value: 'Edited' });
+        expect(JSON.stringify(store.getState().doc.nodes['textNodeA1']?.props?.['text'])).toContain('Edited');
+        expect(store.getState().undoLabel).toBe('inline-edit');
+        host.destroy();
+    });
+    it('a move intent becomes node.move; a refused command is reported', () => {
+        const onCommandError = vi.fn();
+        const { store, host, connect } = setup({ onCommandError });
+        const child = connect();
+        child.send('intent:move', {
+            ids: ['textNodeB1'],
+            target: { parentId: 'boxNode001', slot: 'default', index: 0 },
+        });
+        expect(store.getState().doc.nodes['boxNode001']?.slots?.['default']).toEqual([
+            'textNodeB1',
+            'textNodeA1',
+        ]);
+        child.send('inline:commit', { id: 'ghostNode1', prop: 'text', value: 'x' });
+        expect(onCommandError).toHaveBeenCalledTimes(1);
+        host.destroy();
+    });
+    it('forwards keys, the context menu and drop targets, and keeps diagnostics', () => {
+        const onKeyDown = vi.fn();
+        const onContextMenu = vi.fn();
+        const onDropTarget = vi.fn();
+        const { host, connect } = setup({ onKeyDown, onContextMenu, onDropTarget });
+        const child = connect();
+        child.send('key:down', { key: 'z', code: 'KeyZ', mods: { ...mods, ctrl: true } });
+        child.send('contextmenu', { id: 'textNodeA1', point: { x: 1, y: 2 } });
+        child.send('dnd:target', { target: null });
+        child.send('diagnostics', {
+            items: [{ code: 'x', message: 'y', severity: 'warning' }],
+        });
+        expect(onKeyDown).toHaveBeenCalledOnce();
+        expect(onContextMenu).toHaveBeenCalledOnce();
+        expect(onDropTarget).toHaveBeenCalledWith({ target: null });
+        expect(host.state.getState().diagnostics).toHaveLength(1);
+        host.destroy();
+    });
+    it('a fatal canvas error shows the error screen; a non-fatal one does not', () => {
+        const { host, connect } = setup();
+        const child = connect();
+        child.send('canvas:ready', {});
+        child.send('canvas:error', { message: 'a node broke', fatal: false });
+        expect(host.state.getState().status).toBe('ready');
+        child.send('canvas:error', { message: 'boom', fatal: true });
+        expect(host.state.getState()).toMatchObject({
+            status: 'error',
+            error: { kind: 'canvas', message: 'boom' },
+        });
+        host.destroy();
+    });
+});

package/dist/canvas-host/index.d.ts

@@ -0,0 +1,5 @@
+export type { CanvasFrameProps } from './canvas-frame.tsx';
+export { CanvasFrame, canvasSource, createSession } from './canvas-frame.tsx';
+export type { CanvasError, CanvasErrorKind, CanvasFrames, CanvasHost, CanvasHostOptions, CanvasHostState, CanvasMode, CanvasStatus, LocalesConfig, } from './host.ts';
+export { createCanvasHost, DEFAULT_HANDSHAKE_TIMEOUT_MS } from './host.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/canvas-host/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/canvas-host/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC9E,YAAY,EACV,WAAW,EACX,eAAe,EACf,YAAY,EACZ,UAAU,EACV,iBAAiB,EACjB,eAAe,EACf,UAAU,EACV,YAAY,EACZ,aAAa,GACd,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,gBAAgB,EAAE,4BAA4B,EAAE,MAAM,WAAW,CAAC"}

package/dist/canvas-host/index.js

@@ -0,0 +1,2 @@
+export { CanvasFrame, canvasSource, createSession } from './canvas-frame.js';
+export { createCanvasHost, DEFAULT_HANDSHAKE_TIMEOUT_MS } from './host.js';

package/dist/clipboard/clipboard.d.ts

@@ -0,0 +1,38 @@
+import { type ComponentMigrations, type IdGenerator } from '@next-buildr/core';
+import type { EditorStore } from '../store/index.ts';
+import { type ClipboardError } from './format.ts';
+/** The system clipboard as far as the editor needs it; both calls may reject (no permission, no API). */
+export interface ClipboardIO {
+    writeText(text: string): Promise<void>;
+    readText(): Promise<string>;
+}
+/** `navigator.clipboard`, or `undefined` where there is none (an insecure context, a test). */
+export declare function browserClipboard(): ClipboardIO | undefined;
+export type ClipboardResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly error: ClipboardError;
+};
+export interface ClipboardOptions {
+    readonly store: EditorStore;
+    /** The system clipboard; the editor works without it, within this window only. */
+    readonly io?: ClipboardIO | undefined;
+    readonly generateId?: IdGenerator;
+    /** What brings a fragment copied under older component versions up to the registry; without it such a paste is refused. */
+    readonly migrations?: ComponentMigrations | undefined;
+}
+export interface Clipboard {
+    copy(): Promise<ClipboardResult>;
+    cut(): Promise<ClipboardResult>;
+    paste(): Promise<ClipboardResult>;
+}
+/**
+ * Copy, cut and paste of nodes (docs/editor.md#clipboard-pb-085). What is copied is a fragment
+ * (`extractFragment`) written as text with a marker; what is pasted is parsed, validated, given new
+ * ids and inserted with `node.insert`, which checks it against the rules of the target. Without
+ * access to the system clipboard the last copy is kept in memory. Paste can therefore never do more
+ * than any other insert: an invalid fragment or an illegal place is refused, not partly applied.
+ */
+export declare function createClipboard(options: ClipboardOptions): Clipboard;
+//# sourceMappingURL=clipboard.d.ts.map

package/dist/clipboard/clipboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.d.ts","sourceRoot":"","sources":["../../src/clipboard/clipboard.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAIxB,KAAK,WAAW,EAMjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,KAAK,cAAc,EAAyC,MAAM,aAAa,CAAC;AAEzF,yGAAyG;AACzG,MAAM,WAAW,WAAW;IAC1B,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CAC7B;AAED,+FAA+F;AAC/F,wBAAgB,gBAAgB,IAAI,WAAW,GAAG,SAAS,CAO1D;AAED,MAAM,MAAM,eAAe,GACvB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAA;CAAE,GACrB;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAA;CAAE,CAAC;AAE3D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,kFAAkF;IAClF,QAAQ,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC;IAClC,2HAA2H;IAC3H,QAAQ,CAAC,UAAU,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACvD;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;IACjC,GAAG,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;IAChC,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;CACnC;AAyDD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAyFpE"}

package/dist/clipboard/clipboard.js

@@ -0,0 +1,160 @@
+import { createIndex, extractFragment, generateId, isAncestor, migrateFragment, registryVersions, reId, } from '@next-buildr/core';
+import { parseClipboardText, serializeFragment } from './format.js';
+/** `navigator.clipboard`, or `undefined` where there is none (an insecure context, a test). */
+export function browserClipboard() {
+    if (typeof navigator === 'undefined' || navigator.clipboard === undefined)
+        return undefined;
+    const clipboard = navigator.clipboard;
+    return {
+        writeText: (text) => clipboard.writeText(text),
+        readText: () => clipboard.readText(),
+    };
+}
+const fail = (error) => ({ ok: false, error });
+const OK = { ok: true };
+/** The selected nodes to copy, in document order, without the ones whose ancestor is selected too. */
+function copyable(store) {
+    const { doc, selectedIds } = store.getState();
+    const rank = new Map(createIndex(doc).order.map((id, position) => [id, position]));
+    const wanted = selectedIds.filter((id) => id !== doc.root && Object.hasOwn(doc.nodes, id));
+    return wanted
+        .filter((id) => !wanted.some((other) => other !== id && isAncestor(doc, other, id)))
+        .sort((a, b) => (rank.get(a) ?? 0) - (rank.get(b) ?? 0));
+}
+/**
+ * Where a paste could go, best first: after the selected node, inside it, then after each of its
+ * ancestors, and finally at the end of the page. The first place the rules accept wins.
+ */
+function pasteTargets(store) {
+    const { doc, anchorId } = store.getState();
+    const index = createIndex(doc);
+    const endOf = (parentId, slot) => doc.nodes[parentId]?.slots?.[slot]?.length ?? 0;
+    const after = (id) => {
+        const parentId = index.parentOf[id];
+        const slot = index.slotOf[id];
+        const position = index.indexOf[id];
+        return parentId === undefined || slot === undefined || position === undefined
+            ? undefined
+            : { parentId, slot, index: position + 1 };
+    };
+    const targets = [];
+    if (anchorId !== null && anchorId !== doc.root && doc.nodes[anchorId] !== undefined) {
+        const next = after(anchorId);
+        if (next !== undefined)
+            targets.push(next);
+        const slots = new Set(['default', ...Object.keys(doc.nodes[anchorId]?.slots ?? {})]);
+        for (const slot of slots)
+            targets.push({ parentId: anchorId, slot, index: endOf(anchorId, slot) });
+        for (let up = index.parentOf[anchorId]; up !== undefined && up !== doc.root; up = index.parentOf[up]) {
+            const outer = after(up);
+            if (outer !== undefined)
+                targets.push(outer);
+        }
+    }
+    targets.push({ parentId: doc.root, slot: 'default', index: endOf(doc.root, 'default') });
+    return targets;
+}
+/**
+ * Copy, cut and paste of nodes (docs/editor.md#clipboard-pb-085). What is copied is a fragment
+ * (`extractFragment`) written as text with a marker; what is pasted is parsed, validated, given new
+ * ids and inserted with `node.insert`, which checks it against the rules of the target. Without
+ * access to the system clipboard the last copy is kept in memory. Paste can therefore never do more
+ * than any other insert: an invalid fragment or an illegal place is refused, not partly applied.
+ */
+export function createClipboard(options) {
+    const { store, io } = options;
+    const idGenerator = options.generateId ?? generateId;
+    let memory;
+    async function copy() {
+        const ids = copyable(store);
+        if (ids.length === 0)
+            return fail({ code: 'empty' });
+        const text = serializeFragment(extractFragment(store.getState().doc, ids));
+        memory = text;
+        try {
+            await io?.writeText(text);
+        }
+        catch {
+            // No permission or no API: the in-memory copy still serves this window.
+        }
+        return OK;
+    }
+    async function readText() {
+        if (io === undefined)
+            return memory;
+        try {
+            return await io.readText();
+        }
+        catch {
+            return memory;
+        }
+    }
+    /** The fragment as the running registry knows it, or `undefined` when it is outdated and cannot be migrated. */
+    function current(fragment) {
+        const versions = registryVersions(store.registry);
+        // The nodes count too: a type left out of `components` must not slip past the check.
+        const outdated = (candidate) => Object.entries(candidate.components).some(([type, version]) => versions[type] !== version) ||
+            Object.values(candidate.nodes).some(({ type }) => versions[type] === undefined || candidate.components[type] !== versions[type]);
+        if (!outdated(fragment))
+            return fragment;
+        if (options.migrations === undefined)
+            return undefined;
+        try {
+            const migrated = migrateFragment(fragment, options.migrations);
+            // Still not what the registry serves (a type nothing migrates): refuse rather than guess.
+            return migrated.readOnlyReasons.length === 0 && !outdated(migrated.fragment)
+                ? migrated.fragment
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function insert(source) {
+        const fragment = current(source);
+        if (fragment === undefined)
+            return fail({ code: 'outdated' });
+        let fresh;
+        try {
+            fresh = reId(fragment, idGenerator);
+        }
+        catch {
+            // A child that is not in the fragment: the shape passed, the tree does not hold together.
+            return fail({ code: 'invalid' });
+        }
+        let firstError;
+        for (const target of pasteTargets(store)) {
+            const result = store.dispatch({
+                type: 'node.insert',
+                payload: { ...target, fragment: fresh },
+            });
+            if (result.ok)
+                return OK;
+            firstError ??= result.error.message;
+        }
+        return fail({ code: 'rejected', detail: firstError });
+    }
+    return {
+        copy,
+        async cut() {
+            if (store.getState().readOnly)
+                return fail({ code: 'readOnly' });
+            const copied = await copy();
+            if (!copied.ok)
+                return copied;
+            const removed = store.dispatch({ type: 'node.remove', payload: { ids: copyable(store) } });
+            return removed.ok ? OK : fail({ code: 'rejected', detail: removed.error.message });
+        },
+        async paste() {
+            if (store.getState().readOnly)
+                return fail({ code: 'readOnly' });
+            const text = await readText();
+            if (text === undefined)
+                return fail({ code: 'notFragment' });
+            const parsed = parseClipboardText(text);
+            if (!parsed.ok)
+                return parsed;
+            return insert(parsed.fragment);
+        },
+    };
+}

package/dist/clipboard/clipboard.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=clipboard.test.d.ts.map

package/dist/clipboard/clipboard.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.test.d.ts","sourceRoot":"","sources":["../../src/clipboard/clipboard.test.tsx"],"names":[],"mappings":""}