edytor 5.0.0 → 6.0.0

package/dist/crdt/doc/capability.js

@@ -1,207 +0,0 @@
-/**
- * Structural capability: one answer in advance and at execution.
- *
- * ── Island/void enforcement (operation-layer, not stored) ──────────────
- *
- * Roles are resolved operation-time via `config.roleOf(type)`, through one
- * role table (`DisplayRoles`) that the index's display and every guard
- * below ask of a block's shown kind — the editor derives them from plugin
- * block definitions, exactly like the baseline's
- * `block.definition.island/void`. They are deliberately NOT replicated block
- * data: the schema stays policy-free, and a replica with different plugins
- * reads the same document. Enforced rules (baseline semantics, see
- * `plugins.ts` + `block.utils.ts`):
- *
- * - `void`: cannot accept children (insert/move/nest into void rejected),
- *   cannot merge either direction, cannot be split. Content edits ARE
- *   allowed — void rendered content (captions) stays editable per the
- *   baseline contract. Deletion is allowed (delete is not editing).
- * - `island`: editable content, but its subtree is structurally sealed —
- *   a block inside an island (`insideIsland`) cannot be moved, nested,
- *   unnested, or merged across the island boundary. Merges INSIDE one
- *   island are allowed; merging an island child into the island itself is
- *   allowed when the island renders its content. Moving or merging
- *   INTO an island subtree is rejected. An island declared `lines` (code)
- *   holds only lines of its `defaultChild` kind, and a line holds no
- *   children (the display enforces it against undo,
- *   `insertBlocks` refuses a line parent); any other island keeps its
- *   structure. `canPlace` and `canMerge` are the one answer, asked in
- *   advance or by the ops.
- * - Island merge: when an island block itself is merged (backward or
- *   forward), its children are unnested to the vacated sibling slot and
- *   reset to the default child of that slot's parent (`defaultChild`).
- * - Baseline merges NEVER adopt the merged block's children — they unnest
- *   to the vacated slot. The facade exposes both: `mergeBlocks` is the
- *   engine primitive (children adopt into the target
- *   by staying under the source, which the target's claim displays),
- *   `mergeBackward`/`mergeForward` reproduce the baseline command shape.
- *
- */
-import { isLiveIn } from '../placement/model.js';
-/** The capability of the facade over its reads. */
-export const docCapability = (c) => {
-    const { roles, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, isVoid, isIsland, islandOf, insideIsland, holdsLayout, insideItem, isRowKind, isCellKind, displayLength } = c;
-    // ── structural capability: one answer in advance and at execution ──
-    /**
-     * May `ids` be placed under `parent` (`null` = the root)? Every id is
-     * live, distinct and outside any island interior (island subtrees are
-     * sealed); the destination is live, neither void nor an island nor
-     * inside one, and not inside any moved block's own subtree; and every
-     * block fits it as the kind `kindOf` gives (`fits`; a move keeps its
-     * kind) or already sits in it (a reorder changes nothing a list holds:
-     * an image shed into a list still moves among its items); and
-     * no layout, nor a block holding one, lands inside a layout item
-     * (`layout.nest`). A table's cell never moves, and its row only
-     * within its table (`table.fits`).
-     * Without a `parent`: may these blocks move at all (the drag
-     * affordance). The move ops refuse exactly when this answers `false`.
-     * (`insertBlock` is looser — island interiors are built by inserting
-     * into them.)
-     */
-    const canPlace = (ids, parent, kindOf = blockTypeOf) => {
-        const v = view();
-        if (ids.length === 0 || new Set(ids).size !== ids.length)
-            return false;
-        if (ids.some((id) => !isLiveIn(v, id) || insideIsland(id, v)))
-            return false;
-        // A cell moves only with its column, never as a block (`table.fits`).
-        if (ids.some((id) => isCellKind(blockTypeOf(id))))
-            return false;
-        // A row moves only within its table: a table's rows are reordered, never re-homed.
-        const rows = ids.filter((id) => isRowKind(blockTypeOf(id)));
-        if (rows.length > 0 && parent !== undefined)
-            if (parent === null || rows.some((id) => positionOf(id)?.parent !== parent))
-                return false;
-        if (parent === undefined || parent === null)
-            return true;
-        if (!isLiveIn(v, parent) || isVoid(parent))
-            return false;
-        const stays = (id) => positionOf(id)?.parent === parent;
-        if (!ids.every((id) => stays(id) || fits(parent, kindOf(id))))
-            return false;
-        if (insideItem(parent, v) && ids.some(holdsLayout))
-            return false;
-        return ![parent, ...ancestorsOf(parent, v)].some((a) => isIsland(a) || ids.includes(a));
-    };
-    /**
-     * A container: a block that shows only its children — no content of
-     * its own, neither void nor an island (a list, a table row, a column).
-     */
-    const isContainer = (id) => roles.of(blockTypeOf(id) ?? '').container;
-    /**
-     * THE container rule: may a block of `kind` sit directly
-     * under `parent` (`null` = the root)? A container whose default child is
-     * a kind of its own — its item (a list's `list-item`, a columns
-     * layout's `column`) — holds only its items, and containers of them
-     * when the item renders content (a list directly in a list, from JSON
-     * or the API; a layout holds no layout, `layout.fits`); one whose
-     * default child is the document's (a column) holds any block. Every
-     * structural placement asks it: a move is refused where its blocks do
-     * not fit (`canPlace`), Tab nests under a container's last item
-     * (`nestParent`), an outdent or a lift is refused where the block would
-     * not fit, and a block a merge, delete or range sheds into a container
-     * takes its item kind when it is a plain block (`fitted`). Explicit kind
-     * writes (`insertBlocks`, a retype) place what they are told (the
-     * view's Turn into places the kind where it fits first, `liftOut`); a
-     * plain block stored directly in a list still shows as its item (the
-     * index's `typeOf`), whatever write or race put it there.
-     */
-    const fits = (parent, kind) => parent === null || fitsIn(blockTypeOf(parent) ?? '', kind);
-    /** `fits`, by the parent's kind (a block not written yet: `placeBeside`'s new item). */
-    const fitsIn = (parentType, kind) => {
-        const { container, child: item } = roles.of(parentType);
-        if (!container || item === defaultChild(null) || kind === item)
-            return true;
-        const k = kind === undefined ? undefined : roles.of(kind);
-        return k?.container === true && k.child === item && roles.of(item).rendersContent;
-    };
-    /**
-     * `kind`, or — where a plain block (the document's default kind, or
-     * none: a pasted run) does not fit `parent` — `parent`'s item, when
-     * that renders content (a paragraph landing in a list is its item; one
-     * in a columns layout keeps its kind: its text never vanishes). Any
-     * other kind keeps its kind and data wherever a merge, a delete or a
-     * paste sheds it — an image under a bullet stays an image, a heading a
-     * heading, a to-do keeps its check — as a peer's
-     * concurrent promotion shows it (`typeOf` resets only the default
-     * kind); an outdent or a move that would place one directly in a list
-     * is refused (`fits`).
-     */
-    const fitted = (parent, kind) => {
-        if (fits(parent, kind) || (kind !== undefined && kind !== defaultChild(null)))
-            return kind;
-        const item = defaultChild(parent);
-        return roles.of(item).rendersContent ? item : kind;
-    };
-    /** A container that goes once it loses every child: it holds no text of its own (a peer's retype can leave some, hidden: it renders none). */
-    const emptiable = (id) => isContainer(id) && displayLength(id) === 0;
-    /**
-     * Where `ids` nest when nested into `parent` (Tab, a drop inside it):
-     * `parent`, or — a container they are no items of — its last child,
-     * and so on down. Tab after a list nests under its last item (Notion);
-     * a last child that holds no children (an image, a code block) is
-     * answered as it is, and `canPlace` refuses it, as Tab right under
-     * that block is refused.
-     */
-    const nestParent = (ids, parent) => {
-        let at = parent;
-        while (!ids.every((id) => fits(at, blockTypeOf(id)))) {
-            const last = childrenIds(at).at(-1);
-            if (last === undefined)
-                break;
-            at = last;
-        }
-        return at;
-    };
-    /**
-     * May `fromId`'s content merge into `intoId`? Both live and distinct,
-     * neither void, `intoId` renders its content (a list, a table row or a
-     * code block shows none, so a first item, cell or line never merges
-     * into it), `fromId` renders its own unless it is
-     * an island (a list or a row never merges as a whole: its items would
-     * leave it, `del.merge.container`), and the merge stays on one side of an island
-     * boundary (a block may merge into its own island root — that stays
-     * inside — but nothing from outside merges into an island).
-     */
-    const canMerge = (fromId, intoId) => {
-        const v = view();
-        if (fromId === intoId || !isLiveIn(v, fromId) || !isLiveIn(v, intoId))
-            return false;
-        if (isVoid(fromId) || isVoid(intoId))
-            return false;
-        // Nothing merges into or out of a table's cell (`table.merge`).
-        if (isCellKind(blockTypeOf(fromId)) || isCellKind(blockTypeOf(intoId)))
-            return false;
-        if (!rendersContent(intoId) || !(rendersContent(fromId) || isIsland(fromId)))
-            return false;
-        const islandFrom = islandOf(fromId, v);
-        if (intoId === islandFrom)
-            return true;
-        return islandFrom === islandOf(intoId, v) && !isIsland(intoId);
-    };
-    /** `id`'s shown kind renders its content. */
-    const rendersContent = (id) => roles.of(blockTypeOf(id) ?? '').rendersContent;
-    /** The adopted default child type under `parent` (`null` = the root). */
-    const defaultChild = (parent) => roles.of(parent === null ? null : (blockTypeOf(parent) ?? null)).child;
-    /**
-     * The kind a new block copies from `id` (a split tail, a flow's tail,
-     * a duplicate and each of its descendants). A type a peer's retype is
-     * replacing can be missing while its new value is pending: the copy
-     * then takes its parent's default child, never a missing type
-     * (it showed as `unknown` everywhere, for good).
-     */
-    const kindToCopy = (id) => blockTypeOf(id) ?? defaultChild(positionOf(id)?.parent ?? null);
-    return {
-        canPlace,
-        isContainer,
-        fits,
-        fitsIn,
-        fitted,
-        emptiable,
-        nestParent,
-        canMerge,
-        rendersContent,
-        defaultChild,
-        kindToCopy
-    };
-};

