@next-buildr/editor 0.0.0-stage → 2.0.1

package/dist/clipboard/clipboard.test.js

@@ -0,0 +1,457 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @vitest-environment jsdom
+import { assertDocumentInvariants, createRegistryMeta, createSeededIdGenerator, p, s, } from '@next-buildr/core';
+import { act } from 'react';
+import { createRoot } from 'react-dom/client';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { MessagesProvider } from '../messages/index.js';
+import { ShortcutProvider } from '../shortcuts/index.js';
+import { createEditorStore, EditorStoreProvider } from '../store/index.js';
+import { ToastProvider } from '../ui/index.js';
+import { createClipboard } from './clipboard.js';
+import { CLIPBOARD_MARKER, MAX_CLIPBOARD_BYTES, parseClipboardText, serializeFragment, } from './format.js';
+import { ClipboardProvider, useClipboardActions } from './react.js';
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+const base = {
+    type: 'buildr/leaf',
+    version: 1,
+    label: 'Leaf',
+    category: 'content',
+    props: {},
+    contentCategories: ['flow'],
+    styles: { groups: [] },
+    runtime: 'shared',
+};
+const box = { ...base, type: 'buildr/box', label: 'Box', slots: { default: {} } };
+const page = (max) => ({
+    ...base,
+    type: 'buildr/page',
+    label: 'Page',
+    capabilities: { root: true },
+    slots: { default: max === undefined ? {} : { max } },
+});
+const registryOf = (max, leafVersion = 1) => createRegistryMeta({ components: [page(max), box, { ...base, version: leafVersion }] });
+const fixture = () => ({
+    schemaVersion: 1,
+    root: 'root',
+    nodes: {
+        root: { id: 'root', type: 'buildr/page', slots: { default: ['boxAAAAAA1', 'leafBBBBB1'] } },
+        boxAAAAAA1: { id: 'boxAAAAAA1', type: 'buildr/box', slots: { default: ['leafCCCCC1'] } },
+        leafBBBBB1: { id: 'leafBBBBB1', type: 'buildr/leaf' },
+        leafCCCCC1: { id: 'leafCCCCC1', type: 'buildr/leaf' },
+    },
+    components: { 'buildr/page': 1, 'buildr/box': 1, 'buildr/leaf': 1 },
+});
+const newStore = (options = {}) => createEditorStore({
+    doc: options.doc ?? fixture(),
+    registry: registryOf(options.max, options.leafVersion),
+    generateId: createSeededIdGenerator(11),
+    validationDelayMs: null,
+});
+/** A system clipboard that remembers the text. */
+function memoryIO() {
+    const io = {
+        text: '',
+        writeText: async (text) => {
+            io.text = text;
+        },
+        readText: async () => io.text,
+    };
+    return io;
+}
+const rootOrder = (store) => store.getState().doc.nodes['root']?.slots?.['default'] ?? [];
+const fragmentOf = (store, ids) => {
+    const clip = memoryIO();
+    return {
+        clip,
+        ready: (async () => {
+            store.setSelection(ids);
+            await createClipboard({ store, io: clip }).copy();
+            return clip.text;
+        })(),
+    };
+};
+describe('copy and paste', () => {
+    it('copies the selection as marked text and pastes it after the selected node', async () => {
+        const store = newStore();
+        const io = memoryIO();
+        const clipboard = createClipboard({ store, io, generateId: createSeededIdGenerator(21) });
+        store.select('leafBBBBB1');
+        expect(await clipboard.copy()).toEqual({ ok: true });
+        expect(io.text.startsWith(`${CLIPBOARD_MARKER}\n`)).toBe(true);
+        expect(await clipboard.paste()).toEqual({ ok: true });
+        const order = rootOrder(store);
+        expect(order).toHaveLength(3);
+        expect(order[1]).toBe('leafBBBBB1');
+        const [, , pasted] = [order[0], order[1], order[2]];
+        expect(pasted).not.toBe('leafBBBBB1');
+        expect(order[0]).toBe('boxAAAAAA1');
+        expect(store.getState().selectedIds).toEqual([order[2]]);
+        assertDocumentInvariants(store.getState().doc);
+    });
+    it('gives every paste its own ids', async () => {
+        const store = newStore();
+        const clipboard = createClipboard({ store, io: memoryIO() });
+        store.select('boxAAAAAA1');
+        await clipboard.copy();
+        await clipboard.paste();
+        await clipboard.paste();
+        const ids = Object.keys(store.getState().doc.nodes);
+        expect(new Set(ids).size).toBe(ids.length);
+        expect(ids).toHaveLength(4 + 2 * 2);
+        assertDocumentInvariants(store.getState().doc);
+    });
+    it('copies a container with its content, and never a node twice', async () => {
+        const store = newStore();
+        const io = memoryIO();
+        const clipboard = createClipboard({ store, io });
+        store.setSelection(['leafCCCCC1', 'boxAAAAAA1']);
+        await clipboard.copy();
+        const parsed = parseClipboardText(io.text);
+        expect(parsed.ok && parsed.fragment.roots).toEqual(['boxAAAAAA1']);
+        expect(parsed.ok && Object.keys(parsed.fragment.nodes).sort()).toEqual([
+            'boxAAAAAA1',
+            'leafCCCCC1',
+        ]);
+    });
+    it('cuts to the clipboard, and the cut can be undone', async () => {
+        const store = newStore();
+        const clipboard = createClipboard({ store, io: memoryIO() });
+        store.select('leafBBBBB1');
+        expect(await clipboard.cut()).toEqual({ ok: true });
+        expect(rootOrder(store)).toEqual(['boxAAAAAA1']);
+        store.select('boxAAAAAA1');
+        await clipboard.paste();
+        expect(rootOrder(store)).toHaveLength(2);
+        act(() => {
+            store.undo();
+            store.undo();
+        });
+        expect(rootOrder(store)).toEqual(['boxAAAAAA1', 'leafBBBBB1']);
+    });
+    it('pastes into a container when the selection cannot have a neighbour there', async () => {
+        const store = newStore({ max: 2 });
+        const clipboard = createClipboard({ store, io: memoryIO() });
+        store.select('leafBBBBB1');
+        await clipboard.copy();
+        // The page holds its two nodes already: after the selection is refused, inside a leaf is
+        // impossible, so the paste fails as a whole.
+        const result = await clipboard.paste();
+        expect(result.ok).toBe(false);
+        expect(rootOrder(store)).toHaveLength(2);
+        // Selecting the box gives another place: inside it.
+        store.select('boxAAAAAA1');
+        expect(await clipboard.paste()).toEqual({ ok: true });
+        expect(store.getState().doc.nodes['boxAAAAAA1']?.slots?.['default']).toHaveLength(2);
+    });
+    it('pastes at the end of the page with nothing selected', async () => {
+        const store = newStore();
+        const clipboard = createClipboard({ store, io: memoryIO() });
+        store.select('leafBBBBB1');
+        await clipboard.copy();
+        store.clearSelection();
+        await clipboard.paste();
+        expect(rootOrder(store)).toHaveLength(3);
+    });
+    it('refuses copying nothing, and cutting or pasting in a read-only document', async () => {
+        const store = newStore();
+        const clipboard = createClipboard({ store, io: memoryIO() });
+        expect(await clipboard.copy()).toEqual({ ok: false, error: { code: 'empty' } });
+        store.select('leafBBBBB1');
+        await clipboard.copy();
+        store.setReadOnly(true);
+        expect(await clipboard.cut()).toEqual({ ok: false, error: { code: 'readOnly' } });
+        expect(await clipboard.paste()).toEqual({ ok: false, error: { code: 'readOnly' } });
+        expect(rootOrder(store)).toHaveLength(2);
+    });
+    it('works within the window when the system clipboard cannot be used', async () => {
+        const denied = {
+            writeText: () => Promise.reject(new Error('denied')),
+            readText: () => Promise.reject(new Error('denied')),
+        };
+        for (const io of [denied, undefined]) {
+            const store = newStore();
+            const clipboard = createClipboard({ store, io });
+            store.select('leafBBBBB1');
+            expect(await clipboard.copy()).toEqual({ ok: true });
+            expect(await clipboard.paste()).toEqual({ ok: true });
+            expect(rootOrder(store)).toHaveLength(3);
+        }
+    });
+    it('pastes what was copied in another document', async () => {
+        const source = newStore();
+        const { clip, ready } = fragmentOf(source, ['boxAAAAAA1']);
+        await ready;
+        const other = newStore({
+            doc: {
+                schemaVersion: 1,
+                root: 'root',
+                nodes: { root: { id: 'root', type: 'buildr/page' } },
+                components: { 'buildr/page': 1 },
+            },
+        });
+        const clipboard = createClipboard({ store: other, io: clip });
+        expect(await clipboard.paste()).toEqual({ ok: true });
+        expect(Object.keys(other.getState().doc.nodes)).toHaveLength(3);
+        assertDocumentInvariants(other.getState().doc);
+    });
+    it('refuses a fragment whose components are of another version', async () => {
+        const source = newStore();
+        const { clip, ready } = fragmentOf(source, ['leafBBBBB1']);
+        await ready;
+        const newer = newStore({
+            leafVersion: 2,
+            doc: { ...fixture(), components: { ...fixture().components, 'buildr/leaf': 2 } },
+        });
+        const clipboard = createClipboard({ store: newer, io: clip });
+        const result = await clipboard.paste();
+        expect(result.ok).toBe(false);
+        expect(rootOrder(newer)).toHaveLength(2);
+    });
+});
+describe('hostile clipboard content', () => {
+    const marked = (body) => `${CLIPBOARD_MARKER}\n${body}`;
+    const valid = () => ({
+        format: 'buildr/fragment',
+        schemaVersion: 1,
+        components: { 'buildr/leaf': 1 },
+        roots: ['leafZZZZZ1'],
+        nodes: { leafZZZZZ1: { id: 'leafZZZZZ1', type: 'buildr/leaf' } },
+    });
+    const pasteText = async (text) => {
+        const store = newStore();
+        const before = JSON.stringify(store.getState().doc);
+        const io = memoryIO();
+        io.text = text;
+        const result = await createClipboard({ store, io }).paste();
+        expect(JSON.stringify(store.getState().doc)).toBe(before);
+        return result;
+    };
+    const code = (result) => result.ok ? 'ok' : result.error.code;
+    it('rejects text that is not ours', async () => {
+        expect(code(await pasteText('hello'))).toBe('notFragment');
+        expect(code(await pasteText('{"format":"buildr/fragment"}'))).toBe('notFragment');
+        expect(code(await pasteText(''))).toBe('notFragment');
+    });
+    it('rejects broken JSON, wrong shapes and other versions', async () => {
+        expect(code(await pasteText(marked('{not json')))).toBe('invalid');
+        expect(code(await pasteText(marked('null')))).toBe('invalid');
+        expect(code(await pasteText(marked('[]')))).toBe('invalid');
+        expect(code(await pasteText(marked('{"format":"buildr/fragment"}')))).toBe('invalid');
+        expect(code(await pasteText('buildr-fragment/2\n{}'))).toBe('unsupported');
+        expect(code(await pasteText('buildr-fragment/0\n{}'))).toBe('unsupported');
+        expect(code(await pasteText('buildr-fragment/'))).toBe('unsupported');
+    });
+    it('rejects content over the size limit before parsing it', async () => {
+        const huge = marked(`"${'x'.repeat(MAX_CLIPBOARD_BYTES)}"`);
+        expect(code(await pasteText(huge))).toBe('tooLarge');
+    });
+    it('rejects a fragment with a dangling child, without changing the document', async () => {
+        const fragment = {
+            format: 'buildr/fragment',
+            schemaVersion: 1,
+            components: { 'buildr/box': 1 },
+            roots: ['boxZZZZZZ1'],
+            nodes: {
+                boxZZZZZZ1: { id: 'boxZZZZZZ1', type: 'buildr/box', slots: { default: ['leafMISSING'] } },
+            },
+        };
+        expect(code(await pasteText(serializeFragment(fragment)))).toBe('invalid');
+    });
+    it('refuses an unknown component type as incompatible', async () => {
+        const fragment = {
+            format: 'buildr/fragment',
+            schemaVersion: 1,
+            components: { 'evil/script': 1 },
+            roots: ['evilAAAAA1'],
+            nodes: { evilAAAAA1: { id: 'evilAAAAA1', type: 'evil/script', props: { html: '<script>' } } },
+        };
+        // Unknown to the registry and with nothing to migrate it: refused before any command runs.
+        expect(code(await pasteText(serializeFragment(fragment)))).toBe('outdated');
+    });
+    it('rejects a known type that breaks the rules of the target through the command checks', async () => {
+        const fragment = {
+            format: 'buildr/fragment',
+            schemaVersion: 1,
+            components: { 'buildr/leaf': 1, 'buildr/page': 1 },
+            roots: ['pageEVIL01'],
+            nodes: { pageEVIL01: { id: 'pageEVIL01', type: 'buildr/page' } },
+        };
+        expect(code(await pasteText(serializeFragment(fragment)))).toBe('rejected');
+    });
+    it('is not moved by prototype pollution attempts', async () => {
+        const text = marked('{"format":"buildr/fragment","schemaVersion":1,"components":{},"roots":["leafAAAAA1"],' +
+            '"nodes":{"__proto__":{"polluted":true},"leafAAAAA1":{"id":"leafAAAAA1","type":"buildr/leaf"}},' +
+            '"__proto__":{"polluted":true}}');
+        await pasteText(text);
+        expect({}['polluted']).toBeUndefined();
+    });
+    it('keeps the document valid whatever is thrown at it', async () => {
+        const base = valid();
+        // The unchanged fragment is fine, so each variant below fails for its own change.
+        const fine = newStore();
+        const io = memoryIO();
+        io.text = marked(JSON.stringify(base));
+        expect(await createClipboard({ store: fine, io }).paste()).toEqual({ ok: true });
+        const variants = [
+            { ...base, roots: [] },
+            { ...base, roots: ['root'] },
+            { ...base, extra: 1 },
+            { ...base, schemaVersion: 2 },
+            { ...base, nodes: {} },
+        ];
+        for (const variant of variants) {
+            const result = await pasteText(marked(JSON.stringify(variant)));
+            expect(result.ok).toBe(false);
+        }
+    });
+});
+describe('paste of an outdated fragment', () => {
+    const textProps = { text: s('old') };
+    const fragmentOfLeaf = (type, version) => serializeFragment({
+        schemaVersion: 1,
+        format: 'buildr/fragment',
+        roots: ['leafOld001'],
+        nodes: { leafOld001: { id: 'leafOld001', type, props: textProps } },
+        components: { [type]: version },
+    });
+    const migrations = {
+        'buildr/leaf': {
+            currentVersion: 2,
+            steps: [
+                {
+                    from: 1,
+                    to: 2,
+                    migrate: (props) => ({ ...props, migrated: { kind: 'static', value: true } }),
+                },
+            ],
+            replaces: {
+                'buildr/retired': {
+                    fromVersion: 1,
+                    toVersion: 1,
+                    migrate: (node) => ({ ...node, props: { ...node.props } }),
+                },
+            },
+        },
+    };
+    const setup = (text, withMigrations) => {
+        const store = createEditorStore({
+            doc: { ...fixture(), components: { ...fixture().components, 'buildr/leaf': 2 } },
+            registry: createRegistryMeta({
+                components: [
+                    page(),
+                    box,
+                    {
+                        ...base,
+                        version: 2,
+                        props: { text: p.text({ default: '' }), migrated: p.boolean({ default: false }) },
+                    },
+                ],
+            }),
+            generateId: createSeededIdGenerator(11),
+            validationDelayMs: null,
+        });
+        const clipboard = createClipboard({
+            store,
+            io: { writeText: async () => undefined, readText: async () => text },
+            generateId: createSeededIdGenerator(31),
+            migrations: withMigrations,
+        });
+        return { store, clipboard };
+    };
+    const pastedNode = (store) => {
+        const id = rootOrder(store).at(-1);
+        return store.getState().doc.nodes[id];
+    };
+    it('migrates a fragment copied under an older version before inserting it', async () => {
+        const { store, clipboard } = setup(fragmentOfLeaf('buildr/leaf', 1), migrations);
+        expect(await clipboard.paste()).toEqual({ ok: true });
+        expect(pastedNode(store)?.props).toMatchObject({ migrated: { value: true } });
+        expect(store.getState().doc.components['buildr/leaf']).toBe(2);
+    });
+    it('migrates a fragment of a retired type into the type that replaces it', async () => {
+        const { store, clipboard } = setup(fragmentOfLeaf('buildr/retired', 1), migrations);
+        expect(await clipboard.paste()).toEqual({ ok: true });
+        expect(pastedNode(store)?.type).toBe('buildr/leaf');
+        expect(pastedNode(store)?.props).toMatchObject({ migrated: { value: true } });
+    });
+    it('migrates a retired node whose type is missing from the components map', async () => {
+        const { store, clipboard } = setup(fragmentOfLeaf('buildr/retired', 1).replace('{"buildr/retired":1}', '{}'), migrations);
+        expect(await clipboard.paste()).toEqual({ ok: true });
+        expect(pastedNode(store)?.type).toBe('buildr/leaf');
+    });
+    it('refuses it without migrations and leaves the document as it was', async () => {
+        const { store, clipboard } = setup(fragmentOfLeaf('buildr/leaf', 1));
+        const before = store.getState().doc;
+        expect(await clipboard.paste()).toEqual({ ok: false, error: { code: 'outdated' } });
+        expect(store.getState().doc).toBe(before);
+    });
+    it('refuses it when the migration cannot be applied', async () => {
+        const { store, clipboard } = setup(fragmentOfLeaf('buildr/leaf', 3), migrations);
+        const before = store.getState().doc;
+        expect(await clipboard.paste()).toEqual({ ok: false, error: { code: 'outdated' } });
+        expect(store.getState().doc).toBe(before);
+    });
+    it('refuses a type the registry does not know without migrations', async () => {
+        const { store, clipboard } = setup(fragmentOfLeaf('buildr/unknown', 1), {});
+        const before = store.getState().doc;
+        expect(await clipboard.paste()).toEqual({ ok: false, error: { code: 'outdated' } });
+        expect(store.getState().doc).toBe(before);
+    });
+});
+describe('ClipboardProvider', () => {
+    let container;
+    let root;
+    function Bridge() {
+        return _jsx("input", { "aria-label": "field" });
+    }
+    function Shortcuts(props) {
+        const actions = useClipboardActions();
+        return (_jsx(ShortcutProvider, { platform: "other", actions: actions, children: props.children }));
+    }
+    async function mount(io) {
+        const store = newStore();
+        await act(async () => root.render(_jsx(MessagesProvider, { locale: "en", children: _jsx(ToastProvider, { children: _jsx(EditorStoreProvider, { store: store, children: _jsx(ClipboardProvider, { io: io, children: _jsx(Shortcuts, { children: _jsx(Bridge, {}) }) }) }) }) })));
+        return store;
+    }
+    const key = (target, init) => act(async () => {
+        target.dispatchEvent(new KeyboardEvent('keydown', { bubbles: true, cancelable: true, ...init }));
+    });
+    beforeEach(() => {
+        container = document.createElement('div');
+        document.body.append(container);
+        root = createRoot(container);
+    });
+    afterEach(() => {
+        act(() => root.unmount());
+        document.body.innerHTML = '';
+    });
+    it('copies and pastes with the keyboard', async () => {
+        const io = memoryIO();
+        const store = await mount(io);
+        act(() => store.select('leafBBBBB1'));
+        await key(document.body, { key: 'c', ctrlKey: true });
+        expect(io.text.startsWith(CLIPBOARD_MARKER)).toBe(true);
+        await key(document.body, { key: 'v', ctrlKey: true });
+        expect(rootOrder(store)).toHaveLength(3);
+        await key(document.body, { key: 'x', ctrlKey: true });
+        expect(rootOrder(store)).toHaveLength(2);
+    });
+    it('says why a paste was refused', async () => {
+        const io = memoryIO();
+        io.text = 'just some text';
+        const store = await mount(io);
+        act(() => store.select('leafBBBBB1'));
+        await key(document.body, { key: 'v', ctrlKey: true });
+        expect(container.parentElement?.querySelector('[role=status]')?.textContent).toContain('nothing copied from the editor');
+        expect(rootOrder(store)).toHaveLength(2);
+    });
+    it('leaves copy and paste to a text field that has focus', async () => {
+        const io = memoryIO();
+        const store = await mount(io);
+        act(() => store.select('leafBBBBB1'));
+        const field = container.querySelector('input');
+        await key(field, { key: 'c', ctrlKey: true });
+        expect(io.text).toBe('');
+    });
+});

