edytor 1.0.0 → 2.0.0

package/dist/crdt/edytor-doc.js

@@ -135,7 +135,7 @@ export const docFacade = (Y, layers) => {
         const base = { Y, doc, runsView, roles, roleOf, rendersContentOf };
         const reads = { ...base, ...docReads(base) };
         const shape = { ...reads, ...docCapability(reads) };
-        const { blockJSON, view, blockTypeOf, blockDataOf, docData, dataItemIds, childrenIds, positionOf, pathOf, ancestorsOf, slotOf, isVoid, isIsland, isLines, islandOf, insideIsland, isLayout, isLayoutItem, order, compare, next, previous, displayLength, contentItems, hasBlock, live } = reads;
+        const { blockJSON, view, blockTypeOf, blockDataOf, docData, dataItemIds, dataPreview, childrenIds, positionOf, pathOf, ancestorsOf, slotOf, isVoid, isIsland, isLines, islandOf, insideIsland, isLayout, isLayoutItem, order, compare, next, previous, displayLength, contentItems, hasBlock, live } = reads;
         const { canPlace, fits, nestParent, canMerge, defaultChild } = shape;
         const funnel = writeFunnel({ ...reads, BA, config });
         const { write, apply } = funnel;
@@ -262,6 +262,7 @@ export const docFacade = (Y, layers) => {
             blockDataOf: byRef(blockDataOf),
             docData,
             dataItemIds,
+            dataPreview,
             /**
              * Compact per-block attribution (`{createdBy, contributors,
              * lastChangedBy}`), or `undefined` for unauthored/system blocks.

package/dist/crdt/index.d.ts

@@ -280,6 +280,12 @@ export declare const bindCrdt: (Y: EngineApi) => {
             blockDataOf: (id: string) => Record<string, unknown> | undefined;
             docData: () => import("./doc/types.js").JsonObj;
             dataItemIds: (target: import("./edytor-doc.js").DataTarget, path: readonly string[]) => string[];
+            dataPreview: (target: import("./edytor-doc.js").DataTarget, pending: readonly import("./data.js").DataPatch[]) => {
+                data: {
+                    [x: string]: unknown;
+                };
+                ids: (path: readonly string[]) => string[];
+            } | null;
             blockAttribution: (id: string) => import("./index.js").BlockAttribution | undefined;
             crdtId: (id: string) => string | null;
             resolveBlock: (id: string) => import("./engine-api.js").EngineNode | null;

package/dist/crdt/operations.d.ts

@@ -149,4 +149,4 @@ export interface DocumentOperations extends DocumentWrites, DocumentReads {
 /** Every write of `DocumentWrites`: what a view dispatches under the same names (`edytor.insertBlocks(…)`). */
 export declare const DOCUMENT_WRITES: readonly ["insertBlocks", "moveBlocks", "nestBlock", "unNestBlock", "unNestBlocks", "liftOut", "wrapInLayout", "placeBeside", "splitBlock", "mergeBlocks", "mergeBackward", "mergeForward", "deleteBlock", "deleteBlocks", "setBlock", "setBlockType", "patchData", "duplicateBlock", "insertText", "deleteText", "formatRange", "clearMarks", "insertInline", "removeInline", "deleteRange", "replaceRange", "insertFlow"];
 /** Every name of `DocumentOperations`, for the document's own members (`EdytorDocument`). */
-export declare const DOCUMENT_OPERATIONS: readonly ["insertBlocks", "moveBlocks", "nestBlock", "unNestBlock", "unNestBlocks", "liftOut", "wrapInLayout", "placeBeside", "splitBlock", "mergeBlocks", "mergeBackward", "mergeForward", "deleteBlock", "deleteBlocks", "setBlock", "setBlockType", "patchData", "duplicateBlock", "insertText", "deleteText", "formatRange", "clearMarks", "insertInline", "removeInline", "deleteRange", "replaceRange", "insertFlow", "toJSON", "docData", "dataItemIds", "project", "blockJSON", "childrenIds", "parentOf", "ancestorsOf", "positionOf", "pathOf", "blockTypeOf", "blockDataOf", "blockText", "contentItems", "displayLength", "runs", "hasBlock", "isVisibleBlock", "listBlockIds", "blockAttribution", "isVoid", "isIsland", "isLines", "islandOf", "insideIsland", "isLayout", "isLayoutItem", "besideAt", "isTable", "isTableRow", "isTableCell", "tableOf", "tableColumns", "tableGrid", "order", "compare", "next", "previous", "canPlace", "canMerge", "fits", "nestParent", "landingOf", "anchorAt", "resolveAnchor", "prepare", "apply", "compose", "transact", "onChange", "version"];
+export declare const DOCUMENT_OPERATIONS: readonly ["insertBlocks", "moveBlocks", "nestBlock", "unNestBlock", "unNestBlocks", "liftOut", "wrapInLayout", "placeBeside", "splitBlock", "mergeBlocks", "mergeBackward", "mergeForward", "deleteBlock", "deleteBlocks", "setBlock", "setBlockType", "patchData", "duplicateBlock", "insertText", "deleteText", "formatRange", "clearMarks", "insertInline", "removeInline", "deleteRange", "replaceRange", "insertFlow", "toJSON", "docData", "dataItemIds", "dataPreview", "project", "blockJSON", "childrenIds", "parentOf", "ancestorsOf", "positionOf", "pathOf", "blockTypeOf", "blockDataOf", "blockText", "contentItems", "displayLength", "runs", "hasBlock", "isVisibleBlock", "listBlockIds", "blockAttribution", "isVoid", "isIsland", "isLines", "islandOf", "insideIsland", "isLayout", "isLayoutItem", "besideAt", "isTable", "isTableRow", "isTableCell", "tableOf", "tableColumns", "tableGrid", "order", "compare", "next", "previous", "canPlace", "canMerge", "fits", "nestParent", "landingOf", "anchorAt", "resolveAnchor", "prepare", "apply", "compose", "transact", "onChange", "version"];

package/dist/crdt/operations.js

@@ -34,6 +34,7 @@ export const DOCUMENT_OPERATIONS = [
     'toJSON',
     'docData',
     'dataItemIds',
+    'dataPreview',
     'project',
     'blockJSON',
     'childrenIds',

package/dist/crdt/props.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Properties: the deep proxy behind `block.data`, `atom.data`,
+ * `edytor.data` and `document.data` (SyncedStore's feel, one small module).
+ * It is sugar over the one write path: every mutation is a data patch
+ * handed to `write`, which is the `patchData` operation (dispatched on a
+ * view, raw on a bare document).
+ *
+ * A read goes to `read()` every time (the live source), so a reactive
+ * reader of `block.data.title` re-runs when anyone changes it, and a key a
+ * peer deletes is gone. Plain objects read as nested proxies, arrays as
+ * array proxies, everything else as the raw value; a proxy is cached per
+ * path, so its identity is stable. An object or array held in an array
+ * item is that item's (its path names the item by id, from `ids`): it
+ * stays on its item wherever peers move it, so `{#each list as item (item)}`
+ * keeps a row on its item; once the item is removed, its writes are
+ * refused. A key is a path segment as `keySegment` writes it.
+ *
+ * Writes, each the patch of only what it changes (per-leaf storage, so
+ * concurrent edits of other keys and items merge): `obj.key = v`,
+ * `arr[i] = v` and `delete obj.key` patch that path; `push`, `pop`,
+ * `shift`, `unshift`, `splice` and `length` are one `splice` (the items
+ * kept keep their ids), `sort` and `reverse` one `order` (the items move),
+ * `fill` and `copyWithin` writes of the items they change. Assigning a
+ * value equal to the one there writes nothing. `JSON.stringify` and
+ * `$state.snapshot` read plain JSON through it.
+ */
+import { type DataPatch } from './data.js';
+type Json = Record<string, unknown>;
+export declare const propsProxy: <T extends object = Json>(read: () => Json, write: (ops: DataPatch[]) => void, 
+/** The ids of the items of the array at a path (`facade.dataItemIds`). */
+ids?: (path: readonly string[]) => string[]) => T;
+export {};

package/dist/crdt/props.js

@@ -0,0 +1,172 @@
+/**
+ * Properties: the deep proxy behind `block.data`, `atom.data`,
+ * `edytor.data` and `document.data` (SyncedStore's feel, one small module).
+ * It is sugar over the one write path: every mutation is a data patch
+ * handed to `write`, which is the `patchData` operation (dispatched on a
+ * view, raw on a bare document).
+ *
+ * A read goes to `read()` every time (the live source), so a reactive
+ * reader of `block.data.title` re-runs when anyone changes it, and a key a
+ * peer deletes is gone. Plain objects read as nested proxies, arrays as
+ * array proxies, everything else as the raw value; a proxy is cached per
+ * path, so its identity is stable. An object or array held in an array
+ * item is that item's (its path names the item by id, from `ids`): it
+ * stays on its item wherever peers move it, so `{#each list as item (item)}`
+ * keeps a row on its item; once the item is removed, its writes are
+ * refused. A key is a path segment as `keySegment` writes it.
+ *
+ * Writes, each the patch of only what it changes (per-leaf storage, so
+ * concurrent edits of other keys and items merge): `obj.key = v`,
+ * `arr[i] = v` and `delete obj.key` patch that path; `push`, `pop`,
+ * `shift`, `unshift`, `splice` and `length` are one `splice` (the items
+ * kept keep their ids), `sort` and `reverse` one `order` (the items move),
+ * `fill` and `copyWithin` writes of the items they change. Assigning a
+ * value equal to the one there writes nothing. `JSON.stringify` and
+ * `$state.snapshot` read plain JSON through it.
+ */
+import { isObject, keySegment, segmentKey } from './data.js';
+import { jsonEquals } from '../utils/json.js';
+/** A plain JSON copy (proxies included), or `undefined`. */
+const plain = (v) => (v === undefined ? v : JSON.parse(JSON.stringify(v)));
+/** The items of `now` that differ from `was`, as writes of those items. */
+const changed = (_, __, was, now) => now.flatMap((value, i) => JSON.stringify(value) === JSON.stringify(was[i]) ? [] : [{ at: `${i}`, value }]);
+/**
+ * Each array mutator as the patches of the array (or of its items `at`),
+ * from its length `n`, the call's `args`, the array `was` and the result `out`.
+ */
+const MUTATORS = {
+    push: (n, args) => ({ splice: [n, 0, ...args] }),
+    pop: (n) => ({ splice: [Math.max(n - 1, 0), n && 1] }),
+    shift: () => ({ splice: [0, 1] }),
+    unshift: (_, args) => ({ splice: [0, 0, ...args] }),
+    // The start and count `splice` resolved (negative, fractional, past the end).
+    splice: (n, [start, , ...items], _, out) => {
+        const s = Math.trunc(Number(start)) || 0;
+        return { splice: [s < 0 ? Math.max(n + s, 0) : Math.min(s, n), out.length, ...items] };
+    },
+    sort: (n, [compare], was) => ({ order: sorted(n, was, compare) }),
+    reverse: (n) => ({ order: Array.from({ length: n }, (_, i) => n - 1 - i) }),
+    fill: changed,
+    copyWithin: changed
+};
+/** The indexes `Array.prototype.sort` puts `values` in (stable, `undefined` compare: by string). */
+const sorted = (n, values, compare) => {
+    const by = typeof compare === 'function'
+        ? compare
+        : (a, b) => (`${a}` < `${b}` ? -1 : `${a}` > `${b}` ? 1 : 0);
+    return Array.from({ length: n }, (_, i) => i).sort((a, b) => by(values[a], values[b]));
+};
+export const propsProxy = (read, write, 
+/** The ids of the items of the array at a path (`facade.dataItemIds`). */
+ids = () => []) => {
+    const cache = new Map();
+    // Item ids per array path, for the value `read()` last gave.
+    let seen;
+    const known = new Map();
+    const idsOf = (path) => {
+        const now = read();
+        if (now !== seen) {
+            seen = now;
+            known.clear();
+        }
+        const key = JSON.stringify(path);
+        return known.get(key) ?? known.set(key, ids(path)).get(key);
+    };
+    const at = (path) => path.reduce((v, k, n) => /^~[a-z]/.test(k)
+        ? Array.isArray(v)
+            ? v[idsOf(path.slice(0, n)).indexOf(k)]
+            : undefined // its array is gone
+        : v !== null && typeof v === 'object'
+            ? v[segmentKey(k)]
+            : undefined, read());
+    const put = (path, value) => {
+        const next = plain(value);
+        if (jsonEquals(at(path), next))
+            return;
+        write([{ path, ...(next !== undefined && { value: next }) }]);
+    };
+    const wrap = (path, v) => Array.isArray(v) || isObject(v) ? proxy(path, Array.isArray(v)) : v;
+    const proxy = (path, array) => {
+        const key = `${array ? '[' : '{'}${JSON.stringify(path)}`;
+        const cached = cache.get(key);
+        if (cached)
+            return cached;
+        const current = () => {
+            const v = at(path);
+            return array ? (Array.isArray(v) ? v : []) : isObject(v) ? v : {};
+        };
+        /** The path of child `k`: an item by its id, a key as its segment. */
+        const child = (k) => [...path, (array && idsOf(path)[Number(k)]) || keySegment(k)];
+        const items = () => current().map((v, i) => wrap(child(`${i}`), v));
+        const own = (k) => Object.prototype.hasOwnProperty.call(current(), k);
+        const made = new Proxy(array ? [] : {}, {
+            get(target, k) {
+                if (typeof k === 'symbol')
+                    return array && k === Symbol.iterator
+                        ? () => items()[Symbol.iterator]()
+                        : Reflect.get(target, k);
+                if (array && k === 'length')
+                    return current().length;
+                if (own(k))
+                    return wrap(child(k), current()[k]);
+                if (array && Object.hasOwn(MUTATORS, k))
+                    return (...args) => {
+                        const was = plain(current());
+                        const next = [...was];
+                        const fn = Array.prototype[k];
+                        args = args.map((a) => (a !== null && typeof a === 'object' ? plain(a) : a));
+                        const out = fn.apply(next, args);
+                        const ops = [MUTATORS[k](was.length, args, was, out)].flat();
+                        if (!jsonEquals(was, next))
+                            write(ops.map(({ at, ...op }) => ({ ...op, path: at ? [...path, at] : path })));
+                        return out === next ? made : out;
+                    };
+                const method = array ? Array.prototype[k] : undefined;
+                if (typeof method === 'function')
+                    return (...args) => method.apply(items(), args);
+                return Reflect.get(target, k);
+            },
+            set(_, k, value) {
+                if (typeof k === 'symbol')
+                    return false;
+                if (array && k === 'length') {
+                    const n = current().length;
+                    const nulls = Array.from({ length: Math.max(value - n, 0) }, () => null);
+                    write([{ path, splice: [Math.min(value, n), Math.max(n - value, 0), ...nulls] }]);
+                }
+                else
+                    put([...path, keySegment(k)], value);
+                return true;
+            },
+            deleteProperty(_, k) {
+                if (typeof k === 'symbol')
+                    return false;
+                if (own(k))
+                    put([...path, keySegment(k)], undefined);
+                return true;
+            },
+            has: (target, k) => (typeof k === 'string' && own(k)) || Reflect.has(target, k),
+            ownKeys: () => [...Object.keys(current()), ...(array ? ['length'] : [])],
+            getOwnPropertyDescriptor(target, k) {
+                if (array && k === 'length')
+                    return (Reflect.getOwnPropertyDescriptor(target, k) && {
+                        value: current().length,
+                        writable: true,
+                        enumerable: false,
+                        configurable: false
+                    });
+                if (typeof k !== 'string' || !own(k))
+                    return undefined;
+                return {
+                    value: wrap(child(k), current()[k]),
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                };
+            }
+        });
+        cache.set(key, made);
+        return made;
+    };
+    return proxy([], false);
+};

package/dist/{plugins/blockHandles → dnd}/dropIndicator.d.ts

@@ -5,8 +5,8 @@
  * future parent's own row. Both live in the overlay layer, measured each
  * frame. The controller decides the placement; this draws it.
  */
-import type { Block } from '../../block/block.svelte.js';
-import type { Edytor } from '../../edytor.svelte.js';
+import type { Block } from '../block/block.svelte.js';
+import type { Edytor } from '../edytor.svelte.js';
 import { type DropPlacement } from './geometry.js';
 /** What the indicator reads of the controller: the dragged blocks and the beside resolution. */
 type IndicatorContext = {

package/dist/{plugins/blockHandles → dnd}/geometry.d.ts

@@ -4,8 +4,8 @@
  * placement's shape, a block's own row, its first text line and one
  * nesting step.
  */
-import type { Block } from '../../block/block.svelte.js';
-import type { BlockMovePosition } from '../../session/moves.js';
+import type { Block } from '../block/block.svelte.js';
+import type { BlockMovePosition } from '../session/moves.js';
 export type DropPlacement = {
     target: Block;
     node: HTMLElement;

package/dist/dnd/placement.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Where a drop lands in a view (Notion's rules): the one resolution a block
+ * handle's drag and a file dragged from outside both read, and the drop
+ * indicator draws (`dropIndicator.ts`). A drag is what it carries
+ * (`Drag`: the blocks it moves, none for files) and the placements the
+ * document takes for it (`fits`); the rows are the view's drop targets
+ * (`targetOf`). The block handles wire it to the drag library; a file drag
+ * reads it from the host's own `dragover` (the media plugins' `plugins/fileDrop.ts`).
+ */
+import type { Block } from '../block/block.svelte.js';
+import type { Edytor } from '../edytor.svelte.js';
+import type { DropIndicator } from './dropIndicator.js';
+import { type DropPlacement } from './geometry.js';
+export type Input = {
+    clientX: number;
+    clientY: number;
+};
+/** What a drag carries: the blocks it moves (none for files), and whether a placement takes it. */
+export type Drag = {
+    group: readonly Block[];
+    fits: (placement: DropPlacement) => boolean;
+};
+/** How far beside a target's box it stays the drop target (`getIsSticky`), across and along. */
+export declare const SLOP_X = 20;
+export declare const SLOP_Y = 24;
+/**
+ * A block a drop may land at (a drop target): a movable block, not a
+ * table's row (its row menus move it) nor a cell.
+ */
+export declare const isDropTarget: (edytor: Edytor, block: Block) => boolean;
+type ResolverContext = {
+    /** The drop target block of a block element, if it is one. */
+    targetOf: (node: HTMLElement) => Block | undefined;
+    /** The drag's handle (its width is the handle column's), if any. */
+    handle: () => HTMLElement | null;
+    /** The indicator showing the drag's placement (a margin's reorder holds while it shows). */
+    indicator: DropIndicator;
+};
+export declare class DropResolver {
+    private readonly edytor;
+    private readonly ctx;
+    constructor(edytor: Edytor, ctx: ResolverContext);
+    targetOf: (node: HTMLElement) => Block | undefined;
+    isTarget: (node: HTMLElement) => boolean;
+    /**
+     * The placement over `row` at the pointer: a beside band of the row first
+     * (`beside`; `false` when the document refuses it: nothing shows), else
+     * the row's halves, the top one first when `before` (the pointer's half,
+     * or the one a sticky target holds).
+     */
+    at(drag: Drag, row: Block, input: Input, before: boolean): DropPlacement | null | false;
+    /**
+     * The drop target under the pointer for a drag the host's own events see
+     * (a file's): the innermost target element at the point, `null` outside
+     * the blocks and in the handle column (the margins answer there,
+     * `margin`).
+     */
+    hitAt(input: Input): HTMLElement | null;
+    /** The placement over the row of drop target `node` at the pointer (`rowAt`, its own row's half: `at`). */
+    over(drag: Drag, node: HTMLElement, input: Input): DropPlacement | null | false;
+    /**
+     * The editor's content column (`start`…`end`, the root's content box:
+     * where its blocks' boxes start and end), the width of the handle column
+     * left of it (the drag's handle, measured: `+`, grip and the gap to the
+     * block) and how far the drag reaches past them (`dropReach`, the
+     * `--edytor-drop-reach` the root inherits).
+     */
+    gutter(root: HTMLElement): {
+        start: number;
+        end: number;
+        handles: number;
+        reach: number;
+    };
+    /** Whether `x` is in the handle column left of the editor's blocks (`gutter`): the page target's. */
+    inHandleColumn(x: number): boolean;
+    /**
+     * A placement in the editor's margins at the pointer (`dnd.reach`), within
+     * the editor's height, for the row the content's near edge shows at the
+     * pointer's height (`rowAt`: a nested block's own row; over a layout, the
+     * row of its first column on the left, of its last on the right, never
+     * another), by the zone the pointer is in (`marginAt`):
+     * - the handle column left of the blocks (`gutter`): that row's reorder
+     *   (`reorder`): a drag straight down the handles reorders, row after
+     *   row, gaps included (never a beside band);
+     * - the first `BESIDE_MARGIN` px past it on the left, and past the
+     *   content's right edge: the beside band of that side (`beside`, as if
+     *   the pointer were at that edge) when the document has a layout kind
+     *   and the row offers one (a refused band shows nothing);
+     * - elsewhere within the reach (and there without a band): the reorder,
+     *   on the left the handle column's, on the right the one the row's
+     *   right edge offers (its halves as just inside the content, so nothing
+     *   jumps as the pointer leaves it).
+     * `undefined` past the reach, above or below the editor, and inside the
+     * content (the blocks' own targets answer there).
+     */
+    margin(drag: Drag, { clientX: x, clientY: y }: Input): DropPlacement | undefined;
+    /**
+     * The halves of `row` (`zones`) at the pointer, the one it is in first:
+     * the top half of `rect` (its own row by default) before, the bottom one
+     * after; with `plain`, only before or after a block — never inside one.
+     */
+    halves(drag: Drag, row: Block, input: Input, rect: DOMRect, plain?: boolean): DropPlacement[][];
+    /**
+     * The first placement of `halves` the document takes (a refused one gives
+     * way to the next, then to the other half's), `blocked` when the first
+     * half took none; `null` when none fits.
+     */
+    pick(drag: Drag, halves: DropPlacement[][]): DropPlacement | null;
+    /**
+     * The handle column's reorder over `row` at the pointer: its plain halves
+     * (`halves`, the pointer's x picking the level); `null` when neither half
+     * fits. Over an item of a container the dragged blocks do not fit in (a
+     * paragraph over a list's item: the document refuses every placement at
+     * the item's level), the container is the row: its whole box, the upper
+     * half before it, the lower half after it (round 4), so a drag down the
+     * handles meets the list as one row it can pass.
+     */
+    reorder(drag: Drag, row: Block, input: Input): DropPlacement | null;
+    /**
+     * The block whose row the pointer is on over `node`: the last shown drop
+     * target in it whose row starts at or above the pointer (beside a nested
+     * block, over its ancestors' indent, the pointer is on that block's
+     * row), else `target`, over its own row (`emptied`). A layout's columns
+     * sit side by side: only the one under the pointer is measured (between
+     * two of them, the layout is the row: its gap).
+     */
+    rowAt(drag: Drag, target: Block, node: HTMLElement, { clientX, clientY }: Input): Block;
+    /** Whether the document has a layout kind: only then are there beside placements. */
+    get layouts(): boolean;
+    /**
+     * The block a beside placement over `block` stands beside: the document's
+     * own resolution (`facade.besideAt`, `placeBeside`'s): a list item's list,
+     * a code line's code block, a toggle's child itself, an item itself.
+     */
+    besideOf(block: Block): Block;
+    /** The item (and its layout) a beside placement at `outer` (`besideOf`) adds a column beside. */
+    layoutOf(outer: Block): {
+        item: Block;
+        layout: Block | null;
+    } | null;
+    /**
+     * Whether `x` is over a column other than one holding `block`: a sticky
+     * target never holds the pointer across a column boundary.
+     */
+    overOtherColumn(block: Block, x: number): boolean;
+    /**
+     * Notion's beside bands over `row` (`docs/columns-plan.md`, "View layer"), only while the
+     * pointer is within its own row's height, the document has a layout kind
+     * and the layout the drop makes or grows does not stack (`stacks`):
+     * - right: the row's last 15% (at least 32px), and the slop past it;
+     * - left: the slop left of the row (its sticky margin, left of its text
+     *   column), only for a row whose parent is the root or a column (a
+     *   list's item: its list's) — a nested row keeps the pointer's x for its
+     *   levels (`zones`) — and only
+     *   inside the editor (a column's gap): left of the editor's blocks is the
+     *   handle column, which reorders (`margin`);
+     * - over a layout's gap (the row is the layout): right of the column
+     *   before it, a new column between.
+     * `undefined` outside the bands (the hitbox's halves stand), else the
+     * placement, or `null` when the document refuses it: a refused band shows
+     * nothing.
+     */
+    beside(drag: Drag, row: Block, { clientX: x, clientY: y }: Input, band?: 'left' | 'right'): DropPlacement | null | undefined;
+    /** Where the editor's blocks start (`gutter`), or `fallback` without a host. */
+    inside(fallback: number): number;
+    /** The children a block shows: none for a closed toggle's, or a container's items. */
+    shown(block: Block): Block[];
+    /**
+     * Over a dragged block, the parent it leaves when that parent shows no
+     * other child: the gap under the parent's own row, which reparents as
+     * the parent's lower half does (`zones`). Else `row`.
+     */
+    emptied(drag: Drag, row: Block): Block;
+    /**
+     * The placements over `row`, each half's in preference order (a refused
+     * one gives way to the next, then to the other half's):
+     * - the top half: before it;
+     * - the bottom half of a block whose children show (not a closed toggle):
+     *   its first child's slot. Pragmatic drag and drop's tree rule: an
+     *   expanded item offers no "after" on its own row;
+     * - else, after it at the level whose text column is nearest the pointer:
+     *   the last block of a nested group reparents to any ancestor it ends,
+     *   down to the root. Past one nesting step right of its text start,
+     *   inside it (its last child) first. A block every shown child of which
+     *   is dragged is not expanded: its levels, never inside it when the drag
+     *   moves only its children (they would stay where they are).
+     * None over a dragged block's own row or its subtree: released there, the
+     * drag changes nothing (its levels would outdent it) — unless it empties
+     * its parent's shown children (`emptied`): that parent's row. Over the
+     * hint of the row's empty body (`body.hint`: an open toggle's, a
+     * callout's), inside it first, either half.
+     */
+    zones(drag: Drag, row: Block, { clientX, clientY }: Input): {
+        before: DropPlacement[];
+        after: DropPlacement[];
+    };
+    /** The dragged block that is `row` or holds it: its row offers nothing (it moves with the drag). */
+    carrier(drag: Drag, row: Block): Block | undefined;
+}
+export {};