package/dist/crdt/doc/content.d.ts

@@ -1,16 +0,0 @@
-import type { BlockId, InlineSpec } from '../placement/model.js';
-import type { Prepared } from './types.js';
-import type { OpsContext } from './steps.js';
-/** An inline atom to insert: its id is minted when it names none. */
-export type NewInline = Omit<InlineSpec, 'id'> & {
-    id?: string;
-};
-/** The content ops of one facade, prepared. */
-export declare const contentOps: (c: OpsContext) => {
-    insertText: (id: BlockId, offset: number, text: string, marks?: Record<string, unknown>) => Prepared;
-    deleteText: (id: BlockId, offset: number, length: number) => Prepared;
-    formatRange: (id: BlockId, offset: number, length: number, marks: Record<string, unknown>) => Prepared;
-    clearMarks: (id: BlockId, offset: number, length: number) => Prepared;
-    insertInline: (id: BlockId, offset: number, atom: NewInline) => Prepared;
-    removeInline: (id: BlockId, inlineId: string) => Prepared;
-};

package/dist/crdt/doc/content.js

@@ -1,77 +0,0 @@
-/**
- * Content ops: text and inline atoms in a block's display (allowed
- * inside voids — the caption contract), and marks over a range.
- */
-import { sanitizeWireJson, jsonEquals } from '../../utils/json.js';
-import { id as newId } from '../../utils.js';
-import { ref, sanitizeInline } from './plan.js';
-/** The content ops of one facade, prepared. */
-export const contentOps = (c) => {
-    const { contentTarget, REFUSED, plan, clamp, atomOf, textIn } = c;
-    // content ops (allowed inside voids — caption contract)
-    const insertText = (id, offset, text, marks) => {
-        id = ref(id);
-        const clean = ref(text);
-        if (!contentTarget(id))
-            return REFUSED;
-        const [at] = clamp(id, offset, 0);
-        const m = marks && sanitizeWireJson(marks);
-        return plan([id], clean === '' ? [] : [{ op: 'insertText', id, offset: at, text: clean, marks: m }]);
-    };
-    const deleteText = (id, offset, length) => {
-        id = ref(id);
-        if (!contentTarget(id))
-            return REFUSED;
-        const [at, end] = clamp(id, offset, length);
-        return plan([id], end > at ? [{ op: 'deleteText', id, offset: at, length: end - at }] : []);
-    };
-    /**
-     * Multi-mark format over a range (values may be null = unset); planned
-     * only when some text atom in the range carries a different value.
-     */
-    const formatRange = (id, offset, length, marks) => {
-        id = ref(id);
-        const clean = sanitizeWireJson(marks);
-        if (!contentTarget(id))
-            return REFUSED;
-        const [at, end] = clamp(id, offset, length);
-        // Planned only when some text atom carries another value (the same-value guard).
-        const differs = textIn(id, at, end).some((item) => Object.keys(clean).some((k) => !jsonEquals(item.marks?.[k] ?? null, clean[k] ?? null)));
-        return plan([id], differs ? [{ op: 'formatRange', id, offset: at, length: end - at, marks: clean }] : []);
-    };
-    /**
-     * Baseline `removeMarksFromText`: every mark present anywhere in the
-     * range is unset over the range. Names are discovered from the content.
-     */
-    const clearMarks = (id, offset, length) => {
-        const clears = {};
-        for (const item of textIn(ref(id), offset, offset + length)) {
-            for (const k of Object.keys(item.marks ?? {}))
-                clears[k] = null;
-        }
-        return formatRange(id, offset, length, clears);
-    };
-    /** An atom without an id gets a fresh one. */
-    const insertInline = (id, offset, atom) => {
-        id = ref(id);
-        const clean = sanitizeInline({ ...atom, id: atom.id ?? newId('i') });
-        if (!contentTarget(id))
-            return REFUSED;
-        return plan([id], [{ op: 'insertInline', id, offset: clamp(id, offset, 0)[0], atom: clean }]);
-    };
-    const removeInline = (id, inlineId) => {
-        id = ref(id);
-        const atom = atomOf(id, ref(inlineId));
-        if (atom === undefined)
-            return REFUSED;
-        return plan([id], [{ op: 'removeInline', id, offset: atom.at, inlineId: ref(inlineId) }]);
-    };
-    return {
-        insertText,
-        deleteText,
-        formatRange,
-        clearMarks,
-        insertInline,
-        removeInline
-    };
-};