package/dist/clipboard/format.d.ts

@@ -0,0 +1,27 @@
+import { type BuilderFragment } from '@next-buildr/core';
+/** The first line of what the editor puts on the clipboard; it says which format follows. */
+export declare const CLIPBOARD_MARKER = "buildr-fragment/1";
+/** More than this is not a copied selection but something else (or an attack); it is not parsed. */
+export declare const MAX_CLIPBOARD_BYTES = 1000000;
+export type ClipboardErrorCode = 'empty' | 'readOnly' | 'notFragment' | 'tooLarge' | 'unsupported' | 'invalid' | 'rejected' | 'outdated';
+export interface ClipboardError {
+    readonly code: ClipboardErrorCode;
+    /** The reason the editor's rules gave, for `rejected`; the text for the others is in the message catalog. */
+    readonly detail?: string | undefined;
+}
+export type ParseResult = {
+    readonly ok: true;
+    readonly fragment: BuilderFragment;
+} | {
+    readonly ok: false;
+    readonly error: ClipboardError;
+};
+/** The clipboard text of a fragment: the marker, a line break, JSON. */
+export declare function serializeFragment(fragment: BuilderFragment): string;
+/**
+ * Reads clipboard text as a fragment. The text is untrusted: it is checked for the marker, its size
+ * and version, parsed as JSON and validated with `fragmentSchema` before anything else sees it.
+ * Never throws.
+ */
+export declare function parseClipboardText(text: string): ParseResult;
+//# sourceMappingURL=format.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/clipboard/format.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAkB,MAAM,mBAAmB,CAAC;AAEzE,6FAA6F;AAC7F,eAAO,MAAM,gBAAgB,sBAAsB,CAAC;AAGpD,oGAAoG;AACpG,eAAO,MAAM,mBAAmB,UAAY,CAAC;AAE7C,MAAM,MAAM,kBAAkB,GAC1B,OAAO,GACP,UAAU,GACV,aAAa,GACb,UAAU,GACV,aAAa,GACb,SAAS,GACT,UAAU,GACV,UAAU,CAAC;AAEf,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,6GAA6G;IAC7G,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,GACzD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAA;CAAE,CAAC;AAE3D,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,CAEnE;AAID;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAe5D"}

