Releases

Discover open, resolved, and unavailable conversations through All comments; remove stale block placement and preserve in-progress conversation actions.

Include document-level comment discovery in editable, read-only, persistence, and suggestion examples.

Start the Playground in Editing mode while keeping seeded suggestions visible.

Preserve page scroll when a new comment receives focus and keep the popover attached to its anchor during editor scrolling.

Run final focus from the selected menu item and call typed block `insert` or `upsert` operations directly.

Call installed feature operations directly, preserve exact block selections, and disable unsupported structural actions.

Share the same server-safe formatting kits between editable and static editor compositions.

Install package requirements derived from copied source and serve production and development payloads from one generated registry state.

Publish generated feedback as ordinary comment threads. Keep completed comments when generation stops or fails, and show failed requests with retry and dismissal controls.

Limit comment prompts to the selected content while preserving its formatting and inline structure.

Await comment actions before clearing input, retain failed replies for retry, reopen resolved conversations independently of document undo, and keep suggestion conversations replyable after decisions.

Let completed AI comments finish saving when the chat menu closes; discard pending drafts on cancellation.

Save comments and opaque attachments with the matching document revision and restore them into a fresh editor.

Load three authored suggestions and their conversations together while keeping direct editing as the default.

Keep keyboard navigation visible below fixed toolbars.

Run complete undo, redo, and AI response actions through editor services so each action publishes as one history unit.

Inspect two-way and three-way comparisons with grouped effects, evidence, conflict choices, filters, and navigation.

Save document revisions and compare the two latest snapshots.

Create provider-bound descriptors with `CollaborationPlugin.create(options)` while preserving copied cursor presentation.

Keep selected text visible while writing comments

Use green for the current user's suggestions and stable distinct colors for collaborators, with underlines for insertions and strikethroughs for deletions.

Keep suggestion styling with its optional kit

Install HTML export and MDX API components under semantic filenames.

Install complete editor composition as `rich-text-editor.tsx`.

Review formatting and block proposals, compare document projections, and save proposals with their discussion threads.

Keep discussion buttons available when switching a saved document between accepted content and markup.

Load the multi-author suggestion example and linked discussions from its included saved document, with suggesting mode configured on `EditorRoot`.

Use `SuggestionPlugin`, view-local activation, and authored-change hooks in copied controls and review cards. Customize styles, cards, and Comments composition in registry source.

Review proposed insertions and deletions in the Suggestions demo

Keep Home, End, arrow selection and deletion aligned after focus changes and composition. Use Tab and Shift+Tab for indentation, with Enter and Shift+Enter for an indented newline.

Keep typing in the invoking editor after accepting, inserting, or replacing content with AI.

Focused Comments examples cover conversations, overlapping ranges with undo and redo, local snapshot save/reload with a simulated failed reply, and read-only/static rendering.

Render diagrams for preview and export using the latest source

Keep discussions usable after suggestion actions and on touch screens

Allow editors without comments to render optional comment subscribers

Playground loads its complete editor kit, example comment threads, and comment actions

Reduce table selection rendering work while preserving row and cell highlights

Support AI writing in documents containing code drawings

Call custom controls through `FindPlugin` and subscribe to individual search fields. Closing the bar returns focus to its editor view; mounting another command button preserves the current query.

Find opens independently in each editor view. Custom opening controls use `useFind` inside Editable slots, while `BaseFindPlugin` supplies shared queries and results. The demo includes a second view of the same document.

Keep navigation highlights in the calling editor view. TOC supplies heading highlight classes, and TOC and footnote installs include their highlight styles.

Bind the shared SDK transport with `useAIChat`. Share one session across mounted views and keep streaming while a writable view remains. Keep endpoint configuration and comment persistence in the application.

Render the session preview through a read-only editor view and size the menu within the viewport.

Render ghost text without changing the accepted completion. Keep demo responses in the application route.

Return completion text and pass the configured gateway key to the provider.

Insert blocks with owned construction, empty-source replacement and selection. Preserve source content while media URL input resolves and keep each action in one history step.

Convert the selected blocks with one feature command, including disjoint selections and structural wrappers.

Use `createCodeMirrorAdapter` for versioned text projection and cleanup. Keep presentation and language loading local, with CodeMirror commands for line indentation and syntax-aware Enter.

Prepare selected blocks and inert preview clones through DndPlugin; keep preview spacing and scroll compensation in the component.

Validate every dragged row and its source editor before applying the row drop handler.

