edytor 0.0.11 → 0.1.0-next.16

package/README.md

@@ -1,231 +1,111 @@
 <div align="center">
   <img src="cover.jpg" alt="Edytor Logo" width="60%"/>
 
-  <p>A powerful, extensible rich text editor built with Svelte and Y.js</p>
+<p>A collaborative block editor for Svelte 5, on a Yjs v14 engine</p>
 
-[![npm version](https://badge.fury.io/js/edytor.svg)](https://badge.fury.io/js/edytor)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)
 [![Svelte v5](https://img.shields.io/badge/Svelte-v5-FF3E00.svg)](https://svelte.dev)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.0-blue.svg)](https://www.typescriptlang.org/)
 
-  <p>
-    <a href="#features">Features</a> •
-    <a href="#quick-start">Quick Start</a> •
+<p>
+    <a href="https://edytor-docs.beynar.workers.dev/docs">Documentation</a> •
+    <a href="#quick-start">Quick start</a> •
+    <a href="https://edytor-docs.beynar.workers.dev/docs/reference/migration">Migrating from 0.0.11</a>
   </p>
 </div>
 
-Edytor aims to be the premier rich text editor for Svelte, providing the same level of power, flexibility and extensibility that Slate.js offers for React. Like Slate.js, Edytor strives to be heavily customizable and provide a powerful API to build any kind of collaborative rich text editor.
-
-## ⚠️ Work in progress
-
-Edytor is currently in the early stages of development. It is not yet ready for production use.
-I welcome early contributors to help us build a better editor for Svelte.
-Just run it, see what you can do with it, and open issues or PRs.
-
-If you want to submit an issue please share the json value of the document. It will help understand and fix the issue.
-
-## ✨ Features
-
-- 📑 **Customizable with snippets**: Use snippets to render your own blocks and marks
-- 🎨 **Rich Text Formatting**: Full support for marks, blocks and inline blocks.
-- 🤝 **Real-time Collaboration**: Uses Y.js as data store, collaborative editing is built-in
-- 🔌 **Plugin System**: Extensible architecture for custom features. I try to make every action performed by the editor hackable and preventable to let you build your own features.
-- ⚡ **High Performance**: Optimized for large documents, fine grained update at the leaf level thanks to Y.js and Svelte's reactivity
-- 🔄 **Undo/Redo**: Built-in history management
-- 📦 **Lightweight**: Relatively small bundle size compared to other rich text editors
-- 📦 **AI copilot ready**: Support inline text suggestions for ai completions.
-
-## ✨ Things that are ready
-
-- [x] YJS backed editing
-- [x] Basic block operations and text operations.
-- [x] Stable data structure
-- [x] Undo/Redo
-- [x] Rich text formatting
-- [x] Customizable with snippets
-- [x] Plugin system
-- [x] Text suggestions
-- [x] Inline blocks
-- [x] Nesting
-- [x] Selection + movable blocks
-- [x] Content transformation
-- [x] Content normalization
-- [x] Island blocks
-- [x] Customizable hotkeys
-- [x] Void elements and editable void elements
-- [x] Text spanning deletion
-- [x] Block spanning deletion.
-- [x] Readable JSON data structure
-- [x] Readonly edytor to lightweightly render static content without the Y.js extra works.
-
-## ✨ Things that are not ready
-
-- [ ] DND
-- [ ] Battle tested collaborative editing + awareness + providers
-- [ ] Children normalization
-- [ ] Children transformation
-- [ ] Block suggestions
-- [ ] Reactive data (inline)block properties with syncrostate.
-
-## 🧠 Concepts
-
-Edytor structure is built around this key concepts:
-
-- **Blocks**: Container elements like paragraphs, headings, and lists
-- **Content**: The content of a block is an array of inlines blocks or text and marks.
-- **Children**: Children are the blocks that are directly inside a block. They allow an infinite nesting.
-- **Marks**: Texts are simply text with marks that define the formatting.
-- **Inline blocks**: Inline blocks are inline elements that are no editable and render custom components like footnotes, equations, etc.
-
-Schematic example of a document:
-(content and children are not dom element, i put them here to help you understand the structure)
-
-```html
-<root>
-	<block>
-		<content>
-			<text mark="bold">Hello</text>
-			<text>World</text>
-			<inline-block type="footnote">
-				<!-- Inline block are rendered by the user code -->
-			</inline-block>
-		</content>
-		<children>
-			<nested-block>
-				<content>
-					<text>World</text>
-				</content>
-			</nested-block>
-			<nested-block>
-				<content>
-					<text>World</text>
-				</content>
-				<children>
-					<nested-block>
-						<content>
-							<text>World</text>
-						</content>
-					</nested-block>
-				</children>
-			</nested-block>
-		</children>
-	</block>
-</root>
-```
-
-### Blocks
-
-Blocks are the container elements like paragraphs, headings, and lists.
-They have a content that is an array of inlines blocks or text.
-They may have children that is an array of nested-blocks.
-Blocks can be nested unless they are void or inside an island
-
-An island is a block that is editable but is structuraly stable and isolated from the rest of the document.
-It is impossible to merge an island with another block. It is also impossible to move another block inside an island.
-You may think of an island as a block that is editable but is not completely part of the document structure and isolated from the rest of the document.
+Edytor aims to be for Svelte what Slate.js is for React: a heavily customizable editor with an API to build any kind of collaborative rich text editor.
 
-A void block is a block which does not have children or whose children are not editable and rendered outside of the edytor core logic.
-Void blocks can render and edit their content anyway. That is usefull to render caption.
-You may think of a void block as a block that is completely independent from the rest of the document.
-Void blocks acts also like an island but are even less editables.
+> **Work in progress.** Edytor is a pre-release (`0.1.0-next.16`, `edytor@next` on npm) and not ready for production; the API changes between releases without a compatibility layer. The untagged `edytor@0.0.11` on npm predates the current API. Issues and PRs are welcome: when you report a bug, include the document's JSON value.
 
-### Text
+## Features
 
-Text is the basic text element that is rendered by the editor. At is core it is a Y.js text with any formatting attributes you want.
+- **Notion-style editing out of the box.** `<Edytor />` alone is a rich text editor with images: headings, lists, to-dos, toggles, callouts, quotes, dividers, ten marks, Notion's markdown shortcuts and hotkeys. Add the Notion theme, block handles with a block menu (drag one block, or every block the selection covers), a slash menu, a selection toolbar and code blocks.
+- **Your markup.** Blocks, marks and inline atoms render through your Svelte snippets; the slash menu, toolbar, block menu and handles take a snippet and keep their behavior.
+- **Synced properties.** `block.data`, `atom.data` and `edytor.data` read and write like plain objects (`bind:value={block.data.title}`); each property and each array item syncs on its own, so concurrent edits of different properties, or of different items of one array, merge.
+- **AI suggestions.** `edytor.suggestions.add(position, content)` proposes text, paragraphs, lists, to-dos or images after, before or inside a block, at the end of its text, or in place of the selection; it streams in, shows only on your screen, and becomes one undo step when accepted ([Suggestions](https://edytor-docs.beynar.workers.dev/docs/editor/suggestions)).
+- **Plugins that can veto anything.** Every command is prepared before it writes; plugins see the command and each planned step and can refuse or replace it.
+- **Real-time collaboration.** One `EdytorDocument` shared by any number of views, or none (headless). Presence cursors, identity-preserving moves, splits and merges, and undo that only takes back your own edits.
+- **Offline first.** A local IndexedDB copy and cross-tab sync; offline edits survive reloads and reach the server on reconnect.
+- **A Cloudflare Durable Object room.** `edytor/cloudflare` stores in SQLite, acknowledges after the write, binds identity to the socket and hibernates.
+- **Headless and Worker-safe.** `edytor/crdt/edytor` runs in Node and Workers without Svelte.
 
-### Inlines Block
+## Install
 
-Inlines are inline blocks, useful to render custom components like footnotes, equations, etc.
-They are rendered by the user code and are not editable nor focusable.
-They have a data property
-
-## 🚀 Quick Start
-
-### Installation (not published yet)
+The pre-release is on npm under the `next` tag. Name the tag: a bare `edytor` is the old, incompatible `0.0.11`.
 
 ```bash
-npm install edytor
-# or
-yarn add edytor
-# or
-pnpm add edytor
+pnpm add edytor@next
 ```
 
-### Basic Usage
+`svelte@^5` is a peer dependency. Do not install `yjs`: the v14 engine is vendored (`edytor/crdt`). See [installation](https://edytor-docs.beynar.workers.dev/docs/getting-started).
+
+## Quick start
 
 ```svelte
-<script>
-	import { Edytor } from 'edytor';
-
-	let value = {
-		children: [
-			{
-				type: 'paragraph',
-				content: [{ text: 'Hello, World!' }]
-			}
-		]
+<script lang="ts">
+	import {
+		Edytor,
+		codePlugin,
+		markdownShortcutsPlugin,
+		slashMenuPlugin,
+		toolbarPlugin,
+		blockMenuPlugin,
+		richTextPlaceholder,
+		type JSONDoc
+	} from 'edytor';
+	import 'edytor/themes/notion.css';
+
+	const value: JSONDoc = {
+		children: [{ type: 'paragraph', content: [{ text: 'Hello, World!' }] }]
 	};
-
-	function onChange(newValue) {
-		console.log('Document changed:', newValue);
-	}
+	const plugins = [
+		codePlugin,
+		markdownShortcutsPlugin,
+		slashMenuPlugin,
+		toolbarPlugin,
+		blockMenuPlugin
+	];
 </script>
 
-<Edytor {value} {onChange} />
+<div class="edytor-notion">
+	<Edytor
+		{value}
+		{plugins}
+		placeholder={richTextPlaceholder}
+		onChange={(root) => console.log(root)}
+	/>
+</div>
 ```
 
-## Testing
-
-I'm welcome to any contribution to improve the testing.
-In the end, every block operation should be tested.
-I've implemented a custom jsx parser to simplify testing the editor.
+`<Edytor>` adds the rich text, image, arrow-move and suggestions plugins after yours, and block handles. To collaborate, name a room and a server running the [`edytor/cloudflare` room](https://edytor-docs.beynar.workers.dev/docs/server/quick-start):
 
-So instead of defining the value as a json object, you can define the value as a jsx element.
-
-```html
-<root>
-	<paragraph>Hello, World!</paragraph>
-</root>
+```svelte
+<Edytor
+	server="wss://example.com/rooms"
+	room={documentId}
+	params={{ token }}
+	actor={{ id: userId }}
+/>
 ```
 
-is the same as
+## Documentation
 
-```json
-{
-	"type": "root",
-	"children": [{ "type": "paragraph", "content": [{ "text": "Hello, World!" }] }]
-}
-```
+The [documentation site](https://edytor-docs.beynar.workers.dev/docs) is the single source for the API and behavior; this README only introduces the package.
 
-You can also add one or two cursors with the `|` character into the jsx in order to simulate the cursor position
+- [Getting started](https://edytor-docs.beynar.workers.dev/docs/getting-started): installation, quick start, SvelteKit, entry points and bundle size
+- [Concepts](https://edytor-docs.beynar.workers.dev/docs/concepts/document-model): the document model, blocks, void and island roles
+- [Editor](https://edytor-docs.beynar.workers.dev/docs/editor/edytor-component): the component, commands, selection, history, clipboard, readonly
+- [Plugins](https://edytor-docs.beynar.workers.dev/docs/plugins) and [customization](https://edytor-docs.beynar.workers.dev/docs/customization/blocks): bundled plugins, custom blocks and marks, [hotkeys and editing behavior](https://edytor-docs.beynar.workers.dev/docs/customization/hotkeys)
+- [Collaboration](https://edytor-docs.beynar.workers.dev/docs/collaboration) and [server](https://edytor-docs.beynar.workers.dev/docs/server/quick-start): documents, providers, presence, the Durable Object room and its protocol
+- [Reference](https://edytor-docs.beynar.workers.dev/docs/reference/document-api): the document API, [troubleshooting](https://edytor-docs.beynar.workers.dev/docs/reference/troubleshooting), [migration from 0.0.11](https://edytor-docs.beynar.workers.dev/docs/reference/migration), limitations
 
-```jsx
-<root>
-	<paragraph>Hello, |World!|</paragraph>
-</root>
-```
+## Contributing
 
-I've also implemented the `createTestEdytor` that help with creating an edytor instance from a jsx element in order to test various operations on a virtual edytor and test the expected output.
-
-```jsx
-test('split text', () => {
-	const { edytor, expect } = createTestEdytor(
-		<root>
-			<paragraph>Hello, |World!</paragraph>
-		</root>
-	);
-
-	edytor.selection.state.startBlock?.splitBlock({
-		index: edytor.selection.state.yStart,
-		text: edytor.selection.state.startText
-	});
-
-	expect(
-		<root>
-			<paragraph>Hello, </paragraph>
-			<paragraph>World!</paragraph>
-		</root>
-	);
-});
+`AGENTS.md` describes the architecture (one owner per fact), where to fix what, and the test lanes. The docs live in `site/content/docs`; a change to public behavior updates them in the same commit.
+
+```bash
+pnpm install
+pnpm check && pnpm lint
+pnpm exec vitest --run   # unit and model fixtures (JSX fixture DSL in src/tests/jsx)
+pnpm test:dom            # editors mounted in jsdom
 ```

package/dist/block/block.svelte.d.ts

@@ -1,53 +1,119 @@
 import { Text } from '../text/text.svelte.js';
 import { Edytor } from '../edytor.svelte.js';
-import { type YBlock, type JSONBlock, type JSONText, type JSONInlineBlock } from '../utils/json.js';
-import * as Y from 'yjs';
+import type { JSONBlock, JSONText, JSONInlineBlock } from '../utils/json.js';
+import { type BlockOperations } from './block.utils.js';
 import type { BlockDefinition } from '../plugins.js';
 import { InlineBlock } from './inlineBlock.svelte.js';
-export declare const getSetArray: <T = YBlock>(yBlock: YBlock, key?: "children" | "content") => Y.Array<T>;
-export declare const getSetText: (yBlock: YBlock) => Y.Text;
+import type { DocBlock } from '../crdt/index.js';
+/**
+ * An id-only block handle (§2.4 "Handles", R4): every getter reads the
+ * document index (transaction-aware), every mutator issues a command. The
+ * view keeps one per id (`edytor.idToBlock`); `node` is the element the core
+ * renders for it (O45).
+ */
+/** Mark an element inside a block's markup as non-editable chrome (`block.void`, a preview's too). */
+export declare const voidChrome: (node: HTMLElement) => void;
 export declare class Block {
     #private;
     readonly: boolean;
-    edytor: Edytor;
-    yBlock: YBlock;
-    parent?: Block;
-    yChildren: Y.Array<YBlock>;
-    yContent: Y.Array<YBlock | Y.Text>;
-    children: Block[];
-    content: (Text | InlineBlock)[];
-    id: string;
-    data: Record<string, any>;
+    readonly edytor: Edytor;
+    readonly id: string;
     node?: HTMLElement;
-    definition: BlockDefinition;
+    constructor(edytor: Edytor, id: string);
+    get isRoot(): boolean;
+    /** The typed document node — `null` for the root. */
+    get model(): DocBlock | null;
+    /** The display parent (the root for a top-level block); none for the root or a dead block. */
+    get parent(): Block | undefined;
+    get children(): Block[];
+    /** Text segments and inline atoms, alternating, starting and ending with a text. */
+    get content(): (Text | InlineBlock)[];
+    get type(): string;
+    /** Retype the block — the `setBlock` command (readonly, hooks, `dispatcher.last`). */
+    set type(value: string);
+    /**
+     * The block's `data` as a live proxy (`session/props.ts`): reads follow the
+     * document (reactive through the block's cell), writes are `patchData`
+     * commands. The root's is the document's data (`edytor.data`).
+     */
+    get data(): Record<string, any>;
+    get definition(): BlockDefinition;
+    /**
+     * Replace the block's `data` — a `patchData` command of its root (readonly,
+     * hooks, `dispatcher.last`); `block.model.setData` is the raw document write.
+     */
+    setData: (data: Record<string, unknown>) => void;
     get selected(): boolean;
     get focused(): boolean;
-    get insideIsland(): boolean;
+    /** May this block move at all — R5 `canPlace` without a destination (drag handles). */
+    get movable(): boolean;
+    /**
+     * May text-level structural commands (convert, markdown shortcut, slash
+     * menu) apply: the block is movable — or the virtual paragraph of an
+     * emptied document, which a conversion creates with its kind
+     * (SW10-lists-3) — has no role of its own and renders its own content —
+     * a container (a list) is never converted, its items are (ZW-02).
+     */
+    get convertible(): boolean;
     get firstEditableText(): Text | undefined;
     get lastEditableText(): Text | undefined;
     get index(): number;
-    set index(value: number);
-    get type(): string;
-    set type(value: string);
     get depth(): number;
     get path(): number[];
-    get isRoot(): boolean;
-    get suggestions(): (Text | InlineBlock)[] | null;
+    /** The block is visible in the document (a dead handle answers false). */
+    get isInTree(): boolean;
+    /**
+     * @deprecated `edytor.suggestions` with `{ end: block.id }`. The content of
+     * this block's latest `end` suggestion, as parts (a text's runs, or an
+     * atom); setting it replaces this block's `end` suggestions, `null` drops them.
+     */
+    get suggestions(): (JSONText[] | JSONInlineBlock)[] | null;
     set suggestions(value: (JSONText[] | JSONInlineBlock)[] | null);
     get nextBlock(): Block | null;
     get previousBlock(): Block | null;
     get closestPreviousBlock(): Block | null;
     get closestNextBlock(): Block | null;
-    get deepestChild(): Block;
     get hasChildren(): boolean;
+    /** It shows content: text or an inline atom (a block holding only a mention is not empty). */
     get hasContent(): boolean;
+    /** It holds nothing: no content and no children (the emptiness Turn into reads, `holdsNothing`). */
     get isEmpty(): boolean;
+    get isNested(): boolean;
+    /** This block's JSON — the document's one serializer (`facade.blockJSON`, L14). */
     get value(): JSONBlock;
-    get firstText(): Text;
-    get lastText(): Text;
-    private observeContent;
-    private observeChildren;
-    private batch;
+    isChildOf(block: Block): boolean;
+    /** Whether this kind renders its own content slot — the adopted capability (R5, O22). */
+    get rendersContent(): boolean;
+    /**
+     * A container: it shows only its children (a list), neither void nor an
+     * island — the document's container rule (YW-02). Its items hold what it
+     * shows; it is never converted (`convertible`).
+     */
+    get isContainer(): boolean;
+    /**
+     * An item of a list: its parent is a container whose items are a kind of
+     * their own (a `list-item` in an `unordered-list`), not the document's
+     * default — a column of paragraphs is no list. Turned into another kind,
+     * an item leaves its list; <kbd>Enter</kbd> in an empty one ends it.
+     */
+    get isListItem(): boolean;
+    /**
+     * The list this block shows in: its container when it is an item
+     * (`isListItem`), or — an item outdented out of a nested list into the
+     * item holding it (SW8-roles-4) — the list of the items of its kind it
+     * sits under. <kbd>Enter</kbd> in an empty one outdents it; the menus
+     * name it by the list's `itemKind`.
+     */
+    get list(): Block | undefined;
+    /**
+     * The first text of this block's own content — none for a kind that
+     * does not render its content (a list container, a divider): its slot
+     * is never displayed, so no caret or endpoint may land there. A block
+     * without a content slot (the root) answers with its first child's.
+     */
+    get firstText(): Text | undefined;
+    /** The last text of this block's own content (see {@link firstText}). */
+    get lastText(): Text | undefined;
     addChildBlock: (args_0: {
         block: JSONBlock;
         index: number;
@@ -56,68 +122,89 @@ export declare class Block {
         blocks: JSONBlock[];
         index: number;
     }) => Block[];
-    insertBlockAfter: (args_0: {
+    insertBlockAfter: (payload: {
         block: JSONBlock;
-    }) => Block | null;
-    insertBlockBefore: (args_0: {
+    }, plan?: import("../crdt/index.js").Prepared | undefined) => Block | null | undefined;
+    insertBlockBefore: (payload: {
         block: JSONBlock;
-    }) => Block | null;
-    splitBlock: (args_0: {
+    }, plan?: import("../crdt/index.js").Prepared | undefined) => Block | null | undefined;
+    splitBlock: (payload: {
         index: number;
         text: Text;
-    }) => Block | null;
-    removeBlock: (args_0?: {
-        keepChildren: boolean;
-    } | undefined) => void;
-    unNestBlock: () => Block | null;
-    mergeBlockBackward: () => Block | null;
-    mergeBlockForward: () => Block | null;
-    nestBlock: () => Block | null;
-    setBlock: (args_0: {
-        value: JSONBlock;
-    }) => void;
-    moveBlock: (args_0: {
+    }, plan?: import("../crdt/index.js").Prepared | undefined) => Block | null | undefined;
+    duplicateBlock: (_?: {} | undefined, plan?: import("../crdt/index.js").Prepared | undefined) => Block | null | undefined;
+    removeBlock: (payload?: {
+        keepChildren?: boolean;
+    } | undefined, plan?: import("../crdt/index.js").Prepared | undefined) => void;
+    unNestBlock: (this: Block, _?: {} | undefined, plan?: import("../crdt/index.js").Prepared | undefined) => Block | null;
+    mergeBlockBackward: (_?: {} | undefined, plan?: import("../crdt/index.js").Prepared | undefined) => Block | null | undefined;
+    mergeBlockForward: (_?: {} | undefined, plan?: import("../crdt/index.js").Prepared | undefined) => Block | null | undefined;
+    nestBlock: (this: Block, _?: {} | undefined, plan?: import("../crdt/index.js").Prepared | undefined) => Block | null;
+    setBlock: (payload: {
+        value: Partial<JSONBlock>;
+    }, plan?: import("../crdt/index.js").Prepared | undefined) => void;
+    moveBlock: (this: Block, payload: {
         path: number[];
-    }) => Block | null;
+    }, plan?: import("../crdt/index.js").Prepared | undefined) => Block | null;
+    moveBlocks: (this: Block, payload: {
+        blocks: Block[];
+        path: number[];
+    }, plan?: import("../crdt/index.js").Prepared | undefined) => Block[];
     pushContentIntoBlock: (args_0: {
         value: (Text | InlineBlock)[];
     }) => void;
-    removeInlineBlock: (args_0: {
+    removeInlineBlock: (payload: {
         index: number;
-    }) => void;
+    }, plan?: import("../crdt/index.js").Prepared | undefined) => void;
+    patchData: (payload: {
+        ops: import("../crdt/index.js").DataPatch[];
+        atom?: string;
+    }, plan?: import("../crdt/index.js").Prepared | undefined) => void;
     addInlineBlock: (args_0: {
         index: number;
         block: JSONInlineBlock;
         text: Text;
-    }) => Text;
+    }) => Text | null | undefined;
     normalizeContent: () => void;
-    suggestText: (args_0: {
-        value: (JSONText | JSONInlineBlock)[] | string | null;
-    }) => void;
+    normalizeChildren: () => void;
+    /** @deprecated `edytor.suggestions.add({ end: block.id }, …)`. */
+    suggestText: (payload: BlockOperations["suggestText"]) => void;
+    /** @deprecated `suggestion.accept()`. */
     acceptSuggestedText: () => void;
-    deleteContentAtRange: (args_0: {
+    deleteContentAtRange: (payload: {
         start: [number, number];
         end: [number, number];
-    }) => void;
+    }, plan?: import("../crdt/index.js").Prepared | undefined) => void;
+    /** Mark an element inside the block's markup as non-editable chrome (a header, a caption bar). */
     void: (node: HTMLElement) => void;
-    constructor({ parent, block, yBlock, edytor }: {
-        parent?: Block;
-        edytor: Edytor;
-    } & ({
-        yBlock?: undefined;
-        block: JSONBlock;
-    } | {
-        yBlock: YBlock;
-        block?: undefined;
-    } | {
-        yBlock: YBlock;
-        block: JSONBlock & {
-            type: 'root';
-        };
-    }));
+    /**
+     * The text segment that displays block offset `offset`, and the offset in
+     * it — the one offset → segment mapper over the committed parts (a
+     * boundary before an atom reads the text before it; past the end, the
+     * last text's end).
+     */
+    textAtOffset: (offset: number) => {
+        text: Text;
+        offset: number;
+    } | null;
+    /**
+     * Insert children at `index`: a JSON spec is created (its id kept, minted
+     * when missing); a block handle moves there with its identity.
+     */
+    insertChildren: (index: number, blocks: (JSONBlock | Block)[]) => void;
+    /** Delete `length` visible children from `index`, each with its subtree (a document delete). */
+    deleteChildren: (index: number, length?: number) => void;
+    /**
+     * Insert content before part `index` (a text segment or an inline atom):
+     * each entry is a text's runs or an atom, as JSON.
+     */
+    insertParts: (index: number, parts: (JSONText[] | JSONInlineBlock)[]) => void;
+    /**
+     * Register the element the core rendered for this block (O45) and run the
+     * attach hooks. A re-rendered block (moved, re-parented) keeps its declared
+     * view state (R11): an open toggle stays open.
+     */
     attach: (node: HTMLElement) => {
         destroy: () => void;
     };
 }
-export declare function observeChildren(this: Block, event: Y.YArrayEvent<YBlock>): void;
-export declare function observeContent(this: Block, event: Y.YArrayEvent<YBlock | Y.Text>): void;