edytor 2.0.0 → 4.0.0

package/dist/plugins/triggers/triggers.d.ts

@@ -9,9 +9,14 @@
  * none of it.
  */
 import type { Edytor } from '../../edytor.svelte.js';
-import type { InitializedPlugin, InputRule, Trigger } from '../../plugins.js';
+import type { InitializedPlugin, InputRule, TextRuleContext, Trigger } from '../../plugins.js';
 import { type TextTriggerController } from './TriggerController.svelte.js';
 import { type HeldList } from '../list.svelte.js';
+/**
+ * Write `atom` where the matched text starts (`ctx.from`: a trigger's pick,
+ * an input rule's replacement), the caret after it; whether it was written.
+ */
+export declare const placeAtom: ({ edytor, block, from, caret }: TextRuleContext, atom: Parameters<Edytor["insertInline"]>[2]) => boolean;
 /**
  * `plugin` with `inputRules` (text typed at the caret that a rule
  * replaces: markdown, `:smile:` → 😄) and `triggers` (characters that open

package/dist/plugins/triggers/triggers.js

@@ -1,7 +1,5 @@
 import { inputRulesHook } from '../../session/inputRules.js';
 import { TriggerMenuController } from './TriggerController.svelte.js';
-import { caretRect } from './place.js';
-import { placeNear } from '../../surface/overlay.js';
 import { listHotkeys } from '../list.svelte.js';
 import { mountChrome } from '../chrome.js';
 /** Two bindings of one chord, `first`'s claim ending the key. */
@@ -11,6 +9,16 @@ const both = (first, then) => (payload) => {
 };
 /** The triggers each view numbered so far: a trigger's popup owner name. */
 const counts = new WeakMap();