Keep editor toolbar styling in copied editor components

Measure selection geometry while the toolbar is visible, preserving dismissal, focus and reopening after selection changes.

Bind each editor to its own document, share formatting through the active editor, and include the image editor's drag-and-drop integration.

Retain the dataset search between queries and request up to 60 results through `createEmojiSearch`.

Keep category rows and frequent-history updates in copied UI and use the shared search function.

Use `useExcalidrawSync` to apply document changes and undo to the canvas, save referenced images, and exclude transient canvas state from document writes. Keep lazy loading and presentation in the copied element.

Search through `BaseFindPlugin` while keeping the search bar, deferred input, focus and scroll behavior local. Preserve IME confirmation and opening before the first query.

Style the current match separately from other matches using the feature’s transient data attributes.

Insert selected suggestions through the `onSelect` transaction callback. Cancel at the input's current location, preserve outside selections, and reject stale or foreign input callbacks.

Use editor shortcuts and local panel dismissal

Preserve alignment when resizing media and discard cancelled pointer gestures. Keep slider values and bounds in consistent units.

Shared toolbars target the selected editable view.

Read semantic groups with `useSuggestionReviews` and accept or reject by ID. Keep labels, dates and card activation in the copied view.

Use the feature's inline suggestion projection for consistent inherited text styling.

Derive the default size from the heading level and keep input, presets and step buttons within 1–100 pixels. Reject empty and nonnumeric input.

Display Viewing and select its menu option whenever the editor is read-only, including when the suggestion preference is enabled.

Install the paste and import plugins; call `exportToDocx` with a document snapshot from the export action.

Emit ordinary HTML anchors and let the converter assign unique bookmark names within each DOCX document.

Choose the PlantUML server with `plantUmlServer` and customize PNG downloads, preview height, and debounce in the copied component.

Edit a local equation draft, confirm it with Done or Enter, and undo it in one step. Escape discards the draft without overwriting external changes.

Use `NavigationFeedbackPlugin` target attributes directly for reference and definition highlights.

Keep URL drafts verbatim until submission, preserve rejected input, position the floating form inside narrow viewports, and open shortcuts in the focused editor view.

Render task markers directly in list wrappers

Keep uploads active across placeholder remounts, cancel superseded requests and show upload failures. Configure the transport in `MediaKit`; image completion does not depend on the preview loading.

Insert media URLs through the selected media feature

Explore collapsible Details in the playground

Share toolbar overlay tracking and preserve anchor ref cleanup

Keep search, first-item selection, and Enter activation in the copied command bridge while Fzf owns matching; install only the menu parts used by the tag picker.

Keep heading tracking stable while scrolling and update the active row when returning to an earlier heading. Configure scroll enablement and offset on `TocElement`.

Keep the native code docs preview at 1,000 lines with a separate 10,000-line stress test.

Read search state and call search actions through `FindPlugin`.

Include `use-mounted` in standalone installations.

Responsive scrolling beside large editors

Responsive scrolling around large highlighted native code blocks

Code block copy and drawing controls resolve their current document position when used.

Keep comment drafts intact when submitting with the keyboard

Use `AIKit` and `DndKit` to enable AI commands and drag and drop with ordinary `Plate` and `Editor` composition. Share one AI stream across editor views and retain custom transports and drag managers.

Provide tooltips in standalone installs.

Focus the calendar when opening the date picker.

Preserve server rendering and input semantics in Base UI editors.

Preserve custom command components and their cleanup with asChild.

Run callback ref cleanup when popover anchors and command lists unmount.

Code blocks preserve selection, composition and indentation with incremental CodeMirror syntax.

Open the Link toolbar above its selection without installing Comments or Suggestions.

Preserve discussion state across edits and failed saves

Import `YjsPlugin` from the copied `remote-cursor-overlay` file for selection highlights, carets, and labels. Edit that file to customize their colors, opacity, and classes.

Store multiline code in one text child and remove the code-line component and virtualization dependency.

• Remove the code-line plugin and component when updating copied editor code.

Keep comments reachable after complete text deletion, and restore exact highlights through undo and redo.

Render thread message bodies with the static Plate view so replies do not mount nested editable runtimes.

Keep a 10,000-line highlighted code block responsive with bounded CodeMirror DOM and Plate-owned editing and history.

Keep large highlighted code blocks responsive when list support is installed.

Render editor highlights through plugin decorations.