package/dist/clipboard/format.js

@@ -0,0 +1,37 @@
+import { fragmentSchema } from '@next-buildr/core';
+/** The first line of what the editor puts on the clipboard; it says which format follows. */
+export const CLIPBOARD_MARKER = 'buildr-fragment/1';
+const MARKER_PREFIX = 'buildr-fragment/';
+/** More than this is not a copied selection but something else (or an attack); it is not parsed. */
+export const MAX_CLIPBOARD_BYTES = 1_000_000;
+/** The clipboard text of a fragment: the marker, a line break, JSON. */
+export function serializeFragment(fragment) {
+    return `${CLIPBOARD_MARKER}\n${JSON.stringify(fragment)}`;
+}
+const byteLength = (text) => new TextEncoder().encode(text).length;
+/**
+ * Reads clipboard text as a fragment. The text is untrusted: it is checked for the marker, its size
+ * and version, parsed as JSON and validated with `fragmentSchema` before anything else sees it.
+ * Never throws.
+ */
+export function parseClipboardText(text) {
+    if (!text.startsWith(MARKER_PREFIX))
+        return { ok: false, error: { code: 'notFragment' } };
+    if (byteLength(text) > MAX_CLIPBOARD_BYTES)
+        return { ok: false, error: { code: 'tooLarge' } };
+    const lineEnd = text.indexOf('\n');
+    const marker = lineEnd === -1 ? text : text.slice(0, lineEnd);
+    if (marker !== CLIPBOARD_MARKER)
+        return { ok: false, error: { code: 'unsupported' } };
+    let raw;
+    try {
+        raw = JSON.parse(lineEnd === -1 ? '' : text.slice(lineEnd + 1));
+    }
+    catch {
+        return { ok: false, error: { code: 'invalid' } };
+    }
+    const parsed = fragmentSchema.safeParse(raw);
+    if (!parsed.success)
+        return { ok: false, error: { code: 'invalid' } };
+    return { ok: true, fragment: parsed.data };
+}