package/dist/crdt/doc/delete.d.ts

@@ -1,15 +0,0 @@
-/**
- * Block deletion (`del.blocks.promote`): only the members leave, the
- * unselected children of a deleted block take its slot.
- */
-import type { BlockId } from '../placement/model.js';
-import type { Prepared } from './types.js';
-import type { OpsContext } from './steps.js';
-/** The delete ops of one facade, prepared. */
-export declare const deleteOps: (c: OpsContext) => {
-    deleteBlocks: (ids: readonly BlockId[], subtree?: boolean, filled?: BlockId | null) => Prepared;
-    deleteBlock: (id: BlockId, opts?: {
-        keepChildren?: boolean;
-    }) => Prepared;
-};
-export type DeleteOps = ReturnType<typeof deleteOps>;

package/dist/crdt/doc/delete.js

@@ -1,84 +0,0 @@
-import { ref } from './plan.js';
-/** The delete ops of one facade, prepared. */
-export const deleteOps = (c) => {
-    const { view, blockTypeOf, childrenIds, positionOf, ancestorsOf, itemKindOf, isLayout, isLayoutItem, isTable, isTableRow, live, REFUSED, plan, settle, emptyingAll, emptied, deleting, remove } = c;
-    /**
-     * Delete a set of blocks (`del.blocks.promote`): this writer's mark on
-     * every member and on what it displays through merge claims (wins over
-     * concurrent moves). Only the members leave: the unselected children of a
-     * deleted block take its slot, in order, with their subtrees, as the
-     * kind they show there (`settledKind`: a deleted island's children take
-     * the slot parent's default child, a deleted list's items leave its
-     * kind, a block promoted into a list is its item). A container the delete leaves with no child goes too
-     * (`del.range.empty-container`). `subtree` is the explicit whole-subtree
-     * delete. `filled`: a parent the same plan fills again (a flow placed in
-     * the deleted blocks' slot, `flow.slot`), which is never emptied, so its
-     * layout never dissolves (`layout.flow-slot`).
-     */
-    const deleteBlocks = (ids, subtree = false, filled) => {
-        const set = new Set(ids.map(ref));
-        if ([...set].some((id) => !live(id)))
-            return REFUSED;
-        // A layout goes with its items: their blocks take its slot (`layout.dissolving`).
-        for (const id of [...set])
-            if (isLayout(id))
-                for (const kid of childrenIds(id))
-                    if (isLayoutItem(kid))
-                        set.add(kid);
-        // A table goes with its rows and cells, a row with its cells: none shows outside them (`table.delete-row`).
-        const whole = (id) => {
-            for (const kid of childrenIds(id)) {
-                set.add(kid);
-                whole(kid);
-            }
-        };
-        for (const id of [...set])
-            if (isTable(id) || isTableRow(id))
-                whole(id);
-        if (subtree) {
-            const roots = [...set].filter((id) => !ancestorsOf(id).some((a) => set.has(a)));
-            return plan(roots, emptied(roots, roots.map((id) => remove(id))));
-        }
-        const roots = [...set].filter((id) => !set.has(positionOf(id).parent));
-        const { kids } = view();
-        const promoting = new Set();
-        const members = [];
-        const writes = roots.flatMap((root) => {
-            const pos = positionOf(root);
-            const chunk = [];
-            const kept = [];
-            // The kept children keep their home slots: the read shows them in the
-            // root's slot, in its order (a block a peer puts under a member
-            // meanwhile takes the slot in that order too); only their kinds are
-            // written, as the slot's parent settles them.
-            const walk = (b) => {
-                chunk.push(b);
-                for (const kid of kids.get(b) ?? []) {
-                    if (set.has(kid.id))
-                        walk(kid.id);
-                    else
-                        kept.push({ id: kid.id, from: b });
-                }
-            };
-            walk(root);
-            members.push(...chunk);
-            if (kept.length > 0)
-                promoting.add(root);
-            // A layout shows only its items: a deleted item's blocks show right
-            // after the layout (`layout.only-items`), settled for its parent.
-            const item = pos.parent === null ? undefined : itemKindOf(pos.parent);
-            const out = (k) => item !== undefined && blockTypeOf(k.id) !== item;
-            return [
-                ...kept.flatMap((k) => settle(k.from, [k.id], out(k) ? positionOf(pos.parent).parent : pos.parent)),
-                deleting(root, chunk)
-            ];
-        });
-        return plan(roots, emptyingAll(roots.filter((r) => !promoting.has(r)).map((id) => positionOf(id).parent), roots.filter((r) => !promoting.has(r)), writes, filled === undefined ? undefined : new Set([filled]), members));
-    };
-    /** Delete `id` — its children take its slot (`keepChildren: false`: the whole subtree). */
-    const deleteBlock = (id, opts = {}) => deleteBlocks([id], opts.keepChildren === false);
-    return {
-        deleteBlocks,
-        deleteBlock
-    };
-};