Configure components, mark attributes, and structural UI through the owning plugin's `component`, `render`, and `slots` fields.

Open and reopen Date popovers on the first click.

Open inline equation editors on the first click.

Define component-owned prop shapes at their component signatures and reserve named prop contracts for exported reuse.

Keep hidden media captions mounted during selection changes.

Fix annotation hover scrolling

Open Date calendars on the first click.

Keep block equations full-width and centered.

Fix table of contents clicks so the selected heading scrolls into view and stays there.

Use nested semantic Details and Summary nodes with transient disclosure state.

Use `useCreateEditor` for React editor creation. `use-chat` exports `useEditorChat`, block discussion exports `BlockResolvedSuggestion`, and missing required values report contextual errors.

Use `platejs` for registry editor dependencies.

Keep required-value checks in each component with contextual errors and no shared registry dependency.

Export complete editor block composition as `PlateEditor` while keeping the shared presentation component named `Editor`.

Install with `platejs` and copied helper source; `select-editor` includes its controlled command implementation.

Compose node-selection highlighting and drag selection with `NodeSelectionHighlight` and `NodeSelectionDrag` from `platejs/react`. Link their API and demo from the Editor registry page.

Keep comment popovers anchored to their text, clear abandoned draft marks without moving the live selection or caret, and keep the floating toolbar available after resolving a comment.

Use flat input rows with an edge-to-edge separator.

Hide block and cell drag handles during table cell selection. Keep row drag handles for selections within one row, and hide them across rows.

Hide native text highlight while selecting multiple table cells.

Keep the text cursor while resize handles are ignored during cell-selection drags.

Select custom Plate block content from its schema and let tables render their own selection geometry.

Preserve one selection highlight while changing font size

Paint the block-selection marquee during gutter drags

Fix Plate-to-HTML rendering for values with element IDs

Resolve links without a website-only locale utility.

Install the authored editor kit without generated TypeScript or schema snapshots. Generate exact contracts from the application's customized plugin module and enforce `plate generate --check <entry>` in CI.

• Delete unused plugins.generated.ts and plugins.schema.json files. If the app needs exact contracts, install @platejs/cli, regenerate from its local plugin module, and enforce plate generate --check <entry> in CI.

Keep editor focus and the floating toolbar visible while toolbar menus handle pointer input.

Preserve the active editor value while focus moves into a control, and reopen inline equations only after selection returns.

Give each browser object URL one source lifetime and revoke it when that source is replaced or unmounted.

Render the selected-cell drag handle at its cell owner and keep fake-stream cancellation inside its transport.

Use named React Compiler components without manual memo wrappers or display-name assignments.

The copied editor renders a Pointer Events marquee while exact one-or-many membership stays in editor selection. No selection plugin, area abstraction, or selection package is required.

Activate block drag behavior only during pointer and drag interactions while preserving the stable block DOM.

Show nested property values as JSON in version history updates.

Use native, keyboard-accessible controls for split toolbars, media upload, and image preview actions.

Restrict embedded content with explicit sandbox and referrer policies.

Accept anchored removal suggestions without crashing the editor.

Store dates under one `value` and persisted associations under `ref`.

Use flat lowercase drawing fields and store equation source under `latex`.

Apply the v54 migration, field ownership, and numeric-domain contracts.

Keep controlled tags and decorated text stable during typing and undo.

Keep UploadThing server routing in `uploadthing` and colocate client upload state in `media-placeholder`.

• Keep custom upload state in your media placeholder component; `uploadthing` installs only the server router.

Keep single-consumer subscription and picker state inside their owning component families.

Keep DOCX file import and export in the DOCX example while default editors retain DOCX paste support.

Keep reusable editor composition migration-free and teach named lineage only in the dedicated migration example.

• Define your named schema and migration chain in the application persistence owner; `editor-plugins` exports only `EditorKit`.

Bind the copied editor to a named schema and run its v53-to-v54 document migration before rendering.

Install self-contained families with product copy, limits, styling, endpoints, and interaction policy in copied source; `table` composes renderer layout and pointer behavior directly.

Use one semantic Heading, boundary-only list numbering, semantic Table fields, intrinsic Media dimensions, and the generated v54 editor contract.

Install copied editor features from one flat editor namespace

• Move copied Plate imports from @/components/ui and @/components/editor/plugins to @/components/editor.
• Install feature items without -kit or -base-kit suffixes; FooKit remains the exported plugin tuple.
• Import feature-owned renderers and family-only components from the owning feature file, such as @/components/editor/footnote and @plate/footnote.
• Use semantic renderer item names such as blockquote and media-image instead of *-node; install static renderers from their matching *-static items.