package/dist/clipboard/index.d.ts

@@ -0,0 +1,6 @@
+export type { Clipboard, ClipboardIO, ClipboardOptions, ClipboardResult } from './clipboard.ts';
+export { browserClipboard, createClipboard } from './clipboard.ts';
+export type { ClipboardError, ClipboardErrorCode, ParseResult } from './format.ts';
+export { CLIPBOARD_MARKER, MAX_CLIPBOARD_BYTES, parseClipboardText, serializeFragment, } from './format.ts';
+export { ClipboardProvider, NOTICE_MS, useClipboard, useClipboardActions } from './react.tsx';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/clipboard/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACnE,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACnF,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC"}

package/dist/clipboard/index.js

@@ -0,0 +1,3 @@
+export { browserClipboard, createClipboard } from './clipboard.js';
+export { CLIPBOARD_MARKER, MAX_CLIPBOARD_BYTES, parseClipboardText, serializeFragment, } from './format.js';
+export { ClipboardProvider, NOTICE_MS, useClipboard, useClipboardActions } from './react.js';

package/dist/clipboard/react.d.ts

@@ -0,0 +1,20 @@
+import type { ComponentMigrations } from '@next-buildr/core';
+import { type ReactNode } from 'react';
+import type { ExternalActions } from '../shortcuts/index.ts';
+import { type Clipboard, type ClipboardIO } from './clipboard.ts';
+/** How long a refusal stays on screen. */
+export declare const NOTICE_MS = 6000;
+export declare function useClipboard(): Clipboard;
+/** The clipboard's actions in the shape `<ShortcutProvider actions>` takes: each starts the work and claims the key. */
+export declare function useClipboardActions(): Pick<ExternalActions, 'copy' | 'cut' | 'paste'>;
+/**
+ * Gives the editor's clipboard to the tree below and shows why a copy, cut or paste was refused in
+ * the toast region (there is no dialog: a refused paste is not an emergency). `io` is the system
+ * clipboard; by default `navigator.clipboard`, with the last copy kept in memory as a fallback.
+ */
+export declare function ClipboardProvider(props: {
+    readonly io?: ClipboardIO | undefined;
+    readonly migrations?: ComponentMigrations | undefined;
+    readonly children: ReactNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=react.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/clipboard/react.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAiB,KAAK,SAAS,EAAuB,MAAM,OAAO,CAAC;AAE3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAG7D,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,WAAW,EAGjB,MAAM,gBAAgB,CAAC;AAKxB,0CAA0C;AAC1C,eAAO,MAAM,SAAS,OAAW,CAAC;AAalC,wBAAgB,YAAY,IAAI,SAAS,CAKxC;AAED,wHAAwH;AACxH,wBAAgB,mBAAmB,IAAI,IAAI,CAAC,eAAe,EAAE,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC,CAcrF;AAID;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACvC,QAAQ,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,UAAU,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;IACtD,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;CAC9B,+BAoCA"}

package/dist/clipboard/react.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { useT } from '../messages/index.js';
+import { useEditor } from '../store/index.js';
+import { TOAST_MS, useToast } from '../ui/index.js';
+import { browserClipboard, createClipboard, } from './clipboard.js';
+const ClipboardContext = createContext(undefined);
+/** How long a refusal stays on screen. */
+export const NOTICE_MS = TOAST_MS;
+const MESSAGES = {
+    empty: 'clipboard.error.empty',
+    readOnly: 'clipboard.error.readOnly',
+    notFragment: 'clipboard.error.notFragment',
+    tooLarge: 'clipboard.error.tooLarge',
+    unsupported: 'clipboard.error.unsupported',
+    invalid: 'clipboard.error.invalid',
+    rejected: 'clipboard.error.rejected',
+    outdated: 'clipboard.outdated',
+};
+export function useClipboard() {
+    const clipboard = useContext(ClipboardContext);
+    if (clipboard === undefined)
+        throw new Error('useClipboard must be used inside <ClipboardProvider>');
+    return clipboard;
+}
+/** The clipboard's actions in the shape `<ShortcutProvider actions>` takes: each starts the work and claims the key. */
+export function useClipboardActions() {
+    const clipboard = useClipboard();
+    const report = useContext(ReportContext);
+    return useMemo(() => {
+        const run = (action) => () => {
+            void action().then(report);
+            return true;
+        };
+        return {
+            copy: run(clipboard.copy),
+            cut: run(clipboard.cut),
+            paste: run(clipboard.paste),
+        };
+    }, [clipboard, report]);
+}
+const ReportContext = createContext(() => undefined);
+/**
+ * Gives the editor's clipboard to the tree below and shows why a copy, cut or paste was refused in
+ * the toast region (there is no dialog: a refused paste is not an emergency). `io` is the system
+ * clipboard; by default `navigator.clipboard`, with the last copy kept in memory as a fallback.
+ */
+export function ClipboardProvider(props) {
+    const store = useEditor();
+    const t = useT();
+    const toast = useToast();
+    const io = props.io ?? browserClipboard();
+    const clipboard = useMemo(() => createClipboard({ store, io, migrations: props.migrations }), [store, io, props.migrations]);
+    const report = useMemo(() => (result) => {
+        if (result.ok) {
+            toast.dismiss('clipboard');
+            return;
+        }
+        const { error } = result;
+        toast.show({
+            id: 'clipboard',
+            variant: error.code === 'invalid' || error.code === 'rejected' || error.code === 'outdated'
+                ? 'error'
+                : 'warning',
+            message: t(MESSAGES[error.code]),
+            detail: error.detail,
+            duration: NOTICE_MS,
+        });
+    }, [toast, t]);
+    return (_jsx(ClipboardContext.Provider, { value: clipboard, children: _jsx(ReportContext.Provider, { value: report, children: props.children }) }));
+}

package/dist/dialogs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './media-picker/index.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/dialogs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dialogs/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC"}

package/dist/dialogs/index.js

@@ -0,0 +1 @@
+export * from './media-picker/index.js';

package/dist/dialogs/media-picker/index.d.ts

@@ -0,0 +1,7 @@
+export type { MediaLibrary, MediaLibraryProviderProps } from './library.tsx';
+export { MediaLibraryProvider, useMediaLibrary } from './library.tsx';
+export type { MediaPickerProps } from './media-picker.tsx';
+export { MediaPicker } from './media-picker.tsx';
+export type { MediaKind, MediaRef } from './media-ref.ts';
+export { kindsFor, MEDIA_KINDS, mediaRefSchema, mimeTypesFor, parseMediaRef, toMediaRef, } from './media-ref.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/dialogs/media-picker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dialogs/media-picker/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACtE,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EACL,QAAQ,EACR,WAAW,EACX,cAAc,EACd,YAAY,EACZ,aAAa,EACb,UAAU,GACX,MAAM,gBAAgB,CAAC"}