+/**
+ * Write `atom` where the matched text starts (`ctx.from`: a trigger's pick,
+ * an input rule's replacement), the caret after it; whether it was written.
+ */
+export const placeAtom = ({ edytor, block, from, caret }, atom) => {
+    const written = edytor.insertInline(block.id, from, atom).status === 'applied';
+    if (written)
+        caret(from + 1);
+    return written;
+};
 /**
  * `plugin` with `inputRules` (text typed at the caret that a rule
  * replaces: markdown, `:smile:` → 😄) and `triggers` (characters that open
@@ -47,17 +55,8 @@ export const withRulesAndTriggers = (edytor, plugin, { inputRules = [], triggers
             : undefined,
         close: () => controller.close()
     }), 
-    // Below the caret (above it when there is no room), kept in the viewport.
-    (controller) => mountChrome(edytor, controller.trigger.menu, controller, () => controller.isOpen, {
-        name: 'edytor-trigger-menu-host',
-        zIndex: 50,
-        measure: (host) => {
-            if (!controller.isOpen)
-                return;
-            const rect = caretRect(edytor);
-            return rect && placeNear(host, rect, [280, 240]);
-        }
-    }, () => controller.close()));
+    // Its markup places itself by the controller's `anchor` (the caret).
+    (controller) => mountChrome(edytor, controller.trigger.menu, controller, () => controller.isOpen, { name: 'edytor-trigger-menu-host', zIndex: 50 }, () => controller.close()));
 };
 /**
  * `plugin` with trigger menus wired into its hooks (a plugin's `triggers`,

package/dist/plugins/uploads.svelte.d.ts

@@ -1,7 +1,8 @@
 import type { Edytor } from '../edytor.svelte.js';
 import type { PluginDefinitions, PluginOperations } from '../plugins.js';
 import type { DropAt } from '../session/attempt.js';
-import { type FileDropPort, type ViewUploads } from '../session/uploads.js';
+import { type ViewUploads } from '../session/uploads.js';
+import { FileDrag } from './fileDrop.js';
 /** What an `upload` may report while it runs. */
 export type UploadReport = {
     /** The share sent so far, `0` to `1`: the block shows it as a bar. */
@@ -77,8 +78,10 @@ export declare class FileUploads implements ViewUploads {
     constructor(edytor: Edytor);
     /** The kind that takes `file`, if any. */
     kindOf: (file: File) => string | undefined;
+    /** The types of the kinds that take files. */
+    get types(): string[];
     /** Files dragged from outside: the drop indicator and the placement (`fileDrop.ts`). */
-    readonly drop: FileDropPort;
+    readonly drop: FileDrag;
     /** The upload of block `id` in this view (reactive), if any. */
     of: (id: string) => FileUpload | undefined;
     /**

package/dist/plugins/uploads.svelte.js

@@ -4,7 +4,12 @@ import { jsonBlockToSpec } from '../utils/json.js';
 import { id as mint } from '../utils.js';
 import { placeNew } from '../session/moves.js';
 import { claimUploads, viewUploads } from '../session/uploads.js';
-import { fileDragEnd, fileDragOver, fileDropAt } from './fileDrop.js';
+import { FileDrag } from './fileDrop.js';
+/** An upload's object URL, while it uploads, released. */
+const revoke = (upload) => {
+    if (upload?.status === 'uploading' && upload.preview)
+        URL.revokeObjectURL(upload.preview);
+};
 /**
  * The view's uploads (`media.files`), one per view, claimed by the first
  * media plugin listed with an `upload`: the uploads of pasted, dropped and
@@ -29,6 +34,7 @@ export class FileUploads {
     #uploads = new SvelteMap();
     constructor(edytor) {
         this.edytor = edytor;
+        this.drop = new FileDrag(edytor, this);
     }
     /** The kinds that take files (their records' `upload`), in registration order. */
     get #kinds() {
@@ -39,12 +45,12 @@ export class FileUploads {
         this.#kinds.find((kind) => kind.fallback && kind.accepts(file));
     /** The kind that takes `file`, if any. */
     kindOf = (file) => this.#kindOf(file)?.type;
+    /** The types of the kinds that take files. */
+    get types() {
+        return this.#kinds.map((kind) => kind.type);
+    }
     /** Files dragged from outside: the drop indicator and the placement (`fileDrop.ts`). */
-    drop = {
-        over: (event) => fileDragOver(this.edytor, event) !== null,
-        at: (event) => fileDropAt(this.edytor, event),
-        end: () => fileDragEnd(this.edytor)
-    };
+    drop;
     /** The upload of block `id` in this view (reactive), if any. */
     of = (id) => this.#uploads.get(id);
     /**
@@ -133,9 +139,7 @@ export class FileUploads {
     };
     /** Release every preview. */
     destroy = () => {
-        for (const upload of this.#uploads.values())
-            if (upload.status === 'uploading' && upload.preview)
-                URL.revokeObjectURL(upload.preview);
+        this.#uploads.forEach(revoke);
         this.#uploads.clear();
     };
     /**
@@ -168,8 +172,7 @@ export class FileUploads {
         const upload = this.#uploads.get(id);
         if (upload?.status !== 'uploading')
             return;
-        if (upload.preview)
-            URL.revokeObjectURL(upload.preview);
+        revoke(upload);
         this.#uploads.delete(id);
     };
     #send = async (id, kind, file) => {
@@ -185,7 +188,6 @@ export class FileUploads {
             return;
         const block = edytor.idToBlock.get(id);
         const upload = this.#uploads.get(id);
-        const preview = upload?.status === 'uploading' ? upload.preview : null;
         // Given a source meanwhile (a peer, the link field): nothing to fill.
         if (block?.isInTree && kind.filled(block.data))
             this.#uploads.delete(id);
@@ -196,8 +198,7 @@ export class FileUploads {
             this.#uploads.set(id, { status: 'landed', data });
         else
             this.#write(id, data);
-        if (preview)
-            URL.revokeObjectURL(preview);
+        revoke(upload);
     };
     /** The data's write, outside the history; refused (readonly), it is held for the next show. */
     #write = (id, data) => {
@@ -229,5 +230,14 @@ export const uploadHooks = (edytor, upload) => {
         return {};
     const uploads = new FileUploads(edytor);
     claimUploads(edytor, uploads);
-    return { onPaste: uploads.paste, onEdytorAttached: () => uploads.destroy };
+    return {
+        onPaste: uploads.paste,
+        onEdytorAttached: ({ node }) => {
+            const detach = uploads.drop.attach(node);
+            return () => {
+                detach();
+                uploads.destroy();
+            };
+        }
+    };
 };

package/dist/plugins.d.ts

@@ -581,6 +581,15 @@ export type BlockDefinition = {
     html?: string | ((block: JSONBlock, content: string, children: string) => string);
     /** Clipboard plain-text form; default content then children, one per line. */
     plain?: (block: JSONBlock, content: string, children: string) => string;
+    /**
+     * Markdown form (`toMarkdown`): `content` is the block's text as inline
+     * markdown (marks by their own `markdown` forms), `children` its children's
+     * markdown, blocks apart by a blank line (indent them yourself:
+     * {@link MarkdownContext.indent}). Default: the bundled kind's of that
+     * name (`edytor/export` holds them; the bundled records carry none), else
+     * the `plain` form when the kind has one, else the content, then the children.
+     */
+    markdown?: (block: JSONBlock, content: string, children: string, context: MarkdownContext) => string;
     /**
      * HTML import: the block's data when `element` is this kind, else
      * `undefined`. Checked before the tag tables (a preset's export form or
@@ -652,6 +661,8 @@ export type InlineBlockDefinition = {
      * an empty `<span data-edytor-inline-block>`.
      */
     html?: (data: JSONInlineBlock['data']) => string;
+    /** Markdown form of the atom (`toMarkdown`, escaped by you); default its `plain` form. */
+    markdown?: (data: JSONInlineBlock['data']) => string;
     /**
      * HTML import: the atom's data when `element`, met in a line's inline
      * content, is this atom, else `undefined`. Its contents are then not read
@@ -678,6 +689,12 @@ export type MarkDefinition = {
      * matches its bare `tag` (value `true`).
      */
     parse?: (element: HTMLElement) => SerializableContent | undefined;
+    /**
+     * Markdown form (`toMarkdown`): the delimiters around the marked text
+     * (`['**', '**']`), or a function of the value giving them (a link's
+     * `['[', '](href)']`). Without one the text is exported unmarked.
+     */
+    markdown?: readonly [string, string] | ((value: any) => readonly [string, string] | undefined);
     void?: boolean;
     /** Whether typing at the mark's edges extends it (`marksForInsertion`); default `inclusive`. */
     edge?: MarkEdge;
@@ -755,3 +772,12 @@ export type EditorCommand = {
     searchOnly?: boolean;
 };
 export type InitializedPlugin = ReturnType<Plugin>;
+/** What a kind's `markdown` form is given beside its block, content and children. */
+export type MarkdownContext = {
+    /** The block's position in its run of same-kind siblings, from 1 (a numbered item's number). */
+    index: number;
+    /** Every line of `text` prefixed with `prefix` (`'  '` under a list item, `'> '` in a quote). */
+    indent: (text: string, prefix: string) => string;
+    /** Rich text as inline markdown, by the marks' and atoms' forms (a table cell's). */
+    inline: (content: JSONBlock['content']) => string;
+};

package/dist/plugins.js

@@ -1,25 +1 @@
 export {};
-// Extension-surface note (replaces stale TODOs): the gaps this used to
-// list are all covered by the contract above —
-//   * `onBeforeInput` is a PluginOperations hook (line ~111).
-//   * Block focus/selection lifecycle is `onFocus`/`onBlur`/`onSelect`/
-//     `onDeselect` on BlockDefinition.
-//   * Arrow-key and select-all behavior are hotkeys, not dedicated
-//     events: `mod+a` select-all lives in hotkeys.ts and arrow handling
-//     ships in the arrowMove plugin — plugins can override either via
-//     the `hotkeys` definition map (prevention is first-win).
-// A dedicated raw-key event hook does not exist; add one only if a real
-// consumer needs more than hotkey overrides.
-// ISLAND BLOCKS
-// Island blocks are blocks that are independent of the document.
-// They are editable
-// They can be nested inside other blocks
-// But their children can not be nested or merged with other blocks
-// Their structure will remain as if or will not.
-// In case of a merge operation, the island block will be merged with the parent block and all its children will ne unnest and set to the default block type without being added as children of the merge destination block. The same wil happen to the island's content.
-// VOID BLOCKS
-// Void blocks are blocks that are not editable
-// They can be nested inside other blocks
-// They can not accept children nor be merged with other blocks
-// If the content of the void block is rendered, it will still be editable. This to allow for rendering caption of the void block. I
-// In void blocks the content is treated as an island

package/dist/selection/replaceSelection.js

@@ -340,7 +340,7 @@ export const deleteSelectedBlocks = (edytor, blocks = selectedMembers(edytor)) =
             ...beside(blocks[0], 'blockBefore', blocks),
             ...beside(blocks.at(-1), 'blockAfter', blocks)
         ];
-    const deleted = edytor.dispatcher.caret(at?.text, at?.offset ?? 0, () => edytor.deleteBlocks(blocks.map((block) => block.id)));
+    const deleted = edytor.dispatcher.caretIn(at?.text, at?.offset ?? 0, () => edytor.deleteBlocks(blocks.map((block) => block.id)));
     if (deleted?.status !== 'applied')
         return null;
     edytor.announcer.deleted(what);
@@ -354,7 +354,7 @@ export const deleteSelectedBlocks = (edytor, blocks = selectedMembers(edytor)) =
     const text = virtual ? edytor.idToBlock.get(virtual)?.firstText : undefined;
     const survivor = besides.find((block) => block.isInTree);
     if (text)
-        edytor.dispatcher.caret(text, 0);
+        edytor.dispatcher.caretIn(text, 0);
     else if (survivor)
         edytor.selection.select(blockSelection([survivor.id]));
     return text ?? null;

package/dist/selection/selection.svelte.d.ts

@@ -94,7 +94,7 @@ export declare class EdytorSelection {
      * the start binds right (boundary inserts stay outside), the end and a
      * caret bind left; `none` when the start text is not bound to the document.
      */
-    textValue: (startText: Text, yStart: number, endText?: Text, yEnd?: number, isReversed?: boolean, startAffinity?: "left" | "right", mint?: (text: Text, offset: number, affinity?: "left" | "right") => TextAnchor | null) => SelectionValue;
+    textValue: (startText: Text, yStart: number, endText?: Text, yEnd?: number, isReversed?: boolean, startAffinity?: "left" | "right") => SelectionValue;
     /**
      * A pointer drag is in progress (a press in the host, until its release):
      * the projector does not display under it, and the overlay chrome
@@ -123,9 +123,9 @@ export declare class EdytorSelection {
      * facade maps to the owning backing text — content routed from other
      * blocks' backing texts (merges/splits) anchors correctly.
      *
-     * `null` while the text isn't bound to a live block (mirrors the
-     * baseline where a non-integrated Y.Text couldn't produce an absolute
-     * position).
+     * Minted from the text's block record, live or not (the atoms of a text
+     * that died to a merge live on in the block that claimed them); `null`
+     * for the root's own text.
      */
     createTextAnchor: (text: Text, offset: number, affinity?: "left" | "right") => TextAnchor | null;
     /**
@@ -148,12 +148,6 @@ export declare class EdytorSelection {
      * never mounts.
      */
     displayable: (id: string) => boolean;
-    /** The view's visibility rule (`selection/visibility.ts`), for extensions: hidden by view state, and the shown neighbour. */
-    hidden: (block: Block, removed?: ReadonlySet<Block>) => boolean;
-    shown: (block: Block, step: "blockBefore" | "blockAfter", { sealed, removed }?: {
-        sealed?: boolean;
-        removed?: ReadonlySet<Block>;
-    }) => Block | null;
     /** The text's computed direction (a Surface fact): arrow and word keys are visual. */
     rtl: (text: Text) => boolean;
 }

package/dist/selection/selection.svelte.js

@@ -389,7 +389,8 @@ export class EdytorSelection {
      * the start binds right (boundary inserts stay outside), the end and a
      * caret bind left; `none` when the start text is not bound to the document.
      */
-    textValue = (startText, yStart, endText = startText, yEnd = yStart, isReversed = false, startAffinity, mint = this.createTextAnchor) => {
+    textValue = (startText, yStart, endText = startText, yEnd = yStart, isReversed = false, startAffinity) => {
+        const mint = this.createTextAnchor;
         const collapsed = startText === endText && yStart === yEnd;
         const start = mint(startText, yStart, startAffinity ?? (collapsed ? 'left' : 'right'));
         if (!start)
@@ -413,9 +414,7 @@ export class EdytorSelection {
         if (!startText || !endText)
             return;
         const at = (text, offset) => Math.min(Math.max(offset, 0), text.length);
-        const value = this.textValue(startText, at(startText, yStart), endText, at(endText, yEnd), isReversed, undefined, (text, offset, side) => text.parent.isRoot
-            ? null
-            : this.edytor.facade.anchorAt(text.blockId, text.segStart + offset, side));
+        const value = this.textValue(startText, at(startText, yStart), endText, at(endText, yEnd), isReversed);
         const target = project(value, this.edytor.facade).start
             ? value
             : this.#seamValue(startText.parent?.id ?? null);
@@ -652,12 +651,12 @@ export class EdytorSelection {
      * facade maps to the owning backing text — content routed from other
      * blocks' backing texts (merges/splits) anchors correctly.
      *
-     * `null` while the text isn't bound to a live block (mirrors the
-     * baseline where a non-integrated Y.Text couldn't produce an absolute
-     * position).
+     * Minted from the text's block record, live or not (the atoms of a text
+     * that died to a merge live on in the block that claimed them); `null`
+     * for the root's own text.
      */
     createTextAnchor = (text, offset, affinity = 'left') => {
-        if (text.parent.isRoot || !text.isInDocument)
+        if (text.parent.isRoot)
             return null;
         return this.edytor.facade.anchorAt(text.blockId, text.segStart + offset, affinity);
     };
@@ -688,9 +687,6 @@ export class EdytorSelection {
             ?.content.find((part) => part instanceof Text && part.node != null)?.node;
         return !!node && !node.closest(visibility.HIDDEN);
     };
-    /** The view's visibility rule (`selection/visibility.ts`), for extensions: hidden by view state, and the shown neighbour. */
-    hidden = visibility.hidden;
-    shown = visibility.shown;
     /** The text's computed direction (a Surface fact): arrow and word keys are visual. */
     rtl = (text) => !!text.node?.isConnected && getComputedStyle(text.node).direction === 'rtl';
     /** A caret at the seam `dead` vacated (`doc/anchors`); `null` when nothing displays. */

package/dist/session/bindings.js

@@ -24,7 +24,7 @@ export const replaceSelectedAtom = (edytor, value = '') => {
     edytor.removeInline(parent.id, selected.id);
     if (value)
         edytor.insertText(parent.id, text.segStart + offset, value);
-    edytor.dispatcher.caret(text, offset + value.length);
+    edytor.dispatcher.caretIn(text, offset + value.length);
     return true;
 };
 /** The selection is the editor's own: an inline atom or blocks (no DOM range shows it). */

package/dist/session/commands.d.ts

@@ -128,18 +128,14 @@ export declare class Dispatcher {
         taken: boolean;
     };
     /**
-     * A command's result caret: selected once and recorded on the result;
-     * the projector displays it after the flush. With `ops`, the
-     * caret is declared before the command's operations run — minted while its
-     * text is live, so it survives them — and written only when they applied;
-     * meanwhile the seam repair leaves this view's endpoints to it. Takes a
-     * text segment and an offset in it, or a `{ block, offset }` caret in
-     * block offsets (an inline atom counting 1).
+     * A command's result caret, `{ block, offset }` in block offsets (an
+     * inline atom counting 1): selected once and recorded on the result;
+     * the projector displays it after the flush. With `ops`, the caret is
+     * declared before the command's operations run — minted while its text
+     * is live, so it survives them — and written only when they applied;
+     * meanwhile the seam repair leaves this view's endpoints to it.
      */
-    caret: {
-        (text: Text | null | undefined, offset: number, ops?: () => OpResult): OpResult | undefined;
-        (caret: Caret | DocPosition | null | undefined, ops?: () => OpResult): OpResult | undefined;
-    };
+    caret: (caret: Caret | DocPosition | null | undefined, ops?: () => OpResult) => OpResult | undefined;
     /**
      * The cut an operation applies as it writes. Inside a user command none
      * (the command cut); outside one, its bare policy. A led operation is a

package/dist/session/commands.js

@@ -566,27 +566,20 @@ export class Dispatcher {
         return this.running ? this.kind : null;
     }
     /**
-     * A command's result caret: selected once and recorded on the result;
-     * the projector displays it after the flush. With `ops`, the
-     * caret is declared before the command's operations run — minted while its
-     * text is live, so it survives them — and written only when they applied;
-     * meanwhile the seam repair leaves this view's endpoints to it. Takes a
-     * text segment and an offset in it, or a `{ block, offset }` caret in
-     * block offsets (an inline atom counting 1).
+     * A command's result caret, `{ block, offset }` in block offsets (an
+     * inline atom counting 1): selected once and recorded on the result;
+     * the projector displays it after the flush. With `ops`, the caret is
+     * declared before the command's operations run — minted while its text
+     * is live, so it survives them — and written only when they applied;
+     * meanwhile the seam repair leaves this view's endpoints to it.
      */
-    caret = (target, ...rest) => {
-        // The form is the arguments', not the target's: a nullish caret still runs its `ops`.
-        if (typeof rest[0] === 'number') {
-            return this.#caret(target, rest[0], rest[1]);
-        }
-        const ops = rest[0];
-        const caret = target;
-        // `{ block, offset }`: block offsets (a handle or an id), mapped to the text segment that shows the offset.
+    caret = (caret, ops) => {
         const block = typeof caret?.block === 'string' ? this.edytor.idToBlock.get(caret.block) : caret?.block;
         const at = block?.textAtOffset(Math.max(0, caret.offset));
-        return this.#caret(at?.text, at?.offset ?? 0, ops);
+        return this.caretIn(at?.text, at?.offset ?? 0, ops);
     };
-    #caret = (text, offset, ops) => {
+    /** @internal `caret` at an offset inside a text segment. */
+    caretIn = (text, offset, ops) => {
         const selection = this.edytor.selection;
         const at = text ? Math.max(0, Math.min(offset, text.length)) : 0;
         const value = text ? selection.textValue(text, at) : null;
@@ -642,7 +635,8 @@ export class Dispatcher {
         try {
             for (let i = 0; i < this.queue.length; i++) {
                 if (i === 1000) {
-                    console.warn('[edytor] normalization is not converging; skipping further passes');
+                    if (DEV)
+                        console.warn('[edytor] normalization is not converging; skipping further passes');
                     break;
                 }
                 const entry = this.queue[i];
@@ -654,7 +648,7 @@ export class Dispatcher {
                 const count = (counts.get(id) ?? 0) + 1;
                 counts.set(id, count);
                 if (count > MAX_PASSES) {
-                    if (count === MAX_PASSES + 1)
+                    if (DEV && count === MAX_PASSES + 1)
                         console.warn(`edytor: ${normalize} on block "${id}" exceeded ${MAX_PASSES - 1} passes — a plugin normalizer is not converging; skipping further passes`);
                     continue;
                 }

package/dist/session/inputRules.js

@@ -47,7 +47,7 @@ export const inputRulesHook = (edytor, rules) => {
         /** The typed text lands as typed, the caret after it. */
         const typeAsIs = () => {
             edytor.insertText(...payload);
-            dispatcher.caret(text, yStart + value.length);
+            dispatcher.caretIn(text, yStart + value.length);
         };
         /**
          * Run `rule` over `match`: whether it wrote, or `null` when it declined

package/dist/session/navigation.js

@@ -303,7 +303,7 @@ export const toTrailingParagraph = (edytor) => {
     const text = edytor.idToBlock.get(ids[0] ?? '')?.firstText;
     if (!text)
         return false;
-    edytor.dispatcher.caret(text, 0);
+    edytor.dispatcher.caretIn(text, 0);
     return true;
 };
 /**

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

@@ -1,14 +1,3 @@
-/**
- * Suggestions (site `editor/suggestions`): content one view proposes at a
- * position — AI output, a completion — shown only in that view until it is
- * accepted. Session state: nothing reaches the document, its history,
- * presence, `onChange` or another view before `accept()`, which is one
- * command (`acceptSuggestion`: admission, hooks, one transaction, one undo
- * step) placing the content as a paste places it (`flow.place`, `flow.slot`,
- * `flow.inline`). A suggestion is anchored by block ids (a text range by its
- * anchors): it survives selection changes and edits elsewhere, and is dropped
- * when its block dies. The layer owns the list; the surface renders it.
- */
 import type { BlockId, DocAnchor, OpResult } from '../crdt/index.js';
 import type { Edytor } from '../edytor.svelte.js';
 import { type JSONBlock } from '../utils/json.js';

package/dist/session/suggestions.svelte.js

@@ -1,3 +1,15 @@
+/**
+ * Suggestions (site `editor/suggestions`): content one view proposes at a
+ * position — AI output, a completion — shown only in that view until it is
+ * accepted. Session state: nothing reaches the document, its history,
+ * presence, `onChange` or another view before `accept()`, which is one
+ * command (`acceptSuggestion`: admission, hooks, one transaction, one undo
+ * step) placing the content as a paste places it (`flow.place`, `flow.slot`,
+ * `flow.inline`). A suggestion is anchored by block ids (a text range by its
+ * anchors): it survives selection changes and edits elsewhere, and is dropped
+ * when its block dies. The layer owns the list; the surface renders it.
+ */
+import { DEV } from 'esm-env';
 import { REFUSED } from '../crdt/doc/plan.js';
 import { textToBlocks } from '../clipboard/textBlocks.js';
 import { selectedMembers, viewOf } from '../selection/visibility.js';
@@ -329,17 +341,17 @@ export class Suggestions {
                 resolved = { replace: { anchor: value.anchor, focus: value.focus } };
             else {
                 const block = value.kind === 'atom' ? value.blockId : projection.start?.block;
-                resolved = block ? { after: block } : fail('no selection to replace');
+                resolved = block ? { after: block } : fail(DEV ? 'no selection to replace' : '');
             }
         }
         else
             resolved = at;
         if (!this.#alive(resolved))
-            fail('the position names no shown block');
+            fail(DEV ? 'the position names no shown block' : '');
         if ('inside' in resolved) {
             const probe = edytor.facade.prepare.insertBlocks({ parent: resolved.inside, index: 0 }, []);
             if (!('writes' in probe))
-                fail(`block "${resolved.inside}" holds no children`);
+                fail(DEV ? `block "${resolved.inside}" holds no children` : '');
         }
         return resolved;
     };

package/dist/session/uploads.d.ts

@@ -3,18 +3,18 @@
  * first media plugin given an `upload` claims (`uploadHooks`), and whether it takes a
  * file (a kind's `upload` accepts it). A file dragged over the view shows
  * where it lands only when its uploads take it (`drop`, the plugin layer's
- * `plugins/fileDrop.ts`); a view without uploads ignores dropped files.
+ * `plugins/fileDrop.ts`, Pragmatic's external adapter); a view without uploads ignores dropped files.
  */
 import type { Edytor } from '../edytor.svelte.js';
 import type { DropAt } from './attempt.js';
-/** Files dragged from outside over the view: where they land, shown. */
+/** Files dragged from outside over the view: where they land. */
 export interface FileDropPort {
-    /** A `dragover` of files: show where they land; `false` where none does (nothing shows). */
-    over(event: DragEvent): boolean;
-    /** The drop: the placement shown, re-resolved at the drop point, and nothing shows any more. */
-    at(event: DragEvent): DropAt | null;
-    /** The drag left the view, or ended: nothing shows. */
-    end(): void;
+    /**
+     * The placement the drop of files being handled landed at, once (the
+     * plugin layer's drop target resolves it before the host's `drop`
+     * listener runs); `null` where none shows.
+     */
+    take(): DropAt | null;
 }
 /** What the view's uploads answer about a file. */
 export interface ViewUploads {

package/dist/surface/lines.js

@@ -18,9 +18,7 @@ export const caretBox = (text, offset, after) => {
         const [endNode, end] = domPointOf(element, from + 1);
         range.setStart(startNode, start);
         range.setEnd(endNode, end);
-        // No layout engine (a server, jsdom) lays nothing out: no box.
-        const list = typeof range.getClientRects === 'function' ? range.getClientRects() : null;
-        return [...(list ?? [])].find((r) => r.width > 0 || r.height > 0) ?? null;
+        return [...range.getClientRects()].find((r) => r.width > 0 || r.height > 0) ?? null;
     };
     const next = box(offset);
     const previous = box(offset - 1);

package/dist/surface/observer.svelte.d.ts

@@ -2,6 +2,18 @@ import type { Edytor } from '../edytor.svelte.js';
 import type { Text } from '../text/text.svelte.js';
 import { type Kind, type Owned } from './attributes.js';
 import { type Patched, type Replaced } from './cells.js';
+/**
+ * What the browser shows for `text`: its element's text nodes in order (WebKit's
+ * converted-space wrappers read as plain spaces), the empty filler and the
+ * trailing-newline marker stripped.
+ */
+export declare const readDomText: (text: Text) => string;
+export declare const getCollapsedDomTextSelection: (edytor: Edytor) => {
+    text: Text;
+    offset: number;
+} | null;
+/** A native line break (a diff inserting only newlines at `at`) runs as the key's occurrence. */
+export declare const lineBreak: (edytor: Edytor, text: Text, value: string, at: number) => Promise<void>;
 export declare class SurfaceObserver {
     #private;
     private edytor;
@@ -12,7 +24,11 @@ export declare class SurfaceObserver {
     constructor(edytor: Edytor);
     /** Observe `root` (the host): records name what to compare. */
     attach: (root: HTMLElement) => () => void;
-    /** Register an element the core rendered (an attachment); returns its release. */
+    /**
+     * Register an element the core rendered (an attachment); returns its
+     * release. A text element takes the table's attributes now (its id, its
+     * editing host inside a void).
+     */
     register: (node: Element, kind: Kind, block: string, name?: string, owned?: () => Owned) => () => void;
     /** The render anchor (`Edytor.svelte`): a registered child of the strict root. */
     anchor: (node: HTMLElement) => {