package/dist/crdt/doc/layout.d.ts

@@ -1,9 +0,0 @@
-import type { BlockId } from '../placement/model.js';
-import type { Prepared } from './types.js';
-import type { OpsContext } from './steps.js';
-/** The layout ops of one facade, prepared. */
-export declare const layoutOps: (c: OpsContext) => {
-    besideAt: (target: BlockId, kind?: string) => BlockId;
-    placeBeside: (ids: readonly BlockId[], target: BlockId, side: "left" | "right", kind?: string) => Prepared;
-    wrapInLayout: (ids: readonly BlockId[], kind?: string, columns?: number) => Prepared;
-};

package/dist/crdt/doc/layout.js

@@ -1,178 +0,0 @@
-/**
- * Layout ops (`layout.*`): the layout kind a new layout takes, where a
- * beside placement lands (`besideAt`), and the two layout-making ops,
- * `placeBeside` and `wrapInLayout`.
- */
-import { id as newId } from '../../utils.js';
-import { sanitizeSpec } from '../../utils/json.js';
-import { ref } from './plan.js';
-/** The layout ops of one facade, prepared. */
-export const layoutOps = (c) => {
-    const { roles, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, isIsland, isLines, insideIsland, isLayout, isLayoutItem, holdsLayout, insideItem, live, canPlace, isContainer, fits, fitsIn, REFUSED, plan, moveTo, landing, emptied } = c;
-    /** The layout kind a new layout takes: `kind` when it is one, else the only one the roles declare. */
-    const layoutKind = (kind) => {
-        if (kind !== undefined)
-            return roles.of(kind).layout === undefined ? undefined : kind;
-        const kinds = roles.declared().layouts;
-        return kinds.length === 1 ? kinds[0] : undefined;
-    };
-    /** A fresh empty block of `type`. */
-    const spec = (type) => sanitizeSpec({ id: newId('b'), type, data: {} });
-    /**
-     * The block a beside placement at `target` stands beside
-     * (`layout.place-beside`): a layout or an item for itself; a block whose
-     * parent shows only its children (a list item → its list, at any depth)
-     * or is an island of lines (a code line → its code block) for that
-     * parent; then the block itself when it sits directly in an item or at
-     * the root, or where a new layout of `kind` (else the only layout kind)
-     * fits beside it (a toggle's, a callout's or a nested block's child,
-     * outside any item and island); else its outermost block below the
-     * root or an item.
-     */
-    const besideAt = (target, kind) => {
-        let at = ref(target);
-        if (isLayout(at) || isLayoutItem(at))
-            return at;
-        for (let parent = positionOf(at)?.parent ?? null; parent !== null && !isLayoutItem(parent) && (isContainer(parent) || isLines(parent)); parent = positionOf(parent)?.parent ?? null)
-            at = parent;
-        const parent = positionOf(at)?.parent ?? null;
-        if (parent === null || isLayoutItem(parent))
-            return at;
-        const wrap = layoutKind(kind);
-        if (wrap !== undefined &&
-            fits(parent, wrap) &&
-            !insideItem(parent) &&
-            !isIsland(parent) &&
-            !insideIsland(parent))
-            return at;
-        for (let up = parent; up !== null && !isLayoutItem(up); up = positionOf(up).parent)
-            at = up;
-        return at;
-    };
-    /**
-     * Place `ids` beside `target`, to its `side` (`layout.place-beside`: a
-     * block dragged to another block's left or right edge). The target
-     * resolves to its outermost block below the root or below a layout
-     * item (a list item → its list, a code line → its code block); an item
-     * stands for itself, a layout for its first or last slot. Beside a
-     * block in an item, a new item holding `ids` goes beside that item;
-     * otherwise the block and a new item holding `ids` are wrapped in a new
-     * layout of the layout `kind` (else the only one the roles declare) at
-     * its place. Refused when `ids` holds the target or an ancestor of it,
-     * an item, a layout or a block holding one, a block that does not
-     * fit an item, a block or a layout inside an island, and, wrapping,
-     * when there is no layout kind. The sources are cleaned in the same
-     * plan (`emptying`, `dissolving`); a plain move. `ids`: the moved
-     * blocks.
-     */
-    const placeBeside = (ids, target, side, kind) => {
-        const moved = ids.map(ref);
-        target = ref(target);
-        const v = view();
-        if ((side !== 'left' && side !== 'right') || !canPlace(moved) || !live(target))
-            return REFUSED;
-        if ([target, ...ancestorsOf(target, v)].some((a) => moved.includes(a)))
-            return REFUSED;
-        if (moved.some((id) => isLayoutItem(id) || holdsLayout(id)))
-            return REFUSED;
-        const right = side === 'right';
-        // Where the new item goes: beside an item of a layout, or a new layout wrapping `at`.
-        const at = besideAt(target, kind && ref(kind));
-        let layout = null;
-        let index = 0;
-        if (isLayout(at))
-            [layout, index] = [at, right ? childrenIds(at).length : 0];
-        else {
-            const item = isLayoutItem(at) ? at : positionOf(at).parent;
-            if (item !== null) {
-                const pos = positionOf(item);
-                [layout, index] = [pos.parent, pos.index + (right ? 1 : 0)];
-            }
-        }
-        const wrap = layout === null ? layoutKind(kind && ref(kind)) : blockTypeOf(layout);
-        const item = wrap === undefined ? undefined : roles.of(wrap).layout;
-        if (wrap === undefined || item === undefined)
-            return REFUSED;
-        if (moved.some((id) => !fitsIn(item, blockTypeOf(id))))
-            return REFUSED;
-        if (layout !== null && (isIsland(layout) || insideIsland(layout, v)))
-            return REFUSED;
-        const fresh = spec(item);
-        const into = (parent) => moveTo(moved, parent, 0);
-        let writes;
-        let kept;
-        if (layout !== null) {
-            writes = [{ op: 'insertBlocks', parent: layout, index, specs: [fresh] }, ...into(fresh.id)];
-            kept = new Set([fresh.id, ...landing(layout)]);
-        }
-        else {
-            const pos = positionOf(at);
-            const host = spec(item);
-            const wrapper = { ...spec(wrap), children: right ? [host, fresh] : [fresh, host] };
-            writes = [
-                { op: 'insertBlocks', parent: pos.parent, index: pos.index, specs: [wrapper] },
-                ...moveTo([at], host.id, 0),
-                ...into(fresh.id)
-            ];
-            kept = new Set([wrapper.id, host.id, fresh.id, ...landing(pos.parent)]);
-        }
-        return plan(moved, emptied(moved, writes, kept));
-    };
-    /**
-     * Wrap sibling blocks in a new layout of `columns` items (default: one
-     * per block), at the first one's place (`layout.wrap`: Turn into N
-     * columns, as Notion): the blocks fill the first items, one each, in
-     * document order; each item after them holds one empty block of the
-     * item's default child (one block turned into 3 columns: it, then two
-     * empty columns). The layout is of the layout `kind` (else the only one
-     * the roles declare). Refused for no block, fewer than two items or
-     * fewer items than blocks, blocks of different parents, an item, a
-     * layout or a block holding one, where the layout does not fit
-     * (`fits`: in a list, a code block) or lands inside an item or an
-     * island, and for a block that does not fit an item. A plain move.
-     * `ids`: the new layout.
-     */
-    const wrapInLayout = (ids, kind, columns = ids.length) => {
-        const blocks = ids.map(ref);
-        const v = view();
-        if (!Number.isInteger(columns) || columns < 2 || blocks.length < 1)
-            return REFUSED;
-        if (columns < blocks.length || !canPlace(blocks))
-            return REFUSED;
-        const parent = positionOf(blocks[0]).parent;
-        if (blocks.some((id) => positionOf(id).parent !== parent))
-            return REFUSED;
-        if (blocks.some((id) => isLayoutItem(id) || holdsLayout(id)))
-            return REFUSED;
-        const wrap = layoutKind(kind && ref(kind));
-        const item = wrap === undefined ? undefined : roles.of(wrap).layout;
-        if (wrap === undefined || item === undefined || !fits(parent, wrap))
-            return REFUSED;
-        if (parent !== null && (insideItem(parent, v) || isIsland(parent) || insideIsland(parent, v)))
-            return REFUSED;
-        if (blocks.some((id) => !fitsIn(item, blockTypeOf(id))))
-            return REFUSED;
-        const fill = roles.of(item).child;
-        if (columns > blocks.length && !fitsIn(item, fill))
-            return REFUSED;
-        const ordered = blocks.toSorted((a, b) => positionOf(a).index - positionOf(b).index);
-        const items = Array.from({ length: columns }, (_, i) => i < ordered.length ? spec(item) : { ...spec(item), children: [spec(fill)] });
-        const wrapper = { ...spec(wrap), children: items };
-        const at = positionOf(ordered[0]).index;
-        const writes = [
-            { op: 'insertBlocks', parent, index: at, specs: [wrapper] },
-            ...ordered.flatMap((id, i) => moveTo([id], items[i].id, 0))
-        ];
-        const kept = new Set([
-            wrapper.id,
-            ...items.map((it) => it.id),
-            ...landing(parent)
-        ]);
-        return plan([wrapper.id], emptied(ordered, writes, kept));
-    };
-    return {
-        besideAt,
-        placeBeside,
-        wrapInLayout
-    };
-};

package/dist/crdt/doc/meta.d.ts

@@ -1,19 +0,0 @@
-import { type JSONBlock, type JSONInlineBlock, type JSONText } from '../../utils/json.js';
-import { type DataPatch } from '../data.js';
-import { type BlockId, type BlockSpec, type ContentItem } from '../placement/model.js';
-import type { Prepared, PlanStep, DataTarget } from './types.js';
-import type { OpsContext } from './steps.js';
-/** The meta ops of one facade, prepared. */
-export declare const metaOps: (c: OpsContext) => {
-    dataSteps: (target: DataTarget, patches: DataPatch[]) => PlanStep[] | null;
-    replaceData: (data: unknown) => DataPatch[];
-    setBlockType: (id: BlockId, type: string) => Prepared;
-    patchData: (target: DataTarget, patches: readonly DataPatch[]) => Prepared;
-    setBlock: (id: BlockId, value: {
-        type?: string;
-        data?: Record<string, unknown>;
-        content?: (ContentItem | JSONText | JSONInlineBlock)[];
-        children?: (BlockSpec | JSONBlock)[];
-    }) => Prepared;
-};
-export type MetaOps = ReturnType<typeof metaOps>;