Keep interaction state and behavior inside direct React 19 component families.

• Rename the FloatingToolbar state prop to options.

Install the exact app-local descriptors owned by their copied UI families.

Compose DOCX renderers through target plugins. Install `DocxIOPlugin` explicitly in the live editor when using its scoped import or export API.

Correlate comments and table-cell edits with request-local refs instead of persisted element IDs.

Fix heading renderer prop types across H1-H6 components.

Install every required package and copied registry file without redundant declarations.

Build live TOC navigation and DOCX-local bookmarks from runtime node keys.

Install persisted element IDs explicitly as editor product policy.

Infer copied renderer props from their plugin descriptors.

Apply font marks to text and keep selection highlighting aligned after changing font size.

Use the typed keyboard plugin command while preserving one atomic selection update.

Restore editor focus when the table menu closes.

Fix mouse-drag block selection

Close the inline equation editor at an arrow-key boundary.

Apply formatting without losing the active text selection.

Keep direct block drag and drop stable

Keep typing responsive while comments and suggestions are enabled.

Infer node component props from plugin descriptors

Use one table cell plugin and component for data and header cells.

• Use TableCellElement for data and header cells. Header nodes use type: 'tableCell' with header: true.

Read final element types and property keys from installed schema handles.

Read the stored AI preview when insert or replace commands run, so custom commands pass only formatting options.

Configure feature renderers explicitly while installing each plugin name once.

Read cursor geometry and schema-configured node ids from their package owners.

Let resize handles derive read-only state from the editor.

Use the DnD block selection-and-focus controller after row drops.

Render without installing the code drawing plugin twice.

Seed editor-local plugin stores with `initialState`.

Read, update, and subscribe to plugin state through the typed store API.

Configure and update plugin store state through the same API used by copied registry code.

Use one script mark for subscript and superscript

• For persisted v53 script marks, add migrateV54 to the app's defineDocumentMigrations chain.

Bind static components without React plugin imports

Run two independent local Yjs peers with connection, schema, history, and remote cursor controls.

Configure Markdown parsing without installing a renderer-specific Footnote preset.

Compose the shared Markdown parser with the matching live or static Footnote renderers exactly once.

Install only the presets their copied source composes, without unrelated static/base counterparts.

Preserve Indent support while reserving Tab and Shift+Tab navigation for tabbable elements.

Configure text color palettes, optionally control recent colors, and navigate color grids with the keyboard.

Keep suggestion and trailing-block capabilities independently composable

Use installed feature plugins instead of raw type dispatch in toolbar controls.

Style placeholders and drop cursors in the copied editor component while Plite supplies their structural DOM behavior.

Use the installed List plugin for list-aware block dragging

Compose editor variants with explicit plugin arrays

Render direct media caption children, keep an empty caption hidden until asset focus, and separate asset selection from caption editing.

• Remove CaptionPlugin from media kits and render each media element's direct children as its caption; use [{ text: '' }] when the caption is absent.
• For persisted v53 media captions, add migrateV54 to the app's defineDocumentMigrations chain.

Use plugin-scoped media insertion in copied editor transforms.

Keep plugin configuration terminal

Use the installed plugin's typed editor APIs with Plate v54.

Wire list toolbar controls to ListPlugin

Open the date picker reliably inside Plite editors.

Insert code blocks, drawings, Excalidraw canvases, tables, and dropped media through their installed commands with explicit relational or path placement.

Fix preserved-space wrapping so inserted space runs stay inside editable and static editor widths.

Install editor kit files through the configured components alias so relative `./plugins/*` imports resolve after shadcn CLI adds.

Show the selected language label in read-only and static rendering. Set `showLanguageLabel={false}` on the component to hide it.

Fix column drag and drop by attaching the DnD drop target ref to the rendered column element so horizontal drop lines can resolve a valid target.

Add a 10k-block Plate and Plite comparison demo with performance controls and benchmark links.

Rename to `huge-document-demo`.

Rebuild discussion indexes from editor state so accept and reject updates, inline text summaries, and deleted comments stay current.

Fix block and inline suggestion regressions around inline voids, links, line breaks, block voids, and trailing-block normalization.

Keep Plite children mount points and suggestion wrappers stable for static and media-style nodes.